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

  • 10 Minuten

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.

    Screenshot of the default home page in Azure App Service.

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.

    Screenshot of a browser that shows the Space Game website in the Dev environment.