Un pipeline est un graphe de tâches : certaines peuvent tourner en même temps, d'autres doivent attendre. Comprendre ce graphe, c'est comprendre pourquoi un pipeline est lent.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Chef d'orchestre du pipeline
🎬 L'histoire
Le pipeline de HashBox dure 25 minutes. Quand Kodi regarde de plus près, il s'aperçoit que les tests unitaires attendent la fin de la vérification de style, alors qu'ils n'ont aucun lien. Les tests sur Windows et sur Linux s'exécutent l'un après l'autre. Et tout recompile à chaque fois, même quand seul le README a changé.
« Un pipeline, c'est un graphe de dépendances, dit Sam. Ce qui compte, c'est le chemin le plus long. Tout ce qui est en dehors de ce chemin peut tourner en parallèle sans coûter une seconde de plus. »
Tu apprends à modéliser un pipeline CI comme un graphe, à paralléliser avec des matrices, à utiliser le cache, et à trouver le chemin critique qui détermine la durée.
🎯 Ta mission
À la fin, je serai capable de :
- décrire un pipeline CI comme un graphe orienté acyclique de jobs
- simuler son exécution avec un nombre limité d'exécuteurs (runners)
- calculer le chemin critique et savoir quelles optimisations comptent
- utiliser les matrices pour tester plusieurs environnements
- employer le cache à clé de contenu et propager les échecs correctement
🧩 Défi d'échauffement (5 XP)
Pour préparer un dîner, tu dois : éplucher (10 min), cuire les pâtes (12 min, après éplucher), faire la sauce (15 min, après éplucher), dresser (3 min, après pâtes et sauce). Combien de temps faut-il seul ? À deux ? Quelle tâche, si tu l'accélères, fait gagner du temps ? Laquelle ne change rien ?
💡 Le concept
Le pipeline comme graphe
Un pipeline CI est un ensemble de jobs reliés par des dépendances (needs). Il forme un graphe orienté acyclique (DAG) : pas de boucle.
flowchart LR
L["lint"] --> B["build"]
U["unit"] --> B
U --> I["integration"]
B --> E["e2e"]
I --> E
E --> P["publish"]
Description du schéma : six jobs. lint et unit démarrent en parallèle. build attend les deux. integration attend unit. e2e attend build et integration. publish attend e2e.
Vocabulaire :
| Terme | Sens |
|---|---|
| Job | tâche exécutée sur un exécuteur (build, tests…) |
| Étape (step) | commande à l'intérieur d'un job |
| Exécuteur (runner) | machine ou conteneur qui exécute un job |
| Déclencheur | événement qui lance le pipeline (push, PR, planification) |
| Artefact | fichier produit et transmis d'un job à un autre |
| Cache | résultats réutilisés d'une exécution à l'autre |
| Matrice | un même job répété pour plusieurs combinaisons (système, version) |
Le chemin critique
La durée d'un pipeline avec assez d'exécuteurs est celle du chemin critique : le chemin le plus long dans le graphe (en sommant les durées).
- Accélérer un job sur le chemin critique raccourcit le pipeline ;
- accélérer un job hors du chemin critique ne change rien (jusqu'à ce qu'il devienne critique).
Avec peu d'exécuteurs, les jobs parallèles s'ordonnent dans une file : la durée augmente.
Optimisations qui comptent
| Technique | Effet |
|---|---|
| Paralléliser les jobs indépendants | raccourcit le chemin |
| Échouer vite : jobs rapides d'abord | économise l'attente |
| Cache de dépendances et de builds | évite de refaire |
| Découpage des gros jobs (tests en lots) | raccourcit le chemin critique |
| Sélection des tests | ne lance que le nécessaire |
| Runners plus puissants pour le chemin critique | gain direct |
Les matrices
Pour tester sur plusieurs combinaisons :
matrice: python = [3.10, 3.12] ; système = [linux, windows]
→ 4 jobs indépendants (produit cartésien), avec des exclusions éventuelles
Les jobs sont indépendants donc parallélisables : ils multiplient la couverture sans allonger la durée (si les exécuteurs suffisent).
Le cache par clé de contenu
Comme pour le build (mission 3) : clé = haché des entrées (requirements.lock, sources). Si la clé existe, on restaure ; sinon on calcule et on enregistre. Une clé trop large (la date) ne sert à rien ; trop étroite (le numéro de commit) ne réutilise jamais.
Propagation des échecs
Si un job échoue, ses dépendants sont ignorés (skipped), mais les jobs indépendants continuent (on veut voir tous les problèmes en une exécution).
Bonnes pratiques
- Pipeline défini par du code versionné avec le projet.
- Délais maximums (timeouts) sur chaque job.
- Secrets fournis par la plateforme (mission 5), jamais affichés.
- Permissions minimales pour le jeton du pipeline.
- Jobs idempotents et sans effet de bord sur les environnements partagés.
- Exécution sur chaque demande de fusion ; branche principale protégée.
🧠 Astuce : trace ton pipeline sur papier. Le chemin le plus long est ton premier suspect pour toute optimisation.
🔍 Exemple pas à pas
Problème : simuler l'exécution d'un pipeline avec un nombre limité d'exécuteurs, trouver le chemin critique, mesurer l'effet du cache, de la matrice et d'un échec.
import hashlib, heapq
from graphlib import TopologicalSorter
from itertools import product
PIPELINE = {
"lint": {"needs": [], "duree": 20},
"unit": {"needs": [], "duree": 60},
"integration": {"needs": ["unit"], "duree": 120},
"build": {"needs": ["lint", "unit"], "duree": 90},
"e2e": {"needs": ["build", "integration"], "duree": 240},
"publish": {"needs": ["e2e"], "duree": 30},
}
def chemin_critique(pipeline, durees=None):
durees = durees or {n: j["duree"] for n, j in pipeline.items()}
fin, precedent = {}, {}
for nom in TopologicalSorter({n: j["needs"] for n, j in pipeline.items()}).static_order():
debut = ((fin[d] d pipeline[nom][]), default=)
fin[nom] = debut + durees[nom]
pipeline[nom][]:
precedent[nom] = (pipeline[nom][], key= d: fin[d])
dernier = (fin, key=fin.get)
chemin = [dernier]
chemin[-] precedent:
chemin.append(precedent[chemin[-]])
fin[dernier], chemin[::-]
():
durees = durees {n: j[] n, j pipeline.items()}
etat, fin, temps = {}, {},
restants = {n: (j[]) n, j pipeline.items()}
en_cours = []
(etat) < (pipeline):
nom (n n pipeline n etat n [x[] x en_cours]):
deps = pipeline[nom][]
(etat.get(d) (, ) d deps):
etat[nom] = ; fin[nom] = temps
(etat.get(d) == d deps) (en_cours) < runners:
heapq.heappush(en_cours, (temps + durees[nom], nom))
(etat) == (pipeline):
en_cours:
temps, nom = heapq.heappop(en_cours)
etat[nom] = nom echecs ; fin[nom] = temps
(fin.values()), etat
total, chemin = chemin_critique(PIPELINE)
()
chemin == [, , , ] total ==
r (, , , ):
()
simuler(PIPELINE, )[] == (j[] j PIPELINE.values())
simuler(PIPELINE, )[] == total
base = {n: j[] n, j PIPELINE.items()}
hors = (base, lint=)
sur = (base, e2e=)
(, chemin_critique(PIPELINE, hors)[], , chemin_critique(PIPELINE, sur)[], )
chemin_critique(PIPELINE, hors)[] == total chemin_critique(PIPELINE, sur)[] == total -
duree, etat = simuler(PIPELINE, , echecs={})
(, etat)
etat[] == etat[] == etat[] == etat[] == etat[] ==
CACHE = ()
():
hashlib.sha256(.join(entrees).encode()).hexdigest()[:]
():
k = cle(, lockfile)
k CACHE:
CACHE.add(k);
durees_installation = [installer_dependances(), installer_dependances(), installer_dependances(), installer_dependances()]
(, durees_installation)
durees_installation == [, , , ]
MATRICE = {: [, ], : [, ]}
EXCLUSIONS = [{: , : }]
combinaisons = [((MATRICE, valeurs)) valeurs product(*MATRICE.values())]
combinaisons = [c c combinaisons c EXCLUSIONS]
((combinaisons), , [ c combinaisons])
(combinaisons) ==
Lecture :
- Le chemin critique (
unit → integration → e2e → publish, 450 s) fixe la durée minimale, quelle que soit la quantité d'exécuteurs. Avec 1 exécuteur, c'est la somme (560 s) ; avec 6, on atteint le chemin critique. - Gagner 15 s sur
lint(hors chemin) ne change rien ; gagner 120 s sure2e(sur le chemin) fait gagner 120 s. - Un échec de
unitfait ignorer ses descendants, tandis quelints'exécute quand même. - Le cache à clé de contenu réutilise l'installation tant que le fichier de verrouillage ne change pas.
- La matrice crée trois jobs parallèles (une combinaison exclue).
✍️ À toi, avec aide (10 XP)
Écris etendre_matrice(matrice, exclure=(), inclure=()) qui produit la liste des combinaisons d'une matrice de jobs (produit cartésien), retire celles qui correspondent à une exclusion (une exclusion est un dictionnaire partiel : toute combinaison qui contient ces valeurs est retirée), et ajoute les inclusions. Teste :
{"python": ["3.10","3.11","3.12"], "systeme": ["linux","windows","macos"]} avec exclusion {"python":"3.10","systeme":"macos"} et exclusion {"systeme":"windows","python":"3.11"}, et l'inclusion {"python":"3.13","systeme":"linux"}.
💡 Indice 1
itertools.product sur les valeurs.
💡 Indice 2
Une exclusion partielle correspond si toutes ses clés sont égales dans la combinaison : all(c[k] == v for k, v in excl.items()).
💡 Indice 3
Compte : 9 − 2 + 1 = 8.
✅ Réponse
from itertools import product
def etendre_matrice(matrice, exclure=(), inclure=()):
combinaisons = [dict(zip(matrice, v)) for v in product(*matrice.values())]
combinaisons = [c for c in combinaisons if not any(all(c.get(k) == v for k, v in e.items()) for e in exclure)]
return combinaisons + [dict(i) for i in inclure]
M = {"python": ["3.10", "3.11", "3.12"], "systeme": ["linux", "windows", "macos"]}
res = etendre_matrice(M, exclure=[{"python": "3.10", "systeme": "macos"}, {"systeme": "windows", "python": "3.11"}],
inclure=[{"python": "3.13", "systeme": "linux"}])
assert len(res) == {: , : } res
{: , : } res {: , : } res
((res), )
🚀 À toi, en solo (20 XP)
Optimiseur de pipeline. À partir du graphe de l'exemple :
- calcule pour chaque job le « gain si on le réduisait de 50 % » sur la durée totale (avec assez de runners) ;
- identifie les jobs « critiques » (ceux dont la réduction améliore la durée) ;
- teste trois stratégies : (a) couper
e2een deux jobs parallèles de 130 s chacun ; (b) mettre en cachebuild(90 s → 10 s) ; (c) faire passerintegrationavantunit… (impossible : explique pourquoi la validation du graphe doit refuser de modifier l'ordre sans retirer la dépendance) ; - écris
valider(pipeline)qui détecte : dépendance inconnue, cycle, job sans durée maximale (timeout), job isolé inutile ; - teste la validation avec 4 pipelines défectueux.
✅ Pistes de correction
from graphlib import TopologicalSorter, CycleError
def duree_totale(pipeline, durees):
fin = {}
for nom in TopologicalSorter({n: j["needs"] for n, j in pipeline.items()}).static_order():
fin[nom] = max((fin[d] for d in pipeline[nom]["needs"]), default=0) + durees[nom]
return max(fin.values())
P = {"lint": {"needs": [], "duree": 20}, "unit": {"needs": [], "duree": 60}, "integration": {"needs": ["unit"], "duree": 120},
"build": {"needs": ["lint", "unit"], "duree": 90}, "e2e": {"needs": ["build", "integration"], "duree": 240}, "publish": {"needs": ["e2e"], "duree": 30}}
base = {n: j[] n, j P.items()}
ref = duree_totale(P, base)
gains = {n: ref - duree_totale(P, (base, **{n: base[n] / })) n P}
({n: g n, g (gains.items(), key= kv: -kv[])})
critiques = (n n, g gains.items() g > )
critiques == [, , , ]
P_a = (P); P_a[]
P_a[] = {: [, ], : }
P_a[] = {: [, ], : }
P_a[] = {: [, ], : }
d_a = duree_totale(P_a, {n: j[] n, j P_a.items()})
d_b = duree_totale(P, (base, build=))
()
d_a == ref - d_b == ref
():
problemes = []
n, j pipeline.items():
d j[]:
d pipeline: problemes.append()
j: problemes.append()
:
(TopologicalSorter({n: [d d j[] d pipeline] n, j pipeline.items()}).static_order())
CycleError e:
problemes.append()
utilises = {d j pipeline.values() d j[]}
n, j pipeline.items():
j[] n utilises (pipeline) > :
problemes.append()
problemes
ok = {: {: [], : , : }, : {: [], : , : }}
valider(ok) == []
( p p valider({: {: [], : , : }}))
( p p valider({: {: [], : , : }, : {: [], : , : }}))
valider({: {: [], : }, : {: [], : , : }})
( p p valider({: {: [], : , : }, : {: [], : , : }}))
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Tout enchaîner en série | Pipeline lent sans raison | Paralléliser les jobs indépendants |
| Optimiser un job hors chemin critique | Aucun gain | Calculer le chemin critique d'abord |
| Cache sans clé de contenu | Résultats périmés ou jamais réutilisés | Clé = haché des entrées pertinentes |
| Pipeline sans timeout | Un job bloqué occupe un runner indéfiniment | Un délai maximal par job |
🐉 Mini-boss (40 XP)
Moteur de pipeline de HashBox. Écris mini_pipeline.py qui lit une définition (dictionnaire de jobs avec needs, duree, timeout, cache optionnel, matrice optionnelle) et :
- valide la définition (dépendances, cycles, timeouts) ;
- développe les matrices en jobs ;
- simule l'exécution avec N runners, avec cache et échecs injectés ;
- produit une chronologie (qui a tourné quand, sur quel runner) et la durée totale ;
- calcule le chemin critique et propose la meilleure optimisation ;
- 12 tests : cycle, dépendance inconnue, échec propagé, cache, matrice avec exclusion, runner unique égal à la somme, assez de runners égal au chemin critique.
✅ Pistes de correction
Un bon travail : fonctions valider, etendre_matrice, simuler, chemin_critique de la mission combinées; chronologie sous forme de tableau (job, runner, début, fin, état); suggestion « découper le job critique le plus long ». Tests : un runner → somme des durées; assez de runners → chemin critique; un échec ignore tous les descendants; un cache chaud réduit la durée; une exclusion de matrice retire la bonne combinaison.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un pipeline CI est modélisé comme :
- A. une liste sans dépendances
- B. un graphe orienté acyclique de jobs
- C. une boucle infinie
2. La durée minimale d'un pipeline (avec assez de runners) est celle :
- A. du premier job
- B. de la somme de tous les jobs
- C. du chemin critique
3. Si un job échoue, ses dépendants sont :
- A. ignorés, tandis que les jobs indépendants continuent
- B. exécutés quand même
- C. supprimés du dépôt
4. 🔁 Révision mission 05 : Un secret est :
- A. un nom de variable
- B. une configuration sensible dont la fuite cause un dommage
- C. un commentaire dans le code
5. 🔁 Révision mission 05 : Pour changer un secret sans interruption, on :
- A. remplace brutalement le secret
- B. attend la panne
- C. accepte l'ancien et le nouveau pendant la migration, puis révoque l'ancien
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Quel est le chemin critique de ton pipeline actuel ? L'as-tu déjà dessiné ?
- Quel job lent pourrait être découpé ou mis en cache sans risque ?
🎒 À retenir
- Pipeline = graphe de jobs ; DAG sans cycle.
- Chemin critique = durée minimale ; optimiser seulement ce qui est dessus.
- Cache à clé de contenu ; matrices pour la compatibilité.
- Un échec ignore les dépendants, pas les indépendants.
- Timeouts, permissions minimales, pipeline défini par du code.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Chef d'orchestre du pipeline
← Mission 05 — Configuration et secrets · Mission 07 — CD et environnements →
HEF-120 — DevOps et livraison

