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

Ce tutoriel explique comment utiliser Azure Pipelines, Google Kubernetes Engine (GKE) et Container Registry pour créer un pipeline d'intégration continue/de déploiement continu (CI/CD). Il exploite l'application Web ASP.NET MusicStore, basée sur ASP.NET Core.

Le pipeline CI/CD utilise deux clusters GKE distincts, un pour le développement et un pour la production, comme le montre le schéma suivant.

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

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 une version et la déployer sur le cluster de développement. Un gestionnaire des versions peut ensuite promouvoir la version afin qu'elle soit déployée dans le cluster de production.

Ce tutoriel est destiné aux développeurs et aux ingénieurs DevOps. Nous partons du principe que vous possédez des connaissances de base sur .NET Core, Azure Pipelines et GKE. Vous avez également besoin d'un accès administrateur à un compte Azure DevOps.

Objectifs

  • Connecter Container Registry à Azure Pipelines pour la publication d'images Docker
  • Préparer un exemple d'application .NET Core pour le déploiement dans GKE
  • S'authentifier de manière sécurisée auprès de GKE sans devoir utiliser l'ancienne authentification
  • Utiliser la gestion des versions Azure Pipelines pour orchestrer les déploiements GKE

Coûts

Ce tutoriel utilise 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é ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la page Effectuer un nettoyage pour en savoir plus.

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 Cloud IAM (Cloud Identity and Access Management) puissent être octroyés individuellement. Par souci de simplicité, ce tutoriel utilise un seul projet pour les deux clusters GKE, un pour le développement et un pour la production.

  1. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder à la page de sélection du projet

  2. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  3. 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 GKE. 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 Music Store.
  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 dupliquer le dépôt MusicStore à partir de GitHub, puis définissez les valeurs suivantes :
    • Source type (Type de source) : Git
    • Clone URL (URL du clone) : https://github.com/aspnet/MusicStore.git
  7. Cliquez sur Importer.

    Une fois le processus d'importation terminé, le code source de l'application MusicStore s'affiche.

Compiler en continu

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

Définir la branche par défaut

Ce tutoriel a été créé et testé avec la version 2.1 de l'application MusicStore. Pour vous assurer d'utiliser la même version, définissez la branche release/2.1 comme branche par défaut dans la configuration d'Azure Pipelines :

  1. Dans le menu Azure DevOps, sélectionnez Project settings (Paramètres du projet).
  2. Sélectionnez Repos (Dépôts) > 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 avoir 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 release/2.1. Un bouton ... apparaît à côté du nom de la branche.
  6. Cliquez sur ... et sélectionnez Set as default branch (Définir comme branche par défaut).

Compiler le code

Après avoir créé la branche, vous pouvez commencer à automatiser la compilation. Comme MusicStore est une application ASP.NET Core, la création du code comprend quatre étapes :

  • Le téléchargement et l'installation des dépendances
  • La compilation du code
  • Le lancement de tests unitaires
  • La publication des résultats de la compilation

Plus tard, vous ajouterez des étapes supplémentaires à déployer sur GKE. GKE étant un environnement basé sur Linux, vous allez configurer l'ensemble du processus de génération pour qu'il s'exécute sur des agents de génération basés sur Linux.

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

    resources:
    - repo: self
      fetchDepth: 1
    queue:
      name: Hosted Ubuntu 1604
    trigger:
    - release/2.1
    variables:
      TargetFramework: 'netcoreapp2.1'
      RestoreBuildProjects: 'samples/**/*.csproj'
      TestProjects: 'test/MusicStore.Test/*.csproj'
      BuildConfiguration: 'Release'
      DockerImageName: 'PROJECT_ID/musicstore'
    steps:
    - task: DotNetCoreCLI@2
      displayName: Restore
      inputs:
        command: restore
        projects: '$(RestoreBuildProjects)'
        feedsToUse: config
        nugetConfigPath: NuGet.config
    - task: DotNetCoreCLI@2
      displayName: Build
      inputs:
        projects: '$(RestoreBuildProjects)'
        arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
    - task: DotNetCoreCLI@2
      displayName: Test
      inputs:
        command: test
        projects: '$(TestProjects)'
        arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
    - task: DotNetCoreCLI@2
      displayName: Publish
      inputs:
        command: publish
        publishWebProjects: True
        arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
        zipAfterPublish: false
        modifyOutputPath: false
    

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

  4. Faites un commit de vos modifications et transférez-les vers Azure Pipelines.

    Visual Studio

    1. Ouvrez Team Explorer, puis cliquez sur l'icône Home (Accueil).
    2. Cliquez sur les Modifications.
    3. Saisissez un message de commit, tel que Add build 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 build definition"
      
    3. Transférez les modifications vers Azure DevOps :

      git push
      
  5. Dans Azure, sélectionnez Pipelines.

    Une définition de compilation est créée à partir du fichier YAML pour lequel vous avez effectué un commit dans le dépôt Git.

