Tutoriel Azure Pipelines : Un guide complet de CI/CD pour les débutants

Si votre pipeline CI/CD ne cesse de se briser ou semble lent et lourd, vous n'êtes pas seul. J'ai eu à faire face à des échecs de construction, à des environnements mal adaptés et à des coéquipiers qui écrasaient accidentellement mon travail. Azure Pipelines supprime ces frustrations grâce à un service hébergé dans le cloud qui permet de construire, tester et déployer presque n'importe quel projet sur n'importe quelle plateforme.

C'est pourquoi, dans ce tutoriel, je vous montrerai comment faire :

1. Créez votre premier Azure Pipeline
2. Construisez votre projet dans le cloud
3. Ajoutez des tests automatisés pour détecter rapidement les erreurs
4. Déploiement vers la phase d'essai ou la production d'un simple coup de pouce
5. Surveillez et optimisez votre pipeline pour plus de rapidité et de fiabilité
6. Suivez les meilleures pratiques qui ont fait leurs preuves dans le cadre de projets réels

Commençons !

Qu'est-ce qu'Azure Pipelines ?

Azure Pipelines est une solution basée sur le cloud qui simplifie le développement, les tests et le déploiement des applications. 

Il s'agit d'un composant de la boîte à outils Azure DevOps, qui prend en charge l'ensemble du cycle de développement des logiciels. Il s'agit également d'une option flexible pour les équipes de toutes tailles, car il prend en charge différentes plates-formes et différents langages de programmation. GitHub, Azure Repos et d'autres systèmes de contrôle de version bien connus y sont intégrés. 

Les principales fonctionnalités d'Azure Pipelines sont les suivantes : 

D'après mon expérience, Azure Pipelines est utile à tous ceux qui souhaitent disposer de proper CI/CD au sein de leur équipe. Il est flexible, évolutif et s'intègre bien aux autres services Azure.

Architecture des pipelines Azure (Source: Microsoft).

Si vous souhaitez mieux comprendre Azure DevOps au-delà des pipelines, ce tutoriel Azure DevOps waparcourt l'ensemble du cycle de vie CI/CD, du début à la fin.

Mise en place de votre premier pipeline Azure

Pour travailler avec l'environnement Azure Pipelines, nous devons d'abord tout mettre en place pour favoriser un processus de construction, de test et de déploiement de bout en bout.

Conditions préalables

Avant de vous lancer dans la création de votre premier pipeline, assurez-vous que vous disposez des éléments suivants :

1. Configuration du compte Azure DevOps et de l'organisation : Inscrivez-vous surpour obtenir un compte Azure DevOpsnt si vous n'en avez pas déjà un. Créez une organisation pour gérer vos projets. 
2. Dépôt : Vous aurez besoin d'un dépôt de code avec un exemple de projet. Il peut être hébergé dans Azure Repos ou GitHub. Pour ce tutoriel, nous utiliserons un simple projet Node.js.
3. Accès au portail Azure : Vous aurez également besoin d'un accès àe portail Azure lorsque vous voudrez déployer des services Azure comme Azure Kubernetes Service (AKS) et bien d'autres.

Si vous avez besoin de vous familiariser avec l'écosystème Azure au sens large, je vous recommande de suivre le cours " Comprendre Microsoft Azure". 

Création d'un nouveau projet et d'un nouveau référentiel

Maintenant que votre compte Azure DevOps et votre organisation sont configurés, créons notre premier projet et notre premier référentiel.

• Créez un nouveau projet :
  • Connectez-vous à votre compte Azure DevOps.
  • Cliquez sur Nouveau projet, donnez-lui un nom (par exemple, "AzureDevOps-DataCamp-Tutorial") et choisissez la visibilité (publique ou privée).
  • Cliquez sur Créer un projet.

