{"canonical_url":"https://engineer.company/fr/glossary/ci/","content_markdown":"# CI\n\n## Ce que c'est\n\nCI abrège continuous integration, ou intégration continue : une façon de travailler où tous les membres d'une équipe intègrent leurs changements à une même ligne de développement partagée plusieurs fois par semaine. Une machine compile et teste le résultat à chaque fois, pour qu'une erreur apparaisse tant que son auteur se souvient encore de l'avoir introduite. Le nom complet, intégration continue, s'emploie aussi souvent que l'abréviation.\n\nLe terme désigne deux choses différentes, qu'il vaut mieux distinguer pour éviter bien des confusions. La première est la pratique, qui concerne les personnes. L'article de Martin Fowler, source que la plupart des équipes finissent par citer, la décrit comme un ensemble d'habitudes : garder une ligne principale unique, automatiser la compilation, lui faire exécuter ses propres tests, pousser vers la ligne principale au moins chaque jour, compiler chaque envoi, réparer immédiatement une compilation cassée, conserver une compilation rapide, masquer le travail inachevé plutôt que le garder sur une branche et rendre l'état de la compilation visible à tous. L'article rattache le nom à l'Extreme Programming et précise que Grady Booch employait déjà l'expression auparavant.\n\nLe second sens est la machine. Dire « la CI est rouge » désigne le service qui a exécuté la compilation et signalé un échec. GitHub Actions, GitLab CI/CD et leurs équivalents partagent le même schéma. Un fichier du dépôt décrit le travail : `.github/workflows/*.yml` sur GitHub et `.gitlab-ci.yml` à la racine sur GitLab. Un événement le déclenche : push, pull request ou demande de fusion, déclenchement planifié, ou personne appuyant sur un bouton. Un runner, machine réservée à cet usage, extrait le commit, exécute les commandes du fichier et associe au commit un résultat de réussite ou d'échec.\n\nUn serveur seul ne constitue pas de l'intégration continue. Une équipe qui garde son travail un mois sur des branches et fait compiler chaque branche par un serveur a automatisé ses compilations, ce qui est utile, mais l'intégration se produit toujours d'un coup à la fin. La pratique est la fusion fréquente ; la machine la rend assez sûre pour qu'on puisse continuer à la pratiquer.\n\nLa livraison continue et le déploiement continu sont les étapes suivantes. La livraison garde chaque compilation réussie prête à être publiée, et le déploiement publie automatiquement chacune d'elles. Les deux exigent une CI déjà en place, d'où l'association fréquente des trois sous la forme CI/CD.\n\n## Pourquoi c'est important\n\nLe coût de fusion de deux lignes de développement augmente plus vite que le temps passé à les maintenir séparées. Deux personnes ayant modifié le même module hier peuvent résoudre leur conflit en quelques minutes, car elles se souviennent de leur intention. Deux personnes dont les travaux ont divergé six semaines plus tôt doivent reconstruire les intentions à partir des différences de code. Fusionner souvent de petits changements garde chaque conflit petit. C'est l'essentiel du bénéfice, avant même l'intervention d'une machine.\n\nLa compilation à chaque push ajoute un second apport : une machine propre qui confirme le résultat. « Cela fonctionne sur mon portable » est une affirmation sur un portable particulier, avec ses bibliothèques installées et ses fichiers résiduels. Un runner qui repart chaque fois d'une copie de travail propre reproduit le résultat ou révèle ce que le portable avait de particulier.\n\nLa valeur tient à la vitesse. Fowler fixe un objectif d'environ dix minutes pour la compilation principale, et ce raisonnement se vérifie en pratique. Un échec signalé dix minutes après un push revient à la personne qui l'a causé alors que le changement est encore à l'écran. Un échec signalé le lendemain matin revient à la personne qui le découvre par hasard et exige d'abord une heure d'archéologie.\n\nLa visibilité compte aussi. Quand l'état de la ligne principale est visible de tous, personne ne commence un nouveau travail sur une compilation cassée sans le savoir. La réparation devient la première tâche de l'équipe plutôt que le problème de quelqu'un d'autre.\n\nLa CI n'implique pas non plus un service hébergé. pre-commit exécute les contrôles du projet comme hooks Git avant chaque commit ou push. Sa documentation montre les mêmes contrôles exécutés sur serveur avec `pre-commit run --all-files`. Task nomme chaque contrôle dans un seul `Taskfile.yml` pour qu'une personne et un runner appellent la même commande. Les contrôles de ce site suivent ce modèle. Ils s'exécutent localement, là où les pages sont écrites, et une vérification complète précède chaque push, sans service de compilation hébergé intermédiaire.\n\n## À quoi cela ressemble en pratique\n\nEnviron 4 000 heures ont été rendues à une équipe lorsqu'elle a cessé de publier à la main. La livraison logicielle reposait sur des étapes manuelles que chacun exécutait un peu différemment, jusqu'à ce que [la compilation, les tests et le déploiement automatisés les remplacent](/fr/portfolio/streamlined-ci-cd-processes-saving-4000-hours/). Le chemin du changement à la production est devenu standard plutôt qu'improvisé, et les publications sont devenues à la fois plus rapides et plus fiables.\n\nSur un projet avec une base de données en service depuis longtemps, le schéma est décrit deux fois : par l'installation initiale et par 1 022 migrations numérotées de 036 à 1102. [Une tâche CI construit la base des deux façons à chaque changement](/fr/portfolio/1022-migrations-behind-a-schema-drift-gate/), une fois depuis le schéma neuf et une fois en rejouant toutes les migrations dans l'ordre, puis compare la structure et les données initiales. Si les deux constructions diffèrent, la tâche passe au rouge et affiche les différences. Un environnement neuf et un environnement ancien correspondent ainsi à la même base par vérification, plutôt que par hypothèse.\n\nLa CI peut aussi maintenir la cohérence de deux parties d'une application. Sur un autre projet, la description de l'API et le client du frontend sont générés par une chaîne qui commence à la base de données. Le client seul représente 44 076 lignes de TypeScript typé. [Un contrôle CI confronte ce que le frontend envoie à ce que l'API attend](/fr/portfolio/generated-the-api-contract-from-the-database-out/) et fait échouer la compilation en cas de divergence. C'est le résultat pour lequel la CI existe : un champ modifié d'un seul côté fait échouer la compilation quelques minutes après le changement, au lieu de parvenir à l'utilisateur sous forme d'erreur dans le navigateur.\n\n## Où les problèmes surviennent\n\nLa plupart des configurations CI se dégradent plutôt qu'elles ne cassent. Chacun des cas suivants commence petit et finit par une compilation que l'équipe a appris à contourner.\n\n**La compilation dure plus longtemps que le travail.** Dès qu'un push met quarante minutes à rendre son résultat, les personnes cessent d'attendre, regroupent plusieurs changements dans un push et poussent moins souvent : c'est l'inverse de la pratique. Mesurez où passe le temps avant d'ajouter du matériel. Mettez les dépendances en cache, exécutez d'abord les contrôles rapides et déplacez les suites lentes vers une seconde étape ou une exécution planifiée pour garder la compilation principale proche de dix minutes.\n\n**La ligne principale reste rouge toute une journée.** Une compilation cassée que personne ne répare devient l'état normal, et un second échec arrive inaperçu derrière le premier. La règle est simple : la personne qui l'a cassée la répare maintenant, ou annule le changement et le corrige ensuite de son côté. Une ligne principale verte est la base sur laquelle tous les autres travaillent.\n\n**Les branches vivent des semaines pendant que le serveur compile chacune.** Toutes sont vertes, et les problèmes arrivent d'un coup le jour de leur fusion. C'est de la compilation automatisée sans intégration. Fusionnez vers la ligne principale au moins chaque jour, et désactivez les fonctions inachevées au lieu de les garder séparées.\n\n**Le serveur contrôle une liste et le portable une autre.** Deux listes de commandes maintenues à la main divergent. Un changement passe alors localement et échoue sur le serveur, ou l'inverse, et personne ne fait confiance à l'un ou à l'autre. Donnez un point d'entrée unique aux contrôles et appelez-le aux deux endroits. Avec pre-commit, le serveur peut exécuter exactement les hooks de chaque développeur :\n\n```yaml\n# .gitlab-ci.yml\ncheck:\n    image: python:3.13\n    script:\n        - pip install pre-commit\n        - pre-commit run --all-files --show-diff-on-failure\n```\n\n**Un test instable apprend à tous à cliquer sur Réessayer.** Un test qui échoue une fois sur vingt pour une raison sans lien avec le changement apprend à l'équipe à relancer plutôt qu'à lire. Un véritable échec reçoit ensuite le même traitement. Isolez le test, réparez-le ou supprimez-le, et traitez un bouton de relance souvent utilisé comme un constat à part entière.\n\n## Pour aller plus loin\n\n- [Intégration continue](https://martinfowler.com/articles/continuousIntegration.html) — le long article de Martin Fowler : chaque pratique, la compilation en dix minutes et l'origine du nom.\n- [Comprendre GitHub Actions](https://docs.github.com/en/actions/get-started/understand-github-actions) — workflows, événements, tâches et runners selon les définitions de GitHub.\n- [GitLab CI/CD](https://docs.gitlab.com/ci/) — le fichier `.gitlab-ci.yml`, les pipelines, étapes, tâches et runners dans les termes de GitLab.\n- [pre-commit](https://pre-commit.com/) — des contrôles déclarés une fois dans un fichier, exécutés comme hooks Git, puis comme étape sur un serveur CI.\n- [Task](https://taskfile.dev/) — un `Taskfile.yml` donnant un nom à chaque contrôle, pour qu'une personne et un runner saisissent la même commande.\n\n\u003chttps://engineer.company/fr/glossary/ci/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Les habitudes demandées par l'intégration continue, le rôle d'un serveur CI, les pratiques de projets réels et les signes d'un processus qui se dégrade.","formats":{"gemtext":"https://engineer.company/fr/glossary/ci/index.gmi","gopher":"https://engineer.company/fr/glossary/ci/gophermap","html":"https://engineer.company/fr/glossary/ci/","json":"https://engineer.company/fr/glossary/ci/index.json","markdown":"https://engineer.company/fr/glossary/ci/index.md","pdf":"https://engineer.company/fr/glossary/ci/index.pdf"},"kind":"page","language":"fr","title":"Qu'est-ce que la CI ?","url":"https://engineer.company/fr/glossary/ci/","version":1}