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

Dans ce tutoriel, vous apprendrez à utiliser Azure Pipelines (auparavant appelé Visual Studio Team Services), Google Kubernetes Engine (GKE) et Container Registry pour créer un pipeline d'intégration et de déploiement continus (CI/CD). Ce tutoriel utilise l'application Web ASP.NET MusicStore, basée sur ASP.NET Core.

Le pipeline CI/CD utilise deux clusters GKE distincts, un pour les tests et l'autre 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 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. Le diagramme suivant illustre ce processus.

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

Le tutoriel suppose que vous disposez de connaissances de base de .NET Core, Azure Pipelines et de GKE. Il nécessite également un accès administratif à un compte Azure DevOps et à une installation de Visual Studio 2017 déjà connectée à votre 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 des composants facturables de Google Cloud Platform, y compris :

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

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 deux clusters GKE, un pour le développement et un pour la production.

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

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

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

    Découvrir comment activer la facturation

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

Créer un projet Azure DevOps

Azure DevOps permet de gérer le code source, d'exécuter des compilations et des tests, ainsi que d'orchestrer le déploiement sur GKE. 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. Entrez 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 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/aspnet/MusicStore.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).

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

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.

Créer une branche de test

Pour vous assurer que les instructions de ce tutoriel fonctionnent, créez une branche du code basée sur une version spécifique du code source. (Cela vous aidera à 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 (Balises).
  2. Dans la liste des balises, développez rel, puis cliquez avec le bouton droit sur 2.0.0.
  3. Sélectionnez New branch (Nouvelle branche).
  4. Entrez testing comme nom de branche, puis cliquez sur Create branch (Créer une branche) pour confirmer vos sélections.

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

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

Créer le code

Après avoir créé la branche, vous pouvez commencer à automatiser la compilation. Music Store étant une application ASP.NET Core, la construction comprend quatre étapes :

  • Le téléchargement et l'installation des dépendances
  • La compilation du code
  • Le lancement des 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. Dans le menu Azure DevOps, sélectionnez Pipelines > Builds (Compilations), puis cliquez sur New pipeline (Nouveau pipeline).
  2. Sélectionnez Azure Repos (Dépôt Azure) comme emplacement du code.
  3. Sélectionnez le dépôt précédemment importé. Il doit avoir 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
    queue:
      name: Hosted Ubuntu 1604
    variables:
      TargetFramework: 'netcoreapp2.0'
      RestoreBuildProjects: 'samples/**/*.csproj'
      TestProjects: 'test/MusicStore.Test/*.csproj'
      BuildConfiguration: 'Release'
      DockerImageName: '[PROJECT-NAME]/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
    
  6. Dans la section variables, remplacez [PROJECT_NAME] par le nom de votre projet GCP.

  7. Cliquez sur Save and run (Enregistrer et exécuter).

  8. Entrez un message de commit personnalisé si vous le souhaitez et 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 et 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.

Publier des images Docker

Pour déployer l'application Music Store sur GKE, l'application doit être empaquetée en tant que conteneur Docker et publiée dans Container Registry. Vous allez maintenant étendre la définition de la compilation pour automatiser ces étapes.

Configurer un compte de service pour la publication d'images

La connexion à Container Registry nécessite qu'Azure Pipelines puisse s'authentifier auprès de GCP. Pour ce faire, créez un compte de service dans GCP dédié à cette fin.

  1. Basculez vers votre projet dans la console GCP et ouvrez Cloud Shell.

    Ouvrir Cloud Shell

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

    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 que vous allez utiliser pour créer des ressources. Si vous ne savez pas quelle zone choisir, utilisez us-central1-a.

    Exemple :

    gcloud config set project azure-pipelines-test-project-12345
    gcloud config set compute/zone us-central1-a
  3. Activez l'API Container Registry pour votre projet :

    gcloud services enable containerregistry.googleapis.com
  4. 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"
  5. Attribuez le rôle IAM d'administrateur de l'espace de stockage au compte de service :

    PROJECT_NUMBER=$(gcloud projects describe \
        $(gcloud config get-value core/project) \
        --format='value(projectNumber)')
    
    AZURE_PIPELINES_PUBLISHER=$(gcloud iam service-accounts list \
        --filter="displayName:Azure Pipelines Publisher" \
        --format='value(email)')
    
    gcloud projects add-iam-policy-binding \
        $(gcloud config get-value core/project) \
        --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
        --role roles/storage.admin
    
  6. 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
  7. Lancez l'éditeur de code en cliquant sur le bouton dans le coin supérieur droit de Cloud Shell :

    Capture d'écran de l'icône "Lancer l'éditeur de code" dans la barre de menus de Cloud Shell

  8. Ouvrez le fichier nommé azure-pipelines-publisher-oneline.json. Vous aurez besoin du contenu de ce fichier pour l’une des étapes suivantes :

Connecter Azure Pipelines à Container Registry

Avec le compte de service créé, vous pouvez maintenant 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).
  4. Dans la boîte de dialogue, entrez des valeurs pour les champs suivants :

    • Nom de connexion : gcr-tutorial
    • Registre Docker : https://gcr.io/[PROJECT-NAME], où [PROJECT_NAME] est le nom de votre projet GCP.

      Exemple : https://gcr.io/azure-pipelines-test-project-12345

    • ID Docker : _json_key

    • Password (Mot de passe) : contenu de azure-pipelines-publisher-oneline.json

  5. Cliquez sur OK pour créer la connexion.

