Übung: Hinzufügen einer Vorschauphase zu Ihrer Pipeline

  • 3 Minuten

Sie möchten Ihrer Pipeline eine zusätzliche Phase hinzufügen, damit Sie überprüfen können, welche Änderungen an Ihrer Azure-Umgebung vorgenommen werden.

In dem Prozess gehen Sie wie folgt vor:

  • Aktualisieren Sie die YAML-Pipelinedatei, um eine neue Vorschauphase hinzuzufügen.
  • Fügen Sie Azure Pipelines eine Umgebung hinzu.
  • Konfigurieren Sie die Umgebung so, dass eine Umgebung erforderlich ist.
  • Aktualisieren Sie die YAML-Pipelinedatei, um die Umgebung für die Bereitstellungsphase zu verwenden.
  • Zeigen Sie die Was-wäre-wenn-Ergebnisse an, und genehmigen Sie eine Pipelineausführung.

Aktualisieren der Pipelinedefinition zum Hinzufügen einer Vorschauphase

Hier fügen Sie Ihrer Pipeline eine neue Phase hinzu, in der der Was-wäre-wenn-Vorgang ausgeführt wird.

  1. Öffnen Sie in Visual Studio Code die Datei azure-pipelines.yml im Ordner deploy.

  2. Fügen Sie zwischen den Phasen Validate und Deploy die folgende Definition der Preview-Phase ein:

    - stage: Preview
  jobs:
  - job: PreviewAzureChanges
    displayName: Preview Azure changes
    steps:
      - task: AzureCLI@2
        name: RunWhatIf
        displayName: Run what-if
        inputs:
          azureSubscription: $(ServiceConnectionName)
          scriptType: 'bash'
          scriptLocation: 'inlineScript'
          inlineScript: |
            az deployment group what-if \
              --resource-group $(ResourceGroupName) \
              --template-file deploy/main.bicep \
              --parameters environmentType=$(EnvironmentType)

  3. Speichern Sie die geänderte Datei.

Hinzufügen einer Umgebung

  1. Navigieren Sie im Browser zu Pipelines>Umgebungen.

    Screenshot of the Azure DevOps interface that shows the Pipelines menu, with the Environments item highlighted.

  2. Klicken Sie auf Umgebung erstellen.

    Screenshot of the Azure DevOps interface that shows the Environments page, with the button for creating an environment highlighted.

  3. Geben Sie Website als Umgebungsnamen ein.

    Lassen Sie die Beschreibung leer. Wählen Sie für Ressource die Option Keine aus.

    Hinweis

    In Azure Pipelines werden Bereitstellungsfeatures mithilfe von Umgebungen aktiviert. Einige dieser Features gelten nur für Bereitstellungen in Kubernetes oder auf VMs. In diesem Modul werden diese Features nicht verwendet, und Sie können sie ignorieren.

  4. Wählen Sie Erstellen aus.

    Screenshot of the Azure DevOps page for a new environment, with the details completed and the Create button highlighted.

Hinzufügen einer Genehmigungsprüfung zur Umgebung

  1. Wählen Sie oben links auf dem Bildschirm die Registerkarte Genehmigungen und Überprüfungen aus.

    Screenshot of the Azure DevOps interface that shows the Website environment, with the Approvals and checks tab highlighted.

  2. Wählen Sie Genehmigungen aus.

    Screenshot of the Azure DevOps interface that shows the page for adding a check, with the Approvals item highlighted.

  3. Geben Sie in das Textfeld Genehmigende Personen Ihren eigenen Namen ein, und wählen Sie sich selbst aus.

  4. Wählen Sie neben Erweitert den Pfeil aus.

    Beachten Sie, dass genehmigende Personen standardmäßig berechtigt sind, die von ihnen ausgelösten Ausführungen zu genehmigen. Da Sie die einzige Person sind, die mit dieser Pipeline arbeiten wird, lassen Sie dieses Kontrollkästchen aktiviert.

  5. Wählen Sie Erstellen aus.

    Screenshot of the Azure DevOps interface that shows the page for adding an approval check, with the details completed and the Create button highlighted.

Aktualisieren der Pipelinedefinition zum Erzwingen einer Umgebung und Genehmigung

