Visão geral

Neste laboratório, você vai criar um pipeline de CI/CD que gera automaticamente uma imagem de contêiner com base no código com commit, armazena a imagem no Container Registry, atualiza um manifesto do Kubernetes em um repositório Git e implanta o aplicativo no Google Kubernetes Engine usando esse manifesto.

Você vai criar dois repositórios Git:

• Repositório do aplicativo: contém o código-fonte do próprio aplicativo.
• Repositório do ambiente: contém os manifestos para a implantação no Kubernetes.

Quando você envia uma alteração para o repositório do aplicativo, o pipeline do Cloud Build executa testes, cria uma imagem de contêiner e a envia para o Artifact Registry. Depois de enviar a imagem, o Cloud Build atualiza o manifesto de implantação e o envia para o repositório do ambiente. Isso aciona outro pipeline do Cloud Build, que aplica o manifesto ao cluster do GKE e, se bem-sucedido, armazena o manifesto em outra ramificação do repositório do ambiente.

Mantemos os repositórios do aplicativo e do ambiente separados, porque eles têm utilidades e ciclos de vida diferentes. O repositório do aplicativo é dedicado a um aplicativo específico e é usado principalmente por pessoas reais. Por outro lado, os principais usuários do repositório do ambiente são sistemas automatizados, como o Cloud Build, e ele pode ser compartilhado por vários aplicativos. O repositório do ambiente pode ter várias ramificações, cada uma associada a um ambiente específico, que referenciam uma imagem de contêiner específica, o que não acontece com o repositório do aplicativo. Neste laboratório, você vai usar apenas o ambiente de produção.

Ao terminar o laboratório, você terá um sistema em que poderá:

• Distinguir entre implantações com falha e bem-sucedidas ao analisar o histórico do Cloud Build;
• Acessar o manifesto usado atualmente ao analisar a ramificação de produção do repositório do ambiente;
• Reverter para qualquer versão anterior, bastando executar novamente o build correspondente do Cloud Build.

Observação: vamos usar o Cloud Build para executar os pipelines, mas há outras ferramentas conhecidas de automação de criação que podem ser usadas como alternativa, como o Spinnaker e o Jenkins. No momento, algumas dessas ferramentas têm compatibilidade superior com implantações azul-verde, análise de teste canário e recursos semelhantes que podem ser necessários em implementações de CI/CD mais avançadas.

Objetivos

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

• Criar clusters do Kubernetes Engine
• Criar Cloud Source Repositories
• Acionar o Cloud Build a partir de Cloud Source Repositories
• Automatizar testes e publicar uma imagem de contêiner implantável por meio do Cloud Build
• Gerenciar recursos implantados em um cluster do Kubernetes Engine pelo Cloud Build

Configuração e requisitos

Acesse o Qwiklabs

Para cada laboratório, você recebe um novo projeto do Google Cloud e um conjunto de recursos por um determinado período e sem custos financeiros.

1. Faça login no Qwiklabs em uma janela anônima.

2. Confira o tempo de acesso do laboratório (por exemplo, 1:15:00) e finalize todas as atividades nesse prazo.
   Não é possível pausar o laboratório. Você pode reiniciar o desafio, mas vai precisar refazer todas as etapas.

3. Quando tudo estiver pronto, clique em Começar o laboratório.

4. Anote as credenciais (Nome de usuário e Senha). É com elas que você vai fazer login no Console do Google Cloud.

5. Clique em Abrir Console do Google.

6. Clique em Usar outra conta, depois copie e cole as credenciais deste laboratório nos locais indicados.
   Se você usar outras credenciais, vai receber mensagens de erro ou cobranças.

7. Aceite os termos e pule a página de recursos de recuperação.

Depois que você concluir as etapas iniciais de login, o painel do projeto será exibido.

Ative o Google Cloud Shell

O Google Cloud Shell é uma máquina virtual com 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. No console do Cloud, clique no botão "Abrir o Cloud Shell" na barra de ferramentas superior direita.

   

2. Clique em Continuar.

