0Pricing
Cloud & IT Cert Prep · Lektion

Kontinuierliche Bereitstellung in Azure

Erweitern Sie die Pipeline um eine Bereitstellungsphase, die das Buildartefakt in einen App-Service-Slot überträgt, Smoke-Tests ausführt und es nach Genehmigung in die Produktion austauscht.

Kontinuierliche Bereitstellung in Azure ist eine kostenlose Cloud & IT Cert Prep-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Cloud & IT Cert Prep-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Cloud & IT Cert Prep-Kurs umfasst insgesamt 4 Lektionen.

Was ist Continuous Deployment?

Continuous Deployment (CD) stellt jede Änderung, die die CI-Tests besteht, ohne manuelles Eingreifen automatisch in der Produktion bereit. Continuous Delivery ist die abgeschwächte Variante: Die Bereitstellung bis zu einer Staging-Umgebung wird automatisiert, vor der Produktion ist jedoch ein menschliches Genehmigungstor erforderlich. Beide Praktiken basieren auf derselben Pipelineinfrastruktur. In Azure Pipelines wird CD implementiert, indem nach der CI-Stage Bereitstellungs-Stages hinzugefügt werden, die je nach Bedarf auf Azure-Umgebungen mit Genehmigungstoren abzielen.

Mehrstufige Pipeline: CI + CD

Eine vollständige CI/CD-Pipeline umfasst mindestens drei Stages: Build (kompilieren, testen, Artefakt veröffentlichen), Bereitstellung in Staging (Artefakt in einem Nichtproduktionsslot bereitstellen) und Bereitstellung in der Produktion (Slot austauschen oder nach Genehmigung bereitstellen). Stages geben das Artefakt über den Speicher für Pipelineartefakte weiter. Die Staging-Stage führt Integrations- oder Smoke-Tests automatisch aus; die Produktions-Stage wartet vor dem Fortfahren auf eine manuelle Genehmigung.

# azure-pipelines.yml: multi-stage CI/CD
trigger:
  branches:
    include: [main]

pool:
  vmImage: ubuntu-latest

stages:
- stage: Build
  jobs:
  - job: BuildApp
    steps:
    - script: npm ci && npm run build
    - task: PublishPipelineArtifact@1
      inputs: {targetPath: dist, artifactName: webapp}

- stage: DeployStaging
  dependsOn: Build
  jobs:
  - deployment: StagingDeploy
    environment: Staging
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs: {appName: myapp-staging, package: '$(Pipeline.Workspace)/webapp'}

- stage: DeployProduction
  dependsOn: DeployStaging
  jobs:
  - deployment: ProductionDeploy
    environment: Production   # Has manual approval gate
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs: {appName: myapp, package: '$(Pipeline.Workspace)/webapp'}

Bereitstellungsjobs und Umgebungen

Verwenden Sie für Bereitstellungs-Stages deployment-Jobs und keine normalen job-Jobs. Bereitstellungsjobs unterstützen Bereitstellungsstrategien (runOnce, rolling, canary), erfassen den Bereitstellungsverlauf pro Umgebung und müssen auf Azure-DevOps-Umgebungen verweisen. Eine Umgebung erfasst, welche Pipelineausführungen darin bereitgestellt wurden und welche Version derzeit aktiv ist. Außerdem stellt sie Genehmigungstore, Prüfungen und den Status der Ressourcenintegrität in einem einzigen Dashboard bereit.

# Deployment job with rolling strategy
- job: RollingDeploy
  strategy:
    rolling:
      maxParallel: 2     # Deploy to 2 targets at a time
      preDeploy:
        steps:
        - script: echo 'Pre-deploy checks'
      deploy:
        steps:
        - task: AzureWebApp@1
          inputs:
            appName: myapp
            package: '$(Pipeline.Workspace)/webapp'
      postRouteDeploy:
        steps:
        - script: curl -f https://myapp.azurewebsites.net/health

Bereitstellung in Azure App Service

Der Task AzureWebApp@1 stellt eine Webanwendung in Azure App Service bereit. Er unterstützt die Bereitstellung in einem bestimmten Slot (z. B. Staging) sowie die Bereitstellung von ZIP-Paketen, Docker-Images oder JAR-/WAR-Dateien. Nach der Bereitstellung in einem Staging-Slot verwenden Sie den Task AzureAppServiceManage@0, um den Staging-Slot in die Produktion zu tauschen – das ist das bevorzugte Bereitstellungsmuster ohne Ausfallzeit für App Service.

# Deploy to staging slot, then swap to production
steps:
- task: AzureWebApp@1
  displayName: 'Deploy to staging slot'
  inputs:
    azureSubscription: 'AzureProductionSC'
    appType: webAppLinux
    appName: myUniqueWebApp
    deployToSlotOrASE: true
    resourceGroupName: MyRG
    slotName: staging
    package: '$(Pipeline.Workspace)/webapp/app.zip'
    runtimeStack: 'NODE|18-lts'