• Créez un référentiel :
  • Si vous utilisez Azure Repos, accédez à la sectionRepos et initialisez un nouveau dépôt.
  • Vous pouvez également lier un dépôt GitHub existant en sélectionnant Importer un dépôt.
  • Nommez votre référentiel, choisissez votre type de référentiel (Git ou TFVC), collez l'URL de votre référentiel cloné et cliquez sur Importer.

• Si vous utilisez GitHubvous pouvez lier votre compte GitHub à Azure DevOps en allant en bas à gauche de l'interface de votre projet et en sélectionnant Paramètres du projet > Connexions GitHub > Connecter votre compte GitHub.

Pour ce tutoriel, nous utiliserons Azure Repos comme dépôt de code. Si vous débutez ou si vous n'avez pas de raison particulière de choisir TFVC, je vous conseille de choisir Git.

Créer votre première filière

Il est temps de créer notre premier pipeline. Suivez les étapes ci-dessous :

• Dans votre Pipelines cliquez sur Créer un pipeline.

• Sélectionnez Azure Repos Git comme source et choisissez votre dépôt.

• Vous pouvez configurer votre pipeline à l'aide de l'éditeur YAML ou Classic. Utilisons YAML, une méthode basée sur le code pour définir le pipeline.
• Enregistrez le pipeline et exécutez-le pour voir si tout fonctionne correctement.

Choisir YAML ou l'éditeur classique

Azure Pipelines propose deux façons de définir vos pipelines :

• Pipelines YAML : Une façon codée de décrire votre pipeline. Ils sont définis dans un fichier .yaml ou .yml dans votre référentiel de sources, ce qui permet d'obtenir des versions et d'améliorer la collaboration.
• Éditeur classique : L'éditeur classique est une interface conviviale et visuelle de type "glisser-déposer" qui est moins flexible pour les scénarios complexes.

D'après mon expérience, les pipelines YAML offrent une plus grande flexibilité et conviennent mieux aux équipes qui suivent les pratiques de l'infrastructure en tant que code (IaC) sur le site. Mais cet éditeur classique est parfait pour les plus novices qui ont une vision plus visuelle des choses. 

Toutefois, pour des raisons d'évolutivité à long terme, il est recommandé d'utiliser les pipelines YAML plutôt que l'éditeur classique.

Construire avec Azure Pipelines

Voyons maintenant comment nous pouvons construire avec Azure Pipelines. 

Dans cette section, nous allons spécifier les étapes qu'Azure Pipelines suit pour construire votre code, comme l'installation des dépendances, la compilation et l'exécution des tests. Nous allons exprimer ces étapes dans un fichier de configuration dans notre code source en utilisant YAML, un moyen simple et lisible par l'homme de décrire les étapes d'une recette.

Syntaxe du pipeline YAML

Voici un exemple simple de pipeline YAML :

# This section defines the trigger(s) for the pipeline.
# 'main' specifies that the pipeline will run whenever changes are pushed to the 'main' branch.
trigger:
- main  # automatically triggers this pipeline when changes are made to the 'main' branch.

# This defines the pool where the pipeline will run.
# 'ubuntu-latest' specifies the virtual machine image for executing tasks.
pool:
  vmImage: 'ubuntu-latest'  # This uses the latest Ubuntu image provided by Azure DevOps.

# Steps contain the individual tasks or actions that the pipeline will execute.
steps:
- script: echo Hello, world!  # A script task to run shell commands. This one prints "Hello, world!".
  displayName: 'Run my first pipeline script'  # A friendly name for this step, making it easier to identify in the pipeline logs.Propulsé par

Décomposons le code étape par étape :

• trigger: Spécifie la branche qui déclenche le pipeline (par exemple, main).
• pool: Définit l'agent de construction (par exemple, ubuntu-latest).
• steps: Liste les tâches à exécuter, telles que l'installation des dépendances et l'exécution d'un script de construction.

Configuration des étapes de construction

Pour ajouter des étapes de construction à votre pipeline YAML, vous devez définir le "script" dans la section "étapes".