O provisionamento e a conexão do ambiente podem demorar um pouco. Quando você estiver conectado, já estará autenticado, e o projeto estará definido com seu PROJECT_ID. Exemplo:

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

• Para listar o nome da conta ativa, use este comando:

gcloud auth list

Saída:

Credentialed accounts: - @.com (active)

Exemplo de saída:

Credentialed accounts: - google1623327_student@qwiklabs.net

• Para listar o ID do projeto, use este comando:

gcloud config list project

Saída:

[core] project =

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: a documentação completa da gcloud está disponível no guia com informações gerais sobre a gcloud CLI .

Tarefa 1: inicialize o laboratório

Nesta tarefa, você vai preparar seu projeto do Google Cloud para uso ao ativar as APIs necessárias, inicializar a configuração do Git no Cloud Shell e fazer o download do exemplo de código que será usado mais adiante no laboratório.

1. No Cloud Shell, execute este comando para ativar as APIs do GKE, do Cloud Build, do Cloud Source Repositories e do Container Analysis:

gcloud services enable container.googleapis.com \ cloudbuild.googleapis.com \ sourcerepo.googleapis.com \ containeranalysis.googleapis.com

2. Crie um repositório Docker do Artifact Registry chamado my-repository na região para armazenar as imagens de contêiner:

gcloud artifacts repositories create my-repository \ --repository-format=docker \ --location={{{project_0.default_region | REGION}}}

3. Ainda no Cloud Shell, crie um cluster do GKE para implantar o aplicativo de amostra deste laboratório:

gcloud container clusters create hello-cloudbuild \ --num-nodes 1 --region {{{project_0.default_region | REGION}}}

4. Se você nunca usou o Git no Cloud Shell, configure-o com seu nome e endereço de e-mail:

git config --global user.email "voce@exemplo.com" git config --global user.name "Seu nome"

O Git vai usar essas informações para identificar você como autor dos commits que serão criados no Cloud Shell.

Clique em Verificar meu progresso para conferir o objetivo. Inicialize o laboratório

Tarefa 2: crie repositórios Git no Cloud Source Repositories

Nesta tarefa, você vai criar os dois repositórios Git (hello-cloudbuild-app e hello-cloudbuild-env) usados neste laboratório e inicializar o hello-cloudbuild-app com um exemplo de código.

1. No Cloud Shell, crie os dois repositórios Git:

gcloud source repos create hello-cloudbuild-app gcloud source repos create hello-cloudbuild-env

2. Clone o repositório hello-cloudbuild-app.

PROJECT_ID=$(gcloud config get-value project) gcloud source repos clone hello-cloudbuild-app --project=$PROJECT_ID

3. Para copiar o exemplo de código do Cloud Storage e extrair o conteúdo do arquivo para o diretório inicial, execute os seguintes comandos:

cd ~ gcloud storage cp gs://cloud-training/gke-gitops/hello-cloudbuild-app.zip ~ && unzip ~/hello-cloudbuild-app.zip -d ~ && rm ~/hello-cloudbuild-app.zip

3. Configure o Cloud Source Repositories como remoto:

cd ~/hello-cloudbuild-app REGION={{{project_0.default_region | REGION}}} sed -i s/us-central1/$REGION/g cloudbuild.yaml sed -i s/us-central1/$REGION/g cloudbuild-trigger-cd.yaml sed -i s/us-central1/$REGION/g cloudbuild-delivery.yaml sed -i s/us-central1/$REGION/g kubernetes.yaml.tpl git init git add . git commit -m "first commit" git remote add google \ "https://source.developers.google.com/p/${PROJECT_ID}/r/hello-cloudbuild-app"

O código que você clonou contém um aplicativo simples "Hello World":

from flask import Flask app = Flask('hello-cloudbuild') @app.route('/') def hello(): return "Hello World!\n" if __name__ == '__main__': app.run(host = '0.0.0.0', port = 8080)

Clique em Verificar meu progresso para conferir o objetivo. Crie repositórios Git no Cloud Source Repositories

Tarefa 3: crie uma imagem de contêiner com o Cloud Build

