Aller au contenu

Le coût réel d'une pipeline CI

Un travail d'outillage devait « alléger la pipeline » : découper l'allowlist changes: partagée par les trois suites de tests, et comprendre pourquoi le cache Composer échouait régulièrement à s'extraire. La mesure préalable — cinq à six pipelines relevées job par job — n'a validé aucune des deux hypothèses de départ. Elle a déplacé les deux questions.

Cette page garde la trace de ce déplacement, parce qu'un raisonnement qu'on ne consigne pas se rejoue à l'envers six mois plus tard.

Latence et consommation ne sont pas la même chose

L'hypothèse de départ était chiffrée : test:e2e coûte environ 190 s, donc ne pas le lancer sur une MR qui ne touche que des tests unitaires ferait gagner 190 s.

Les relevés disent autre chose. test:unit et test:e2e appartiennent au même stage test et démarrent à une seconde d'écart : ils tournent en parallèle. Leurs durées sont du même ordre — test:unit entre 162 s et 312 s, test:e2e entre 115 s et 308 s — et c'est le plus souvent test:unit qui est sur le chemin critique. Retirer test:e2e d'une pipeline fait donc gagner l'écart entre les deux, soit 0 à 8 s. Sur la MR qui a motivé ce constat — trois fichiers modifiés, tous sous tests/Unit/Infra/ — test:e2e se terminait à +186 s alors que test:unit continuait encore 195 s : le gain aurait été nul.

Le découpage a été fait quand même, et pas pour la raison qu'annonçait la spec.

Un test:e2e qui ne peut rien trouver mobilise un navigateur complet, du CPU et de la RAM pendant deux à cinq minutes. Que la pipeline dure aussi longtemps par ailleurs ne rend pas cette dépense acceptable : ça la rend invisible. Le raisonnement « ça ne coûte rien puisque c'est en parallèle » confond la latence perçue par la personne qui attend sa MR et l'énergie réellement consommée par le runner.

Deux bénéfices s'y ajoutent, tous deux corollaires :

  • des minutes runner, qui se facturent ou se rationnent ;
  • de la fiabilité : test:e2e (Panther, navigateur headless) est le job le plus sujet aux faux rouges du projet. Le lancer quand il n'a rien à observer n'ajoute que du risque, sans contrepartie.

Le contresens à ne pas commettre

Ce découpage ne doit pas être défait au motif qu'« il ne fait pas gagner de temps » : ça n'a jamais été son but. La note est également inscrite dans .gitlab-ci.yml, juste au-dessus des trois règles, pour être lue par la personne qui serait tentée de les refusionner.

Et si l'objectif était réellement d'accélérer la CI, la cible serait test:unit (285–312 s sur les pipelines chargées), pas le filtrage des jobs.

Ce que le découpage coûte, et ce qui le paie

Affiner une allowlist augmente la probabilité qu'un test ne tourne pas alors qu'il aurait rougi. Passer d'une liste à trois multiplie ce piège par trois : un dossier de production créé demain doit être ajouté à au moins une des trois, et rien dans le YAML ne le rappelle.

Deux contrepoids rendent le découpage acceptable, et ils sont indissociables de lui :

  1. Sur main et sur tag, tout tourne toujours. Les règles if: sans changes: sont le filet final. Nuance à garder en tête : les MRs de lot mergent vers la branche parente d'étape, pas vers main — ce filet ne joue donc qu'au merge final de l'étape, pas à chaque lot.
  2. Un garde-fou versionné, sous tests/Unit/Infra/, lit .gitlab-ci.yml et vérifie que chaque dossier de production est couvert par au moins une des trois listes. Un dossier oublié partout fait rougir la CI au lieu de passer inaperçu jusqu'au jour où un bug le traverse. ComposeStackReader et ComposeGuardrailsTest (même dossier) donnent le modèle : lecture du YAML réel, contrôle négatif obligatoire.