In diesem Abschnitt konfigurieren Sie die Bereitstellungsphase (Deploy), die für die Umgebung Website ausgeführt wird, die Sie zuvor erstellt haben. Dazu konvertieren Sie die Deploy-Phase, um einen Bereitstellungsauftrag anstelle eines Standardauftrags auszuführen, und konfigurieren diesen, sodass er die Umgebung bereitstellt.

  1. Ersetzen Sie in Visual Studio Code in der Datei azure-pipelines.yml die Definition der Phase Deploy durch folgenden Code:

    - stage: Deploy
  jobs:
  - deployment: DeployWebsite
    displayName: Deploy website
    environment: Website
    strategy:
      runOnce:
        deploy:
          steps:
            - checkout: self

            - task: AzureResourceManagerTemplateDeployment@3
              name: DeployBicepFile
              displayName: Deploy Bicep file
              inputs:
                connectedServiceName: $(ServiceConnectionName)
                deploymentName: $(Build.BuildNumber)
                location: $(deploymentDefaultLocation)
                resourceGroupName: $(ResourceGroupName)
                csmFile: deploy/main.bicep
                overrideParameters: >
                  -environmentType $(EnvironmentType)

    Beachten Sie, dass Sie einen neuen checkout-Schritt definiert haben. Im Gegensatz zu normalen Aufträgen müssen Bereitstellungsaufträge so konfiguriert werden, dass sie die Dateien aus Ihrem Git-Repository auschecken (herunterladen). Wenn Sie diesen Schritt nicht durchführen, kann der Bereitstellungsauftrag Ihre Bicep-Datei nicht lesen. Sie können stattdessen auch Pipelineartefakte verwenden, um Dateien zwischen Pipelinephasen zu senden. In der Zusammenfassung haben wir weitere Informationen zu Artefakten verlinkt.

  2. Speichern Sie die Datei .

Überprüfen und Committen Ihrer Pipelinedefinition

  1. Vergewissern Sie sich, dass die Datei azure-pipelines.yml wie folgt aussieht:

    trigger:
  batch: true
  branches:
    include:
    - main

pool:
  vmImage: ubuntu-latest

variables:
  - name: deploymentDefaultLocation
    value: westus3

stages:

- stage: Lint
  jobs:
  - job: LintCode
    displayName: Lint code
    steps:
      - script: |
          az bicep build --file deploy/main.bicep
        name: LintBicepCode
        displayName: Run Bicep linter

- stage: Validate
  jobs:
  - job: ValidateBicepCode
    displayName: Validate Bicep code
    steps:
      - task: AzureResourceManagerTemplateDeployment@3
        name: RunPreflightValidation
        displayName: Run preflight validation
        inputs:
          connectedServiceName: $(ServiceConnectionName)
          location: $(deploymentDefaultLocation)
          deploymentMode: Validation
          resourceGroupName: $(ResourceGroupName)
          csmFile: deploy/main.bicep
          overrideParameters: >
            -environmentType $(EnvironmentType)

- stage: Preview
  jobs:
  - job: PreviewAzureChanges
    displayName: Preview Azure changes
    steps:
      - task: AzureCLI@2
        name: RunWhatIf
        displayName: Run what-if
        inputs:
          azureSubscription: $(ServiceConnectionName)
          scriptType: 'bash'
          scriptLocation: 'inlineScript'
          inlineScript: |
            az deployment group what-if \
              --resource-group $(ResourceGroupName) \
              --template-file deploy/main.bicep \
              --parameters environmentType=$(EnvironmentType)

- stage: Deploy
  jobs:
  - deployment: DeployWebsite
    displayName: Deploy website
    environment: Website
    strategy:
      runOnce:
        deploy:
          steps:
            - checkout: self

            - task: AzureResourceManagerTemplateDeployment@3
              name: DeployBicepFile
              displayName: Deploy Bicep file
              inputs:
                connectedServiceName: $(ServiceConnectionName)
                deploymentName: $(Build.BuildNumber)
                location: $(deploymentDefaultLocation)
                resourceGroupName: $(ResourceGroupName)
                csmFile: deploy/main.bicep
                overrideParameters: >
                  -environmentType $(EnvironmentType)

    Falls nicht, aktualisieren Sie sie entsprechend diesem Beispiel, und speichern Sie sie.

  2. Committen und pushen Sie Ihre Änderungen in Ihr Git-Repository, indem Sie die folgenden Befehle im Visual Studio Code-Terminal ausführen:

    git add .
