Como configurar visualizações de implantação

---

Este tutorial mostra como usar o URLs de revisão do Cloud Runpara implementar pré-visualizações de solicitações de envio do GitHub por meio de Gatilhos do Cloud Build. As visualizações permitem implantar possíveis alterações em um serviço sem alterar a versão ativa ou de "produção" do serviço. Ao implantar uma revisão de tráfego de 0% de uma solicitação de envio aberta, é possível visualizar a alteração e garantir que ela funcione conforme o esperado em um ambiente de quase produção antes da mesclagem.

Este tutorial funciona com repositórios do GitHub públicos e particulares. As visualizações serão públicas, se estiverem ocultas.

Objetivos

• Criar um serviço do Cloud Run.
• Implemente a integração contínua baseada em controle de origem no GitHub.
• Criar e gerenciar o acesso a secrets por meio do Secret Manager.
• Implantar um Cloud Builder personalizado.
• Criar um gatilho do Cloud Build para invocar versões nas solicitações de envio do GitHub

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

• Cloud Build
• Cloud Run
• Container Registry
• Secret Manager

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Observação: o Container Registry está obsoleto. A partir de 15 de maio de 2024, os projetos do Google Cloud sem uso anterior do Container Registry só serão compatíveis com a hospedagem e o gerenciamento de imagens para o domínio gcr.io no Artifact Registry. Para detalhes, consulte Descontinuação do Container Registry.

Antes de começar

1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

4. Ative as APIs Cloud Run, Cloud Build, and Secret Manager.

   Ative as APIs

5. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

6. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

7. Ative as APIs Cloud Run, Cloud Build, and Secret Manager.

   Ative as APIs

Funções exigidas

Para conseguir as permissões necessárias para concluir o tutorial, peça ao administrador para conceder a você os seguintes papéis do IAM no seu projeto:

• Editor do Cloud Build (roles/cloudbuild.builds.editor)
• Administrador do Cloud Run (roles/run.admin)
• Criar contas de serviço (roles/iam.serviceAccountCreator)
• Administrador do Secret Manager (roles/secretmanager.admin)

Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Observação: os papéis básicos do IAM também podem conter permissões para concluir o tutorial. Não conceda papéis básicos em um ambiente de produção, mas é possível fazer isso em um ambiente de desenvolvimento ou teste.

Como recuperar o exemplo de código

Para facilitar o uso neste tutorial, você criará um novo repositório do GitHub com uma cópia de um aplicativo Hello World com base em um modelo. Em seguida, você adicionará um novo arquivo a esse repositório com a configuração personalizada do Cloud Build.

1. Faça login no GitHub e acesse o repositório de modelos.
2. Crie um novo repositório usando este modelo clicando em "Usar este modelo".
   1. Nomeie seu repositório como helloworld-python.
   2. Escolha "Público" ou "Privado" para o repositório.
   3. Clique em Criar repositório com base em modelo.

3. Crie um novo arquivo de configuração do Cloud Build no seu repositório (instruções completas):

   1. Na página de seu repositório, clique em Adicionar arquivo > Criar novo arquivo
   2. Nomeie o novo arquivo como cloudbuild.yaml

   3. Copie o código abaixo para cloudbuild.yaml:

      run/deployment-previews/cloudbuild-configurations/cloudbuild.yaml

      Ver no GitHub Feedback

      steps:
        - id: "build image"
          name: "gcr.io/cloud-builders/docker"
          args:
            [
              "build",
              "-t",
              "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}",
              ".",
            ]
      
        - id: "push image"
          name: "gcr.io/cloud-builders/docker"
          args:
            [
              "push",
              "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}",
            ]
      
        - id: "deploy prod service"
          name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
          entrypoint: "gcloud"
          args:
            [
              "run",
              "deploy",
              "${_SERVICE_NAME}",
              "--platform",
              "managed",
              "--region",
              "${_REGION}",
              "--allow-unauthenticated",
              "--image",
              "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}",
            ]
      
        # Force the new revision to serve 100% of traffic.
        - id: "ensure prod service live"
          name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
          entrypoint: "gcloud"
          args:
            [
              "run",
              "services",
              "update-traffic",
              "${_SERVICE_NAME}",
              "--to-latest",
              "--platform",
              "managed",
              "--region",
              "${_REGION}",
            ]
      
      substitutions:
        _SERVICE_NAME: myservice
        _REGION: us-central1
      
      options:
        logging: CLOUD_LOGGING_ONLY

   4. Mantenha a opção padrão "Confirmar diretamente na ramificação main".

   5. Clique em Confirmar novo arquivo.