Publier des images Docker

Pour déployer l'application MusicStore sur GKE, vous devez empaqueter l'application en tant qu'image de conteneur Docker et la rendre disponible dans Container Registry. Vous utilisez Container Registry dans votre projet de production pour cette tâche.

Configurer un compte de service pour la publication d'images

Avant de pouvoir configurer Azure Pipelines pour créer et publier une image de conteneur, vous devez vous assurer qu'Azure Pipelines peut s'authentifier auprès de Container Registry. Pour ce faire, créez un compte de service Google Cloud dans votre projet de production :

  1. Basculez vers votre projet dans Cloud Console.
  2. Dans Cloud Console, activez Cloud Shell.

    Activer Cloud Shell

  3. Pour gagner du temps lors de la saisie de votre ID de projet et des options de la zone Compute Engine, définissez des valeurs de configuration par défaut en exécutant les commandes suivantes :

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

    Remplacez PROJECT_ID par l'ID de votre projet GCP, et 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 azure-pipelines-test-project-12345
    gcloud config set compute/zone us-central1-a
  4. Activez l'API Container Registry pour votre projet :

    gcloud services enable containerregistry.googleapis.com
  5. Créez un compte de service pour Azure Pipelines afin de publier des images Docker :

    gcloud iam service-accounts create azure-pipelines-publisher \
        --display-name "Azure Pipelines Publisher"
  6. Attribuez le rôle IAM d'administrateur de l'espace de stockage au compte de service :

    AZURE_PIPELINES_PUBLISHER=azure-pipelines-publisher@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com
    
    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
        --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
        --role roles/storage.admin
    
  7. Générez une clé de compte de service :

    gcloud iam service-accounts keys create azure-pipelines-publisher.json \
        --iam-account $AZURE_PIPELINES_PUBLISHER
    
    tr -d '\n' < azure-pipelines-publisher.json > azure-pipelines-publisher-oneline.json
  8. Dans le menu Cloud Shell, cliquez sur Ouvrir l'éditeur.

  9. Ouvrez le fichier nommé azure-pipelines-publisher-oneline.json. Vous aurez besoin du contenu de ce fichier à l'une des étapes suivantes.

Connecter Azure Pipelines à Container Registry

Une fois le compte de service créé, vous pouvez connecter Azure Pipelines à Container Registry.

  1. Dans le menu Azure DevOps, sélectionnez Project settings (Paramètres du projet), puis Pipelines > Service connections (Connexions de service).
  2. Cliquez sur New service connection (Nouvelle connexion de service).
  3. Dans la liste, sélectionnez Docker Registry (Registre Docker), puis cliquez sur Next (Suivant).
  4. Dans la boîte de dialogue, entrez des valeurs pour les champs suivants :
    • Registry type (Type de registre) : Others (Autres)
    • Docker Registry (Registre Docker) : https://gcr.io/PROJECT_ID, en remplaçant PROJECT_ID par le nom de votre projet (par exemple, https://gcr.io/azure-pipelines-test-project-12345)
    • Docker ID (ID Docker) : _json_key
    • Password (Mot de passe) : collez le contenu de azure-pipelines-publisher-oneline.json.
    • Service connexion name (Nom de la connexion au service) : gcr-tutorial
  5. Cliquez sur Save (Enregistrer) pour créer la connexion.

Créer un fichier Dockerfile

