GSP188

Visão geral

O Google Kubernetes Engine oferece um ambiente gerenciado para implantação, gerenciamento e escalonamento dos aplicativos conteinerizados usando a infraestrutura do Google. O ambiente do Kubernetes Engine é composto por várias máquinas (instâncias do Compute Engine) agrupadas para formar um cluster.

O Kubernetes contém os mecanismos necessários para interagir com o cluster. Use os comandos e recursos do Kubernetes para implantar e gerenciar os aplicativos, executar tarefas administrativas e definir políticas, além de monitorar a integridade das cargas de trabalho implantadas.

Neste laboratório, você vai implantar o aplicativo de teste no Kubernetes Engine usando os recursos do Google Cloud, como o Cloud Build e o Artifact Registry, além dos recursos do Kubernetes, como implantações, pods e serviços.

O que você vai aprender

Neste laboratório, você aprenderá a fazer o seguinte:

• Criar Dockerfiles para empacotar o código de front-end e back-end do aplicativo de teste para implantação.
• Usar o Cloud Build para produzir imagens Docker.
• Provisionar um cluster do Kubernetes Engine para hospedar o aplicativo de teste.
• Usar implantações do Kubernetes para provisionar pods replicados no Kubernetes Engine.
• Usar um serviço do Kubernetes para provisionar um balanceador de carga para o front-end do teste.

Configuração e requisitos

Antes de clicar no botão Começar o Laboratório

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é ativado quando você clica em Iniciar laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, e não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima (recomendado) ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório: não se esqueça que, depois de começar, não será possível pausar o laboratório.

Observação: use apenas a conta de estudante neste laboratório. Se usar outra conta do Google Cloud, você poderá receber cobranças nela.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar por ele, uma caixa de diálogo vai aparecer para você selecionar a forma de pagamento. No painel Detalhes do Laboratório, à esquerda, você vai encontrar o seguinte:

   • O botão Abrir Console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer Login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Username"}}}

   Você também encontra o nome de usuário no painel Detalhes do Laboratório.

4. Clique em Próxima.

5. Copie a Senha abaixo e cole na caixa de diálogo de Olá.

   {{{user_0.password | "Password"}}}

   Você também encontra a senha no painel Detalhes do Laboratório.

6. Clique em Próxima.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: para acessar os produtos e serviços do Google Cloud, clique no Menu de navegação ou digite o nome do serviço ou produto no campo Pesquisar.

Ativar o Cloud Shell

O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.

2. Clique nas seguintes janelas:

   • Continue na janela de informações do Cloud Shell.
   • Autorize o Cloud Shell a usar suas credenciais para fazer chamadas de APIs do Google Cloud.

Depois de se conectar, você verá que sua conta já está autenticada e que o projeto está configurado com seu Project_ID, . A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

A gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

3. (Opcional) É possível listar o nome da conta ativa usando este comando:

gcloud auth list

4. Clique em Autorizar.

Saída:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Opcional) É possível listar o ID do projeto usando este comando:

gcloud config list project

Saída:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Observação: consulte a documentação completa da gcloud no Google Cloud no guia de visão geral da gcloud CLI.

Iniciar o editor do Cloud Shell

No Cloud Shell, clique em Abrir editor para iniciar o editor de código.

Observação: o editor de código é iniciado em uma guia separada do navegador, junto com o Cloud Shell.

Preparar o aplicativo de teste

Nesta seção, você vai acessar o Cloud Shell, clonar o repositório git que contém o aplicativo de teste, configurar as variáveis de ambiente e executar o aplicativo.

Clonar o código-fonte no Cloud Shell

1. Clique em Abrir terminal e clone o repositório do laboratório:

git clone https://github.com/GoogleCloudPlatform/training-data-analyst

2. Crie um link flexível como atalho para o diretório de trabalho:

ln -s ~/training-data-analyst/courses/developingapps/v1.2/python/kubernetesengine ~/kubernetesengine

Configurar o aplicativo de teste

1. Mude o diretório que contém os exemplos de arquivos deste laboratório:

cd ~/kubernetesengine/start

2. Para substituir a região padrão pela região atribuída pelo laboratório, execute os seguintes comandos:

export APP_REGION={{{project_0.startup_script.app_region | APP_REGION}}} export REGION={{{project_0.default_region | REGION}}} sed -i -e 's/us-central1/'"$REGION"'/g' -e 's/us-central/'"$APP_REGION"'/g' -e 's/python3/'"python3.12"'/g' prepare_environment.sh