Pour une simple application Node.js, par exemple, notre fichier azure-pipelines.yml ci-dessous contient du code créé automatiquement par Azure DevOps.

# Node.js
# Build a general Node.js project with npm.
# Add steps that analyze code, save build artifacts, deploy, and more:
# https://docs.microsoft.com/azure/devops/pipelines/languages/javascript

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: NodeTool@0
  inputs:
    versionSpec: '20.x'
  displayName: 'Install Node.js'

- script: |
    npm install
    npm run build
  displayName: 'npm install and build'Propulsé par

Jetons un coup d'œil au build steps dans le pipeline YAML ci-dessus : 

1. Installez Node.js : Utilisez la tâche NodeTool@0 pour spécifier la version de Node.js. 
2. Installez les dépendances : Exécutez npm install pour installer les dépendances du projet. 
3. Compiler le code (construire le projet) : Lancez npm run build pour compiler le code. 

Exploitation de la canalisation

Notre pipeline peut être déclenché manuellement ou configuré pour s'exécuter automatiquement lorsque des événements tels que des poussées de branches se produisent.

• Déclenchement manuel : Cliquez sur Run Pipeline dans l'interface Azure DevOps pour déclencher manuellement le pipeline.

• Déclenchement automatique : Mettez en place des déclencheurs basés sur les événements du référentiel pour pousser les changements vers la branche main afin de déclencher automatiquement le pipeline. En voici un exemple :

trigger:
- mainPropulsé par

Après avoir exécuté votre pipeline, vous pouvez consulter les journaux et résoudre les problèmes éventuels.

Pour accéder aux journaux, accédez au résumé de l'exécution de votre pipeline et sélectionnez le travail ou la tâche en question. Cela affichera les journaux pour cette étape ; comme dans l'image ci-dessous, vous pouvez choisir n'importe quel travail (Build, Push, ou Update) pour voir les journaux bruts.

Pour résoudre les problèmes courants, vous pouvez vérifier que votre pipeline ne présente pas de problèmes courants tels que des dépassements de délai, des contraintes de ressources ou des configurations erronées.

Ajouter des tests à votre pipeline

Vous ajoutez des tests à votre pipeline pour garantir la qualité du code et détecter les problèmes dès le début du développement. Dans Azure Pipelines, vous pouvez intégrer des tests unitaires, d'intégration ou autres en ajoutant des étapes dans la configuration de votre pipeline.

Configuration des étapes du test

Intégrez des étapes de test dans votre pipeline pour garantir la qualité du code. Vous pouvez utiliser des frameworks populaires comme Jest, Mocha ou NUnit. Par exemple, voici comment ajouter des tests unitaires avec Jest :

- script: |
    npm test
  displayName: 'Run unit tests with Jest'Propulsé par

Visualisation des résultats des tests

Azure Pipelines intègre des rapports de test. Vous pouvez configurer la publication des résultats des tests pour un suivi plus simple et consulter les résultats des tests dans les journaux de pipeline. Voici comment :

• Commencez par naviguer vers Constructions > Résultats des tests.
• Pour publier les résultats des tests, utilisez la tâche PublishTestResults@2 pour afficher les résultats. Le cursus global s'en trouve facilité. Par exemple :

- task: PublishTestResults@2
  inputs:
    testResultsFiles: '**/test-results.xml'
    testRunTitle: 'Unit Tests'Propulsé par

Déploiement avec Azure Pipelines

Dans les étapes de déploiement de votre fichier YAML du pipeline Azure, vous pouvez déployer automatiquement votre application dans plusieurs environnements, tels que testing, staging et production. Dans cette section, nous allons passer en revue quelques méthodes de déploiement avec Azure Pipelines.

Déploiement vers Azure Web Apps

Azure Web Apps est un service du portail Azure qui vous permet de développer, de déployer et de gérer des applications web à grande échelle. 

