Como implantar um aplicativo da Web conteinerizado

Autopilot Padrão

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 upload da imagem do Docker para o Artifact 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.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

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

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Compute Engine, Artifact Registry, and Google Kubernetes Engine .

Ative as APIs

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Compute Engine, Artifact Registry, and Google Kubernetes Engine .

Ative as APIs

Ativar o Cloud Shell

O Cloud Shell vem pré-instalado com as ferramentas de linha de comando gcloud, docker e kubectl usadas neste tutorial.

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

Uma sessão do Cloud Shell é aberta dentro de um novo frame na parte inferior do Console do Google Cloud, e exibe um prompt de linha de comando.

Criar um repositório

Neste tutorial, você armazenará uma imagem no Artifact Registry e a implantará a partir do registro. Para este guia de início rápido, crie um repositório chamado hello-repo.

Defina a variável de ambiente PROJECT_ID para o ID do projeto do Google Cloud (PROJECT_ID). Você usará essa variável de ambiente ao criar a imagem do contêiner e enviá-la ao seu repositório.
```
export PROJECT_ID=PROJECT_ID
```
Confirme se a variável de ambiente PROJECT_ID tem o valor correto:
```
echo $PROJECT_ID
```
Defina o ID do projeto para a CLI do Google Cloud:
```
gcloud config set project $PROJECT_ID
```
Saída:
```
Updated property [core/project].
```
Observação: a CLI gcloud já pode estar definida como $PROJECT_ID. Você ainda verá a saída Updated property.

Crie o repositório hello-repo com o seguinte comando:

gcloud artifacts repositories create hello-repo \
   --repository-format=docker \
   --location=REGION \
   --description="Docker repository"

Substitua REGION pela região do repositório, como us-west1. Para ver uma lista de locais disponíveis, execute o comando:

 gcloud artifacts locations list

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.

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/quickstarts/hello-app

Crie e atribua uma tag à imagem do Docker para hello-app:
```
docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 .
```
Este comando instrui o Docker a criar a imagem usando Dockerfile no diretório atual, salvá-la no seu ambiente local e marcá-la com um nome, como us-west1-docker.pkg.dev/my-project/hello-repo/hello-app:v1. A imagem é enviada para o Artifact Registry na próxima seção.
- O PROJECT_ID associa a imagem do contêiner ao repositório hello-repo no projeto do Google Cloud.
- O prefixo us-west1-docker.pkg.dev refere-se ao Artifact Registry, host regional para seu repositório.
Observação: se solicitado, autorize o Cloud Shell a fazer chamadas de API do Google Cloud.

Execute o comando docker images para verificar se a compilação foi bem-sucedida:

docker images

Saída:

REPOSITORY                                                 TAG     IMAGE ID       CREATED          SIZE
us-west1-docker.pkg.dev/my-project/hello-repo/hello-app    v1      25cfadb1bf28   10 seconds ago   54 MB

Adicione vinculações de política do IAM à conta de serviço:

gcloud artifacts repositories add-iam-policy-binding hello-repo \
    --location=REGION \
    --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
    --role="roles/artifactregistry.reader"

Substitua PROJECT_NUMBER pelo número do projeto.

Como executar o contêiner localmente (opcional)

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

docker run --rm -p 8080:8080 REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1

Clique no botão 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.

Como enviar a imagem do Docker para o Artifact 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. Neste tutorial, você armazenará o contêiner no Artifact Registry.

Configure a ferramenta de linha de comando do Docker para autenticar no Artifact Registry:
```
gcloud auth configure-docker REGION-docker.pkg.dev
```
Observação: ignore qualquer aviso sobre ter uma lista longa de auxiliares de credenciais.

Envie a imagem do Docker que você acabou de criar para o repositório:

docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1

crie um cluster do GKE;

Agora que a imagem do Docker está armazenada no Artifact 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

Defina a região do Compute Engine:
```
 gcloud config set compute/region REGION
```
Para clusters zonais do Standard, defina uma zona do Compute Engine mais próxima do repositório do Artifact Registry.
Crie um cluster chamado hello-cluster:
```
 gcloud container clusters create-auto hello-cluster
```
Leva alguns minutos para que o cluster do GKE seja criado e verificado quanto à integridade. Para executar este tutorial em um cluster do GKE Standard, use o comando gcloud container clusters create.

