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

Dans ce tutoriel, vous allez apprendre à créer un pipeline d'intégration continue/déploiement continu (continuous integration/continuous deployment ou CI/CD) à l'aide d'Azure Pipelines (anciennement dénommé Visual Studio Team Services) et de Compute Engine. Nous utilisons Orchard CMS, un système de gestion de contenu Open Source, comme exemple d'application. Orchard CMS est basé sur ASP.NET MVC et s'exécute sur Windows Server 2016.

Le pipeline CI/CD utilise deux environnements distincts, un pour les tests et un pour la production. Lorsqu'un développeur effectue un commit dans le dépôt Git, le code source est généré et une image de VM basée sur Windows Server 2016 est créée à l'aide de Packer. La nouvelle image est ensuite automatiquement publiée dans l'environnement de développement selon une mise à jour progressive. Après les tests, un gestionnaire de versions peut promouvoir le déploiement afin qu'il intervienne dans l'environnement de production.

Schéma conceptuel du pipeline CI/CD montrant comment les développeurs et les utilisateurs finaux interagissent avec l'application

Dans ce tutoriel, nous partons du principe que vous possédez des connaissances de base sur le framework .NET, Windows Server, Microsoft Internet Information Services (IIS), Azure Pipelines et Compute Engine. Le tutoriel nécessite également un accès administrateur à un compte Azure DevOps et une installation de Visual Studio 2017 déjà connectée à votre compte Azure DevOps.

Objectifs

  • Exécuter un agent Azure Pipelines privé sur Compute Engine et le connecter à Azure Pipelines.
  • Utiliser Packer avec Compute Engine pour créer des images Windows.
  • 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

Ce tutoriel utilise des composants facturables de Google Cloud Platform, dont :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Consultez la page de tarification Azure DevOps pour connaître les frais éventuels liés à l'utilisation d'Azure DevOps.

Avant de commencer

Le déploiement d'une application sur Google Cloud Platform (GCP) nécessite un projet GCP. 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.

Toutefois, par souci de simplicité, ce tutoriel utilise un seul projet pour les environnements CI, de développement et de production.

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Sélectionnez ou créez un projet Google Cloud Platform.

    Accéder à la page "Gérer les ressources"

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

  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.
  5. Assurez-vous que Visual Studio 2017 est installé et qu'il est connecté à votre compte Azure DevOps.

Créer un projet Azure DevOps

En utilisant Orchard CMS comme exemple, Azure Pipelines vous permettra de gérer le code source, d'exécuter des compilations et des tests, et d'orchestrer le déploiement sur Compute Engine.

Pour commencer, créez 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 Create Project (Créer un projet).
  3. Indiquez un nom de projet, tel que Orchard.
  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ôts).
  6. Cliquez sur Import (Importer) pour diviser le dépôt Orchard CMS à partir de GitHub. Définissez les valeurs suivantes :

    • Source type (Type de source) : Git
    • Clone URL (URL du clone) : https://github.com/OrchardCMS/Orchard.git
    • Ne cochez pas la case Requires authorization (Demander une autorisation).

    Capture d'écran de la boîte de dialogue "Importer un dépôt Git"

  7. Cliquez sur Import (Importer). Lorsque le processus d'importation est terminé, le code source d'Orchard CMS s'affiche.

Intégration continue

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 publie l'artefact de compilation résultant dans l'espace de stockage Azure Pipelines interne.

Créer une branche de test

Pour vous assurer que les instructions de ce tutoriel fonctionnent, vous devez créer une branche basée sur une version spécifique du code source. Cette opération permettra de vous assurer que les futures modifications du code sur GitHub n'interrompront pas ce tutoriel.

  1. Dans le menu Azure DevOps, sélectionnez Repos (Dépôt) > Tags.
  2. Dans la liste des tags, cliquez avec le bouton droit de la souris sur l'icône située à côté de 1.10.2.
  3. Sélectionnez New branch (Nouvelle branche).
  4. Dans la zone Name (Nom), saisissez testing comme nom de branche, puis confirmez en cliquant sur Create Branch (Créer la branche).

    Capture d'écran de la boîte de dialogue "Créer une branche" dans Azure Pipelines

Par défaut, Azure Pipelines cherche votre code dans la branche master. Pour qu'il utilise le code dans la branche testing, il faut modifier la branche par défaut.

  1. Dans le menu Azure DevOps, sélectionnez Project settings (Paramètres du projet).
  2. Sélectionnez Code > Repositories (Dépôts).
  3. Dans la liste des dépôts, sélectionnez le dépôt Git précédemment importé. Il doit porter le même nom que votre projet Azure DevOps.
  4. Développez la liste des branches en cliquant sur la flèche à côté de Branches.
  5. Sélectionnez la branche testing. Cela déclenche l'apparition d'un bouton ... juste à côté du nom de la branche.
  6. Cliquez sur ... et sélectionnez Set as default branch (Définir comme branche par défaut).

Créer une définition de la compilation

Après avoir créé la branche, vous pouvez définir la compilation. Comme Orchard CMS est une application ASP.NET écrite dans Visual Studio, la définition de la compilation comprend les étapes suivantes :

  • Restaurer les dépendances de package NuGet
  • Compiler la solution (src\Orchard.sln) sur un agent de compilation Hosted VS2017.
  • Publier les artefacts de compilation du projet Orchard.Web.