Pour déployer vers Azure Web Apps, vous devez relier les deux services. Voici comment procéder :

• En bas à gauche de votre projet, cliquez sur Paramètres du projet et cliquez sur Connexions de service sous la rubrique Pipelines sous la section Pipelines.

• Cliquez ici Nouvelle connexion de service et choisissez Azure Resource Manager.

• Authentifiez-vous avec votre compte Azure.
• Déployez vers Azure App Service :
  • Retournez dans vos Pipelines et configurez votre pipeline.
  • Dans votre pipeline, ajoutez une tâche de déploiement vers Azure.
  • Spécifiez le groupe de ressources et les détails du service. 

Voici un exemple de pipeline de déploiement YAML pour une simple application Node.js vers Azure App Service :

# Define the task for deploying to an Azure Web App
- task: AzureWebApp@1
  inputs:
    # This specifies your Azure subscription service connection
    azureSubscription: 'your-azure-subscription'
    # This specifies the name of your web app
    appName: 'your-app-name'
    # This specifies the location of the app package or files to be deployed
    package: '$(Build.ArtifactStagingDirectory)'Propulsé par

Décomposons le code ci-dessus, afin que vous puissiez l'adapter à votre cas d'utilisation :

• Remplacez your-azure-subscription par le nom de la connexion de service qui donne accès à votre abonnement Azure.
• Remplacez your-app-name par le nom réel de votre application web dans Azure. 
• Remplacez $(Build.ArtifactStagingDirectory) par le répertoire où placer le paquetage ou les fichiers de l'application web pour le déploiement. $(Build.ArtifactStagingDirectory) - Cette variable pointe vers le dossier où se trouvent vos artefacts de construction (vos fichiers d'application) une fois qu'ils ont été construits.

Mise en place du déploiement continu (CD)

Une fois que tout notre code a passé tous les tests et vérifications, l'étape suivante consiste à mettre en place notre déploiement continu. Suivez les étapes décrites ci-dessous.

Modèle de déploiement du pipeline de diffusion Azure (Source : Microsoft)

• Créez un pipeline de diffusion :
• Aller à Pipelines > Communiqués et cliquez sur Nouveau pipeline.

• Sélectionnez l'option Déploiement Azure App Service .

• Configurer les environnements :
• Ajouter et configurer Dev, Staging, QAet production où vous souhaitez déployer votre application.

• Liez l'artefact de votre pipeline de construction comme source pour le pipeline de diffusion en sélectionnant Ajouter un artefact.

• Configurez les approbations et les barrières :
• Il est nécessaire de mettre en place des approbations préalables au déploiement pour les environnements sensibles, tels que les environnements de production. Par exemple, un chef d'équipe peut être tenu d'approuver la version. Vous pouvez également ajouter des points de contrôle tels que des tests automatisés ou des contrôles de surveillance pour vous assurer que le déploiement respecte les normes de qualité.

D'après mon expérience, cette phase est nécessaire pour maintenir la stabilité dans des environnements de développement exigeants. Les approbations et les barrières assurent le contrôle et garantissent que seul un code de haute qualité est mis en production.

Déploiement vers Kubernetes

Kubernetes facilite l'exécution d'applications conteneurisées fiables et évolutives. En utilisant Azure Kubernetes Service (AKS), vous bénéficiez d'un environnement géré qui simplifie le déploiement et les opérations. Dans cette section, je vais vous expliquer comment déployer votre application sur AKS à l'aide d'Azure Pipelines.

Préparez votre cluster AKS

Vous pouvez créer un cluster AKS à l'aide du portail Azure ou de la CLI. Voici une commande de base de l'interface Bash CLI pour provisionner un cluster :

az aks create \
  --resource-group <ResourceGroupName> \
  --name <AKSClusterName> \
  --node-count 3 \
  --enable-addons monitoring \
  --generate-ssh-keysPropulsé par