Vous pouvez maintenant créer le fichier Dockerfile utilisé par Azure Pipelines pour créer l'image de conteneur.

  1. À la racine du dépôt, créez un fichier nommé Dockerfile.
  2. Copiez le code suivant dans le fichier, puis enregistrez le fichier :

    FROM mcr.microsoft.com/dotnet/core/aspnet:2.1
    WORKDIR /app
    COPY samples/MusicStore/bin/Release/netcoreapp2.1/publish /app/
    COPY samples/MusicStore/config.json /app/
    
    ENV ASPNETCORE_URLS=http://0.0.0.0:8080
    
    ENTRYPOINT ["dotnet", "MusicStore.dll"]
    
  3. Créez un autre fichier nommé deployment.yaml à la racine de votre espace de travail Git. Laissez le fichier vide pour l'instant.

  4. Validez vos modifications :

    Visual Studio

    1. Ouvrez Team Explorer et cliquez sur l'icône d'accueil en haut à gauche pour passer à la vue Home (Accueil).
    2. Cliquez sur les Modifications.
    3. Saisissez un message de commit, tel que Add Dockerfile and placeholder for the Kubernetes manifest.
    4. Cliquez sur Commit All (Commit pour tous).

    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 Dockerfile and placeholder for the Kubernetes manifest"
      

Étendre la définition de compilation pour créer une image Docker

Avec tous les fichiers nécessaires enregistrés, vous pouvez maintenant étendre la définition de compilation.

  1. Ouvrez le fichier azure-pipelines.yml.
  2. Étendez la définition de compilation en ajoutant le code suivant au fichier :

    - task: CmdLine@1
      displayName: 'Lock image version in deployment.yaml'
      inputs:
        filename: /bin/bash
        arguments: '-c "awk ''{gsub(\"MUSICSTORE_IMAGE\", \"gcr.io/$(DockerImageName):$(Build.BuildId)\", $0); print}'' deployment.yaml > $(build.artifactstagingdirectory)/deployment.yaml"'
    - task: PublishBuildArtifacts@1
      displayName: 'Publish Artifact'
      inputs:
        PathtoPublish: '$(build.artifactstagingdirectory)'
    - task: Docker@0
      displayName: 'Build image'
      inputs:
        containerregistrytype: 'Container Registry'
        dockerRegistryConnection: 'gcr-tutorial'
        imageName: '$(DockerImageName):$(Build.BuildId)'
    - task: Docker@0
      displayName: 'Publish image'
      inputs:
        containerregistrytype: 'Container Registry'
        dockerRegistryConnection: 'gcr-tutorial'
        action: 'Push an image'
        imageName: '$(DockerImageName):$(Build.BuildId)'
    
  3. Faites un commit de vos modifications et transférez-les vers Azure Pipelines :

    Visual Studio

    1. Ouvrez Team Explorer et cliquez sur l'icône d'accueil en haut à gauche pour passer à la vue Home (Accueil).
    2. Cliquez sur les Modifications.
    3. Saisissez un message de commit, tel que Extend build definition to build Docker image.
    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 "Extend build definition to build Docker image"
      
    3. Transférez les modifications vers Azure DevOps :

      git push
      
  4. Dans le menu Azure DevOps, sélectionnez Pipelines.

    Un nouveau build est automatiquement déclenché. La compilation prend environ deux minutes. La compilation peut prendre jusqu'à deux minutes.

  5. Pour vérifier que l'image a été publiée dans Container Registry, basculez vers Cloud Console, sélectionnez Container Registry > Images, puis cliquez sur musicstore.

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

Déployer en continu

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

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

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

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

Le principal artefact produit par le processus de compilation de Music Store est l'image Docker. Toutefois, étant donné que l'image Docker est publiée dans Container Registry, elle ne relève pas de la portée d'Azure Pipelines. L'image n'est donc pas un bon indicateur de définition d'une version.

Pour déployer sur Kubernetes, vous avez également besoin d'un fichier manifeste qui ressemble à une nomenclature. Non seulement, le fichier manifeste définit les ressources que Kubernetes est censé créer et gérer, mais il spécifie également la version exacte de l'image Docker à utiliser. Le fichier manifeste Kubernetes est bien adapté pour servir d'artefact de définition de la version dans la gestion des versions Azure Pipelines.

Configurer le déploiement Kubernetes

Pour exécuter MusicStore dans Kubernetes, vous avez besoin des ressources suivantes :

  • Un déploiement qui définit un pod unique pour exécuter l'image Docker produite par la compilation
  • Un service NodePort qui permet à un équilibreur de charge d'accéder au pod
  • Une entrée qui expose l'application à l'Internet public à l'aide d'un équilibreur de charge Cloud HTTP(S)

