Como criar um pipeline de CI/CD com o Azure Pipelines e o Cloud Run

Neste tutorial, você verá como usar o Azure Pipelines, o Cloud Run e o Container Registry para criar um pipeline de integração/implantação contínuas (CI/CD) para um aplicativo da Web MVC ASP.NET Core.

O pipeline de CI/CD usa dois projetos do Google Cloud, um para desenvolvimento e outro para produção, como mostra o diagrama a seguir.

Arquitetura de como os pipelines de compilação e lançamento do Azure interagem com os pipelines de produção e desenvolvimento do Google Cloud.

No início do pipeline, os desenvolvedores confirmam as alterações no codebase de exemplo. Esta ação aciona o pipeline para criar uma versão e implantá-la no Cloud Run no cluster de desenvolvimento. Um gerente de versão promove a versão para que ela seja implantada no projeto de produção.

Este tutorial se destina a desenvolvedores e engenheiros de DevOps. Ele pressupõe que você tenha conhecimentos básicos sobre .NET Core, Azure Pipelines, Cloud Run e git. Para concluir este tutorial, você precisa ter acesso administrativo a uma conta do Azure DevOps.

Objetivos

  • Conectar o Container Registry ao Azure Pipelines para publicar imagens do Docker.
  • Prepare um aplicativo de amostra .NET Core para implantação no Cloud Run.
  • Configure a autenticação entre o Azure Pipelines e o Google Cloud.
  • Use o gerenciamento de versões do Azure Pipelines para orquestrar implantações do Cloud Run.

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.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Verifique a página de preços do Azure DevOps para ver as taxas aplicáveis ao uso do Azure DevOps.

Antes de começar

Neste tutorial são usados dois projetos separados, um para desenvolvimento e outro para produção. O uso de projetos separados permite testar as versões antes de implantá-las na produção e também permite gerenciar papéis e permissões do Gerenciamento de identidade e acesso (IAM, na sigla em inglês) individualmente.

  1. Crie um projeto do Google Cloud para desenvolvimento. O tutorial refere-se a este projeto como o projeto de desenvolvimento.
  2. Crie um projeto do Google Cloud para produção. O tutorial refere-se a este projeto como o projeto de produção.

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

  4. Verifique se você tem uma conta do Azure DevOps e se tem acesso de administrador a ela. Se você ainda não tiver uma conta do Azure DevOps, inscreva-se na página inicial do Azure DevOps.

Criar um projeto do Azure DevOps

