Créer un pipeline CI/CD avec Azure Pipelines et Cloud Run

Ce tutoriel explique comment utiliser Azure Pipelines, Cloud Run et Container Registry afin de créer un pipeline d'intégration continue/de déploiement continu (CI/CD) pour une application Web principale ASP.NET MVC.

Le pipeline CI/CD utilise deux projets Google Cloud , un pour le développement et un pour la production, comme le montre le schéma suivant.

Architecture de l'interaction des pipelines de compilation et de publication Azure avec les pipelines de production et de développement Google Cloud.

Au début du pipeline, les développeurs effectuent un commit des modifications dans l'exemple de codebase. Cette action déclenche le pipeline pour créer un release et le déployer sur Cloud Run dans le cluster de développement. Un gestionnaire de releases déclenche ensuite le déploiement de la version dans le projet de production.

Ce tutoriel est destiné aux développeurs et aux ingénieurs DevOps. Nous partons du principe que vous possédez des connaissances de base sur .NET, Azure Pipelines, Cloud Run et git. Pour suivre ce tutoriel, vous devez disposer d'un accès administrateur à un compte Azure DevOps.

Objectifs

Connecter Artifact Registry à Azure Pipelines pour la publication d'images Docker
Préparer un exemple d'application .NET pour le déploiement dans Cloud Run
Configurer l'authentification entre Azure Pipelines et Google Cloud
Utiliser la gestion des releases d'Azure Pipelines pour orchestrer les déploiements sur Cloud Run

Coûts

Dans ce document, vous utilisez les composants facturables de Google Cloudsuivants :

Vous pouvez obtenir une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Consultez la page des tarifs d'Azure DevOps pour connaître les frais éventuels liés à l'utilisation d'Azure DevOps.

Avant de commencer

Vous utiliserez deux projets distincts dans ce tutoriel, un pour le développement et un pour la production. L'utilisation de projets distincts permet de tester les versions avant de les déployer en production, et permet également de gérer individuellement les rôles et les autorisations IAM (Identity and Access Management).

Créez un projet Google Cloud pour le développement. Dans ce tutoriel, ce projet est appelé projet de développement.
Créez un projet Google Cloud pour la production. Dans ce tutoriel, ce projet est appelé projet de production.
Verify that billing is enabled for your Google Cloud project.
Assurez-vous de disposer d'un compte Azure DevOps avec un accès administrateur. Si vous ne possédez pas encore de compte Azure DevOps, vous pouvez vous inscrire sur la page d'accueil Azure DevOps.

Créer un projet Azure DevOps

Azure DevOps permet de gérer le code source, d'exécuter des builds et des tests, et d'orchestrer le déploiement sur Cloud Run. Pour commencer, vous devez créer un projet dans votre compte Azure DevOps.

Accédez à la page d'accueil Azure DevOps (https://dev.azure.com/YOUR_AZURE_DEVOPS_ACCOUNT_NAME).
Cliquez sur New project (Nouveau projet).
Indiquez un nom de projet, tel que CloudDemo.
Définissez Visibility (Visibilité) sur Private (Mode privé), puis cliquez sur Create project (Créer un projet).
Une fois le projet créé, dans le menu de gauche, cliquez sur Repos (Dépôt).
Cliquez sur Import (Importer) pour dupliquer le dépôt dotnet-docs-samples à partir de GitHub, puis définissez les valeurs suivantes :
- Type de dépôt : Git
- Clone URL (URL du clone) : https://github.com/GoogleCloudPlatform/dotnet-docs-samples.git
Cliquez sur Import (Importer).

Une fois le processus d'importation terminé, le code source du dépôt dotnet-docs-samples s'affiche.

Connecter Azure Pipelines à Artifact Registry

Avant de pouvoir configurer l'intégration continue pour l'application CloudDemo, vous devez connecter Azure Pipelines à Artifact Registry. Cette connexion permet à Azure Pipelines de publier des images de conteneurs dans Artifact Registry.

Configurer un compte de service pour la publication d'images

Créez un Google Cloud compte de service dans votre projet de production :

Dans la console Google Cloud , basculez vers le projet de production.
In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell
Définissez les variables d'environnement suivantes :
```
DEV_PROJECT_ID=DEV_PROJECT_ID
PROD_PROJECT_ID=PROD_PROJECT_ID
```
Remplacez l'élément suivant :
- DEV_PROJECT_ID : par l'ID de projet de votre projet de développement.
- PROD_PROJECT_ID : par l'ID de projet de votre projet de production.

