Übung: Hinzufügen eines Vorschauauftrags zu Ihrem Workflow

  • 3 Minuten

Sie möchten Ihrem Workflow einen zusätzlichen Auftrag hinzufügen, damit Sie überprüfen können, welche Änderungen an Ihrer Azure-Umgebung vorgenommen werden.

Während des Prozesses führen Sie die folgenden Aufgaben aus:

  • Sie aktualisieren die YAML-Workflowdefinitionsdatei, um einen neuen Vorschauauftrag hinzuzufügen.
  • Sie fügen Ihrem GitHub-Repository eine Umgebung hinzu.
  • Sie konfigurieren die Umgebung so, dass eine Überprüfung erforderlich ist.
  • Sie aktualisieren die YAML-Workflowdatei, um die Umgebung für den Bereitstellungsauftrag zu verwenden.
  • Sie zeigen die Ergebnisse des Was-wäre-wenn-Vorgangs an und genehmigen eine Workflowausführung.

Aktualisieren der Workflowdefinition zum Hinzufügen eines Vorschauauftrags

Hier fügen Sie Ihrem Workflow einen neuen Auftrag hinzu, der den Was-wäre-wenn-Vorgang ausführt.

  1. Öffnen Sie in Visual Studio Code die Datei workflow.yml im Ordner .github/workflows.

  2. Fügen Sie zwischen den Aufträgen validate und deploy die folgende Definition für den Auftrag preview ein:

    preview:
  runs-on: ubuntu-latest
  needs: [lint, validate]
  steps:
  - uses: actions/checkout@v3
  - uses: azure/login@v1
    name: Sign in to Azure
    with:
      client-id: ${{ secrets.AZURE_CLIENT_ID }}
      tenant-id: ${{ secrets.AZURE_TENANT_ID }}
      subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
  - uses: azure/arm-deploy@v1
    name: Run what-if
    with:
      failOnStdErr: false
      resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
      template: deploy/main.bicep
      parameters: >
        environmentType=${{ env.ENVIRONMENT_TYPE }}
      additionalArguments: --what-if

    Beachten Sie, dass der Auftrag preview vom erfolgreichen Abschluss der Aufträge lint und validate abhängt.

  3. Aktualisieren Sie den Auftrag deploy, damit er vom Auftrag preview abhängt:

    deploy:
  runs-on: ubuntu-latest
  needs: preview
  steps:
  - uses: actions/checkout@v3
  - uses: azure/login@v1
    name: Sign in to Azure
    with:
      client-id: ${{ secrets.AZURE_CLIENT_ID }}
      tenant-id: ${{ secrets.AZURE_TENANT_ID }}
      subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
  - uses: azure/arm-deploy@v1
    name: Deploy website
    with:
      failOnStdErr: false
      deploymentName: ${{ github.run_number }}
      resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
      template: ./deploy/main.bicep
      parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

  4. Speichern Sie die geänderte Datei.

Hinzufügen einer Umgebung

  1. Navigieren Sie im Browser zu Einstellungen>Umgebungen.

  2. Wählen Sie Neue Umgebung aus.

    Screenshot der GitHub-Benutzeroberfläche mit der Seite „Environments“ (Umgebungen) und hervorgehobener Schaltfläche zum Erstellen einer Umgebung

  3. Geben Sie Website als Umgebungsnamen ein.

  4. Wählen Sie Configure environment (Umgebung konfigurieren) aus.

    Screenshot der GitHub-Seite für eine neue Umgebung mit eingetragenen Details und hervorgehobener Schaltfläche zum Konfigurieren der Umgebung

In den Einrichtungsschritten für dieses Modul haben Sie bereits Verbundanmeldeinformationen für Ihren Workflow erstellt, die bei der Bereitstellung in der Umgebung verwendet werden.

Hinzufügen der Schutzregel „Erforderliche Reviewer“ zur Umgebung

  1. Aktivieren Sie das Feld Erforderliche Reviewer.

  2. Fügen Sie der Liste der Reviewer Ihren eigenen GitHub-Benutzernamen hinzu.

    Screenshot der GitHub-Benutzeroberfläche mit der Umgebung „Website“ mit hervorgehobenem Kontrollkästchen „Erforderliche Reviewer“ und hervorgehobenem Textfeld

  3. Wählen Sie Save protection rules (Schutzregeln speichern) aus.

  4. Wählen Sie Umgebungen aus, um die Konfiguration zu beenden.

Aktualisieren der Workflowdefinition zum Erzwingen einer Umgebung und von Reviewern

In diesem Abschnitt konfigurieren Sie den Bereitstellungsauftrag (deploy), die für die Umgebung Website ausgeführt wird, die Sie zuvor erstellt haben.

  1. Öffnen Sie die Datei workflow.yml in Visual Studio Code.

  2. Fügen Sie dem Auftrag deploy den Parameter environment hinzu. Legen Sie den Wert auf Website fest, damit er mit dem Namen der erstellten Umgebung übereinstimmt:

    deploy:
  runs-on: ubuntu-latest
  environment: Website
  needs: preview
  steps:
  - uses: actions/checkout@v3
  - uses: azure/login@v1
    name: Sign in to Azure
    with:
      client-id: ${{ secrets.AZURE_CLIENT_ID }}
      tenant-id: ${{ secrets.AZURE_TENANT_ID }}
      subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
  - uses: azure/arm-deploy@v1
    name: Deploy website
    with:
      failOnStdErr: false
      deploymentName: ${{ github.run_number }}
      resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
      template: ./deploy/main.bicep
      parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

  3. Speichern Sie die Datei .

