Les pipelines YAML Azure DevOps offrent une approche rigoureuse et contrôlée en version pour l'intégration continue et la livraison continue (CI/CD) qui s'harmonise parfaitement avec les pratiques de livraison de logiciels modernes. En codant la définition du pipeline dans les fichiers YAML stockés aux côtés du code d'application, les équipes obtiennent la transparence, la répétabilité et l'audibilité que les éditeurs graphiques ne peuvent pas faire correspondre.

Que vous automatisez les constructions pour une architecture de microservices, déployant l'infrastructure comme code ou orchestrez des flux de travail de sortie multi-environnement complexes, les pipelines YAML Azure DevOps vous donnent le contrôle, la flexibilité et l'évolutivité nécessaires pour expédier les logiciels de manière fiable. Cet article fournit un examen approfondi de ce que sont les pipelines YAML, comment les créer, les modèles avancés et les meilleures pratiques éprouvées tirées des environnements de production.

Qu'est-ce que les pipelines Azure DevOps YAML?

Les pipelines YAML Azure DevOps sont des fichiers de configuration déclaratifs qui définissent les étapes, les étapes, les tâches et les dépendances nécessaires pour construire, tester et déployer des applications. Contrairement à l'éditeur classique qui stocke les définitions de pipeline dans la base de données de service Azure DevOps, les pipelines YAML existent comme des fichiers texte dans votre dépôt – généralement appelés ou placés sous un répertoire . Ce fichier contient la définition de pipeline entière en utilisant un format structuré que Azure DevOps analyse à l'exécution.

Le fichier pipeline peut renvoyer à d'autres fichiers YAML (templates) pour une logique réutilisable, inclure des déclarations conditionnelles, des variables dynamiques, et même déclencher différents comportements basés sur des filtres de branche, de balise ou de chemin. Cela rend le processus CI/CD entièrement scriptable et capable de gérer des scénarios complexes du monde réel sans intervention manuelle.

Composantes essentielles des pipelines YAML