O código que você clonou já contém o seguinte Dockerfile:

FROM python:3.7-slim RUN pip install flask WORKDIR /app COPY app.py /app/app.py ENTRYPOINT ["python"] CMD ["/app/app.py"]

Com esse Dockerfile, crie uma imagem de contêiner com o Cloud Build e armazene-a no Container Registry.

1. No Cloud Shell, crie um build do Cloud Build com base no commit mais recente usando o comando abaixo:

cd ~/hello-cloudbuild-app COMMIT_ID="$(git rev-parse --short=7 HEAD)" gcloud builds submit --tag="{{{project_0.default_region | REGION}}}-docker.pkg.dev/${PROJECT_ID}/my-repository/hello-cloudbuild:${COMMIT_ID}" .

O Cloud Build faz o streaming dos registros gerados pela criação da imagem do contêiner para seu terminal quando você executa esse comando.

2. Após a conclusão da criação, no console do Google Cloud, acesse Artifact Registry > Repositórios para verificar se a nova imagem de contêiner está realmente disponível no Artifact Registry.

3. Clique em my-repository.

Clique em Verificar meu progresso para conferir o objetivo. Crie uma imagem de contêiner com o Cloud Build

Tarefa 4: crie o pipeline de integração contínua (CI)

Nesta tarefa, você vai configurar o Cloud Build para executar automaticamente um teste de unidade pequeno, criar a imagem do contêiner e enviá-la para o Container Registry. Enviar uma confirmação nova para o Cloud Source Repositories aciona automaticamente o pipeline. O arquivo cloudbuild.yaml, já incluso no código, é a configuração do pipeline.

1. No Console do Google Cloud, acesse Cloud Build > Gatilhos.
2. Clique em Criar gatilho.
3. No campo "Nome", digite hello-cloudbuild.
4. Em Evento, selecione Enviar para uma ramificação.
5. Em Origem, selecione hello-cloudbuild-app como o Repositório e digite ^master$ na Ramificação.
6. Em Configuração do build, selecione Arquivo de configuração do Cloud Build.
7. No campo Local do arquivo de configuração do Cloud Build, digite cloudbuild.yaml depois de /.
8. Em Conta de serviço, selecione a conta de serviço que começa com seu ID do projeto semelhante a (@.iam.gserviceaccount.com).
9. Clique em Criar.

Depois que o gatilho for criado, volte ao Cloud Shell. Envie o código do aplicativo para o Cloud Source Repositories para acionar o pipeline de CI no Cloud Build.

10. Para iniciar esse gatilho, execute este comando:

cd ~/hello-cloudbuild-app git push google master

11. No console do Google Cloud, acesse Cloud Build > Painel.

Você verá um build em execução ou finalizado recentemente.

Se quiser, clique no build para acompanhar a execução e analisar os registros.

Clique em Verificar meu progresso para conferir o objetivo. Crie o pipeline de integração contínua (CI)

Tarefa 5: crie o ambiente de teste e o pipeline de CD

O Cloud Build também é usado para o pipeline de entrega contínua. Esse pipeline é executado sempre que uma confirmação é enviada para a ramificação de candidato do repositório __hello-cloudbuild-env__. O pipeline aplica a versão nova do manifesto ao cluster do Kubernetes e, se bem-sucedido, copia o manifesto para a ramificação de produção. Esse processo tem as seguintes propriedades:

• A ramificação de candidato é um histórico das tentativas de implantação.
• A ramificação de produção é um histórico das implantações bem-sucedidas.
• É possível ver as implantações bem-sucedidas e com falha no Cloud Build.
• É possível reverter para qualquer implantação anterior, bastando executar novamente o build correspondente no Cloud Build. A reversão também atualiza a ramificação de produção para refletir fielmente o histórico de implantações.

Você vai modificar o pipeline de integração contínua para atualizar a ramificação de candidato do repositório hello-cloudbuild-env, acionando o pipeline de entrega contínua.

Conceda ao Cloud Build acesso ao GKE

