DevOps et intégration continue
Partie 3 sur 5
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.
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 :
| Pratique | Ce qui est automatique | Ce qui reste humain |
|---|---|---|
| Intégration continue | construire et tester à chaque changement | décider de livrer, installer |
| Livraison continue | tout ce qui précède, plus la préparation d’un paquet prêt à partir et son installation en préproduction | la décision de mettre en production : un clic |
| Déploiement continu | tout, jusqu’à la production, dès que les contrôles réussissent | rien à 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).
- 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.