Décortiquons la commande ci-dessus :

• --resource-group: Ceci indique le groupe de ressources Azure dans lequel le cluster AKS sera créé.
• --name: Il s'agit du nom de votre cluster AKS.
• --node-count: Ce paramètre définit le nombre de nœuds dans la grappe (par exemple, 3 dans cet exemple).
• --enable-addons monitoring: Cela rend possible la surveillance et l'analyse avec Azure Monitor for Containers.
• --generate-ssh-keys: Cette option génère automatiquement des clés SSH pour un accès sécurisé au nœud si elles ne sont pas fournies.

N'oubliez pas de remplacer et par les noms de vos groupes de ressources et de vos clusters.

Kubectl doit être configuré après la mise en place de votre cluster AKS. Cela garantit que votre agent de pipeline ou votre ordinateur local peut utiliser kubectl pour communiquer avec le cluster.

Vous pouvez accélérer vos tâches Azure à l'aide de la ligne de commande pourols - cet aide-mémoire sur la ligne de commande Azure est une référence pratique.

Créez un fichier YAML de déploiement 

Prenons l'exemple d'un fichier YAML de déploiement de base pour déployer une image Docker sur Kubernetes :

# This defines the API version and the kind of Kubernetes resource we are creating.
# 'apps/v1' is the API version, and 'Deployment' is the resource type.
apiVersion: apps/v1
kind: Deployment

# Metadata contains information to identify the resource uniquely.
# 'name' specifies the name of the Deployment.
metadata:
  name: my-app  # Name of the Deployment, used for identification.

# "spec" specifies the intended deployment state.
spec:
  # Number of replicas/pods we want for this Deployment.
  replicas: 3  # Ensures high availability by running three app replicas.

  # Selector is used to define the labels that this Deployment will manage.
  selector:
    matchLabels:
      app: my-app  # This ensures that only Pods with the label 'app: my-app' are managed by this Deployment.

  # Template specifies the blueprint for the pods created by the Deployment.
  template:
    metadata:
      labels:
        app: my-app  # Labels for the Pods, matching the selector above.

    # A specification for the containers of the Pods.
    spec:
      containers:
      - name: my-app  # Name of the container. This is useful for linking to the container in logs, etc.
        image: mycontainerregistry.azurecr.io/my-app:latest  # Pull the container image you will call from your container registry.
        ports:
        - containerPort: 80  # The container listens on port 80.Propulsé par

Déployer à l'aide d'Azure Pipelines

Dans votre pipeline YAML, incluez une tâche de déploiement vers AKS.

# This defines a task for deploying Kubernetes manifests within an Azure DevOps pipeline.
- task: KubernetesManifest@0  # Task type for working with Kubernetes manifest files.
  inputs:
    # This configures what to do with the Kubernetes manifest files.
    action: 'deploy'  # 'deploy' action ensures the Kubernetes manifests are applied to the cluster.

    # This defines the namespace where the Kubernetes resources will be deployed.
    namespace: 'default'  # 'default' is the namespace for deploying resources. Change if needed.

    # All this does is point to the manifest files that define the desired state of your Kubernetes resources.
    manifests: '$(Build.ArtifactStagingDirectory)/manifests/*.yaml'
    # The 'manifests' variable points to the location of all the YAML files (e.g., Deployment, Service, etc.) that will be applied during the deployment.

    # To access private container registry images, use the image pull secret.
    imagePullSecrets: 'my-registry-secret'
    # This instructs Kubernetes on which secret to use when pulling images from a private container registry.
    # Ensure that 'my-registry-secret' exists in the namespace before the deployPropulsé par

Commencer et pousser le fichier YAML pour déclencher le déploiement.

AKS simplifie l'orchestration des conteneurs, ce qui facilite la gestion de la mise à l'échelle, des mises à jour et des retours en arrière. D'après mon expérience, c'est un must-have pour les applications cloud-natives modernes.