Pour automatiser ces étapes, procédez comme suit :

  1. Dans le menu Azure DevOps, sélectionnez Pipelines > Builds (Compilations), puis cliquez sur New pipeline (Nouveau pipeline).
  2. Sélectionnez Azure Repos (Dépôts Azure) comme emplacement du code.
  3. Sélectionnez le dépôt Git précédemment importé. Il doit porter le même nom que votre projet Azure DevOps.
  4. Sélectionnez Starter pipeline (Pipeline de démarrage).
  5. Supprimez l'exemple de code généré pour azure-pipelines.yml et copiez le code suivant dans l'éditeur :

    resources:
    - repo: self
      fetchDepth: 1
    variables:
      artifactName: 'Orchard.Web'
    phases:
    - phase: Phase_1
      displayName: Build application
      condition: succeeded()
      queue:
        name: Hosted VS2017
        demands:
        - msbuild
        - visualstudio
      variables:
        solution: 'src\Orchard.sln'
        buildPlatform: 'Any CPU'
        buildConfiguration: 'Release'
      steps:
      - task: NuGetToolInstaller@0
        displayName: 'Use NuGet 4.4.1'
        inputs:
          versionSpec: 4.4.1
      - 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: PublishSymbols@2
        displayName: 'Publish symbols path'
        continueOnError: true
        inputs:
          SearchPattern: '**\bin\**\*.pdb'
          PublishSymbols: false
      - task: PublishBuildArtifacts@1
        displayName: 'Publish Artifact'
        inputs:
          PathtoPublish: '$(build.artifactstagingdirectory)/Orchard.Web.zip'
          ArtifactName: '$(artifactName)'
    
  6. Cliquez sur Save and run (Enregistrer et exécuter).

  7. Saisissez un message de validation personnalisé, puis confirmez en cliquant sur Save and run (Enregistrer et exécuter).

    azure-pipelines.yml est ainsi validé dans la branche testing de votre dépôt, ce qui déclenche une compilation. Toute modification supplémentaire de la définition de la compilation devra être effectuée en modifiant le fichier dans le dépôt Git.

La compilation peut prendre jusqu'à sept minutes. À la fin de la compilation, le fichier Orchard.Web.zip, qui contient tous les fichiers de l'application Web, sera disponible dans la zone de stockage d'artefacts Azure Pipelines interne.

Comme le code source est compilé de manière continue, il faut ensuite créer automatiquement des images de VM. Cette automatisation comprend les étapes suivantes :

  • Lancer une nouvelle instance de VM temporaire qui utilise l'image Windows Server 2016
  • Installer et configurer IIS
  • Déployer Orchard CMS
  • Arrêter la VM
  • Créer une image
  • Supprimer la VM temporaire

Automatisez ce processus à l'aide de Packer. Ce service a besoin d'accéder à l'instance de VM, mais vous ne voulez pas exposer l'instance à l'Internet public. Par conséquent, vous allez exécuter Packer sur un agent Azure Pipelines privé au sein du réseau GCP.

Déployer un agent Azure Pipelines privé

L'exécution de Packer sur un agent privé dans GCP évite d'exposer des ressources à l'Internet public et donc de créer un environnement moins sécurisé. Toutefois, cela contribue également à une surcharge de tâches administratives. Pour minimiser cette surcharge, déployez l'agent dans un groupe d'instances géré. Cette approche présente les avantages suivants :

  • Un groupe d'instances géré vous permet de recréer la VM, d'installer tous les composants requis et de vous enregistrer automatiquement auprès d'Azure Pipelines.
  • Vous pouvez appliquer les mises à jour Windows en supprimant la VM et en laissant le groupe d'instances géré recréer l'environnement sur la base de la dernière image Windows entièrement corrigée.

