Tutorial: Criar um pipeline de vários estágios com o Azure DevOps

Azure DevOps Services | Azure DevOps Server 2022 - Azure DevOps Server 2019

Você pode usar um pipeline de vários estágios do Azure DevOps para dividir seu processo de CI/CD em estágios que representam diferentes partes do seu ciclo de desenvolvimento. O uso de um pipeline de vários estágios oferece mais visibilidade do processo de implantação e facilita a integração de aprovações e verificações.

Neste artigo, você criará duas instâncias do Serviço de Aplicativo e criará um pipeline YAML com três estágios:

• Build: construir o código-fonte e produzir um pacote
• Dev: implante seu pacote em um site de desenvolvimento para teste
• Preparo: implantar em uma instância do Serviço de Aplicativo do Azure com uma verificação de aprovação manual

Em um cenário do mundo real, você pode ter outro estágio para implantação na produção, dependendo do seu processo de DevOps.

O código de exemplo neste exercício é para um aplicativo Web .NET para um jogo espacial simulado que inclui uma tabela de classificação para mostrar pontuações altas. Você implantará em instâncias de desenvolvimento e preparo do Aplicativo Web do Azure para Linux.

Pré-requisitos

• Uma conta do GitHub onde você pode criar um repositório. Crie um gratuitamente.
• Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
• Uma organização e um projeto do Azure DevOps. Crie um gratuitamente.
• Capacidade de executar pipelines em agentes hospedados pela Microsoft. Você pode comprar um trabalho paralelo ou solicitar um nível gratuito.

Fork o projeto

Fork o seguinte repositório de exemplo no GitHub.

https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web-deploy

Criar as instâncias do Serviço de Aplicativo

Antes de implantar seu pipeline, você precisa primeiro criar uma instância do Serviço de Aplicativo para implantar. Você usará a CLI do Azure para criar a instância.

1. Inicie sessão no portal do Azure.

2. No menu, selecione Cloud Shell e a experiência Bash .

3. Gere um número aleatório que torne o nome de domínio do seu aplicativo Web exclusivo. A vantagem de ter um valor exclusivo é que sua instância do Serviço de Aplicativo não terá um conflito de nome com outros alunos que concluírem este tutorial.

   webappsuffix=$RANDOM    
   

4. Abra um prompt de comando e use um az group create comando para criar um grupo de recursos chamado tailspin-space-game-rg que contém todas as suas instâncias do Serviço de Aplicativo. Atualize o valor para usar a location região mais próxima.

   az group create --location eastus --name tailspin-space-game-rg
   

5. Use o prompt de comando para criar um plano do Serviço de Aplicativo.

   az appservice plan create \
     --name tailspin-space-game-asp \
     --resource-group tailspin-space-game-rg \
     --sku B1 \
     --is-linux
   

6. No prompt de comando, crie duas instâncias do Serviço de Aplicativo, uma para cada instância (Dev e Staging) com o az webapp create comando.

   az webapp create \
     --name tailspin-space-game-web-dev-$webappsuffix \
     --resource-group tailspin-space-game-rg \
     --plan tailspin-space-game-asp \
     --runtime "DOTNET|6.0"
   
   az webapp create \
     --name tailspin-space-game-web-staging-$webappsuffix \
     --resource-group tailspin-space-game-rg \
     --plan tailspin-space-game-asp \
     --runtime "DOTNET|6.0"
   

7. Com o prompt de comando, liste ambas as instâncias do Serviço de Aplicativo para verificar se elas estão sendo executadas com o az webapp list comando.

   az webapp list \
     --resource-group tailspin-space-game-rg \
     --query "[].{hostName: defaultHostName, state: state}" \
     --output table
   

8. Copie os nomes das instâncias do Serviço de Aplicativo para usar como variáveis na próxima seção.

Crie seu projeto e variáveis do Azure DevOps

Configure seu projeto do Azure DevOps e um pipeline de compilação. Você também adicionará variáveis para suas instâncias de desenvolvimento e preparação.

Seu pipeline de construção:

• Inclui um gatilho que é executado quando há uma alteração de código para ramificação
• Define duas variáveis buildConfiguration e releaseBranchName
• Inclui um estágio chamado Build que cria o aplicativo Web
• Publica um artefato que você usará em um estágio posterior

Adicionar o estágio Build

1. Entre na sua organização do Azure DevOps e vá para o seu projeto.

2. Vá para Pipelines e selecione Novo pipeline ou Criar pipeline se estiver criando seu primeiro pipeline.

3. Siga as etapas do assistente selecionando primeiro o GitHub como o local do código-fonte.

4. Poderá ser redirecionado para o GitHub para iniciar sessão. Em caso afirmativo, insira suas credenciais do GitHub.

5. Quando vir a lista de repositórios, selecione o repositório.

6. Você pode ser redirecionado para o GitHub para instalar o aplicativo Azure Pipelines. Em caso afirmativo, selecione Aprovar e instalar.

7. Quando a guia Configurar for exibida, selecione Pipeline inicial.

8. Substitua o conteúdo do azure-pipelines.yml por este código.

   trigger:
   - '*'
   
   variables:
     buildConfiguration: 'Release'
     releaseBranchName: 'release'
   
   stages:
   - stage: 'Build'
     displayName: 'Build the web application'
     jobs: 
     - job: 'Build'
       displayName: 'Build job'
       pool:
         vmImage: 'ubuntu-20.04'
         demands:
         - npm
   
       variables:
         wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
         dotnetSdkVersion: '6.x'
   
       steps:
       - task: UseDotNet@2
         displayName: 'Use .NET SDK $(dotnetSdkVersion)'
         inputs:
           version: '$(dotnetSdkVersion)'
   
       - task: Npm@1
         displayName: 'Run npm install'
         inputs:
           verbose: false
   
       - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
         displayName: 'Compile Sass assets'
   
       - task: gulp@1
         displayName: 'Run gulp tasks'
   
       - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
         displayName: 'Write build info'
         workingDirectory: $(wwwrootDir)
   
       - task: DotNetCoreCLI@2
         displayName: 'Restore project dependencies'
         inputs:
           command: 'restore'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Build the project - $(buildConfiguration)'
         inputs:
           command: 'build'
           arguments: '--no-restore --configuration $(buildConfiguration)'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Publish the project - $(buildConfiguration)'
         inputs:
           command: 'publish'
           projects: '**/*.csproj'
           publishWebProjects: false
           arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
           zipAfterPublish: true
   
       - publish: '$(Build.ArtifactStagingDirectory)'
         artifact: drop
   

9. Quando estiver pronto, selecione Salvar e executar.

Adicionar variáveis de instância

1. No Azure DevOps, vá para Biblioteca de Pipelines>.

2. Selecione + Grupo de variáveis.

3. Em Propriedades, adicione Release para o nome do grupo de variáveis.

4. Crie duas variáveis para fazer referência aos seus nomes de host de desenvolvimento e preparação. Substitua o valor 1234 pelo valor correto para sua instância.

   Nome da variável	Valor de exemplo
   WebAppNameDev	tailspin-espaço-jogo-web-dev-1234
   WebAppNameStaging	tailspin-espaço-jogo-web-encenação-1234

5. Selecione Salvar para salvar suas variáveis.

Adicionar o estágio de desenvolvimento

Em seguida, você atualizará seu pipeline para promover sua compilação para o estágio de desenvolvimento .

1. No Azure Pipelines, vá para Pipelines>Pipelines.

2. Selecione Editar no menu contextual para editar seu pipeline.

   

