GSP1077

Visão geral

O Cloud Build é um serviço que executa seus builds no Google Cloud. Ele pode importar código-fonte, executar builds e muito mais.

Neste laboratório, você vai criar um pipeline de integração e implantação contínuas (CI/CD) que gera automaticamente uma imagem de contêiner com base no código confirmado, 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:

• app: contém o código-fonte do aplicativo
• env: contém os manifestos de implantação do 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. Após enviar a imagem, o Cloud Build atualiza o manifesto de implantação e o envia para o repositório env. 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 env.

Os repositórios app e do env são mantidos separados porque 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. O repositório env pode ser compartilhado por vários aplicativos e é usado por sistemas automatizados (como o Cloud Build). O repositório do env pode ter várias ramificações, cada uma mapeando para um ambiente específico e referenciando uma imagem de contêiner específica, diferente do repositório app.

Ao terminar o laboratório, seu sistema 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 env;
• reverter para qualquer versão anterior, bastando executar novamente o build correspondente do Cloud Build.

Objetivos

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

• Criar clusters do Kubernetes Engine
• Criar repositórios do GitHub.
• Acionar o Cloud Build a partir de repositórios do GitHub.
• 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 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.

Tarefa 1: inicialize o laboratório

Nesta tarefa, você vai configurar o ambiente:

• Importe o ID e o número do projeto como variáveis
• Ative as APIs do GKE, Cloud Build, Secret Manager e Artifact Analysis
• Crie um repositório Docker do Artifact Registry
• Crie um cluster do GKE para implantar o aplicativo de amostra deste laboratório:

1. No Cloud Shell, execute o seguinte comando para definir 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

Em seguida, você vai preparar seu projeto do Google Cloud 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 do GKE, Cloud Build, Secret Manager e Artifact Analysis:

gcloud services enable container.googleapis.com \ cloudbuild.googleapis.com \ secretmanager.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. Execute o comando a seguir para configurar o Git e o GitHub no Cloud Shell: curl -sS https://webi.sh/gh | sh gh auth login gh api user -q ".login" GITHUB_USERNAME=$(gh api user -q ".login") git config --global user.name "${GITHUB_USERNAME}" git config --global user.email "${USER_EMAIL}" echo ${GITHUB_USERNAME} echo ${USER_EMAIL}

Pressione ENTER para aceitar as opções padrão. Leia as instruções na ferramenta CLI para fazer login no GitHub com um navegador da Web. Se já tiver feito login, seu nome de usuário do GitHub vai aparecer.

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

Tarefa 2: criar os repositórios Git nos repositórios do GitHub

O GitHub é uma plataforma onde você armazena, compartilha e trabalha em conjunto com outras pessoas para escrever códigos. O Git é um sistema de controle de versões. Quando você faz upload de arquivos no GitHub, eles são armazenados em um "repositório Git". Isso significa que, quando você faz alterações (ou "commits") nos seus arquivos do GitHub, o Git começa a rastrear e gerenciar suas alterações automaticamente. Para mais detalhes, consulte Sobre o GitHub e o Git.

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

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

gh repo create hello-cloudbuild-app --private gh repo create hello-cloudbuild-env --private

2. Faça o download do exemplo de código do Cloud Storage:

cd ~ mkdir hello-cloudbuild-app gcloud storage cp -r gs://spls/gsp1077/gke-gitops-tutorial-cloudbuild/* hello-cloudbuild-app

3. Configure o repositório do GitHub 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 init git config credential.helper gcloud.sh git remote add google https://github.com/${GITHUB_USERNAME}/hello-cloudbuild-app git branch -m master git add . && git commit -m "initial commit"

O código que você clonou contém um aplicativo simples de "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)

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

Nesta tarefa, com um Dockerfile já criado, você vai usar o Cloud Build para criar e armazenar uma imagem de contêiner.

O código que você clonou anteriormente contém o arquivo Docker:

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, você pode usar o Cloud Build para criar uma imagem de contêiner e armazená-la 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 de contêiner para seu terminal quando você executa esse comando.