Avec l'application MusicStore, vous pouvez utiliser SQL Server ou une base de données intégrée stockée 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 copie du pod peut être exécutée à la fois. Sinon, les utilisateurs pourraient voir des données différentes en fonction du pod qui les diffuse.
  • Toutes les modifications des données sont perdues à chaque redémarrage du pod, sauf si vous modifiez le déploiement de sorte à utiliser des volumes persistants. (Nous ne couvrons pas ce scénario dans le tutoriel.)

Pour définir ces ressources Kubernetes, procédez comme suit :

  1. Ouvrez deployment.yaml et collez le code suivant, puis enregistrez le fichier :

    apiVersion: v1
    kind: Service
    metadata:
      name: musicstore
    spec:
      ports:
      - port: 80
        targetPort: 8080
        protocol: TCP
        name: http
      selector:
        app: musicstore
      type: NodePort
    
    ---
    apiVersion: extensions/v1beta1
    kind: Ingress
    metadata:
      name: musicstore
    spec:
      backend:
        serviceName: musicstore
        servicePort: 80
    
    ---
    apiVersion: extensions/v1beta1
    kind: Deployment
    metadata:
      name: musicstore
    spec:
      replicas: 1
      template:
        metadata:
          labels:
            app: musicstore
        spec:
          containers:
          - name: musicstore
            image: MUSICSTORE_IMAGE
            ports:
              - containerPort: 8080
            livenessProbe:      # Used by deployment controller
              httpGet:
                path: /
                port: 8080
              initialDelaySeconds: 5
              periodSeconds: 5
            readinessProbe:     # Used by Ingress/GCLB
              httpGet:
                path: /
                port: 8080
              initialDelaySeconds: 3
              periodSeconds: 5
            resources:
              limits:
                memory: 1024Mi
              requests:
                memory: 768Mi
    
  2. Faites un commit de vos modifications et transférez-les vers Azure Pipelines :

    Visual Studio

    1. Ouvrez Team Explorer et cliquez sur l'icône d'accueil en haut à gauche pour passer à la vue Home (Accueil).
    2. Cliquez sur les Modifications.
    3. Saisissez un message de commit, tel que Add Kubernetes manifest.
    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 Kubernetes manifest"
      
    3. Transférez les modifications vers Azure DevOps :

      git push
      

Configurer les environnements de développement et de production

Avant de revenir à la gestion des versions Azure Pipelines, vous devez créer les clusters GKE.

Créer des clusters GKE

  1. Revenez à votre instance Cloud Shell.

  2. Activez l'API GKE pour votre projet :

    gcloud services enable container.googleapis.com
  3. Créez le cluster de développement à l'aide de la commande suivante. Notez que cela peut prendre quelques minutes :

    gcloud container clusters create azure-pipelines-cicd-dev
  4. Créez le cluster de production à l'aide de la commande suivante. Notez que cela peut prendre quelques minutes :

    gcloud container clusters create azure-pipelines-cicd-prod

Connecter Azure Pipelines au cluster de développement

Tout comme vous pouvez utiliser Azure Pipelines pour vous connecter à un registre Docker externe tel que Container Registry, Azure Pipelines prend en charge l'intégration de clusters Kubernetes externes.

Il est possible de s'authentifier auprès de Container Registry à l'aide d'un compte de service Google Cloud, mais Azure Pipelines ne permet pas d'employer ce type de compte pour l'authentification avec GKE. Vous devez à la place utiliser un compte de service Kubernetes.

