Como implantar um aplicativo da Web em contêiner

Neste tutorial, mostramos como empacotar um aplicativo da Web em uma imagem de contêiner do Docker e como executar essa imagem em um Cluster do Google Kubernetes Engine (GKE). Você implantará o aplicativo da Web como um conjunto de réplicas com balanceamento de carga que pode ser escalonado de acordo com as necessidades dos usuários.

Objetivos

  • Empacotar um aplicativo da Web de amostra em uma imagem do Docker.
  • Fazer o upload da imagem do Docker no Container Registry.
  • Criar um cluster do GKE.
  • Implantar o app de amostra no cluster.
  • Gerenciar o escalonamento automático da implantação.
  • Publicar o app de amostra na Internet.
  • Implantar uma nova versão do app de amostra.

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 o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

Opção A: usar o Cloud Shell

Siga este tutorial usando o 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 Cloud Shell:

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

    Uma sessão do Cloud Shell é aberta dentro de um novo frame na parte inferior do Console do Cloud, 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, siga estas etapas para instalar as ferramentas necessárias.

  1. Instale o SDK do 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.

Como construir a imagem do container

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

O GKE aceita imagens do Docker como o formato de implantação do aplicativo. Antes de implantar hello-app no GKE, é preciso empacotar o código-fonte hello-app como uma imagem do Docker.

Para criar uma imagem do Docker, é necessário ter um código-fonte e um Dockerfile (em inglês). Um Dockerfile contém instruções relacionadas à construção da imagem.

  1. Faça o download do código-fonte hello-app e do Dockerfile executando estes comandos:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
    cd kubernetes-engine-samples/hello-app
    
  2. Defina a variável de ambiente PROJECT_ID para seu ID do projeto do Google Cloud (PROJECT_ID). A variável PROJECT_ID associa a imagem do contêiner ao Container Registry do seu projeto.

    export PROJECT_ID=PROJECT_ID
    
  3. Confirme se a variável de ambiente PROJECT_ID tem o valor correto:

    echo $PROJECT_ID
    
  4. Crie e atribua uma tag à imagem do Docker para hello-app:

    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 Container Registry, em que a imagem está hospedada. A execução desse comando não carrega a imagem.

  5. Execute o comando docker images para verificar se a compilaçã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
    

Como executar o contêiner localmente (opcional)

  1. Teste a imagem do contêiner usando o mecanismo local do Docker:

    docker run --rm -p 8080:8080 gcr.io/${PROJECT_ID}/hello-app:v1
    
  2. Se você estiver usando o Cloud Shell, clique no botão Visualização da Web Botão de visualização da Web e selecione o número da porta 8080. O GKE abre o URL de visualização no serviço de proxy em uma nova janela do navegador.

  3. Caso contrário, abra uma nova janela do terminal ou uma guia do Cloud Shell e execute o seguinte comando 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, desligue o contêiner pressionando Ctrl + C na guia em que o comando docker run está sendo executado.

Como enviar a imagem do Docker para o Container Registry

É preciso fazer upload da imagem do contêiner para um registro para que seu cluster do GKE possa fazer o download e executar a imagem do contêiner. No Google Cloud, o Container Registry está disponível por padrão.

  1. Ative a API Container Registry para o projeto do Google Cloud em que você está trabalhando:

    gcloud services enable containerregistry.googleapis.com
    
  2. Configure a ferramenta de linha de comando do Docker para autenticar no Container Registry:

    gcloud auth configure-docker
    
  3. Envie a imagem do Docker que você acabou de criar para o Container Registry:

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

crie um cluster do GKE;

Agora que a imagem do Docker está armazenada no Container Registry, crie um cluster do GKE para executar o hello-app. Um Cluster do GKE consiste em um pool de instâncias de VM do Compute Engine executando o Kubernetes (em inglês), isto é, o sistema de orquestração de cluster de código aberto que alimenta o GKE.