3. Atualize azure-pipelines.yml para incluir um estágio de desenvolvimento. No estágio de desenvolvimento, seu pipeline irá:

   • Executar quando o estágio Build for bem-sucedido devido a uma condição

   • Baixar um artefato de drop

   • Implantar no Serviço de Aplicativo do Azure com uma conexão de serviço do Azure Resource Manager

     trigger:
     - '*'
     
     variables:
       buildConfiguration: 'Release'
       releaseBranchName: 'release'
     
     stages:
     - stage: 'Build'
       displayName: 'Build the web application'
       jobs: 
       - job: 'Build'
         displayName: 'Build job'
         pool:
           vmImage: 'ubuntu-20.04'
           demands:
           - npm
     
         variables:
           wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
           dotnetSdkVersion: '6.x'
     
         steps:
         - task: UseDotNet@2
           displayName: 'Use .NET SDK $(dotnetSdkVersion)'
           inputs:
             version: '$(dotnetSdkVersion)'
     
         - task: Npm@1
           displayName: 'Run npm install'
           inputs:
             verbose: false
     
         - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
           displayName: 'Compile Sass assets'
     
         - task: gulp@1
           displayName: 'Run gulp tasks'
     
         - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
           displayName: 'Write build info'
           workingDirectory: $(wwwrootDir)
     
         - task: DotNetCoreCLI@2
           displayName: 'Restore project dependencies'
           inputs:
             command: 'restore'
             projects: '**/*.csproj'
     
         - task: DotNetCoreCLI@2
           displayName: 'Build the project - $(buildConfiguration)'
           inputs:
             command: 'build'
             arguments: '--no-restore --configuration $(buildConfiguration)'
             projects: '**/*.csproj'
     
         - task: DotNetCoreCLI@2
           displayName: 'Publish the project - $(buildConfiguration)'
           inputs:
             command: 'publish'
             projects: '**/*.csproj'
             publishWebProjects: false
             arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
             zipAfterPublish: true
     
         - publish: '$(Build.ArtifactStagingDirectory)'
           artifact: drop
     
     - stage: 'Dev'
       displayName: 'Deploy to the dev environment'
       dependsOn: Build
       condition:  succeeded()
       jobs:
       - deployment: Deploy
         pool:
           vmImage: 'ubuntu-20.04'
         environment: dev
         variables:
         - group: Release
         strategy:
           runOnce:
             deploy:
               steps:
               - download: current
                 artifact: drop
               - task: AzureWebApp@1
                 displayName: 'Azure App Service Deploy: dev website'
                 inputs:
                   azureSubscription: 'your-subscription'
                   appType: 'webAppLinux'
                   appName: '$(WebAppNameDev)'
                   package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
     

4. Altere a tarefa para utilizar a AzureWebApp@1 sua subscrição.

   1. Selecione Configurações para a tarefa.

      

   2. Atualize o valor da Subscrição do Azure para utilizar a your-subscription sua própria subscrição. Poderá ter de autorizar o acesso como parte deste processo. Se você tiver um problema ao autorizar seu recurso no editor YAML, uma abordagem alternativa é criar uma conexão de serviço.

      

   3. Defina o tipo de aplicativo como Aplicativo Web no Linux.

   4. Selecione Adicionar para atualizar a tarefa.

5. Guarde e execute o pipeline.

Adicionar o estágio de preparo

Por último, você promoverá o estágio de desenvolvimento para Preparação. Ao contrário do ambiente de desenvolvimento, você deseja ter mais controle no ambiente de preparo e adicionará uma aprovação manual.

Criar ambiente de preparo

1. Em Azure Pipelines, selecione Environments.

2. Selecione Novo ambiente.

3. Crie um novo ambiente com o nome preparo e Recurso definido como Nenhum.

4. Na página Ambiente de preparação, selecione Aprovações e verificações.

   

5. Selecione Aprovações.

6. Em Aprovadores, selecione Adicionar utilizadores e grupos e, em seguida, selecione a sua conta.

7. Em Instruções para aprovadores, escreva Aprovar esta alteração quando estiver pronto para preparação.

8. Selecione Guardar.

Adicionar novo estágio ao pipeline

Você adicionará um novo estágio Staging ao pipeline que inclui uma aprovação manual.

