Créer un pipeline CI/CD avec Azure Pipelines et Compute Engine

Compiler en continu

Vous pouvez maintenant utiliser Azure Pipelines pour configurer un pipeline de compilation. Pour chaque commit envoyé dans le dépôt Git, Azure Pipelines construit le code, le crée dans un fichier ZIP, puis publie le package obtenu dans l'espace de stockage Azure Pipelines interne.

Par la suite, vous allez configurer un pipeline de publication qui utilise les packages à partir du stockage Azure Pipelines et les déploie sur Compute Engine.

Créer une définition de compilation

Créez une définition de compilation dans Azure Pipelines à l'aide de 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 ce qui suit dans le fichier :

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

4. Effectuez 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. Celle-ci va prendre environ 2 minutes. À la fin de la compilation, le package d'application CloudDemo.Mvc.zip, qui contient tous les fichiers de l'application Web, est disponible dans la zone de stockage d'artefacts Azure Pipelines interne.

Déployer en continu

Maintenant qu'Azure Pipelines compile automatiquement votre code pour chaque commit, vous pouvez 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 comprend trois étapes :

1. Dans un premier temps, le pipeline extrait le package de l'application de la zone de stockage d'artefacts Azure Pipelines et le publie dans un bucket Cloud Storage afin que Compute Engine puisse accéder au package.
2. Ensuite, le pipeline met à jour l'environnement de développement à l'aide d'une mise à jour progressive.
3. Lors de la dernière étape, après approbation, le pipeline met à jour l'environnement de production à l'aide d'une mise à jour progressive.

Créer un bucket Cloud Storage pour les artefacts de compilation

Créer un bucket Cloud Storage pour stocker les packages d'application Par la suite, vous allez configurer Compute Engine pour que les nouvelles instances de VM puissent extraire automatiquement les packages d'application de ce bucket.

1. Dans la console Google Cloud, basculez vers le projet que vous venez de créer.

2. Ouvrez Cloud Shell.

   Accéder à Cloud Shell

3. Pour gagner du temps, définissez les valeurs par défaut pour l'ID de projet et la zone Compute Engine :

   gcloud config set project PROJECT_ID
   gcloud config set compute/zone ZONE

   Remplacez PROJECT_ID par l'ID de votre projet Google Cloud, et remplacez ZONE par le nom de la zone que vous allez utiliser pour créer des ressources. En cas de doute, utilisez la zone us-central1-a.

   Exemple :

   gcloud config set project devops-test-project-12345
   gcloud config set compute/zone us-central1-a

4. Créez un bucket Cloud Storage pour les packages d'application :

   gsutil mb gs://$(gcloud config get-value core/project)-artifacts
   

   Si vous ne souhaitez pas conserver les artefacts de toutes les compilations, vous pouvez envisager de configurer une règle de cycle de vie des objets afin de supprimer les fichiers ayant dépassé un certain âge.

Configurer un compte de service pour Azure Pipelines

Créez un compte de service Google Cloud qu'Azure Pipelines peut utiliser pour accéder à votre projet Google Cloud.

1. Créez un compte de service pour Azure Pipelines :

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

2. Attribuez les rôles IAM Lecteur des objets de l'espace de stockage (roles/storage.objectViewer) et Créateur des objets de l'espace de stockage (roles/storage.objectCreator) au compte de service azure-pipelines afin qu'Azure Pipelines puisse importer des packages d'application dans Cloud Storage :

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

3. Attribuez le rôle Administrateur Compute (roles/compute.admin) au compte de service azure-pipelines afin qu'Azure Pipelines puisse gérer les instances de VM :

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

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

   gcloud iam service-accounts keys create azure-pipelines-key.json \
     --iam-account=$AZURE_PIPELINES_SERVICE_ACCOUNT
   
   cat azure-pipelines-key.json | base64 -w 0;echo
   
   rm azure-pipelines-key.json
   

   La clé de compte de service est nécessaire pour l'une des étapes suivantes.

Configurer l'environnement de développement

Avant de pouvoir configurer les étapes dans Azure Pipelines pour automatiser le déploiement, vous devez préparer l'environnement de développement. Cette préparation inclut la création d'un groupe d'instances géré qui se chargera de la gestion des instances de VM du serveur Web. Vous devrez également créer un équilibreur de charge HTTP.

1. Dans Cloud Shell, créez un compte de service pour le groupe d'instances géré :

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

2. Attribuez le rôle IAM Lecteur des objets de l'espace de stockage (roles/storage.objectViewer) au compte de service afin que les instances de VM puissent télécharger des packages d'application depuis Cloud Storage :

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

3. Accordez au compte de service azure-pipelines l'autorisation d'utiliser le compte de service clouddemo-dev :

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

