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 Core, Azure Pipelines, Cloud Run et git. Pour suivre ce tutoriel, vous devez disposer d'un accès administrateur à un compte Azure DevOps.

Objectifs

  • Connecter Container Registry à Azure Pipelines pour la publication d'images Docker
  • Préparer un exemple d'application .NET Core 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 suivants de Google Cloud :

Obtenez 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 gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. 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).

  1. Créez un projet Google Cloud pour le développement. Dans ce tutoriel, ce projet est appelé projet de développement.
  2. Créez un projet Google Cloud pour la production. Dans ce tutoriel, ce projet est appelé projet de production.

  3. Make sure that billing is enabled for your Google Cloud project.

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

  1. Accédez à la page d'accueil Azure DevOps (https://dev.azure.com/YOUR_AZURE_DEVOPS_ACCOUNT_NAME).
  2. Cliquez sur New project (Nouveau projet).
  3. Indiquez un nom de projet, tel que CloudDemo.
  4. Définissez Visibility (Visibilité) sur Private (Mode privé), puis cliquez sur Create project (Créer un projet).
  5. Une fois le projet créé, dans le menu de gauche, cliquez sur Repos (Dépôt).
  6. Cliquez sur 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

  7. 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 à Container Registry

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

Configurer un compte de service pour la publication d'images

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

  1. Dans la console Google Cloud, basculez vers le projet de production.

  2. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

  3. Définissez les variables d'environnement suivantes :

    DEV_PROJECT_ID=DEV_PROJECT_ID
PROD_PROJECT_ID=PROD_PROJECT_ID

    Remplacez les éléments suivants :

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

  4. Activez l'API Container Registry dans le projet de production :

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

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

  6. Attribuez le rôle IAM d'administrateur Storage (roles/storage.admin) au compte de service pour permettre à Azure Pipelines de transférer les données dans Container 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/storage.admin \
    --project=$PROD_PROJECT_ID

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

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

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

  1. Dans le menu Azure DevOps, sélectionnez Project settings (Paramètres du projet), puis Pipelines > Service connections (Connexions de service).
  2. Cliquez sur Créer une connexion de service.
  3. Dans la liste, sélectionnez Docker Registry (Registre Docker), puis cliquez sur Next (Suivant).
  4. Dans la boîte de dialogue, saisissez les valeurs des champs suivants :
    • Registry type (Type de registre) : Others (Autres)
    • Docker Registry (Registre Docker) : https://gcr.io/PROD_PROJECT_ID, en remplaçant PROD_PROJECT_ID par le nom de votre projet de production (par exemple, https://gcr.io/azure-pipelines-test-project-12345).
    • 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
  5. 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 Container Registry.

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

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

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

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

  3. Copiez le code suivant dans le fichier :

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

    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.

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

  5. Dans le menu Azure DevOps, sélectionnez Pipelines, puis cliquez sur Create Pipeline (Créer un pipeline).

  6. Sélectionnez Azure Repos Git.

  7. Sélectionnez votre dépôt.

  8. Sur la page Examiner le pipeline YAML, cliquez sur Exécuter.

    Une nouvelle compilation est déclenchée. La compilation prend environ deux minutes.

  9. Pour vérifier que l'image a été publiée dans Container Registry, sélectionnez votre projet de production dans la console Google Cloud, cliquez sur Container Registry > Images, 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 Container 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 Container Registry roles/storage.admin (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 de Container Registry roles/storage.objectViewer (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

  1. Ouvrez Cloud Shell.

  2. Définissez les variables d'environnement suivantes :

    DEV_PROJECT_ID=DEV_PROJECT_ID