Como implantar o serviço com um gatilho de compilação

Neste tutorial, mostramos como configurar um gatilho de compilação para iniciar uma compilação automaticamente sempre que você atualizar a ramificação principal do repositório. Também é possível implantar o serviço manualmente invocando o Cloud Build toda vez que você quiser implantar uma alteração.

Neste tutorial, use o arquivo cloudbuild.yaml para implantar um serviço de amostra chamado myservice.

1. Conceda os papéis de administrador da conta de serviço e de administrador do Cloud Run à conta de serviço do Cloud Build (instruções completas):

   1. No console do Google Cloud, acesse a página de configurações da conta do Cloud Build.

      Acessar a página de configurações da conta do Cloud Build

   2. Ative o papel de administrador do Cloud Run.

   3. Na caixa de diálogo de confirmação, clique em Conceder acesso a todas as contas de serviço.

2. Conecte sua conta do GitHub ao Cloud Build (instruções completas):

   1. No console do Google Cloud, acesse a página de gatilhos do Cloud Build.

      Acessar a página de gatilhos do Cloud Build

   2. Clique em Conectar repositório.

   3. Selecione GitHub (aplicativo do GitHub para Cloud Build) como origem e siga as caixas de diálogo de autenticação e autorização.

   4. Selecione o repositório "GITHUB_USER_NAME/helloworld-python".

   5. Clique em Conectar repositório.

   6. Em "Criar um gatilho (opcional)", clique em Criar um gatilho.

3. Crie um gatilho do Cloud Build (instruções completas):

   1. Na página de gatilhos do Cloud Build, clique em Criar gatilho.
   2. Digite os seguintes detalhes:
      • Nome: prod-deploy
      • Evento: enviar por push para a ramificação
      • Repositório de origem: "GITHUB_USER_NAME/helloworld-python"
      • Ramificação de origem: ^main$
      • Configuração do build: arquivo de configuração do Cloud Build (yaml ou json)
      • Local do arquivo de configuração do Cloud Build: cloudbuild.yaml
   3. Clique em Criar.

4. Execute o novo gatilho manualmente:

   1. Na nova lista de acionadores, clique em Executar.
   2. No pop-up, confirme o nome da ramificação (main) e clique em Executar gatilho.
   3. Verifique o progresso da compilação no Histórico do Cloud Build.
   4. Aguarde a conclusão da criação.

5. Confirme a implantação bem-sucedida.

   1. No console do Google Cloud, acesse a página do Cloud Run.

      Acessar a página do Cloud Run

   2. Confirme se o serviço tem uma marca de seleção verde que mostra a implantação bem-sucedida.

   3. Clique na guia Revisões e confirme se o serviço tem uma revisão, veiculando 100% do tráfego, começando com "myservice-00001-".

   4. Clique na URL do serviço e confirme se ela exibe "Hello World!".

   

   

Como criar tokens e configurações

O gatilho prod-deploy criado na seção anterior implanta o serviço quando um push é feito para a ramificação principal. Agora você criará um segundo gatilho que será executado sempre que uma solicitação de envio for criada ou atualizada no seu repositório.

Depois que o novo gatilho for configurado, a visualização será implantada, mas não haverá informações na solicitação de envio para vincular à visualização. Para configurar essa funcionalidade, você precisa concluir as seguintes etapas de configuração adicionais:

• Criar um token do GitHub
• Armazenar esse token no Secret Manager
• Crie uma imagem personalizada para usar como uma etapa no Cloud Build.

Como criar e armazenar um token do GitHub