4. Créez un modèle d'instance qui utilise une image standard Windows Server 2019 Core. Vous n'utiliserez ce modèle que dans un premier temps, car chaque compilation produira un nouveau modèle.

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

5. Créez une vérification d'état HTTP. Comme l'application ne dispose pas d'un point de terminaison dédié à la vérification de l'état, vous pouvez interroger le chemin d'accès /.

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

6. Créez un groupe d'instances géré basé sur le modèle d'instance initial. Par souci de simplicité, les commandes suivantes créent un groupe d'instances géré zonal. Toutefois, vous pouvez utiliser la même approche pour les groupes d'instances gérés régionaux, qui répartissent les instances de VM sur plusieurs zones.

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

7. Créez un service backend d'équilibreur de charge qui utilise la vérification de l'état HTTP et le groupe d'instances géré que vous avez créé précédemment :

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

8. Créez une interface d'équilibrage de charge :

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

9. Créez une règle de pare-feu permettant à l'équilibreur de charge Google d'envoyer des requêtes HTTP aux instances comportant le tag gclb-backend. Vous appliquerez ensuite ce tag aux instances de VM du service Web.

   gcloud compute firewall-rules create gclb-backend --source-ranges=130.211.0.0/22,35.191.0.0/16 --target-tags=gclb-backend --allow tcp:80
   

Configurer l'environnement de production

La configuration de l'environnement de production nécessite une séquence d'étapes semblables à celles requises pour configurer l'environnement de développement.

1. Dans Cloud Shell, créez une vérification d'état HTTP :

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

2. Créez un autre groupe d'instances géré, basé sur le modèle d'instance initial que vous avez créé précédemment :

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

3. Créez un service backend d'équilibreur de charge qui utilise la vérification de l'état HTTP et le groupe d'instances géré que vous avez créé précédemment :

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

4. Créez une interface d'équilibrage de charge :

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

Configurer le pipeline de publication

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 Publish.
5. En haut de l'écran, nommez la version clouddemo-ComputeEngine.
6. Dans le schéma du pipeline, à côté d'Artifacts (Artefacts), cliquez sur Add (Ajouter).

7. Sélectionnez Build (Compilation) et ajoutez les paramètres suivants :

   • Source : sélectionnez le dépôt Git contenant le fichier azure-pipelines.yml.
   • Default version (Version par défaut) : Latest
   • Source alias (Alias source) : CloudDemo.Web

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 ressemble désormais à ceci :

Publier sur Cloud Storage

Maintenant que vous avez créé la définition de mise en production, vous pouvez ajouter les étapes permettant de publier le package d'application dans Cloud Storage.