2. Quando a build terminar, na barra de título do Google Cloud, digite Artifact Registry no campo Pesquisar e clique em Artifact Registry nos resultados da pesquisa. Verifique se a nova imagem do contêiner está realmente disponível no Artifact Registry. Clique em my-repository para ver a imagem hello-cloudbuild na lista Imagem.

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 repositórios do GitHub aciona o pipeline automaticamente.

O arquivo cloudbuild.yaml, já incluso no código, é a configuração do pipeline.

1. Na barra de título do console, digite gatilhos do Cloud Build no campo Pesquisar e clique em Gatilhos, Cloud Build nos resultados da pesquisa.

2. Clique em Criar gatilho.

3. Em Nome, digite hello-cloudbuild. Para Região, configure .

4. Defina Evento como Enviar para uma ramificação.

5. Em Origem, Repositório, clique em Conectar novo repositório.

   a. Selecione GitHub (app GitHub do Cloud Build). Clique em Continuar.

   b. Autentique o repositório de origem com seu nome de usuário e senha.

   c. Se o pop-up "O app GitHub não está instalado em nenhum dos seus repositórios" aparecer, siga estas etapas.

   i. Clique em **Instalar o Google Cloud Build**. Instale o app GitHub para Cloud Build na sua conta pessoal. Permita a instalação usando a conta do GitHub. ii. Em **Acesso ao repositório**. Escolha **Somente repositórios selecionados**. Clique no menu **Selecionar os repositórios** e selecione `${GITHUB_USERNAME}/hello-cloudbuild-app` and `${GITHUB_USERNAME}/hello-cloudbuild-env`. iii. Clique em **Instalar**

   d. Selecione ${GITHUB_USERNAME}/hello-cloudbuild-app como Repositório. Clique em OK.

   e. Aceite Entendo que o conteúdo do GitHub referente aos repositórios selecionados....

   f. Clique em Conectar.

6. Se o app GitHub do Cloud Build já estiver instalado na sua conta, você terá a opção de Editar repositórios no GitHub.

   a. Em Acesso ao repositório, escolha Somente alguns repositórios. Clique no menu Selecionar repositórios e selecione **$${GITHUB_USERNAME}/hello-cloudbuild-app** e **$${GITHUB_USERNAME}/hello-cloudbuild-env**.

   b. Clique em Salvar.

7. Na página "Gatilho", na lista de repositórios, clique em ${GITHUB_USERNAME}/hello-cloudbuild-app.

8. Para Ramificação, digite .* (qualquer ramificação).

9. Na seção Configuração, defina Tipo como Arquivo de configuração do Cloud Build.

10. No campo Local, digite cloudbuild.yaml depois de /.

11. Defina a Conta de serviço como a conta de serviço padrão do Compute Engine.

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

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

14. No painel à esquerda, clique em Painel.

15. 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: como acessar o GitHub de um build via chaves SSH

Nesta etapa, use o Secret Manager com o Cloud Build para acessar repositórios privados do GitHub.

Criar uma chave SSH

1. No Cloud Shell, mude para o diretório inicial.

   cd ~

2. Crie um novo diretório chamado workingdir e navegue até ele:

   mkdir workingdir cd workingdir

3. Crie uma nova chave SSH do GitHub, substitua [your-github-email] pelo seu endereço de e-mail pessoal do GitHub:

   ssh-keygen -t rsa -b 4096 -N '' -f id_github -C [your-github-email]

Esta etapa cria dois arquivos, id_github e id_github.pub.

4. Na barra de ações do Cloud Shell, clique em Mais () e em Download > Ativar navegador de arquivos. Selecione o menu suspenso e a pasta workingdir para fazer o download do arquivo id_github na sua máquina local.

Armazenar a chave SSH privada no Secret Manager

1. Na barra de título do console, digite Secret Manager e clique em Secret Manager nos resultados da pesquisa.