Überprüfen und Committen Ihrer Workflowdefinition

  1. Überprüfen Sie, ob die Datei workflow.yml wie im folgenden Code aussieht:

    name: deploy-toy-website-test
concurrency: toy-company

on:
  push:
    branches:
      - main

permissions:
  id-token: write
  contents: read

env:
  AZURE_RESOURCEGROUP_NAME: ToyWebsiteTest
  ENVIRONMENT_TYPE: Test

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Run Bicep linter
      run: az bicep build --file deploy/main.bicep

  validate:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: azure/login@v1
      name: Sign in to Azure
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - uses: azure/arm-deploy@v1
      name: Run preflight validation
      with:
        deploymentName: ${{ github.run_number }}
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: ./deploy/main.bicep
        parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}
        deploymentMode: Validate

  preview:
    runs-on: ubuntu-latest
    needs: [lint, validate]
    steps:
    - uses: actions/checkout@v3
    - uses: azure/login@v1
      name: Sign in to Azure
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - uses: azure/arm-deploy@v1
      name: Run what-if
      with:
        failOnStdErr: false
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: deploy/main.bicep
        parameters: >
          environmentType=${{ env.ENVIRONMENT_TYPE }}
        additionalArguments: --what-if

  deploy:
    runs-on: ubuntu-latest
    environment: Website
    needs: preview
    steps:
    - uses: actions/checkout@v3
    - uses: azure/login@v1
      name: Sign in to Azure
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - uses: azure/arm-deploy@v1
      name: Deploy website
      with:
        failOnStdErr: false
        deploymentName: ${{ github.run_number }}
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: ./deploy/main.bicep
        parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

    Wenn Ihre Datei anders aussieht, ändern Sie sie entsprechend diesem Beispiel, und speichern Sie sie dann.

  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 job"
git push

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

  1. Navigieren Sie in Ihrem Browser zu Ihren Workflowausführungen.

  2. Wählen Sie die letzte Ausführung Ihres Workflows aus.

    Warten Sie, bis der Workflow die Aufträge lint, validate und preview abgeschlossen hat. Obwohl GitHub die Seite automatisch mit dem aktuellen Status aktualisiert, sollten Sie die Seite gelegentlich aktualisieren.

  3. Beachten Sie, dass sie vom Workflow zur Überprüfung aufgefordert werden. Abhängig davon, wie Sie Ihr GitHub-Konto eingerichtet haben, erhalten Sie eine E-Mail- oder Webbenachrichtigung mit einer Aufforderung, den Workflow zu überprüfen.

    Screenshot der GitHub-Benutzeroberfläche mit der Workflowausführung und hervorgehobener Überprüfungsaufforderung

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

  4. Wählen Sie den Vorschauauftrag (preview) aus.

  5. 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.

  6. Beachten Sie, dass das Workflowprotokoll Was-wäre-wenn-Ergebnisse enthält, die folgendem Code ähneln:

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

The deployment will update the following scope:

Scope: /subscriptions/***/resourceGroups/ToyWebsiteTest

  ~ Microsoft.OperationalInsights/workspaces/workspace-abcdefghijklm [2022-10-01]
    - properties.retentionInDays: 30
    - properties.sku:

        name: "pergb2018"

    - properties.workspaceCapping:

        dailyQuotaGb: -1.0

  ~ Microsoft.Web/sites/toy-website-abcdefghijklm [2022-03-01]
    + properties.siteConfig.localMySqlEnabled:   false
    + properties.siteConfig.netFrameworkVersion: "v4.6"

  = Microsoft.Insights/components/toywebsite [2020-02-02]
  = Microsoft.Storage/storageAccounts/mystorageabcdefghijklm [2022-09-01]
  = Microsoft.Web/serverfarms/toy-website [2022-03-01]
  * microsoft.alertsmanagement/smartDetectorAlertRules/Failure Anomalies - toywebsite

Resource changes: 2 to modify, 3 no change, 1 to ignore.

    Der Was-wäre-wenn-Vorgang hat eine Änderung des Log Analytics-Arbeitsbereichs und der Websiteressourcen 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 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 wurde von Application Insights automatisch erstellt. Der Was-wäre-wenn-Befehl erkennt, dass an der Ressource keine Änderungen vorgenommen werden.

Genehmigen der Workflowausführung

  1. Wählen Sie die Zusammenfassung aus, um zur Übersicht für die Workflowausführung zurückzukehren.

    Screenshot der GitHub-Benutzeroberfläche mit dem Menü „Summary“ (Zusammenfassung) und hervorgehobenem Pfeil „Zurück“

  2. Wählen Sie im Genehmigungsbereich die Schaltfläche Review deployments (Bereitstellungen überprüfen) aus.

  3. Wählen Sie im Popupelement Review pending deployments (Ausstehende Bereitstellungen überprüfen) die Umgebung Website aus. Geben Sie in das Feld Leave a comment (Kommentar) die Anmerkung Reviewed what-if results (Was-wäre-wenn-Ergebnisse überprüft) ein.

  4. Wählen Sie Approve and deploy (Genehmigen und bereitstellen) aus.

    Screenshot der GitHub-Benutzeroberfläche mit der Seite zur Workflowgenehmigung und hervorgehobener Schaltfläche „Approve“ (Genehmigen)

Abschließen der erfolgreichen Bereitstellung

  1. Beachten Sie, dass die Ausführung des Bereitstellungsauftrags (deploy) beginnt, nachdem Sie die Workflowausführung genehmigt haben.

    Warten Sie auf den Abschluss des Auftrags.

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