Procédez comme suit :

  1. Dans la console GCP, passez au 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_NAME]
    gcloud config set compute/zone [ZONE]

    Remplacez [PROJECT_NAME] par le nom de votre projet GCP et [ZONE] par le nom de la zone dans laquelle vous allez créer des ressources. Si vous ne savez pas quelle zone choisir, utilisez us-central1-a.

    Exemple :

    gcloud config set project devops-test-project-12345
    gcloud config set compute/zone us-central1-a
  4. Activez l'API Compute Engine :

    gcloud services enable compute.googleapis.com
  5. Dans le menu Azure DevOps, sélectionnez Project settings (Paramètres du projet), puis Pipelines > Agent pools (Pools d'agents).

  6. Cliquez sur New agent pool (Nouveau pool d'agents).

  7. Renseignez Google Cloud comme nom de pool et cliquez sur OK. Ce pool constituera la file d'attente de l'agent de compilation privé qui s'exécute sur Compute Engine.

  8. Dans le volet de gauche, sélectionnez le pool Google Cloud que vous venez de créer, puis cliquez sur Download agent (Agent de téléchargement).

  9. Sous Download the agent (Télécharger l'agent), cliquez sur Copy (Copier) pour copier l'URL de téléchargement.

  10. Dans Cloud Shell, initialisez une variable d'environnement. Pour la valeur de l'URL, collez celle que vous avez copiée à l'étape précédente.

    export AZURE_DEVOPS_AGENT_URL=[PASTE URL FROM CLIPBOARD]
  11. Revenez dans Azure Pipelines, cliquez sur l'avatar de l'utilisateur dans le coin supérieur droit de l'écran, puis cliquez sur Security (Sécurité).

  12. Sous Security (Sécurité) > Personal access tokens (Jetons d'accès personnels), cliquez sur New Token (Nouveau jeton).

  13. Configurez les paramètres suivants :

    • Name (Nom) : Google Cloud Agent
    • Scopes (Champs d'application) : accès complet
  14. Cliquez sur Créer (Create).

  15. Copiez le jeton dans le presse-papiers.

  16. Dans Cloud Shell, initialisez une autre variable d'environnement en exécutant la commande ci-dessous. Pour l'URL, collez celle que vous venez de copier.

    export AZURE_DEVOPS_TOKEN=[PASTE TOKEN FROM CLIPBOARD]
  17. Initialisez une autre variable d'environnement pour qu'elle contienne l'URL Azure Pipelines. Remplacez [ACCOUNT] par le nom de votre compte, comme indiqué dans la barre d'adresse d'Azure Pipelines.

    export AZURE_DEVOPS_URL=https://[ACCOUNT].visualstudio.com
  18. Exécutez la commande ci-dessous pour créer un script de spécialisation. Le script télécharge et installe le package d'agent Azure Pipelines, Packer et Cloud SDK, puis enregistre l'agent auprès d'Azure Pipelines.

    cat | envsubst '$AZURE_DEVOPS_AGENT_URL $AZURE_DEVOPS_TOKEN $AZURE_DEVOPS_URL' > specialize.ps1 << 'EOF'
    # Create an installation directory for the Azure Pipelines agent
    New-Item -ItemType directory -Path $env:programfiles\vsts-agent
    
    # Create a work directory for the Azure Pipelines agent
    New-Item -ItemType directory -Path $env:programdata\vsts-agent
    
    # Download and install the Azure Pipelines agent package
    Invoke-WebRequest `
      -Uri "$AZURE_DEVOPS_AGENT_URL" `
      -OutFile $env:TEMP\vsts-agent.zip
    Add-Type -AssemblyName System.IO.Compression.FileSystem
    [System.IO.Compression.ZipFile]::ExtractToDirectory( `
      "$env:TEMP\vsts-agent.zip", `
      "$env:programfiles\vsts-agent")
    
    # Download and install Packer
    [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
    Invoke-WebRequest `
      -Uri "https://releases.hashicorp.com/packer/1.2.2/packer_1.2.2_windows_amd64.zip" `
      -OutFile $env:TEMP\packer.zip
    [System.IO.Compression.ZipFile]::ExtractToDirectory( `
      "$env:TEMP\packer.zip", `
      "$env:programfiles\packer")
    
    # Download and install the Cloud SDK
    Invoke-WebRequest `
      -Uri https://dl.google.com/dl/cloudsdk/channels/rapid/GoogleCloudSDKInstaller.exe `
      -OutFile $env:TEMP\cloudsdk.exe
    Start-Process -Wait $env:TEMP\cloudsdk.exe -arg "/S /noreporting /nostartmenu /nodesktop"
    
    # Add Packer and the Cloud SDK installation directory to global path
    [Environment]::SetEnvironmentVariable( `
      "Path", $env:Path + ";$env:programfiles\packer;${env:ProgramFiles(x86)}\Google\Cloud SDK\google-cloud-sdk\bin", `
      [System.EnvironmentVariableTarget]::Machine)
    
    # Install gcloud beta commands
    $env:CLOUDSDK_PYTHON=gcloud components copy-bundled-python
    Start-Process -Wait gcloud -arg "components install beta --quiet"
    
    # Configure the Azure Pipelines agent
    & $env:programfiles\vsts-agent\bin\Agent.Listener configure `
      --url $AZURE_DEVOPS_URL `
      --agent "GCE Agent" `
      --work $env:programdata\vsts-agent `
      --pool "Google Cloud" `
      --replace `
      --runAsService `
      --windowsLogonAccount "NT AUTHORITY\NETWORK SERVICE" `
      --auth PAT `
      --token $AZURE_DEVOPS_TOKEN
    EOF
    
  19. Créez un modèle d'instance pour l'agent Azure Pipelines. Configurez le modèle de sorte que l'instance de VM exécute specialize.ps1 en tant que script de spécialisation au démarrage.

    gcloud compute instance-templates create vsts-agent \
        --machine-type n1-standard-1 \
        --image-family windows-2016-core \
        --image-project windows-cloud \
        --metadata-from-file sysprep-specialize-script-ps1=specialize.ps1 \
        --scopes "https://www.googleapis.com/auth/compute,https://www.googleapis.com/auth/devstorage.read_write"
    
  20. Créez un groupe d'instances géré basé sur ce modèle. Le démarrage de la nouvelle instance de VM et l'enregistrement de l'agent Azure Pipelines peuvent prendre environ trois minutes.

    gcloud compute instance-groups managed create vsts-agent \
        --template=vsts-agent \
        --size=1
    
  21. Dans Azure DevOps, revenez à votre projet.

  22. Dans le menu, sélectionnez Project settings (Paramètres du projet), puis Pipelines > Agent pools (Pools d'agents).

  23. Sélectionnez le pool Google Cloud, puis vérifiez que l'agent est enregistré et que son état est défini sur Online (En ligne).

    Capture d'écran de la boîte de dialogue "Files d'attente de l'agent" dans Azure Pipelines

Dépannage

Si l'agent ne s'enregistre pas dans les 10 minutes, il peut y avoir un problème. Essayez ce qui suit :

  1. Dans la console GCP, accédez à Compute Engine > Instances de VM.
  2. Affichez les détails de la VM ayant le préfixe vsts-agent.
  3. Cliquez sur Port de série 1 (console).

Le journal de la console contient la sortie du script de spécialisation, ce qui peut vous aider à résoudre les problèmes. Même après que l'agent est visible dans Azure Pipelines, il peut apparaître initialement Offline (Hors connexion). Auquel cas, attendez encore deux minutes pour que son état passe à Online (En ligne).

Tester la configuration

Si vous le souhaitez, testez la résilience de cette configuration de la manière suivante :

  1. Accédez à Compute Engine > Instances de VM.
  2. Supprimez la VM portant le préfixe vsts-agent.

Le groupe d'instances géré créera immédiatement une instance. Quelques minutes plus tard, un nouvel agent sera à nouveau opérationnel.

Créer des images de VM

Pour automatiser le processus de création d'images de VM, vous devez créer un modèle Packer. Ce modèle consiste en un fichier JSON que vous devez conserver avec le code source du projet.

Créer un modèle Packer

Avant de créer le modèle, vous devez extraire le code source.

  1. Dans Visual Studio, ouvrez Team Explorer.
  2. Dans le menu, cliquez sur l'icône Gérer les connexions.
  3. Cliquez sur Manage Connections (Gérer les connexions) > Connect to a Project (Se connecter à un projet).

    Capture d'écran de l'option "Se connecter à un projet" dans le volet Team Explorer de Visual Studio

  4. Dans la boîte de dialogue ci-dessous, sélectionnez le dépôt Git Orchard, puis cliquez sur Clone (Cloner).

    Capture d'écran du dépôt Git "Orchard" sélectionné dans la boîte de dialogue "Se connecter à un projet" dans Visual Studio

  5. Une fois le code extrait, ouvrez l'explorateur de solutions dans Visual Studio.

  6. À la racine de la solution, créez un fichier nommé packer.json.

  7. Copiez le code suivant dans le fichier récemment créé, puis enregistrez le fichier :

    {
      "variables": {
        "gcp_project": "",
        "gcp_zone": "",
        "windows_user": "packer_user",
        "windows_password": "Packer123",
        "image_name": "vsts",
        "image_family": "vsts",
        "app_package": ""
      },
      "builders": [
        {
          "type": "googlecompute",
          "project_id": "&lbrace;&lbrace;user `gcp_project`&rbrace;&rbrace;",
          "source_image_family": "windows-2016",
          "disk_size": "50",
          "instance_name": "&lbrace;&lbrace;user `image_name`&rbrace;&rbrace;",
          "image_name": "&lbrace;&lbrace;user `image_name`&rbrace;&rbrace;",
          "image_family": "&lbrace;&lbrace;user `image_family`&rbrace;&rbrace;",
          "machine_type": "n1-standard-2",
          "communicator": "winrm",
          "winrm_username": "&lbrace;&lbrace;user `windows_user`&rbrace;&rbrace;",
          "winrm_password": "&lbrace;&lbrace;user `windows_password`&rbrace;&rbrace;",
          "winrm_insecure": true,
          "winrm_use_ssl": true,
          "winrm_port": 5986,
          "metadata": {
            "windows-startup-script-cmd": "winrm quickconfig -quiet & net user /add &lbrace;&lbrace;user `windows_user`&rbrace;&rbrace; &lbrace;&lbrace;user `windows_password`&rbrace;&rbrace; & net localgroup administrators &lbrace;&lbrace;user `windows_user`&rbrace;&rbrace; /add & winrm set winrm/config/service/auth @{Basic=\"true\"}"
          },
          "zone": "&lbrace;&lbrace;user `gcp_zone`&rbrace;&rbrace;",
          "use_internal_ip": true,
          "state_timeout": "8m",
          "scopes": [ "https://www.googleapis.com/auth/devstorage.read_only" ]
        }
      ],
      "provisioners": [
        {
          "type": "powershell",
          "inline": [
            "$ErrorActionPreference = \"Stop\"",
    
            "# Download application package from Cloud Storage",
            "gsutil cp &lbrace;&lbrace;user `app_package`&rbrace;&rbrace; $env:TEMP\\app.zip",
    
            "# Install IIS",
            "Enable-WindowsOptionalFeature -Online -FeatureName NetFx4Extended-ASPNET45",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-WebServerRole",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-WebServer",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-CommonHttpFeatures",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-HttpErrors",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-HttpRedirect",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-ApplicationDevelopment",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-HealthAndDiagnostics",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-HttpLogging",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-LoggingLibraries",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-RequestMonitor",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-HttpTracing",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-Security",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-RequestFiltering",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-Performance",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-WebServerManagementTools",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-IIS6ManagementCompatibility",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-Metabase",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-DefaultDocument",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-ApplicationInit",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-NetFxExtensibility45",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-ISAPIExtensions",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-ISAPIFilter",
            "Enable-WindowsOptionalFeature -Online -FeatureName IIS-ASPNET45",
            "Enable-WindowsOptionalFeature -Online -FeatureName 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 orchard-net4", "Set-ItemProperty IIS:\\AppPools\\orchard-net4 managedRuntimeVersion v4.0", "New-WebApplication -Name Orchard -Site 'Default Web Site' -PhysicalPath c:\\inetpub\\wwwroot\\app -ApplicationPool orchard-net4", "# Grant read/execute access to the application pool user", "&icacls C:\\inetpub\\wwwroot\\app\\ /grant \"IIS AppPool\\orchard-net4:(OI)(CI)(RX)\"", "# Create data folder and grant write access to the application pool user", "New-Item -ItemType directory -Path C:\\inetpub\\wwwroot\\app\\App_Data\\", "&icacls C:\\inetpub\\wwwroot\\app\\App_Data\\ /grant \"IIS AppPool\\orchard-net4:(OI)(CI)M\"", "# Disable searching for Windows updates", "New-ItemProperty -Path HKLM:\\SOFTWARE\\Policies\\Microsoft\\Windows\\WindowsUpdate\\AU -Name NoAutoUpdate -Value 1 -PropertyType DWORD -Force", "# Disable provisioning user", "disable-localuser &lbrace;&lbrace;user `windows_user`&rbrace;&rbrace;", "# Generalize the image", "& \"$Env:Programfiles\\Google\\Compute Engine\\sysprep\\gcesysprep\"" ] } ] }

Le modèle Packer comprend trois sections :

  • La section variables définit les variables utilisées dans le modèle. Les valeurs de ces variables seront transmises à Packer en tant qu'arguments de ligne de commande.
  • La section builders contient les paramètres de création de l'instance de VM temporaire et de communication avec elle.
  • La section provisioners contient une séquence de commandes exécutées sur la VM permettant de la configurer après sa création.

Le modèle précédent utilise Google Compute Builder de Packer pour créer une instance de VM qui exécute Windows Server 2016. Lorsque vous spécifiez l'image source à utiliser pour Packer, il est important d'utiliser une image contenant déjà les derniers correctifs de sécurité. Pour vous éviter de devoir modifier le paramètre source_image chaque fois que Google publie une nouvelle version de l'image Windows Server 2016, la configuration obtient l'image la plus récente de la famille d'images windows-2016-core.

À l'aide d'un script de démarrage, le modèle active le service de gestion à distance de Windows (WinRM) et crée un utilisateur temporaire. Une fois la VM opérationnelle, Packer utilise WinRM et cet utilisateur pour exécuter les commandes PowerShell spécifiées à la section provisioners. Avec le paramètre use_internal_ip, vous vous assurez que WinRM communique sur le réseau local plutôt que sur Internet, ce qui est possible parce que l'étape de compilation correspondante est exécutée sur l'agent de compilation privé que vous avez configuré précédemment. Enfin, la section builders définit également un champ d'application IAM pour la VM, ce qui permet d'accéder à Cloud Storage.

Les commandes PowerShell figurant à la section provisioners configurent la VM de sorte qu'elle exécute Orchard CMS. Cette configuration implique les opérations suivantes :

  • Télécharger le package d'application à partir de Cloud Storage
  • Installer IIS
  • Créer un pool d'applications IIS ainsi qu'une application pour Orchard CMS
  • Extraire le package d'application dans le dossier racine web de IIS et configurer des listes de contrôle d'accès (LCA) pour le dossier
  • Désactiver la recherche de mises à jour Windows, qui est inutile si vous appliquez des mises à jour en exécutant à nouveau le pipeline CI/CD de manière régulière
  • Désactiver la gestion des comptes utilisateur
  • Généraliser l'image à l'aide de GCESysprep pour vous assurer que chaque VM créée à partir de l'image se voit attribuer un identifiant de sécurité unique.

Pour effectuer le commit du fichier dans Git, procédez comme suit :

  1. Dans Visual Studio, ouvrez Team Explorer.
  2. Cliquez sur l'icône Accueil en haut à gauche pour passer à la vue Accueil.
  3. Cliquez sur Changes (Modifications).
  4. Sous Changes (Modifications), cliquez avec le bouton droit de la souris sur packer.json, puis cliquez sur Stage (Préproduire).
  5. Saisissez un message de validation tel que Add Packer template.
  6. Cliquez sur Commit Staged (Valider la préproduction).

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

À l'aide de File Provisioner dans Packer, vous pouvez copier des fichiers à partir de la machine exécutant Packer vers la VM. Si vous utilisez WinRM, cette opération peut être lente. C'est pourquoi le modèle que vous avez créé à la section précédente recherche le package d'application Orchard CMS dans Cloud Storage, qui offre des performances nettement supérieures.

Pour créer un bucket dans Cloud Storage à cet effet, exécutez la commande suivante :

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.

Étendre la définition de la compilation

Vous venez d'extraire le modèle Packer enregistré dans Git et de créer le bucket Cloud Storage. Vous pouvez désormais intégrer Packer à votre processus de compilation Azure Pipelines.

Jusqu'à présent, la définition de la compilation Azure Pipelines que vous avez créée utilise une seule phase. Dans Azure Pipelines, toutes les tâches issues de la même phase s'exécutent sur le même agent de compilation. Dans votre cas, cet agent est Hosted VS2017. Pour commencer à utiliser l'agent de compilation privé provisionné dans Compute Engine, vous devez ajouter une deuxième phase à la définition de compilation.

En une seule phase, les tâches partagent un répertoire de travail et ont accès aux artefacts des tâches précédentes. Cet accès n'est pas possible entre les phases. En effet, pour utiliser les artefacts des étapes précédentes, vous devez les publier sur Azure Pipelines lors de la première phase, puis les télécharger lors de la phase suivante. Par conséquent, étendez la définition de la compilation comme suit :

  1. Dans Visual Studio, ouvrez azure-pipelines.yml.
  2. Étendez la définition de compilation en ajoutant le code ci-dessous au fichier. Remplacez [PROJECT_NAME] par le nom de votre projet GCP et [ZONE] par le nom de la zone dans laquelle vous allez créer des ressources. Si vous ne savez pas quelle zone choisir, utilisez us-central1-a.

    - phase: Phase_2
      displayName: Create VM image
      dependsOn: Phase_1
      condition: succeeded()
      queue:
        name: 'Google Cloud'
      variables:
        Packer.Project: '[PROJECT_NAME]'
        Packer.Zone: '[ZONE]'
      steps:
      - task: DownloadBuildArtifacts@0
        displayName: 'Download Build Artifacts'
        inputs:
          artifactName: '$(artifactName)'
      - task: CmdLine@1
        displayName: 'Publish artifact to Cloud Storage'
        inputs:
          filename: gsutil
          arguments: 'cp $(System.ArtifactsDirectory)\$(artifactName)\Orchard.Web.zip gs://$(Packer.Project)-artifacts/Orchard.Web-$(Build.BuildId).zip'
      - task: CmdLine@1
        displayName: 'Create image'
        inputs:
          filename: packer
          arguments: 'build -var "gcp_project=$(Packer.Project)" -var "gcp_zone=$(Packer.Zone)" -var "image_family=orchard" -var "image_name=orchard-$(Build.BuildId)" -var "app_package=gs://$(Packer.Project)-artifacts/Orchard.Web-$(Build.BuildId).zip" $(Build.SourcesDirectory)/packer.json'
    

Pour valider les modifications et les transférer à Azure DevOps, procédez comme suit :

  1. Dans Visual Studio, ouvrez Team Explorer.
  2. Cliquez sur l'icône Accueil en haut à gauche pour passer à la vue Accueil.
  3. Cliquez sur Changes (Modifications).
  4. Sous Changes (Modifications), cliquez avec le bouton droit de la souris sur azure-pipelines.yml, puis cliquez sur Stage (Préproduire).
  5. Saisissez un message de validation tel que Extend build definition to create VM image.
  6. Cliquez sur Commit Staged and Push (Valider la préproduction et envoyer).
  7. Dans le menu Azure DevOps, sélectionnez Pipelines > Build (Compiler). Vous devriez voir qu'une nouvelle compilation a été déclenchée automatiquement. La compilation peut prendre 10 à 15 minutes. Notez que, si la compilation échoue et affiche le message d'erreur Could not find a pool with name Google Cloud, il vous faudra peut-être réenregistrer votre pipeline.
  8. Dans GCP, accédez à Compute Engine > Images et vérifiez qu'une image nommée orchard-N a été créée, où N correspond à l'ID de compilation Azure Pipelines.

Maintenant qu'Azure Pipelines compile automatiquement votre code et crée une nouvelle image de VM pour chaque commit, vous pouvez vous concentrer sur le déploiement.

Configurer l'environnement de développement

Avec Orchard CMS, vous pouvez utiliser SQL Server ou une base de données intégrée qui stocke les données localement. Par souci de simplicité, utilisez la configuration par défaut qui repose sur la base de données intégrée, même si elle comporte deux restrictions :

  • Une seule instance de VM peut être exécutée à la fois. Sinon, les utilisateurs risqueraient de voir des données différentes suivant l'instance de VM qui diffuse le contenu.
  • Toutes les modifications de données sont perdues à chaque redémarrage de l'instance de VM, sauf si vous modifiez le déploiement de manière à ce qu'il utilise Cloud Filestore pour stocker les données (nous ne couvrons pas ce scénario dans ce tutoriel).

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 modèle d'instance qui utilise une image standard Windows Server 2016 Core (et non une image personnalisée). Vous n'utiliserez ce modèle que dans un premier temps, car chaque compilation produira un nouveau modèle.

    gcloud compute instance-templates create orchard-initial \
        --machine-type n1-standard-2 \
        --image-family windows-2016-core \
        --image-project windows-cloud
  2. Créez une vérification de l'état HTTP. Comme Orchard CMS 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 orchard-dev-http \
        --check-interval=10s --unhealthy-threshold=10 \
        --request-path=/
  3. 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 beta compute instance-groups managed create orchard-dev \
        --template=orchard-initial \
        --http-health-check=orchard-dev-http \
        --initial-delay=2m \
        --size=1 && \
    gcloud compute instance-groups set-named-ports orchard-dev --named-ports http:80
  4. 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 orchard-dev-backend \
        --http-health-checks orchard-dev-http \
        --port-name http --protocol HTTP --global && \
    gcloud compute backend-services add-backend orchard-dev-backend \
        --instance-group orchard-dev --global \
        --instance-group-zone=$(gcloud config get-value compute/zone)
  5. Créez une interface d'équilibreur de charge :

    gcloud compute url-maps create orchard-dev --default-service orchard-dev-backend && \
    gcloud compute target-http-proxies create orchard-dev-proxy --url-map=orchard-dev && \
    gcloud compute forwarding-rules create orchard-dev-fw-rule --global --target-http-proxy orchard-dev-proxy --ports=80
  6. 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 de l'état HTTP. Comme Orchard CMS 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 orchard-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 beta compute instance-groups managed create orchard-prod \
        --template=orchard-initial \
        --http-health-check=orchard-prod-http \
        --initial-delay=2m \
        --size=1 && \
    gcloud compute instance-groups set-named-ports orchard-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 orchard-prod-backend --http-health-checks orchard-prod-http --port-name http --protocol HTTP --global && \
    gcloud compute backend-services add-backend orchard-prod-backend --instance-group orchard-prod --global --instance-group-zone=$(gcloud config get-value compute/zone)
  4. Créez une interface d'équilibreur de charge :

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

Configurer le pipeline de publication

Contrairement à certains 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.

En règle générale, une version Azure Pipelines utilise un artefact tel qu'un fichier zip issu d'une compilation. Dans ce tutoriel, la compilation génère une image de VM dans GCP. Il n'y a donc aucun artefact de ce type à utiliser. Toutefois, en utilisant l'ID de la compilation, qui est transmis à la version en tant que variable d'environnement, vous pouvez localiser l'image de VM correspondante et l'utiliser pour le déploiement.

Créer une définition de version

La première étape consiste à créer une définition de version.

  1. Dans le menu Azure DevOps, sélectionnez Pipelines > Releases (Versions).
  2. Cliquez sur New pipeline (Nouveau pipeline).
  3. Dans la liste des modèles, sélectionnez Empty job (Job vide).
  4. Lorsqu'il vous est demandé de donner un nom à l'étape, saisissez Dev.
  5. En haut de l'écran, nommez la version Orchard-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) : Orchard
  8. Cliquez sur Add (Ajouter).

  9. Dans la zone Artifact (Artefact), cliquez sur l'icône représentant un éclair pour ajouter un déclencheur de déploiement.

  10. Sous Continuous deployment trigger (Déclenchement de déploiement continu), définissez le commutateur sur Enabled (Activé).

  11. Cliquez sur Save (Enregistrer).

  12. Saisissez un commentaire si vous le souhaitez, puis confirmez en cliquant sur Save (Enregistrer).

Le pipeline ressemble désormais à ceci :

Capture d'écran du pipeline dans Azure Pipelines

Déployer l'environnement de développement

Maintenant que vous avez créé la définition de version, vous pouvez ajouter les étapes permettant d'initier un déploiement progressif.

  1. Dans Azure Pipelines, accédez à l’onglet Tasks (Tâches).
  2. Cliquez sur Agent job (Job de l'agent).
  3. Définissez le pool d'agents sur Private (Privé) > Google Cloud.
  4. À côté d'Agent job (Job de l'agent), cliquez sur l'icône + pour ajouter une étape à la phase.
  5. Sélectionnez la tâche Command Line (Ligne de commande), puis cliquez sur Add (Ajouter) et configurez les paramètres suivants :

    • Version : 1.*
    • Dislay Name (Nom d'affichage) : Create instance template
    • Tool (Outil) : gcloud
    • Arguments : compute instance-templates create orchard-$(Build.BuildId)-$(Release.ReleaseId) --machine-type n1-standard-2 --image orchard-$(Build.BuildId) --image-project $(Packer.Project) --tags=gclb-backend

    Cette commande crée un modèle d'instance qui utilise l'image de VM que vous avez créée précédemment à l'aide de Packer. La commande applique le tag gclb-backend afin que l'équilibreur de charge puisse atteindre les instances créées à partir de ce modèle.

  6. Ajoutez une tâche Command Line (Ligne de commande) et configurez les paramètres suivants :

    • Version : 1.*
    • Dislay Name (Nom d'affichage) : Associate instance template
    • Tool (Outil) : gcloud
    • Arguments : beta compute instance-groups managed set-instance-template orchard-dev --template=orchard-$(Build.BuildId)-$(Release.ReleaseId) --zone $(Deployment.Dev.Zone)

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

  7. Ajoutez une tâche Command Line (Ligne de commande) et configurez les paramètres suivants :

    • Version : 1.*
    • Dislay Name (Nom d'affichage) : Start rolling update
    • Tool (Outil) : gcloud
    • Arguments : beta compute instance-groups managed rolling-action start-update orchard-dev --version template=orchard-$(Build.BuildId)-$(Release.ReleaseId) --type proactive --min-ready 2m --max-unavailable 0 --zone $(Deployment.Dev.Zone)

    Cette commande force le groupe d'instances existant à remplacer les VM existantes par de nouvelles VM de manière progressive.

  8. Cliquez sur l'onglet Variables, et ajoutez les variables suivantes :

    Nom Valeur
    Packer.Project Nom de votre projet GCP
    Deployment.Dev.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)
  9. Cliquez sur Save (Enregistrer).

  10. 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 le cluster de production GKE.

  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. Lorsqu'il vous est demandé de 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 :

    • Select trigger (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 ou groupe
  7. Maintenez enfoncé le bouton de la souris sur l'onglet Tasks (Tâches) et sélectionnez Tasks (Tâches) > Prod.

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

  9. Définissez la valeur Agent pool (Pool d'agents) sur Private > Google Cloud.

  10. À côté d'Agent job (Phase de l'agent), cliquez sur l'icône + pour ajouter une étape à la phase.

  11. Ajoutez une tâche Command Line (Ligne de commande) et configurez les paramètres suivants :

    • Version : 1.*
    • Dislay Name (Nom d'affichage) : Associate instance template
    • Tool (Outil) : gcloud
    • Arguments : beta compute instance-groups managed set-instance-template orchard-prod --template=orchard-$(Build.BuildId)-$(Release.ReleaseId) --zone $(Deployment.Prod.Zone)

    Cette commande met à jour le groupe d'instances existant de sorte qu'il utilise le modèle d'instance que vous avez créé lors du déploiement de l'environnement Dev. La réutilisation du même modèle d'instance garantit que vous déployez exactement la même image.

  12. Ajoutez une tâche Command Line (Ligne de commande) et configurez les paramètres suivants :

    • Version : 1.*
    • Dislay Name (Nom d'affichage) : Start rolling update
    • Tool (Outil) : gcloud
    • Arguments : beta compute instance-groups managed rolling-action start-update orchard-prod --version template=orchard-$(Build.BuildId)-$(Release.ReleaseId) --type proactive --min-ready 2m --max-unavailable 0 --zone $(Deployment.Prod.Zone)

    Cette commande force le groupe d'instances existant à remplacer les VM existantes par de nouvelles VM de manière progressive.

  13. Passez à l'onglet Variables.

  14. Ajoutez une variable :

    • Name (Nom) : Deployment.Prod.Zone
    • Value (Valeur) : 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)
  15. Cliquez sur Save (Enregistrer).

  16. 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, c'est le moment de le tester. Dans le modèle Packer que vous avez créé précédemment, vous avez utilisé windows-2016 en tant que famille d'images sources. Lorsque vous souhaitez exécuter un serveur Web, le recours à une distribution Windows Server complète peut augmenter la consommation des ressources, sans aucun avantage. À la place, vous allez modifier le modèle de sorte qu'il utilise Windows Server 2016 Core, puis appliquer cette modification afin d'exploiter l'intégralité du pipeline CI/CD.

  1. Dans Visual Studio, ouvrez le fichier packer.json.
  2. Modifiez la famille d'images sources :

    "source_image_family": "windows-2016-core",
  3. Ouvrez Team Explorer et passez à la vue Accueil.

  4. Cliquez sur Changes (Modifications).

  5. Sous Changes (Modifications), cliquez avec le bouton droit de la souris sur packer.json, puis cliquez sur Stage (Préproduire).

  6. Saisissez un message de validation tel que Use Windows Server Core.

  7. Cliquez sur Commit All and Push (Commit et envoi pour tous).

  8. Dans Azure Pipelines, sélectionnez Build and Release > Builds (Compilation et version > Versions) et notez qu'une compilation a été déclenchée automatiquement :

    Capture d'écran montrant la liste des compilations en cours, avec Music Store en construction

    L'opération peut prendre entre 10 et 15 minutes pour aboutir à l'état Succeeded (Réussite).

  9. Une fois la compilation terminée, sélectionnez Build and Release > Builds (Compilation et version > Compilations). Un processus de déploiement se lance :

    Capture d'écran montrant que le processus de publication a commencé

  10. Cliquez sur Release-1 (Version-1) pour ouvrir la page de détails, puis attendez que l'état de l'étape Dev bascule sur Succeeded (Réussite). Vous devrez peut-être actualiser l'état en cliquant sur le bouton Refresh (Actualiser) dans le menu ou en rechargeant la page du navigateur.

  11. Dans Cloud Shell, exécutez la commande suivante pour obtenir l'adresse IP de l'équilibreur de charge pour l'environnement de développement :

    gcloud compute forwarding-rules list | grep orchard-dev | awk '{print $2}'
  12. Dans le navigateur, accédez à l'installation d'Orchard à l'aide de l'URL obtenue à l'étape précédente :

    http://[DEV_IP]/orchard/

    Une erreur risque de s'afficher au début, car l'équilibreur de charge a besoin de quelques minutes pour devenir disponible. Lorsqu'il est prêt, vous constatez qu'Orchard CMS a bien été déployé :

    Capture d'écran montrant l'application Orchard CMS s'exécutant dans une page de navigateur

  13. Dans Azure Pipelines, sous l'étape Prod, cliquez sur Approve (Approuver) pour déclencher le déploiement dans l'environnement de production :

    Capture d'écran affichant la page de publication et un message "Une approbation de prédéploiement est en attente"Approuver ou refuser

  14. Attendez que l'état de l'étape Prod bascule sur Succeeded{/0 (Réussite). Vous devrez peut-être actualiser manuellement la page dans votre navigateur.

  15. Dans Cloud Shell, exécutez la commande suivante pour obtenir l'adresse IP de l'équilibreur de charge pour l'environnement de développement :

    gcloud compute forwarding-rules list | grep orchard-prod | awk '{print $2}'
  16. Dans le navigateur, accédez à l'installation d'Orchard à l'aide de l'URL obtenue à l'étape précédente :

    http://[PROD_IP]/orchard/

    Là encore, une erreur risque de s'afficher au début, car l'équilibreur de charge a besoin de quelques minutes pour devenir disponible. Quand il est prêt, CMS Orchard s'affiche à nouveau et s'exécute cette fois dans le cluster de production.

Effectuer un nettoyage

Une fois le tutoriel terminé, nettoyez les ressources que vous avez créées afin d'éviter qu'elles ne vous soient facturées à l'avenir.

Supprimer le projet Azure Pipelines

Supprimez le projet dans Azure DevOps. Notez que cela entraîne également la perte de toutes les modifications du code source.

Supprimer le projet GCP

  1. Dans la console GCP, accédez à la page "Projets".

    Accéder à la page Projets

  2. Dans la liste des projets, sélectionnez celui que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…