CI/CD-Pipeline mit Azure Pipelines und Cloud Run erstellen

In dieser Anleitung erfahren Sie, wie Sie Azure Pipelines, Cloud Run und Container Registryverwenden, um eine CI/CD-Pipeline (Continuous Integration/Continuous Deployment) für eine Webanwendung von ASP.NET MVC Core zu erstellen.

Die CI/CD-Pipeline verwendet zwei Google Cloud-Projekte, eines für die Entwicklung und eines für die Produktion, wie das folgende Diagramm zeigt.

Grafik: Architektur der Interaktion der Build- und Releasepipelines von Azure mit den Produktions- und Entwicklungspipelines von Google Cloud

Am Anfang der Pipeline nehmen Entwickler Änderungen an der Beispielcodebasis vor. Diese Aktion veranlasst die Pipeline dazu, einen Release zu erstellen und im Entwicklungscluster in Cloud Run bereitzustellen. Ein Releasemanager stellt dann den Release hoch, sodass er im Produktionsprojekt bereitgestellt wird.

Diese Anleitung richtet sich an Entwickler und DevOps-Entwickler. Dabei werden Grundkenntnisse in .NET Core, Azure Pipelines, Cloud Run und git vorausgesetzt. Für diese Anleitung benötigen Sie Administratorzugriff auf ein Azure DevOps-Konto.