1. Crie um token do GitHub para permitir a gravação novamente em uma solicitação de envio (instruções completas):
   1. Acesse a página de configurações do Token de acesso pessoal do GitHub.
   2. Clique em Gerar novo token.
   3. Digite os seguintes detalhes:
      • Observação: preview-deploy
      • Expiração: 30 dias
      • Escopo:
        • Para um repositório público: repo:status ("Status de confirmação de acesso")
        • Para um repositório particular: repo ("Controle total de repositórios particulares")
   4. Clique em Gerar token.
   5. Copie o valor do token gerado.

2. Armazene o token do GitHub no Secret Manager:

   1. No console do Google Cloud, acesse a página Secret Manager.

      Acessar a página "Gerenciador de secrets"

   2. Clique em Criar secret.

   3. Digite os seguintes detalhes:

      1. Nome: github_token.
      2. Valor do secret: cole o valor do token que você copiou do GitHub.

   4. Clique em Criar secret.

3. Permita o acesso do Cloud Build a este secret:

   1. Em uma nova guia do navegador, no console do Google Cloud, acesse a página Configurações do Cloud Build.

      Acessar a página de configurações do Cloud Build

   2. Copie o valor para "E-mail da conta de serviço".

      • O e-mail é [e-mail]

   3. Retorne ao Secret Manager, clique na guia Permissão e em Adicionar.

      • Novas principais: [e-mail]
      • Papel: acessador de secrets do Secret Manager

   4. Clique em Save.

O GitHub recomenda definir a validade dos tokens de acesso pessoal e enviará lembretes por e-mail quando eles estiverem definidos para expirar. Se você continuar usando visualizações de implantação, crie uma nova versão do github_token ao gerar o token novamente. O builder na próxima etapa recupera a versão mais recente do token, para que as visualizações continuem funcionando.

Como criar uma nova imagem para o Cloud Build

O script que grava a notificação "Visualização da implantação" na solicitação de envio está localizado nas Amostras de documentos do Python. Em vez de adicionar esse script ao código-fonte, é possível criar esse script em um contêiner dentro do seu projeto e executar esse contêiner como uma etapa na configuração do Cloud Build.

Conclua as instruções a seguir usando o Cloud Shell ou a máquina local se tiver instalado e configurado o git e a CLI do Google Cloud. As instruções abaixo mostram os dois métodos.

1. No Console do Google Cloud, ative o Cloud Shell.

   Ativar o Cloud Shell

   Na parte inferior do Console do Google Cloud, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

2. Configure a CLI do Google Cloud para usar seu projeto, substituindo PROJECT_ID pelo ID do projeto:

   export PROJECT_ID=PROJECT_ID
   gcloud config set project $PROJECT_ID
   

   Se você estiver usando o Cloud Shell, talvez seja necessário autorizar a CLI do Google Cloud para fazer uma chamada de API do Google Cloud. Clique em Autorizar para continuar a ação.
3. Crie uma nova imagem de contêiner:

   git clone https://github.com/GoogleCloudPlatform/python-docs-samples
   cd python-docs-samples/
   gcloud builds submit --tag gcr.io/$PROJECT_ID/deployment-previews run/deployment-previews
   

4. Confirme se o contêiner foi criado:

   gcloud container images list
   

5. Remova o repositório clonado:

   cd ..
   rm -rf python-docs-samples
   

Como adicionar a nova configuração do Cloud Build

Seu repositório já tem um arquivo cloudbuild.yaml usado na ramificação principal. Agora você criará uma nova configuração para esse novo gatilho.

