Como implantar um aplicativo da Web em contêineres

Neste tutorial, mostramos como empacotar um aplicativo da Web em uma imagem de contêiner do Docker. Além disso, você verá como executar essa imagem de contêiner em um cluster do Kubernetes Engine como um conjunto de réplicas com balanceamento de carga que pode se adaptar às necessidades dos usuários.

Objetivos

Para empacotar e implantar o aplicativo no Kubernetes Engine:

  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 Google Kubernetes Engine API:
  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 no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

Opção A: usar o Google Cloud Shell

Siga 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 na sua estação de trabalho.

Para usar o Google Cloud Shell:

  1. Acesse o Console do Google Cloud Platform.
  2. Clique no botão Ativar o Google Cloud Shell na parte superior da janela do console.

    Console do Google Cloud Platform

    Uma sessão do Cloud Shell é aberta em um novo frame na parte inferior do console e um prompt de linha de comando é exibido.

    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á necessário instalar as seguintes ferramentas:

  1. Instale o Google Cloud SDK, que contém a ferramenta de linha de comando gcloud.
  2. Usando a ferramenta de linha de comando gcloud, instale a ferramenta de linha de comando do Kubernetes. kubectl é usado para se comunicar com o Kubernetes, que é o sistema de orquestração de clusters do Kubernetes Engine:

    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.

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

Para economizar tempo ao digitar o código do projeto e as opções de zona do Compute Engine na ferramenta de linha de comando gcloud, defina valores de configuração padrão executando os seguintes comandos:
gcloud config set project [PROJECT_ID]
gcloud config set compute/zone us-central1-b

Etapa 1: criar a imagem do contêiner

No Kubernetes Engine, imagens do Docker podem ser usadas como o formato de implantação do aplicativo. Para criar uma imagem do Docker, são necessários um aplicativo e um Dockerfile.

Para este 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 arquivo abaixo para empacotar o aplicativo a seguir.

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

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

Defina a variável de ambiente PROJECT_ID na sua shell por meio da recuperação do código do projeto pré-configurado no gcloud ao executar o comando abaixo:

export PROJECT_ID="$(gcloud config get-value project -q)"

O valor de PROJECT_ID será usado para marcar a imagem do contêiner a fim de enviá-lo ao seu Container Registry particular.

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 criar a imagem usando o Dockerfile no diretório atual e 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 faz upload da imagem.

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

$ docker images
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 fazer o upload da imagem do contêiner em um registro para que o Kubernetes Engine possa fazer o download e executá-lo. Para carregar a imagem do contêiner no Container Registry, execute o comando a seguir:

gcloud 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 você está no Cloud Shell, clique em "Visualização da Web" na parte superior direita para ver o aplicativo em execução 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, feche o contêiner pressionando Ctrl+C na guia em que o comando docker run está sendo executado.

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 pool de instâncias de VMs do Compute Engine que executam o Kubernetes, o sistema de orquestração de clusters de código aberto que alimenta o Kubernetes Engine.

Depois de criar o cluster do Kubernetes Engine, use o Kubernetes para implantar aplicativos no cluster e gerenciar o ciclo de vida deles.

Execute o comando a seguir para criar um cluster de três nodes chamado hello-cluster:

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

A criação do cluster pode levar vários minutos. Após a conclusão do comando, execute o comando a seguir e veja as instâncias de VM com três trabalhadores do cluster:

$ gcloud compute instances list
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
gke-hello-cluster-default-pool-07a63240-shm4  us-central1-b  n1-standard-1               10.128.0.5   35.193.133.73   RUNNING

Etapa 5: implantar o aplicativo

Para implantar e gerenciar aplicativos em um cluster do Kubernetes Engine, estabeleça a comunicação com o sistema de gerenciamento de cluster 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 o contêiner do seu hello-app.

O comando kubectl run abaixo faz com que o Kubernetes crie uma implantação chamada hello-web no seu 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 comando a seguir para implantar seu aplicativo, com escuta na porta 8080:

kubectl run hello-web --image=gcr.io/${PROJECT_ID}/hello-app:v1 --port 8080

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

$ kubectl get pods
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 que você executa no Kubernetes Engine não estão acessíveis pela Internet, porque eles 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 de serviço, que oferece compatibilidade de rede e IP para os pods do seu aplicativo. Um IP externo e um balanceador de carga, sujeito a faturamento, são criados para o aplicativo pelo Kubernetes Engine.

A sinalização --port especifica o número da porta configurado no balanceador de carga, e a sinalização --target-port especifica o número da porta usado pelo pod criado pelo comando kubectl run da etapa anterior.

Depois de determinar o endereço IP externo do aplicativo, copie-o. Acesse esse URL (por exemplo, http://203.0.113.0) no navegador para verificar se o aplicativo está acessível.

Etapa 7: expandir o aplicativo

Adicione mais réplicas ao recurso Implantação do aplicativo com 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
NAME        DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-web   3         3         3            2           1m
$ kubectl get pods
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 aplicativo em execução, independentes uma da outra, e pode usar o comando kubectl scale para ajustar a capacidade do 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

Com o mecanismo de atualização contínua do Kubernetes Engine, é garantido que o aplicativo permaneça operacional e disponível mesmo que o sistema substitua as instâncias das imagens do contêiner antigas por novas em todas as réplicas em execução.

Você pode criar uma imagem para a versão v2 do aplicativo criando o mesmo código-fonte e marcando-o como v2 (ou você pode alterar a string "Hello, World!" para "Hello, Kubernetes Engine!" antes de criar a imagem):

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

Em seguida, envie a imagem ao Google Container Registry:

gcloud 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-web=gcr.io/${PROJECT_ID}/hello-app:v2

Acesse o aplicativo novamente em http://[EXTERNAL_IP] e observe as mudanças feitas entrarem em vigor.

Limpeza

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform, siga esta recomendação.

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 para o serviço é desalocado:

    kubectl delete service hello-web
    
  2. Aguarde a exclusão do balanceador de carga provisionado para o serviço da Web hello-world: o balanceador de carga é excluído de modo assíncrono em segundo plano quando você executa kubectl delete. Aguarde até que o balanceador de carga seja excluído observando a saída do seguinte comando:

    gcloud compute forwarding-rules list
    
  3. 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
    

Próximas etapas

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

Enviar comentários sobre…

Documentação do Kubernetes Engine