Tutorial: criar um pipeline de várias fases com o Azure DevOps

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

Você pode usar um pipeline de várias fases do Azure DevOps para dividir o processo de CI/CD em fases que representam diferentes partes do ciclo de desenvolvimento. O uso de um pipeline de várias fases 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:

• Compilação: compilar o código-fonte e produzir um pacote
• Desenvolvimento: implantar o pacote em um site de desenvolvimento para testes
• Preparação: implantar em uma instância de preparação do Serviço de Aplicativo do Azure com uma verificação de aprovação manual

Em um cenário real, você pode ter outra fase para a implantação em produção, dependendo do processo de DevOps.

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

Pré-requisitos

• Uma conta do GitHub, na qual você pode criar um repositório. Crie um gratuitamente.
• Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente.
• Uma organização e um projeto do Azure DevOps. Crie um gratuitamente.
• Uma capacidade de executar pipelines em agentes hospedados pela Microsoft. Você pode comprar um trabalho paralelo ou solicitar uma camada gratuita.

Criar fork do projeto

Crie um fork do 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 o pipeline, você precisa primeiro criar uma instância do Serviço de Aplicativo para a implantação. Você usará a CLI do Azure para criar a instância.

1. Entre no portal do Azure.

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

3. Gerar um número aleatório que torne exclusivo o nome de domínio do seu aplicativo Web. 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 estudantes que estiverem concluindo este tutorial.

   webappsuffix=$RANDOM    
   

4. Abra um prompt de comando e use um comando az group create para criar um grupo de recursos chamado tailspin-space-game-rg que contenha todas as instâncias do Serviço de Aplicativo. Atualize o valor location para usar sua 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 (Desenvolvimento e Preparo) com o comando az webapp create.

   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 as duas instâncias do Serviço de Aplicativo para verificar se estão sendo executadas com o comando az webapp list.

   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 usá-los como variáveis na próxima seção.

Criar projeto e variáveis do Azure DevOps

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

O pipeline de build:

• Inclui um gatilho que é executado quando há uma alteração de código na branch
• Define duas variáveis, buildConfiguration e releaseBranchName
• Inclui uma fase chamada Compilação que cria o aplicativo Web
• Publica um artefato que será usado em uma fase posterior

Adicione o estágio de Compilação

1. Entre na organização do Azure DevOps e acesse seu projeto.

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

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

4. Você pode ser redirecionado para o GitHub para então entrar. Nesse caso, insira suas credenciais do GitHub.

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

6. Você poderá ser redirecionado ao GitHub para instalar o aplicativo do Azure Pipelines. Se sim, 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. Ao final, selecione Salvar e executar.

Adicionar variáveis de instância

1. No Azure DevOps, acesse Pipelines>Biblioteca.

2. Selecione + Variable group.

3. Em Propriedades, adicione a Versão para o nome do grupo de variáveis.

4. Crie duas variáveis para se referir aos nomes dos hosts de desenvolvimento e de preparação. Substitua o valor 1234 pelo valor correto para a instância.

   Nome da variável	Valor de exemplo
   WebAppNameDev	tailspin-space-game-web-dev-1234
   WebAppNameStaging	tailspin-space-game-web-staging-1234

5. Selecione Salvar para salvar as variáveis.

Adicionar a fase de Desenvolvimento

Em seguida, você atualizará o pipeline para promover sua compilação para a fase de Desenvolvimento.

1. No Azure Pipelines, acesse Pipelines>Pipelines.

2. Selecione Editar no menu de contexto para editar o pipeline.

   

3. Atualize o azure-pipelines.yml para incluir uma fase de Desenvolvimento. Na fase de Desenvolvimento, o pipeline irá:

   • Ser executado quando a fase de Compilação for bem-sucedida devido a uma condição

   • Fazer download de 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 AzureWebApp@1 para usar sua assinatura.

   1. Selecione Configurações para a tarefa.

      

   2. Atualize o valor your-subscription da Assinatura do Azure para usar sua própria assinatura. Talvez seja necessário autorizar o acesso como parte desse processo. Se você tiver um problema ao autorizar o recurso no editor YAML, uma abordagem alternativa será 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. Salve e execute o seu pipeline.

Adicionar a fase de Preparo

Por fim, você promoverá a fase de Desenvolvimento para a de Preparo. Ao contrário do ambiente de Desenvolvimento, você deseja ter mais controle no ambiente de preparo; para isso, adicione uma aprovação manual.

Criar ambiente de preparo

1. No Azure Pipelines, selecione Environments.

2. Selecione Novo ambiente.

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

4. Na página do ambiente de preparo, selecione Aprovações e verificações.

   

5. Selecione Approvals.

6. Em Aprovadores, selecione Adicionar usuários e grupos e, em seguida, selecione a conta.

7. Em Instruções para aprovadores, escreva Aprovar essa alteração quando ela estiver pronta para o preparo.

8. Selecione Salvar.

Adicionar nova fase ao pipeline

Você adicionará uma nova fase, Staging ao pipeline que inclui uma aprovação manual.

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

   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 AzureWebApp@1 na fase de Preparo para usar sua assinatura.

   1. Selecione Configurações para a tarefa.

      

   2. Atualize o valor your-subscription da Assinatura do Azure para usar sua própria assinatura. Talvez seja necessário autorizar o acesso como parte desse 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 o build enquanto ele é executado. Quando ele atinge Staging, o pipeline aguarda a aprovação manual da liberação. Você também receberá um email informando que tem um pipeline pendente de aprovação.

   

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

   

Limpar os recursos

Se você não quiser 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 o grupo de recursos:

1. Acesse o portal do Azure e entre.

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

   

3. Execute o comando az group delete a seguir 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 do Azure DevOps, incluindo o pipeline de build, confira Excluir projeto.

Conteúdo relacionado

• Principais conceitos para novos usuários do Azure Pipelines
• Implantar no Serviço de Aplicativo usando o Azure Pipelines