Para implantar o aplicativo no seu cluster do Kubernetes, o Cloud Build precisa do papel de Desenvolvedor do Identity and Access Management para o Kubernetes Engine.

• No Cloud Shell, execute este comando:

PROJECT_NUMBER="$(gcloud projects describe ${PROJECT_ID} --format='get(projectNumber)')" gcloud projects add-iam-policy-binding ${PROJECT_NUMBER} \ --member=serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com \ --role=roles/container.developer

Inicialize o repositório hello-cloudbuild-env

É necessário inicializar o repositório hello-cloudbuild-env com duas ramificações (produção e candidato) e um arquivo de configuração do Cloud Build que descreve o processo de implantação.

A primeira etapa é clonar o repositório hello-cloudbuild-env e criar a ramificação de produção. Ele ainda estará vazio.

1. No Cloud Shell, execute este comando:

cd ~ gcloud source repos clone hello-cloudbuild-env cd ~/hello-cloudbuild-env git checkout -b production

2. Depois copie o arquivo cloudbuild-delivery.yaml disponível no repositório hello-cloudbuild-app e faça o commit da alteração:

cd ~/hello-cloudbuild-env cp ~/hello-cloudbuild-app/cloudbuild-delivery.yaml ~/hello-cloudbuild-env/cloudbuild.yaml git add . git commit -m "Create cloudbuild.yaml for deployment" . Observação: o arquivo "cloudbuild-delivery.yaml" descreve o processo de implantação a ser executado no Cloud Build.

Isso é feito em duas etapas:

• O Cloud Build aplica o manifesto no cluster do GKE.
• Se bem-sucedido, o Cloud Build copia o manifesto na ramificação de produção.

3. Crie uma ramificação de candidato e envie as duas ramificações para que fiquem disponíveis no Cloud Source Repositories:

git checkout -b candidate git push origin production git push origin candidate

4. Conceda o papel de Gravador de repositório de código-fonte do IAM à conta de serviço do Cloud Build para o repositório hello-cloudbuild-env:

PROJECT_NUMBER="$(gcloud projects describe ${PROJECT_ID} \ --format='get(projectNumber)')" cat >/tmp/hello-cloudbuild-env-policy.yaml <<EOF bindings: - members: - serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com role: roles/source.writer EOF gcloud source repos set-iam-policy \ hello-cloudbuild-env /tmp/hello-cloudbuild-env-policy.yaml

Clique em Verificar meu progresso para conferir o objetivo. Conceda os papéis de Desenvolvedor do Kubernetes Engine e de Gravador do repositório de origem do IAM ao Cloud Build

Crie o gatilho do pipeline de entrega contínua

1. No Console do Google Cloud, acesse Cloud Build > Gatilhos.
2. Clique em Criar gatilho.
3. No campo "Nome", digite hello-cloudbuild-deploy.
4. Em Evento, selecione Enviar para uma ramificação.
5. Em Origem, selecione hello-cloudbuild-env como o Repositório e ^candidate$ como a Ramificação.
6. Em Configuração do build, selecione Arquivo de configuração do Cloud Build.
7. No campo Local do arquivo de configuração do Cloud Build, digite cloudbuild.yaml depois de /.
8. Em Conta de serviço, selecione a conta de serviço que começa com seu ID do projeto semelhante a (@.iam.gserviceaccount.com).
9. Clique em Criar.

Modifique o pipeline de integração contínua para acionar o pipeline de entrega contínua

Nesta seção, você vai adicionar algumas etapas ao pipeline de integração contínua que vão gerar uma nova versão do manifesto do Kubernetes. Depois disso, vai enviar esse manifesto para o repositório __hello-cloudbuild-env__ a fim de acionar o pipeline de entrega contínua.

1. Copie a versão estendida do arquivo cloudbuild.yaml para o repositório do aplicativo:

cd ~/hello-cloudbuild-app cp cloudbuild-trigger-cd.yaml cloudbuild.yaml

O arquivo cloudbuild-trigger-cd.yaml é uma versão estendida do cloudbuild.yaml. Com ele, as etapas a seguir são adicionadas para gerar o novo manifesto do Kubernetes e acionar o pipeline de entrega contínua.