1. Na página de repositório do GitHub, clique em Adicionar arquivo > Criar novo arquivo.

   1. Nomeie o novo arquivo como cloudbuild-preview.yaml
   2. Copie o código abaixo e cole-o no novo arquivo:
   run/deployment-previews/cloudbuild-configurations/cloudbuild-preview.yaml

   Ver no GitHub Feedback

   steps:
     - id: "build image"
       name: "gcr.io/cloud-builders/docker"
       args:
         [
           "build",
           "-t",
           "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}:${_PR_NUMBER}-${SHORT_SHA}",
           ".",
         ]
   
     - id: "push image"
       name: "gcr.io/cloud-builders/docker"
       args:
         [
           "push",
           "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}:${_PR_NUMBER}-${SHORT_SHA}",
         ]
   
     - id: "deploy revision with tag"
       name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
       entrypoint: "gcloud"
       args:
         [
           "run",
           "deploy",
           "${_SERVICE_NAME}",
           "--platform",
           "managed",
           "--region",
           "${_REGION}",
           "--image",
           "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}:${_PR_NUMBER}-${SHORT_SHA}",
           "--tag",
           "pr-${_PR_NUMBER}",
           "--no-traffic",
         ]
   
     - id: "link revision on pull request"
       name: "us-central1-docker.pkg.dev/$PROJECT_ID/containers/deployment-previews" # our custom builder
       secretEnv: ["GITHUB_TOKEN"]
       args:
         [
           "set",
           "--project-id",
           "${PROJECT_ID}",
           "--region",
           "${_REGION}",
           "--service",
           "${_SERVICE_NAME}",
           "--pull-request",
           "${_PR_NUMBER}",
           "--repo-name",
           "${REPO_FULL_NAME}",
           "--commit-sha",
           "${SHORT_SHA}",
         ]
   
   substitutions:
     _SERVICE_NAME: myservice
     _REGION: us-central1
   
   options:
     dynamicSubstitutions: true
     logging: CLOUD_LOGGING_ONLY
   
   availableSecrets:
     secretManager:
       - versionName: projects/$PROJECT_ID/secrets/github_token/versions/latest
         env: "GITHUB_TOKEN"

2. Confirme a alteração na ramificação principal do seu repositório.

Como criar o gatilho secundário

Agora que toda a base foi feita, crie o novo gatilho.

1. Crie um novo gatilho do Cloud Build (instruções completas):

   1. No console do Google Cloud, acesse a página Gatilhos do Cloud Build.

      Acessar a página de gatilhos do Cloud Build

   2. Clique em Criar gatilho.

   3. Digite os seguintes detalhes:

      • Nome: preview-deploy
      • Evento: solicitação de envio
      • Repositório de origem: "GITHUB_USER_NAME/helloworld-python"
      • Ramificação de base: ^main$
      • Controle de comentários: obrigatório, exceto para proprietários e colaboradores
        • Como proprietário do repositório, as visualizações serão criadas automaticamente com base nas solicitações de envio que você criar.
        • Se você quiser permitir que qualquer pessoa veja as alterações, leia as implicações de segurança da seleção de "Não obrigatório".
      • Configuração: arquivo de configuração do Cloud Build
      • Local do arquivo de configuração do Cloud Build: cloudbuild-preview.yaml

   4. Clique em Criar.

Verificação do sucesso

Como esse novo gatilho é disparado quando uma nova solicitação de envio é criada, você precisará criar uma nova para efetuar o teste.

1. Acesse seu repositório e faça uma alteração visual para app.py em uma nova ramificação.
   1. Acesse app.py e clique no ícone de lápis ().

      

   2. Faça uma alteração. Por exemplo, mude "Olá" para "Saudações".
   3. Selecione Criar uma nova ramificação para essa confirmação e iniciar uma solicitação de envio e clique em Propor alteração.

2. Crie uma nova solicitação de envio com esta ramificação.

   Se o gatilho estiver configurado corretamente, uma nova verificação será exibida logo depois que você criar a solicitação de envio:

   

3. O nome da verificação é o nome do gatilho e o ID do projeto. Para verificar o progresso da criação, clique em Detalhes > Ver mais detalhes no Google Cloud Build.

   Se o acionador falhar e você precisar reenviar a compilação, ou se quiser fazer outra alteração na solicitação de envio, será necessário confirmar uma alteração na mesma ramificação. Cada nova confirmação em uma solicitação de envio acionará uma nova compilação.

4. Após a conclusão do acionador, uma nova verificação de status chamada Visualização da implantação é exibida para a solicitação de envio. O ícone exibido é o seu avatar porque a sua conta é proprietária do token usado:

   

5. Clique em Details para navegar até a visualização. O URL mostrado é o mesmo do original, mas tem o prefixo "pr-1---".

   

   Se você navegar para a URL do serviço original, o conteúdo original será mostrado:

   

6. Veja a lista de revisões do serviço para verificar o estado dele no Cloud Run. Agora, há duas revisões que veiculam tráfego: a original e a visualização:

   

