Criar um livro de visitas com Redis e PHP

Este tutorial demonstra como criar um aplicativo da Web simples de várias camadas usando o GKE. O aplicativo do tutorial é um livro de visitas que permite que os visitantes insiram texto em um registro e vejam as últimas entradas registradas.

Use o tutorial para saber como configurar o serviço da Web de livro de visitas em um IP externo com um balanceador de carga e como executar um cluster do Redis com um único mestre (líder) e várias réplicas (seguidores)..

O exemplo destaca vários conceitos importantes do GKE:

  • Configuração declarativa (em inglês) usando arquivos de manifestos YAML.
  • Implantações, que são recursos do Kubernetes que determinam a configuração de um conjunto de pods replicados (links em inglês)
  • Serviços (em inglês) para criar balanceadores de cargas internos e externos em um conjunto de pods.

Objetivos

Para implantar e executar o aplicativo de livro de visitas no GKE, você precisará:

  1. Configurar o líder do Redis
  2. Configurar dois seguidores do Redis
  3. Configurar o front-end da Web do livro de visitas
  4. Acesse o site do livro de visitas.
  5. Amplie o front-end da Web do livro de visitas.

Antes de começar

Siga estas etapas para ativar a API do Kubernetes Engine:
  1. Acesse a página do Kubernetes Engine no Console do Google Cloud.
  2. Crie ou selecione um projeto.
  3. Aguarde a ativação da API e dos serviços relacionados. Isso pode levar alguns minutos.
  4. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu projeto.

Instale as ferramentas de linha de comando a seguir usadas neste tutorial:

  • gcloud é usado para criar e excluir clusters do Kubernetes Engine. gcloud está incluído no SDK do Google Cloud.
  • O kubectl é usado para gerenciar o Kubernetes, o sistema de orquestração de cluster usado pelo Kubernetes Engine. É possível instalar kubectl usando gcloud:
    gcloud components install kubectl

Definir padrões para a ferramenta de linha de comando gcloud

Para poupar tempo, em vez de digitar o ID do projeto e as opções de zona do Compute Engine na ferramenta de linha de comando gcloud, defina os padrões:
gcloud config set project project-id
gcloud config set compute/zone compute-zone

Criar um cluster do GKE

O primeiro passo é criar um cluster do GKE em que você executará o aplicativo de livro de visitas e o serviço Redis.

Crie um Cluster do GKE chamado guestbook:

gcloud container clusters create guestbook --num-nodes=4

É possível listar os clusters em execução no projeto usando estes comandos:

gcloud container clusters list
gcloud container clusters describe guestbook

Etapa 1: configurar o líder do Redis

No aplicativo do livro de visitas, o Redis é usado para armazenar os dados. Ele grava os dados em uma instância líder do Redis e lê dados de várias instâncias de seguidores do Redis. A primeira etapa é implantar um líder do Redis.

Primeiro, clone os manifestos de amostra.

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/guestbook
git checkout abbb383

Use o arquivo de manifesto denominado redis-leader-deployment para implantar o líder do Redis. Esse arquivo de manifesto especifica 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

Execute o seguinte comando para implantar o líder do Redis:

kubectl apply -f redis-leader-deployment.yaml

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

kubectl get pods
Saída:
NAME                           READY     STATUS    RESTARTS   AGE
redis-leader-343230949-qfvrq   1/1       Running   0          43s

Execute o seguinte comando para visualizar os registros do pod líder do Redis:

kubectl logs deployment/redis-leader

Saída:

1:M 24 Jun 2020 14:48:20.917 * Ready to accept connections

Criar o serviço de líder do Redis

O aplicativo de livro de visitas precisa se comunicar com o líder do Redis para gravar os dados. Você precisa criar um Serviço para fazer o proxy do tráfego para o pod 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 acessá-los. É um balanceador de carga nomeado com eficiência que estabelece o proxy do tráfego para um ou mais pods. Ao configurar um serviço, você diz aos pods para fazer o proxy com base nos rótulos dos pods.

Dê uma olhada no arquivo de manifesto redis-leader-service.yaml que descreve um recurso de 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 arquivo de manifesto cria um serviço chamado redis-leader com um conjunto de seletores de rótulos. Esses rótulos são iguais ao conjunto implantado na etapa anterior. Portanto, esse Serviço roteia o tráfego de rede para o pod líder do Redis criado na etapa 1.

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

Inicie o Serviço líder do Redis executando:

kubectl apply -f redis-leader-service.yaml

Verifique se o serviço foi criado:

kubectl get service
Saída:
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

Etapa 2: configurar os 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.

Dê uma olhada no arquivo de manifesto redis-follower-deployment.yaml que descreve 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: gcr.io/google_samples/gb-redis-follower:v2
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
        ports:
        - containerPort: 6379

Para criar a implantação do seguidor do Redis, execute:

kubectl apply -f redis-follower-deployment.yaml

Consulte a lista de pods para verificar se as duas réplicas de seguidores do Redis estão em execução:

kubectl get pods
Saída:
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

Receba os registros do pod de um dos seguidores do Redis.

kubectl logs deployment/redis-follower
Saída:
1:M 24 Jun 2020 14:50:43.617 * Background saving terminated with success
1:M 24 Jun 2020 14:50:43.617 * Synchronization with replica 10.12.3.4:6379 succeeded

Criar o serviço de seguidor do Redis