1. Edite seu arquivo de pipeline e adicione a Staging seção.

   trigger:
   - '*'
   
   variables:
     buildConfiguration: 'Release'
     releaseBranchName: 'release'
   
   stages:
   - stage: 'Build'
     displayName: 'Build the web application'
     jobs: 
     - job: 'Build'
       displayName: 'Build job'
       pool:
         vmImage: 'ubuntu-20.04'
         demands:
         - npm
   
       variables:
         wwwrootDir: 'Tailspin.SpaceGame.Web/wwwroot'
         dotnetSdkVersion: '6.x'
   
       steps:
       - task: UseDotNet@2
         displayName: 'Use .NET SDK $(dotnetSdkVersion)'
         inputs:
           version: '$(dotnetSdkVersion)'
   
       - task: Npm@1
         displayName: 'Run npm install'
         inputs:
           verbose: false
   
       - script: './node_modules/.bin/node-sass $(wwwrootDir) --output $(wwwrootDir)'
         displayName: 'Compile Sass assets'
   
       - task: gulp@1
         displayName: 'Run gulp tasks'
   
       - script: 'echo "$(Build.DefinitionName), $(Build.BuildId), $(Build.BuildNumber)" > buildinfo.txt'
         displayName: 'Write build info'
         workingDirectory: $(wwwrootDir)
   
       - task: DotNetCoreCLI@2
         displayName: 'Restore project dependencies'
         inputs:
           command: 'restore'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Build the project - $(buildConfiguration)'
         inputs:
           command: 'build'
           arguments: '--no-restore --configuration $(buildConfiguration)'
           projects: '**/*.csproj'
   
       - task: DotNetCoreCLI@2
         displayName: 'Publish the project - $(buildConfiguration)'
         inputs:
           command: 'publish'
           projects: '**/*.csproj'
           publishWebProjects: false
           arguments: '--no-build --configuration $(buildConfiguration) --output $(Build.ArtifactStagingDirectory)/$(buildConfiguration)'
           zipAfterPublish: true
   
       - publish: '$(Build.ArtifactStagingDirectory)'
         artifact: drop
   
   - stage: 'Dev'
     displayName: 'Deploy to the dev environment'
     dependsOn: Build
     condition:  succeeded()
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: dev
       variables:
       - group: Release
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: dev website'
               inputs:
                 azureSubscription: 'your-subscription'
                 appType: 'webAppLinux'
                 appName: '$(WebAppNameDev)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Staging'
     displayName: 'Deploy to the staging environment'
     dependsOn: Dev
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: staging
       variables:
       - group: 'Release'
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: staging website'
               inputs:
                 azureSubscription: 'your-subscription'
                 appType: 'webAppLinux'
                 appName: '$(WebAppNameStaging)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   

2. Altere a tarefa no estágio de preparo AzureWebApp@1 para usar sua assinatura.

   1. Selecione Configurações para a tarefa.

      

   2. Atualize o valor da Subscrição do Azure para utilizar a your-subscription sua própria subscrição. Poderá ter de autorizar o acesso como parte deste processo.

      

   3. Defina o tipo de aplicativo como Aplicativo Web no Linux.

   4. Selecione Adicionar para atualizar a tarefa.

3. Vá para a execução do pipeline. Observe a compilação enquanto ela é executada. Quando chega Staging, o pipeline aguarda a aprovação manual da liberação. Você também receberá um e-mail informando que tem um pipeline pendente de aprovação.

   

4. Revise a aprovação e permita que o pipeline seja executado.

   

Clean up resources (Limpar recursos)

Se você não vai continuar a usar esse aplicativo, exclua o grupo de recursos no portal do Azure e o projeto no Azure DevOps com as seguintes etapas:

Para limpar seu grupo de recursos:

1. Aceda ao Portal do Azure e inicie sessão.

2. Na barra de menus, selecione Cloud Shell. Quando solicitado, selecione a experiência Bash .

   

3. Execute o seguinte comando az group delete para excluir o grupo de recursos que você usou, tailspin-space-game-rg.

   az group delete --name tailspin-space-game-rg
   

Para excluir seu projeto de DevOps do Azure, incluindo o pipeline de compilação, consulte Excluir projeto.

Conteúdos relacionados

• Principais conceitos para novos usuários do Azure Pipelines
• Implementar no Serviço de Aplicações com o Azure Pipelines