2. Clique em Criar secret.

3. Defina o Nome como ssh_key_secret.

4. Defina o Valor do secret como Fazer upload e faça upload do arquivo id_github.

5. Mantenha as outras configurações padrão.

6. Clique em Criar secret.

Isso vai fazer upload do arquivo id_github para o Secret Manager.

Adicionar a chave SSH pública às chaves de implantação do repositório particular

1. Faça login na sua conta pessoal do GitHub

2. No canto superior direito, clique na sua foto do perfil e em Seu perfil.

3. Na página do perfil, clique em Repositórios e, em seguida, clique no repositório hello-cloudbuild-env.

4. No seu repositório, clique em Configurações.

5. No painel à esquerda, clique em Chaves de implantação e em Adicionar chave de implantação.

6. Forneça o título SSH_KEY e cole sua chave SSH pública de workingdir/id_github.pub do Cloud Shell.

7. Selecione Permitir acesso de gravação para que essa chave tenha acesso de gravação ao repositório. Uma chave de implantação com acesso de gravação permite que uma implantação seja enviada ao repositório.

8. Clique em Adicionar chave.

9. Exclua a chave SSH do disco:

   rm id_github*

Conceder permissão à conta de serviço para acessar o Secret Manager

Insira o comando a seguir para dar acesso ao Secret Manager à conta de serviço:

gcloud projects add-iam-policy-binding ${PROJECT_NUMBER} \ --member=serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com \ --role=roles/secretmanager.secretAccessor

Clique em Verificar meu progresso para conferir o objetivo. Como acessar o GitHub de um build com chaves SSH

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

Você também pode usar o Cloud Build 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 Desenvolvedor do Cloud Identity and Access Management do Kubernetes Engine.

1. No Cloud Shell, execute o comando a seguir:

cd ~ 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, que ainda está vazia.

2. No Cloud Shell, faça o download do exemplo de código do Cloud Storage:

mkdir hello-cloudbuild-env gcloud storage cp -r gs://spls/gsp1077/gke-gitops-tutorial-cloudbuild/* hello-cloudbuild-env cd hello-cloudbuild-env 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

3. Para que o Cloud Build se conecte ao GitHub, você precisa adicionar a chave SSH pública ao arquivo known_hosts no ambiente de build do Cloud Build. No diretório hello-cloudbuild-env, crie um arquivo chamado known_hosts.github, adicione a chave SSH pública a ele e forneça a permissão necessária ao arquivo:

cd ~/hello-cloudbuild-env ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github git init git config credential.helper gcloud.sh git remote add google https://github.com/${GITHUB_USERNAME}/hello-cloudbuild-env git branch -m master git add . && git commit -m "initial commit" git push google master cd ~/hello-cloudbuild-env git checkout -b production

4. Em seguida, substitua o arquivo cloudbuild.yaml disponível no repositório hello-cloudbuild-env e faça o commit da alteração:

cd ~/hello-cloudbuild-env

5. Substitua o arquivo cloudbuild.yaml no repositório hello-cloudbuild-env pelo código abaixo. Substitua {GITHUB-USERNAME} pelo seu nome de usuário pessoal do GitHub:

# Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # [START cloudbuild-delivery] steps: # This step deploys the new version of our container image # in the hello-cloudbuild Kubernetes Engine cluster. - name: 'gcr.io/cloud-builders/kubectl' id: Deploy args: - 'apply' - '-f' - 'kubernetes.yaml' env: - 'CLOUDSDK_COMPUTE_REGION={{{ project_0.default_region }}}' - 'CLOUDSDK_CONTAINER_CLUSTER=hello-cloudbuild' # Access the id_github file from Secret Manager, and setup SSH - name: 'gcr.io/cloud-builders/git' secretEnv: ['SSH_KEY'] entrypoint: 'bash' args: - -c - | echo "$$SSH_KEY" >> /root/.ssh/id_rsa chmod 400 /root/.ssh/id_rsa cp known_hosts.github /root/.ssh/known_hosts volumes: - name: 'ssh' path: /root/.ssh # Clone the repository - name: 'gcr.io/cloud-builders/git' args: - clone - --recurse-submodules - git@github.com:${GITHUB-USERNAME}/hello-cloudbuild-env.git volumes: - name: ssh path: /root/.ssh # This step copies the applied manifest to the production branch # The COMMIT_SHA variable is automatically # replaced by Cloud Build. - name: 'gcr.io/cloud-builders/gcloud' id: Copy to production branch entrypoint: /bin/sh args: - '-c' - | set -x && \ cd hello-cloudbuild-env && \ git config user.email $(gcloud auth list --filter=status:ACTIVE --format='value(account)') sed "s/GOOGLE_CLOUD_PROJECT/${PROJECT_ID}/g" kubernetes.yaml.tpl | \ git fetch origin production && \ # Switch to the production branch and copy the kubernetes.yaml file from the candidate branch git checkout production && \ git checkout $COMMIT_SHA kubernetes.yaml && \ # Commit the kubernetes.yaml file with a descriptive commit message git commit -m "Manifest from commit $COMMIT_SHA $(git log --format=%B -n 1 $COMMIT_SHA)" && \ # Push the changes back to Cloud Source Repository git push origin production volumes: - name: ssh path: /root/.ssh availableSecrets: secretManager: - versionName: projects/${PROJECT_NUMBER}/secrets/ssh_key_secret/versions/1 env: 'SSH_KEY' # [END cloudbuild-delivery] options: logging: CLOUD_LOGGING_ONLY 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.

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

git checkout -b candidate git push google production git push google candidate

Criar o gatilho do pipeline de entrega contínua

1. Na barra de título do console, digite Gatilhos do Cloud Build e clique em Gatilhos, Cloud Build.

2. Clique em Criar gatilho.

3. Defina Nome como hello-cloudbuild-deploy. Para Região, configure .

4. Em Evento, selecione Enviar para uma ramificação.

5. Em Origem, Repositório, clique em Conectar novo repositório.

   a. Selecione GitHub (app GitHub do Cloud Build). Clique em Continuar.

   b. Autentique o repositório de origem com seu nome de usuário e senha.

   c. Selecione o repositório ${GITHUB_USERNAME}/hello-cloudbuild-env. Clique em OK.

   d. Selecione Entendo que o conteúdo do GitHub referente aos repositórios selecionados…

   e. Clique em Conectar.

6. Em Repositório, selecione ${GITHUB_USERNAME}/hello-cloudbuild-env.

7. Em Origem, selecione ^candidate$ como a Ramificação.

8. Em Configuração do build, selecione Arquivo de configuração do Cloud Build.

9. No campo Local do arquivo de configuração do Cloud Build, digite cloudbuild.yaml depois de /.

10. Defina Conta de serviço como a conta de serviço padrão do Compute Engine.

11. Clique em Criar.

12. No diretório hello-cloudbuild-app, crie um arquivo chamado known_hosts.github, adicione a chave SSH pública a ele e forneça a permissão necessária ao arquivo:

cd ~/hello-cloudbuild-app ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github git add . git commit -m "Adding known_host file." git push google master

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.

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

cd ~/hello-cloudbuild-app

O arquivo cloudbuild.yaml adiciona as etapas que geram o novo manifesto do Kubernetes e acionam o pipeline de entrega contínua.

Configure o build

1. Substitua o arquivo cloudbuild.yaml no repositório hello-cloudbuild-app pelo código abaixo. Substitua ${GITHUB_USERNAME} pelo seu nome de usuário do GitHub:

# Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # [START cloudbuild] steps: # This step runs the unit tests on the app - name: 'python:3.7-slim' id: Test entrypoint: /bin/sh args: - -c - 'pip install flask && python test_app.py -v' # This step builds the container image. - name: 'gcr.io/cloud-builders/docker' id: Build args: - 'build' - '-t' - '{{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:$SHORT_SHA' - '.' # This step pushes the image to Artifact Registry # The PROJECT_ID and SHORT_SHA variables are automatically # replaced by Cloud Build. - name: 'gcr.io/cloud-builders/docker' id: Push args: - 'push' - '{{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:$SHORT_SHA' # [END cloudbuild] # Access the id_github file from Secret Manager, and setup SSH - name: 'gcr.io/cloud-builders/git' secretEnv: ['SSH_KEY'] entrypoint: 'bash' args: - -c - | echo "$$SSH_KEY" >> /root/.ssh/id_rsa chmod 400 /root/.ssh/id_rsa cp known_hosts.github /root/.ssh/known_hosts volumes: - name: 'ssh' path: /root/.ssh # Clone the repository - name: 'gcr.io/cloud-builders/git' args: - clone - --recurse-submodules - git@github.com:${GITHUB-USERNAME}/hello-cloudbuild-env.git volumes: - name: ssh path: /root/.ssh # [START cloudbuild-trigger-cd] # This step clones the hello-cloudbuild-env repository - name: 'gcr.io/cloud-builders/gcloud' id: Change directory entrypoint: /bin/sh args: - '-c' - | cd hello-cloudbuild-env && \ git checkout candidate && \ git config user.email $(gcloud auth list --filter=status:ACTIVE --format='value(account)') volumes: - name: ssh path: /root/.ssh # This step generates the new manifest - name: 'gcr.io/cloud-builders/gcloud' id: Generate manifest entrypoint: /bin/sh args: - '-c' - | sed "s/GOOGLE_CLOUD_PROJECT/${PROJECT_ID}/g" kubernetes.yaml.tpl | \ sed "s/COMMIT_SHA/${SHORT_SHA}/g" > hello-cloudbuild-env/kubernetes.yaml volumes: - name: ssh path: /root/.ssh # This step pushes the manifest back to hello-cloudbuild-env - name: 'gcr.io/cloud-builders/gcloud' id: Push manifest entrypoint: /bin/sh args: - '-c' - | set -x && \ cd hello-cloudbuild-env && \ git add kubernetes.yaml && \ git commit -m "Deploying image {{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:${SHORT_SHA} Built from commit ${COMMIT_SHA} of repository hello-cloudbuild-app Author: $(git log --format='%an <%ae>' -n 1 HEAD)" && \ git push origin candidate volumes: - name: ssh path: /root/.ssh availableSecrets: secretManager: - versionName: projects/${PROJECT_NUMBER}/secrets/ssh_key_secret/versions/1 env: 'SSH_KEY' # [END cloudbuild-trigger-cd] options: logging: CLOUD_LOGGING_ONLY Observação: esse pipeline usa um sed simples para renderizar o modelo do manifesto. Na verdade, é interessante usar uma ferramenta dedicada, como o Kustomize ou o Skaffold, porque elas oferecem mais controle sobre a renderização dos modelos de manifesto.

2. Faça o commit das modificações e envie-as para os respositórios do GitHub:

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 7: analise o pipeline do Cloud Build

Nesta tarefa, você vai analisar o pipeline do Cloud Build no console.

1. No console, ainda na página do Cloud Build, clique em Painel no painel esquerdo.
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 8: teste o pipeline completo

Agora você configurou o pipeline completo de CI/CD. Nesta tarefa, você vai realizar um teste de ponta a ponta.

1. No console, no Menu de navegação (), clique em Kubernetes Engine > Gateways, serviços e entrada > Serviços.

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. Se necessário, clique em Atualizar para atualizar a página.

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 os repositórios do GitHub:

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 9: teste a reversão

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

1. Na barra de título do console, digite Painel do Cloud Build no campo Pesquisar e clique em Cloud Build nos resultados da pesquisa. Verifique se Painel está selecionado no painel à esquerda.
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 19 de fevereiro de 2025

Laboratório testado em 19 de fevereiro de 2025

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 produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.