Cloud Shell

  1. Defina a opção de ID do projeto para a ferramenta gcloud:

    gcloud config set project $PROJECT_ID
    
  2. Defina a zona ou região. Dependendo do modo de operação escolhido para usar no GKE, especifique uma zona ou região padrão. Se você usar o modo Padrão, o cluster será zonal (neste tutorial), portanto, defina a zona de computação padrão. Se você usar o modo Autopilot, o cluster será regional. Portanto, defina a região de computação padrão. Escolha a zona ou região mais próxima de você.

    • Cluster padrão, como us-west1-a:

      gcloud config set compute/zone COMPUTE_ZONE
      
    • Cluster de Autopilot, como us-west1:

      gcloud config set compute/region COMPUTE_REGION
      
  3. Crie um cluster chamado hello-cluster:

    • Cluster padrão:

      gcloud container clusters create hello-cluster
      
    • Cluster de Autopilot:

      gcloud container clusters create-auto hello-cluster
      

    Leva alguns minutos para que o cluster do GKE seja criado e verificado quanto à integridade.

  4. Depois que o comando for concluído, execute o seguinte comando para ver os três nós do cluster:

    kubectl get nodes
    

    Saída:

    NAME                                           STATUS   ROLES    AGE   VERSION
    gke-hello-cluster-default-pool-229c0700-cbtd   Ready    <none>   92s   v1.18.12-gke.1210
    gke-hello-cluster-default-pool-229c0700-fc5j   Ready    <none>   91s   v1.18.12-gke.1210
    gke-hello-cluster-default-pool-229c0700-n9l7   Ready    <none>   92s   v1.18.12-gke.1210
    

Console

  1. Acesse o menu do Google Kubernetes Engine no Console do Cloud.

    Acesse o menu do Google Kubernetes Engine

  2. Clique em Criar.

  3. Escolha os modos Padrão ou Autopilot e clique em Configurar.

  4. No campo Nome, digite o nome hello-cluster.

  5. Selecione uma zona ou região:

  6. Clique em Criar. Isso cria um cluster do GKE.

  7. Aguarde a criação do cluster. Quando o cluster estiver pronto, uma marca de seleção verde aparecerá ao lado do nome dele.

Como implantar o app de amostra no GKE

Agora está tudo pronto para implantar no cluster do GKE a imagem do Docker que você criou.

O Kubernetes representa aplicativos como pods (em inglês), que são unidades escalonáveis com um ou mais contêineres. O pod é a menor unidade implantável no Kubernetes. Normalmente, você implanta pods como um conjunto de réplicas que podem ser escalonadas e distribuídas juntas no cluster. Uma maneira de implantar um conjunto de réplicas é por meio de uma implantação do Kubernetes (em inglês).

Nesta seção, você cria uma implantação do Kubernetes para executar hello-app no cluster. Esta implantação tem réplicas (pods). Um pod de implantação contém apenas um contêiner: a imagem hello-app do Docker. Você também cria um recurso HorizontalPodAutoscaler que escalona o número de pods de 3 para um número entre 1 e 5, com base na carga da CPU.

Cloud Shell

  1. Verifique se você está conectado ao cluster do GKE.

    gcloud container clusters get-credentials hello-cluster --zone COMPUTE_ZONE
    
  2. Crie uma implantação do Kubernetes para a imagem do Docker hello-app.

    kubectl create deployment hello-app --image=gcr.io/${PROJECT_ID}/hello-app:v1
    
  3. Defina como três o número de valor de referência das réplicas de implantação.

    kubectl scale deployment hello-app --replicas=3
    
  4. Crie um recurso HorizontalPodAutoscaler para a implantação.

    kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5
    
  5. Para ver os pods criados, execute este comando:

    kubectl get pods
    

    Saída:

    NAME                         READY   STATUS    RESTARTS   AGE
    hello-app-784d7569bc-hgmpx   1/1     Running   0          10s
    hello-app-784d7569bc-jfkz5   1/1     Running   0          10s
    hello-app-784d7569bc-mnrrl   1/1     Running   0          15s
    

