Implemente uma app Web contentorizada do Docker no GKE

Este tutorial mostra como implementar uma aplicação Web contentorizada num cluster do Google Kubernetes Engine (GKE).

Esta página destina-se a operadores e programadores que preparam e configuram recursos na nuvem, e implementam apps e serviços. Para saber mais sobre as funções comuns e as tarefas de exemplo referenciadas no Google Cloud conteúdo, consulte o artigo Funções e tarefas comuns de utilizadores do GKE.

Antes de ler esta página, certifique-se de que conhece o Kubernetes.

Crie um repositório

Neste tutorial, armazena uma imagem no Artifact Registry e implementa-a a partir do registo. Para este início rápido, vai criar um repositório com o nome hello-repo.

1. Defina a variável de ambiente PROJECT_ID para o Google Cloud ID do projeto (PROJECT_ID). Vai usar esta variável de ambiente quando criar a imagem do contentor e a enviar para o seu repositório.

   export PROJECT_ID=PROJECT_ID
   

2. Confirme que a variável de ambiente PROJECT_ID tem o valor correto:

   echo $PROJECT_ID
   

3. Defina o ID do projeto para a CLI do Google Cloud:

   gcloud config set project $PROJECT_ID
   

   Saída:

   Updated property [core/project].
   

   Nota: a CLI gcloud pode já estar definida para o seu $PROJECT_ID. Continua a ver o resultado Updated property.

4. 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 por uma região para o repositório, como us-west1. Para ver uma lista de localizações disponíveis, execute o comando:

    gcloud artifacts locations list
   

Crie a imagem do hello-app Docker

Neste tutorial, implementa uma aplicação Web de exemplo denominada hello-app, um servidor Web escrito em Go que responde a todos os pedidos com a mensagem Hello, World! na porta 8080.

O GKE aceita imagens Docker como o formato de implementação de aplicações. Antes de implementar o hello-app no GKE, tem de criar um pacote do código fonte do hello-app como uma imagem do Docker.

Para criar uma imagem do Docker, precisa de código-fonte e de um Dockerfile. Um Dockerfile contém instruções sobre como a imagem é criada.

1. Transfira o hello-app código-fonte e o Dockerfile executando os seguintes comandos:

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

2. Crie e etiquete a imagem de Docker para hello-app:

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

   Este comando indica ao Docker para criar a imagem usando o Dockerfile no diretório atual, guardá-la no seu ambiente local e etiquetá-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 secção seguinte.

   • A variável PROJECT_ID associa a imagem do contentor ao hello-reporepositório no seu Google Cloud projeto.
   • O prefixo us-west1-docker.pkg.dev refere-se ao Artifact Registry, anfitrião regional do seu repositório.
   Nota: se lhe for pedido, autorize o Cloud Shell a fazer Google Cloud chamadas API.

3. 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
   

   Nota: também pode ver imagens adicionais que representam camadas de imagens intermédias.

4. Adicione associações de políticas IAM à sua conta de serviço:

   gcloud artifacts repositories add-iam-policy-binding hello-repo \
       --location=REGION \
       --member=serviceAccount:[e-mail] \
       --role="roles/artifactregistry.reader"
   

   Substitua PROJECT_NUMBER pelo número do projeto do seu projeto.

(Opcional) Execute o contentor Docker localmente

1. Teste a imagem do contentor com o motor Docker local:

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

2. Clique no botão Pré-visualização na Web e, de seguida, selecione o número da porta 8080. O GKE abre o URL de pré-visualização no respetivo serviço de proxy numa nova janela do navegador.

Envie a sua imagem de Docker para o Artifact Registry

Tem de carregar a imagem do contentor para um registo para que o cluster do GKE possa transferir e executar a imagem do contentor. Neste tutorial, vai armazenar o seu contentor no Artifact Registry.

1. Configure a ferramenta de linha de comandos do Docker para autenticar no Artifact Registry:

   gcloud auth configure-docker REGION-docker.pkg.dev
   

   Nota: pode ignorar todos os avisos sobre ter uma longa lista de utilitários de credenciais.

2. Envie a imagem do Docker que 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 num conjunto de instâncias de VM do Compute Engine que executam o Kubernetes, o sistema de orquestração de clusters de código aberto que alimenta o GKE.

Cloud Shell

1. Defina a região do Compute Engine:

    gcloud config set compute/region REGION
   

   Para clusters zonais padrão, defina uma zona do Compute Engine mais próxima do repositório do Artifact Registry.

