Exercício - Implementar o padrão de implantação azul-verde

10 minutos

Em Criar um pipeline de vários estágios usando o Azure Pipelines, você criou um pipeline de implantação básico que implanta um aplicativo Web no Serviço de Aplicativo do Azure nestes estágios: Dev, Teste de Preparo.

Aqui você adiciona a esse fluxo de trabalho aplicando o padrão de implantação de azul-verde durante de preparo .

Para tal, você:

Adicione um slot de implantação à instância do Serviço de Aplicações que corresponda a Preparação.
Adicione uma tarefa ao pipeline para trocar os slots de implantação.

Adicionar um slot de implantação

Aqui, adiciona-se um slot de implantação à instância do Serviço de Aplicações que corresponde a Staging.

Por padrão, cada instância do Serviço de Aplicativo fornece um slot padrão, chamado de produção. Você implantou no slot de produção quando configurou o pipeline na seção anterior.

Uma instância do Serviço de Aplicativo pode ter vários slots. Aqui adiciona um segundo slot de implantação à instância do App Service que corresponde a Staging. O slot de implantação é denominado swap.

Para adicionar o espaço:

Vá para o portal do Azure e inicie a sessão.
No menu, selecione Cloud Shell. Quando lhe for pedido, selecione a experiência Bash.
Execute o seguinte comando para obter o nome da instância do App Service que corresponde a Staging e para armazenar o resultado em uma variável do Bash com o nome staging.
```
staging=$(az webapp list \
  --resource-group tailspin-space-game-rg \
  --query "[?contains(@.name, 'tailspin-space-game-web-staging')].{name: name}" \
  --output tsv)
```
O argumento --query usa JMESPath, que é uma linguagem de consulta para JSON. O argumento seleciona a instância do Serviço de Aplicativo cujo campo name contém "tailspin-space-game-web-staging".
Imprima a variável staging para verificar se você obtém o nome correto.
```
echo $staging
```
Aqui está um exemplo da saída:
```
tailspin-space-game-web-staging-1234
```

Execute o seguinte comando para adicionar um slot chamado swap ao seu ambiente de preparação .

az webapp deployment slot create \
  --name $staging \
  --resource-group tailspin-space-game-rg \
  --slot swap

Corra o comando seguinte para listar o nome do host do seu slot de implementação.

az webapp deployment slot list \
    --name $staging \
    --resource-group tailspin-space-game-rg \
    --query [].hostNames \
    --output tsv

O resultado é semelhante a esta saída:

tailspin-space-game-web-staging-25391-swap.azurewebsites.net

Anote este nome de host para mais tarde.

Como etapa opcional, acesse seu site em um navegador. Você vê a página inicial padrão porque ainda não implantou seu código nesse slot.

Por padrão, um slot de implantação pode ser acessado pela Internet. Na prática, pode configurar uma rede virtual do Azure que coloque o seu slot de troca numa rede que não é acessível a partir da Internet, mas que apenas a sua equipa pode aceder. O seu slot de produção permaneceria acessível a partir da internet.

Alterar slots de implantação na fase de preparação

Aqui, você usa a tarefa AzureAppServiceManage@0 para trocar slots de implantação no seu ambiente de Staging.

Você também pode usar essa tarefa para iniciar, parar ou excluir um slot. Ou você pode usá-lo para instalar extensões de site ou para habilitar o monitoramento contínuo no Serviço de Aplicativo.

No Visual Studio Code, modifique azure-pipelines.yml com este código:

Dica

Você pode substituir o arquivo inteiro ou apenas atualizar a parte realçada.

trigger:
- '*'

variables:
  buildConfiguration: '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
  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
  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'
              deployToSlotOrASE: 'true'
              resourceGroupName: 'tailspin-space-game-rg'
              slotName: 'swap'
              appName: '$(WebAppNameStaging)'
              package: '$(Pipeline.Workspace)/drop/$(buildConfiguration)/*.zip'
          - task: AzureAppServiceManage@0
            displayName: 'Swap deployment slots'
            inputs:
              azureSubscription: 'Resource Manager - Tailspin - Space Game'
              resourceGroupName: 'tailspin-space-game-rg'
              webAppName: '$(WebAppNameStaging)'
              sourceSlot: 'swap'
              targetSlot: 'production'
              action: 'Swap Slots'

Observe estas alterações:

A tarefa AzureWebApp@1 agora especifica estes valores:
- deployToSlotOrASE, quando definido como true, implanta em um slot de implantação existente.
- resourceGroupName especifica o nome do grupo de recursos. Esse valor é necessário quando deployToSlotOrASE é true.
- slotName especifica o nome do slot de implantação. Aqui você implanta no slot chamado swap.
A nova tarefa, AzureAppServiceManage@0, troca os slots de implantação.
- sourceSlot e targetSlot especificam os slots a trocar.
- action especifica a ação a ser tomada. Lembre-se de que você pode usar essa tarefa para iniciar, parar ou excluir um slot. Aqui, "Swap Slots" indica trocar os slots de origem e destino.

Essa configuração sempre é implantada no swap slot. Em seguida, a produção troca e troca os slots. O processo de permuta garante que de produção aponte para a implantação mais recente.

No terminal integrado, adicione azure-pipelines.yml ao índice. Confirme as alterações e, em seguida, empurre a ramificação para o GitHub.

Dica

Salve azure-pipelines.yml antes de executar esses comandos do Git.
```
git add azure-pipelines.yml
git commit -m "Swap deployment slots"
git push origin blue-green
```
No Azure Pipelines, rastreie a compilação em todas as etapas.

Observação

Se você encontrar o seguinte erro ...'staging' slot did not respond to http ping. (CODE: 417) tente reiniciar o serviço de aplicativo. Se o problema persistir, redefina a troca automática para o seu slot.

Como etapa opcional, em um navegador, vá para o URL que corresponde a cada etapa.

Embora você ainda não tenha feito alterações no site, verá que o site do Space Game foi implantado com êxito em cada ambiente do Serviço de Aplicações.

Exercício - Implementar o padrão de implantação azul-verde

Adicionar um slot de implantação

Alterar slots de implantação na fase de preparação

Comentários