Aller au contenu
Encyclopédie informatique Édition 2026

DevOps et intégration continue

Partie 3 sur 5

Niveau de lecture :

5Le pipeline : la chaîne automatique

Le pipeline (le mot anglais signifie « tuyauterie ») est la suite d’étapes que parcourt chaque changement, de son dépôt à la production. Il s’écrit sous forme d’un fichier texte, conservé avec le code : la chaîne est donc versionnée et relue comme le reste. La figure 2 en montre une version typique.

UN PARCOURS AUTOMATIQUE, DU CHANGEMENT À LA PRODUCTION Déposer le changement Construire compiler, assembler Tester unitaires, intégration Analyser qualité, vulnérabilités Publier paquet versionné Déployer préproduction, production échec : l’auteur du changement est prévenu tout de suite intégration continue (CI) chaque changement est construit et testé livraison continue (CD) jusqu’à la production Plus le retour est rapide, moins un changement fautif a le temps de se mêler à d’autres.
Figure 2. Un pipeline typique, du changement à la production.

5.1Les étapes

  • Déposer. Le dépôt d’un changement déclenche tout. Aucune action manuelle.
  • Construire. Récupérer le code et les bibliothèques dont il dépend, compiler, assembler. La construction se fait dans un environnement propre, neuf à chaque fois, pour éviter qu’un résultat dépende d’un reste oublié.
  • Tester. Lancer les tests automatiques (5.2).
  • Analyser. Contrôler la qualité du code (style, complexité) et la sécurité : bibliothèques connues pour avoir des failles, secrets laissés dans le code, schémas de code dangereux.
  • Publier. Ranger le résultat (l’artefact) dans un entrepôt, avec un numéro de version et une empreinte qui permet de vérifier qu’il n’a pas été modifié. Principe clé : on construit une fois, on déploie partout. Le même paquet, octet pour octet, passe en test puis en production ; seule la configuration change.
  • Déployer. Installer l’artefact sur l’environnement visé, souvent d’abord sur un environnement de test, puis de préproduction (copie la plus fidèle possible de la production), enfin en production.

5.2Les tests automatiques

Les tests sont le cœur du dispositif : sans eux, automatiser la livraison revient à automatiser les erreurs. On les range en niveaux, souvent dessinés en pyramide :

  • les tests unitaires vérifient un petit morceau de code isolé (par exemple une fonction qui calcule une pénalité de retard). Ils sont nombreux et très rapides : quelques secondes pour des milliers ;
  • les tests d’intégration vérifient que plusieurs morceaux fonctionnent ensemble (le programme et sa base de données). Ils sont moins nombreux et plus lents ;
  • les tests de bout en bout simulent l’usage réel, par exemple un navigateur qui se connecte et réserve un livre. Peu nombreux, lents, fragiles, mais irremplaçables pour les parcours essentiels ;
  • d’autres tests visent des qualités précises : la performance (tient-on la charge ?), la sécurité, l’accessibilité.

Le principe d’économie est de faire beaucoup de petits tests rapides et peu de gros tests lents. Un test qui échoue au hasard, sans raison (on dit « instable »), est un poison : on prend l’habitude de relancer et d’ignorer, et un vrai échec passe inaperçu. Il faut le réparer ou le supprimer.

Un exemple de pipeline écrit en texte, volontairement simple et sans lien avec un outil précis, donne une idée de la forme :

etapes:
  construire:
    quand: a chaque changement
    commande: ./construire.sh
  tester:
    depend de: construire
    commande: ./lancer-les-tests.sh
  analyser:
    depend de: construire
    commande: ./verifier-la-securite.sh
  publier:
    depend de: [tester, analyser]
    seulement sur: la ligne principale
    commande: ./publier-le-paquet.sh

Chaque outil réel (Jenkins, GitLab, GitHub Actions, et bien d’autres) a sa syntaxe propre, mais ils expriment tous la même chose : des étapes, leurs dépendances, des conditions de déclenchement.

6De la livraison au déploiement continus

Les sigles CI et CD s’écrivent ensemble (CD veut dire « livraison continue » ou « déploiement continu », Continuous Delivery ou Continuous Deployment), mais le « D » de CD recouvre deux idées différentes, qu’il faut distinguer :

Tableau 1. Intégration, livraison et déploiement continus.
PratiqueCe qui est automatiqueCe qui reste humain
Intégration continueconstruire et tester à chaque changementdécider de livrer, installer
Livraison continuetout ce qui précède, plus la préparation d’un paquet prêt à partir et son installation en préproductionla décision de mettre en production : un clic
Déploiement continutout, jusqu’à la production, dès que les contrôles réussissentrien à l’instant du déploiement ; on surveille après

La livraison continue convient à presque tout le monde : le logiciel est toujours prêt, et c’est la personne responsable qui choisit le moment, par exemple en évitant la veille d’un week-end. Le déploiement continu demande une confiance forte dans les tests et dans les moyens de retour arrière : il est répandu pour des services en ligne, plus rare quand une erreur est très grave (santé, finance, transport). Il est tout à fait respectable de s’arrêter à la livraison continue.

6.1Trois façons de mettre en service sans risque

Installer une nouvelle version d’un coup chez tous les utilisateurs est la méthode la plus risquée. Trois techniques réduisent le danger (figure 3).

