DevOps et intégration continue
Il fut un temps où mettre un logiciel en service ressemblait à un déménagement : une fois par an, de nuit, avec des listes, des cartons et des disputes. Les personnes qui avaient écrit le programme le « jetaient par-dessus le mur » à celles qui devaient le faire tourner, et chaque camp reprochait à l’autre les pannes. Le mouvement DevOps (contraction de « développement » et d’« exploitation ») est né pour casser ce mur : on met en service des petits changements, très souvent, avec des machines qui font les vérifications à la place des humains, et une seule équipe qui répond du résultat. Cet article explique ce qu’est DevOps, comment fonctionne l’intégration continue (construire et tester à chaque changement), la livraison et le déploiement continus, les façons de mettre une version en service sans risque, comment on mesure le résultat, et ce que cela change pour la sécurité. Il est écrit pour des débutantes et débutants motivés : aucun outil n’est supposé connu.
- Rubrique
- Développement
- Niveau
- Intermédiaire
- Lecture
- 25 min (essentiel)
28 min (complet) - Révision
- 4 novembre 2026
En bref
- DevOps rapproche ceux qui écrivent le logiciel et ceux qui le font tourner : une seule équipe, un seul objectif, des changements petits et fréquents plutôt que de gros changements rares.
- L’intégration continue construit et teste automatiquement le logiciel à chaque modification du code : une erreur est repérée en quelques minutes, pas en quelques semaines.
- La livraison continue garde chaque version prête à partir en production ; le déploiement continu la publie automatiquement. Des techniques (bleu-vert, canari, progressif) limitent les dégâts en cas de problème.
- On mesure l’efficacité par quatre grandes questions : à quelle fréquence livre-t-on, en combien de temps, combien de changements échouent, et en combien de temps répare-t-on.
- Automatiser la chaîne la rend aussi attaquable : comptes, secrets et outils du pipeline sont des cibles, d’où l’importance de la sécurité intégrée à la chaîne (DevSecOps).
Prérequis conseillés : La gestion de versions et Git · Les méthodes agiles
1Le problème que DevOps résout
Pour comprendre DevOps, mettez-vous à la place de deux équipes dans une même entreprise. La première, celle du développement, écrit le logiciel. Elle est jugée sur la nouveauté : livrer vite de nouvelles fonctions. La seconde, celle de l’exploitation, fait tourner le logiciel sur des serveurs, répond aux pannes la nuit et protège le service. Elle est jugée sur la stabilité : que rien ne tombe. Les deux objectifs se contredisent : toute nouveauté est un risque de panne. Chaque camp a donc intérêt, sans mauvaise intention, à freiner l’autre.
Voici ce que cela donnait. Le développement travaillait pendant des mois, puis remettait une grosse version à l’exploitation. Celle-ci l’installait sur des machines qui ne ressemblaient pas à celles du développement. Quelque chose ne marchait pas ; chacun disait « chez moi, ça marchait » ; il fallait chercher la cause dans un amas de centaines de changements faits depuis des mois. Parce que chaque mise en service était douloureuse, on en faisait peu ; parce qu’on en faisait peu, chacune contenait beaucoup de changements, donc encore plus de risques. Un cercle vicieux.
L’idée centrale de DevOps est de renverser le cercle : si une mise en service fait mal, il faut la faire plus souvent, jusqu’à ce qu’elle devienne ordinaire. Un petit changement est facile à tester, facile à comprendre, et facile à annuler s’il se passe mal. Pour que ce soit possible, il faut que les deux équipes travaillent ensemble et que les machines fassent tout ce qui peut être automatisé.
1.1Une culture avant d’être des outils
On confond souvent DevOps avec une liste d’outils. Or le sens du mot est d’abord humain. Les ingrédients de base sont :
- Une responsabilité partagée. Celui qui écrit le code est concerné par son fonctionnement en production. L’adage populaire : « vous le construisez, vous le faites tourner ».
- Des échanges rapides et honnêtes. On se parle avant le problème, pas pendant la crise.
- Le droit de se tromper. Après un incident, on cherche ce que le système a permis, pas un coupable. On parle de retour d’expérience « sans reproche » : si l’on punit celui qui signale une erreur, tout le monde cache les erreurs.
- De petits pas. Des changements limités, vérifiables, réversibles.
- De la mesure. On décide d’après des chiffres sur ce qui se passe réellement, pas d’après des impressions.
Les outils viennent ensuite, pour rendre ces habitudes faciles. Acheter des outils sans changer la manière de travailler donne ce qu’on a vu dans beaucoup d’entreprises : une équipe « DevOps » de plus, qui devient un troisième mur entre les deux autres.
1.2Le lien avec les méthodes agiles
Les méthodes agiles (voir les méthodes agiles) ont appris aux équipes à livrer par petites tranches, toutes les deux ou trois semaines, et à tenir compte des retours. Mais cette agilité s’arrêtait à la porte de l’exploitation : le logiciel était « terminé » à la fin de la tranche, puis attendait des semaines avant d’être réellement mis en service. DevOps prolonge l’agilité jusqu’à l’utilisateur final : un changement n’est fini que lorsqu’il tourne en production et qu’on a vu qu’il fonctionne.
Pour s’exercer
Exercice 1 : le cercle vicieux
Expliquez pourquoi des mises en service rares sont plus risquées que des mises en service fréquentes.
Voir la réponse
Quand on met rarement en service, chaque version contient beaucoup de changements. En cas de problème, la cause est cachée parmi des centaines de modifications, donc longue à trouver ; l’opération est douloureuse, donc on la repousse, donc la suivante est encore plus grosse. Avec des petits changements fréquents, la cause d’un échec est forcément dans quelques lignes, la correction est rapide, le retour arrière simple, et l’équipe s’entraîne : l’opération devient ordinaire.
2Une brève histoire
DevOps n’a pas été inventé par une personne ni dans un livre. Il est né de pratiques qui se sont rencontrées vers la fin des années 2000.
- Années 1990 : l’intégration fréquente. La méthode de programmation extrême (XP, pour Extreme Programming), portée notamment par Kent Beck, recommande de réunir le travail de toute l’équipe plusieurs fois par jour et de lancer les tests à chaque fois. C’est l’ancêtre de l’intégration continue. Des outils de construction automatique apparaissent au début des années 2000.
- 2009 : un déclic. En juin, lors d’une conférence sur l’exploitation des sites web, deux responsables d’un grand site de partage de photos (John Allspaw et Paul Hammond) présentent un exposé intitulé « plus de dix mises en service par jour ». À l’époque, c’était considéré comme fou. Leur message : on peut aller très vite et rester fiable, si développeurs et exploitants collaborent et automatisent.
- Fin 2009 : le mot. Un informaticien belge, Patrick Debois, qui a suivi cet exposé à distance, organise à Gand (Belgique) une rencontre baptisée « DevOpsDays ». Le mot « DevOps » se répand, d’abord par le nom de l’événement.
- 2010 : le livre de référence sur la livraison. Jez Humble et David Farley publient Continuous Delivery, qui décrit comment garder un logiciel toujours prêt à être livré.
- 2013-2015 : de nouvelles briques techniques. Les conteneurs (voir cet article) rendent les environnements identiques de l’ordinateur du développeur au serveur ; les outils d’orchestration permettent de gérer des milliers de conteneurs ; décrire l’infrastructure par du code (voir cet article) permet de la recréer à volonté.
- 2018 : les chiffres. Le livre Accelerate (Nicole Forsgren, Jez Humble, Gene Kim) s’appuie sur des années d’enquêtes pour montrer que les équipes qui livrent souvent et vite sont aussi les plus fiables, ce qui contredisait l’idée reçue qu’il faut choisir entre vitesse et stabilité.
- Depuis 2020 : la sécurité de la chaîne. Plusieurs attaques célèbres visent la chaîne de fabrication des logiciels elle-même (partie 8), et la sécurité devient une préoccupation à intégrer dès le début, d’où le mot DevSecOps.
2.1Ce qu’il y avait avant
Avant DevOps, la livraison d’un logiciel était souvent un événement long, avec un document d’installation de plusieurs dizaines de pages, rempli à la main, suivi par une personne dédiée. Les erreurs de saisie étaient fréquentes, les environnements dérivaient les uns des autres (« un serveur flocon de neige » : unique, que personne n’ose plus toucher) et les connaissances restaient dans la tête de quelques personnes. Les tests étaient faits à la main par une équipe spécialisée, en fin de projet, quand corriger coûtait le plus cher.