7. Continue fazendo alterações na solicitação de envio adicionando novas confirmações à ramificação. Sempre que você faz a confirmação, o gatilho preview-deploy é acionado, criando uma nova revisão do serviço e disponibilizando a revisão na mesma URL:

   

8. Quando estiver pronto para mesclar suas alterações, clique em Mesclar solicitação de envio. O gatilho prod-deploy original é executado e as alterações da solicitação de envio são refletidas na URL original:

   

   A nova revisão veicula 100% do tráfego na URL principal, mas a URL de visualização da solicitação ainda estará anexada à confirmação mais recente dessa solicitação de envio para que o link continue funcionando:

   

Limitações

Há um limite no número de URLs de revisão que podem ser criadas. Se você espera que seu repositório tenha mais de 1.000 solicitações de envio, considere um processo para limpar as tags, como mostrado em cloudbuild-cleanup.yaml.

Noções básicas sobre o código

cloudbuild.yaml

Este código é baseado no exemplo cloudbuild.yaml fornecido pelo Cloud Build, mas com uma atualização anotada: a quarta etapa que executa update-traffic.

run/deployment-previews/cloudbuild-configurations/cloudbuild.yaml

Ver no GitHub Feedback

steps:
  - id: "build image"
    name: "gcr.io/cloud-builders/docker"
    args:
      [
        "build",
        "-t",
        "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}",
        ".",
      ]

  - id: "push image"
    name: "gcr.io/cloud-builders/docker"
    args:
      [
        "push",
        "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}",
      ]

  - id: "deploy prod service"
    name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
    entrypoint: "gcloud"
    args:
      [
        "run",
        "deploy",
        "${_SERVICE_NAME}",
        "--platform",
        "managed",
        "--region",
        "${_REGION}",
        "--allow-unauthenticated",
        "--image",
        "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}",
      ]

  # Force the new revision to serve 100% of traffic.
  - id: "ensure prod service live"
    name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
    entrypoint: "gcloud"
    args:
      [
        "run",
        "services",
        "update-traffic",
        "${_SERVICE_NAME}",
        "--to-latest",
        "--platform",
        "managed",
        "--region",
        "${_REGION}",
      ]

substitutions:
  _SERVICE_NAME: myservice
  _REGION: us-central1

options:
  logging: CLOUD_LOGGING_ONLY

As configurações em cloudbuild.yaml fazem alterações na divisão de tráfego. O parâmetro --to-latest oferece a mesma funcionalidade que a caixa de seleção Veicular esta revisão imediatamente na página do Cloud Run. Ela garante que essa revisão do serviço exiba 100% do tráfego imediatamente.

cloudbuild-preview.yaml

run/deployment-previews/cloudbuild-configurations/cloudbuild-preview.yaml

Ver no GitHub Feedback

steps:
  - id: "build image"
    name: "gcr.io/cloud-builders/docker"
    args:
      [
        "build",
        "-t",
        "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}:${_PR_NUMBER}-${SHORT_SHA}",
        ".",
      ]

  - id: "push image"
    name: "gcr.io/cloud-builders/docker"
    args:
      [
        "push",
        "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}:${_PR_NUMBER}-${SHORT_SHA}",
      ]

  - id: "deploy revision with tag"
    name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
    entrypoint: "gcloud"
    args:
      [
        "run",
        "deploy",
        "${_SERVICE_NAME}",
        "--platform",
        "managed",
        "--region",
        "${_REGION}",
        "--image",
        "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}:${_PR_NUMBER}-${SHORT_SHA}",
        "--tag",
        "pr-${_PR_NUMBER}",
        "--no-traffic",
      ]

  - id: "link revision on pull request"
    name: "us-central1-docker.pkg.dev/$PROJECT_ID/containers/deployment-previews" # our custom builder
    secretEnv: ["GITHUB_TOKEN"]
    args:
      [
        "set",
        "--project-id",
        "${PROJECT_ID}",
        "--region",
        "${_REGION}",
        "--service",
        "${_SERVICE_NAME}",
        "--pull-request",
        "${_PR_NUMBER}",
        "--repo-name",
        "${REPO_FULL_NAME}",
        "--commit-sha",
        "${SHORT_SHA}",
      ]

substitutions:
  _SERVICE_NAME: myservice
  _REGION: us-central1

