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.

Aprenda a como configurar o serviço da Web do livro de visitas em um IP externo com um balanceador de carga e como executar um cluster Redis com uma instância mestre e várias de trabalho.

O exemplo destaca vários conceitos importantes do GKE:

  • Configuração declarativa usando arquivos de manifestos YAML.
  • Implantações, que são recursos do Kubernetes que determinam a configuração de um conjunto de pods replicados.
  • Serviços 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, siga estas etapas:

  1. Configure um mestre Redis.
  2. Configure instâncias de trabalho Redis.
  3. Configure 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 Platform.
  2. Crie ou selecione um projeto.
  3. Aguarde a ativação da API e dos serviços relacionados. Isso pode demorar alguns minutos.
  4. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

Instale as seguintes ferramentas de linha de comando usadas neste tutorial:

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

Definir padrões da ferramenta de linha de comando gcloud

Para não perder tempo digitando o código 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 us-central1-b

Fazer o download dos arquivos de configuração

Acesse o repositório do Kubernetes no GitHub para fazer o download dos arquivos de configuração usados neste tutorial:

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 de contêiner chamado guestbook com dois nós:

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

É possível listar os clusters do seu projeto ou receber detalhes de um só usando os seguintes comandos:

gcloud container clusters list
gcloud container clusters describe guestbook

Etapa 1: configurar um mestre Redis

No aplicativo do livro de visitas, o Redis é usado para armazenar os dados. Eles são gravados em uma instância mestre Redis, e os dados de várias instâncias de trabalho (escravos) Redis são lidos. O primeiro passo é implantar um mestre Redis.

Use o arquivo de manifesto redis-master-deployment para implantar o mestre Redis. Nesse arquivo de manifesto, é especificado um controlador de implantação que executa um pod réplica mestre Redis:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: redis-master
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: redis
        role: master
        tier: backend
    spec:
      containers:
      - name: master
        image: k8s.gcr.io/redis:e2e  # or just image: redis
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
        ports:
        - containerPort: 6379

Execute o seguinte comando para implantar o mestre Redis:

kubectl create -f redis-master-deployment.yaml

Verifique se o pod do mestre Redis está executando kubectl get pods:

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

Copie o nome do pod da saída do comando anterior e execute o comando a seguir para observar os registros do pod mestre Redis:

kubectl logs -f [POD_NAME]

Criar o serviço mestre Redis

O aplicativo do livro de visitas precisa se comunicar com o mestre Redis para gravar os dados. Será necessário criar um serviço para redirecionar o tráfego ao pod do mestre Redis.

O serviço é uma abstração 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.

Confira o arquivo de manifesto redis-master-service.yaml, que descreve um recurso de serviço para o mestre Redis:

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

Esse arquivo de manifesto cria um serviço chamado redis-master com 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 mestre Redis criado na Etapa 1.

A seção ports do manifesto apresenta o mapeamento para uma só porta. Nesse caso, o serviço encaminha o tráfego da port: 6379 para a targetPort: 6379 dos contêineres que correspondem aos rótulos selector especificados. Observe que a containerPort usada na implantação precisa corresponder à targetPort para encaminhar o tráfego para a implantação.

Inicie o serviço do mestre Redis. Basta executar:

kubectl create -f redis-master-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-master   10.51.242.233   <none>        6379/TCP   12s

Etapa 2: configurar as instâncias de trabalho Redis

Como o mestre Redis é um pod único, é possível deixá-lo disponível e atender às demandas de tráfego acrescentando algumas réplicas de trabalho Redis.

Confira o arquivo de manifesto redis-slave-deployment.yaml. Ele descreve uma implantação para os pods de trabalho do Redis:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: redis-slave
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: redis
        role: slave
        tier: backend
    spec:
      containers:
      - name: slave
        image: gcr.io/google_samples/gb-redisslave:v1
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
        env:
        - name: GET_HOSTS_FROM
          value: dns
          # If your cluster config does not include a dns service, then to
          # instead access an environment variable to find the master
          # service's host, comment out the 'value: dns' line above, and
          # uncomment the line below:
          # value: env
        ports:
        - containerPort: 6379

A implantação é responsável por atingir a configuração declarada no arquivo de manifesto. Por exemplo, nesse arquivo define-se duas réplicas para as instâncias de trabalho Redis. Se não houver nenhuma réplica em execução, as duas réplicas serão implantadas no cluster de contêiner. Caso haja mais de duas réplicas em execução, ela encerrará algumas para atender à configuração especificada.

Nesse caso, no objeto de implantação são especificadas duas réplicas. Para criar a implantação de trabalho Redis, execute:

kubectl create -f redis-slave-deployment.yaml

Veja se as duas réplicas de trabalhador Redis estão em execução. Basta consultar a lista de pods:

kubectl get pods
Saída:
NAME                           READY     STATUS    RESTARTS   AGE
redis-master-343230949-qfvrq   1/1       Running   0          17m
redis-slave-132015689-dp23k    1/1       Running   0          2s
redis-slave-132015689-xq9v0    1/1       Running   0          2s

Criar o serviço redis-slave

O aplicativo do livro de visitas precisa se comunicar com as instâncias de trabalho Redis para ler os dados. Configure um serviço para tornar as instâncias de trabalho Redis detectáveis. O serviço possibilita um balanceamento de carga transparente a um conjunto de pods.

O redis-slave-service.yaml define a configuração do serviço para as instâncias de trabalho do Redis:

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

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

Crie o serviço redis-slave. Para isso, basta executar:

kubectl create -f redis-slave-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-master   10.51.242.233   <none>        6379/TCP   49s
redis-slave    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 trabalhos Redis, isto é um aplicativo replicado gerenciado por uma implantação.

Neste tutorial, é usado um front-end PHP simples. Ele está configurado para se comunicar com os serviços da instância de trabalho ou mestre Redis, de acordo com a solicitação de leitura ou de gravação. Nele é apresentada uma interface JSON simples e veiculada uma UX baseada em jQuery-Ajax.

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

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: frontend
spec:
  replicas: 3
  template:
    metadata:
      labels:
        app: guestbook
        tier: frontend
    spec:
      containers:
      - name: php-redis
        image: gcr.io/google-samples/gb-frontend:v4
        resources:
          requests:
            cpu: 100m
            memory: 100Mi
        env:
        - name: GET_HOSTS_FROM
          value: dns
          # If your cluster config does not include a dns service, then to
          # instead access environment variables to find service host
          # info, comment out the 'value: dns' line above, and uncomment the
          # line below:
          # value: env
        ports:
        - containerPort: 80

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

kubectl create -f frontend-deployment.yaml

Verifique se as três réplicas estão em execução. Basta executar a lista dos rótulos que identificam o front-end da Web:

kubectl get pods -l app=guestbook -l tier=frontend
Saída:
NAME                      READY     STATUS    RESTARTS   AGE
frontend-88237173-5p257   1/1       Running   0          40s
frontend-88237173-84036   1/1       Running   0          40s
frontend-88237173-j3rvr   1/1       Running   0          40s

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-slave e redis-master e faz uma busca DNS dos 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-slave e redis-master que você criou nas etapas anteriores só são acessíveis dentro do cluster de contêiner, porque o tipo padrão de um serviço é ClusterIP. O ClusterIP fornece um único endereço IP para o conjunto de pods a que o serviço aponta. Esse endereço IP só é acessível dentro do cluster.

Mas é necessário que o serviço front-end da Web do livro de visitas seja visível externamente. Ou seja, o cliente precisa solicitar o serviço de fora do cluster de contêiner. Para isso, é necessário especificar type: LoadBalancer na configuração do serviço. O arquivo de manifesto frontend-service.yaml que define essa configuração tem a seguinte aparência:

apiVersion: v1
kind: Service
metadata:
  name: frontend
  labels:
    app: guestbook
    tier: frontend
spec:
  # if your cluster supports it, uncomment the following to automatically create
  # an external load-balanced IP for the frontend service.
  # type: LoadBalancer
  ports:
  - port: 80
  selector:
    app: guestbook
    tier: frontend

Quando o serviço de frontend é criado, o GKE gera 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 mostra port: 80, e a targetPort não está especificada. Quando a propriedade targetPort é omitida, usa-se o valor padrão do campo port. Nesse caso, o serviço encaminha o tráfego externo da porta 80 para a porta 80 dos contêineres da implantação frontend.

Para criar o serviço, primeiro remova o comentário da seguinte linha do arquivo frontend-service.yaml:

type: LoadBalancer

Depois, crie o serviço. Basta executar:

kubectl create -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

Parabéns! Tente adicionar algumas entradas ao livro de visitas.

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.

Amplie o número dos seus pods frontend para cinco. Basta executar:

kubectl scale deployment frontend --replicas=5

A configuração da implementação é atualizada para especificar que deve haver 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-master-343230949-qfvrq   1/1       Running   0          54m
redis-slave-132015689-dp23k    1/1       Running   0          37m
redis-slave-132015689-xq9v0    1/1       Running   0          37m

Quando tráfego no site diminuir, reduza o número de pods de servidor da Web da mesma maneira.

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 de frontend, é desalocado:

    kubectl delete service frontend

  2. Aguarde a exclusão do balanceador de carga provisionado para o serviço de frontend: o balanceador de carga é excluído de modo assíncrono em segundo plano quando você executa kubectl delete. Aguarde a exclusão observando o resultado do comando a seguir:

    gcloud compute forwarding-rules list

  3. Exclua o cluster de contêiner: nessa etapa, são excluídos os recursos que compõem o cluster de contêiner, como instâncias de computação, discos e recursos de rede.

    gcloud container clusters delete guestbook

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Tutoriais do Kubernetes Engine