CI-/CD-Pipeline mit Azure Pipelines und Compute Engine erstellen

Last reviewed 2023-03-09 UTC

In dieser Anleitung wird gezeigt, wie Sie mit Azure Pipelines und Compute Engine eine CI/CD-Pipeline (Continuous Integration/Continuous Deployment) für eine ASP.NET MVC-Webanwendung nutzen. Die Anwendung verwendet Microsoft Internet Information Services und wird auf Windows Server ausgeführt.

Die CI-/CD-Pipeline nutzt zwei getrennte Umgebungen, eine für Tests und eine für die Produktion.

Am Anfang der Pipeline nehmen Entwickler Änderungen an der Beispielcodebasis vor. Diese Aktion löst die Pipeline aus, um die Anwendung zu erstellen, als ZIP-Datei zu verpacken und die ZIP-Datei in Cloud Storage hochzuladen.

Das Paket wird dann über ein Rolling Update automatisch in der Entwicklungsumgebung freigegeben. Nachdem der Release getestet wurde, kann ein Release-Manager den Release hochstufen, damit er in der Produktionsumgebung bereitgestellt wird.

Diese Anleitung richtet sich an Entwickler und DevOps-Entwickler. Dabei werden Grundkenntnisse in .NET Framework, Windows Server, IIS, Azure Pipelines und Compute Engine vorausgesetzt. Für die Anleitung benötigen Sie außerdem Administratorzugriff auf ein Azure DevOps-Konto.

Lernziele

Mit verwalteten Instanzgruppen von Compute Engine rollierende Deployments implementieren.
CI-/CD-Pipeline in Azure Pipelines einrichten, um die Build-, Erstellungs- und Deployment-Prozesse zu orchestrieren

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Auf der Azure DevOps-Preisseite finden Sie alle Gebühren, die bei der Verwendung von Azure DevOps anfallen können.

Hinweis

In der Regel empfiehlt es sich, getrennte Projekte für Entwicklungs- und Produktionsarbeitslasten zu verwenden. So können Sie Rollen und Berechtigungen der Identitäts- und Zugriffsverwaltung (IAM) einzeln erteilen. Der Einfachheit halber wird in dieser Anleitung ein einziges Projekt für die Entwicklungs- und Produktionsumgebungen verwendet.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

Zur Projektauswahl

Compute Engine and Cloud Storage APIs aktivieren.
Aktivieren Sie die APIs

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Sie müssen ein Azure DevOps-Konto mit Administratorzugriff haben. Wenn Sie noch kein Azure DevOps-Konto haben, können Sie sich auf der Azure DevOps-Startseite registrieren.

Azure DevOps-Projekt erstellen

Sie verwenden Azure DevOps, um den Quellcode zu verwalten, Builds und Tests auszuführen und die Bereitstellung in Compute Engine zu orchestrieren. Erstellen Sie zuerst in Ihrem Azure DevOps-Konto ein Projekt.