- task: AzureAppServiceManage@0
  displayName: 'Swap staging into production'
  inputs:
    azureSubscription: 'AzureProductionSC'
    action: Swap Slots
    webAppName: myUniqueWebApp
    resourceGroupName: MyRG
    sourceSlot: staging

Smoke-Tests in der CD-Pipeline

Führen Sie nach der Bereitstellung in Staging Smoke-Tests aus – eine minimale Testsuite, die überprüft, ob die Bereitstellung erfolgreich war und die Anwendung korrekt antwortet. Smoke-Tests rufen typischerweise wichtige API-Endpunkte auf und überprüfen die erwarteten Statuscodes und Antwortinhalte. Wenn Smoke-Tests fehlschlagen, stoppt die Pipeline vor dem Tausch in die Produktion oder vor der Genehmigungsanforderung. So wird verhindert, dass eine fehlerhafte Version die Benutzer erreicht.

# Smoke test step after staging deployment
- script: |
    MAX_RETRY=10
    COUNT=0
    until curl -sf https://myUniqueWebApp-staging.azurewebsites.net/health; do
      COUNT=$((COUNT+1))
      if [ $COUNT -ge $MAX_RETRY ]; then
        echo 'Health check failed after $MAX_RETRY attempts'
        exit 1
      fi
      echo 'Waiting for app to start... attempt '$COUNT
      sleep 10
    done
    echo 'App is healthy'
  displayName: 'Smoke test: health endpoint'

Genehmigungstore für Umgebungen

Fügen Sie Azure-DevOps-Umgebungen Genehmigungstore hinzu, um vor dem Fortsetzen einer Bereitstellung eine manuelle Freigabe zu verlangen. Öffnen Sie die Umgebungseinstellungen und fügen Sie unter „Approvals“ Genehmigungen hinzu – legen Sie die Benutzer oder Gruppen fest, die genehmigen müssen. Wenn die Pipeline einen Bereitstellungsjob erreicht, der auf diese Umgebung zielt, wird sie angehalten und sendet eine E-Mail-Benachrichtigung. Genehmigende Personen können die Bereitstellungsdetails im Azure-DevOps-Portal oder über den Link in der Benachrichtigungs-E-Mail anzeigen und genehmigen oder ablehnen.

# Pipeline YAML: deployment to production environment
# (Approval configured in Azure DevOps portal on 'Production' environment)
- stage: DeployProduction
  displayName: 'Deploy to Production'
  dependsOn: DeployStaging
  condition: succeeded('DeployStaging')
  jobs:
  - deployment: ProdDeploy
    environment: Production   # <-- Triggers approval gate configured in portal
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureWebApp@1
            inputs:
              appName: myapp-prod
              package: '$(Pipeline.Workspace)/webapp/app.zip'

Bereitstellung in Azure Kubernetes Service

Stellen Sie containerisierte Anwendungen mit dem Task KubernetesManifest@0 in AKS bereit. Dieser Task wendet Kubernetes-YAML-Manifeste auf den Cluster an und unterstützt standardmäßig imagePullSecrets und Canary-Bereitstellungen. Stellen Sie über eine in Azure DevOps konfigurierte Kubernetes-Dienstverbindung eine Verbindung mit dem AKS-Cluster her. Der Task verwendet intern kubectl apply und wartet, bis das Rollout abgeschlossen ist, bevor der Step als erfolgreich markiert wird.

# AKS deployment step in Azure Pipelines
- task: KubernetesManifest@0
  displayName: 'Deploy to AKS'
  inputs:
    action: deploy
    kubernetesServiceConnection: 'AKS-Production-SC'
    namespace: production
    manifests: |
      k8s/deployment.yaml
      k8s/service.yaml
    containers: 'mycontainerregistry.azurecr.io/myapp:$(Build.BuildId)'
    imagePullSecrets: acr-secret

Strategie für Image-Tags

Versehen Sie Container-Images mit der Build-ID ($(Build.BuildId)) oder dem Git-Commit-SHA ($(Build.SourceVersion)), damit Sie jederzeit einen laufenden Container auf genau die Codeversion zurückführen können, aus der er erstellt wurde. Vermeiden Sie das Tag latest in der Produktion – Kubernetes cached es und ruft die neue Version möglicherweise nicht ab. Speichern Sie das spezifische Image-Tag als Pipelinevariable und fügen Sie es zum Bereitstellungszeitpunkt mithilfe von envsubst oder sed in Kubernetes-Manifeste ein.

# Tag and push image with build ID in CI stage
- script: |
    IMAGE='mycontainerregistry.azurecr.io/myapp'
    TAG='$(Build.BuildId)'
    docker build -t $IMAGE:$TAG -t $IMAGE:latest .
    az acr login --name mycontainerregistry
    docker push $IMAGE:$TAG
    docker push $IMAGE:latest
    echo "##vso[task.setvariable variable=imageTag;isOutput=true]$TAG"
  name: BuildImage
  displayName: 'Build and push container image'

