Vorherige

Nächste

Übung: Implementieren des Blau-Grün-Bereitstellungsmusters

Abgeschlossen

In Erstellen einer mehrstufigen Pipeline mithilfe von Azure Pipelines haben Sie eine grundlegende Bereitstellungspipeline erstellt, die eine Webanwendung in diesen Stages in Azure App Service bereitstellt: Entwicklung, Test und Staging.

Hier ergänzen Sie diesen Workflow, indem Sie das Blau-Grün-Bereitstellungsmuster beim Staging anwenden.

Dazu gehen Sie wie folgt vor:

• Fügen Sie der App Service-Instanz einen Bereitstellungsslot hinzu, der Staging entspricht.
• Fügen Sie der Pipeline einen Task hinzu, um die Bereitstellungsslots zu tauschen.

Hinzufügen eines Bereitstellungsslots

Hier fügen Sie der App Service-Instanz einen Bereitstellungsslot hinzu, der Staging entspricht.

Standardmäßig bietet jede App Service-Instanz einen Standardslot namens Produktion. Sie haben die Pipeline im vorherigen Abschnitt beim Einrichten im Produktionsslot bereitgestellt.

Eine App Service-Instanz kann über mehrere Slots verfügen. Hier fügen Sie der App Service-Instanz einen zweiten Bereitstellungsslot hinzu, der Staging entspricht. Der Bereitstellungsslot hat den Namen swap.

So fügen Sie den Slot hinzu

1. Wechseln Sie zum Azure-Portal, und melden Sie sich an.

2. Wählen Sie im Menü Cloud Shell aus. Wählen Sie Bash aus, wenn Sie dazu aufgefordert werden.

3. Führen Sie den folgenden Befehl aus, um den Namen der App Service-Instanz abzurufen, die Staging entspricht, und um das Ergebnis in einer Bash-Variablen namens staging zu speichern.

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

   Das Argument --query verwendet JMESPath, eine Abfragesprache für JSON. Das Argument wählt die App Service-Instanz aus, deren name-Feld „tailspin-space-game-web-staging“ enthält.

4. Geben Sie die Variable staging aus, um zu überprüfen, ob Sie den richtigen Namen abrufen.

   echo $staging
   

   Dies ist ein Beispiel für die Ausgabe:

   tailspin-space-game-web-staging-1234
   

5. Führen Sie den folgenden Befehl aus, um einen Slot namens swap zu Ihrer Stagingumgebung hinzuzufügen.

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

6. Führen Sie den folgenden Befehl aus, um den Hostnamen Ihres Bereitstellungsslots aufzulisten.

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

   Das Ergebnis ähnelt der folgenden Ausgabe:

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

   Notieren Sie sich diesen Hostnamen zur späteren Verwendung.

7. Als optionalen Schritt rufen Sie Ihre Website in einem Browser auf. Die Standardhomepage wird angezeigt, da Sie Ihren Code noch nicht in diesen Slot bereitgestellt haben.

   

Standardmäßig kann über das Internet auf einen Bereitstellungsslot zugegriffen werden. In der Praxis könnten Sie ein virtuelles Azure-Netzwerk konfigurieren, das Ihren swap-Slot in einem Netzwerk platziert, der nicht vom Internet aus erreichbar ist, auf den aber nur Ihr Team zugreifen kann. Ihr Slot production wäre weiterhin vom Internet aus erreichbar.

Austauschen von Bereitstellungsslots beim Staging

Hier verwenden Sie den Task AzureAppServiceManage@0, um Bereitstellungsslots in Ihrer Stagingumgebung zu tauschen.

Sie können diesen Task auch verwenden, um einen Slot zu starten, zu beenden oder zu löschen. Oder Sie können ihn verwenden, um Websiteerweiterungen zu installieren oder um die fortlaufende Überwachung in App Service zu aktivieren.

1. Ändern Sie in Visual Studio Code azure-pipelines.yml mithilfe des folgenden Codes:

   Tipp

   Sie können die gesamte Datei ersetzen oder nur den hervorgehobenen Teil aktualisieren.

   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'
   

   Beachten Sie diese Änderungen:

   • Der Task AzureWebApp@1 gibt nun die folgenden Werte an:
     • Wenn deployToSlotOrASE auf true festgelegt ist, erfolgt die Bereitstellung in einem vorhandenen Bereitstellungsslot.
     • resourceGroupName gibt den Namen der Ressourcengruppe an. Dieser Wert ist erforderlich, wenn deployToSlotOrASE gleich true ist.
     • slotName gibt den Namen des Bereitstellungsslots an. Hier erfolgt die Bereitstellung im Slot swap.
   • Der neue Task, AzureAppServiceManage@0, tauscht die Bereitstellungsslots.
     • sourceSlot und targetSlot geben die zu tauschenden Slots an.
     • action gibt die durchzuführende Maßnahme an. Erinnern Sie sich daran, dass Sie diesen Task verwenden können, um einen Slot zu starten, zu beenden oder zu löschen. Hier gibt „Swap Slots“ (Slots tauschen) an, dass die Quell- und Zielslots vertauscht werden.

   Diese Konfiguration wird immer im Slot swap bereitgestellt. Sie vertauscht dann die Slots production und swap. Der Austausch stellt sicher, dass production auf die aktuellere Bereitstellung verweist.

2. Fügen Sie im integrierten Terminal azure-pipelines.yml zum Index hinzu. Committen Sie die Änderungen, und pushen Sie dann den Branch zu GitHub.

   Tipp

   Speichern Sie azure-pipelines.yml, bevor Sie diese Git-Befehle ausführen.

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

3. Verfolgen Sie die einzelnen Schritte des Buildvorgangs in Azure Pipelines.

Hinweis

Wenn der folgende Fehler ...'staging' slot did not respond to http ping. (CODE: 417) auftritt, versuchen Sie, den App-Dienst neu zu starten. Wenn das Problem weiterhin besteht, setzen Sie den automatischen Tausch für das Einschubfach zurück.

1. Als optionalen Schritt rufen Sie in einem Browser die URL auf, die der jeweiligen Stage entspricht.

   Obwohl Sie noch keine Änderungen an der Website vorgenommen haben, sehen Sie, dass die Space Game-Website erfolgreich in den einzelnen App Service-Umgebungen bereitgestellt wurde.

   

Weiter