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

Last reviewed 2023-03-09 UTC

Ce tutoriel explique comment utiliser Azure Pipelines et Compute Engine afin de créer un pipeline d'intégration continue/de déploiement continu (CI/CD) pour un Application Web ASP.NET MVC L'application utilise Microsoft Internet Information Services et s'exécute sur Windows Server.

Le pipeline CI/CD utilise deux environnements distincts, un pour les tests et un pour la production.

Au début du pipeline, les développeurs valident les modifications apportées à l'exemple de code. Cette action déclenche le pipeline pour créer l'application, l'empaqueter en tant que fichier ZIP, puis importer ce fichier dans Cloud Storage.

Le package est ensuite automatiquement publié dans l'environnement de développement selon une mise à jour progressive. Une fois la version testée, un gestionnaire de versions peut promouvoir la version afin qu'elle soit déployée dans l'environnement 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 Framework, Windows Server, IIS, Azure Pipelines et Compute Engine. Vous avez également besoin d'un accès administrateur à un compte Azure DevOps.

Objectifs

  • Utiliser des groupes d'instances gérés Compute Engine pour mettre en œuvre des déploiements progressifs.
  • Configurer un pipeline CI/CD dans Azure Pipelines pour orchestrer les processus de compilation, de création et de déploiement.

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

Il est généralement conseillé d'utiliser des projets distincts pour les charges de travail de développement et de production afin que les rôles et les autorisations de gestion de l'authentification et des accès (IAM) puissent être octroyés individuellement. Par souci de simplicité, ce tutoriel utilise un seul projet pour les environnements de développement et de production.

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  2. Enable the Compute Engine and Cloud Storage APIs.

    Enable the APIs

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

  4. Assurez-vous de posséder un compte Azure DevOps et d'en avoir l'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 Compute Engine. 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 (Créer).
  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.

  8. Dans le menu, cliquez sur Repos > Branchs (Dépôt > Branches).

  9. Déplacez la souris sur la branche main. Un bouton ... s'affiche à droite.

  10. Cliquez sur ... > Set as default branch (Définir comme branche par défaut).

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 :

Capture d'écran du pipeline dans Azure Pipelines

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

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

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