3. Configure o aplicativo de teste:

. prepare_environment.sh

Esse arquivo de script faz o seguinte:

• cria um aplicativo do Google App Engine.
• exporta as variáveis de ambiente GCLOUD_PROJECT e GCLOUD_BUCKET.
• atualiza o pip e depois executa pip install -r requirements.txt.
• cria entidades no Google Cloud Datastore.
• cria um tópico do Google Cloud Pub/Sub.
• cria uma instância, um banco de dados e uma tabela do Cloud Spanner.
• exibe o ID do projeto.

O aplicativo de teste estará configurado quando a seguinte mensagem aparecer:

Exemplo de mensagem de saída:

Creating Cloud Pub/Sub topic Created topic [projects/qwiklabs-gcp-92b7e5716e0cbf7e/topics/feedback]. Created subscription [projects/qwiklabs-gcp-92b7e5716e0cbf7e/subscriptions/worker-subscription]. Creating Cloud Spanner Instance, Database, and Table Creating instance...done. Creating database...done. Project ID: qwiklabs-gcp-92b7e5716e0cbf7e

Clique em Verificar meu progresso para conferir o objetivo. Configurar o aplicativo de teste

Revisar o código

Nesta seção, você vai analisar os arquivos do aplicativo.

Use os editores de shell instalados no Cloud Shell, como nano ou vim, ou o editor do Cloud Shell para visualizar e editar arquivos. Este laboratório usa o editor do Cloud Shell.

Analisar o código

• Acesse training-data-analyst/courses/developingapps/v1.2/python/kubernetesengine/start.

A estrutura de pastas do aplicativo de teste representa como ele será implantado no Kubernetes Engine.

O aplicativo da web está em uma pasta chamada frontend.

O código do aplicativo do worker que se registra no Cloud Pub/Sub e processa mensagens está na pasta backend.

Você encontrará arquivos de configuração para o Docker (um Dockerfile nas pastas frontend e backend) e arquivos no formato .yaml do Kubernetes Engine chamados backend-deployment e frontend-deployment.

Criar um cluster do Kubernetes Engine e se conectar a ele

Nesta seção, você vai usar o console do Google Cloud para criar e se conectar a um cluster do Kubernetes Engine.

Criar um cluster do Kubernetes Engine

1. No console, clique em Menu de navegação () > Kubernetes Engine > Clusters.

2. Clique em Criar.

3. Clique em Configurar em Padrão: você gerencia seu cluster e defina os campos a seguir com os valores fornecidos, deixando todos os outros com o valor padrão:

Propriedade	Valor
Nome	quiz-cluster
Zonal
default Pool > Segurança > Escopos de acesso	Selecione Permitir acesso completo a todas as APIs do Cloud

4. Clique em Criar. O provisionamento do cluster leva alguns minutos.

   Clique em Verificar meu progresso para conferir o objetivo. Criar cluster do Kubernetes Engine

Conexão ao cluster

Nesta seção, você vai conectar o aplicativo de teste ao cluster do Kubernetes.

1. Quando o cluster estiver pronto, clique no ícone Ações e selecione Conectar.

2. Em Conexão ao cluster, clique em Executar no Cloud Shell para preencher o Cloud Shell com um comando semelhante a este:

gcloud container clusters get-credentials quiz-cluster --zone {{{project_0.default_zone|ZONE}}} --project {{{project_0.project_id|Project ID}}}

Pressione ENTER para executar o comando no Cloud Shell.

3. Execute o seguinte comando para listar os pods do cluster:

kubectl get pods

A resposta No resources found in default namespace será exibida, já que não há pods no cluster. Isso confirma que você configurou a segurança para permitir que a ferramenta de linha de comando kubectl execute operações no cluster.

Criar um repositório do Docker no Artifact Registry

O Artifact Registry é compatível com o gerenciamento de imagens de contêiner e pacotes de linguagem. Diferentes tipos de artefatos exigem especificações diferentes. Por exemplo, as solicitações de dependências do Maven são diferentes das solicitações de dependências do Node.

Para ser compatível com as diferentes especificações de API, o Artifact Registry precisa saber qual formato você quer que as respostas da API sigam. Para fazer isso, crie um repositório e transmita a flag --repository-format indicando o tipo de repositório desejado.

1. No Cloud Shell, execute o comando a seguir para criar um repositório para imagens do Docker:

gcloud artifacts repositories create container-dev-repo --repository-format=docker \ --location={{{project_0.default_region | REGION}}} \ --description="Docker repository for Container Dev Workshop"

Clique em Autorizar se o comando de autorização do Cloud Shell aparecer.

2. No console do Cloud, acesse Artifact Registry > Repositórios e observe o repositório Docker recém-criado chamado container-dev-repo. Se você clicar nele, vai ver que está vazio no momento.

Clique em Verificar meu progresso para conferir o objetivo.

Criar um repositório do Docker

Criar imagens Docker usando o Cloud Build

Nesta seção, você vai criar um Dockerfile para o front-end e back-end do aplicativo e, em seguida, usar o Cloud Build para criar imagens e armazená-las no Artifact Registry.

Criar o Dockerfile para o front-end e o back-end

1. No editor do Cloud Shell, abra o frontend/Dockerfile.
2. Agora adicione um bloco de código que faça o seguinte:

• insira o comando do Dockerfile para inicializar a criação de uma imagem Docker personalizada usando a imagem do App Engine para Python do Google como ponto de partida.
• escreva os comandos do Dockerfile para ativar um ambiente virtual.
• escreva o comando do Dockerfile para executar pip install como parte do processo de build.
• escreva o comando do Dockerfile para adicionar conteúdo da pasta atual ao caminho /app no contêiner.
• finaliza o Dockerfile ao inserir a declaração gunicorn ..., executada quando o contêiner é iniciado. O Gunicorn (Green Unicorn) é um servidor HTTP compatível com a especificação para Python da interface de gateway do servidor da web (WSGI).

Copie e cole o comando a seguir no Dockerfile:

FROM gcr.io/google_appengine/python RUN virtualenv -p python3.7 /env ENV VIRTUAL_ENV /env ENV PATH /env/bin:$PATH ADD requirements.txt /app/requirements.txt RUN pip install -r /app/requirements.txt ADD . /app CMD gunicorn -b 0.0.0.0:$PORT quiz:app

3. Abra o arquivo backend/Dockerfile. Depois copie e cole este código:

FROM gcr.io/google_appengine/python RUN virtualenv -p python3.7 /env ENV VIRTUAL_ENV /env ENV PATH /env/bin:$PATH ADD requirements.txt /app/requirements.txt RUN pip install -r /app/requirements.txt ADD . /app CMD python -m quiz.console.worker

Criar imagens Docker com o Cloud Build

1. No Cloud Shell, confirme que você está na pasta start:

cd ~/kubernetesengine/start

2. Execute o comando a seguir para criar a imagem Docker de front-end:

gcloud builds submit -t {{{project_0.default_region | REGION}}}-docker.pkg.dev/{{{project_0.project_id|Project ID}}}/container-dev-repo/quiz-frontend:v1 ./frontend/

Aqui, a imagem Docker é criada e armazenada no Artifact Registry. Isso pode demorar alguns minutos.

Ignore as mensagens de incompatibilidade que aparecerão com os resultados.

3. Agora, execute o seguinte comando para criar a imagem Docker de back-end:

gcloud builds submit -t {{{project_0.default_region | REGION}}}-docker.pkg.dev/{{{project_0.project_id|Project ID}}}/container-dev-repo/quiz-backend:v1 ./backend/

Quando a imagem Docker de back-end estiver pronta, estas últimas mensagens serão exibidas:

DONE --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ID: 97a3648f-5229-49ef-9c93-a33dbdb421f3 CREATE_TIME: 2024-12-16T13:29:57+00:00 DURATION: 2M10S SOURCE: gs://qwiklabs-gcp-03-2cae39dd1d7c_cloudbuild/source/1734355794.276254-1b5d85622afb4360910a164f9f29734d.tgz IMAGES: us-east1-docker.pkg.dev/qwiklabs-gcp-03-2cae39dd1d7c/container-dev-repo/quiz-backend:v1 STATUS: SUCCESS

4. No console, no menu de navegação, clique em Artifact Registry e selecione container-dev-repo. Dois pods serão exibidos: quiz-frontend e quiz-backend.

5. Clique em quiz-frontend.

Observação: o nome da imagem e as tags (mais recentes) serão exibidos.

Clique em Verificar meu progresso para conferir o objetivo. Criar imagens Docker usando o Cloud Build

Criar recursos de implantação e serviço do Kubernetes