2. Crie um cluster com o nome hello-cluster:

    gcloud container clusters create-auto hello-cluster
   

   Demora alguns minutos para que o cluster do GKE seja criado e a respetiva integridade seja verificada. Para executar este tutorial num cluster padrão do GKE, use o comando gcloud container clusters create.

Consola

1. Na Google Cloud consola, aceda à página Criar um cluster do Autopilot.

   Aceda a Crie um cluster do Autopilot

2. No campo Nome, introduza o nome hello-cluster.

3. Selecione uma região do Compute Engine na lista pendente Região, como us-west1.

4. Clique em Criar.

5. Aguarde a criação do cluster. Quando o cluster estiver pronto, é apresentada uma marca de verificação junto ao nome do cluster.

Implemente o hello-app no GKE

Já tem tudo pronto para implementar a imagem do Docker que criou no seu cluster do GKE.

O Kubernetes representa as aplicações como Pods, que são unidades escaláveis que contêm um ou mais contentores. O Pod é a unidade implementável mais pequena no Kubernetes. Normalmente, implementa os pods como um conjunto de réplicas que podem ser dimensionadas e distribuídas em conjunto no seu cluster. Uma forma de implementar um conjunto de réplicas é através de uma implementação do Kubernetes.

Nesta secção, cria uma implementação do Kubernetes para executar o hello-app no seu cluster. Esta implementação tem réplicas (pods). Um pod de implementação contém apenas um contentor: a imagem do hello-app Docker. Também cria um recurso HorizontalPodAutoscaler que dimensiona o número de pods de 3 para um número entre 1 e 5, com base na carga da CPU.

Cloud Shell

1. Certifique-se de que tem ligação ao cluster do GKE.

   gcloud container clusters get-credentials hello-cluster
   

2. Crie uma implementação do Kubernetes para a sua hello-app imagem do Docker.

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

3. Defina o número de réplicas de implementação de base como 3.

   kubectl scale deployment hello-app --replicas=3
   

4. Crie um recurso HorizontalPodAutoscaler para a sua implementação.

   kubectl autoscale deployment hello-app --cpu-percent=80 --min=1 --max=5
   

5. Para ver os pods criados, execute o seguinte 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
   

   Nota: os Pods podem demorar até dois minutos a começar a funcionar. Até começarem, a coluna Status apresenta Pending.

Consola

1. Aceda à página Workloads na Google Cloud consola.

   Visitar cargas de trabalho

2. Clique em Implementar.

3. Na secção Especificar contentor, selecione Imagem de contentor existente.

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

5. No painel Selecionar imagem do contentor, selecione a imagem hello-app que enviou para o Artifact Registry e clique em Selecionar.

6. Na secção Contentor, clique em Concluído e, de seguida, em Continuar.

7. Na secção Configuração, em Etiquetas, introduza app para Chave e hello-app para Valor.

8. Em YAML de configuração, clique em Ver YAML. Esta ação abre um ficheiro de configuração YAML que representa os dois recursos da API Kubernetes prestes a serem implementados no seu cluster: uma implementação e um HorizontalPodAutoscaler para essa implementação.

9. Clique em Fechar e, de seguida, em Implementar.

10. Quando os pods de implementação estiverem prontos, é apresentada a página Detalhes da implementação.

11. Em Managed pods (Pods geridos), repare nos três pods em execução para a hello-app implementação.

Exponha a app à Internet

Embora os pods tenham endereços IP atribuídos individualmente, só é possível aceder a esses IPs a partir do interior do cluster. Além disso, os pods do GKE são concebidos para serem temporários, iniciando ou parando com base nas necessidades de escalabilidade. Além disso, quando um pod falha devido a um erro, o GKE volta a implementar automaticamente esse pod, atribuindo um novo endereço IP do pod de cada vez.

Isto significa que, para qualquer implementação, o conjunto de endereços IP correspondente ao conjunto ativo de pods é dinâmico. Precisamos de uma forma de 1) agrupar os pods num nome de anfitrião estático e 2) expor um grupo de pods fora do cluster à Internet.

Os serviços do Kubernetes resolvem ambos os problemas. Os serviços agrupam os pods num endereço IP estático, acessível a partir de qualquer pod no cluster. O GKE também atribui um nome de anfitrião DNS a esse IP estático. Por exemplo, hello-app.default.svc.cluster.local.