Ce garde-fou n'est pas un confort : c'est lui qui paie le risque introduit par le passage d'une allowlist à trois. Il porte aussi la cohérence du bloc « environnement » (composer.*, Dockerfile, compose*.yaml, .env*, fichiers CI), recopié à l'identique dans les trois listes parce que YAML ne sait pas concaténer deux séquences et que !reference ne s'applique pas à changes:. La duplication est assumée ; ce n'est pas le YAML qui la tient, c'est le test.

Le contenu exact des trois listes est en référence : Allowlists changes: des suites de tests.

Un trou comblé au passage

La liste unique classait .claude/** en bloc dans le périmètre doc-only. C'était faux : des bats couvrent .claude/hooks/lib/*.sh, .claude/skills/*/bin/*.sh et jusqu'au contenu versionné de .claude/settings.local.json.tpl. Une MR qui modifiait ces fichiers ne déclenchait donc pas test:bash, c'est-à-dire pas les tests écrits exprès pour eux.

Le découpage comble ce trou autant qu'il en évite d'autres. C'est le contre-argument à l'idée reçue selon laquelle une allowlist plus fine serait seulement plus risquée : une liste grossière ne se trompe pas que dans le sens du bruit, elle se trompe aussi dans le sens du silence.

Le cache CI n'est pas distribué

Le second volet partait d'un symptôme récurrent : Failed to extract cache, sur plusieurs jobs, avec l'hypothèse d'un cache corrompu.

La trace de tous les jobs — y compris ceux qui réussissent leur extraction — porte pourtant ces deux lignes :

No URL provided, cache will not be downloaded from shared cache server.
Instead a local version of cache will be extracted.

Le cache n'est pas stocké sur un espace partagé (S3, MinIO) : il est local à la machine du runner. Un job qui atterrit sur un autre runner, ou sur un runner recyclé, ne le trouve pas — d'où le WARNING: Cache file does not exist puis l'échec d'extraction. Ce n'est pas une corruption, c'est l'architecture des runners.

Et il n'apporte aucun gain mesurable

Cache Durées de test:unit Moyenne
Hit (extraction réussie) 290 s · 296 s · 312 s 299 s
Miss (extraction échouée) 297 s · 285 s · 162 s 248 s

Sur six pipelines, les jobs qui extraient le cache ne sont pas plus rapides — ils sont en moyenne légèrement plus lents. L'échantillon est petit et le point à 162 s est isolé, mais il n'existe aucun bénéfice mesurable à en tirer.

L'explication tient à ce que le cache économise réellement. Extraire vendor/ (50 à 180 Mo) coûte à peu près ce que coûterait son téléchargement, d'autant que composer install s'exécute de toute façon ensuite dans le before_script, avec son propre cache Composer.

Ce que ça change, et où

Trois conséquences, dont une seule est dans le dépôt :

  • La correction est une configuration d'infrastructure, côté runner : brancher le cache sur un stockage partagé (S3 ou MinIO). Rien dans .gitlab-ci.yml ni dans .gitlab/ci/quality.yml ne peut la produire — inutile d'y chercher.
  • L'arbitrage sur build:vendor reste ouvert, et il n'est plus « inconditionnel ou pas ». Les deux voies réelles sont : configurer ce cache distribué, seul endroit où le gain existerait ; ou retirer build:vendor et le cache pull-push (une soixantaine de lignes de CI, un chown défensif, un prefix: v2 et une chaîne de needs: optional, maintenus pour un gain nul) — simplification réelle, mais qui redeviendrait une régression le jour où un cache distribué serait configuré. Aucune des deux n'est tranchée.
  • La raison d'être défensive du cache a changé de porteur. Le cache chaud était présenté comme la seule protection contre l'échec d'un composer install sur archive dist indisponible ; ce mode de panne est couvert par le repli sur la source git du before_script, borné au code de sortie 100.

Voir aussi