O aplicativo de livro de visitas precisa se comunicar com os seguidores do Redis para ler dados. Para tornar os seguidores do Redis detectáveis, é preciso configurar outro Serviço.

O redis-follower-service.yaml define a configuração do 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

Este arquivo define um serviço chamado redis-follower em execução na porta 6379. Observe que o campo selector do Serviço corresponde aos pods de seguidores do Redis criados na etapa anterior.

Crie o serviço redis-follower executando:

kubectl apply -f redis-follower-service.yaml

Verifique se o serviço foi criado:

kubectl get service
Saída:
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

Etapa 3: configurar o front-end da Web do livro de visitas

Agora que o armazenamento Redis do livro de visitas está configurado e funcionando, inicie os servidores da Web do livro. Assim como os seguidores do Redis, o front-end será implantado usando uma implantação do Kubernetes.

O app de livro de visitas usa um front-end simples em PHP. Ele é configurado para se comunicar com os Serviços de líder ou seguidor do Redis, dependendo de a solicitação ser uma leitura ou uma gravação. O front-end apresenta uma interface JSON simples e veicula uma UX baseada em jQuery-Ajax.

Veja o arquivo de manifesto frontend-deployment.yaml que descreve a implantação do servidor da Web do livro de visitas:

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: gcr.io/google_samples/gb-frontend:v5
        env:
        - name: GET_HOSTS_FROM
          value: "dns"
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
        ports:
        - containerPort: 80

Para criar a implantação front-end da Web do livro de visitas, execute:

kubectl apply -f frontend-deployment.yaml

Consulte a lista de rótulos que identificam o front-end da Web para verificar se as três réplicas estão em execução:

kubectl get pods -l app=guestbook -l tier=frontend
Saída:
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

O arquivo de manifesto acima especifica a variável de ambiente GET_HOSTS_FROM=dns. Quando o aplicativo de front-end da Web do livro de visitas recebe essa configuração, ele usa os nomes de host redis-follower e redis-leader e executa uma busca DNS para encontrar os endereços IP dos respectivos Serviços criados nas etapas anteriores. Esse conceito é chamado de descoberta de serviços DNS.

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

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. ClusterIP fornece um único endereço IP para o conjunto de pods a que o Service aponta. Esse endereço IP só é acessível no cluster.

Mas é necessário que o serviço front-end da Web do livro de visitas seja visível externamente. Ou seja, você quer que um cliente possa solicitar o Serviço de fora do Cluster do GKE. Para isso, é possível especificar type: LoadBalancer ou type: NodePort na configuração do Serviço, dependendo de suas necessidades. Neste exemplo, você usará type: LoadBalancer. O arquivo de manifesto frontend-service.yaml que especifica essa configuração tem esta aparência:

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

Quando o serviço frontend é criado, o GKE cria um balanceador de carga e um endereço IP externo. Observe que esses recursos estão sujeitos à cobrança. 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.

Para criar o Serviço, execute este comando:

kubectl apply -f frontend-service.yaml

Etapa 4: visitar o site do livro de visitas

Para acessar o serviço do livro de visitas, encontre o IP externo do serviço que você acabou de configurar. Para isso, basta executar o comando:

kubectl get service frontend
Saída:
NAME       CLUSTER-IP      EXTERNAL-IP        PORT(S)        AGE
frontend   10.51.242.136   109.197.92.229     80:32372/TCP   1m

Copie o endereço IP da coluna EXTERNAL-IP e carregue a página em seu navegador:

Livro de visitas em execução no GKE

Tente adicionar algumas entradas do livro de visitas digitando uma mensagem e clicando em Enviar. Você verá a mensagem digitada aparecer no front-end. Isso indica que os dados foram adicionados ao Redis com sucesso por meio dos Serviços criados anteriormente.

Etapa 5: ampliar o front-end da Web

Suponha que o app do livro de visitas esteja em execução há algum tempo e de repente fique famoso. Você decide que seria uma boa ideia adicionar mais servidores da Web ao seu front-end. Isso é fácil, visto que os servidores estão definidos como um serviço que usa um controlador de implantação.

Aumente o número dos seus pods frontend para cinco executando:

kubectl scale deployment frontend --replicas=5

Saída:

deployment.extensions/frontend scaled

A configuração da implantação é atualizada para especificar que são necessárias cinco réplicas em execução. Na implementação, o número de pods em execução é ajustado para corresponder a esse valor. Execute o seguinte comando para verificar isso:

kubectl get pods
Saída:
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 de front-end usando o mesmo comando.

Como fazer a limpeza

Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform:

Etapa 6: limpar

Após concluir o tutorial, siga estas etapas para remover os seguintes recursos e evitar cobranças indesejadas na sua conta:

  1. Exclua o serviço: com essa etapa, o balanceador de carga do Cloud, criado para o serviço frontend é desalocado:

    kubectl delete service frontend

  2. Aguarde o provisionamento do balanceador de carga para o serviço frontend a ser excluído: o balanceador de carga é excluído de maneira assíncrona em segundo plano quando você executa kubectl delete. Aguarde a exclusão enquanto observa a resposta ao comando a seguir:

    gcloud compute forwarding-rules list

  3. Exclua o Cluster do GKE: nesta etapa, serão excluídos os recursos que compõem o Cluster do GKE, como instâncias de computação, discos e recursos de rede.

    gcloud container clusters delete guestbook

A seguir