Activez l'API Artifact Registry dans le projet de production :

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

Créez un dépôt Artifact Registry pour stocker vos images Docker :
```
gcloud artifacts repositories create docker  \
    --project=$PROD_PROJECT_ID \
    --repository-format=docker \
    --location REGION
```
Remplacez REGION par la région de votre dépôt Artifact Registry, par exemple us-central1.

Créez un compte de service utilisé par Azure Pipelines pour publier des images Docker :

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

Attribuez le rôle Rédacteur Artifact Registry (roles/artifactregistry.writer) au compte de service pour permettre à Azure Pipelines de transférer les données dans Artifact Registry :

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/artifactregistry.writer \
    --project=$PROD_PROJECT_ID

Générez une clé de compte de service :

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

Affichez le contenu du fichier de clé du compte de service :
```
echo $(<azure-pipelines-publisher-oneline.json)
```
La clé de compte de service est nécessaire pour l'une des étapes suivantes.

Créer une connexion de service pour Artifact Registry

Dans Azure Pipelines, créez une connexion de service pour Artifact Registry :

Dans le menu Azure DevOps, sélectionnez Project settings (Paramètres du projet), puis Pipelines > Service connections (Connexions de service).
Cliquez sur Créer une connexion de service.
Dans la liste, sélectionnez Docker Registry (Registre Docker), puis cliquez sur Next (Suivant).
Dans la boîte de dialogue, entrez des valeurs pour les champs suivants :
- Registry type (Type de registre) : Others (Autres)
- Registre Docker : https://REGION-docker.pkg.dev/PROD_PROJECT_ID/docker/
  
  Remplacez les éléments suivants :
  - REGION : région de votre dépôt Artifact Registry
  - PROD_PROJECT_ID : nom de votre projet de production
- Docker ID (ID Docker) : _json_key
- Password (Mot de passe) : collez le contenu de azure-pipelines-publisher-oneline.json.
- Service connexion name (Nom de la connexion au service) : gcr-tutorial
Cliquez sur Save (Enregistrer) pour créer la connexion.

Compiler en continu

Vous pouvez maintenant utiliser Azure Pipelines pour configurer l'intégration continue. Pour chaque commit envoyé dans le dépôt Git, Azure Pipelines compile le code et crée un package des artefacts de la compilation dans un conteneur Docker. Le conteneur est ensuite publié dans Artifact Registry.

Le dépôt contient déjà le fichier Dockerfile suivant :

#
# 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"]

Vous allez maintenant créer un pipeline qui utilise la syntaxe YAML :

À l'aide de Visual Studio ou d'un client git de ligne de commande, clonez votre nouveau dépôt Git.
À la racine du dépôt, créez un fichier nommé azure-pipelines.yml.

Copiez le code suivant dans le fichier :

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)'

Remplacez PROJECT_ID par le nom de votre projet de production, puis enregistrez le fichier.

Cloud Run étant un environnement Linux, le pipeline utilise des agents de compilation basés sur Linux.

Faites un commit de vos modifications et transférez-les vers Azure Pipelines.
Visual Studio
1. Ouvrez Team Explorer, puis cliquez sur l'icône Home (Accueil).
2. Cliquez sur les Modifications.
3. Saisissez un message de commit, tel que Add pipeline definition.
4. Cliquez sur Valider tout et envoyer.
Ligne de commande
1. Préproduisez tous les fichiers modifiés :
  git add -A
2. Faites un commit des modifications dans le dépôt local :
  git commit -m "Add pipeline definition"
3. Transférez les modifications vers Azure DevOps :
  git push
Dans le menu Azure DevOps, sélectionnez Pipelines, puis cliquez sur Create Pipeline (Créer un pipeline).
Sélectionnez Azure Repos Git.
Sélectionnez votre dépôt.
Sur la page Examiner le pipeline YAML, cliquez sur Exécuter.

Une nouvelle compilation est déclenchée. La compilation prend environ deux minutes.
Pour vérifier que l'image a été publiée dans Artifact Registry, sélectionnez votre projet de production dans la console Google Cloud , cliquez sur Artifact Registry > docker, puis sur CloudDemo.

Une seule image et le tag associé s'affichent. Le tag correspond à l'ID numérique du build exécuté dans Azure Pipelines.

Déployer en continu

Puisque Azure Pipelines crée automatiquement votre code et publie des images Docker pour chaque commit, vous pouvez désormais vous concentrer sur le déploiement.