Consulter le projet dans Visual Studio

Pour créer un Dockerfile définissant le contenu de l'image Docker, vous devez d'abord consulter le code.

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

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

  4. Dans la boîte de dialogue suivante, sélectionnez le dépôt Git Music Store, puis cliquez sur Clone (Cloner).

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

Créer un Dockerfile

Une fois le code consulté, vous pouvez configurer le Dockerfile.

  1. Dans Visual Studio, ouvrez l'Explorateur de solutions.
  2. À la racine de la solution, créez un nouveau fichier nommé Dockerfile.
  3. Copiez le code suivant et collez-le dans le fichier, puis enregistrez le fichier :

    FROM microsoft/aspnetcore:2.0.0
    WORKDIR /app
    COPY samples/MusicStore/bin/Release/netcoreapp2.0/publish /app/
    ENTRYPOINT ["dotnet", "MusicStore.dll"]
  4. À la racine de la solution, créez un fichier nommé deployment.yaml. Laissez le fichier vide pour l'instant.

  5. Ouvrez Team Explorer et cliquez sur l'icône d'accueil en haut à gauche pour passer à la vue Home (Accueil).

  6. Cliquez sur Changes (Modifications).

  7. Entrez un message de commit tel que Add Dockerfile and placeholder for the Kubernetes manifest.

  8. Cliquez sur Commit All (Commit pour tous).

É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. Dans Visual Studio, ouvrez 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)'
    

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 d'accueil en haut à gauche pour passer à la vue Home (Accueil).
  3. Cliquez sur Changes (Modifications).
  4. Entrez un message de commit tel que Extend build definition to build Docker image.
  5. Cliquez sur Commit All and Push (Commit et envoi pour tous).
  6. Dans le menu Azure DevOps, sélectionnez Pipelines > Build (Compilation).

    Notez qu'une nouvelle compilation a été déclenchée automatiquement. La compilation peut prendre jusqu'à deux minutes.

    Si la compilation échoue et affiche le message d'erreur Step input dockerRegistryConnection references service connection gcr-tutorial which could not be found, il vous faudra peut-être réenregistrer votre pipeline.

  7. Pour vérifier que l'image a été publiée dans Container Registry, basculez vers la console GCP, sélectionnez Container Registry > Images, puis cliquez sur musicstore.

    Notez qu'il existe une seule image et que la balise de cette image correspond à l'ID numérique de la compilation exécutée dans Azure Pipelines.

    Capture d'écran de la liste des images dans Container Registry

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 à certains autres systèmes d'intégration continue, Azure Pipelines fait la distinction entre la compilation et le déploiement, et fournit un ensemble d'outils spécialisés appelé 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 l'application et qui résultent généralement d'un processus de compilation.
  • 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 par phases.
  • 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 de Kubernetes

Pour exécuter Music Store 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 rend le pod accessible à un équilibreur de charge.
  • Une entrée qui expose l'application à l'Internet public à l'aide d'un équilibreur de charge HTTP/S Cloud.

