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

Neste laboratório, você vai usar dois repositórios Git hospedados em um servidor Git Gitea auto-hospedado dedicado (git-server):

• app: contém o código-fonte do aplicativo (hello-cloudbuild-app)
• env: contém os manifestos de implantação do Kubernetes (hello-cloudbuild-env)

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.
• Conectar-se a um servidor Git dedicado e inicializar repositórios Git.
• Executar pipelines do Cloud Build de repositórios de código-fonte.
• 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 laboratório. Se for preciso pagar por ele, uma caixa de diálogo vai aparecer para você selecionar a forma de pagamento. À direita, você encontra o painel Configuração e acesso ao laboratório com as seguintes informações:

   • O botão Abrir console do Google Cloud
   • As credenciais temporárias (nome de usuário e senha) que você vai usar no laboratório
   • Outros dados, se necessários

   O timer do laboratório fica na parte de cima da página e mostra o tempo restante.

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 "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 Login.

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

   Você também encontra o nome de usuário no painel Configuração e acesso ao laboratório.

4. Clique em Avançar.

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

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

   Você também encontra a senha no painel Configuração e acesso ao laboratório.

6. Clique em Avançar.

   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, talvez 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 sem custo financeiro.

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: inicializar o laboratório

Nesta tarefa, você vai configurar o ambiente:

• Importe o ID do projeto, o número do projeto e o IP do servidor Git 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 do projeto, o número do projeto e a região:

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 export GIT_SERVER_IP=$(gcloud compute instances describe git-server --zone={{{ project_0.default_zone }}} --format='get(networkInterfaces[0].accessConfigs[0].natIP)') echo "Git Server IP is: ${GIT_SERVER_IP}"

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 seguinte comando para configurar o Git no Cloud Shell: git config --global user.name "giteaadmin" git config --global user.email "student@qwiklabs.net"

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

Tarefa 2: conectar-se aos repositórios Git no servidor Git

Nesta tarefa, você vai inicializar os dois repositórios Git (hello-cloudbuild-app e hello-cloudbuild-env) no seu servidor Git dedicado (git-server) e enviar o exemplo de código inicial.

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

cd ~ git clone http://${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git

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: criar 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.11-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 o build terminar, na barra de título do console 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: criar e executar o pipeline de integração contínua (CI)

Nesta tarefa, você vai configurar e executar o Cloud Build para executar automaticamente testes de unidade, criar a imagem do contêiner e enviá-la para o Artifact Registry.

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

1. Confirme as mudanças e envie-as para o servidor Git:

cd ~/hello-cloudbuild-app git add . git commit -m "Trigger CI pipeline" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git main

2. Envie o build para o Cloud Build usando o seguinte comando:

gcloud builds submit --config=cloudbuild.yaml --substitutions=SHORT_SHA=$(git rev-parse --short=7 HEAD) .

3. No console do Google Cloud, pesquise Cloud Build e clique em Histórico no painel esquerdo. É possível examinar o registro de execução do seu build de CI.

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

Tarefa 5: armazenar o secret da chave SSH no Secret Manager

Nesta etapa, você armazena um secret de chave privada no Secret Manager e concede permissões do Cloud Build para acessar o Secret Manager.

Criar uma chave SSH e armazená-la no Secret Manager

1. No Cloud Shell, crie uma chave SSH:

   mkdir -p ~/workingdir && cd ~/workingdir ssh-keygen -t rsa -b 4096 -N '' -f id_rsa -C "student@qwiklabs.net"

2. Armazene a chave SSH privada no Secret Manager executando o seguinte comando no Cloud Shell:

gcloud secrets create ssh_key_secret --data-file=$HOME/workingdir/id_rsa

Como alternativa, no console do Google Cloud: a. Primeiro, faça o download de id_rsa para seu computador: no Cloud Shell, clique em Mais () > Fazer download do arquivo, insira workingdir/id_rsa e clique em Fazer download. b. Pesquise Secret Manager e clique em Secret Manager. c. Clique em Criar secret. d. Defina o Nome como ssh_key_secret. e. Em Valor do secret, selecione Fazer upload e faça upload do arquivo id_rsa que você baixou. f. Clique em Criar secret.

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

Execute o seguinte comando no Cloud Shell para conceder à conta de serviço padrão do Compute Engine permissão para acessar o Secret Manager:

PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format='value(projectNumber)') 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. Armazenar o secret da chave SSH no Secret Manager

Tarefa 6: criar 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 de Desenvolvedor do Kubernetes Engine.

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

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.

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

cd ~ git clone http://${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git

3. No Cloud Shell, substitua o conteúdo de cloudbuild.yaml no repositório hello-cloudbuild-env executando o seguinte comando:

cd ~/hello-cloudbuild-env cat <<'EOF' > cloudbuild.yaml # 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. substitutions: _COMMIT_SHA: 'v1.0' 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' # This step copies the applied manifest to the production branch - name: 'gcr.io/cloud-builders/gcloud' id: Copy to production branch entrypoint: /bin/sh args: - '-c' - | set -x && \ git clone -b production http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git prod_repo && \ cd prod_repo && \ git config user.email "student@qwiklabs.net" && \ git config user.name "Cloud Build" && \ cp ../kubernetes.yaml kubernetes.yaml && \ git add kubernetes.yaml && \ git commit -m "Deployed manifest from commit $_COMMIT_SHA" && \ git push origin production options: logging: CLOUD_LOGGING_ONLY EOF sed -i "s/\${GIT_SERVER_IP}/$GIT_SERVER_IP/g" cloudbuild.yaml

Confirme e envie a atualização para hello-cloudbuild-env:

cd ~/hello-cloudbuild-env git checkout candidate git add cloudbuild.yaml git commit -m "Create cloudbuild.yaml for deployment" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git candidate

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

Em seguida, atualize o pipeline de integração contínua em hello-cloudbuild-app para gerar uma nova versão do manifesto do Kubernetes e enviá-lo para hello-cloudbuild-env para acionar o pipeline de CD.

1. No Cloud Shell, substitua cloudbuild.yaml em hello-cloudbuild-app e substitua o IP do servidor Git executando os seguintes comandos:

cd ~/hello-cloudbuild-app cat <<'EOF' > cloudbuild.yaml # 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. substitutions: _SHORT_SHA: 'v1.0' _COMMIT_SHA: 'v1.0' steps: # This step runs the unit tests on the app - name: 'python:3.11-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 - 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' # This step clones the hello-cloudbuild-env repository - name: 'gcr.io/cloud-builders/gcloud' id: Clone env repo entrypoint: /bin/sh args: - '-c' - | git clone http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git && \ cd hello-cloudbuild-env && \ git checkout candidate && \ git config user.email "student@qwiklabs.net" && \ git config user.name "Cloud Build" # 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 # This step pushes the manifest back to hello-cloudbuild-env candidate branch - 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 options: logging: CLOUD_LOGGING_ONLY EOF sed -i "s/\${GIT_SERVER_IP}/$GIT_SERVER_IP/g" cloudbuild.yaml

2. Confirme as modificações, envie-as para o servidor Git e envie o build do pipeline:

cd ~/hello-cloudbuild-app git add cloudbuild.yaml git commit -m "Trigger CD pipeline" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git main gcloud builds submit --config=cloudbuild.yaml --substitutions=_SHORT_SHA=$(git rev-parse --short=7 HEAD),_COMMIT_SHA=$(git rev-parse HEAD) .

Isso aciona o pipeline de integração contínua no Cloud Build, que cria a imagem do aplicativo e envia um novo manifesto kubernetes.yaml para o repositório hello-cloudbuild-env.

3. Extraia o manifesto gerado em hello-cloudbuild-env e acione o build de implantação de entrega contínua (CD):

cd ~/hello-cloudbuild-env git pull http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git candidate gcloud builds submit --config=cloudbuild.yaml --substitutions=_COMMIT_SHA=$(git rev-parse HEAD) .

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

Tarefa 7: analisar o pipeline do Cloud Build

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

1. No console, acesse Cloud Build > Histórico.
2. Clique no build mais recente para acompanhar a execução e analisar os registros.
3. Verifique se o pipeline de build executou todas as etapas com sucesso.

Tarefa 8: testar 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. Confirme e envie a alteração para o servidor Git e, em seguida, envie o build de CI:

git add app.py test_app.py git commit -m "Hello Cloud Build" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git main gcloud builds submit --config=cloudbuild.yaml --substitutions=_SHORT_SHA=$(git rev-parse --short=7 HEAD),_COMMIT_SHA=$(git rev-parse HEAD) .

5. Extraia o manifesto atualizado para hello-cloudbuild-env e envie o build do pipeline de implantação para implantar a nova versão do aplicativo:

cd ~/hello-cloudbuild-env git pull http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git candidate gcloud builds submit --config=cloudbuild.yaml --substitutions=_COMMIT_SHA=$(git rev-parse HEAD) .

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

Tarefa 9: testar 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 Histórico está selecionado no painel à esquerda.
2. Clique no segundo build mais recente disponível em Histórico de builds.
3. Clique em Recriar.

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

Parabéns!

Agora você pode 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 10 de julho de 2026

Laboratório testado em 20 de julho de 2026

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.