Contrairement à d'autres systèmes d'intégration continue, Azure Pipelines fait la distinction entre la compilation et le déploiement, et fournit un ensemble spécialisé d'outils appelé "Release Management" (gestion des versions) pour toutes les tâches liées au déploiement.

La gestion des versions Azure Pipelines repose sur les concepts suivants :

Une version fait référence à un ensemble d'artefacts qui constituent une révision spécifique de votre application et qui résultent généralement d'un processus de compilation.
Le déploiement désigne le processus qui consiste à prendre une version et à la déployer dans un environnement spécifique.
Un déploiement exécute un ensemble de tâches pouvant être regroupées en jobs.
Les étapes vous permettent de segmenter votre pipeline et peuvent être utilisées pour orchestrer des déploiements dans plusieurs environnements, par exemple des environnements de développement et de test.

Vous configurez votre pipeline de publication pour qu'il se déclenche à chaque nouvelle compilation. Le pipeline comporte deux étapes : le développement et la production. À chaque étape, le pipeline de publication utilise l'image Docker générée par le pipeline de compilation, puis la déploie sur Cloud Run.

Le pipeline de compilation que vous avez configuré précédemment marque chaque image Docker avec l'ID de build avant de la publier dans Artifact Registry. Par conséquent, dans le pipeline de publication, vous utilisez la variable $BUILD_BUILDID pour identifier l'image Docker appropriée à déployer.

Configurer Cloud Run

Cloud Run est un environnement sans serveur entièrement géré. Vous n'avez donc pas besoin de provisionner d'infrastructure. Pour sécuriser vos déploiements Cloud Run, vous devez configurer IAM.

Le déploiement et l'exécution d'un service Cloud Run impliquent plusieurs identités, comme le montre le schéma suivant.

Identités s'exécutant en tant que comptes de service dans un déploiement Cloud Run.

Chacune de ces identités est mise en œuvre en tant que compte de service et est utilisée dans un but spécifique, comme décrit dans le tableau suivant.

Compte de service	Utilisée par	Usage	Rôles requis
Éditeur Azure Pipelines	Créer un pipeline	Publier des images Docker dans Artifact Registry	`roles/artifactregistry.writer` (projet de production uniquement)
Déployeur Azure Pipelines	Pipeline de publication	Lancer des déploiements Cloud Run	`roles/run.admin`
		Lancer le service CloudDemo	`roles/iam.serviceAccountUser`