Observação: esse pipeline usa um sed simples para renderizar o modelo de manifesto. Na verdade, é interessante usar uma ferramenta dedicada, como o Kustomize ou o Skaffold. Elas oferecem mais controle sobre a renderização dos modelos de manifesto.

2. Faça o commit das modificações e envie-as para o Cloud Source Repositories:

cd ~/hello-cloudbuild-app git add cloudbuild.yaml git commit -m "Trigger CD pipeline" git push google master

Isso aciona o pipeline de integração contínua no Cloud Build.

Clique em Verificar meu progresso para conferir o objetivo. Crie o gatilho do pipeline de entrega contínua

Tarefa 6: analise o pipeline do Cloud Build

1. No Console do Google Cloud, acesse Cloud Build > Painel.
2. Clique no gatilho hello-cloudbuild-app para acompanhar a execução e examinar os logs.

A última etapa desse pipeline envia o manifesto novo para o repositório hello-cloudbuild-env, que aciona o pipeline de entrega contínua.

3. Volte para o Painel principal.
4. Você verá um build do repositório hello-cloudbuild-env em execução ou finalizado recentemente. Se quiser, clique no build para acompanhar a execução e analisar os registros.

Tarefa 7: teste o pipeline completo

O pipeline de CI/CD completo está configurado. Nesta seção, você vai testar o pipeline inteiro.

1. No console do Google Cloud, acesse Kubernetes Engine > Gateways, serviços e entrada.

2. Selecione Serviços no menu superior.

Provavelmente haverá um único serviço chamado hello-cloudbuild na lista. Ele foi criado pelo build de entrega contínua recém-executado.

3. Clique no endpoint do serviço hello-cloudbuild.

Você verá "Hello World!". Se não houver um endpoint ou ocorrer um erro no balanceador de carga, pode ser necessário aguardar alguns minutos até que o balanceador de carga seja totalmente inicializado. Clique em "Atualizar" para atualizar a página, se necessário.

4. No Cloud Shell, substitua "Hello World" por "Hello Cloud Build" no aplicativo e no teste de unidade:

cd ~/hello-cloudbuild-app sed -i 's/Hello World/Hello Cloud Build/g' app.py sed -i 's/Hello World/Hello Cloud Build/g' test_app.py

5. Faça o commit e envie a alteração para o Cloud Source Repositories:

git add app.py test_app.py git commit -m "Hello Cloud Build" git push google master

6. Isso aciona o pipeline de CI/CD inteiro.

Após alguns minutos, atualize o aplicativo no seu navegador. Agora você verá "Hello Cloud Build!".

Clique em Verificar meu progresso para conferir o objetivo. Teste o pipeline completo

Tarefa 8: teste a reversão

Nesta tarefa, você vai voltar para a versão do aplicativo que dizia "Hello World!".

1. No Console do Google Cloud, acesse Cloud Build > Painel.

2. Clique no link Ver tudo em Histórico de builds para encontrar o repositório hello-cloudbuild-env.

3. Clique no segundo build mais recente disponível.

4. Clique em Tentar recriar.

5. Quando o build estiver concluído, atualize o aplicativo no navegador.

Agora você verá "Hello World!" novamente.

Clique em Verificar meu progresso para conferir o objetivo. Teste a reversão

Finalize o laboratório

Clique em Terminar o laboratório após a conclusão. O Google Cloud Ensina remove os recursos usados e limpa a conta por você.

Você vai poder avaliar sua experiência no laboratório. Basta selecionar o número de estrelas, digitar um comentário e clicar em Enviar.

O número de estrelas indica o seguinte:

• 1 estrela = muito insatisfeito
• 2 estrelas = insatisfeito
• 3 estrelas = neutro
• 4 estrelas = satisfeito
• 5 estrelas = muito satisfeito

Feche a caixa de diálogo se não quiser enviar feedback.

Para enviar seu feedback, fazer sugestões ou correções, use a guia Suporte.

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