GSP1077

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 Artifact 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 app, 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.

Os repositórios do app e do ambiente são mantidos separados porque eles têm utilidades e ciclos de vida diferentes. O repositório do app é 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.

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

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o 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, 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 ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

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

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

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, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você verá o seguinte:

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

2. Clique em Abrir Console do Google. O laboratório ativa recursos e depois abre outra guia com a página Fazer login.

   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. Caso seja preciso, copie o Nome de usuário no painel Detalhes do laboratório e cole esse nome na caixa de diálogo Fazer login. Clique em Avançar.

4. Copie a Senha no painel Detalhes do laboratório e a cole na caixa de diálogo Olá. Clique em Avançar.

   Importante: você precisa usar as credenciais do painel à esquerda. Não use suas credenciais do Google Cloud Ensina. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

5. 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 GCP vai ser aberto nesta guia.

Observação: para ver uma lista dos produtos e serviços do Google Cloud, clique no Menu de navegação no canto superior esquerdo.

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.

Depois de se conectar, vai notar 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 YOUR_PROJECT_ID

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

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

gcloud auth list

3. Clique em Autorizar.

4. A saída será parecida com esta:

Saída:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net 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_ID>

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: para conferir a documentação completa da gcloud, acesse o guia com informações gerais sobre a gcloud CLI no Google Cloud.

Tarefa 1: inicialize o laboratório

1. No Cloud Shell, defina o ID e o número do projeto. Salve-os como as variáveis PROJECT_ID e PROJECT_NUMBER:

export PROJECT_ID=$(gcloud config get-value project) export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)') export REGION={{{ project_0.default_region }}} gcloud config set compute/region $REGION

Na próxima 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.

2. Execute o seguinte comando para ativar as APIs para GKE, Cloud Build, Cloud Source Repositories e Container Analysis:

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

3. 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=$REGION

4. Crie um cluster do GKE para implantar o aplicativo de amostra deste laboratório:

gcloud container clusters create hello-cloudbuild --num-nodes 1 --region $REGION

5. Se você nunca usou o Git no Cloud Shell, configure-o com seu nome e endereço de e-mail. O Git usará essas informações para identificar você como autor dos commits que criará no Cloud Shell (se você não tiver uma conta no GitHub, basta preencher esse campo com suas informações atuais. Você não precisa de uma conta para este laboratório):

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

Clique em Verificar meu progresso para conferir o objetivo. Ative os serviços, crie um artifact registry e o cluster do GKE

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

Nesta tarefa, você criará os dois repositórios do Git (hello-cloudbuild-app e hello-cloudbuild-env) e inicializará hello-cloudbuild-app com algum exemplo de código.

1. No Cloud Shell, execute o seguinte para criar os dois repositórios Git:

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

2. Clone o exemplo de código do GitHub:

cd ~ git clone https://github.com/GoogleCloudPlatform/gke-gitops-tutorial-cloudbuild hello-cloudbuild-app

3. Configure o Cloud Source Repositories como remoto:

cd ~/hello-cloudbuild-app export REGION={{{project_0.default_region | "REGION"}}} sed -i "s/us-central1/$REGION/g" cloudbuild.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-delivery.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-trigger-cd.yaml sed -i "s/us-central1/$REGION/g" kubernetes.yaml.tpl PROJECT_ID=$(gcloud config get-value project) 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 os repositórios do Git

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

O código que você clonou já contém o Dockerfile a seguir.

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 Artifact 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="${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 Cloud, acesse Artifact Registry > Repositórios para verificar se a nova imagem de contêiner está realmente disponível no Artifact Registry. Clique em my-repository.

Clique em Verificar meu progresso para conferir o objetivo. Crie a imagem do 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 Artifact Registry. Enviar um novo commit para o Cloud Source Repositories aciona o pipeline automaticamente. O arquivo cloudbuild.yaml, já incluso no código, é a configuração do pipeline.

1. No console do 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 seu Repositório e .* (qualquer ramificação) como sua 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. 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.

9. Para iniciar esse gatilho, execute este comando:

cd ~/hello-cloudbuild-app git add . git commit -m "Digite qualquer mensagem de commit aqui" git push google master

10. No console do Cloud, acesse Cloud Build > Painel.

11. 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 um commit é enviado 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.

Em seguida, 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.

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

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

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

2. No Cloud Shell, execute este comando:

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

3. 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 "Criar cloudbuild.yaml para implantaçã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.

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

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

Criar o gatilho do pipeline de entrega contínua

1. No console do 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. Clique em Criar.

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

Em seguida, adicione algumas etapas ao pipeline de integração contínua para gerar uma nova versão do manifesto do Kubernetes e enviá-lo 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 app:

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.

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 "Acionar pipeline de CD" git push google master

Isso aciona o pipeline de entrega contínua no Cloud Build.

Clique em Verificar meu progresso para conferir o objetivo. Crie o ambiente de teste e o pipeline de CD

Tarefa 6: analise o pipeline do Cloud Build

1. No console do Cloud, acesse Cloud Build > Painel.
2. Clique no gatilho hello-cloudbuild-app para acompanhar a execução e examinar os registros. 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. Faça um teste completo.

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

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

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

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

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

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

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

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

Quando o build estiver concluído, atualize o aplicativo no navegador. Agora você verá "Hello World!" novamente.

Parabéns!

Agora é possível usar o Cloud Build para criar e reverter pipelines de integração contínua com o GKE no Google Cloud!

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em: 26 de janeiro de 2024

Laboratório testado em: 19 de janeiro de 2024

Copyright 2024 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.