Avec l'application Music Store, 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. Faute de quoi, les utilisateurs pourraient voir des données différentes en fonction du pod qui les diffuse.
  • Toutes les modifications de 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. Dans Visual Studio, ouvrez l'Explorateur de solutions.
  2. Ouvrez deployment.yaml et collez le code suivant, puis enregistrez le fichier :

    apiVersion: v1
    kind: Service
    metadata:
      name: musicstore
    spec:
      ports:
      - port: 80
        targetPort: 80
        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: 80
            livenessProbe:      # Used by deployment controller
              httpGet:
                path: /
                port: 80
              initialDelaySeconds: 5
              periodSeconds: 5
            readinessProbe:     # Used by Ingress/GCLB
              httpGet:
                path: /
                port: 80
              initialDelaySeconds: 3
              periodSeconds: 5
            resources:
              limits:
                memory: 1024Mi
              requests:
                memory: 768Mi
    
  3. Ouvrez Team Explorer et passez à la vue Home (Accueil).

  4. Cliquez sur les Modifications.

  5. Entrez un message de commit tel que Add Kubernetes manifest.

  6. Cliquez sur Commit et envoi pour tous.

Mettre en place des 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. Dans GCP, ouvrez une instance Cloud Shell.
  2. Pour gagner du temps lors de la saisie de votre ID de projet et des options de la zone Compute Engine, définissez les valeurs de configuration par défaut en exécutant les commandes suivantes :

    gcloud config set project [PROJECT_NAME]
    gcloud config set compute/zone [ZONE]

    Exemple :

    gcloud config set project azure-pipelines-test-project-12345
    gcloud config set compute/zone us-central1-a
  3. Activez l’API GKE pour votre projet :

    gcloud services enable container.googleapis.com
  4. Créez le cluster de développement en utilisant la commande ci-après. Notez que cela peut prendre quelques minutes :

    gcloud container clusters create azure-pipelines-cicd-dev
  5. 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 GCP, mais l'utilisation des comptes de service GCP n'est pas compatible avec Azure Pipelines pour l'authentification avec GKE. Au lieu de cela, vous devez 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) et sélectionnez Kubernetes.

  7. Configurez les paramètres suivants.

    • Choose authentication (Choisir l'authentification) : Service account (Compte de service).
    • Connection name (Nom de la connexion) : azure-pipelines-cicd-dev.
    • Server URL (URL du serveur) : https://[MASTER-IP]/. Remplacez [MASTER-IP] par l'adresse IP que vous avez déterminée précédemment.
    • Token (Jeton) : Exécutez la commande suivante dans Cloud Shell et copiez le résultat :
      kubectl get secret $(kubectl get secret -o custom-columns=":metadata.name" | grep azure-pipelines-deploy-) -o jsonpath="{.data.token}{'\n'}"
    • Certificate (Certificat) : Exécutez la commande suivante dans Cloud Shell et copiez le résultat :
      kubectl get secret $(kubectl get secret -o custom-columns=":metadata.name" | grep azure-pipelines-deploy-) -o jsonpath="{.data['ca\.crt']}{'\n'}"
  8. Cliquez sur OK.

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 Paramètres du projet, puis Pipelines > Service connections (Services de connexion).

  6. Cliquez sur New service connection (Nouvelle connexion de service) et sélectionnez Kubernetes.

  7. Configurez les paramètres suivants :

    • Choose authentication (Choisir l'authentification) : Service account (Compte de service).
    • Connection name (Nom de la connexion) : azure-pipelines-cicd-prod.
    • Server URL (URL du serveur) : https://[MASTER-IP]/. Remplacez [MASTER-IP] par l'adresse IP que vous avez déterminée précédemment.
    • Token (Jeton) : Exécutez la commande suivante dans Cloud Shell et copiez le résultat :
      kubectl get secret $(kubectl get secret -o custom-columns=":metadata.name" | grep azure-pipelines-deploy-) -o jsonpath="{.data.token}{'\n'}"
    • Certificate (Certificat) : Exécutez la commande suivante dans Cloud Shell et copiez le résultat :
      kubectl get secret $(kubectl get secret -o custom-columns=":metadata.name" | grep azure-pipelines-deploy-) -o jsonpath="{.data['ca\.crt']}{'\n'}"
  8. Cliquez sur OK.

Configurer le pipeline de version

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 (Phase vide).
  4. Lorsqu'il vous est demandé de donner un nom à l'étape, entrez 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 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) : manifest
  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. Entrez un commentaire si vous le souhaitez, puis confirmez en cliquant sur Save (Enregistrer).

Le pipeline ressemble maintenant à ceci :

Capture d'é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 du pipeline, accédez à l’onglet Tasks (Tâches).
  2. Cliquez sur Agent job (Phase de l'agent).
  3. Définissez le pool d'agents sur Hosted Ubuntu 1604.
  4. À côté de Agent job (Phase de l'agent), cliquez sur l'icône + 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 qui vient d'être ajoutée et configurez les paramètres suivants :

    • Display Name (Nom d'affichage) : Deploy
    • Service connection type (Type de connexion de service) : Kubernetes Service Connection
    • Kubernetes service connection (Connexion de service Kubernetes) : azure-pipelines-cicd-dev
    • Command (Commande) : apply
    • Use configuration files (Utiliser les fichiers de configuration) : Enabled (Activé)
    • Configuration file (Fichier de configuration) : manifest/drop/deployment.yaml
  7. Cliquez sur Save (Enregistrer).

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

Déployer le cluster de production

Enfin, vous 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 (Phase vide).
  4. Lorsqu'il vous est demandé de donner un nom à l'étape, entrez 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é)
    • Approbateurs : sélectionnez votre propre nom d'utilisateur ou groupe.

    Le pipeline ressemble maintenant à ceci :

    Capture d'é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) > Prod.

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

  10. Définissez le pool d'agents sur Hosted Ubuntu 1604.

  11. Cliquez sur l'icône + 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 qui vient d'être ajoutée et configurez les paramètres suivants :

    • Display Name (Nom d'affichage) : Deploy
    • Service connection type (Type de connexion de service) : Kubernetes Service Connection
    • Kubernetes service connection (Connexion de service Kubernetes) : azure-pipelines-cicd-prod
    • Command (Commande) : apply
    • Use configuration files (Utiliser les fichiers de configuration) : Enabled (Activé)
    • Configuration file (Fichier de configuration) : manifest/drop/deployment.yaml
  14. Cliquez sur Save (Enregistrer).

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

Lancer le pipeline

Maintenant que vous avez configuré tout le pipeline, il est temps de le tester en modifiant le code source.

  1. Dans Visual Studio, ouvrez le fichier samples\MusicStore\config.json.
  2. Sur la ligne 3, définissez le paramètre SiteTitle sur ASP.NET MVC Music Store running on Google Kubernetes Engine.
  3. Ouvrez Team Explorer et passez à la vue Home (Accueil).
  4. Cliquez sur les Modifications.
  5. Entrez un message de commit tel que Change site title.
  6. Cliquez sur Commit All and Push (Commit et envoi pour tous).
  7. Dans le menu Azure DevOps, sélectionnez Build and Release (Compilation et version) > Builds (Compilations) et vous verrez qu'une compilation a été déclenchée automatiquement :

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

    Il peut s'écouler environ deux minutes avant que l’état ne passe à Succeeded (Réussie).

  8. Une fois la compilation terminée, sélectionnez Pipelines > Releases (Versions) et vous verrez qu’un processus de déploiement a été lancé :

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

  9. 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). Vous devrez peut-être actualiser l'état en cliquant sur le bouton Refresh (Actualiser) dans le menu ou en actualisant la page du navigateur.

  10. Dans la console GCP, sélectionnez Kubernetes Engine > Services.

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

  12. Copiez l'URL du lien libellé */* dans la même ligne et supprimez l'astérisque de fin.

  13. Ouvrez l'URL dans un nouvel onglet de navigateur. Vous risquez peut-être de constater une erreur au début, car l'équilibrage de charge prend quelques minutes à devenir disponible. Lorsqu'il est prêt, vous verrez que Music Store a été déployé et utilise le titre personnalisé suivant :

    Capture d'écran montrant l'application Music Store en cours d'exécution dans une page de navigateur

  14. Dans Azure Pipelines, cliquez sur Approve (Approuver) pour promouvoir le déploiement dans l'environnement de production :

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

    Si vous ne voyez pas la barre ombrée en jaune, vous devrez peut-être d'abord approuver ou rejeter une version précédente.

  15. Entrez un commentaire si vous le souhaitez, puis confirmez en cliquant sur Approve (Approuver).

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

  17. Dans la console GCP, actualisez la page Services.

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

  19. Copiez l'URL du lien libellé */* dans la même ligne et supprimez l'astérisque de fin.

  20. Ouvrez l'URL dans un nouvel onglet de navigateur. 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.

Nettoyer

Pour éviter d’engendrer des coûts supplémentaires après avoir terminé ce tutoriel, supprimez les entités que vous avez créées.

Supprimer le projet Azure Pipelines

Supprimez le projet dans Azure Pipelines. 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…