git commit -m "Add preview stage"
git push

Ausführen der Pipeline und Überprüfen der Was-wäre-wenn-Ausgaben

  1. Wechseln Sie in Ihrem Browser zu Ihrer Pipeline.

  2. Wählen Sie die letzte Ausführung Ihrer Pipeline aus.

    Warten Sie, bis die Pipeline die Phasen Lint, Überprüfen und Vorschau abgeschlossen hat. Obwohl Azure Pipelines die Seite automatisch mit dem aktuellen Status aktualisiert, sollten Sie die Seite gelegentlich auch manuell aktualisieren.

  3. Wenn Sie aufgefordert werden, die Berechtigung zum Zugriff auf eine Ressource zu erteilen, wählen Sie Ansicht und dann Zulassen aus.

  4. Beachten Sie, dass Azure Pipelines Sie zur Genehmigung auffordert. Sie erhalten außerdem eine E-Mail mit dem Hinweis, dass die Pipeline Ihre Genehmigung benötigt.

    Screenshot of the Azure DevOps interface that shows the pipeline run, with the approval requirement highlighted.

    Bevor Sie die Fortsetzung der Pipeline genehmigen, überprüfen Sie die Was-wäre-wenn-Ergebnisse, um sicherzustellen, dass diese Ihren Erwartungen entsprechen.

  5. Wählen Sie die Phase Preview aus.

  6. Wählen Sie den Schritt Run what-if (Was-wäre-wenn ausführen) aus, um die Änderungen zu überprüfen, über die der Was-wäre-wenn-Befehl berichtet.

  7. Beachten Sie, dass das Pipelineprotokoll Was-wäre-wenn-Ergebnisse enthält, die in etwa wie der folgende Code aussehen:

    Resource and property changes are indicated with these symbols:
  + Create
  ~ Modify
  = Nochange

The deployment will update the following scope:

Scope: /subscriptions/f0750bbe-ea75-4ae5-b24d-a92ca601da2c/resourceGroups/ToyWebsiteTest

  ~ Microsoft.Web/sites/toy-website-nbfnedv766snk [2021-01-15]
    + properties.siteConfig.localMySqlEnabled:   false
    + properties.siteConfig.netFrameworkVersion: "v4.6"

  = Microsoft.Insights/components/toywebsite [2020-02-02]
  = Microsoft.Storage/storageAccounts/mystoragenbfnedv766snk [2021-04-01]
  = Microsoft.Web/serverfarms/toy-website [2021-01-15]

Resource changes: 1 to modify, 3 no change.

    Der Was-wäre-wenn-Vorgang hat eine Änderung an der Websiteressource erkannt. Die erkannten Änderungen sind jedoch störend. und nicht um eine echte Änderung an Ihrer Ressource. Das Azure-Team arbeitet daran, Störfaktoren mit der Zeit zu minimieren. Bis dahin können Sie die für diese beiden Eigenschaften erkannten Änderungen ignorieren.

    Unter Umständen wird Ihnen in der Was-wäre-wenn-Ausgabe auch ein Element zum Ressourcentyp microsoft.alertsmanagement/smartDetectorAlertRules/Failure Anomalies - toywebsite angezeigt. Diese Ressource wird von Application Insights automatisch erstellt. Der Was-wäre-wenn-Befehl erkennt, dass an der Ressource keine Änderungen vorgenommen werden.

Genehmigen der Pipelineausführung

  1. Wählen Sie den Pfeil nach links aus, um zu den Details der Pipelineausführung zurückzukehren.

    Screenshot of the Azure DevOps interface that shows the pipeline log menu, with the back arrow highlighted.

  2. Klicken Sie im Genehmigungsbereich auf Überprüfen.

  3. Geben Sie in das Feld Kommentar die Anmerkung Reviewed what-if results (Was-wäre-wenn-Ergebnisse überprüft) ein.

  4. Wählen Sie Genehmigen aus.

    Screenshot of the Azure DevOps interface that shows the pipeline approval page, with the Approve button highlighted.

Abschließen der erfolgreichen Bereitstellung

  1. Beachten Sie, dass die Ausführung der Deploy-Phase beginnt, nachdem Sie die Pipelineausführung genehmigt haben.

    Warten Sie, bis die Phase abgeschlossen ist.

  2. Sie sehen, dass die Pipelineausführung erfolgreich abgeschlossen wird.