O tipo de serviço predefinido no GKE chama-se ClusterIP, em que o serviço recebe um endereço IP acessível apenas a partir do interior do cluster. Para expor um serviço do Kubernetes fora do cluster, crie um serviço do tipo LoadBalancer. Este tipo de serviço gera um IP do balanceador de carga externo para um conjunto de pods, acessível através da Internet.

Nesta secção, expõe a hello-app implementação à Internet através de um serviço do tipo LoadBalancer.

Nota: os balanceadores de carga de aplicações externos estão (sujeitos a faturação) separados dos custos do GKE.

Cloud Shell

1. Use o comando kubectl expose para gerar um serviço Kubernetes para a implementação hello-app:

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

   Aqui, a flag --port especifica o número da porta configurado no equilibrador de carga e a flag --target-port especifica o número da porta em que o contentor hello-app está a escutar.

2. Execute o seguinte comando para obter os detalhes do serviço para 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 para a área de transferência (por exemplo: 203.0.113.0).

   Nota: o aprovisionamento do equilibrador de carga pode demorar alguns minutos. Até o balanceador de carga ser aprovisionado, pode ver um <pending> endereço IP.

Consola

1. Aceda à página Workloads na Google Cloud consola.

   Aceda a Cargas de trabalho

2. Clique em hello-app.

3. Na página Deployment details (Detalhes da implementação), clique em Actions > Expose (Ações > Expor).

4. Na caixa de diálogo Expor, defina a Porta de destino como 8080. Esta é a porta que o contentor hello-app escuta.

5. Na lista pendente Tipo de serviço, selecione Equilibrador de carga.

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

7. Quando o equilibrador de carga estiver pronto, é apresentada a página Detalhes do serviço.

8. Desloque a página para baixo até ao campo Pontos finais externos e copie o endereço IP.

Agora que os hello-apppods estão expostos à Internet através de um serviço Kubernetes, pode abrir um novo separador do navegador e navegar para o endereço IP do serviço que copiou para a área de transferência. É apresentada uma mensagem Hello, World!, juntamente com um campo Hostname. O Hostname corresponde a um dos três hello-app pods que publicam o seu pedido HTTP no seu navegador.

Implemente uma nova versão do hello-app

Nesta secção, atualiza o hello-app para uma nova versão criando e implementando uma nova imagem do Docker no seu cluster do GKE.

A atualização contínua do Kubernetes permite-lhe atualizar as suas implementações sem períodos de inatividade. Durante uma atualização contínua, o cluster do GKE substitui incrementalmente os hello-apppods existentes por pods que contêm a imagem do Docker para a nova versão. Durante a atualização, o serviço de balanceamento de carga encaminha o tráfego apenas para os pods disponíveis.

1. Volte ao Cloud Shell, onde clonou o código fonte da app hello e o Dockerfile. Atualize a função hello() no ficheiro main.go para comunicar a nova versão 2.0.0.

2. Crie e etiquete uma nova imagem do hello-app Docker.

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

3. Envie a imagem para o Artifact Registry.

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

Agora, já pode atualizar a sua implementação do hello-app Kubernetes para usar uma nova imagem do Docker.

Nota: como criou um HorizontalPodAutoscaler anteriormente, o número de hello-app pods em execução nesta secção pode ser inferior aos três pods implementados inicialmente. O seu cluster do GKE pode ter reduzido o número de pods com base na baixa utilização da CPU.

Cloud Shell

1. Aplique uma atualização contínua à hello-app implementação existente com uma atualização de imagem através do comando kubectl set image:

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

2. Veja os pods em execução com a imagem v1 parar e os novos pods em execução com a imagem v2 iniciar.

   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. Num separador separado, navegue novamente para o hello-app-service IP externo. Agora, deve ver o Version definido como 2.0.0.

Consola

1. Aceda à página Workloads na Google Cloud consola.

   Aceda a Cargas de trabalho

2. Clique em hello-app.

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

4. Na caixa de diálogo Atualização contínua, defina o campo Imagem de hello-app como REGION-docker.pkg.dev/PROJECT_ID/hello-repo/hello-app:v2.

5. Clique em Atualizar.

6. Na página Detalhes da implementação, inspecione a secção Revisões ativas. Agora, deve ver duas revisões, 1 e 2. A revisão 1 corresponde à implementação inicial que criou anteriormente. A revisão 2 é a atualização incremental que acabou de iniciar.

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

8. Num separador separado, navegue novamente para o endereço IP do serviço que copiou. O Version deve ser 2.0.0.