Como implantar um aplicativo da Web em contêiner

Este tutorial mostra como empacotar um aplicativo da Web em uma imagem de contêiner do Docker e executar essa imagem de contêiner em um cluster do Google Kubernetes Engine como um conjunto de réplicas com balanceamento de carga que pode ser dimensionado para as necessidades dos seus usuários.

Objetivos

Para empacotar e implantar seu aplicativo no GKE, faça o seguinte:

  1. empacote o app em uma imagem do Docker;
  2. execute o contêiner localmente na sua máquina (opcional);
  3. faça upload da imagem para um registro;
  4. crie um cluster do contêiner;
  5. implante o aplicativo no cluster;
  6. publique o app na Internet;
  7. amplie a implantação;
  8. implante uma nova versão do app.

Antes de começar

Siga estas etapas para ativar a API 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 o faturamento foi ativado no projeto do Google Cloud Platform. Saiba como confirmar que o faturamento está ativado para seu projeto.

Opção A: usar o Google Cloud Shell

Você pode seguir este tutorial usando o Google Cloud Shell, que vem pré-instalado com as ferramentas de linha de comando gcloud, docker e kubectl usadas neste tutorial. Se você usa o Cloud Shell, não precisa instalar essas ferramentas de linha de comando na sua estação de trabalho.

Para usar o Google Cloud Shell:

  1. Acesse o Console do Google Cloud.
  2. Clique no botão Ativar o Cloud Shell no topo da janela do console.

    Console do Google Cloud Platform

    Uma sessão do Cloud Shell abre dentro de um novo frame na parte inferior do console e exibe um prompt de linha de comando.

    Sessão do Cloud Shell

Opção B: usar ferramentas de linha de comando localmente

Se você preferir seguir este tutorial na sua estação de trabalho, será preciso instalar as seguintes ferramentas:

  1. Instale o SDK do Google Cloud, que inclui a ferramenta de linha de comando gcloud.
  2. Instale a ferramenta de linha de comando Kubernetes usando a ferramenta gcloud. A ferramenta kubectl é usada para se comunicar com o Kubernetes, que é o sistema de orquestração de clusters do GKE:

    gcloud components install kubectl
  3. Instale o Docker Community Edition (CE) na estação de trabalho. Use-o para criar uma imagem do contêiner para o aplicativo.

  4. Instale a ferramenta de controle de origem Git para buscar a amostra de aplicativo do GitHub.

Etapa 1: criar a imagem do contêiner

O GKE aceita imagens do Docker como o formato de implantação do aplicativo. Para criar uma imagem do Docker, são necessários um aplicativo e um Dockerfile.

Neste tutorial, você implantará um aplicativo da Web de amostra chamado hello-app, um servidor da Web escrito em Go que responde a todas as solicitações com a mensagem "Hello, World!" na porta 80.

O aplicativo é empacotado como uma imagem do Docker usando o Dockerfile, que contém instruções sobre como a imagem é criada. Você usará este Dockerfile para empacotar seu aplicativo.

Para fazer o download do código-fonte hello-app, execute os seguintes comandos:

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

Defina a variável de ambiente PROJECT_ID para seu ID do projeto do Google Cloud. Essa variável será usada para associar a imagem do contêiner ao Container Registry do seu projeto.

export PROJECT_ID=[PROJECT_ID]

Para criar a imagem do contêiner desse aplicativo e marcá-lo para upload, execute o seguinte comando:

docker build -t gcr.io/${PROJECT_ID}/hello-app:v1 .

Este comando instrui o Docker a construir a imagem usando Dockerfile no diretório atual e a marcá-la com um nome, como gcr.io/my-project/hello-app:v1. O prefixo gcr.io refere-se ao Google Container Registry, em que a imagem será hospedada. A execução desse comando ainda não carrega a imagem.

Você pode executar o comando docker images para verificar se a versão foi bem-sucedida:

docker images
Saída:
REPOSITORY                     TAG                 IMAGE ID            CREATED             SIZE
gcr.io/my-project/hello-app    v1                  25cfadb1bf28        10 seconds ago      54 MB

Etapa 2: fazer upload da imagem do contêiner

Você precisa carregar a imagem do contêiner em um registro para que o GKE possa fazer o download e executá-la.

Primeiro, configure a ferramenta de linha de comando do Docker para autenticação no Container Registry. Você só precisa executá-la uma vez:

gcloud auth configure-docker

Agora, use a ferramenta de linha de comando do Docker para fazer upload da imagem para seu Container Registry:

docker push gcr.io/${PROJECT_ID}/hello-app:v1

Etapa 3: executar o contêiner localmente (opcional)

Para testar a imagem do contêiner usando o mecanismo local do Docker, execute o seguinte comando:

docker run --rm -p 8080:8080 gcr.io/${PROJECT_ID}/hello-app:v1

Se estiver usando o Cloud Shell, clique no botão" "Visualização da Web" no canto superior direito para ver o aplicativo sendo executado em uma guia do navegador. Caso contrário, abra uma nova janela do terminal ou uma guia do Cloud Shell e execute para verificar se o contêiner funciona e responde às solicitações com "Hello, World!":

curl http://localhost:8080

Depois de ver uma resposta bem-sucedida, encerre o contêiner pressionando Ctrl + C na guia em que o comando docker run está em execução.

Etapa 4: criar um cluster de contêiner

Agora que a imagem do contêiner está armazenada em um registro, você precisa criar um cluster de contêiner para executar a imagem. Um cluster consiste em um conjunto de instâncias de VM do Compute Engine executando Kubernetes, isto é, o sistema de orquestração de cluster de código aberto que alimenta o GKE.