Pour connecter Azure Pipelines à votre cluster de développement, vous devez donc d'abord créer un compte de service Kubernetes.

  1. Dans Cloud Shell, connectez-vous au cluster de développement :

    gcloud container clusters get-credentials azure-pipelines-cicd-dev
  2. Créez un compte de service Kubernetes pour Azure Pipelines :

    kubectl create serviceaccount azure-pipelines-deploy
  3. Attribuez le rôle cluster-admin au compte de service en créant une liaison de rôle de cluster :

    kubectl create clusterrolebinding azure-pipelines-deploy --clusterrole=cluster-admin --serviceaccount=default:azure-pipelines-deploy
  4. Déterminez l'adresse IP du cluster :

    gcloud container clusters describe azure-pipelines-cicd-dev --format=value\(endpoint\)
    

    Vous aurez besoin de cette adresse dans un instant.

  5. Dans le menu Azure DevOps, sélectionnez Project settings (Paramètres du projet), puis Pipelines > Service connections (Connexions de service).

  6. Cliquez sur New service connection (Nouvelle connexion de service).

  7. Sélectionnez Kubernetes, puis cliquez sur Next (Suivant).

  8. Configurez les paramètres suivants.

    • Authentication method (Méthode d'authentification) : Service account (Compte de service).
    • Server URL (URL du serveur) : https://[PRIMARY_IP]/. Remplacez [PRIMARY_IP] par l'adresse IP que vous avez déterminée précédemment.
    • Secret : exécutez la commande suivante dans Cloud Shell, puis copiez le résultat :
      kubectl get secret $(kubectl get serviceaccounts azure-pipelines-deploy -o custom-columns=":secrets[0].name") -o yaml
    • Service connexion name (Nom de la connexion au service) : azure-pipelines-cicd-dev.
  9. Cliquez sur Save (Enregistrer).

Connecter Azure Pipelines au cluster de production

Pour connecter Azure Pipelines à votre cluster de production, vous pouvez suivre la même approche.

  1. Dans Cloud Shell, connectez-vous au cluster de production :

    gcloud container clusters get-credentials azure-pipelines-cicd-prod
  2. Créez un compte de service Kubernetes pour Azure Pipelines :

    kubectl create serviceaccount azure-pipelines-deploy
  3. Attribuez le rôle cluster-admin au compte de service en créant une liaison de rôle de cluster :

    kubectl create clusterrolebinding azure-pipelines-deploy --clusterrole=cluster-admin --serviceaccount=default:azure-pipelines-deploy
  4. Déterminez l'adresse IP du cluster :

    gcloud container clusters describe azure-pipelines-cicd-prod --format=value\(endpoint\)
    

    Vous aurez besoin de cette adresse dans un instant.

  5. Dans le menu Azure DevOps, sélectionnez Project settings (Paramètres du projet), puis Pipelines > Service connections (Connexions de service).

  6. Cliquez sur New service connection (Nouvelle connexion de service).

  7. Sélectionnez Kubernetes, puis cliquez sur Next (Suivant).

  8. Configurez les paramètres suivants :

    • Authentication method (Méthode d'authentification) : Service account (Compte de service).
    • Server URL (URL du serveur) : https://[PRIMARY_IP]/. Remplacez [PRIMARY_IP] par l'adresse IP que vous avez déterminée précédemment.
    • Secret : exécutez la commande suivante dans Cloud Shell, puis copiez le résultat :
      kubectl get secret $(kubectl get serviceaccounts azure-pipelines-deploy -o custom-columns=":secrets[0].name") -o yaml
    • Service connexion name (Nom de la connexion au service) : azure-pipelines-cicd-prod.
  9. Cliquez sur Save (Enregistrer).

Configurer le pipeline de versions

Une fois l'infrastructure GKE configurée, vous revenez à Azure Pipelines pour automatiser le déploiement, ce qui inclut les éléments suivants :

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

Créer une définition de version

Dans un premier temps, créez une nouvelle 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. Lorsque vous êtes invité à donner un nom à l'étape, saisissez Dev.
  5. En haut de l'écran, nommez la version MusicStore-KubernetesEngine.
  6. Dans le schéma du pipeline, à côté d'Artifacts (Artefacts), cliquez sur Add (Ajouter).
  7. Sélectionnez Compilation et ajoutez les paramètres suivants :

    • Source type (Type de source) : Build
    • Source (build pipeline) (pipeline de compilation) : sélectionnez la définition de compilation (il ne devrait y avoir qu'une seule option)
    • Default version (Version par défaut) : Latest
    • Source alias (Alias source) : manifest
  8. Cliquez sur Add (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 Save (Enregistrer).

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

    Le pipeline affiché ressemble à ce qui suit :

    Capture d&#39;écran du pipeline mis à jour dans Azure Pipelines

Déployer sur le cluster de développement

Avec la définition de version créée, vous pouvez maintenant configurer le déploiement sur le cluster de développement GKE.

  1. Dans le menu, accédez à l'onglet Tasks (Tâches).
  2. Cliquez sur Agent job (Job de l'agent).
  3. Définissez Agent spécification (Spécification de l'agent) sur ubuntu-18.04.
  4. À côté de Agent job (Job de l'agent), cliquez sur Add a task to agent job (Ajouter une tâche au job de l'agent)  pour ajouter une étape à la phase.
  5. Sélectionnez la tâche Deploy to Kubernetes (Déployer sur Kubernetes), puis cliquez sur Add (Ajouter).
  6. Cliquez sur la tâche nouvellement ajoutée et configurez les paramètres suivants :

    • Display name (Nom à afficher) : Deploy
    • Action : deploy
    • Kubernetes service connection (Connexion de service Kubernetes) : azure-pipelines-cicd-dev
    • Namespace (Espace de noms) : default
    • Strategy (Stratégie) : None (Aucune)
    • Manifests (Fichiers manifestes) : manifest/drop/deployment.yaml
  7. Cliquez sur Save (Enregistrer).

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

Déployer sur le cluster de production

Pour finir, configurez le déploiement sur le cluster de production GKE.

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

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

    Le pipeline ressemble désormais à ceci :

    Capture d&#39;écran du pipeline mis à jour dans Azure Pipelines

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

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

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

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

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

  12. Sélectionnez la tâche Deploy to Kubernetes (Déployer sur Kubernetes), puis cliquez sur Add (Ajouter).

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

    • Display name (Nom à afficher) : Deploy
    • Action : deploy
    • Kubernetes service connection (Connexion de service Kubernetes) : azure-pipelines-cicd-prod
    • Namespace (Espace de noms) : default
    • Strategy (Stratégie) : None (Aucune)
    • Manifests (Fichiers manifestes) : manifest/drop/deployment.yaml
  14. Cliquez sur Save (Enregistrer).

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

Exécuter le pipeline

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

  1. Sur votre ordinateur local, ouvrez le fichier samples\MusicStore\config.json dans le dépôt Git que vous avez cloné précédemment.
  2. Sur la ligne 3, remplacez le paramètre SiteTitle par ASP.NET MVC Music Store on Kubernetes Engine.
  3. Faites un commit de vos modifications, puis transférez-les vers Azure Pipelines.

    Visual Studio

    1. Ouvrez Team Explorer, puis cliquez sur l'icône Home (Accueil).
    2. Cliquez sur les Modifications.
    3. Saisissez un message de commit, tel que Change site title.
    4. Cliquez sur Valider tout et envoyer.

    Ligne de commande

    1. Préproduisez tous les fichiers modifiés :

      git add -A
      
    2. Faites un commit des modifications dans le dépôt local :

      git commit -m "Change site title"
      
    3. Transférez les modifications à Azure Pipelines :

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

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

  6. Cliquez sur Release-1 pour ouvrir la page de détails et attendez que l'état de l'étape Development bascule sur Succeeded (Réussite).

  7. Dans Cloud Console, sélectionnez Kubernetes Engine > Services et entrées.

  8. Recherchez le service d'entrée pour le cluster azure-pipelines-cicd-dev et attendez que son état bascule sur Ok. Cela peut prendre quelques minutes.

  9. Ouvrez le lien dans la colonne Points de terminaison de la même ligne. Vous risquez peut-être de constater une erreur au début, car un délai de quelques minutes est nécessaire pour que l'équilibreur de charge soit disponible. Lorsqu'il est prêt, vous verrez que Music Store a été déployé et utilise le titre personnalisé suivant :

    Capture d&#39;écran montrant l&#39;application Music Store en cours d&#39;exécution dans une page de navigateur

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

    Capture d&#39;écran affichant la page de publication et le message &quot;A pre-deployment approval is pending … Approve or Reject&quot; (Une approbation de prédéploiement est en attente … Approuver ou refuser)

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

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

  12. Attendez que l'état de l'environnement Prod bascule sur Succeeded (Réussi). Vous devrez peut-être actualiser manuellement la page dans votre navigateur.

  13. Dans Cloud Console, actualisez la page Services.

  14. Recherchez le service d'entrée pour le cluster azure-pipelines-cicd-prod et attendez que son état bascule sur OK. Cela peut prendre quelques minutes.

  15. Ouvrez le lien dans la colonne Points de terminaison de la même ligne. Là encore, il est possible que vous voyiez une erreur au début, car l'équilibreur de charge met quelques minutes à être disponible. Lorsqu'il est prêt, vous voyez à nouveau l'application Music Store avec le titre personnalisé, qui s'exécute cette fois-ci dans le cluster de production.

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. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet 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.

Étape suivante