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

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 doCloud de Confiance no seu projeto de produção:

1. No console do Cloud de Confiance , mude para o projeto de produção.

2. No console do Cloud de Confiance , ative o Cloud Shell.

   Ativar o 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 ID do projeto de desenvolvimento
   • PROD_PROJECT_ID: o ID 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 envie por push ao Artifact Registry:

   AZURE_PIPELINES_PUBLISHER=azure-pipelines-publisher@$PROD_PROJECT_ID.s3ns.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 Cloud de Confiance , 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 lançamento usa a imagem Docker que o pipeline de build produz e a implanta no Cloud Run.

O pipeline de build que você configurou anteriormente marca cada imagem Docker com o ID do build antes de publicá-la no Artifact Registry. Portanto, no pipeline de lançamento, use a variável $BUILD_BUILDID para identificar a imagem 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.

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 ID do projeto de desenvolvimento
   • PROD_PROJECT_ID: o ID 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-$DEV_PROJECT_NUMBER@serverless-robot-prod.s3ns-system.iam.gserviceaccount.com \
       --role roles/artifactregistry.reader
   
   gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
       --member=serviceAccount:service-$PROD_PROJECT_NUMBER@serverless-robot-prod.s3ns-system.iam.gserviceaccount.com \
       --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.s3ns.iam.gserviceaccount.com
  
  PROD_CLOUDDEMO_RUNNER=clouddemo-runner@$PROD_PROJECT_ID.s3ns.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.s3ns.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 contínua.
10. Em Acionador de implantação contínua, defina a chave como Ativado.
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 add para adicionar uma etapa à fase.
5. Selecione a tarefa linha de comando 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).s3ns.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	ID do projeto de produção.
   CloudRun.Region	Região em que você selecionou anteriormente para implantar recursos do Artifact Registry.
   CloudRun.ProjectId.Development	ID do projeto de desenvolvimento.
   CloudRun.ProjectId.Production	ID 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 add para adicionar uma etapa à fase.

12. Selecione a tarefa Linha de Comando e clique em Adicionar.

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).s3ns.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 Cloud de Confiance 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 Cloud de Confiance , 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.