Console

Acesse a página Google Kubernetes Engine no console do Google Cloud.

Acessar o Google Kubernetes Engine
Clique em Criar.
Em GKE Autopilot, clique em Configurar.
No campo Nome, digite o nome hello-cluster.
Selecione uma região do Compute Engine na lista suspensa Região, como us-west1.
Clique em Criar.
Aguarde a criação do cluster. Quando o cluster estiver pronto, uma marca de seleção vai 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

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

gcloud container clusters get-credentials hello-cluster --region REGION

Crie uma implantação do Kubernetes para a imagem do Docker hello-app.

kubectl create deployment hello-app --image=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1

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
```

Crie um recurso HorizontalPodAutoscaler para a implantação.

kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=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          90s
hello-app-784d7569bc-jfkz5   1/1     Running   0          90s
hello-app-784d7569bc-mnrrl   1/1     Running   0          95s

Console

Acesse a página Cargas de trabalho no console do Google Cloud.

Acesse "Cargas de trabalho"
Clique em Implantar.
Na seção Especificar contêiner, selecione Imagem do contêiner atual.
No campo Caminho da imagem, clique em Selecionar.
No painel Selecionar imagem do contêiner, selecione a imagem hello-app que você enviou para o Artifact Registry e clique em Selecionar.
Na seção Contêiner, clique em Concluído e em Continuar.
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.
Em Configuração 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.
Clique em Fechar e depois em Implantar.
Quando os pods de implantação estiverem prontos, a página Detalhes da implantação será aberta.
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

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.

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

Copie o endereço EXTERNAL_IP na área de transferência (por exemplo: 203.0.113.0).

Observação: pode levar alguns minutos para que o balanceador de carga seja provisionado. Até que o balanceador de carga seja provisionado, é possível ver um endereço IP <pending>.

Console

Acesse a página Cargas de trabalho no console do Google Cloud.

Acesse "Cargas de trabalho"
Clique em hello-app.
Na página "Detalhes da implantação", clique em Ações > Expor.
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.
Na lista suspensa Tipo de serviço, selecione Balanceador de carga.
Clique em Expor para criar um serviço do Kubernetes para hello-app.
Quando o balanceador de carga estiver pronto, a página Detalhes do serviço será aberta.
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.

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.

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

docker build -t REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 .

Envie a imagem para o Artifact Registry

docker push REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/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

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=REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2
```

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

Em uma guia separada, navegue novamente para o IP externo hello-app-service. Você verá a Version definida como 2.0.0.

Console

Acesse a página Cargas de trabalho no console do Google Cloud.

Acesse "Cargas de trabalho"
Clique em hello-app.
Na página Detalhes da implantação, clique em Ações > Atualização contínua.
Na caixa de diálogo Atualização gradual, defina o campo Imagem do hello-app como REGION-docker.pkg.dev/PROJECT_ID/hello-repo/hello-app:v2.
Clique em Atualizar.
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.
Após alguns instantes, atualize a página. Em Pods gerenciados, todas as réplicas de hello-app agora correspondem à revisão 2.
Em uma guia separada, navegue até o endereço IP do serviço que você copiou. Version precisa ser 2.0.0.

Limpar

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.

Exclua o serviço: isso desaloca o Cloud Load Balancer criado para o serviço:
```
kubectl delete service hello-app-service
```
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 --region REGION
```

Exclua as imagens de contêiner: isso exclui as imagens do Docker que você enviou para o Artifact Registry.

gcloud artifacts docker images delete \
    REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v1 \
    --delete-tags --quiet
gcloud artifacts docker images delete \
    REGION-docker.pkg.dev/${PROJECT_ID}/hello-repo/hello-app:v2 \
    --delete-tags --quiet

A seguir

Saiba mais sobre os Preços do GKE e use a Calculadora de preços para estimar custos.
Leia o tutorial Balanceadores de carga, em que você pode ver as configurações avançadas de balanceamento de carga para aplicativos da Web.
Configure um IP estático e um nome de domínio para o aplicativo.
Explore outros tutoriais do Kubernetes Engine.
Confira arquiteturas de referência, diagramas, tutoriais e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.

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 também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Faça uma avaliação gratuita do GKE