Exercício - Promover a Encenação

8 minutos

Seu pipeline de lançamento agora tem três estágios: Compilação, Desenvolvimento e Teste. Você e a equipe do Tailspin têm mais um estágio para implementar: o preparo.

Nesta parte, você:

Crie o ambiente de preparo no Azure Pipelines e atribua-se como aprovador.
Defina o estágio de preparo , que é executado somente depois que um aprovador verifica os resultados do estágio de teste .

Criar o ambiente de preparo

Aqui, você cria um ambiente no Azure Pipelines for Staging. Para fins de aprendizagem, você se atribui como aprovador. Na prática, você atribuiria os usuários que são obrigados a aprovar as alterações antes que elas passem para a próxima etapa. Para a equipe Tailspin, Amita aprova mudanças para que possam ser promovidas de Teste para Encenação.

No início deste módulo, você especificou environment configurações para os estágios de desenvolvimento e teste . Aqui está um exemplo para o estágio 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 um ambiente por meio do Azure Pipelines que inclui 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 liberação de um estágio para o outro. Aqui, você especifica essas aprovações.

Para criar o ambiente de preparação :

Em Azure Pipelines, selecione Environments.
Selecione Novo ambiente.
Em Nome, insira preparo.
Deixe os campos restantes em seus valores padrão.
Selecione Criar.
Na página Ambiente de preparação , abra a lista suspensa e selecione Aprovações e verificações.
Selecione Aprovações.
Em Aprovadores, selecione Adicionar utilizadores e grupos e, em seguida, selecione a sua conta.
Em Instruções para aprovadores, insira Aprovar esta alteração quando ela estiver pronta para preparação.
Selecione Criar.

Promover alterações no preparo

Aqui você modifica sua configuração de pipeline para implantar a compilação no estágio de preparo .

No Visual Studio Code, modifique azure-pipelines.yml da seguinte maneira:

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'

Este código adiciona o estágio de preparo . O estágio é implantado no ambiente de preparação, que inclui uma aprovação de versão.

Gorjeta

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

No terminal integrado, adicione azure-pipelines.yml ao índice. Em seguida, confirme a alteração e envie-a para o GitHub.

Gorjeta

Antes de executar esses comandos do Git, salve azure-pipelines.yml.
```
git add azure-pipelines.yml
git commit -m "Deploy to Staging"
git push origin release
```
No Azure Pipelines, vá para a compilação. Rastreie a compilação enquanto ela é executada.

Quando a compilação atinge o preparo, você vê que o pipeline aguarda a aprovação de todas as verificações. Neste caso, há uma verificação - a aprovação de liberação manual.

Você pode configurar o Azure DevOps para enviar uma notificação por email quando a compilação exigir aprovação. Eis um exemplo:
Selecione Rever>Aprovar.

Na prática, para verificar se eles atendem aos seus requisitos, você inspecionaria as alterações.
Após a conclusão da compilação, abra um navegador da Web. Vá para a URL associada à instância do Serviço de Aplicativo para seu ambiente de preparação .

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

Você vê que o site do Jogo Espacial está implantado no Serviço de Aplicativo e em execução.
Como etapa opcional, no Azure Pipelines, selecione Ambientes. Em seguida, selecione o ambiente de preparação .

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

A equipa da Tailspin reúne-se para discutir o seu progresso. Amita aprova mudanças na fase de testes enquanto os outros assistem.

Tim: Para dizer a verdade, no início eu estava um pouco nervoso com os pipelines de liberação automatizados. Mas eu realmente gosto disso agora que eu vejo isso funcionando. Cada estágio pode ter seu próprio ambiente, testes associados e aprovadores. O pipeline automatiza muitas coisas que tivemos que fazer manualmente. Mas ainda temos controle onde precisamos.

Amita: Eu poderia imaginar que fizéssemos algo semelhante para promover mudanças de Encenação para Produção. Por falar em... Quando adicionamos um ambiente de produção ?

Andy: Em breve. Penso que ainda precisamos de preencher algumas peças aqui antes de acrescentarmos isso.

Continuar

Exercício - Promover a Encenação

Criar o ambiente de preparo

Promover alterações no preparo

Comentários