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:

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.

Antes de começar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Cloud Run, Cloud Build, and Secret Manager APIs.

    Enable the APIs

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Cloud Run, Cloud Build, and Secret Manager APIs.

    Enable the APIs

    8.

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:

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.

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

    Captura de tela do console do Cloud Run com uma revisão destacando a URL de serviço.
    Captura de tela do serviço implantado do Cloud Run, mostrando "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 é PROJECT_NUM@cloudbuild.gserviceaccount.com

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

      • Novas principais: PROJECT_NUM@cloudbuild.gserviceaccount.com
      • 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. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  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 
    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 ().
      Captura de tela da interface do GitHub para a edição de arquivos no site.
    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:

    Captura de tela da interface do GitHub mostrando uma verificação pendente.

  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:

    Captura de tela da interface do GitHub mostrando uma verificação concluída.

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

    Captura de tela da visualização do serviço do Cloud Run implantado, mostrando "Greetings World!".

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

    Captura de tela do serviço originalmente implantado do Cloud Run, mostrando "Hello World!".

  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:

    Captura de tela do console do Cloud Run, com duas revisões ativas.

  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:

    Captura de tela do console do Cloud Run, com três revisões.

  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:

    Captura de tela da visualização do serviço do Cloud Run implantado, mostrando "Greetings World!".

    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:

    Captura de tela do console do Cloud Run, com quatro revisões.

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

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

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

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:

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