options:
  dynamicSubstitutions: true
  logging: CLOUD_LOGGING_ONLY

availableSecrets:
  secretManager:
    - versionName: projects/$PROJECT_ID/secrets/github_token/versions/latest
      env: "GITHUB_TOKEN"

Este código é semelhante a cloudbuild.yaml, mas com etapas adicionais:

1. Depois de criar e enviar a imagem do serviço, cloudbuild-preview.yaml implanta o serviço usando a sinalização --no-traffic. Isso significa que, mesmo que esta seja a revisão mais recente, ela não está sendo usada para exibir o tráfego.

2. cloudbuild-preview.yaml adiciona uma tag personalizada com base no número da solicitação de envio. Nesse caso, uma string prefixada com "pr-" e terminando no número da solicitação de envio.

   Nesse momento, a URL de revisão está funcionando, mas a pessoa que enviou a solicitação de envio não consegue determinar isso porque os registros do Cloud Build não estão visíveis no próprio GitHub: apenas um link aos registros está visível. Somente os usuários autenticados do projeto do Cloud Build com permissões suficientes podem ver os registros.

3. cloudbuild-preview.yaml executa o script check_status.py usando parâmetros de substituição integrados fornecidos pelo Cloud Build. Alguns desses parâmetros estão disponíveis ao trabalhar com repositórios do GitHub, como o número da solicitação de envio, o nome do repositório e o SHA de confirmação.

Para executar novamente este gatilho, envie outra confirmação no GitHub. Não é possível executar novamente este gatilho a partir da página do Cloud Build no console.

cloudbuild-cleanup.yaml

run/deployment-previews/cloudbuild-configurations/cloudbuild-cleanup.yaml

Ver no GitHub Feedback

steps:
  - id: "build image"
    name: "gcr.io/cloud-builders/docker"
    args:
      [
        "build",
        "-t",
        "us-central1-docker.pkg.dev/${PROJECT_ID}/containers/${_SERVICE_NAME}",
        ".",
      ]

  - id: "push image"
    name: "gcr.io/cloud-builders/docker"
    args:
      [
        "push",
        "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}",
      ]

  - id: "deploy prod service"
    name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
    entrypoint: "gcloud"
    args:
      [
        "run",
        "deploy",
        "${_SERVICE_NAME}",
        "--platform",
        "managed",
        "--region",
        "${_REGION}",
        "--allow-unauthenticated",
        "--image",
        "us-central1-docker.pkg.dev/$PROJECT_ID/containers/${_SERVICE_NAME}",
      ]

  # Force the new revision to serve 100% of traffic.
  - id: "ensure prod service live"
    name: "gcr.io/google.com/cloudsdktool/cloud-sdk"
    entrypoint: "gcloud"
    args:
      [
        "run",
        "services",
        "update-traffic",
        "${_SERVICE_NAME}",
        "--to-latest",
        "--platform",
        "managed",
        "--region",
        "${_REGION}",
      ]

  # Cleanup tags against closed pull requests
  - id: "clean up old tag"
    name: "us-central1-docker.pkg.dev/${PROJECT_ID}/containers/deployment-previews" # our custom builder
    secretEnv: ["GITHUB_TOKEN"]
    args:
      [
        "cleanup",
        "--project-id",
        "${PROJECT_ID}",
        "--region",
        "${_REGION}",
        "--service",
        "${_SERVICE_NAME}",
        "--repo-name",
        "${REPO_FULL_NAME}",
      ]

substitutions:
  _SERVICE_NAME: myservice
  _REGION: us-central1

options:
  dynamicSubstitutions: true
  logging: CLOUD_LOGGING_ONLY

availableSecrets:
  secretManager:
    - versionName: projects/$PROJECT_ID/secrets/github_token/versions/latest
      env: "GITHUB_TOKEN"

Esse código é uma alternativa ao cloudbuild.yaml, com funcionalidade de limpeza. As etapas iniciais realizam a implantação, e a funcionalidade é estendida da seguinte maneira:

1. Usando a API de descoberta e as APIs do GitHub, determine quais tags para o serviço são para solicitações de envio fechadas. No mínimo, haverá uma solicitação de envio que foi mesclada, fazendo com que esse gatilho seja disparado.

