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

Azure Pipelines mit Artifact Registry verbinden

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

Dienstkonto für die Veröffentlichung von Images einrichten

Erstellen Sie ein Cloud de Confiance -Dienstkonto in Ihrem Produktionsprojekt:

1. Wechseln Sie in der Cloud de Confiance -Console zum Produktionsprojekt.

2. Aktivieren Sie Cloud Shell in der Cloud de Confiance Console.

   Cloud Shell aktivieren

3. Initialisieren Sie die folgenden Umgebungsvariablen:

   DEV_PROJECT_ID=DEV_PROJECT_ID
   PROD_PROJECT_ID=PROD_PROJECT_ID
   

   Ersetzen Sie dabei Folgendes:

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

4. Aktivieren Sie im Produktionsprojekt die Artifact Registry API:

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

5. Erstellen Sie ein Artifact Registry-Repository zum Speichern Ihrer Docker-Images:

   gcloud artifacts repositories create docker  \
       --project=$PROD_PROJECT_ID \
       --repository-format=docker \
       --location REGION
   

   Ersetzen Sie REGION durch die Region Ihres Artifact Registry-Repositorys, z. B. us-central1.

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

7. Weisen Sie dem Dienstkonto die Rolle „Artifact Registry-Autor“ (roles/artifactregistry.writer) zu, damit Azure Pipelines per Push in Artifact Registry übertragen kann:

   AZURE_PIPELINES_PUBLISHER=azure-pipelines-publisher@$PROD_PROJECT_ID.s3ns.iam.gserviceaccount.com
   
   gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
       --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
       --role roles/artifactregistry.writer \
       --project=$PROD_PROJECT_ID
   

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

9. 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 Artifact Registry erstellen

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

1. Wählen Sie im Azure DevOps-Menü die Option Projekteinstellungen und dann Pipelines > Service connections 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 (Registry-Typ): Others (Andere).

   • Docker-Registrierung: https://REGION-docker.pkg.dev/PROD_PROJECT_ID/docker/

     Ersetzen Sie Folgendes:

     • REGION: die Region Ihres Artifact Registry-Repositorys
     • PROD_PROJECT_ID: Der Name Ihres Produktionsprojekts

   • Docker ID (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 Continuous 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 Artifact Registry veröffentlicht.

Das Repository enthält bereits das folgende 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
   pool:
     vmImage: ubuntu-22.04
   trigger:
   - master
   variables:
     TargetFramework: 'net6.0'
     BuildConfiguration: 'Release'
     DockerImageName: 'PROD_PROJECT_ID/docker/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 Artifact Registry veröffentlicht wurde, zu Ihrem Produktionsprojekt in der Cloud de Confiance Console. Wählen Sie dort Artifact Registry > docker 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 Artifact 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.

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

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
   

   Ersetzen Sie dabei Folgendes:

   • 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 Artifact 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.s3ns-system.iam.gserviceaccount.com \
       --role roles/artifactregistry.reader
   
   gcloud projects add-iam-policy-binding $PROD_PROJECT_ID \
       --member=serviceAccount:service-$PROD_PROJECT_NUMBER@serverless-robot-prod.s3ns-system.iam.gserviceaccount.com \
       --role roles/artifactregistry.reader
   

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.s3ns.iam.gserviceaccount.com
  
  PROD_CLOUDDEMO_RUNNER=clouddemo-runner@$PROD_PROJECT_ID.s3ns.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.s3ns.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.

Release-Pipeline 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.
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:

    

Im Entwicklungsprojekt bereitstellen

Mit der erstellten Releasedefinition 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 (Agent-Job).
3. Setzen Sie die Agent-Spezifikation auf ubuntu-22.04.
4. Klicken Sie neben Agent job (Agent-Job) auf Add a task to agent job (Aufgabe zum Agent-Job hinzufügen) add, um der Phase einen Schritt hinzuzufügen.
5. Wählen Sie die Aufgabe Befehlszeile aus und klicken Sie auf Hinzufügen.

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

   1. Display name (Anzeigename): 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).s3ns.iam.gserviceaccount.com \
          --allow-unauthenticated \
          --image=$(CloudRun.Region)-docker.pkg.dev/$(ContainerRegistry.ProjectId)/docker/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 Artifact Registry-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.

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

   

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 (Agent-Job).

10. Setzen Sie die Agent-Spezifikation auf ubuntu-22.04.

11. Klicken Sie auf Add a task to agent job (Aufgabe zum Agent-Job hinzufügen) add, um der Phase einen Schritt hinzuzufügen.

12. Wählen Sie die Aufgabe Befehlszeile aus und klicken Sie auf Hinzufügen:

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

    1. Display name (Anzeigename): 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).s3ns.iam.gserviceaccount.com \
           --allow-unauthenticated \
           --image=$(CloudRun.Region)-docker.pkg.dev/$(ContainerRegistry.ProjectId)/docker/clouddemo:$BUILD_BUILDID \
           --platform=managed \
           --region=$(CloudRun.Region) \
           --project=$(CloudRun.ProjectId.Production)
       

14. Klicken Sie auf Save.

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 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 Cloud de Confiance -Console zum Entwicklungsprojekt.

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

   Der Dienst clouddemo wurde bereitgestellt.

   

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 Cloud de Confiance -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.