Criar um web app de várias camadas com Redis e PHP

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

prepare o ambiente

Para configurar o ambiente, siga estas etapas:

1. Defina as variáveis de ambiente:

   export PROJECT_ID=PROJECT_ID
   export COMPUTE_LOCATION=COMPUTE_LOCATION
   

   Substitua:

   • PROJECT_ID: o Google Cloud ID do projeto
   • COMPUTE_LOCATION: um local do Compute Engine, como us-central1.

2. Clone o repositório do GitHub:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   

3. Mude para o diretório de trabalho:

   cd kubernetes-engine-samples/quickstarts/guestbook/
   

Crie um cluster do GKE

Crie um cluster do Autopilot ou do GKE padrão:

Piloto automático

gcloud container clusters create-auto guestbook \
    --location=${COMPUTE_LOCATION} \

Standard

gcloud container clusters create guestbook \
    --location=${COMPUTE_LOCATION} \
    --num-nodes=4

Conectar ao cluster

Configure kubectl para se comunicar com o cluster:

gcloud container clusters get-credentials guestbook \
    --location=${COMPUTE_LOCATION}

Configurar o líder do Redis

No aplicativo, o Redis é usado para armazenar os dados. O aplicativo grava os dados em uma instância líder do Redis e lê os dados de várias instâncias de seguidores do Redis.

1. No manifesto a seguir, descrevemos uma implantação do Kubernetes que executa um pod líder do Redis de réplica única:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: redis-leader
     labels:
       app: redis
       role: leader
       tier: backend
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: redis
     template:
       metadata:
         labels:
           app: redis
           role: leader
           tier: backend
       spec:
         containers:
         - name: leader
           image: "docker.io/redis:6.0.5"
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 6379

   Aplique o manifesto ao cluster:

   kubectl apply -f redis-leader-deployment.yaml
   

2. Verifique se o pod líder do Redis está em execução:

   kubectl get pods
   

   O resultado será assim:

   NAME                           READY     STATUS    RESTARTS   AGE
   redis-leader-343230949-qfvrq   1/1       Running   0          43s
   

   Pode levar vários minutos para que STATUS mude de Pending para Running.

Criar o serviço de líder do Redis

O aplicativo precisa se comunicar com o líder do Redis para gravar os dados. É possível criar um serviço para redirecionar o tráfego ao pod do líder do Redis.

Um serviço é uma abstração do Kubernetes que define um conjunto lógico de pods e uma política para permitir o acesso aos pods. Ao criar um serviço, você descreve quais pods proxy com base nos rótulos.

1. O manifesto a seguir descreve um serviço para o líder do Redis:

   apiVersion: v1
   kind: Service
   metadata:
     name: redis-leader
     labels:
       app: redis
       role: leader
       tier: backend
   spec:
     ports:
     - port: 6379
       targetPort: 6379
     selector:
       app: redis
       role: leader
       tier: backend

   Esse manifesto inclui um conjunto de seletores de rótulos. Esses rótulos são iguais ao conjunto implantado na etapa anterior. Portanto, esse serviço faz o roteamento do tráfego de rede para o pod do líder do Redis criado em uma etapa anterior.

   A seção ports do manifesto apresenta um único mapeamento de porta. O serviço encaminha o tráfego em port: 6379 para targetPort: 6379 dos contêineres que correspondem aos rótulos selector especificados. O containerPort usado na implantação precisa corresponder a targetPort para rotear o tráfego para a implantação.

   Aplique o manifesto ao cluster:

   kubectl apply -f redis-leader-service.yaml
   

2. Verifique se o GKE criou o serviço:

   kubectl get service
   

   O resultado será assim:

   NAME           CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   kubernetes     10.51.240.1     <none>        443/TCP    42s
   redis-leader   10.51.242.233   <none>        6379/TCP   12s
   

Configurar seguidores do Redis

