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

Neste tutorial, mostramos 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 Google Cloud , um para desenvolvimento e outro para produção, como mostra o diagrama a seguir.

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, Azure Pipelines, Cloud Run e git. Para concluir este tutorial, você precisa ter acesso administrativo a uma conta do Azure DevOps.

Objetivos

• Conecte o Artifact Registry ao Azure Pipelines para publicar imagens do Docker.
• Prepare um aplicativo de amostra.NET 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ê vai usar os seguintes componentes faturáveis do Google Cloud:

• Cloud Run
• Cloud Storage

Para gerar uma estimativa de custo baseada na sua projeção de uso, utilize a calculadora de preços.

Novos usuários do Google Cloud podem estar qualificados para um teste sem custo financeiro.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Para mais informações, consulte Limpar.

Confira a página de preços do Azure DevOps para saber quais taxas podem ser aplicadas 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 se refere a esse projeto como o projeto de desenvolvimento.
2. Crie um projeto do Google Cloud para produção. O tutorial se refere a esse projeto como o projeto de produção.

3. Verify 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 builds e testes e orquestrar a implantação no Cloud Run. Para começar, crie um novo 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 Importar 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 Artifact Registry

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

Configurar uma conta de serviço para publicar imagens

Crie uma conta de serviço doGoogle 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 Artifact Registry no projeto de produção:

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

5. Crie um repositório do Artifact Registry para armazenar suas imagens do Docker:

   gcloud artifacts repositories create docker  \
       --project=$PROD_PROJECT_ID \
       --repository-format=docker \
       --location REGION
   

   Substitua REGION pela região do seu repositório do Artifact Registry, por exemplo, us-central1.

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

7. Conceda o papel de gravador do Artifact Registry (roles/artifactregistry.writer) à conta de serviço para permitir que o Azure Pipelines seja enviado ao Artifact 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/artifactregistry.writer \
       --project=$PROD_PROJECT_ID
   

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

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

Criar uma conexão de serviço para o Artifact Registry

No Azure Pipelines, crie uma conexão de serviço para o Artifact 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

   • Registro do Docker: https://REGION-docker.pkg.dev/PROD_PROJECT_ID/docker/

     Substitua:

     • REGION: a região do repositório do Artifact Registry
     • PROD_PROJECT_ID: o nome do seu projeto de produção

   • 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 Artifact Registry.

O repositório já contém o seguinte 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
   pool:
     vmImage: ubuntu-22.04
   trigger:
   - master
   variables:
     TargetFramework: 'net6.0'
     BuildConfiguration: 'Release'
     DockerImageName: 'PROD_PROJECT_ID/docker/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 Artifact Registry, alterne para o projeto de produção no console Google Cloud , selecione Artifact Registry > docker e 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 build que você configurou anteriormente marca cada imagem do Docker com o ID do build antes de publicá-la no Artifact 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.



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 Artifact Registry	roles/artifactregistry.writer (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	Extrair imagens Docker do Artifact Registry	roles/artifactregistry.reader (somente projeto de produção)
Executor do CloudDemo (conta de serviço do ambiente de execução)	Serviço CloudDemo	Acessar recursos em Google Cloud	Nenhum

Observação: o app CloudDemo não usa nenhum serviço do Google Cloud , como Cloud Storage, Cloud Logging ou Cloud SQL. Mas se usasse, você poderia atribuir os papéis necessários à conta de serviço do executor do CloudDemo.

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 Artifact 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-$[e-mail] \
       --role roles/artifactregistry.reader
   
   gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
       --member=serviceAccount:service-$[e-mail] \
       --role roles/artifactregistry.reader
   

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 IAM 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 Add.
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:

    

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 Especificação do agente como ubuntu-22.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=$(CloudRun.Region)-docker.pkg.dev/$(ContainerRegistry.ProjectId)/docker/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 Artifact Registry.
   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.

   

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 Especificação do agente como ubuntu-22.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=$(CloudRun.Region)-docker.pkg.dev/$(ContainerRegistry.ProjectId)/docker/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. Mude 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 Google Cloud console, mude para o projeto de desenvolvimento.

8. No menu, selecione Compute > Cloud Run.

   O serviço clouddemo é implantado com sucesso.

   

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

Cuidado: a exclusão de um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos nele.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um ID 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 explorar várias arquiteturas, tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda limites da cota.

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

• Configure um domínio personalizado para o serviço do Cloud Run.
• Saiba como usar o Azure Pipelines para implantar o mesmo app no Google Kubernetes Engine.
• Leia mais sobre como implantar aplicativos .NET no Google Cloud.
• Confira arquiteturas de referência, diagramas, tutoriais e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.