DevOps et intégration continue
Partie 2 sur 5
3Le cycle DevOps
On représente souvent DevOps par un huit couché, qui exprime l’idée de boucle sans fin : le travail ne va pas d’un point de départ à une ligne d’arrivée ; ce qu’on apprend en production nourrit la préparation de la suite. La figure 1 le montre en huit activités.
- Planifier. Décider quoi faire : besoins, priorités, découpage en petites tâches.
- Coder. Écrire le changement, de préférence petit, sur une copie de travail du code (voir Git).
- Construire. Transformer le code en quelque chose d’exécutable : compiler, assembler, empaqueter.
- Tester. Vérifier automatiquement que ça marche et que rien d’ancien n’est cassé.
- Livrer. Publier le produit fabriqué (l’artefact) dans un entrepôt, avec un numéro de version.
- Déployer. Installer cette version sur un environnement : test, préproduction, production.
- Exploiter. Faire tourner, régler, sauvegarder, monter en charge.
- Surveiller. Mesurer, recevoir des alertes, comprendre ce qui se passe (voir l’observabilité).
Les quatre premières relèvent plutôt du développement, les quatre dernières plutôt de l’exploitation, mais le principe de DevOps est justement que la frontière s’efface : les développeurs lisent les alertes de production, les exploitants relisent le code de déploiement.
4L’intégration continue
4.1Le problème de l’intégration
Dans une équipe de plusieurs personnes, chacune travaille sur sa copie du code. À un moment, il faut réunir ces copies : c’est l’intégration. Si l’on intègre une fois par mois, on découvre un jour que les morceaux ne s’emboîtent pas : deux personnes ont modifié la même fonction différemment, une troisième a supposé qu’elle ne bougerait pas. C’est ce que l’on appelait l’« enfer de l’intégration » : des jours perdus à démêler des conflits, avec le risque d’oublier quelque chose.
L’intégration continue (on dit CI, pour Continuous Integration) applique le principe : ce qui fait mal, il faut le faire souvent. Chaque personne réunit son travail avec celui des autres au moins une fois par jour, en petits morceaux ; à chaque fois, une machine construit le logiciel et lance les tests. Si quelque chose casse, on le sait en quelques minutes, et la cause est forcément dans les quelques lignes qui viennent d’être changées.
4.2Ce qu’il faut pour la pratiquer
- Un dépôt unique de code, géré par un système de versions comme Git : une source de vérité, avec l’historique de tout changement.
- Une construction automatique et reproductible. La commande qui construit le logiciel doit tenir en une ligne et donner le même résultat partout. Si « ça ne se construit que sur l’ordinateur de Marc », c’est un problème.
- Des tests automatiques rapides (partie 5).
- Un serveur d’intégration, c’est-à-dire un logiciel (ou un service en ligne) qui surveille le dépôt et déclenche la chaîne à chaque changement.
- Une règle d’équipe : quand la construction est « rouge » (en échec), on la répare tout de suite, avant tout autre travail. Une construction rouge laissée traîner rend tout le dispositif inutile : plus personne ne regarde.
4.3Les branches et les demandes de fusion
Git permet de travailler sur des branches, des lignes de travail parallèles. Une pratique courante est de faire une courte branche par changement, de la proposer à l’équipe via une demande de fusion (pull request ou merge request), de la faire relire par une autre personne, puis de la fusionner dans la ligne principale. La chaîne automatique se lance à chaque proposition : la relecture humaine porte alors sur ce qu’une machine ne sait pas juger (lisibilité, choix de conception), les contrôles mécaniques étant déjà faits.
Un piège classique : les branches qui vivent des semaines. Elles recréent le problème d’intégration que l’on voulait éviter. La bonne mesure est une branche qui vit quelques heures à quelques jours. Pour livrer une fonction qui n’est pas terminée sans la montrer aux utilisateurs, on la cache derrière un drapeau de fonctionnalité (feature flag) : un interrupteur, dans la configuration, qui l’active ou non. Le code est dans la version commune mais dort jusqu’au jour où l’on tourne l’interrupteur.