Embora o líder do Redis seja um único pod, é possível torná-lo altamente disponível e atender às demandas de tráfego adicionando algumas réplicas ou seguidores do Redis.

1. No manifesto a seguir, descrevemos uma implantação para os pods de seguidores do Redis:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: redis-follower
     labels:
       app: redis
       role: follower
       tier: backend
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: redis
     template:
       metadata:
         labels:
           app: redis
           role: follower
           tier: backend
       spec:
         containers:
         - name: follower
           image: us-docker.pkg.dev/google-samples/containers/gke/gb-redis-follower:v2
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 6379

2. Aplique o manifesto ao cluster:

   kubectl apply -f redis-follower-deployment.yaml
   

3. Verifique se as duas réplicas de seguidores do Redis estão em execução:

   kubectl get pods
   

   O resultado será assim:

   NAME                              READY   STATUS    RESTARTS   AGE
   redis-follower-76588f55b7-bnsq6   1/1     Running   0          27s
   redis-follower-76588f55b7-qvtws   1/1     Running   0          27s
   redis-leader-dd446dc55-kl7nl      1/1     Running   0          119s
   

   Pode levar vários minutos para que STATUS mude de Pending para Running.

Criar o serviço de seguidor do Redis

O aplicativo da Web precisa se comunicar com os seguidores do Redis para ler os dados. Para que os seguidores do Redis possam ser descobertos, configure um serviço.

1. O manifesto a seguir descreve um serviço para os seguidores do Redis:

   apiVersion: v1
   kind: Service
   metadata:
     name: redis-follower
     labels:
       app: redis
       role: follower
       tier: backend
   spec:
     ports:
       # the port that this service should serve on
     - port: 6379
     selector:
       app: redis
       role: follower
       tier: backend

   Esse manifesto especifica que o serviço é executado na porta 6379. O campo selector do serviço corresponde aos pods de seguidores do Redis criados na etapa anterior.

   Aplique o manifesto ao cluster:

   kubectl apply -f redis-follower-service.yaml
   

2. Verifique se o GKE criou o serviço:

   kubectl get service
   

   O resultado será assim:

   NAME           CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
   kubernetes     10.51.240.1     <none>        443/TCP    1m
   redis-leader   10.51.242.233   <none>        6379/TCP   49s
   redis-follower 10.51.247.238   <none>        6379/TCP   3s
   

Configurar o front-end da Web do aplicativo

Agora que você tem o armazenamento Redis para seu aplicativo, inicie os servidores da Web. Assim como os seguidores do Redis, o front-end é implantado usando uma implantação do Kubernetes.

O aplicativo da Web usa um front-end PHP, que é configurado para se comunicar com os serviços de líder ou seguidor do Redis, dependendo de a solicitação ser de leitura ou gravação. O front-end apresenta uma interface JSON e veicula uma IU baseada em jQuery-Ajax.

1. O manifesto a seguir descreve uma implantação para o servidor da Web:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: frontend
   spec:
     replicas: 3
     selector:
       matchLabels:
           app: guestbook
           tier: frontend
     template:
       metadata:
         labels:
           app: guestbook
           tier: frontend
       spec:
         containers:
         - name: php-redis
           image: us-docker.pkg.dev/google-samples/containers/gke/gb-frontend:v5
           env:
           - name: GET_HOSTS_FROM
             value: "dns"
           resources:
             requests:
               cpu: 100m
               memory: 100Mi
           ports:
           - containerPort: 80

   O arquivo de manifesto especifica a variável de ambiente GET_HOSTS_FROM=dns. Quando você fornece a configuração para o aplicativo de front-end da Web, o aplicativo de front-end usa os nomes de host redis-follower e redis-leader para realizar uma busca DNS. A busca DNS encontra os endereços IP dos serviços criados nas etapas anteriores. Esse conceito é chamado de descoberta de serviços DNS.

   Aplique o manifesto ao cluster:

   kubectl apply -f frontend-deployment.yaml
   