TROIS FAÇONS DE METTRE UNE NOUVELLE VERSION EN SERVICE Bleu-vert : deux environnements Ancien : version 1, en service Nouveau : version 2, prêt tout le trafic bascule d’un coup Canari presque tout : version 1 un petit groupe : version 2 on observe, puis on élargit ou on retire le groupe Roulant t1 t2 t3 t4 un serveur après l’autre Dans tous les cas : un retour arrière préparé à l’avance, et des mesures pour savoir si la nouvelle version se comporte bien.
Figure 3. Trois façons de mettre une nouvelle version en service.
  • Bleu-vert. On entretient deux environnements identiques : l’un (appelé « bleu ») sert les utilisateurs avec la version 1, l’autre (« vert ») reçoit la version 2 et est testé tranquillement. Quand on est prêt, on bascule le trafic d’un coup vers le vert. Si un problème apparaît, on rebascule vers le bleu en quelques secondes : c’est le retour arrière. Le coût est de payer deux environnements pendant le changement.
  • Canari. Le nom vient des canaris que les mineurs emportaient autrefois : l’oiseau, plus sensible aux gaz, tombait malade avant eux. Ici, on envoie la nouvelle version à un petit groupe d’utilisateurs (quelques pour cent), on compare ses mesures à celles de l’ancienne (erreurs, lenteurs), puis on élargit par paliers ou on retire le groupe si ça se passe mal.
  • Roulant. On remplace les serveurs un par un (ou par petits groupes) : à tout moment, une partie des serveurs fait tourner l’ancienne version, l’autre la nouvelle. Le service ne s’interrompt jamais, mais les deux versions cohabitent un temps, ce qui demande qu’elles soient compatibles entre elles (notamment avec la base de données).

6.2Le problème des données

Changer le code est facile, changer la base de données est plus délicat : une nouvelle version peut avoir besoin d’une colonne que l’ancienne ne connaît pas. La règle d’or est de procéder en deux temps compatibles : d’abord ajouter la nouvelle structure sans rien retirer (l’ancienne version continue de fonctionner), déployer le nouveau code, puis, bien plus tard, retirer l’ancienne structure quand plus personne ne s’en sert. Une modification de données ne se « rejoue » pas à l’envers aussi facilement que du code : avant toute opération sur les données, il faut avoir une sauvegarde dont on a vérifié qu’elle se restaure (voir les sauvegardes).

6.3Le retour arrière : préparer la sortie avant l’entrée

Une équipe mûre prévoit, avant chaque mise en service, comment elle revient en arrière : quelle commande, en combien de temps, avec quelle conséquence sur les données. Un retour arrière jamais essayé n’est qu’une espérance. On le répète régulièrement, comme un exercice d’évacuation.

Pour s’exercer

Exercice 2 : livraison ou déploiement ?

Une équipe prépare automatiquement un paquet testé, l’installe en préproduction, puis attend que la responsable produit clique pour l’envoyer en production. Fait-elle de la livraison continue ou du déploiement continu ?

Voir la réponse

De la livraison continue : tout est automatique jusqu’à la préproduction et le logiciel est toujours prêt, mais la mise en production reste une décision humaine. Ce serait du déploiement continu si le paquet partait en production sans clic dès que tous les contrôles réussissent.

Exercice 3 : une construction rouge

La chaîne est en échec depuis trois jours, et l’équipe continue de déposer des changements « parce que ce n’est probablement pas grave ». Quel est le problème, et que faites-vous ?

Voir la réponse

Une construction rouge ignorée rend le dispositif inutile : on ne sait plus si les nouveaux échecs viennent des nouveaux changements, et plus personne ne regarde les alertes. La règle est de réparer immédiatement, avant tout autre travail : soit corriger le changement fautif, soit l’annuler. Si un test est instable (échoue au hasard), on le répare ou on le retire, mais on ne s’habitue pas au rouge.

Exercice 4 : choisir une stratégie

Un site reçoit de nombreux visiteurs, une panne même d’une minute est coûteuse, et le budget permet d’avoir un deuxième environnement pendant quelques heures. Une nouvelle version change beaucoup de choses. Quelle stratégie choisissez-vous et pourquoi ?

Voir la réponse

Le bleu-vert convient : on teste la nouvelle version sur l’environnement vert avec de vraies données de test, on bascule, et on peut rebasculer en quelques secondes. Le canari est aussi très bon pour limiter l’effet d’une erreur sur peu d’utilisateurs, et peut même suivre le bleu-vert. Le roulant évite la panne mais fait cohabiter les deux versions, risqué si le changement est profond (surtout sur les données).

Exercice 5 : la base de données

La nouvelle version a besoin de remplacer la colonne nom par deux colonnes prenom et nom_famille. Comment procédez-vous sans interrompre le service ?

Voir la réponse

En plusieurs temps compatibles. (1) Ajouter les deux nouvelles colonnes sans toucher à l’ancienne ; l’ancienne version continue de fonctionner. (2) Déployer un code qui écrit dans les trois colonnes et lit les nouvelles, et copier les données existantes. (3) Une fois que toutes les instances ont la nouvelle version, qu’on a vérifié et gardé une sauvegarde restaurable, retirer l’ancienne colonne dans un changement ultérieur. Chaque étape peut être annulée sans perte.