Rufen Sie die Azure DevOps-Startseite (https://dev.azure.com/YOUR_AZURE_DEVOPS_ACCOUNT_NAME) auf.
Klicken Sie auf Neues Projekt.
Geben Sie einen Projektnamen ein, z. B. CloudDemo.
Legen Sie für Sichtbarkeit die Option Privat fest und klicken Sie dann auf Erstellen.
Nachdem Sie das Projekt erstellt haben, klicken Sie im Menü links auf Repositories.
Klicken Sie auf Importieren, um einen Fork des Repositorys dotnet-docs-samples aus GitHub zu erstellen, und legen Sie dann die folgenden Werte fest:
- Repository-Typ: Git
- Klon-URL: https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
Klicken Sie auf Importieren.

Wenn der Importvorgang abgeschlossen ist, wird der Quellcode des Repositorys dotnet-docs-samples angezeigt.
Klicken Sie im Menü auf Repos > Zweige.
Bewegen Sie den Mauszeiger auf den Zweig main. Auf der rechten Seite wird die Schaltfläche ... angezeigt.
Klicken Sie auf ... > Als Standardzweig festlegen.

Kontinuierlich entwickeln

Sie können jetzt mit Azure Pipelines eine Build-Pipeline einrichten. Für jeden Commit, der an das Git-Repository gesendet wird, erstellt Azure Pipelines den Code, verpackt ihn in eine ZIP-Datei und veröffentlicht das resultierende Paket im internen Azure Pipelines-Speicher.

Später konfigurieren Sie eine Releasepipeline, die die Pakete aus dem Speicher der Azure Pipelines verwendet und in Compute Engine bereitstellt.

Build-Definition erstellen

Erstellen Sie in Azure Pipelines eine neue Build-Definition, die die YAML-Syntax verwendet:

Klonen Sie Ihr neues Git-Repository mit Visual Studio oder einem git-Befehlszeilenclient.
Erstellen Sie im Stammverzeichnis des Repositorys eine Datei mit dem Namen azure-pipelines.yml.

Kopieren Sie den folgenden Code und fügen Sie ihn in die Datei ein:

resources:
- repo: self
  fetchDepth: 1
trigger:
- main
variables:
  artifactName: 'CloudDemo.Mvc'
jobs:
- job: Build
  displayName: Build application
  condition: succeeded()
  pool:
    vmImage: windows-latest
    demands:
    - msbuild
    - visualstudio
  variables:
    Solution: 'applications/clouddemo/net4/CloudDemo.Mvc.sln'
    BuildPlatform: 'Any CPU'
    BuildConfiguration: 'Release'
    ArtifactName: 'CloudDemo.Web'
  steps:
  - task: NuGetCommand@2
    displayName: 'NuGet restore'
    inputs:
      restoreSolution: '$(Solution)'
  - task: VSBuild@1
    displayName: 'Build solution'
    inputs:
      solution: '$(Solution)'
      msbuildArgs: '/p:DeployOnBuild=true /p:WebPublishMethod=Package /p:PackageAsSingleFile=true /p:SkipInvalidConfigurations=true /p:PackageLocation="$(build.artifactstagingdirectory)\\"'
      platform: '$(BuildPlatform)'
      configuration: '$(BuildConfiguration)'
  - task: PublishBuildArtifacts@1
    displayName: 'Publish Artifact'
    inputs:
      PathtoPublish: '$(build.artifactstagingdirectory)/CloudDemo.Mvc.zip'
      ArtifactName: '$(ArtifactName)'

Übernehmen Sie die Änderungen und übertragen Sie sie per Push an Azure Pipelines.
Visual Studio
1. Öffnen Sie den Team Explorer und klicken Sie auf das Symbol Startseite.
2. Klicken Sie auf Änderungen.
3. Geben Sie eine Commit-Nachricht wie Add pipeline definition ein.
4. Klicken Sie auf Commit für alle und Push.
Befehlszeile
1. Alle geänderten Dateien bereitstellen:
```
git add -A
```
2. Übernehmen Sie die Änderungen für das lokale Repository:
```
git commit -m "Add pipeline definition"
```
3. Übertragen Sie die Änderungen per Push an Azure DevOps:
```
git push
```
Wählen Sie im Azure DevOps-Menü Pipelines aus und klicken Sie dann auf Pipeline erstellen.
Wählen Sie Azure Repos Git aus.
Wählen Sie Ihr Repository aus.
Klicken Sie auf der Seite YAML-Pipeline prüfen auf Ausführen.

Ein neuer Build wird ausgelöst. Es kann etwa zwei Minuten dauern, bis der Build abgeschlossen ist. Am Ende des Builds ist das Anwendungspaket CloudDemo.Mvc.zip, das alle Dateien der Webanwendung enthält, im internen Artefaktspeicherbereich von Azure Pipelines verfügbar.

Kontinuierliches Deployment

Nachdem Azure Pipelines den Code für jeden Commit automatisch erstellt, können Sie sich auf die Bereitstellung konzentrieren.

Im Gegensatz zu anderen Systemen für Continuous Integration unterscheidet Azure Pipelines zwischen Builds und Deployments. Daher steht in Azure Pipelines eine Reihe von speziellen Tools unter dem Namen „Releaseverwaltung“ zur Verfügung, die für alle Aufgaben in Zusammenhang mit dem Deployment zum Einsatz kommen.

Die Azure Pipelines-Releaseverwaltung basiert auf folgenden Konzepten:

Ein Release bezieht sich auf eine Reihe von Artefakten, die eine bestimmte Version Ihrer Anwendung ausmachen und normalerweise das Ergebnis eines Build-Prozesses sind.
Deployment bezieht sich auf das Erstellen eines Releases in einer bestimmten Umgebung.
Bei einem Deployment werden mehrere Aufgaben ausgeführt, die in Jobs zusammengefasst sein können.
Mit Phasen können Sie Ihre Pipeline segmentieren und Deployments in mehreren Umgebungen (z. B. Entwicklungs- und Testumgebungen) orchestrieren.

Sie richten Ihre Releasepipeline so ein, dass sie bei Abschluss eines neuen Builds ausgelöst wird. Die Pipeline besteht aus drei Phasen:

In der ersten Phase veröffentlicht die Pipeline das Anwendungspaket aus dem Azure Pipelines-Artefaktspeicherbereich und veröffentlicht es in einem Cloud Storage-Bucket, sodass Compute Engine auf das Paket zugreifen kann.
In der zweiten Phase aktualisiert die Pipeline die Entwicklungsumgebung mithilfe eines Rolling Updates.
In der letzten Phase nach der Genehmigung aktualisiert die Pipeline die Produktionsumgebung mithilfe eines Rolling Updates.

Cloud Storage-Bucket für Build-Artefakte erstellen

Erstellen Sie ein Cloud Storage-Bucket zum Speichern von Anwendungspaketen. Später konfigurieren Sie Compute Engine so, dass neue VM-Instanzen automatisch Anwendungspakete aus diesem Bucket abrufen können.

Wechseln Sie in der Google Cloud Console zu Ihrem neu erstellten Projekt.
Cloud Shell öffnen

Zu Cloud Shell
Legen Sie zur Beschleunigung des Vorgangs Standardwerte für Ihre Projekt-ID und Compute Engine-Zone fest:
```
gcloud config set project PROJECT_ID
gcloud config set compute/zone ZONE
```
Ersetzen Sie PROJECT_ID durch die ID Ihres Google Cloud-Projekts und ZONE durch den Namen der Zone, die Sie zum Erstellen von Ressourcen verwenden möchten. Wenn Sie nicht sicher sind, welche Zone Sie auswählen sollen, verwenden Sie us-central1-a.

Beispiel:
```
gcloud config set project devops-test-project-12345
gcloud config set compute/zone us-central1-a
```
Erstellen Sie einen neuen Cloud Storage-Bucket für Anwendungspakete:
```
gsutil mb gs://$(gcloud config get-value core/project)-artifacts
```
Wenn Sie nicht von allen Builds die Anwendungspakete beibehalten möchten, können Sie eine Regel für den Lebenszyklus von Objekten konfigurieren. Damit werden Dateien gelöscht, die ein gewisses Alter überschritten haben.

Dienstkonto für Azure Pipelines einrichten

Erstellen Sie ein Google Cloud-Dienstkonto, mit dem Azure Pipelines auf Ihr Google Cloud-Projekt zugreifen kann.

Erstellen Sie ein Kubernetes-Dienstkonto für Azure Pipelines:

AZURE_PIPELINES_SERVICE_ACCOUNT=$(gcloud iam service-accounts create azure-pipelines --format "value(email)")

Weisen Sie dem Dienstkonto azure-pipelines die IAM-Rollen Storage-Objekt-Betrachter (roles/storage.objectViewer) und Storage-Objekt-Ersteller (roles/storage.objectCreator) zu, damit Azure Pipelines Anwendungspakete in Cloud Storage hochladen können:

gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
    --member serviceAccount:$AZURE_PIPELINES_SERVICE_ACCOUNT \
    --role roles/storage.objectViewer
gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
    --member serviceAccount:$AZURE_PIPELINES_SERVICE_ACCOUNT \
    --role roles/storage.objectCreator

Weisen Sie dem Dienstkonto azure-pipelines die Rolle „Compute-Administrator“ (roles/compute.admin) zu, damit Azure Pipelines VM-Instanzen verwalten können:

gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
    --member serviceAccount:$AZURE_PIPELINES_SERVICE_ACCOUNT \
    --role roles/compute.admin

Generieren Sie einen Dienstkontoschlüssel:

gcloud iam service-accounts keys create azure-pipelines-key.json \
  --iam-account=$AZURE_PIPELINES_SERVICE_ACCOUNT

cat azure-pipelines-key.json | base64 -w 0;echo

rm azure-pipelines-key.json

Sie benötigen den Dienstkontoschlüssel in einem der folgenden Schritte.

Entwicklungsumgebung konfigurieren

Bevor Sie die Schritte zur Automatisierung des Deployments in Azure Pipelines konfigurieren können, müssen Sie die Entwicklungsumgebung vorbereiten. Im Rahmen dieser Vorbereitung ist eine verwaltete Instanzgruppe zu erstellen, die die VM-Instanzen des Webservers verwaltet. Außerdem muss ein HTTP-Load-Balancer erstellt werden.

Erstellen Sie in Cloud Shell ein Dienstkonto für die verwaltete Instanzgruppe:

DEV_SERVICE_ACCOUNT=$(gcloud iam service-accounts create clouddemo-dev --format "value(email)")

Weisen Sie dem Dienstkonto die IAM-Rolle „Storage-Objekt-Betrachter“ (roles/storage.objectViewer) zu, damit VM-Instanzen Anwendungspakete aus Cloud Storage herunterladen können:
```
gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
    --member serviceAccount:$DEV_SERVICE_ACCOUNT \
    --role roles/storage.objectViewer
```

Gewähren Sie dem Dienstkonto azure-pipelines die Berechtigung, das Dienstkonto clouddemo-dev zu verwenden:

gcloud iam service-accounts add-iam-policy-binding $DEV_SERVICE_ACCOUNT \
    --member serviceAccount:$AZURE_PIPELINES_SERVICE_ACCOUNT \
    --role roles/iam.serviceAccountUser

Erstellen Sie eine Instanzvorlage, die ein standardmäßiges Windows Server 2019 Core-Image verwendet. Sie verwenden diese Vorlage nur zu Beginn, da jeder nachfolgende Build eine neue Vorlage generiert.

gcloud compute instance-templates create clouddemo-initial \
    --machine-type n1-standard-2 \
    --image-family windows-2019-core \
    --image-project windows-cloud \
    --service-account $DEV_SERVICE_ACCOUNT \
    --scopes https://www.googleapis.com/auth/devstorage.read_only \
    --tags gclb-backend

Erstellen Sie eine HTTP-Systemdiagnose. Da die Anwendung keinen eigenen Endpunkt für Systemdiagnosen hat, können Sie den Pfad / abfragen.
```
gcloud compute http-health-checks create clouddemo-dev-http \
    --check-interval=10s --unhealthy-threshold=10 \
    --request-path=/
```
Erstellen Sie eine verwaltete Instanzgruppe auf Basis der ersten Instanzvorlage. Der Einfachheit halber wird mit den im Folgenden aufgeführten Befehlen eine zonale verwaltete Instanzgruppe erstellt. Sie können diese Methode jedoch auch für regionale verwaltete Instanzgruppen verwenden, die VM-Instanzen über mehrere Zonen verteilen.
```
gcloud compute instance-groups managed create clouddemo-dev \
    --template=clouddemo-initial \
    --http-health-check=clouddemo-dev-http \
    --initial-delay=2m \
    --size=1 && \
gcloud compute instance-groups set-named-ports clouddemo-dev --named-ports http:80
```

Erstellen Sie einen Back-End-Dienst für den Load-Balancer, der die HTTP-Systemdiagnose und die verwaltete Instanzgruppe verwendet, die zuvor erstellt wurde:

gcloud compute backend-services create clouddemo-dev-backend \
    --http-health-checks clouddemo-dev-http \
    --port-name http --protocol HTTP --global && \
gcloud compute backend-services add-backend clouddemo-dev-backend \
    --instance-group clouddemo-dev --global \
    --instance-group-zone=$(gcloud config get-value compute/zone)

Erstellen Sie ein Front-End für den Load-Balancer:

gcloud compute url-maps create clouddemo-dev --default-service clouddemo-dev-backend && \
gcloud compute target-http-proxies create clouddemo-dev-proxy --url-map=clouddemo-dev && \
gcloud compute forwarding-rules create clouddemo-dev-fw-rule --global --target-http-proxy clouddemo-dev-proxy --ports=80

Erstellen Sie eine Firewallregel, die es dem Load-Balancer von Google erlaubt, HTTP-Anfragen an Instanzen zu senden, die mit dem Tag gclb-backend annotiert sind. Sie wenden dieses Tag später auf die VM-Instanzen des Webdienstes an.
```
gcloud compute firewall-rules create gclb-backend --source-ranges=130.211.0.0/22,35.191.0.0/16 --target-tags=gclb-backend --allow tcp:80
```

Produktionsumgebung konfigurieren

Zum Einrichten der Produktionsumgebung müssen ähnliche Schritte wie beim Konfigurieren der Entwicklungsumgebung ausgeführt werden.

Erstellen Sie in Cloud Shell eine HTTP-Systemdiagnose:

gcloud compute http-health-checks create clouddemo-prod-http \
    --check-interval=10s --unhealthy-threshold=10 \
    --request-path=/

Erstellen Sie eine weitere verwaltete Instanzgruppe auf Basis der ersten Instanzvorlage, die Sie zuvor erstellt haben:

gcloud compute instance-groups managed create clouddemo-prod \
    --template=clouddemo-initial \
    --http-health-check=clouddemo-prod-http \
    --initial-delay=2m \
    --size=1 && \
gcloud compute instance-groups set-named-ports clouddemo-prod --named-ports http:80

Erstellen Sie einen Back-End-Dienst für den Load-Balancer, der die HTTP-Systemdiagnose und die verwaltete Instanzgruppe verwendet, die zuvor erstellt wurde:

gcloud compute backend-services create clouddemo-prod-backend --http-health-checks clouddemo-prod-http --port-name http --protocol HTTP --global && \
gcloud compute backend-services add-backend clouddemo-prod-backend --instance-group clouddemo-prod --global --instance-group-zone=$(gcloud config get-value compute/zone)

Erstellen Sie ein Front-End für den Load-Balancer:

gcloud compute url-maps create clouddemo-prod --default-service clouddemo-prod-backend && \
gcloud compute target-http-proxies create clouddemo-prod-proxy --url-map=clouddemo-prod && \
gcloud compute forwarding-rules create clouddemo-prod-fw-rule --global --target-http-proxy clouddemo-prod-proxy --ports=80

Release-Pipeline konfigurieren

Erstellen Sie eine neue Releasedefinition:

Wählen Sie im Azure DevOps-Menü Pipelines > Releases aus.
Klicken Sie auf New pipeline (Neue Pipeline).
Wählen Sie in der Vorlagenliste den Eintrag Empty job aus.
Wenn Sie einen Namen für die Phase eingeben sollen, geben Sie Publish ein.
Geben Sie der Version oben auf dem Bildschirm den Namen clouddemo-ComputeEngine.
Klicken Sie im Pipelinediagramm neben Artefakte auf Hinzufügen.
Wählen Sie Build aus und legen Sie folgende Einstellungen fest:
- Quelle: Wählen Sie das Git-Repository aus, das die Datei azure-pipelines.yml enthält.
- Standardversion: Latest
- Quellalias: CloudDemo.Web
Klicken Sie auf Add (Hinzufügen).
Klicken Sie im Feld Artifact (Artefakt) auf Continuous deployment trigger (Trigger für kontinuierliches Deployment) (das Blitzsymbol), um einen Deployment-Trigger hinzuzufügen.
Stellen Sie unter Continuous Deployment Trigger den Schieberegler auf Aktiviert ein.
Klicken Sie auf Speichern.
Geben Sie bei Bedarf einen Kommentar ein und bestätigen Sie mit OK.

Die Pipeline sieht nun so aus:

Bild: Screenshot der Pipeline in Azure Pipelines

In Cloud Storage veröffentlichen

Nachdem Sie die Release-Definition erstellt haben, können Sie die Schritte zum Veröffentlichen des Anwendungspakets in Cloud Storage hinzufügen.

Wechseln Sie in Azure Pipelines zum Tab Tasks (Aufgaben).
Klicken Sie auf Agent-Job und konfigurieren Sie die folgenden Einstellungen:
- Agent-Pool: Azure Pipelines
- Agent-Spezifikation: ubuntu-latest
Klicken Sie neben Agent-Job auf Aufgabe zum Agent-Job hinzufügen .
Wählen Sie die Aufgabe bash aus und klicken Sie auf Hinzufügen.

Klicken Sie auf die neu hinzugefügte Aufgabe und legen Sie die folgenden Einstellungen fest:

Display name (Anzeigename): Publish to Cloud Storage.
Type (Typ): inline

Script:

cat << "EOF" > CloudDemo.Mvc.deploy.ps1
    $ErrorActionPreference = "Stop"

    # Download application package from Cloud Storage
    gsutil cp gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).zip $env:TEMP\app.zip

    # Install IIS
    Enable-WindowsOptionalFeature -Online -FeatureName `
        NetFx4Extended-ASPNET45, `
        IIS-WebServerRole, `
        IIS-WebServer, `
        IIS-CommonHttpFeatures, `
        IIS-HttpErrors, `
        IIS-HttpRedirect, `
        IIS-ApplicationDevelopment, `
        IIS-HealthAndDiagnostics, `
        IIS-HttpLogging, `
        IIS-LoggingLibraries, `
        IIS-RequestMonitor, `
        IIS-HttpTracing, `
        IIS-Security, `
        IIS-RequestFiltering, `
        IIS-Performance, `
        IIS-WebServerManagementTools, `
        IIS-IIS6ManagementCompatibility, `
        IIS-Metabase, `
        IIS-DefaultDocument, `
        IIS-ApplicationInit, `
        IIS-NetFxExtensibility45, `
        IIS-ISAPIExtensions, `
        IIS-ISAPIFilter, `
        IIS-ASPNET45, `
        IIS-HttpCompressionStatic

    # Extract application package to wwwroot
    New-Item -ItemType directory -Path $env:TEMP\app
    Add-Type -AssemblyName System.IO.Compression.FileSystem
    [System.IO.Compression.ZipFile]::ExtractToDirectory("$env:TEMP\app.zip", "$env:TEMP\app")
    Remove-Item $env:TEMP\app.zip
    Move-Item -Path $(dir -recurse $env:TEMP\app\**\PackageTmp | % { $_.FullName }) -Destination c:\inetpub\wwwroot\app -force

    # Configure IIS web application pool and application
    Import-Module WebAdministration
    New-WebAppPool clouddemo-net4
    Set-ItemProperty IIS:\AppPools\clouddemo-net4 managedRuntimeVersion v4.0
    New-WebApplication -Name clouddemo -Site 'Default Web Site' -PhysicalPath c:\inetpub\wwwroot\app -ApplicationPool clouddemo-net4

    # Grant read/execute access to the application pool user
    &icacls C:\inetpub\wwwroot\app\ /grant "IIS AppPool\clouddemo-net4:(OI)(CI)(RX)"
EOF

gcloud auth activate-service-account \
    --quiet \
    --key-file <(echo $(ServiceAccountKey) | base64 -d)

gsutil cp $(System.ArtifactsDirectory)/CloudDemo.Web/CloudDemo.Web/CloudDemo.Mvc.zip gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).zip
gsutil cp CloudDemo.Mvc.deploy.ps1 gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).deploy.ps1

Das Skript führt Folgendes aus:

Ein Startskript wird konfiguriert, das IIS konfiguriert.
Konfiguriert die Google Cloud CLI für die Verwendung des Dienstkontoschlüssels aus der Umgebungsvariablen, um sich bei Google Cloud zu authentifizieren.
Lädt das Anwendungspaket und das Startskript in Cloud Storage hoch.

Wechseln Sie zum Tab Variables und fügen Sie folgende Variablen hinzu.

Name	Value	Secret
`ServiceAccountKey`	Dienstkontoschlüssel, der zuvor für `azure-pipelines-deployer` erstellt wurde.	Ja
`CloudDemo.ProjectId`	Die Projekt-ID Ihres Google Cloud-Projekts.
`CloudDemo.Zone`	Die Zone, die Sie beim Ausführen von `gcloud config set compute/zone` angegeben haben (z. B. `us-central1-a`)

Klicken Sie auf Speichern.
Geben Sie bei Bedarf einen Kommentar ein und bestätigen Sie mit OK.

Entwicklungsumgebung bereitstellen

Sie können jetzt die Schritte zum Starten einer rollierenden Bereitstellung in der Entwicklungsumgebung hinzufügen.

Wechseln Sie in Azure Pipelines zum Tab Pipeline.
Wählen Sie im Feld Phasen die Option Hinzufügen > Neue Phase aus.
Wählen Sie in der Vorlagenliste den Eintrag Empty job aus.
Wenn Sie einen Namen für die Phase angeben sollen, geben Sie Dev ein.
Klicken Sie auf das Blitzsymbol der neu erstellten Phase.
Legen Sie folgende Einstellungen fest:
- Trigger auswählen: After stage
- Phasen: Publish
Bewegen Sie den Mauszeiger auf den Tab Aufgaben und klicken Sie auf Aufgaben > Dev.
Klicken Sie auf Agent-Job und konfigurieren Sie die folgenden Einstellungen:
- Agent-Pool: Azure Pipelines
- Agent-Spezifikation: ubuntu-latest
Klicken Sie neben Agent-Job auf Aufgabe zum Agent-Job hinzufügen .
Wählen Sie die Aufgabe bash aus und klicken Sie auf Hinzufügen.

Klicken Sie auf die neu hinzugefügte Aufgabe und legen Sie die folgenden Einstellungen fest:

Display name (Anzeigename): Rolling deploy.
Type (Typ): inline

Script:

INSTANCE_TEMPLATE=clouddemo-$(Build.BuildId)-$(Release.ReleaseId)

gcloud auth activate-service-account \
    --quiet \
    --key-file <(echo $(ServiceAccountKey) | base64 -d)

gcloud compute instance-templates create $INSTANCE_TEMPLATE \
  --machine-type n1-standard-2 \
  --image-family windows-2019-core \
  --image-project windows-cloud \
  --service-account clouddemo-dev@$(CloudDemo.ProjectId).iam.gserviceaccount.com \
  --scopes https://www.googleapis.com/auth/devstorage.read_only \
  --tags gclb-backend \
  --metadata sysprep-specialize-script-url=gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).deploy.ps1 \
  --project $(CloudDemo.ProjectId) \

gcloud compute instance-groups managed set-instance-template clouddemo-dev \
  --template $INSTANCE_TEMPLATE \
  --project $(CloudDemo.ProjectId) \
  --zone $(CloudDemo.Zone)

gcloud compute instance-groups managed rolling-action start-update clouddemo-dev \
  --version template=$INSTANCE_TEMPLATE \
  --type proactive \
  --max-unavailable 0 \
  --project $(CloudDemo.ProjectId) \
  --zone $(CloudDemo.Zone)

Das Skript führt Folgendes aus:

Konfiguriert die Google Cloud CLI für die Verwendung des Dienstkontoschlüssels aus der Umgebungsvariablen, um sich bei Google Cloud zu authentifizieren.
Erstellt eine neue Instanzvorlage, die das aus der vorherigen Phase generierte Startskript verwendet.
Aktualisiert die vorhandene Instanzgruppe, um die neue Instanzvorlage zu verwenden. Allerdings bewirkt der Befehl noch nicht, dass vorhandene VMs ersetzt oder aktualisiert werden. Vielmehr gewährleistet er, dass alle zukünftigen VMs in dieser Instanzgruppe auf Basis der neuen Vorlage erstellt werden.
Startet ein Rolling Update, das die bestehende Instanzgruppe dazu veranlasst, bestehende VMs durch neue VMs zu ersetzen, und zwar auf rollierende Art und Weise.

Klicken Sie auf Speichern.
Geben Sie bei Bedarf einen Kommentar ein und bestätigen Sie mit OK.

Produktionsumgebung bereitstellen

Schließlich konfigurieren Sie das Deployment für die Produktionsumgebung.

Wechseln Sie in Azure Pipelines zum Tab Pipeline.
Wählen Sie im Feld Phasen die Option Hinzufügen > Neue Phase aus.
Wählen Sie in der Vorlagenliste den Eintrag Empty job aus.
Wenn Sie einen Namen für die Phase angeben sollen, geben Sie Prod ein.
Klicken Sie auf das Blitzsymbol der neu erstellten Phase.
Legen Sie folgende Einstellungen fest:
- Trigger auswählen: After stage
- Phasen: Dev
- Genehmigungen vor der Bereitstellung: (aktiviert)
- Approvers (Genehmigende Personen): Wählen Sie Ihren eigenen Nutzernamen aus.
Bewegen Sie den Mauszeiger auf den Tab Aufgaben und klicken Sie auf Aufgaben > Prod.
Klicken Sie auf Agent-Job und konfigurieren Sie die folgenden Einstellungen:
- Agent-Pool: Azure Pipelines
- Agent-Spezifikation: ubuntu-latest
Klicken Sie neben Agent job (Agent-Job) auf Add a task to agent job (Aufgabe zum Agent-Job hinzufügen) , um der Phase einen Schritt hinzuzufügen.
Wählen Sie die Aufgabe bash aus und klicken Sie auf Hinzufügen.

Klicken Sie auf die neu hinzugefügte Aufgabe und legen Sie die folgenden Einstellungen fest:

Display name (Anzeigename): Rolling deploy.
Type (Typ): inline

Script:

INSTANCE_TEMPLATE=clouddemo-$(Build.BuildId)-$(Release.ReleaseId)

gcloud auth activate-service-account \
    --quiet \
    --key-file <(echo $(ServiceAccountKey) | base64 -d)

gcloud compute instance-templates create $INSTANCE_TEMPLATE \
  --machine-type n1-standard-2 \
  --image-family windows-2019-core \
  --image-project windows-cloud \
  --service-account clouddemo-prod@$(CloudDemo.ProjectId).iam.gserviceaccount.com \
  --scopes https://www.googleapis.com/auth/devstorage.read_only \
  --tags gclb-backend \
  --metadata sysprep-specialize-script-url=gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).deploy.ps1 \
  --project $(CloudDemo.ProjectId) \

gcloud compute instance-groups managed set-instance-template clouddemo-prod \
  --template $INSTANCE_TEMPLATE \
  --project $(CloudDemo.ProjectId) \
  --zone $(CloudDemo.Zone)

gcloud compute instance-groups managed rolling-action start-update clouddemo-prod \
  --version template=$INSTANCE_TEMPLATE \
  --type proactive \
  --max-unavailable 0 \
  --project $(CloudDemo.ProjectId) \
  --zone $(CloudDemo.Zone)

Klicken Sie auf Speichern.
Geben Sie bei Bedarf einen Kommentar ein und bestätigen Sie mit OK.

Pipeline ausführen

Nachdem Sie nun die gesamte Pipeline konfiguriert haben, können Sie sie testen, indem Sie eine Änderung am Quellcode vornehmen:

Öffnen Sie auf Ihrem lokalen Computer die Datei applications\clouddemo\net4\CloudDemo.Mvc\Views\Home\Index.cshtml aus dem Git-Repository, das Sie zuvor geklont haben.
Ändern Sie den Wert von ViewBag.Title von Home Page in This app runs on GKE.
Übernehmen Sie die Änderungen und übertragen Sie sie per Push an Azure Pipelines.
Visual Studio
1. Öffnen Sie den Team Explorer und klicken Sie auf das Symbol Startseite.
2. Klicken Sie auf Änderungen.
3. Geben Sie eine Commit-Nachricht wie Change site title ein.
4. Klicken Sie auf Commit für alle und Push.
Befehlszeile
1. Alle geänderten Dateien bereitstellen:
```
git add -A
```
2. Übernehmen Sie die Änderungen für das lokale Repository:
```
git commit -m "Change site title"
```
3. Übertragen Sie die Änderungen per Push an Azure Pipelines:
```
git push
```
Wählen Sie im Azure DevOps-Menü Pipelines aus.

Ein Build wird ausgelöst.
Wählen Sie nach Abschluss des Builds Pipelines > Releases aus. Ein Freigabeprozess wird gestartet.
Klicken Sie auf Release-1, um die Detailseite zu öffnen, und warten Sie, bis der Status der Phase Dev zu Succeeded (Erfolgreich) wechselt.
Wählen Sie in der Google Cloud Console Netzwerkdienste > Load-Balancing > clouddemo-dev aus.

Notieren Sie sich die IP-Adresse des Front-Ends.
Öffnen Sie ein neues Browserfenster und gehen Sie zu der folgenden Adresse:
```
http://IP_ADDRESS/clouddemo/
```
Dabei ist IP_ADDRESS die IP-Adresse des Front-Ends.

Prüfen Sie, ob die Anwendung bereitgestellt wurde und den benutzerdefinierten Titel verwendet.

Möglicherweise wird anfangs ein Fehler angezeigt, da der Load-Balancer erst nach einigen Minuten verfügbar ist.
Klicken Sie in Azure Pipelines auf die Schaltfläche Approve (Genehmigen), die sich unterhalb der Prod-Phase befindet, um das Deployment in der Produktionsumgebung anzustoßen.

Wenn die Schaltfläche nicht angezeigt wird, müssen Sie möglicherweise erst einen vorherigen Release genehmigen oder ablehnen.
Geben Sie bei Bedarf einen Kommentar ein und bestätigen Sie mit Approve (Genehmigen).
Warten Sie, bis der Status der Umgebung Prod zu Succeeded (Erfolgreich) wechselt.
Wählen Sie in der Google Cloud Console Netzwerkdienste > Load-Balancing > clouddemo-prod aus.

Notieren Sie sich die IP-Adresse des Front-Ends.
Öffnen Sie ein neues Browserfenster und gehen Sie zu der folgenden Adresse:
```
http://IP_ADDRESS/clouddemo/
```
Dabei ist IP_ADDRESS die IP-Adresse des Front-Ends.

Prüfen Sie, ob die Anwendung bereitgestellt wurde und den benutzerdefinierten Titel verwendet.

Bereinigen

Löschen Sie die von Ihnen erstellten Entitäten, um nach Abschluss dieser Anleitung keine weiteren Kosten zu verursachen.

Azure Pipelines-Projekt löschen

Informationen zum Löschen des Azure Pipelines-Projekts finden Sie in der Dokumentation zu Azure DevOps Services. Wenn Sie das Azure Pipelines-Projekt löschen, gehen alle Änderungen am Quellcode verloren.

Google Cloud-Entwicklungs- und Produktionsprojekte löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Nächste Schritte

Mehr zu Best Practices zur Verwaltung von Images erfahren
Hochverfügbare SQL Server-Gruppe in Compute Engine erstellen
.NET auf der Google Cloud Platform
Cloud Tools für Visual Studio installieren
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center