Depois de criar um cluster do GKE, você usa o Kubernetes para implantar aplicativos no cluster e gerenciar o ciclo de vida deles.

Defina as opções ID do projeto e zona do Compute Engine para a ferramenta gcloud:

gcloud config set project $PROJECT_ID
gcloud config set compute/zone [COMPUTE_ENGINE_ZONE]

Execute o seguinte comando para criar um cluster de dois nós chamado hello-cluster:

gcloud container clusters create hello-cluster --num-nodes=2

A criação do cluster pode levar vários minutos. Quando o comando for concluído, execute o seguinte comando e veja as duas instâncias de VM de worker do cluster:

gcloud compute instances list
Saída:
NAME                                          ZONE           MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP     STATUS
gke-hello-cluster-default-pool-07a63240-822n  us-central1-b  n1-standard-1               10.128.0.7   35.192.16.148   RUNNING
gke-hello-cluster-default-pool-07a63240-kbtq  us-central1-b  n1-standard-1               10.128.0.4   35.193.136.140  RUNNING

Etapa 5: implantar o aplicativo

Para implantar e gerenciar aplicativos em um cluster do GKE, comunique-se com o sistema de gerenciamento de clusters do Kubernetes. Normalmente, isso é feito com a ferramenta de linha de comando kubectl.

O Kubernetes representa aplicativos como pods, que são unidades que representam um contêiner, ou grupo de contêineres estreitamente associados. O pod é a menor unidade implantável no Kubernetes. Neste tutorial, cada pod contém apenas seu contêiner hello-app.

O comando kubectl create deployment abaixo faz com que o Kubernetes crie uma implantação chamada hello-web no cluster. Diversas cópias do seu aplicativo, chamadas de réplicas, são gerenciadas pelo recurso Implantação, que as programa para execução em nodes individuais no seu cluster. Neste caso, a Implantação executará apenas um pod do seu aplicativo.

Execute o seguinte comando para implantar seu aplicativo:

kubectl create deployment hello-web --image=gcr.io/${PROJECT_ID}/hello-app:v1

Para ver o pod criado pela Implantação, execute o comando a seguir:

kubectl get pods
Saída:
NAME                         READY     STATUS    RESTARTS   AGE
hello-web-4017757401-px7tx   1/1       Running   0          3s

Etapa 6: publicar o aplicativo na Internet

Por padrão, os contêineres executados no GKE não podem ser acessados pela Internet porque não têm endereços IP externos. Execute o comando a seguir para publicar explicitamente o aplicativo no tráfego da Internet:

kubectl expose deployment hello-web --type=LoadBalancer --port 80 --target-port 8080

O comando kubectl expose acima cria um recurso Serviço, que fornece suporte de IP e de rede para os pods do seu aplicativo. O GKE cria um IP externo e um balanceador de carga, sujeito ao faturamento, para seu aplicativo.

A sinalização --port especifica o número da porta configurada no balanceador de carga, e a sinalização --target-port especifica o número da porta em que o contêiner hello-app está escutando.

Depois de determinar o endereço IP externo do aplicativo, copie-o. Aponte seu navegador para este URL, por exemplo, http://203.0.113.0 para verificar se seu aplicativo está acessível.

Etapa 7: expandir o aplicativo

Adicione mais réplicas ao recurso de implantação do seu aplicativo usando o comando kubectl scale. Para adicionar mais duas réplicas ao recurso Implantação, para um total de três, execute o seguinte comando:

kubectl scale deployment hello-web --replicas=3

Veja as novas réplicas no seu cluster. Basta executar os seguintes comandos:

kubectl get deployment hello-web
Saída:
NAME        DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-web   3         3         3            2           1m
kubectl get pods
Saída:
NAME                         READY     STATUS    RESTARTS   AGE
hello-web-4017757401-ntgdb   1/1       Running   0          9s
hello-web-4017757401-pc4j9   1/1       Running   0          9s
hello-web-4017757401-px7tx   1/1       Running   0          1m

Agora, você tem várias instâncias do seu aplicativo em execução independentemente umas das outras e pode usar o comando kubectl scale para ajustar a capacidade do seu aplicativo.

O balanceador de carga provisionado na etapa anterior começará a direcionar o tráfego para essas novas réplicas automaticamente.

Etapa 8: implantar uma nova versão do aplicativo

O mecanismo de atualização gradual do GKE garante que seu aplicativo permaneça ativo e disponível, mesmo que o sistema substitua as instâncias da imagem antiga do contêiner por todas as réplicas em execução.

É possível criar uma imagem para a versão v2 do seu aplicativo criando o mesmo código-fonte e marcando-o como v2 (ou alterar a string "Hello, World!" para "Hello, GKE!" antes de criar a imagem):

docker build -t gcr.io/${PROJECT_ID}/hello-app:v2 .

Em seguida, envie a imagem ao Google Container Registry:

docker push gcr.io/${PROJECT_ID}/hello-app:v2

Agora, aplique a atualização contínua à implantação existente com uma atualização da imagem:

kubectl set image deployment/hello-web hello-app=gcr.io/${PROJECT_ID}/hello-app:v2

Visite seu aplicativo novamente em http://[EXTERNAL_IP] e observe as alterações feitas entrarem em vigor.

Como fazer a limpeza

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

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

  1. Excluir o Serviço: essa etapa irá desalocar o balanceador de carga do Cloud criado para seu Serviço:

    kubectl delete service hello-web

  2. Exclua o cluster de contêineres: nessa etapa, os recursos que compõem o cluster de contêineres, como instâncias de cálculo, discos e recursos de rede, são excluídos.

    gcloud container clusters delete hello-cluster

A seguir