Lernziele

  • Verbindung von Container Registry zu Azure Pipelines für die Veröffentlichung von Docker-Images herstellen
  • .NET Core-Beispielanwendung für das Deployment in Cloud Run vorbereiten
  • Authentifizierung zwischen Azure Pipelines und Google Cloud einrichten
  • Releaseverwaltung von Azure Pipelines zur Orchestrierung von Cloud Run-Deployments verwenden

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 dieser Anleitung verwenden Sie zwei separate Projekte, eines für die Entwicklung und eines für die Produktion. Wenn Sie separate Projekte verwenden, können Sie Releases testen, bevor Sie sie in der Produktion bereitstellen. Außerdem können Sie IAM-Rollen (Identity and Access Management) und -Berechtigungen einzeln verwalten.

  1. Erstellen Sie ein Google Cloud-Projekt für die Entwicklung. In der Anleitung wird dieses Projekt als Entwicklungsprojekt bezeichnet.
  2. Erstellen Sie ein Google Cloud-Projekt für die Produktion. In der Anleitung wird dieses Projekt als Produktionsprojekt bezeichnet.

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

  4. Sie brauchen ein Azure DevOps-Konto mit Administratorzugriff. 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 Cloud Run zu orchestrieren. Erstellen Sie zuerst in Ihrem Azure DevOps-Konto ein Projekt.

  1. Rufen Sie die Azure DevOps-Startseite (https://dev.azure.com/YOUR_AZURE_DEVOPS_ACCOUNT_NAME) auf.
  2. Klicken Sie auf Neues Projekt.
  3. Geben Sie einen Projektnamen ein, z. B. CloudDemo.
  4. Legen Sie Visibility (Sichtbarkeit) auf Private (Privat) fest und klicken Sie dann auf Create project (Projekt erstellen).
  5. Nachdem Sie das Projekt erstellt haben, klicken Sie im Menü links auf Repositories.
  6. 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

  7. Klicken Sie auf Importieren.

    Wenn der Importvorgang abgeschlossen ist, wird der Quellcode des Repositorys dotnet-docs-samples angezeigt.

Azure Pipelines mit Container Registry verbinden

Bevor Sie die kontinuierliche Integration für die Anwendung CloudDemo einrichten können, müssen Sie Azure Pipelines mit Container Registry verbinden. Über diese Verbindung kann Azure Pipelines Container-Images in Container Registry veröffentlichen.

Dienstkonto für die Veröffentlichung von Images einrichten

Erstellen Sie ein Google Cloud-Dienstkonto in Ihrem Produktionsprojekt:

  1. Wechseln Sie in der Google Cloud Console zum Produktionsprojekt.

  2. Aktivieren Sie Cloud Shell in der Google Cloud Console.

    Cloud Shell aktivieren

  3. Initialisieren Sie die folgenden Umgebungsvariablen:

    DEV_PROJECT_ID=DEV_PROJECT_ID
PROD_PROJECT_ID=PROD_PROJECT_ID

    Dabei gilt:

    • DEV_PROJECT_ID: Die Projekt-ID Ihres Entwicklungsprojekts
    • PROD_PROJECT_ID: Die Projekt-ID Ihres Produktionsprojekts

  4. Aktivieren Sie im Produktionsprojekt die Container Registry API:

    gcloud services enable containerregistry.googleapis.com \
    --project=$PROD_PROJECT_ID

  5. Erstellen Sie ein Dienstkonto, das von Azure Pipelines zum Veröffentlichen von Docker-Images verwendet wird:

    gcloud iam service-accounts create azure-pipelines-publisher \
    --display-name="Azure Pipelines Publisher" \
    --project=$PROD_PROJECT_ID

  6. Weisen Sie dem Dienstkonto die IAM-Rolle "Storage Administrator" (roles/storage.admin) zu, damit Azure Pipelines per Push in Container Registry übertragen kann:

    AZURE_PIPELINES_PUBLISHER=azure-pipelines-publisher@$PROD_PROJECT_ID.iam.gserviceaccount.com

gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
    --role roles/storage.admin \
    --project=$PROD_PROJECT_ID

  7. Generieren Sie einen Dienstkontoschlüssel:

    gcloud iam service-accounts keys create azure-pipelines-publisher.json \
    --iam-account $AZURE_PIPELINES_PUBLISHER \
    --project=$PROD_PROJECT_ID

tr -d '\n' < azure-pipelines-publisher.json > azure-pipelines-publisher-oneline.json

  8. Rufen Sie den Inhalt der Dienstkonto-Schlüsseldatei auf:

    echo $(<azure-pipelines-publisher-oneline.json)

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

Dienstverbindung für Container Registry erstellen

Erstellen Sie in Azure Pipelines eine neue Dienstverbindung für Container Registry:

  1. Wählen Sie im Azure DevOps-Menü die Option Project settings und dann Pipelines > Agent pools aus.
  2. Klicken Sie auf Dienstverbindung erstellen.
  3. Wählen Sie in der Liste Docker Registry aus und klicken Sie dann auf Next.
  4. Geben Sie im Dialogfeld Werte für die folgenden Felder ein:
    • Registry type: Others.
    • Docker Registry: https://gcr.io/PROD_PROJECT_ID. Ersetzen Sie PROD_PROJECT_ID durch den Namen Ihres Produktionsprojekts (z. B. https://gcr.io/azure-pipelines-test-project-12345).
    • Docker ID: _json_key.
    • Password: Fügen Sie den Inhalt von azure-pipelines-publisher-oneline.json ein.
    • Service connection name: gcr-tutorial.
  5. Klicken Sie auf Save, um die Verbindung herzustellen.

Kontinuierlich erstellen

Sie können jetzt mit Azure Pipelines die kontinuierliche Integration einrichten. Für jeden Commit, der an das Git-Repository gesendet wird, erstellt Azure Pipelines den Code und verpackt die Build-Artefakte in einen Docker-Container. Der Container wird dann in Container Registry veröffentlicht.

Das Repository enthält bereits das folgende Dockerfile:

applications/clouddemo/netcore/Dockerfile 
#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

FROM mcr.microsoft.com/dotnet/aspnet:6.0
EXPOSE 8080

#------------------------------------------------------------------------------
# Copy publishing artifacts.
#------------------------------------------------------------------------------

WORKDIR /app
COPY CloudDemo.MvcCore/bin/Release/net6.0/publish/ /app/

ENV ASPNETCORE_URLS=http://0.0.0.0:8080

#------------------------------------------------------------------------------
# Run application in Kestrel.
#------------------------------------------------------------------------------

ENTRYPOINT ["dotnet", "CloudDemo.MvcCore.dll"]

Jetzt erstellen Sie eine neue Pipeline, die die YAML-Syntax verwendet:

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

  3. Kopieren Sie den folgenden Code in die Datei:

    resources:
- repo: self
  fetchDepth: 1
queue:
  name: Hosted Ubuntu 1604
trigger:
- master
variables:
  TargetFramework: 'net6.0'
  BuildConfiguration: 'Release'
  DockerImageName: 'PROD_PROJECT_ID/CloudDemo'
steps:
- task: DotNetCoreCLI@2
  displayName: Publish
  inputs:
    projects: 'applications/clouddemo/netcore/CloudDemo.MvcCore.sln'
    publishWebProjects: false
    command: publish
    arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
    zipAfterPublish: false
    modifyOutputPath: false
- task: PublishBuildArtifacts@1
  displayName: 'Publish Artifact'
  inputs:
    PathtoPublish: '$(build.artifactstagingdirectory)'
- task: Docker@2
  displayName: 'Login to Container Registry'
  inputs:
    command: login
    containerRegistry: 'gcr-tutorial'
- task: Docker@2
  displayName: 'Build and push image'
  inputs:
    Dockerfile: 'applications/clouddemo/netcore/Dockerfile'
    command: buildAndPush
    repository: '$(DockerImageName)'

    Ersetzen Sie PROJECT_ID durch den Namen Ihres Produktionsprojekts und speichern Sie die Datei.

    Da es sich bei Cloud Run um eine Linux-basierte Umgebung handelt, verwendet die Pipeline Linux-basierte Build-Agents.

  4. Ü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

  5. Wählen Sie im Azure DevOps-Menü Pipelines aus und klicken Sie dann auf Pipeline erstellen.

  6. Wählen Sie Azure Repos Git aus.

  7. Wählen Sie Ihr Repository aus.

  8. Klicken Sie auf der Seite YAML-Pipeline prüfen auf Ausführen.

    Ein neuer Build wird ausgelöst. Der Build kann etwa zwei Minuten dauern.

  9. Wechseln Sie zur Überprüfung, ob das Image in Container Registry veröffentlicht wurde, zu Ihrem Produktionsprojekt in der Google Cloud Console. Wählen Sie dort Container Registry > Images aus und klicken Sie dann auf CloudDemo.

    Ein einzelnes Image und dessen Tag werden angezeigt. Das Tag entspricht der numerischen ID des Builds, der in Azure Pipelines ausgeführt wurde.

Kontinuierliches Deployment

Da Azure Pipelines den Code automatisch erstellt und für jedes Commit Docker-Images veröffentlicht werden, können Sie sich nun dem Deployment widmen.

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 Bereitstellungen 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 zwei Phasen: Entwicklung und Produktion. In jeder Phase verwendet die Releasepipeline das von der Build-Pipeline erstellte Docker-Image und stellt es dann in Cloud Run bereit.

Vor der Veröffentlichung in Container Registry kennzeichnet die von Ihnen konfigurierte Build-Pipeline jedes Docker-Image mit der Build-ID. Daher ermitteln Sie das richtige Docker-Image für die Bereitstellung in der Releasepipeline mithilfe der Variablen $BUILD_BUILDID.

Cloud Run konfigurieren

Cloud Run ist eine vollständig verwaltete, serverlose Umgebung. Daher brauchen Sie keine Infrastruktur bereitzustellen. Damit die Sicherheit Ihrer Cloud Run-Bereitstellungen gewährleistet ist, müssen Sie IAM einrichten.

Wie das folgende Diagramm zeigt, sind beim Bereitstellen und Ausführen eines Cloud Run-Dienstes mehrere Identitäten involviert.

Diagramm: Identitäten, die als Dienstkonten in einer Cloud Run-Bereitstellung ausgeführt werden.

Jede dieser Identitäten wird als Dienstkonto implementiert und, wie in der folgenden Tabelle beschrieben, für einen bestimmten Zweck verwendet.

Dienstkonto Verwendet von Zweck Erforderliche Rollen
Azure Pipelines Publisher Build-Pipeline Docker-Images in Container Registry veröffentlichen roles/storage.admin (nur Produktionsprojekt)
Azure Pipelines Deployer Releasepipeline Cloud Run-Bereitstellungen auslösen roles/run.admin
CloudDemo-Dienst starten roles/iam.serviceAccountUser
Cloud Run-Dienst-Agent Cloud Run Docker-Images aus Container Registry abrufen roles/storage.objectViewer (nur Produktionsprojekt)
CloudDemo-Runner (Laufzeitdienstkonto) CloudDemo-Dienst Auf Ressourcen in Google Cloud zugreifen –

Sie haben das Dienstkonto Azure Pipelines Publisher erstellt und konfiguriert. In den folgenden Abschnitten erstellen und konfigurieren Sie die verbleibenden Dienstkonten.

Cloud Run-Dienstkonto konfigurieren

  1. Cloud Shell öffnen

  2. Initialisieren Sie die folgenden Umgebungsvariablen:

    DEV_PROJECT_ID=DEV_PROJECT_ID
PROD_PROJECT_ID=PROD_PROJECT_ID

    Dabei gilt:

    • DEV_PROJECT_ID: Die Projekt-ID Ihres Entwicklungsprojekts
    • PROD_PROJECT_ID: Die Projekt-ID Ihres Produktionsprojekts

  3. Aktivieren Sie sowohl im Entwicklungs- als auch im Produktionsprojekt die Cloud Run API und die Compute Engine API:

    gcloud services enable run.googleapis.com --project=$DEV_PROJECT_ID
gcloud services enable run.googleapis.com --project=$PROD_PROJECT_ID

    Wenn Sie diese APIs aktivieren, werden die Cloud Run-Dienst-Agent-Konten in Ihren Projekten erstellt.

  4. Gewähren Sie den beiden Cloud Run-Dienst-Agent-Konten in dem Produktionsprojekt, in dem Ihre Docker-Images gespeichert sind, Zugriff auf Container Registry:

    DEV_PROJECT_NUMBER=$(gcloud projects describe $DEV_PROJECT_ID \
    --format='value(projectNumber)')
PROD_PROJECT_NUMBER=$(gcloud projects describe $PROD_PROJECT_ID \
    --format='value(projectNumber)')

gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member=serviceAccount:service-$DEV_PROJECT_NUMBER@serverless-robot-prod.iam.gserviceaccount.com \
    --role roles/storage.objectViewer

gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member=serviceAccount:service-$PROD_PROJECT_NUMBER@serverless-robot-prod.iam.gserviceaccount.com \
    --role roles/storage.objectViewer

CloudDemo-Runner-Konto konfigurieren

Sie können jetzt das CloudDemo-Runner-Konto konfigurieren. Dabei handelt es sich um ein benutzerdefiniertes Laufzeitdienstkonto für den CloudDemo-Dienst:

  • Erstellen Sie ein Dienstkonto mit dem Namen CloudDemo-runner:

    gcloud iam service-accounts create clouddemo-runner \
    --display-name="CloudDemo Runner" \
    --project=$DEV_PROJECT_ID

gcloud iam service-accounts create clouddemo-runner \
    --display-name="CloudDemo Runner" \
    --project=$PROD_PROJECT_ID

DEV_CLOUDDEMO_RUNNER=clouddemo-runner@$DEV_PROJECT_ID.iam.gserviceaccount.com

PROD_CLOUDDEMO_RUNNER=clouddemo-runner@$PROD_PROJECT_ID.iam.gserviceaccount.com

Azure Pipelines Deployer-Konto konfigurieren

Erstellen und konfigurieren Sie schließlich das Azure Pipelines Deployer-Konto, das die Azure-Releasepipeline für die Bereitstellung in Cloud Run verwendet.

  1. Erstellen Sie ein Dienstkonto mit dem Namen azure-pipelines-deployer:

    gcloud iam service-accounts create azure-pipelines-deployer \
    --display-name="Azure Pipelines Deployer" \
    --project=$PROD_PROJECT_ID

AZURE_PIPELINES_DEPLOYER=azure-pipelines-deployer@$PROD_PROJECT_ID.iam.gserviceaccount.com

  2. Weisen Sie die erforderlichen IAM-Rollen zu, um neue Cloud Run-Dienste oder -Überarbeitungen im Entwicklungsprojekt bereitzustellen:

    gcloud projects add-iam-policy-binding $DEV_PROJECT_ID \
    --member serviceAccount:$AZURE_PIPELINES_DEPLOYER \
    --role roles/run.admin

gcloud iam service-accounts add-iam-policy-binding \
    $DEV_CLOUDDEMO_RUNNER \
    --member=serviceAccount:$AZURE_PIPELINES_DEPLOYER \
    --role="roles/iam.serviceAccountUser" \
    --project=$DEV_PROJECT_ID

  3. Weisen Sie dem Produktionsprojekt dieselben Rollen zu:

    gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
    --member serviceAccount:$AZURE_PIPELINES_DEPLOYER \
    --role roles/run.admin

gcloud iam service-accounts add-iam-policy-binding \
    $PROD_CLOUDDEMO_RUNNER \
    --member=serviceAccount:$AZURE_PIPELINES_DEPLOYER \
    --role="roles/iam.serviceAccountUser" \
    --project=$PROD_PROJECT_ID

  4. Generieren Sie einen Dienstkontoschlüssel:

    gcloud iam service-accounts keys create azure-pipelines-deployer.json \
    --iam-account=$AZURE_PIPELINES_DEPLOYER \
    --project=$PROD_PROJECT_ID

cat azure-pipelines-deployer.json | base64 -w 0

    Sie verwenden die Ausgabe dieses Befehls, wenn Sie die Releasepipeline konfigurieren.

Releasepipeline konfigurieren

Sie können jetzt zu Azure Pipelines zurückkehren, um die Bereitstellung zu automatisieren. Die folgenden Schritte sind dafür nötig:

  • In der Entwicklungsumgebung bereitstellen
  • Anfordern der manuellen Genehmigung, bevor das Deployment in der Produktionsumgebung eingeleitet wird
  • In der Produktionsumgebung bereitstellen

Release-Definition erstellen

Erstellen Sie zuerst eine Release-Definition:

  1. Wählen Sie im Azure DevOps-Menü Pipelines > Releases aus.
  2. Klicken Sie auf New pipeline.
  3. Wählen Sie in der Vorlagenliste den Eintrag Empty job aus.
  4. Wenn Sie einen Namen für die Phase angeben sollen, geben Sie Development ein.
  5. Geben Sie der Pipeline oben auf dem Bildschirm den Namen CloudDemo.
  6. Klicken Sie im Pipelinediagramm neben Artifacts auf Add.
  7. Wählen Sie Build aus und legen Sie folgende Einstellungen fest:
    • Source type: Build.
    • Source (build pipeline): Wählen Sie die Build-Definition aus (es sollte nur eine Option vorhanden sein).
    • Standardversion: Latest
    • Source Alias: build.
  8. Klicken Sie auf Add (Hinzufügen).
  9. Klicken Sie im Feld Artifact (Artefakt) auf Continuous deployment trigger (Trigger für kontinuierliches Deployment) (das Blitzsymbol), um einen Deployment-Trigger hinzuzufügen.
  10. Stellen Sie unter Continuous Deployment Trigger den Schieberegler auf Aktiviert ein.
  11. Klicken Sie auf Speichern.

  12. Geben Sie bei Bedarf einen Kommentar ein und bestätigen Sie mit OK.

    Die Pipeline wird in etwa so dargestellt:

    Screenshot: Pipelineansicht bei der Einrichtung einer automatisierten Bereitstellung.

Im Entwicklungsprojekt bereitstellen

Mit der erstellten Release-Definition können Sie nun die Cloud Run-Bereitstellung für das Entwicklungsprojekt konfigurieren.

  1. Wechseln Sie im Menü zum Tab Tasks.
  2. Klicken Sie auf Agent Job.
  3. Setzen Sie die Agent specification auf ubuntu-18.04.
  4. Klicken Sie neben Agent job auf Add a task to agent job , um der Phase einen Schritt hinzuzufügen.
  5. Wählen Sie die Aufgabe Command Line aus und klicken Sie auf Add:

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

    1. Display name: Deploy image to development project.

    2. Script:

      gcloud auth activate-service-account \
    --quiet \
    --key-file <(echo $(ServiceAccountKey) | base64 -d) && \
gcloud run deploy clouddemo \
    --quiet \
    --service-account=clouddemo-runner@$(CloudRun.ProjectId.Development).iam.gserviceaccount.com \
    --allow-unauthenticated \
    --image=gcr.io/$(ContainerRegistry.ProjectId)/clouddemo:$BUILD_BUILDID \
    --platform=managed \
    --region=$(CloudRun.Region) \
    --project=$(CloudRun.ProjectId.Development)

      Mit diesem Befehl wird ein Dienstkontoschlüssel aus einer Umgebungsvariable abgerufen. Anschließend wird die Anwendung mit der gcloud CLI in Cloud Run bereitgestellt. Die gcloud CLI ist standardmäßig in Azure Pipelines-Agents verfügbar.

  7. 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
    ContainerRegistry.ProjectId Projekt-ID Ihres Produktionsprojekts.
    CloudRun.Region Region, die Sie zuvor ausgewählt haben, um Cloud Run-Ressourcen bereitzustellen.
    CloudRun.ProjectId.Development Projekt-ID Ihres Entwicklungsprojekts.
    CloudRun.ProjectId.Production Projekt-ID Ihres Produktionsprojekts.

  8. Klicken Sie auf Save.

  9. Geben Sie bei Bedarf einen Kommentar ein und bestätigen Sie mit OK.

Auf dem Produktionscluster bereitstellen

Abschließend konfigurieren Sie die Bereitstellung für das Produktionsprojekt:

  1. Wechseln Sie im Menü zum Tab Pipeline.
  2. Wählen Sie im Feld "Stages" die Option Add > New stage aus.
  3. Wählen Sie in der Vorlagenliste den Eintrag Empty job aus.
  4. Wenn Sie einen Namen für die Phase angeben sollen, geben Sie Production ein.
  5. Klicken Sie auf das Blitzsymbol der neu erstellten Phase.

  6. Legen Sie folgende Einstellungen fest:

    1. Select trigger: After stage
    2. Stages: Development
    3. Pre-deployment approvals: (aktiviert)
    4. Approvers: Wählen Sie Ihren Nutzernamen aus.

    Die Pipeline zeigt eine Ansicht ähnlich der folgenden an.

    Screenshot: Pipelineansicht der Einrichtung der Clusterbereitstellung

  7. Wechseln Sie zum Tab Tasks.

  8. Bewegen Sie den Mauszeiger auf den Tab Tasks und wählen Sie Tasks > Production aus.

  9. Klicken Sie auf Agent Job.

  10. Setzen Sie die Agent specification auf ubuntu-18.04.

  11. Klicken Sie auf Add a task to agent job , um der Phase einen Schritt hinzuzufügen.

  12. Wählen Sie die Aufgabe Command Line aus und klicken Sie auf Add:

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

    1. Display name: Deploy image to production project.

    2. Script:

      gcloud auth activate-service-account \
    --quiet \
    --key-file <(echo $(ServiceAccountKey) | base64 -d) && \
gcloud run deploy clouddemo \
    --quiet \
    --service-account=clouddemo-runner@$(CloudRun.ProjectId.Production).iam.gserviceaccount.com \
    --allow-unauthenticated \
    --image=gcr.io/$(ContainerRegistry.ProjectId)/clouddemo:$BUILD_BUILDID \
    --platform=managed \
    --region=$(CloudRun.Region) \
    --project=$(CloudRun.ProjectId.Production)

  14. Klicken Sie auf Speichern.

  15. 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:

  1. Öffnen Sie auf Ihrem lokalen Computer die Datei applications\clouddemo\netcore\CloudDemo.MvcCore\Views\Home\Index.cshtml aus dem Git-Repository, das Sie zuvor geklont haben.
  2. Ändern Sie in Zeile 26 den Wert von ViewBag.Title von Home Page in Home Page Cloud Run.

  3. Ü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

  4. Wählen Sie im Azure DevOps-Menü Pipelines aus. Ein Build wird ausgelöst.

  5. Wählen Sie nach Abschluss des Builds Pipelines > Releases aus. Ein Freigabeprozess wird gestartet.

  6. Klicken Sie auf Release-1, um die Detailseite zu öffnen, und warten Sie, bis der Status der Phase Development zu Succeeded wechselt.

  7. Wechseln Sie in der Google Cloud Console zum Entwicklungsprojekt.

  8. Wählen Sie im Menü Compute > Cloud Run aus.

    Der Dienst clouddemo wurde bereitgestellt.

    Screenshot: Bereitstellungsstatus in Cloud Run.

  9. Klicken Sie auf clouddemo, um weitere Details aufzurufen.

    Eine URL, aus der hervorgeht, dass Cloud Run den Dienst bereitgestellt hat, wird angezeigt.

  10. Öffnen Sie die URL in einem neuen Browsertab, um zu prüfen, ob die CloudDemo-Anwendung bereitgestellt wurde und den benutzerdefinierten Titel verwendet.

  11. Klicken Sie in Azure Pipelines neben der Phase Production auf Approve, um die Bereitstellung für die Produktionsumgebung auszulösen.

  12. Optional: Geben Sie einen Kommentar ein.

  13. Klicken Sie zur Bestätigung auf Approve und warten Sie, bis der Status der Umgebung Production zu Succeeded wechselt.

  14. Wechseln Sie in der Google Cloud Console zum Produktionsprojekt.

  15. Wählen Sie im Menü Compute > Cloud Run aus.

    Der Dienst clouddemo wird im Produktionsprojekt bereitgestellt.

  16. Klicken Sie auf clouddemo, um weitere Details aufzurufen.

    Eine URL, aus der hervorgeht, dass Cloud Run den Dienst bereitgestellt hat, wird angezeigt.

  17. Öffnen Sie die URL in einem neuen Browsertab, um zu prüfen, ob die CloudDemo-Anwendung für die Produktion 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

  1. Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Nächste Schritte