Agent de service Cloud Run	Cloud Run	Extraire des images Docker à partir d'Artifact Registry	`roles/artifactregistry.reader` (projet de production uniquement)
Exécution de CloudDemo (compte de service d'exécution)	Service CloudDemo	Accéder aux ressources sur Google Cloud	Aucun

Vous avez créé et configuré le compte de service Éditeur Azure Pipelines. Dans les sections suivantes, vous allez créer et configurer les comptes de service restants.

Configurer le compte de service Cloud Run

Ouvrez Cloud Shell.
Définissez les variables d'environnement suivantes :
```
DEV_PROJECT_ID=DEV_PROJECT_ID
PROD_PROJECT_ID=PROD_PROJECT_ID
```
Remplacez l'élément suivant :
- DEV_PROJECT_ID : par l'ID de projet de votre projet de développement.
- PROD_PROJECT_ID : par l'ID de projet de votre projet de production.
Activez les API Cloud Run et Compute Engine dans les projets de développement et de production :
```
gcloud services enable run.googleapis.com --project=$DEV_PROJECT_ID
gcloud services enable run.googleapis.com --project=$PROD_PROJECT_ID
```
L'activation de ces API entraîne la création des comptes d'agent de service Cloud Run dans vos projets.

Accordez aux deux comptes d'agent de service Cloud Run l'accès à Artifact Registry dans le projet de production où vos images Docker sont stockées :

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/artifactregistry.reader

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

Configurer le compte d'exécution CloudDemo

Vous pouvez maintenant configurer le compte d'exécution CloudDemo, qui est un compte de service d'exécution personnalisé pour le service CloudDemo :

Créez un compte de service nommé 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

Configurer le compte Déployeur Azure Pipelines

Enfin, créez et configurez le compte Déployeur Azure Pipelines qui permet au pipeline de publication Azure d'effectuer les déploiements sur Cloud Run.

Créez un compte de service nommé 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

Attribuez les rôles IAM requis pour déployer de nouveaux services ou révisions Cloud Run dans le projet de développement :

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

Attribuez le même ensemble de rôles pour le projet de production :

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

Générez une clé de compte de service :

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

La sortie de cette commande vous servira à configurer le pipeline de publication.

Configurer le pipeline de publication

Vous pouvez maintenant revenir à Azure Pipelines pour automatiser le déploiement, qui comprend les étapes suivantes :

Le déploiement dans l'environnement de développement
La demande d'approbation manuelle avant de lancer un déploiement dans l'environnement de production
Le déploiement dans l'environnement de production

Créer une définition de release

Tout d'abord, créez une définition de release :

Dans le menu Azure DevOps, sélectionnez Pipelines > Releases.
Cliquez sur New pipeline (Nouveau pipeline).
Dans la liste des modèles, sélectionnez Empty job (Job vide).
Lorsque vous êtes invité à donner un nom à l'étape, saisissez Development.
En haut de l'écran, nommez le pipeline CloudDemo.
Dans le schéma du pipeline, à côté d'Artifacts (Artefacts), cliquez sur Add (Ajouter).
Sélectionnez Build (Compilation) et ajoutez les paramètres suivants :
- Source type (Type de source) : Build
- Source (build pipeline) (pipeline de compilation) : sélectionnez la définition de compilation (il ne devrait y avoir qu'une seule option)
- Version par défaut : Latest
- Source alias (Alias source) : build
Cliquez sur Add (Ajouter).
Dans la zone Artifact (Artefact), cliquez sur Continuous deployment trigger (Déclencheur de déploiement continu), c'est-à-dire l'icône représentant un éclair, pour ajouter un déclencheur de déploiement.
Sous Continuous deployment trigger (Déclencheur de déploiement continu) définissez le commutateur sur Enabled (Activé).
Cliquez sur Save.
Saisissez un commentaire si vous le souhaitez, puis confirmez en cliquant sur OK.

Le pipeline affiché ressemble à ce qui suit :

Déployer dans le projet de développement

Une fois la définition de release créée, vous pouvez configurer le déploiement Cloud Run sur le projet de développement.

Dans le menu, accédez à l'onglet Tâches.
Cliquez sur Agent job (Job de l'agent).
Définissez Agent specification (Spécification de l'agent) sur ubuntu-22.04.
À côté de Agent job (Job de l'agent), cliquez sur Add a task to agent job (Ajouter une tâche au job de l'agent) pour ajouter une étape à la phase.
Cliquez sur la tâche Command Line (Ligne de commande), puis sur Add (Ajouter).

Cliquez sur la tâche nouvellement ajoutée et configurez les paramètres suivants :

Display name (Nom à afficher) : Deploy image to development project

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=$(CloudRun.Region)-docker.pkg.dev/$(ContainerRegistry.ProjectId)/docker/clouddemo:$BUILD_BUILDID \
    --platform=managed \
    --region=$(CloudRun.Region) \
    --project=$(CloudRun.ProjectId.Development)

Cette commande obtient une clé de compte de service provenant d'une variable d'environnement, puis utilise gcloud CLI pour déployer l'application sur Cloud Run. gcloud CLI est disponible par défaut sur les agents Azure Pipelines.

Passez à l'onglet Variables et ajoutez les variables ci-dessous.

Nom	Valeur	Secret
`ServiceAccountKey`	Clé de compte de service créée précédemment pour `azure-pipelines-deployer`.	Oui
`ContainerRegistry.ProjectId`	ID du projet de production.
`CloudRun.Region`	Région dans laquelle vous avez sélectionné précédemment le déploiement des ressources Artifact Registry.
`CloudRun.ProjectId.Development`	ID du projet de développement.
`CloudRun.ProjectId.Production`	ID du projet de production.

Cliquez sur Save.
Saisissez un commentaire si vous le souhaitez, puis confirmez en cliquant sur OK.

Déployer sur le cluster de production

Enfin, vous devez configurer le déploiement sur l'environnement de production.

Dans le menu, accédez à l'onglet Pipeline.
Dans la zone "Stages" (Étapes), sélectionnez Add (Ajouter) > New stage (Nouvelle étape).
Dans la liste des modèles, sélectionnez Empty job (Job vide).
Lorsque vous êtes invité à donner un nom à l'étape, saisissez Production.
Cliquez sur l'icône en forme d'éclair de l'environnement récemment créé.
Configurez les paramètres suivants :
1. Select trigger (Sélectionner le déclencheur) : After stage
2. Stages (Étapes) : Development (Développement)
3. Pre-deployment approvals (Approbations de prédéploiement) : (activé)
4. Approvers (Approbateurs) : sélectionnez votre nom d'utilisateur.
Le pipeline affiche une vue semblable à celle-ci :
Accédez à l'onglet Tasks (Tâches).
Maintenez la souris sur l'onglet Tasks (Tâches) et sélectionnez Tasks (Tâches) > Prod.
Cliquez sur Agent job (Job de l'agent).
Définissez Agent specification (Spécification de l'agent) sur ubuntu-22.04.
Cliquez sur Add a task to agent job (Ajouter une tâche au job de l'agent) pour ajouter une étape à la phase.
Sélectionnez la tâche Command line (Ligne de commande), puis cliquez sur Add (Ajouter).

Cliquez sur la tâche nouvellement ajoutée et configurez les paramètres suivants :

Display name (Nom à afficher) : Deploy image to production project

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=$(CloudRun.Region)-docker.pkg.dev/$(ContainerRegistry.ProjectId)/docker/clouddemo:$BUILD_BUILDID \
    --platform=managed \
    --region=$(CloudRun.Region) \
    --project=$(CloudRun.ProjectId.Production)

Cliquez sur Save.
Saisissez un commentaire si vous le souhaitez, puis confirmez en cliquant sur OK.

Exécuter le pipeline

Maintenant que vous avez configuré l'intégralité du pipeline, vous pouvez le tester en modifiant le code source :

Sur votre ordinateur local, ouvrez le fichier applications\clouddemo\netcore\CloudDemo.MvcCore\Views\Home\Index.cshtml dans le dépôt Git que vous avez cloné précédemment.
Remplacez la valeur de ViewBag.Title (Home Page) par Home Page Cloud Run.
Faites un commit de vos modifications, puis transférez-les vers Azure Pipelines.
Visual Studio
1. Ouvrez Team Explorer, puis cliquez sur l'icône Home (Accueil).
2. Cliquez sur les Modifications.
3. Saisissez un message de commit, tel que Change site title.
4. Cliquez sur Valider tout et envoyer.
Ligne de commande
1. Préproduisez tous les fichiers modifiés :
  git add -A
2. Faites un commit des modifications dans le dépôt local :
  git commit -m "Change site title"
3. Transférez les modifications à Azure Pipelines :
  git push
Dans le menu Azure DevOps, sélectionnez Pipelines. Une compilation est déclenchée.
Une fois la compilation terminée, sélectionnez Pipelines > Releases (Versions). Un processus de déploiement est lancé.
Cliquez sur Release-1 pour ouvrir la page de détails et attendez que l'état de l'étape Development bascule sur Succeeded (Réussite).
Dans la console Google Cloud , basculez vers le projet de développement.
Dans le menu, sélectionnez Compute > Cloud Run.

Le service clouddemo est déployé.
Cliquez sur clouddemo pour afficher plus de détails.

Une URL s'affiche, indiquant que Cloud Run a provisionné le service.
Ouvrez l'URL dans un nouvel onglet de navigateur pour vérifier que l'application CloudDemo est déployée et utilise le titre personnalisé.
Dans Azure Pipelines, cliquez sur Approve (Approuver) (à côté de l'étape Production) pour déclencher le déploiement dans l'environnement de production.
(Facultatif) Saisissez un commentaire.
Confirmez l'opération en cliquant sur Approve (Approuver) et attendez que l'état de l'environnement Production bascule vers Succeeded (Réussite).
Dans la console Google Cloud , basculez vers le projet de production.
Dans le menu, sélectionnez Compute > Cloud Run.

Le service clouddemo est déployé sur le projet de production.
Cliquez sur clouddemo pour afficher plus de détails.

Une URL s'affiche, indiquant que Cloud Run a provisionné le service.
Ouvrez l'URL dans un nouvel onglet de navigateur pour vérifier que l'application CloudDemo est déployée en production et qu'elle utilise le titre personnalisé.

Nettoyer

Pour éviter la facturation des ressources utilisées dans ce tutoriel, supprimez les entités que vous avez créées.

Supprimer le projet Azure Pipelines

Pour supprimer le projet Azure Pipelines, consultez la documentation sur Azure DevOps Services. La suppression du projet Azure Pipelines entraîne la perte de toutes les modifications du code source.

Supprimer les projets de développement et de production Google Cloud

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Étapes suivantes

Configurez un domaine personnalisé pour votre service Cloud Run.
Découvrez comment utiliser Azure Pipelines pour déployer la même application sur Google Kubernetes Engine.
Découvrez comment déployer des applications .NET sur Google Cloud.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Cloud Architecture Center.