Oefening: het blauwgroene implementatiepatroon implementeren

Voltooid

In Een pijplijn met meerdere fasen maken met behulp van Azure Pipelines, hebt u in deze fasen een eenvoudige implementatiepijplijn gebouwd waarmee een webtoepassing in Azure App Service wordt geïmplementeerd: Dev, Testen Fasering.

Hier draagt u bij aan die werkstroom door het blauwgroene implementatiepatroon toe te passen tijdens de stagingfase.

Hiervoor gaat u als volgt te werk:

• Voeg een implementatieslot toe aan het App Service-exemplaar dat overeenkomt met Staging.
• Voeg een taak toe aan de pijplijn om de implementatieslots te wisselen.

Een uitvoeringsslot toevoegen

Hier voegt u een implementatieslot toe aan het App Service-exemplaar dat overeenkomt met Fase.

Standaard biedt elk App Service-exemplaar een standaardslot, genaamd productie-. U hebt gedeployed naar het productieslot toen u de pijplijn opzette in de vorige sectie.

Een App Service-exemplaar kan meerdere slots hebben. Hier voegt u een tweede implementatie-slot toe aan het App Service-exemplaar dat overeenkomt met Staging. Het implementatieslot heet wissel.

De slot toevoegen:

1. Ga naar de Azure Portal en meld u aan.

2. Selecteer in het menu Cloud Shell. Wanneer u hierom wordt gevraagd, selecteert u de Bash ervaring.

3. Voer de volgende opdracht uit om de naam op te halen van het App Service-exemplaar dat overeenkomt met faserings- en om het resultaat op te slaan in een Bash-variabele met de naam staging.

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

   Het argument --query maakt gebruik van JMESPath-, een querytaal voor JSON. Het argument selecteert het App Service-exemplaar waarvan het veld name 'tailspin-space-game-web-staging' bevat.

4. Druk de staging variabele af om te controleren of u de juiste naam krijgt.

   echo $staging
   

   Hier volgt een voorbeeld van de uitvoer:

   tailspin-space-game-web-staging-1234
   

5. Voer de volgende opdracht uit om een site met de naam wisselen toe te voegen aan uw faseringsomgeving.

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

6. Voer de volgende opdracht uit om de hostnaam van uw implementatiesite weer te geven.

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

   Het resultaat lijkt op deze uitvoer:

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

   Noteer deze hostnaam voor later.

7. Als optionele stap gaat u naar uw site in een browser. U ziet de standaardstartpagina omdat u uw code nog niet hebt geïmplementeerd in deze slot.

   

Standaard is een implementatieslot toegankelijk vanaf internet. In de praktijk kunt u een virtueel Azure-netwerk configureren waarmee uw wisselsleuf in een netwerk wordt geplaatst dat niet bereikbaar is vanaf internet en die alleen toegankelijk is voor uw team. Uw productie slot zou bereikbaar blijven vanaf het internet.

Implementatieslots wisselen in Staging

Hier gebruikt u de AzureAppServiceManage@0 taak om implementatiesleuven te wisselen in uw stagingomgeving.

U kunt deze taak ook gebruiken om een slot te starten, te stoppen of te verwijderen. U kunt deze ook gebruiken om site-extensies te installeren of continue bewaking in Te schakelen in App Service.

1. Wijzig in Visual Studio Code azure-pipelines.yml met behulp van deze code:

   Fooi

   U kunt het hele bestand vervangen of het gedeelte bijwerken dat is gemarkeerd.

   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'
   

   Let op deze wijzigingen:

   • De AzureWebApp@1 taak geeft nu de volgende waarden op:
     • deployToSlotOrASE, wanneer ingesteld op true, wordt geïmplementeerd in een bestaand implementatieslot.
     • resourceGroupName geeft de naam van de resourcegroep op. Deze waarde is vereist wanneer deployToSlotOrASE is true.
     • slotName specificeert de naam van het implementatieslot. Hier implementeert u in de slot die de naam heeft naar.
   • De nieuwe taak, AzureAppServiceManage@0, wisselt de implementatieslots.
     • sourceSlot en targetSlot specificeren de sleuven die moeten worden gewisseld.
     • action geeft de actie op die moet worden uitgevoerd. Onthoud dat u deze taak kunt gebruiken om een slot te starten, te stoppen of te verwijderen. Hier geeft 'Swap Slots' aan dat de bron- en doelsites moeten worden gewisseld.

   Deze configuratie wordt altijd geïmplementeerd in de wissel slot. Vervolgens worden de productie en de sleuven gewisseld. Het wisselproces zorgt ervoor dat productie verwijst naar de recentere implementatie.

2. Voeg in de geïntegreerde terminal azure-pipelines.yml toe aan de index. Voer de wijzigingen door en push de vertakking vervolgens naar GitHub.

   Tip

   Sla azure-pipelines.yml op voordat u deze Git-opdrachten uitvoert.

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

3. Traceer in Azure Pipelines de build via elk van de stappen.

Notitie

Als de volgende fout optreedt ...'staging' slot did not respond to http ping. (CODE: 417) probeert u de app-service opnieuw te starten. Als het probleem zich blijft voordoen, reset de automatische wisseling voor uw slot.

1. Als optionele stap gaat u in een browser naar de URL die overeenkomt met elke fase.

   Hoewel u nog geen wijzigingen hebt aangebracht aan de website, ziet u dat de Space Game website is geïmplementeerd in elke App Service-omgeving.