Console

  1. Acesse o menu de cargas de trabalho do GKE no Console do Cloud.

    Acesse o menu “Cargas de trabalho”

  2. Clique em Implantar.

  3. Na seção Contêiner, selecione Imagem existente do contêiner.

  4. No campo Caminho da imagem, clique em Selecionar.

  5. No painel Selecionar imagem do contêiner, selecione a imagem hello-app que você enviou para o Container Registry e clique em Selecionar.

  6. Na seção Contêiner, clique em Concluído e em Continuar.

  7. Na seção Configuração, em Rótulos, digite app para Chave e hello-app em Valor. para criar um anexo da VLAN de monitoramento.

  8. Em YAML YAML, clique em Ver YAML. Isso abrirá um arquivo de configuração YAML que representa os dois recursos da API Kubernetes a serem implantados no cluster: uma implantação e HorizontalPodAutoscaler para essa implantação.

  9. Clique em Fechar e depois em Implantar.

  10. Quando os pods de implantação estiverem prontos, a página Detalhes da implantação será aberta.

  11. Em Pods gerenciados, observe os três pods em execução para a implantação hello-app.

Como publicar o app de amostra na Internet

Embora os pods tenham endereços IP atribuídos individualmente, esses IPs só podem ser acessados de dentro do cluster. Além disso, os pods do GKE foram projetados para serem temporários, iniciados ou interrompidos com base nas necessidades de escalonamento. E quando um pod falha devido a um erro, o GKE o reimplanta automaticamente, atribuindo um novo endereço IP de pod toda vez.

Isso significa que, para qualquer implantação, o conjunto de endereços IP correspondente ao conjunto ativo de pods é dinâmico. Precisamos de uma maneira para 1) Agrupar pods em um nome de host estático e 2) Expor um grupo de pods, fora do cluster, na Internet.

Os Serviços do Kubernetes resolvem esses dois problemas. Serviços agrupam pods em um endereço IP estático e acessível a partir de qualquer pod dentro do cluster. O GKE também atribui um nome de host DNS a esse IP estático. Por exemplo, hello-app.default.svc.cluster.local.

O tipo de Serviço padrão no GKE é chamado de ClusterIP, em que o Serviço recebe um endereço IP acessível somente de dentro do cluster. Para expor um serviço do Kubernetes fora do cluster, crie um Serviço do tipo LoadBalancer. Esse tipo de Serviço gera um IP do balanceador de carga externo para um conjunto de pods, acessíveis por meio da Internet.

Nesta seção, você expõe a implantação hello-app à Internet usando um Serviço do tipo LoadBalancer.

.

Cloud Shell

  1. Use o comando kubectl expose para gerar um Serviço do Kubernetes para a implantação do hello-app:

    kubectl expose deployment hello-app --name=hello-app-service --type=LoadBalancer --port 80 --target-port 8080
    

    Aqui, 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á realizando detecções.

  2. Execute o comando a seguir para receber os detalhes do Serviço de hello-app-service:

    kubectl get service
    

    Saída:

    NAME                 CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
    hello-app-service    10.3.251.122    203.0.113.0     80:30877/TCP     10s
    
  3. Copie o endereço EXTERNAL_IP na área de transferência (por exemplo: 203.0.113.0).

Console

  1. Acesse o menu Cargas de trabalho do Google Kubernetes Engine no Console do Cloud.

    Acesse o menu “Cargas de trabalho”

  2. Clique em hello-app.

  3. Na página "Detalhes da implantação", clique em Ações > Expor.

  4. Na caixa de diálogo Expor, defina a Porta de destino como 8080. Essa é a porta em que o contêiner hello-app realiza detecções.

  5. Na lista suspensa Tipo de serviço, selecione Balanceador de carga.

  6. Clique em Expor para criar um serviço do Kubernetes para hello-app.

  7. Quando o balanceador de carga estiver pronto, a página Detalhes do serviço será aberta.

  8. Role para baixo até o campo External endpoints e copie o endereço IP.