Nesta seção, você vai modificar os arquivos de modelo yaml, que contêm a especificação dos recursos de implantação e serviço do Kubernetes, e criar os recursos no cluster do Kubernetes Engine.

Criar um arquivo de implantação do Kubernetes

1. No editor do Cloud Shell, abra o arquivo frontend-deployment.yaml.

Observação: o esqueleto do arquivo já foi criado para você. Agora substitua os marcadores de posição pelos valores do projeto.

2. Substitua os marcadores no arquivo frontend-deployment.yaml usando os seguintes valores:

Nome do marcador de posição	Valor
[GCLOUD_PROJECT]	ID do projeto (confira o ID do projeto digitando echo $GCLOUD_PROJECT no Cloud Shell)
[GCLOUD_BUCKET]	Nome do bucket do Cloud Storage para o bucket de mídia do projeto (mostre o nome do bucket digitando echo $GCLOUD_BUCKET no Cloud Shell)
[FRONTEND_IMAGE_IDENTIFIER]	A imagem de front-end identificada no formato [REGION]-docker.pkg.dev/[Project_ID]/container-dev-repo/quiz-frontend:v1

Observação: a implantação do quiz-frontend provisiona três réplicas da imagem Docker de front-end nos pods do Kubernetes, distribuídas nos três nós do cluster do Kubernetes Engine.

3. Salve o arquivo.
4. Substitua os marcadores de posição no arquivo backend-deployment.yaml pelos seguintes valores:

Nome do marcador de posição	Valor
[GCLOUD_PROJECT]	ID do projeto
[GCLOUD_BUCKET]	ID do bucket do Cloud Storage para o bucket de mídia do projeto
[BACKEND_IMAGE_IDENTIFIER]	A imagem de back-end identificada no formato [REGION]-docker.pkg.dev/[Project_ID]/container-dev-repo/quiz-backend:v1

Observação: a implantação do quiz-backend provisiona duas réplicas da imagem Docker de back-end nos pods do Kubernetes, distribuídas em dois dos três nós do cluster do Kubernetes Engine.

5. Salve o arquivo.
6. Revise o conteúdo do arquivo frontend-service.yaml.

Observação: o serviço mostra a implantação do front-end usando um balanceador de carga. O balanceador de carga envia solicitações de clientes para as três réplicas do pod de front-end.

Executar os arquivos de implantação e serviço

1. No Cloud Shell, provisione a implantação do front-end do teste:

kubectl create -f ./frontend-deployment.yaml

2. Provisione a implantação do back-end do teste:

kubectl create -f ./backend-deployment.yaml

3. Provisione o serviço do front-end do teste:

kubectl create -f ./frontend-service.yaml Observação: cada comando provisiona recursos no Kubernetes Engine. O processo leva alguns minutos para ser concluído.

Clique em Verificar meu progresso para conferir o objetivo. Criar recursos de implantação e serviço do Kubernetes

Testar o aplicativo de teste

Nesta seção, você vai revisar os pods e o serviço implantados e acessar o aplicativo de teste.

Revisar os recursos implantados

1. No menu de navegação do console, clique em Kubernetes Engine.
2. Clique em Cargas de trabalho no menu à esquerda.

Observação: os dois contêineres, "quiz-frontend" e "quiz-backend", serão exibidos. Talvez apareça que o status está OK ou que está em processo de criação.

Se o status de um ou dos dois contêineres for Não há disponibilidade mínima, atualize a janela.

3. Clique em quiz-frontend. Na seção Pods gerenciados, há três pods "quiz-frontend".

4. Ao final da seção Como expor serviços, procure a seção Endpoints, copie o endereço IP e cole-o no campo URL de uma nova guia ou janela do navegador:

5. Essa ação abrirá o aplicativo de teste. Isso indica que você implantou o aplicativo corretamente. Você pode encerrar o laboratório aqui ou usar o restante do tempo para criar alguns testes.

Observação: se aparecer um pop-up avisando que a conexão com o site não é segura, clique em Ir para o site.

Parabéns!

Aqui termina o laboratório autoguiado "Desenvolvimento de aplicativos: como implantar aplicativos no Kubernetes Engine – Python". Você usou recursos do Google Cloud e do Kubernetes para implantar um aplicativo de teste.

Próximas etapas / Saiba mais

Saiba mais sobre o Kubernetes Engine.

Manual atualizado em 24 de setembro de 2025

Laboratório testado em 24 de setembro de 2025

Copyright 2026 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.