1. Dans Azure Pipelines, accédez à l’onglet Tasks (Tâches).
2. Cliquez sur Agent job (job de l'agent), puis configurez les paramètres suivants :
   • Pool d'agents : Azure Pipelines
   • Spécification de l'agent : ubuntu-latest
3. À côté de Agent job, cliquez sur Add a task to agent job (Ajouter une tâche au job de l'agent) add.
4. Sélectionnez la tâche bash, puis cliquez sur Add (Ajouter).

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

   • Display name (Nom à afficher) : Publish to Cloud Storage
   • Type : inline (intégré)

   • Script :

     cat << "EOF" > CloudDemo.Mvc.deploy.ps1
         $ErrorActionPreference = "Stop"
     
         # Download application package from Cloud Storage
         gsutil cp gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).zip $env:TEMP\app.zip
     
         # Install IIS
         Enable-WindowsOptionalFeature -Online -FeatureName `
             NetFx4Extended-ASPNET45, `
             IIS-WebServerRole, `
             IIS-WebServer, `
             IIS-CommonHttpFeatures, `
             IIS-HttpErrors, `
             IIS-HttpRedirect, `
             IIS-ApplicationDevelopment, `
             IIS-HealthAndDiagnostics, `
             IIS-HttpLogging, `
             IIS-LoggingLibraries, `
             IIS-RequestMonitor, `
             IIS-HttpTracing, `
             IIS-Security, `
             IIS-RequestFiltering, `
             IIS-Performance, `
             IIS-WebServerManagementTools, `
             IIS-IIS6ManagementCompatibility, `
             IIS-Metabase, `
             IIS-DefaultDocument, `
             IIS-ApplicationInit, `
             IIS-NetFxExtensibility45, `
             IIS-ISAPIExtensions, `
             IIS-ISAPIFilter, `
             IIS-ASPNET45, `
             IIS-HttpCompressionStatic
     
         # Extract application package to wwwroot
         New-Item -ItemType directory -Path $env:TEMP\app
         Add-Type -AssemblyName System.IO.Compression.FileSystem
         [System.IO.Compression.ZipFile]::ExtractToDirectory("$env:TEMP\app.zip", "$env:TEMP\app")
         Remove-Item $env:TEMP\app.zip
         Move-Item -Path $(dir -recurse $env:TEMP\app\**\PackageTmp | % { $_.FullName }) -Destination c:\inetpub\wwwroot\app -force
     
         # Configure IIS web application pool and application
         Import-Module WebAdministration
         New-WebAppPool clouddemo-net4
         Set-ItemProperty IIS:\AppPools\clouddemo-net4 managedRuntimeVersion v4.0
         New-WebApplication -Name clouddemo -Site 'Default Web Site' -PhysicalPath c:\inetpub\wwwroot\app -ApplicationPool clouddemo-net4
     
         # Grant read/execute access to the application pool user
         &icacls C:\inetpub\wwwroot\app\ /grant "IIS AppPool\clouddemo-net4:(OI)(CI)(RX)"
     EOF
     
     gcloud auth activate-service-account \
         --quiet \
         --key-file <(echo $(ServiceAccountKey) | base64 -d)
     
     gsutil cp $(System.ArtifactsDirectory)/CloudDemo.Web/CloudDemo.Web/CloudDemo.Mvc.zip gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).zip
     gsutil cp CloudDemo.Mvc.deploy.ps1 gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).deploy.ps1
     

   Ce script effectue les opérations suivantes :

   1. Génère un script de démarrage qui configure le serveur IIS.
   2. Configure Google Cloud CLI pour utiliser la clé de compte de service de la variable d'environnement pour s'authentifier auprès de Google Cloud.
   3. Importe le package d'application et le script de démarrage dans Cloud Storage.

6. 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
   CloudDemo.ProjectId	ID de votre projet Google Cloud.
   CloudDemo.Zone	Zone que vous avez spécifiée précédemment lors de l'exécution de gcloud config set compute/zone (par exemple : us-central1-a)

7. Cliquez sur Enregistrer.

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

Déployer l'environnement de développement

Vous pouvez maintenant ajouter les étapes pour lancer un déploiement progressif dans l'environnement de développement.

1. Dans Azure Pipelines, 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 Dev.
5. Cliquez sur l'icône en forme d'éclair de l'environnement récemment créé.

6. Configurez les paramètres suivants :

   • Sélectionner le déclencheur : After stage
   • Stages (Étapes) : Publish

7. Maintenez enfoncé le bouton de la souris sur l'onglet Tasks (Tâches) et cliquez sur Tasks > Dev.

8. Cliquez sur Job de l'agent, puis configurez les paramètres suivants :

   • Pool d'agents : Azure Pipelines
   • Spécification de l'agent : ubuntu-latest

9. À côté de Agent job, cliquez sur Add a task to agent job (Ajouter une tâche au job de l'agent) add.

10. Sélectionnez la tâche bash, puis cliquez sur Add (Ajouter).

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

    • Display name (Nom à afficher) : Rolling deploy
    • Type : inline (intégré)

    • Script :

      INSTANCE_TEMPLATE=clouddemo-$(Build.BuildId)-$(Release.ReleaseId)
      
      gcloud auth activate-service-account \
          --quiet \
          --key-file <(echo $(ServiceAccountKey) | base64 -d)
      
      gcloud compute instance-templates create $INSTANCE_TEMPLATE \
        --machine-type n1-standard-2 \
        --image-family windows-2019-core \
        --image-project windows-cloud \
        --service-account clouddemo-dev@$(CloudDemo.ProjectId).iam.gserviceaccount.com \
        --scopes https://www.googleapis.com/auth/devstorage.read_only \
        --tags gclb-backend \
        --metadata sysprep-specialize-script-url=gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).deploy.ps1 \
        --project $(CloudDemo.ProjectId) \
      
      gcloud compute instance-groups managed set-instance-template clouddemo-dev \
        --template $INSTANCE_TEMPLATE \
        --project $(CloudDemo.ProjectId) \
        --zone $(CloudDemo.Zone)
      
      gcloud compute instance-groups managed rolling-action start-update clouddemo-dev \
        --version template=$INSTANCE_TEMPLATE \
        --type proactive \
        --max-unavailable 0 \
        --project $(CloudDemo.ProjectId) \
        --zone $(CloudDemo.Zone)
      

    Ce script effectue les opérations suivantes :

    1. Configure Google Cloud CLI pour utiliser la clé de compte de service de la variable d'environnement pour s'authentifier auprès de Google Cloud.
    2. Crée un modèle d'instance qui utilise le script de démarrage généré par l'étape précédente.
    3. Met à jour le groupe d'instances existant de manière à utiliser le nouveau modèle d'instance. Notez que cette commande n'entraîne pas encore le remplacement ni la mise à jour des VM existantes. En revanche, elle garantit que toutes les futures VM de ce groupe d'instances seront créées à partir du nouveau modèle.
    4. Démarre une mise à jour progressive, ce qui entraîne le remplacement progressif des VM existantes par de nouvelles VM.

12. Cliquez sur Enregistrer.

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

Déployer l'environnement de production

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

1. Dans Azure Pipelines, 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 Prod.
5. Cliquez sur l'icône en forme d'éclair de l'environnement récemment créé.

6. Configurez les paramètres suivants :

   • Sélectionner le déclencheur : After stage
   • Stages (Étapes) : Dev
   • Pre-deployment approvals (Approbations de prédéploiement) : (activé)
   • Approvers (Approbateurs) : sélectionnez votre propre nom d'utilisateur.

7. Maintenez enfoncé le bouton de la souris sur l'onglet Tasks (Tâches), puis cliquez sur Tasks > Prod.

8. Cliquez sur Job de l'agent, puis configurez les paramètres suivants :

   • Pool d'agents : Azure Pipelines
   • Spécification de l'agent : ubuntu-latest

9. À 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) add pour ajouter une étape à la phase.

10. Sélectionnez la tâche bash, puis cliquez sur Add (Ajouter).

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

    • Display name (Nom à afficher) : Rolling deploy
    • Type : inline (intégré)

    • Script :

      INSTANCE_TEMPLATE=clouddemo-$(Build.BuildId)-$(Release.ReleaseId)
      
      gcloud auth activate-service-account \
          --quiet \
          --key-file <(echo $(ServiceAccountKey) | base64 -d)
      
      gcloud compute instance-templates create $INSTANCE_TEMPLATE \
        --machine-type n1-standard-2 \
        --image-family windows-2019-core \
        --image-project windows-cloud \
        --service-account clouddemo-prod@$(CloudDemo.ProjectId).iam.gserviceaccount.com \
        --scopes https://www.googleapis.com/auth/devstorage.read_only \
        --tags gclb-backend \
        --metadata sysprep-specialize-script-url=gs://$(CloudDemo.ProjectId)-artifacts/CloudDemo.Mvc-$(Build.BuildId)-$(Release.ReleaseId).deploy.ps1 \
        --project $(CloudDemo.ProjectId) \
      
      gcloud compute instance-groups managed set-instance-template clouddemo-prod \
        --template $INSTANCE_TEMPLATE \
        --project $(CloudDemo.ProjectId) \
        --zone $(CloudDemo.Zone)
      
      gcloud compute instance-groups managed rolling-action start-update clouddemo-prod \
        --version template=$INSTANCE_TEMPLATE \
        --type proactive \
        --max-unavailable 0 \
        --project $(CloudDemo.ProjectId) \
        --zone $(CloudDemo.Zone)
      

12. Cliquez sur Enregistrer.

13. 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\net4\CloudDemo.Mvc\Views\Home\Index.cshtml dans le dépôt Git que vous avez cloné précédemment.
2. Remplacez la valeur de ViewBag.Title (Home Page) par This app runs on GKE.

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. Un processus de déploiement est lancé.

6. Cliquez sur Release-1 (Version-1) pour ouvrir la page de détails et attendez que l'état de l'environnement Dev bascule sur Succeeded (Réussi).

7. Dans la console Google Cloud, sélectionnez Services réseau > Équilibrage de charge > clouddemo-dev.

   Notez l'adresse IP de l'interface.

8. Ouvrez une nouvelle fenêtre de navigateur et accédez à l'adresse suivante :

   http://IP_ADDRESS/clouddemo/
   

   où IP_ADDRESS est l'adresse IP de l'interface.

   Notez que l'application a été déployée et utilise le titre personnalisé.

   Une erreur risque de s'afficher au début, car l'équilibreur de charge a besoin de quelques minutes pour devenir disponible.

9. Dans Azure Pipelines, cliquez sur le bouton Approve (Approuver) situé sous l'étape Prod pour promouvoir le déploiement dans l'environnement de production.

   Si vous ne voyez pas ce bouton, vous devrez peut-être d'abord approuver ou rejeter une version précédente.

10. Saisissez un commentaire si vous le souhaitez, puis cliquez sur Approve (Approuver) pour confirmer.

11. Attendez que l'état de l'environnement Prod bascule sur Succeeded (Réussi).

12. Dans la console Google Cloud, sélectionnez Services réseau > Équilibrage de charge > clouddemo-prod.

    Notez l'adresse IP de l'interface.

13. Ouvrez une nouvelle fenêtre de navigateur et accédez à l'adresse suivante :

    http://IP_ADDRESS/clouddemo/
    

    où IP_ADDRESS est l'adresse IP de l'interface.

    Notez que l'application a été déployée et utilise le titre personnalisé.