Esercizio - Implementa il modello di distribuzione blu-verde

• 10 minuti

In Creare una pipeline multifase usando Azure Pipelines è stata creata una pipeline di distribuzione di base che distribuisce un'applicazione Web nel Servizio app di Azure in queste fasi: Dev, Test e Staging.

In questa sezione si integrerà il flusso di lavoro applicando il modello di distribuzione blu verde durante la fase di gestione temporanea (Staging).

A tale scopo, è necessario:

Aggiungere uno slot di distribuzione

In questa sezione si aggiungerà uno slot di distribuzione all'istanza del servizio app corrispondente alla fase di gestione temporanea (Staging).

Per impostazione predefinita, ogni istanza del servizio app fornisce uno slot predefinito, denominato produzione. La distribuzione nello slot produzione è stata effettuata al momento della configurazione della pipeline nella sezione precedente.

Un'istanza del servizio app può disporre di più slot. In questa sezione si aggiungerà un secondo slot di distribuzione all'istanza del servizio app corrispondente ala fase di gestione temporanea (Staging). Lo slot di distribuzione è denominato scambio.

Per aggiungere lo slot:

1. Aprire il portale di Azure e accedere.

2. Scegli Cloud Shell dal menu. Quando viene richiesto, seleziona l'esperienza Bash.

3. Esegui questo comando per ottenere il nome dell'istanza del servizio app corrispondente alla fase di gestione temporanea (Staging) e per archiviare il risultato in una variabile Bash denominata staging.

   staging=$(az webapp list \
     --resource-group tailspin-space-game-rg \
     --query "[?contains(@.name, 'tailspin-space-game-web-staging')].{name: name}" \
     --output tsv)
   

   L'--queryargomento usa JMESPath, un linguaggio di query per JSON. L’argomento seleziona l'istanza del servizio app il cui campo name contiene "tailspin-space-game-web-staging".

4. Stampa la variabile staging per verificare che si ottenga il nome corretto.

   echo $staging
   

   Ecco un esempio di output:

   tailspin-space-game-web-staging-1234
   

5. Esegui questo comando per aggiungere uno slot denominato scambio all'ambiente di gestione temporanea (staging).

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

6. Esegui questo comando per elencare il nome host dello slot di distribuzione.

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

   Il risultato è simile a questo output:

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

   Prendi nota del nome host per usarlo in seguito.

7. Come passaggio facoltativo, visita il sito in un browser. Verrà visualizzata la home page predefinita perché il codice non è ancora stato distribuito in questo slot.

   

Per impostazione predefinita, uno slot di distribuzione è accessibile da Internet. Nella pratica, puoi configurare una rete virtuale di Azure che posiziona lo slot scambio in una rete non instradabile da Internet, ma accessibile solo al team. Lo slot produzione continuerebbe a essere raggiungibile da Internet.

Scambia gli slot di distribuzione nell'ambiente di gestione temporanea (Staging)

In questa sezione si userà l'attività AzureAppServiceManage@0 per scambiare gli slot di distribuzione nell'ambiente di staging.

Puoi anche usare questa attività per avviare, arrestare o eliminare uno slot. In alternativa, puoi usarla per installare estensioni del sito o per abilitare il monitoraggio continuo nel servizio app.

1. In Visual Studio Code, modifica azure-pipelines.yml usando questo codice:

   Suggerimento

   Puoi sostituire l'intero file o aggiornare solo il percorso evidenziato.

   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'
   

   Osservare queste modifiche:

   • L'attività AzureWebApp@1 specifica ora i valori seguenti:
     • deployToSlotOrASE, se è impostato true, esegue la distribuzione in uno slot di distribuzione esistente.
     • resourceGroupName specifica il nome del gruppo di risorse. Questo valore è obbligatorio se per deployToSlotOrASE è impostato true.
     • slotName specifica il nome dello slot di distribuzione. In questa sezione la distribuzione verrà eseguita nello slot denominato scambio.
   • La nuova attività, AzureAppServiceManage@0, scambia gli slot di distribuzione.
     • sourceSlot e targetSlot specificano gli slot da scambiare.
     • action specifica l'azione da eseguire. Tieni presente che puoi anche usare questa attività per avviare, arrestare o eliminare uno slot. "Swap Slots"qui specifica di scambiare gli slot di origine e di destinazione.

   Questa configurazione viene sempre distribuita nello slot scambio. Quindi, scambia gli slot produzione e scambio. Il processo di scambio garantisce che lo slot produzione punti alla distribuzione più recente.

2. Nel terminale integrato, aggiungi azure-pipelines.yml all'indice. Esegui il commit delle modifiche, quindi esegui il push del ramo fino a GitHub.

   Suggerimento

   Salva azure-pipelines.yml prima di eseguire questi comandi Git.

   git add azure-pipelines.yml
   git commit -m "Swap deployment slots"
   git push origin blue-green
   

3. In Azure Pipelines, traccia la build in ogni passaggio.

1. Come passaggio facoltativo, in un browser passa all'URL corrispondente a ogni fase.

   Anche se non sono ancora state apportate modifiche al sito Web, noterai che il sito Web Space Game è stato distribuito correttamente in ogni ambiente del servizio app.