Rollback-Strategien

Definieren Sie eine Rollback-Strategie für Produktionsbereitstellungen, damit Sie sich schnell von einem fehlerhaften Release erholen können. Bei App Service bedeutet ein Rollback, den Produktionsslot wieder auf die vorherige Staging-Version zurückzusetzen. Verwenden Sie für AKS kubectl rollout undo. Erstellen Sie eine eigene Rollback-Pipeline oder fügen Sie einen manuellen Rollback-Job hinzu, der über das Azure-DevOps-Portal ausgelöst werden kann. Dokumentieren Sie das Rollback-Verfahren und üben Sie es regelmäßig — ein nicht getestetes Rollback ist kein Rollback.

# Rollback job triggered manually
- job: Rollback
  condition: and(failed(), eq(variables['Build.Reason'], 'Manual'))
  steps:
  # App Service rollback: swap production back to previous
  - task: AzureAppServiceManage@0
    inputs:
      azureSubscription: 'AzureProductionSC'
      action: Swap Slots
      webAppName: myUniqueWebApp
      resourceGroupName: MyRG
      sourceSlot: production  # Swap production back to staging version
      targetSlot: staging

Bereitstellungsbenachrichtigungen und Überwachung

Führen Sie nach jeder Produktionsbereitstellung automatisch eine Überprüfung der Überwachung aus, um zu bestätigen, dass die neue Version fehlerfrei ist. Verwenden Sie die AzureMonitor@1-Pipelineprüfung, um Azure-Monitor-Metriken abzufragen — sind die Fehlerraten nach der Bereitstellung erhöht, blockieren Sie den weiteren Verlauf der Pipeline und lösen Sie ein Rollback aus. Senden Sie Bereitstellungsbenachrichtigungen über Webhook-Tasks an Microsoft Teams oder Slack, damit das Team weiß, wann eine Bereitstellung abgeschlossen ist und welche Version aktiv ist.

# Send Teams notification on deployment completion
- task: InvokeRestAPI@1
  displayName: 'Notify Teams channel'
  inputs:
    connectionType: connectedServiceName
    serviceConnection: 'TeamsWebhookSC'
    method: POST
    body: '{
      "text": "Deployed **$(Build.BuildId)** to Production. Committed by $(Build.RequestedFor). <br>View: https://myapp.contoso.com"
    }'
    waitForCompletion: false

Best Practices für CD

Befolgen Sie diese Best Practices für Continuous Deployment: Stellen Sie häufig bereit (kleine Pakete reduzieren das Risiko), verwenden Sie Feature Flags, um Bereitstellung und Release zu entkoppeln, automatisieren Sie alle Qualitätsschranken vor der Produktion, nutzen Sie ein produktionsnahes Staging, damit Unterschiede keine Fehler verdecken, überwachen Sie Bereitstellungsfenster mit automatisierten Integritätsprüfungen und haben Sie immer einen getesteten Rollback-Plan. Eine ausgereifte CD-Pipeline macht die Bereitstellung zu einem unauffälligen Vorgang statt zu einem Ablauf unter hohem Stress.

Kurze Überprüfung

Testen Sie Ihr Verständnis der Konzepte von Microsoft Azure Fundamentals (AZ-900) aus dieser Lektion.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: mehrstufige YAML-Pipelines verknüpfen die Phasen Build, Staging und Production und übergeben Artefakte, Bereitstellungsjobs mit Environments ermöglichen Genehmigungsschranken und die Nachverfolgung von Bereitstellungen, und Smoke-Tests nach der Staging-Bereitstellung verhindern, dass fehlerhafte Releases die Produktion erreichen. Als Nächstes sehen wir uns GitHub Actions in Azure an.

Häufig gestellte Fragen

Ist die Lektion „Kontinuierliche Bereitstellung in Azure“ kostenlos?

Ja — der vollständige Text von „Kontinuierliche Bereitstellung in Azure“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Cloud & IT Cert Prep-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Cloud & IT Cert Prep-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Kontinuierliche Bereitstellung in Azure“?

Erweitern Sie die Pipeline um eine Bereitstellungsphase, die das Buildartefakt in einen App-Service-Slot überträgt, Smoke-Tests ausführt und es nach Genehmigung in die Produktion austauscht. Du übst Cloud & IT Cert Prep mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Cloud & IT Cert Prep zu starten?

Keine Vorkenntnisse erforderlich. Cloud & IT Cert Prep auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Kontinuierliche Bereitstellung in Azure“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Cloud & IT Cert Prep-Lektion Code schreiben und ausführen?

Ja. Jede Cloud & IT Cert Prep-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Überblick über Azure DevOps Services
  2. Eine CI-Pipeline mit Azure Pipelines erstellen
  3. Kontinuierliche Bereitstellung in Azure
  4. GitHub Actions in Azure
← Zurück zu Cloud & IT Cert Prep