Exercício – Promover para o Preparo

• 8 minutos

Agora, seu pipeline de lançamento tem três fases: Build, Desenvolvimento e Teste. Você e a equipe da Tailspin têm mais uma fase para implementar: Preparo.

Nesta parte, você vai:

Criar o ambiente de preparo

Aqui, você cria no Azure Pipelines um ambiente para Preparo. Para fins de aprendizado, você atribui a si mesmo como aprovador. Na prática, você atribuiria os usuários necessários para aprovar as alterações antes que elas se movam para a próxima fase. Para a equipe da Tailspin, Marina aprova as alterações para que elas possam ser promovidas do Teste para o Preparo.

Anteriormente neste módulo, você especificou configurações de environment para as fases de Desenvolvimento e Teste. Veja um exemplo para a fase de Desenvolvimento.

- stage: 'Deploy'
  displayName: 'Deploy the web application'
  dependsOn: Build
  jobs:
  - deployment: Deploy
    pool:
      vmImage: 'ubuntu-20.04'
    environment: dev
    variables:
    - group: Release

Você pode definir, por meio do Azure Pipelines, um ambiente que inclua critérios específicos para sua versão. Esses critérios podem incluir os pipelines autorizados a implantar no ambiente. Você também pode especificar as aprovações humanas necessárias para promover a versão de uma fase para a próxima. Aqui, você especifica essas aprovações.

Para criar o ambiente de preparo:

1. No Azure Pipelines, selecione Environments.

   

2. Selecione Novo ambiente.

3. Em Name, insira preparo.

4. Deixe os outros campos com suas definições padrão.

5. Selecione Criar.

6. Na página do ambiente de preparo, abra o menu suspenso e selecione Aprovações e verificações.

   

7. Selecione Approvals.

8. Em Approvers, selecione Add users and groups e escolha sua conta.

9. Em Instructions to approvers, digite Approve this change when it's ready for staging.

10. Selecione Criar.

Promover alterações para o Preparo

Aqui, você modifica a configuração do pipeline para implantar o build na fase de Preparo.

1. No Visual Studio Code, modifique azure-pipelines.yml desta forma:

   trigger:
   - '*'
   
   variables:
     buildConfiguration: 'Release'
     releaseBranchName: 'release'
   
   schedules:
   - cron: '0 3 * * *'
     displayName: 'Deploy every day at 3 A.M.'
     branches:
       include:
       - release
     always: false 
   
   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: |
       and
       (
         succeeded(),
         eq(variables['Build.SourceBranchName'], variables['releaseBranchName'])
       )
     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: website'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameDev)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Test'
     displayName: 'Deploy to the test environment'
     dependsOn: Dev
     #condition: eq(variables['Build.Reason'], 'Schedule')
     jobs:
     - deployment: Deploy
       pool:
         vmImage: 'ubuntu-20.04'
       environment: test
       variables:
       - group: 'Release'
       strategy:
         runOnce:
           deploy:
             steps:
             - download: current
               artifact: drop
             - task: AzureWebApp@1
               displayName: 'Azure App Service Deploy: website'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameTest)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   
   - stage: 'Staging'
     displayName: 'Deploy to the staging environment'
     dependsOn: Test
     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: website'
               inputs:
                 azureSubscription: 'Resource Manager - Tailspin - Space Game'
                 appName: '$(WebAppNameStaging)'
                 package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
   

   Esse código adiciona a fase de Preparo. A fase é implantada no ambiente de preparo, que inclui uma aprovação de versão.

   Dica

   Você provavelmente percebeu que as três fases de implantação seguem etapas semelhantes. Você pode usar modelos para definir tarefas de build comuns uma vez e reutilizá-las várias vezes. Você já usou essa técnica no módulo Criar um pipeline de build com o Azure Pipelines. Para fins de aprendizado, repetimos as etapas em cada fase.

2. No terminal integrado, adicione azure-pipelines.yml ao índice. Em seguida, faça commit da alteração e efetue push dela para o GitHub.

   Dica

   Antes de executar esses comandos Git, salve azure-pipelines.yml.

   git add azure-pipelines.yml
   git commit -m "Deploy to Staging"
   git push origin release
   

3. No Azure Pipelines, acesse o build. Rastreie o build enquanto ele é executado.

   Quando o build chegar ao Preparo, você verá que o pipeline espera que todas as verificações passem. Nesse caso, há uma verificação: a aprovação de versão manual.

   

   Você pode configurar o Azure DevOps para enviar uma notificação por email quando o build precisar de aprovação. Veja um exemplo:

   

4. Escolha Review>Approve.

   Na prática, para verificar se elas atendem às suas necessidades, você deve inspecionar as alterações.

5. Após a conclusão do build, abra um navegador da Web. Acesse a URL associada à instância do Serviço de Aplicativo do seu ambiente de preparo.

   Se ainda tiver a guia do navegador aberta, atualize a página. Se você não se lembrar da URL, localize-a no portal do Azure, na página Detalhes do Serviço de Aplicativo.

   Você verá que o site do Space Game está implantado no Serviço de Aplicativo e está em execução.

   

6. Como uma etapa opcional, no Azure Pipelines, selecione Environments. Em seguida, selecione o ambiente de preparo.

   O Azure Pipelines registra seu histórico de implantação, o que permite rastrear alterações no ambiente chegando até as confirmações de código e os itens de trabalho.

   

A equipe da Tailspin se reúne para discutir seu progresso. Marina aprova as alterações na fase de Teste enquanto os outros observam.

Pedro: Para dizer a verdade, no início eu estava um pouco preocupado com os pipelines de lançamento automatizados. Mas eu realmente gosto do que vejo funcionando agora. Cada fase pode ter o próprio ambiente, testes associados e aprovadores. O pipeline automatiza muitas coisas que tínhamos que fazer manualmente. Mas ainda temos controle onde precisamos.

Marina: Eu imaginaria algo semelhante para promover as alterações do Preparo para a Produção. Por falar nisso... quando adicionaremos um ambiente de produção?

Paulo: Em breve. Acho que ainda precisamos preencher algumas peças aqui antes de adicionarmos isso.