PROD_PROJECT_ID=PROD_PROJECT_ID

    Remplacez les éléments suivants :

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

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

  4. Accordez aux deux comptes d'agent de service Cloud Run l'accès à Container 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/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

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.

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

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

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

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

  1. Dans le menu Azure DevOps, sélectionnez Pipelines > Releases.
  2. Cliquez sur New pipeline (Nouveau pipeline).
  3. Dans la liste des modèles, sélectionnez Empty job (Job vide).
  4. Lorsque vous êtes invité à donner un nom à l'étape, saisissez Development.
  5. En haut de l'écran, nommez le pipeline CloudDemo.
  6. Dans le schéma du pipeline, à côté d'Artifacts (Artefacts), cliquez sur Add (Ajouter).
  7. Sélectionnez Build (Compiler), puis 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
  8. Cliquez sur Ajouter.
  9. 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.
  10. Sous Continuous deployment trigger (Déclencheur de déploiement continu) définissez le commutateur sur Enabled (Activé).
  11. Cliquez sur Enregistrer.

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

    Le pipeline affiché ressemble à ce qui suit :

    Vue du pipeline de configuration du déploiement automatisé.

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.

  1. Dans le menu, accédez à l'onglet Tâches.
  2. Cliquez sur Agent job (Job de l'agent).
  3. Définissez Agent spécification (Spécification de l'agent) sur ubuntu-18.04.
  4. À 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.
  5. Cliquez sur la tâche Command Line (Ligne de commande), puis sur Add (Ajouter).

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

    1. Display name (Nom à afficher) : 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)

      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.

  7. 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. Yes
    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 Cloud Run.
    CloudRun.ProjectId.Development ID du projet de développement.
    CloudRun.ProjectId.Production ID du projet de production.

  8. Cliquez sur Save.

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

  1. Dans le menu, accédez à l'onglet Pipeline.
  2. Dans la zone "Stages" (Étapes), sélectionnez Add (Ajouter) > New stage (Nouvelle étape).
  3. Dans la liste des modèles, sélectionnez Empty job (Job vide).
  4. Lorsque vous êtes invité à donner un nom à l'étape, saisissez Production.
  5. Cliquez sur l'icône en forme d'éclair de l'environnement récemment créé.

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

    Vue du pipeline de configuration du déploiement sur le cluster.

  7. Accédez à l'onglet Tasks (Tâches).

  8. Maintenez la souris sur l'onglet Tasks (Tâches) et sélectionnez Tasks (Tâches) > Prod.

  9. Cliquez sur Agent job (Job de l'agent).

  10. Définissez Agent spécification (Spécification de l'agent) sur ubuntu-18.04.

  11. Cliquez sur Add a task to agent job (Ajouter une tâche au job de l'agent)  pour ajouter une étape à la phase.

  12. Sélectionnez la tâche Command line (Ligne de commande), puis cliquez sur Add (Ajouter).

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

    1. Display name (Nom à afficher) : 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. Cliquez sur Enregistrer.

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

  1. 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.
  2. À la ligne 26, remplacez la valeur de ViewBag.Title (Home Page) par Home Page Cloud Run.

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

  4. Dans le menu Azure DevOps, sélectionnez Pipelines. Une compilation est déclenchée.

  5. Une fois la compilation terminée, sélectionnez Pipelines > Releases (Versions). Un processus de déploiement est lancé.

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

  7. Dans la console Google Cloud, basculez vers le projet de développement.

  8. Dans le menu, sélectionnez Compute > Cloud Run.

    Le service clouddemo est déployé.

    État du déploiement dans Cloud Run.

  9. Cliquez sur clouddemo pour afficher plus de détails.

    Une URL s'affiche, indiquant que Cloud Run a provisionné le service.

  10. 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é.

  11. Dans Azure Pipelines, cliquez sur Approve (Approuver) (à côté de l'étape Production) pour déclencher le déploiement dans l'environnement de production.

  12. (Facultatif) Saisissez un commentaire.

  13. Confirmez l'opération en cliquant sur Approve (Approuver) et attendez que l'état de l'environnement Production bascule vers Succeeded (Réussite).

  14. Dans la console Google Cloud, basculez vers le projet de production.

  15. Dans le menu, sélectionnez Compute > Cloud Run.

    Le service clouddemo est déployé sur le projet de production.

  16. Cliquez sur clouddemo pour afficher plus de détails.

    Une URL s'affiche, indiquant que Cloud Run a provisionné le service.

  17. 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é.

Effectuer un nettoyage

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

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Étapes suivantes