Use o Azure DevOps para gerenciar o código-fonte, executar compilações e testes e orquestrar a implantação no Cloud Run. Para começar, crie um projeto na sua conta do Azure DevOps.

  1. Acesse a página inicial do Azure DevOps (https://dev.azure.com/YOUR_AZURE_DEVOPS_ACCOUNT_NAME).
  2. Clique em New project.
  3. Insira um nome de projeto, como CloudDemo.
  4. Defina Visibility como Private e clique em Create project.
  5. Depois de criar o projeto, clique em Repos no menu à esquerda.
  6. Clique em Import para bifurcar o repositório dotnet-docs-samples do GitHub e defina os seguintes valores:
    • Tipo de repositório: Git
    • URL do clone: https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git

  7. Clique em Importar.

    Quando o processo de importação estiver concluído, você verá o código-fonte do repositório dotnet-docs-samples.

Conectar o Azure Pipelines ao Container Registry

Antes de configurar a integração contínua para o aplicativo CloudDemo, é preciso conectar o Azure Pipelines ao Container Registry. Essa conexão permite que o Azure Pipelines publique imagens de contêiner no Container Registry.

Configurar uma conta de serviço para publicar imagens

Crie uma conta de serviço do Google Cloud no seu projeto de produção:

  1. No Console do Google Cloud, mude para o projeto de produção.

  2. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

  3. Inicialize as seguintes variáveis de ambiente:

    DEV_PROJECT_ID=DEV_PROJECT_ID
PROD_PROJECT_ID=PROD_PROJECT_ID

    Substitua:

    • DEV_PROJECT_ID: o código do projeto de desenvolvimento
    • PROD_PROJECT_ID: o código do projeto de produção

  4. Ative a API Container Registry no projeto de produção:

    gcloud services enable containerregistry.googleapis.com \
    --project=$PROD_PROJECT_ID

  5. Crie uma conta de serviço que o Azure Pipelines usa para publicar imagens do Docker:

    gcloud iam service-accounts create azure-pipelines-publisher \
    --display-name="Azure Pipelines Publisher" \
    --project=$PROD_PROJECT_ID

  6. Conceda o papel de IAM do Storage Admin (roles/storage.admin) à conta de serviço para permitir que o Azure Pipelines seja enviado ao Container Registry:

    AZURE_PIPELINES_PUBLISHER=azure-pipelines-publisher@$PROD_PROJECT_ID.iam.gserviceaccount.com

gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
    --role roles/storage.admin \
    --project=$PROD_PROJECT_ID

  7. Gere uma chave de conta de serviço:

    gcloud iam service-accounts keys create azure-pipelines-publisher.json \
    --iam-account $AZURE_PIPELINES_PUBLISHER \
    --project=$PROD_PROJECT_ID

tr -d '\n' < azure-pipelines-publisher.json > azure-pipelines-publisher-oneline.json

  8. Veja o conteúdo do arquivo de chave da conta de serviço:

    echo $(<azure-pipelines-publisher-oneline.json)

    Você precisa da chave da conta de serviço em uma das etapas a seguir.

Como criar uma conexão de serviço para o Container Registry

No Azure Pipelines, crie uma nova conexão de serviço para o Container Registry:

  1. No menu do Azure DevOps, selecione Configurações do projeto e, em seguida, selecione Pipelines > Conexões do serviço.
  2. Clique em Criar conexão de serviço.
  3. Na lista, selecione Registro do Docker e clique em Avançar.
  4. Na caixa de diálogo, insira valores para os seguintes campos:
    • Tipo de registro: Outros
    • Docker Registry: https://gcr.io/PROD_PROJECT_ID, substituindo PROD_PROJECT_ID pelo nome do projeto de produção (por exemplo, https://gcr.io/azure-pipelines-test-project-12345).
    • ID do Docker: _json_key
    • Senha: cole o conteúdo de azure-pipelines-publisher-oneline.json.
    • Nome da conexão de serviço: gcr-tutorial
  5. Clique em Salvar para criar a conexão.

Como compilar continuamente

Agora, use o Azure Pipelines para configurar a integração contínua. Para cada confirmação enviada para o repositório Git, o Azure Pipelines cria o código e empacota os artefatos de build em um contêiner do Docker. Em seguida, o contêiner é publicado no Container Registry.

O repositório já contém o seguinte Dockerfile:

applications/clouddemo/netcore/Dockerfile 
#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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
#
#   http://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.
#

FROM mcr.microsoft.com/dotnet/aspnet:6.0
EXPOSE 8080

#------------------------------------------------------------------------------
# Copy publishing artifacts.
#------------------------------------------------------------------------------

WORKDIR /app
COPY CloudDemo.MvcCore/bin/Release/net6.0/publish/ /app/

ENV ASPNETCORE_URLS=http://0.0.0.0:8080

#------------------------------------------------------------------------------
# Run application in Kestrel.
#------------------------------------------------------------------------------

ENTRYPOINT ["dotnet", "CloudDemo.MvcCore.dll"]

Agora, crie um novo pipeline que use a sintaxe YAML:

  1. Usando o Visual Studio ou um cliente de linha de comando git, clone seu novo repositório Git.
  2. Na raiz do repositório, crie um arquivo chamado azure-pipelines.yml.

  3. Copie o seguinte código no arquivo:

    resources:
- repo: self
  fetchDepth: 1
queue:
  name: Hosted Ubuntu 1604
trigger:
- master
variables:
  TargetFramework: 'net6.0'
  BuildConfiguration: 'Release'
  DockerImageName: 'PROD_PROJECT_ID/CloudDemo'
steps:
- task: DotNetCoreCLI@2
  displayName: Publish
  inputs:
    projects: 'applications/clouddemo/netcore/CloudDemo.MvcCore.sln'
    publishWebProjects: false
    command: publish
    arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
    zipAfterPublish: false
    modifyOutputPath: false
- task: PublishBuildArtifacts@1
  displayName: 'Publish Artifact'
  inputs:
    PathtoPublish: '$(build.artifactstagingdirectory)'
- task: Docker@2
  displayName: 'Login to Container Registry'
  inputs:
    command: login
    containerRegistry: 'gcr-tutorial'
- task: Docker@2
  displayName: 'Build and push image'
  inputs:
    Dockerfile: 'applications/clouddemo/netcore/Dockerfile'
    command: buildAndPush
    repository: '$(DockerImageName)'

    Substitua PROJECT_ID pelo nome do projeto de produção e salve o arquivo.

    Como o Cloud Run é um ambiente baseado em Linux, o pipeline usa agentes de versão baseados em Linux.

  4. Confirme as alterações e envie-as para o Azure Pipelines.

    Visual Studio

    1. Abra o Team Explorer e clique no ícone Home.
    2. Clique em Changes.
    3. Insira uma mensagem de confirmação como Add pipeline definition.
    4. Clique em Confirmar tudo e enviar por push.

    Linha de comando

    1. Organize todos os arquivos modificados:

      git add -A

    2. Confirme as alterações no repositório local:

      git commit -m "Add pipeline definition"

    3. Envie as alterações para o Azure DevOps:

      git push

  5. No menu do Azure DevOps, selecione Pipelines e clique em Criar pipeline.

  6. Selecione Azure Repos Git.

  7. Selecione seu Repositório.

  8. Na página Revise o YAML do pipeline, clique em Executar.

    Uma nova versão é acionada. Pode levar cerca de dois minutos para que a compilação seja concluída.

  9. Para verificar se a imagem foi publicada no Container Registry, alterne para o projeto de produção no Console do Cloud, selecione Container Registry > Imagens e, em seguida, Clique em CloudDemo.

    Uma única imagem e a tag desta imagem são exibidas. A tag corresponde ao ID numérico da compilação executada no Azure Pipelines.

Como implantar continuamente

Agora que o Azure Pipelines está compilando automaticamente seu código e publicando imagens do Docker para cada commit, retorne sua atenção para a implantação.

Ao contrário de alguns outros sistemas de integração contínua, o Azure Pipelines distingue entre criação e implantação e fornece um conjunto especializado de ferramentas chamado Gerenciamento de versões para todas as tarefas relacionadas à implantação.

O Gerenciamento de versões do Azure Pipelines é criado com base nestes conceitos:

  • Uma versão se refere a um conjunto de artefatos que compõem uma versão específica do app e que geralmente é o resultado de um processo de compilação.
  • Implantação refere-se ao processo de escolher uma versão e implantá-la em um ambiente específico.
  • Uma implantação executa um conjunto de tarefas, que podem ser agrupadas em jobs.
  • Os estágios permitem segmentar o pipeline e podem ser usados para orquestrar implantações em vários ambientes, como ambientes de desenvolvimento e teste.

Configure o pipeline de versão a ser acionado sempre que uma nova compilação for concluída. O pipeline consiste em dois estágios: desenvolvimento e produção. Em cada estágio, o pipeline de versão usa a imagem do Docker que o pipeline de compilação produz e o implanta no Cloud Run.

O pipeline de compilação que você configurou anteriormente marca cada imagem do Docker com o código da compilação antes de publicá-la no Container Registry. Portanto, no pipeline de versão, use a variável $BUILD_BUILDID para identificar a imagem do Docker correta a ser implantada.

Configurar o Cloud Run

O Cloud Run é um ambiente totalmente gerenciado e sem servidor. Portanto, você não precisa provisionar nenhuma infraestrutura. Para ajudar a manter as implantações do Cloud Run seguras, é necessário configurar o IAM.

A implantação e execução de um serviço do Cloud Run envolve várias identidades, como mostra o diagrama a seguir.

Identidades executadas como contas de serviço em uma implantação do Cloud Run.

Cada uma destas identidades é implementada como uma conta de serviço e usada para uma finalidade específica, conforme descrito na tabela a seguir.

Conta de serviço Usada por Finalidade Papéis necessários
Editor do Azure Pipelines Pipeline de criação Publicar imagens do Docker no Container Registry roles/storage.admin (somente projeto de produção)
Implantador do Azure Pipelines Pipeline de versão Iniciar implantações do Cloud Run roles/run.admin
Inicie o serviço CloudDemo. roles/iam.serviceAccountUser
Agente de serviço do Cloud Run Cloud Run Retire as imagens do Docker do Container Registry roles/storage.objectViewer (somente projeto de produção)
Executor do CloudDemo (conta de serviço do ambiente de execução) Serviço CloudDemo Acessar os recursos no Google Cloud Nenhum

Você criou e configurou a conta de serviço do editor do Azure Pipelines. Nas seções a seguir, você cria e configura as contas de serviço restantes.

Configurar a conta de serviço do Cloud Run

  1. Abra o Cloud Shell.

  2. Inicialize as seguintes variáveis de ambiente:

    DEV_PROJECT_ID=DEV_PROJECT_ID
PROD_PROJECT_ID=PROD_PROJECT_ID

    Substitua:

    • DEV_PROJECT_ID: o código do projeto de desenvolvimento
    • PROD_PROJECT_ID: o código do projeto de produção

  3. Ative as APIs do Cloud Run e do Compute Engine nos projetos de desenvolvimento e produto:

    gcloud services enable run.googleapis.com --project=$DEV_PROJECT_ID
gcloud services enable run.googleapis.com --project=$PROD_PROJECT_ID

    A ativação destas APIs faz com que as contas do agente de serviço do Cloud Run sejam criadas nos seus projetos.

  4. Conceda às duas contas de agente de serviço do Cloud Run acesso ao Container Registry no projeto de produção em que as imagens do Docker estão armazenadas:

    DEV_PROJECT_NUMBER=$(gcloud projects describe $DEV_PROJECT_ID \
    --format='value(projectNumber)')
PROD_PROJECT_NUMBER=$(gcloud projects describe $PROD_PROJECT_ID \
    --format='value(projectNumber)')

gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member=serviceAccount:service-$DEV_PROJECT_NUMBER@serverless-robot-prod.iam.gserviceaccount.com \
    --role roles/storage.objectViewer

gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member=serviceAccount:service-$PROD_PROJECT_NUMBER@serverless-robot-prod.iam.gserviceaccount.com \
    --role roles/storage.objectViewer

Configurar a conta de executor do CloudDemo

Agora é possível configurar a conta de executor do CloudDemo, que é uma conta de serviço do ambiente de execução personalizada para o serviço CloudDemo:

  • Crie uma conta de serviço chamada CloudDemo-runner:

    gcloud iam service-accounts create clouddemo-runner \
    --display-name="CloudDemo Runner" \
    --project=$DEV_PROJECT_ID

gcloud iam service-accounts create clouddemo-runner \
    --display-name="CloudDemo Runner" \
    --project=$PROD_PROJECT_ID

DEV_CLOUDDEMO_RUNNER=clouddemo-runner@$DEV_PROJECT_ID.iam.gserviceaccount.com

PROD_CLOUDDEMO_RUNNER=clouddemo-runner@$PROD_PROJECT_ID.iam.gserviceaccount.com

Configure a conta do implantador do Azure Pipelines

Por fim, crie e configure a conta do implantador do Azure Pipelines, que o pipeline de versão do Azure usa para implantar no Cloud Run.

  1. Crie uma conta de serviço chamada azure-pipelines-deployer:

    gcloud iam service-accounts create azure-pipelines-deployer \
    --display-name="Azure Pipelines Deployer" \
    --project=$PROD_PROJECT_ID

AZURE_PIPELINES_DEPLOYER=azure-pipelines-deployer@$PROD_PROJECT_ID.iam.gserviceaccount.com

  2. Atribua os papéis necessários do AM para implantar novos serviços ou revisões do Cloud Run no projeto de desenvolvimento:

    gcloud projects add-iam-policy-binding $DEV_PROJECT_ID \
    --member serviceAccount:$AZURE_PIPELINES_DEPLOYER \
    --role roles/run.admin

gcloud iam service-accounts add-iam-policy-binding \
    $DEV_CLOUDDEMO_RUNNER \
    --member=serviceAccount:$AZURE_PIPELINES_DEPLOYER \
    --role="roles/iam.serviceAccountUser" \
    --project=$DEV_PROJECT_ID

  3. Atribua o mesmo conjunto de papéis para o projeto de produção:

    gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member serviceAccount:$AZURE_PIPELINES_DEPLOYER \
    --role roles/run.admin

gcloud iam service-accounts add-iam-policy-binding \
    $PROD_CLOUDDEMO_RUNNER \
    --member=serviceAccount:$AZURE_PIPELINES_DEPLOYER \
    --role="roles/iam.serviceAccountUser" \
    --project=$PROD_PROJECT_ID

  4. Gere uma chave de conta de serviço:

    gcloud iam service-accounts keys create azure-pipelines-deployer.json \
    --iam-account=$AZURE_PIPELINES_DEPLOYER \
    --project=$PROD_PROJECT_ID

cat azure-pipelines-deployer.json | base64 -w 0

    Use a saída deste comando ao configurar o pipeline de versão.

Configurar o pipeline de versão

Agora você pode retornar ao Azure Pipelines para automatizar a implantação, que inclui as seguintes etapas:

  • Implantação no ambiente de desenvolvimento.
  • Solicitação de aprovação manual antes de iniciar uma implantação no ambiente de produção
  • Implantação no ambiente de produção

Crie uma definição de versão

Primeiro, crie uma definição de versão:

  1. No menu do Azure DevOps, selecione Pipelines > Releases.
  2. Clique em New pipeline.
  3. Na lista de modelos, selecione Job vazio.
  4. Quando for necessário inserir um nome para o estágio, digite Development.
  5. Na parte superior da tela, nomeie o pipeline como CloudDemo.
  6. No diagrama de pipeline, ao lado de Artefatos, clique em Adicionar.
  7. Selecione Build e adicione as seguintes configurações:
    • Tipo de origem: Compilação
    • Origem (build pipeline): selecione a definição de compilação. Haverá apenas uma opção
    • Versão padrão: Latest
    • Alias de origem: build
  8. Clique em Adicionar.
  9. Na caixa Artifact, clique em Continuous deployment trigger (ícone de raio) para adicionar um gatilho de implantação.
  10. Em Continuous deployment trigger, defina a chave como Enabled.
  11. Clique em Save.

  12. Insira um comentário, se quiser, e confirme clicando em OK.

    O pipeline será assim:

    Visualização do pipeline da configuração de implantação automatizada.

Implante no projeto de desenvolvimento

Com a definição da versão criada é possível configurar a implantação do Cloud Run no projeto de desenvolvimento.

  1. No menu, alterne para a guia Tasks.
  2. Clique em Agent job.
  3. Defina Agent specification para ubuntu-18.04.
  4. Ao lado de Agent job, clique em Add a task to agent job para adicionar uma etapa à fase.
  5. Selecione a tarefa Command Line e clique em Add.

  6. Clique na tarefa recém-adicionada e defina as seguintes configurações:

    1. Nome de exibição: Deploy image to development project

    2. Script:

      gcloud auth activate-service-account \
    --quiet \
    --key-file <(echo $(ServiceAccountKey) | base64 -d) && \
gcloud run deploy clouddemo \
    --quiet \
    --service-account=clouddemo-runner@$(CloudRun.ProjectId.Development).iam.gserviceaccount.com \
    --allow-unauthenticated \
    --image=gcr.io/$(ContainerRegistry.ProjectId)/clouddemo:$BUILD_BUILDID \
    --platform=managed \
    --region=$(CloudRun.Region) \
    --project=$(CloudRun.ProjectId.Development)

      Esse comando recebe uma chave de conta de serviço de uma variável de ambiente e usa a CLI gcloud para implantar o aplicativo no Cloud Run. A CLI gcloud está disponível por padrão nos agentes do Azure Pipelines.

  7. Alterne para a guia Variables e adicione as seguintes variáveis.

    Nome Valor Secret
    ServiceAccountKey Chave da conta de serviço criada para azure-pipelines-deployer anteriormente. Sim
    ContainerRegistry.ProjectId Código do projeto de produção.
    CloudRun.Region Região em que você selecionou anteriormente para implantar recursos do Cloud Run.
    CloudRun.ProjectId.Development Código do projeto de desenvolvimento.
    CloudRun.ProjectId.Production Código do projeto de produção.

  8. Clique em Save.

  9. Insira um comentário se quiser e clique em OK para confirmar.

Implante no cluster de produção

Por fim, configure a implantação no projeto de produção:

  1. No menu, alterne para a guia Pipeline.
  2. Na caixa Stages, select Add > New stage.
  3. Na lista de modelos, selecione Job vazio.
  4. Quando for necessário inserir um nome para o estágio, digite Production.
  5. Clique no ícone de raio, referente ao cenário recém-criado.

  6. Defina as configurações a seguir:

    1. Select trigger: After stage
    2. Stages: Development
    3. Pre-deployment approvals: (ativada)
    4. Approvers: selecione seu nome de usuário.

    O pipeline exibe uma visualização semelhante à seguinte.

    Visualização do pipeline da configuração da implantação do cluster.

  7. Alterne para a guia Tasks.

  8. Mantenha o mouse sobre a guia Tasks e selecione Tasks > Production.

  9. Clique em Agent job.

  10. Defina Agent specification para ubuntu-18.04.

  11. Clique em Add a task to agent job para adicionar uma etapa à fase.

  12. Selecione a tarefa Command Line e clique em Add.

  13. Clique na tarefa recém-adicionada e defina as seguintes configurações:

    1. Nome de exibição: Deploy image to production project

    2. Script:

      gcloud auth activate-service-account \
    --quiet \
    --key-file <(echo $(ServiceAccountKey) | base64 -d) && \
gcloud run deploy clouddemo \
    --quiet \
    --service-account=clouddemo-runner@$(CloudRun.ProjectId.Production).iam.gserviceaccount.com \
    --allow-unauthenticated \
    --image=gcr.io/$(ContainerRegistry.ProjectId)/clouddemo:$BUILD_BUILDID \
    --platform=managed \
    --region=$(CloudRun.Region) \
    --project=$(CloudRun.ProjectId.Production)

  14. Clique em Save.

  15. Insira um comentário se quiser e clique em OK para confirmar.

Executar o pipeline

Agora que você configurou o pipeline inteiro, é possível testá-lo executando uma alteração no código-fonte:

  1. No computador local, abra o arquivo applications\clouddemo\netcore\CloudDemo.MvcCore\Views\Home\Index.cshtml no repositório Git que você clonou anteriormente.
  2. Na linha 26, altere o valor de ViewBag.Title de Home Page para Home Page Cloud Run.

  3. Confirme as alterações e envie-as para o Azure Pipelines.

    Visual Studio

    1. Abra o Team Explorer e clique no ícone Home.
    2. Clique em Changes.
    3. Insira uma mensagem de confirmação como Change site title.
    4. Clique em Confirmar tudo e enviar por push.

    Linha de comando

    1. Organize todos os arquivos modificados:

      git add -A

    2. Confirme as alterações no repositório local:

      git commit -m "Change site title"

    3. Envie as alterações para o Azure Pipelines:

      git push

  4. No menu do Azure DevOps, selecione Pipelines. Um build é acionada.

  5. Após a conclusão do build, selecione Pipelines > Releases. Um processo de versão será iniciado.

  6. Clique em Release-1 para abrir a página de detalhes e aguarde até que o status do estágio Development mude para Succeeded.

  7. No Console do Google Cloud, mude para o projeto de desenvolvimento.

  8. No menu, selecione Compute > Cloud Run.

    O serviço clouddemo é implantado com sucesso.

    Status da implantação no Cloud Run.

  9. Clique em clouddemo para ver mais detalhes.

    Será exibido um URL que mostrará que o Cloud Run forneceu o serviço.

  10. Abra o URL em uma nova guia do navegador para verificar se o aplicativo CloudDemo está implantado e usa o título personalizado.

  11. No Azure Pipelines, clique em Approve (adjacent to the Production stage) para promover a implantação no ambiente de produção.

  12. (Opcional) Digite um comentário.

  13. Confirme clicando em Approve e aguarde o status do ambiente Production mudar para Succeeded.

  14. No Console do Google Cloud, mude para o projeto de produção.

  15. No menu, selecione Compute > Cloud Run.

    O serviço clouddemo é implantado no projeto de produção.

  16. Clique em clouddemo para ver mais detalhes.

    Um URL é exibido e mostra que o Cloud Run forneceu o serviço.

  17. Abra o URL em uma nova guia do navegador para verificar se o aplicativo CloudDemo está implantado na produção e se usa o título personalizado.

Limpeza

Para evitar custos adicionais depois de concluir este tutorial, exclua as entidades criadas.

Excluir o projeto do Azure Pipelines

Para excluir o projeto do Azure Pipelines, consulte a documentação de serviços do Azure DevOps. A exclusão do projeto do Azure Pipelines faz com que todas as alterações no código-fonte sejam perdidas.

Excluir os projetos de desenvolvimento e produção do Google Cloud

  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.

A seguir