Agora que os pods hello-app estão expostos na Internet por meio de um Serviço do Kubernetes, é possível abrir uma nova guia do navegador e navegar até o endereço IP do Serviço copiado para a área de transferência. Uma mensagem Hello, World! é exibida, com um campo Hostname. O Hostname corresponde a um dos três pods hello-app que veiculam a solicitação HTTP para o navegador.

Como implantar uma nova versão do app de amostra

Nesta seção, você fará o upgrade do hello-app para uma nova versão ao criar e implantar uma nova imagem do Docker no Cluster do GKE.

O recurso de atualização gradual do GKE permite que você atualize as implantações sem inatividade. Durante uma atualização gradual, o Cluster do GKE substitui incrementalmente os pods hello-app atuais por pods que contêm a imagem do Docker para a nova versão. Durante a atualização, o serviço de balanceador de carga direciona o tráfego apenas para os pods disponíveis.

  1. Retorne ao Cloud Shell, onde você clonou o código-fonte do app hello e o Dockerfile. Atualize a função hello() no arquivo main.go para relatar a nova versão 2.0.0.

  2. Crie e atribua uma tag à nova imagem do Docker hello-app.

    docker build -t gcr.io/${PROJECT_ID}/hello-app:v2 .
    
  3. Envie a imagem para o Container Registry

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

Agora está tudo pronto para atualizar a implantação do Kubernetes hello-app e usar uma nova imagem do Docker.

Cloud Shell

  1. Aplique uma atualização gradual à implantação hello-app atual com uma atualização de imagem usando o comando kubectl set image:

    kubectl set image deployment/hello-app hello-app=gcr.io/${PROJECT_ID}/hello-app:v2
    
  2. Observe os pods ativos que executam a imagem v1 pararem e os novos pods que executam a imagem v2 começarem a funcionar.

    watch kubectl get pods
    

    Saída:

    NAME                        READY   STATUS    RESTARTS   AGE
    hello-app-89dc45f48-5bzqp   1/1     Running   0          2m42s
    hello-app-89dc45f48-scm66   1/1     Running   0          2m40s
    
  3. Em uma guia separada, navegue novamente para o IP externo hello-app-service. Você verá a Version definida como 2.0.0.

Console

  1. Acesse o menu Cargas de trabalho do Google Kubernetes Engine no Console do Cloud.

    Acesse o menu “Cargas de trabalho”

  2. Clique em hello-app.

  3. Na página Detalhes da implantação, clique em Ações > Atualização contínua.

  4. Na caixa de diálogo Atualização gradual, defina o campo Imagem de hello-app como gcr.io/PROJECT_ID/hello-app:v2, substituindo PROJECT_ID pelo código do projeto.

  5. Clique em Atualizar.

  6. Na página Detalhes da implantação, inspecione a seção Revisões ativas. Agora você verá duas Revisões, a 1 e a 2. A Revisão 1 corresponde à Implantação inicial criada anteriormente. A Revisão 2 é a atualização gradual que você acabou de iniciar.

  7. Após alguns instantes, atualize a página. Em Pods gerenciados, todas as réplicas de hello-app agora correspondem à revisão 2.

  8. Em uma guia separada, navegue até o endereço IP do serviço que você copiou. Version precisa ser 2.0.0.

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

  1. Exclua o serviço: isso desaloca o Cloud Load Balancer criado para o serviço:

    kubectl delete service hello-app-service
    
  2. Exclua o cluster: exclui os recursos que compõem o cluster, como instâncias de computação, discos e recursos de rede:

    gcloud container clusters delete hello-cluster --zone COMPUTE_ZONE
    
  3. Exclua as imagens de contêiner: isso exclui as imagens do Docker que você enviou para o Container Registry.

    gcloud container images delete gcr.io/${PROJECT_ID}/hello-app:v1  --force-delete-tags --quiet
    gcloud container images delete gcr.io/${PROJECT_ID}/hello-app:v2  --force-delete-tags --quiet
    

A seguir

Faça um teste

Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho do GKE em situações reais. Clientes novos recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Faça uma avaliação gratuita do GKE