Assembler toutes les pièces : du commit à la production, avec tests, artefact, déploiements progressifs, observation et retour arrière automatique.
⏱️ Durée : environ 115 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Architecte de la livraison
🎬 L'histoire
Un mercredi matin, Kodi corrige un bug d'arrondi dans les remises. Il pousse son commit à 10 h 02. À 10 h 04, les tests sont verts. À 10 h 06, l'artefact est publié. À 10 h 09, il est en préproduction, où le test de fumée réussit. À 10 h 12, 5 % du trafic le reçoit ; à 10 h 25, tout le monde. Kodi n'a pas cliqué sur un seul bouton.
Le lendemain, un autre changement dégrade la latence. À la deuxième étape, le contrôle des métriques détecte la dérive : le déploiement recule seul, en deux minutes, avant que la plupart des clients ne remarquent quoi que ce soit.
« Voilà ce qu'on cherchait depuis le début, sourit Sam. Non pas aller vite en prenant des risques, mais aller vite parce que chaque étape est vérifiée et réversible. »
Dans cette dernière mission, tu assembles tout le module : Git, build reproductible, CI, configuration, déploiement progressif, observabilité, retour arrière — dans un pipeline cohérent et mesuré.
🎯 Ta mission
À la fin, je serai capable de :
- assembler les briques du module en un pipeline de bout en bout
- appliquer des politiques de livraison sous forme de code (gel, approbations, empreintes)
- automatiser la décision de promotion ou de retour arrière
- mesurer le pipeline avec les indicateurs DORA
- documenter le pipeline et ses procédures d'exploitation
🧩 Défi d'échauffement (5 XP)
Dessine sur une feuille la chaîne complète d'un changement dans ton idéal : de la touche « enregistrer » jusqu'à l'utilisateur. Marque 4 points de contrôle et pour chacun : ce qu'on vérifie, et ce qu'on fait si le contrôle échoue. Où se trouvent, selon toi, les endroits où l'on ne peut pas revenir en arrière ?
💡 Le concept
La chaîne de bout en bout
flowchart LR
G["Commit (Git)"] --> CI["CI : lint, tests, build"]
CI --> A["Artefact signé (registre)"]
A --> S["Staging + test de fumée"]
S --> C["Canary 5 % → 25 % → 100 %"]
C --> O["Observation (SLI, burn rate)"]
O -->|dérive| R["Retour arrière automatique"]
O -->|sain| F["Terminé"]
Description du schéma : un commit déclenche la CI (style, tests, construction). L'artefact est publié dans un registre, déployé en préproduction avec un test de fumée, puis en production par étapes canary. L'observation décide : dérive → retour arrière automatique ; sain → fin du déploiement.
Les briques et leur rôle
| Brique | Mission | Garantit |
|---|---|---|
| Git, PR, branche protégée | 2 | relecture, historique, déclencheur |
| Build reproductible, verrouillage | 3 | même source → même artefact |
| Conteneurs | 4 | même environnement d'exécution |
| Configuration et secrets | 5 | un artefact, plusieurs environnements |
| CI (graphe de jobs) | 6 | vérification rapide et automatique |
| CD (canary, drapeaux, migrations) | 7 | livraison progressive et réversible |
| Observabilité (SLI, burn rate) | 8 | décision fondée sur des mesures |
| Résilience (retour arrière, chaos) | 9 | récupération rapide |
Politique de livraison comme code
Les règles de l'équipe s'écrivent en code vérifiable, évaluées à chaque déploiement :
| Règle | Exemple |
|---|---|
| Empreinte | l'artefact déployé = l'artefact testé |
| Approbation | deux relectures pour les changements sensibles |
| Gel | pas de déploiement hors horaires d'astreinte ou la veille d'un pic |
| Budget d'erreurs | pas de déploiement risqué si le budget est épuisé |
| Santé de l'environnement | pas de déploiement pendant un incident ouvert |
| Sécurité | aucune faille critique dans l'artefact (HEF-100) |
Une politique automatisée est appliquée à tous de la même façon, sans négociation.
Pipeline et indicateurs
Chaque exécution laisse une trace (événements horodatés) : on en déduit les indicateurs DORA (mission 1) automatiquement, plutôt que par déclaration.
Documenter pour exploiter
| Document | Contenu |
|---|---|
| Architecture du pipeline | schéma, étapes, outils, propriétaires |
| Guide d'intervention (runbook) | par alerte : symptômes, vérifications, actions, escalade |
| Procédure de retour arrière | commandes, critères, qui décide |
| Registre des décisions | pourquoi telle stratégie, tel seuil |
| Plan d'amélioration | prochains goulots à traiter |
Maturité : où en es-tu ?
| Niveau | Caractéristique |
|---|---|
| 1 | build et déploiement manuels |
| 2 | CI automatisée, déploiement manuel |
| 3 | livraison continue vers staging, production par bouton |
| 4 | déploiement progressif automatique avec observation et retour arrière |
| 5 | amélioration continue mesurée, exercices de panne réguliers |
🧠 Astuce : automatise d'abord ce qui te fait peur ou ce qui te prend le plus de temps, mesure, puis recommence. Un pipeline parfait n'existe pas ; un pipeline qui s'améliore, si.
🔍 Exemple pas à pas
Problème : assembler un pipeline complet simulé — politique de livraison, build reproductible, CI, staging, canary avec décision statistique, observation, retour arrière automatique, et DORA calculés à partir du journal d'événements.
import hashlib, math, random
from datetime import datetime, timedelta
# ================= artefact et politique =================
def construire(sources):
return hashlib.sha256("|".join(f"{k}={v}" for k, v in sorted(sources.items())).encode()).hexdigest()[:12]
def politique(contexte):
violations = []
if contexte["empreinte_deployee"] != contexte["empreinte_testee"]: violations.append("l'artefact déployé n'est pas celui qui a été testé")
if contexte["relecteurs"] < 1: violations.append("aucune relecture")
if contexte["maintenant"].weekday() == 4 and contexte["maintenant"].hour >= 16: violations.append("gel : pas de déploiement le vendredi après 16 h")
if contexte["budget_restant"] <= 0: violations.append("budget d'erreurs épuisé : seuls les correctifs de fiabilité sont autorisés")
if contexte["failles_critiques"] > 0: violations.append("faille critique présente")
return violations
# ================= CI simulée =================
():
etapes = [(, sources.get(, )), (, sources.get(, ) )]
(ok _, ok etapes), etapes
:
():
.rng, .version, .t = random.Random(graine), ,
():
erreurs = ( _ (n) .rng.random() < ( (defectueuse version == ) ))
erreurs, n
():
n_c < :
p1, p2, p = err_c / n_c, err_r / n_r, (err_c + err_r) / (n_c + n_r)
z = (p1 - p2) / math.sqrt(p * ( - p) * ( / n_c + / n_r)) < p <
z >
():
t0 = maintenant
journal.append((t0, ))
reussi, _ = ci(sources)
journal.append((t0 + timedelta(minutes=), reussi ))
reussi:
empreinte = construire(sources)
contexte = (empreinte_deployee=empreinte, empreinte_testee=empreinte, relecteurs=, maintenant=t0, budget_restant=, failles_critiques=)
contexte.update(contexte_extra {})
violations = politique(contexte)
violations:
journal.append((t0 + timedelta(minutes=), )); + .join(violations)
journal.append((t0 + timedelta(minutes=), ))
prod = Production()
etape, part ((, , ), ):
horodatage = t0 + timedelta(minutes= + * etape)
n_c = ( * part)
e_c, n_c = prod.trafic(, (n_c, ), defectueuse)
e_r, n_r = prod.trafic(, , defectueuse)
d = decision(e_c, n_c, e_r, n_r)
journal.append((horodatage, ))
d == :
journal.append((horodatage + timedelta(minutes=), ));
journal.append((t0 + timedelta(minutes=), ))
journal = []
debut = datetime(, , , , )
resultats = {
: livrer({: }, , journal, debut),
: livrer({: }, , journal, debut + timedelta(days=)),
: livrer({: , : }, , journal, debut + timedelta(days=)),
: livrer({: }, , journal, datetime(, , , , )),
: livrer({: }, , journal, debut + timedelta(days=), {: }),
}
nom, res resultats.items():
()
resultats[] ==
resultats[].startswith()
resultats[] ==
resultats[] resultats[]
deploiements = [t t, e journal e == ]
retours = [t t, e journal e == ]
()
(deploiements) == (retours) ==
duree = ((t t, e journal e == ) - debut).total_seconds() /
()
duree ==
Lecture : cinq cas passent par le même pipeline :
- Changement sain : CI → staging → canary 5 % → 25 % → 100 % : déployé en 30 minutes, sans intervention.
- Version défectueuse : le contrôle statistique détecte la dérive à une étape de canary et déclenche le retour arrière automatique, avant que tout le trafic soit touché.
- Tests rouges : arrêté à la CI, rien n'est construit ni déployé.
- Vendredi 17 h : la politique de gel refuse le déploiement.
- Artefact altéré : l'empreinte ne correspond pas à l'artefact testé → refus.
Chaque événement est journalisé, d'où les indicateurs DORA se calculent automatiquement.
✍️ À toi, avec aide (10 XP)
À partir du journal de l'exemple (liste de (horodatage, événement)), écris dora_depuis_journal(journal) qui calcule :
- le nombre de déploiements réussis (
deploye) ; - le nombre de retours arrière ;
- le taux d'échec des changements = retours arrière / (déploiements + retours) ;
- le délai moyen entre un
commitet sondeploye(pour les changements qui sont allés au bout) ; - le temps moyen de rétablissement : entre l'événement
canary_..._retouret leretour_arrieresuivant.
Teste avec un journal construit à la main de 4 changements (2 réussis, 1 retour arrière, 1 arrêté en CI).
💡 Indice 1
Associe chaque commit à l'événement final qui le suit avant le commit suivant.
💡 Indice 2
Parcours le journal dans l'ordre et conserve le dernier commit rencontré.
💡 Indice 3
Le délai est la différence entre l'horodatage du deploye et celui du commit.
✅ Réponse
from datetime import datetime, timedelta
def dora_depuis_journal(journal):
journal = sorted(journal)
deployes, retours, delais, retablissements = 0, 0, [], []
dernier_commit, detection = None, None
for t, e in journal:
if e == "commit":
dernier_commit, detection = t, None
elif e.startswith("canary_") and e.endswith("_retour"):
detection = t
elif e == "retour_arriere":
retours += 1
if detection is not None:
retablissements.append((t - detection).total_seconds() / 60)
elif e == "deploye":
deployes += 1
delais.append((t - dernier_commit).total_seconds() / 60)
taux = retours / (deployes + retours) if deployes + retours else 0.0
return {"deployes": deployes, "retours": retours, "taux_echec": taux,
"delai_moyen_min": sum(delais) / len(delais) delais ,
: (retablissements) / (retablissements) retablissements }
t = datetime(, , , , )
J = [(t, ), (t + timedelta(minutes=), ),
(t + timedelta(hours=), ), (t + timedelta(hours=, minutes=), ), (t + timedelta(hours=, minutes=), ),
(t + timedelta(hours=), ), (t + timedelta(hours=, minutes=), ),
(t + timedelta(hours=), ), (t + timedelta(hours=, minutes=), )]
m = dora_depuis_journal(J)
(m)
m[] == m[] == (m[], ) ==
m[] == m[] ==
🚀 À toi, en solo (20 XP)
Politique de livraison comme code, extensible. Écris un moteur de politiques :
- chaque règle est une fonction
(contexte) -> None | str(message de violation) enregistrée avec un nom, une gravité (bloquant/avertissement) et une exception possible (dispense signée avec date d'expiration) ; - au moins 8 règles : empreinte, relectures (2 pour un changement touchant
securite/), gel, budget d'erreurs, failles critiques, couverture minimale, migration compatible (pas deDROP COLUMNsans phasecontract), taille de PR ; - un rapport clair (règle, gravité, résultat, dispense éventuelle) ;
- des tests : un changement conforme passe ; chaque règle peut échouer isolément ; une dispense expirée n'est plus acceptée ;
- une règle « méta » : aucune dispense ne peut s'appliquer à la règle d'empreinte.
✅ Pistes de correction
from datetime import date
class Politiques:
def __init__(self): self.regles, self.dispenses = [], {}
def regle(self, nom, gravite="bloquant"):
def deco(f):
self.regles.append((nom, gravite, f)); return f
return deco
def dispenser(self, nom, jusqua, par):
if nom == "empreinte":
raise ValueError("aucune dispense possible pour la règle d'empreinte")
self.dispenses[nom] = {"jusqua": jusqua, "par": par}
def evaluer(self, ctx):
rapport, bloque = [], False
for nom, gravite, f in self.regles:
message = f(ctx)
if message is None:
rapport.append((nom, gravite, "ok", None)); continue
d = .dispenses.get(nom)
d ctx[] <= d[]:
rapport.append((nom, gravite, , d[]));
rapport.append((nom, gravite, , message))
bloque = bloque gravite ==
( bloque), rapport
P = Politiques()
(): c[] == c[]
():
exige = (f.startswith() f c[])
c[] >= exige
(): c[].weekday() == c[] >=
(): c[] >
(): c[] ==
(): c[] >=
(): c[] c.get()
(): c[] <=
BON = (empreinte_deployee=, empreinte_testee=, relecteurs=, fichiers=[], date=date(, , ), heure=,
budget_restant=, failles_critiques=, couverture=, sql=, lignes=)
ok, rapport = P.evaluer(BON); ok (r[] == r rapport)
cle, valeur, regle [(, , ), (, , ), (, , ),
(, , ), (, , ), (, , )]:
ok, rapport = P.evaluer((BON, **{cle: valeur}))
ok [r[] r rapport r[] == ] == [regle], regle
ok, rapport = P.evaluer((BON, fichiers=[], relecteurs=)); ok
ok, rapport = P.evaluer((BON, date=date(, , ), heure=)); ok
ok, _ = P.evaluer((BON, lignes=)); ok
P.dispenser(, date(, , ), )
ok, rapport = P.evaluer((BON, couverture=)); ok (, , , ) rapport
ok, _ = P.evaluer((BON, couverture=, date=date(, , ))); ok
:
P.dispenser(, date(, , ), ); AssertionError
ValueError:
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Automatiser sans mesurer | On ne sait pas si on s'améliore | Calculer DORA depuis les événements du pipeline |
| Retour arrière jamais répété | Il échoue le jour où on en a besoin | Exercer régulièrement (jours de jeu) |
| Politiques par courtoisie, pas par code | Appliquées inégalement | Politiques exécutables, dispenses tracées et expirantes |
| Pipeline que personne ne comprend | Un seul expert, risque d'équipe | Documentation, schéma, guide d'intervention, propriétaires |
🐉 Mini-boss (60 XP)
Le pipeline de livraison de HashBox, de bout en bout. Livre un dossier complet :
- un simulateur
pipeline.pyqui enchaîne : commit → CI (graphe de jobs avec chemin critique) → build reproductible (empreinte) → politique de livraison → staging (test de fumée) → canary (5, 25, 100 %) avec décision statistique → observation (SLI, burn rate) → retour arrière automatique, avec journal d'événements ; - 8 scénarios de test (sain, défectueux, tests rouges, vendredi, artefact altéré, budget épuisé, faille critique, dispense valide) ;
- calcul automatique des indicateurs DORA sur 30 jours de changements simulés (graine fixée) ;
- un schéma du pipeline (Mermaid) et un
RUNBOOK.md: 5 alertes avec symptômes, vérifications, actions, critères de retour arrière ; - un exercice de panne : un composant de la chaîne tombe (registre indisponible, staging cassé), et le pipeline se comporte de façon sûre ;
- un plan d'amélioration à 3 mois fondé sur tes mesures, avec le goulot actuel, le gain attendu et l'indicateur qui prouvera le résultat ;
- une rétrospective de 10 lignes : quelle brique du module a eu le plus d'effet sur le délai ? sur la fiabilité ?
✅ Pistes de correction
Un bon dossier : le pipeline assemble les fonctions de toutes les missions (chemin_critique, build déterministe, Politiques, decision_canary, burn_rate, retour arrière), un journal unique d'événements, un calcul DORA qui retrouve fréquence / délai / taux d'échec / MTTR sur 30 jours; le runbook décrit pour chaque alerte (par exemple « burn rate élevé après déploiement ») les premières vérifications (dernier déploiement, comparaison canary/référence), l'action (retour arrière par drapeau ou version précédente) et l'escalade; le plan d'amélioration cible le goulot réel mesuré (par exemple l'approbation manuelle ou le job E2E) avec un indicateur de preuve (délai médian < 1 h).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Dans un pipeline mature, une politique de livraison est :
- A. exécutée automatiquement et appliquée à tous les changements
- B. un document que personne n'applique
- C. une décision verbale
2. Les indicateurs DORA peuvent être calculés :
- A. uniquement par questionnaire
- B. automatiquement à partir du journal d'événements du pipeline
- C. jamais
3. Le retour arrière automatique est déclenché par :
- A. l'heure de la journée
- B. le nombre de commits
- C. la détection d'une dérive des métriques pendant le déploiement progressif
4. 🔁 Révision mission 09 : Un disjoncteur (circuit breaker) sert à :
- A. cesser d'appeler une dépendance en panne pour la laisser récupérer
- B. accélérer les requêtes
- C. chiffrer les échanges
5. 🔁 Révision mission 09 : Le RPO représente :
- A. le temps de rétablissement
- B. la perte de données maximale acceptable
- C. le nombre de serveurs
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Dans ta propre chaîne de livraison, quelle étape est encore manuelle et fait peur ?
- Quel indicateur DORA aimerais-tu améliorer d'abord, et quelle action y contribuerait le plus ?
🎒 À retenir
- Un pipeline relie Git, build, CI, configuration, CD, observabilité et retour arrière.
- Les politiques de livraison s'écrivent en code, avec des dispenses tracées.
- La promotion ou le retour arrière sont décidés par des mesures.
- Les indicateurs DORA se calculent depuis le journal d'événements.
- Documenter, exercer, améliorer : un pipeline vit.
🏅 Récompenses
Total possible : 120 XP · 🏅 Badge Architecte de la livraison
← Mission 09 — Rollback et résilience opérationnelle
🎉 Félicitations
Tu as terminé HEF-120 — DevOps et livraison. Tu sais utiliser Git comme outil de collaboration, produire des builds reproductibles, conteneuriser un service, gérer configuration et secrets, concevoir un pipeline CI/CD, déployer progressivement et revenir en arrière, observer un système avec des SLO, et le rendre résilient.
→ Prochain module : HEF-130 — Performance
HEF-120 — DevOps et livraison