2. Exclua as tags identificadas.

check_status.py

run/deployment-previews/check_status.py

Ver no GitHub Feedback

def set(
    dry_run: str,
    project_id: str,
    region: str,
    service: str,
    repo_name: str,
    commit_sha: str,
    pull_request: str,
) -> None:
    """Set a status on a GitHub commit to a specific revision URL"""
    service_obj = get_service(project_id, region, service)
    revision_url = get_revision_url(service_obj, tag=make_tag(pull_request))

    ghtoken = os.environ.get("GITHUB_TOKEN", None)

    if not ghtoken:
        raise ValueError("GITHUB_TOKEN not defined.")

    try:
        repo = github.Github(ghtoken).get_repo(repo_name)
    except GithubException as e:
        error(
            e.data["message"],
            context=f"finding repo {repo_name}. Is it a private repo, and does your token have the correct permissions?",
        )

    try:
        commit = repo.get_commit(sha=commit_sha)
    except GithubException as e:
        error(e.data["message"], context=f"finding commit {commit_sha}")

    # ...

    commit.create_status(
        state="success",
        target_url=revision_url,
        context=f"Deployment Preview for {service}",
        description="Your preview is now available.",
    )
    click.secho("Success: ", fg="green", bold=True, nl=False)
    click.echo(
        f"Status created on {repo_name}, commit {commit.sha[:7]}, "
        f"linking to {revision_url} on service {service_obj['metadata']['name']}"
    )

O script check_status.py usa as informações fornecidas sobre o serviço do Cloud Run, sobre o repositório e a confirmação do GitHub e, em seguida, executa as seguintes operações:

• Recupere o nome, a tag e o URL de revisão do serviço usando o cliente Python da API do Google.
• Recupere o token do GitHub da variável de ambiente, fornecida pelo Secret Manager.
• Crie um status na confirmação determinada, criando um link para a URL de revisão recuperada, usando uma API do cliente GitHub para Python.

Limpeza

Se você criou um novo projeto para este tutorial, exclua o projeto. Se você usou um projeto atual e quer mantê-lo sem as alterações incluídas neste tutorial, exclua os recursos criados para o tutorial. Além disso, você precisará excluir as configurações do GitHub criadas para este tutorial.

Excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. No Console do Google Cloud, acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Como excluir recursos do tutorial

1. Exclua o serviço do Cloud Run que você implantou neste tutorial:

   1. Navegue até o Console do Cloud Run.
   2. Selecione a listagem "myservice" e clique em Excluir.
   3. Na caixa de diálogo de confirmação, clique em Excluir.

2. Exclua outros recursos do Google Cloud criados neste tutorial:

   • Exclua a imagem do contêiner da visualização de implantação denominada gcr.io/PROJECT_ID/deployment-preview do Container Registry.
   • Exclua a imagem de contêiner helloworld denominada gcr.io/PROJECT_ID/helloworld do Container Registry.
   • Exclua os gatilhos do Cloud Build.
   • Exclua o secret do Secret Manager.

Como excluir configurações de tutorial

Para limpar as configurações do GitHub, remova o aplicativo Google Cloud Build do GitHub:

1. Navegue até as configurações do aplicativo GitHub
2. Na listagem do Google Cloud Build, clique em Configurar.
3. Na seção Zona de perigo, clique em Desinstalar.
4. Na caixa de diálogo de confirmação, clique em OK.

Você também precisará excluir o token do GitHub criado:

1. Navegue até a página Tokens de acesso pessoal do GitHub.
2. Na listagem preview-deploy, clique em Excluir.
3. Na caixa de diálogo de confirmação, clique em Entendo, exclua este token.

Você também precisará excluir o repositório do GitHub:

1. Navegue até o repositório do GitHub criado e clique na guia Configurações.
2. Na seção Zona de perigo, clique em Excluir este repositório.
3. Na caixa de diálogo de confirmação, insira o nome completo do repositório e clique em Entendo as consequências, exclua este repositório.

A seguir

• Saiba mais sobre reversões, lançamentos graduais e migração de tráfego no Cloud Run.
• Saiba mais sobre os gatilhos de aplicativos do GitHub no Cloud Build.