Un pipeline YAML est composé de plusieurs éléments hiérarchiques qui travaillent ensemble: triggers, variables[, étapes, emplois[, ]étapes[, et templates.

Étapes, emplois et étapes

Les stations représentent des divisions importantes dans le pipeline, telles que Construire, Tester et Déployer. Elles peuvent fonctionner successivement ou en parallèle. Au sein de chaque étape, jobs définissent l'environnement d'exécution (pool ou conteneur d'agent) et contiennent une séquence de steps. Les étapes sont la plus petite unité de travail – un script à exécuter, une tâche à exécuter ou un modèle à inclure. Azure DevOps fournit des centaines de tâches intégrées pour des opérations communes comme l'installation de dépendances, des tests en cours ou la publication d'artefacts.

Déclencheurs

Triggers définit quand le pipeline doit démarrer automatiquement. Le plus courant est le déclencheur CI, qui allume des commits sur des branches spécifiées (p. ex. , ). Vous pouvez également utiliser des déclencheurs PR pour la validation de la requête, programmer des déclencheurs pour les compilations nocturnes et les filtres de chemin pour limiter le déclenchement de changements dans des répertoires spécifiques. Les configurations avancées de déclenchement vous permettent d'utiliser des wildcards, d'exclure des chemins ou de fonctionner conditionnellement sur la base de tags.

trigger:
 branches:
 include:
 - main
 - releases/*
 paths:
 exclude:
 - docs/*
 - README.md

Variables et paramètres

Les variables stockent des valeurs qui peuvent être utilisées dans tout le pipeline – chaînes de connexion, numéros de version ou noms d'environnement. Elles peuvent être définies au niveau du pipeline, au niveau de l'étape ou au niveau de travail, et peuvent être dépassées au moment de la file d'attente. Les paramètres sont un mécanisme plus puissant pour introduire des choix d'exécution (par exemple, dans quel environnement à déployer) et sont particulièrement utiles dans les modèles.

Azure DevOps prend également en charge des variables secrètes, qui sont cryptées et ne sont jamais exposées dans les journaux. Pour les secrets de qualité production, intégrer avec Azure Key Vault en utilisant la tâche "Azure Key Vault" ou la référence de groupe variable.

Modèles de réutilisation

Les templates sont l'une des caractéristiques les plus puissantes des pipelines YAML. Ils vous permettent de considérer la logique commune dans des fichiers YAML séparés et de les inclure dans plusieurs pipelines. Il y a deux types de modèles d'emploi et . Les modèles de travail encapsulent un travail entier (pool, variables et étapes compris), tandis que les modèles d'étape réutilisent un groupe d'étapes à travers des emplois ou des étapes.

Par exemple, vous pouvez créer un modèle "build-node-app.yml" qui prend une version Node.js comme paramètre et exécute npm install, build et test. Tout pipeline qui doit construire une application Node.js peut simplement inclure ce modèle avec la version appropriée. Cela élimine la duplication et assure la cohérence entre les projets.

# templates/build-node-app.yml
parameters:
- name: nodeVersion
 type: string
 default: '18.x'

steps:
- task: NodeTool@0
 inputs:
 versionSpec: ${{ parameters.nodeVersion }}
- script: npm install
 displayName: 'Install dependencies'
- script: npm run build
 displayName: 'Build application'
- script: npm test
 displayName: 'Run tests'

Principaux avantages de l'IC/DC contrôlé par version

L'adoption de pipelines YAML apporte plusieurs avantages concrets par rapport aux pipelines classiques basés sur l'interface utilisateur :

  • Contrôle de la version complète: Chaque changement de pipeline est suivi dans le même dépôt que le code d'application. Vous pouvez diff, commenter et faire revenir les changements de pipeline en utilisant les workflows standard Git. Cela élimine le mystère « qui a changé le pipeline » et garantit que la définition du pipeline est toujours en synchronisation avec le code qu'il construit.
  • Reproductibilité et auditabilité:[ Comme le pipeline est défini comme un code, vous pouvez reconstruire n'importe quel commit avec exactement les mêmes étapes, variables et dépendances que lorsqu'il a été construit. Ceci est essentiel pour déboger les problèmes de production et satisfaire aux exigences de conformité.
  • Automation au-delà des builds: Les pipelines YAML supportent la logique conditionnelle, les boucles et les expressions complexes en utilisant le langage d'expression d'Azure DevOps. Vous pouvez implémenter des workflows sophistiqués tels que le déploiement dans plusieurs régions en parallèle, l'exécution de tests de fumée uniquement sur les branches de libération, ou le déclenchement de pipelines en aval.
  • Portabilité: Les pipelines YAML peuvent être copiés entre les projets, réutilisés entre les équipes, et même utilisés pour bootstrap IC/CD pour de nouveaux dépôts. Les modèles améliorent encore cette portabilité en permettant aux équipes de partager et de maintenir la logique commune des pipelines au niveau central.
  • Collaboration et révision de code:[ Les modifications de pipeline sont assujetties au même processus d'examen des demandes de tirage que le code source.

Création d'un pipeline YAML contrôlé par version

La mise en place d'un pipeline YAML à partir de zéro est simple. Voici les étapes recommandées :

  1. Décider sur une structure de fichier Vous pouvez placer votre fichier pipeline principal à la racine du dépôt () ou dans un dossier dédié tel que . Cette dernière approche s'échelle mieux lorsque vous avez plusieurs pipelines.
  2. Écrire la définition du pipeline. Commencez par un fichier YAML minimal valide qui comprend un déclencheur, un pool (image ou conteneur VM agent) et au moins une tâche. Exemple :
  3. Store the file in your country Commettez et poussez vers la télécommande, en vous assurant que le fichier se trouve dans la branche que vous comptez utiliser comme branche par défaut pour le pipeline.
  4. Créer le pipeline dans Azure DevOps. Naviguez vers Pipelines > Create Pipeline, sélectionnez "Azure Repos Git" (ou votre source choisie), choisissez le dépôt, puis sélectionnez "Existant Azure Pipelines YAML file". Pointez sur le chemin de fichier que vous venez de créer (par exemple, ). Azure DevOps analyse le YAML et affiche un aperçu.
  5. Confirmer et exécuter. Cliquez sur « Exécuter » pour exécuter le pipeline pour la première fois. Vous pouvez surveiller la sortie en temps réel. Les commits subséquents aux branches de déclenchement démarrent automatiquement de nouveaux exécutions.

Pour les projets existants qui ont déjà un pipeline classique, vous pouvez migrer vers YAML en exportant la définition du pipeline ou en la recréant à l'aide de l'éditeur YAML. Microsoft fournit un guide de migration[ pour faciliter la transition.

Exemple de pipeline

Examinons un pipeline plus réaliste pour une application web Node.js qui construit, teste, publie un artefact et se déploie dans un environnement de mise en scène. Cet exemple montre plusieurs étapes, variables et déploiement conditionnel.

trigger:
 branches:
 include:
 - main
 - develop
 paths:
 exclude:
 - 'README.md'

variables:
 nodeVersion: '18.x'
 artifactName: 'webapp'

stages:
- stage: Build
 displayName: 'Build and Test'
 jobs:
 - job: BuildJob
 pool:
 vmImage: 'ubuntu-latest'
 steps:
 - task: NodeTool@0
 inputs:
 versionSpec: $(nodeVersion)
 - script: npm install
 displayName: 'Install dependencies'
 - script: npm run lint
 displayName: 'Lint code'
 - script: npm run build
 displayName: 'Build application'
 - script: npm test
 displayName: 'Run unit tests'
 - task: PublishBuildArtifacts@1
 inputs:
 PathtoPublish: 'dist'
 ArtifactName: $(artifactName)

- stage: DeployStaging
 displayName: 'Deploy to Staging'
 dependsOn: Build
 condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
 jobs:
 - deployment: DeployJob
 pool:
 vmImage: 'ubuntu-latest'
 environment: staging
 strategy:
 runOnce:
 deploy:
 steps:
 - download: current
 artifact: $(artifactName)
 - script: echo "Deploying artifact to staging server..."
 displayName: 'Deploy step'
 - script: echo "Running smoke tests..."
 displayName: 'Smoke test'

Ce pipeline montre:

  • Trigger avec exclusion de chemin – les modifications de documentation ne déclencheront pas une compilation complète.
  • Variables définies en haut pour la réutilisabilité.
  • Deux étapes – Construire (non-déploiement) et DéployerStaging (travail de déploiement).L'étape de déploiement ne fonctionne que si la branche source est et que la construction a réussi.
  • Emploi en utilisant le mot clé , qui permet la traçabilité, les approbations et les portes.
  • Édition et téléchargement d'artefacts – la sortie de construction est enregistrée et récupérée ultérieurement par l'étape de déploiement.

Modèles avancés

Multi-étape avec approbations manuelles

Azure DevOps Les pipelines YAML supportent les environnements avec des vérifications manuelles d'approbation. Vous pouvez exiger des utilisateurs ou des groupes spécifiques pour approuver un déploiement avant qu'il ne se produise. Ceci est défini dans le YAML en référenceant un environnement qui a des approbations configurées.

- stage: DeployProduction
 dependsOn: DeployStaging
 condition: succeeded()
 jobs:
 - deployment: ProdDeployment
 pool:
 vmImage: 'ubuntu-latest'
 environment: production
 strategy:
 runOnce:
 deploy:
 steps:
 - script: echo "Deploying to production..."

Exécution conditionnelle

Utilisez des expressions comme pour contrôler les étapes, les tâches ou les étapes exécutées. Azure DevOps prend en charge un langage riche expression[ avec des fonctions de manipulation de chaîne, des opérateurs logiques et des vérifications de collecte.

Utilisation de conteneurs

Au lieu d'utiliser une image VM, vous pouvez exécuter des tâches entières à l'intérieur d'un conteneur. Ceci est idéal pour assurer des environnements cohérents dans tout le développement et CI/CD. Il suffit de spécifier un élément sous le travail ou le pool.

pool:
 vmImage: 'ubuntu-latest'
container: node:18-alpine

Meilleures pratiques pour les pipelines YAML

En s'inspirant des réalisations de production, voici les pratiques clés pour maintenir vos pipelines robustes et durables :

  • Utiliser des modèles de façon libérale. Extraire des étapes communes dans des modèles paramétrés. Cela réduit la duplication et facilite l'application des normes (p. ex., un modèle de balayage de sécurité que tous les projets doivent exécuter).
  • Garder les fichiers YAML petits et concentrés. Un seul fichier monolithique devient difficile à lire et à déboguer. Se fractionner en plusieurs fichiers organisés par étape ou fonction (p. ex., , , .
  • Servoir les secrets avec la faille de clé d'azure. Évitez les mots de passe, les clés API ou les certificats de codage dur. Utilisez des groupes variables liés à la faille de clé, et référez-les dans votre pipeline. Azure DevOps récupère automatiquement les dernières valeurs à l'exécution.
  • Valider la syntaxe YAML avant de commettre. Utilisez un plugin linter ou IDE pour attraper les erreurs d'indentation et les clés manquantes. Azure DevOps fournit également un bouton "Validate" dans l'éditeur de pipeline.
  • Nommer les ressources clairement. Donner des valeurs significatives aux étapes, aux emplois et aux étapes , ce qui améliore grandement la lisibilité des journaux et des visualisations.
  • [FLT:]]][FLT:][F
  • Mise en œuvre de la défaillance précoce. Échec le plus rapidement possible du pipeline. Exécuter des contrôles de lintage et de syntaxe avant des tests d'intégration coûteux.
  • Documenter votre pipeline. Inclure des commentaires dans le fichier YAML expliquant les choix non évidents, surtout lorsque vous utilisez des expressions ou une logique conditionnelle.

Intégration avec d'autres outils

Azure DevOps Les pipelines YAML s'intègrent nativement à de nombreux services. Les intégrations communes comprennent:

  • SonarQube pour l'inspection continue de la qualité du code – ajouter une tâche SonarQubePrepare avant la construction et une tâche SonarQubeAnalyze après.
  • Docker pour les constructions de conteneurs – utilisez la tâche Docker@2 pour construire et pousser des images vers Azure Container Registry ou Docker Hub.
  • GitHub – Les pipelines YAML peuvent être configurés pour fonctionner avec les dépôts GitHub, et pas seulement Azure Repos. Il suffit de sélectionner GitHub comme source lors de la création du pipeline.
  • ServiceNow pour la gestion du changement – l'extension ServiceNow Change Management permet aux pipelines de créer et de mettre à jour des demandes de changement pendant les déploiements.

Pour une liste complète des tâches disponibles, veuillez consulter la documentation .

Pièges courants et comment les éviter

Même les équipes expérimentées rencontrent parfois des problèmes avec les pipelines YAML. Ci-dessous sont les erreurs fréquentes et leurs solutions:

  • Syntaxe YAML invalide – espaces de suivi, indentation incohérente (YAML n'autorise pas les onglets). Utilisez un outil de validation dans votre éditeur ou l'analyseur YAML de Azure DevOps.
  • – variables définies au niveau supérieur, surpassent les variables étape/emploi, sauf si vous utilisez la syntaxe macro correctement. Utilisez pour les expressions de gabarit et pour l'évaluation de l'exécution.
  • Déclencheurs défigureurs[ – oubliant de définir un déclencheur dans le pipeline uniquement sur des déclencheurs manuels ou programmés. Vérifier que la section de déclenchement couvre vos branches et chemins prévus.
  • Ignorer la capacité de la piscine d'agents[ – utiliser une piscine d'agents privés sans s'assurer que suffisamment d'agents peuvent causer des retards ou des défaillances.
  • N'essayez pas les changements de pipeline – exécutez toujours un test de construction sur une branche avant de fusionner à main. Même des changements mineurs aux modèles peuvent casser des dizaines de pipelines silencieusement.

Conclusion

Les pipelines YAML Azure DevOps représentent une approche de premier niveau, qui s'étend de petits projets à l'ingénierie de la version de l'entreprise. En plaçant les définitions de pipeline sous contrôle de version, les équipes acquièrent la transparence, la reproductibilité et un lien sans faille entre le développement et les opérations. La syntaxe YAML est suffisamment expressive pour modéliser des workflows complexes, mais suffisamment structurés pour rester lisibles et à jour lorsqu'ils sont jumelés à des modèles et à des pratiques exemplaires.

L'adoption de pipelines contrôlés par version ne se limite pas à l'automatisation, mais concerne le traitement du processus de livraison avec la même rigueur que le code d'application. Pour les équipes qui cherchent à augmenter la fréquence de déploiement, à réduire les erreurs manuelles et à améliorer la collaboration, les pipelines Azure DevOps YAML sont une fondation éprouvée.