2. Verifique se as réplicas estão em execução:

   kubectl get pods -l app=guestbook -l tier=frontend
   

   O resultado será assim:

   NAME                        READY   STATUS    RESTARTS   AGE
   frontend-7b78458576-8kp8s   1/1     Running   0          37s
   frontend-7b78458576-gg86q   1/1     Running   0          37s
   frontend-7b78458576-hz87g   1/1     Running   0          37s
   

Expor o front-end em um endereço IP externo

Com a configuração atual, os serviços redis-follower e redis-leader criados nas etapas anteriores só podem ser acessados no cluster do GKE porque o tipo padrão de um serviço é ClusterIP.

Um serviço ClusterIP fornece um único endereço IP para o conjunto de pods para onde o serviço está apontando. Esse endereço IP só é acessível no cluster.

Para tornar o serviço de front-end da Web acessível externamente, é possível especificar type: LoadBalancer ou type: NodePort na configuração do serviço, dependendo de seus requisitos.

O manifesto a seguir descreve um serviço do tipo LoadBalancer.

apiVersion: v1
kind: Service
metadata:
  name: frontend
  labels:
    app: guestbook
    tier: frontend
spec:
  type: LoadBalancer
  ports:
    # the port that this service should serve on
  - port: 80
  selector:
    app: guestbook
    tier: frontend

A declaração de porta na seção ports especifica port: 80 e targetPort não é especificado. Quando você omite a propriedade targetPort, o padrão é o valor do campo port. Nesse caso, o serviço encaminha o tráfego externo da porta 80 para a porta 80 dos contêineres na implantação frontend.

Aplique o manifesto ao cluster:

kubectl apply -f frontend-service.yaml

Quando o serviço frontend é criado, o GKE cria um balanceador de carga e um endereço IP externo. Esses recursos estão sujeitos à cobrança.

Acessar o site do aplicativo

Para acessar o site do aplicativo, veja o endereço IP externo do serviço frontend:

kubectl get service frontend

O resultado será assim:

NAME       CLUSTER-IP      EXTERNAL-IP        PORT(S)        AGE
frontend   10.51.242.136   109.197.92.229     80:32372/TCP   1m

A coluna EXTERNAL-IP pode mostrar <pending> enquanto o balanceador de carga está sendo criado. Isso pode levar alguns minutos. Se você encontrar erros como Does not have minimum availability, aguarde alguns minutos. Esse erro temporário ocorre porque o GKE recria os nós para fazer as alterações.

Copie o endereço IP e abra a página no navegador:

Tente adicionar algumas entradas digitando uma mensagem e clicando em Enviar. A mensagem que você digitou aparece no front-end. Essa mensagem indica que os dados foram adicionados ao Redis por meio dos Serviços que você criou.

Escalonar o front-end da Web

Suponha que seu aplicativo esteja em execução há algum tempo e de repente fique famoso. Você decide que seria uma boa ideia adicionar mais servidores Web ao seu front-end. Para isso, aumente o número de pods.

1. Amplie o número de pods frontend:

   kubectl scale deployment frontend --replicas=5
   

   O resultado será assim:

   deployment.extensions/frontend scaled
   

2. Verifique o número de réplicas em execução:

   kubectl get pods
   

   O resultado será assim:

   NAME                             READY     STATUS    RESTARTS   AGE
   frontend-88237173-3s3sc          1/1       Running   0          1s
   frontend-88237173-twgvn          1/1       Running   0          1s
   frontend-88237173-5p257          1/1       Running   0          23m
   frontend-88237173-84036          1/1       Running   0          23m
   frontend-88237173-j3rvr          1/1       Running   0          23m
   redis-leader-343230949-qfvrq     1/1       Running   0          54m
   redis-follower-132015689-dp23k   1/1       Running   0          37m
   redis-follower-132015689-xq9v0   1/1       Running   0          37m
   

   É possível reduzir o número de pods frontend usando o mesmo comando, substituindo 5 por 1.