DevOps n'est pas un outil ni un poste : c'est faire circuler le changement du code vers les utilisateurs, vite, sûrement, ensemble.
⏱️ Durée : environ 85 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Passeur de pont
🎬 L'histoire
À HashBox, l'équipe de développement termine une fonctionnalité en deux jours. Puis elle attend. Le ticket de déploiement passe chez les « ops », qui le planifient pour le jeudi suivant. Le déploiement échoue (« chez nous ça marchait ! »), on recommence la semaine d'après. Résultat : une fonctionnalité de deux jours met trois semaines à atteindre les utilisateurs.
« Les devs veulent livrer vite, les ops veulent que rien ne casse, dit Maya. Mis dos à dos, ils se bloquent. Mis dans la même équipe, avec les mêmes outils et les mêmes mesures, ils font les deux. »
Tu apprends ce qu'est DevOps, comment mesurer la performance d'une chaîne de livraison avec les indicateurs DORA, et pourquoi les petits lots changent tout.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer la culture DevOps (CALMS) et les « trois voies »
- calculer les quatre indicateurs DORA à partir d'un historique de déploiements
- cartographier un flux de valeur (temps de travail contre temps d'attente)
- comprendre pourquoi les petits lots réduisent délai et risque
- identifier le goulot d'étranglement d'une chaîne de livraison
🧩 Défi d'échauffement (5 XP)
Un restaurant a deux équipes : la cuisine et la salle, qui ne se parlent jamais. La cuisine prépare des plats « parfaits » à son rythme ; la salle les sert froids et critique. Qui est responsable de la satisfaction du client ? Que changerais-tu pour que les deux équipes partagent le même objectif ?
💡 Le concept
Le problème que DevOps résout
Historiquement, deux équipes aux objectifs opposés :
| Développement | Exploitation (Ops) |
|---|---|
| mesuré sur le changement (nouvelles fonctionnalités) | mesuré sur la stabilité (pas de panne) |
| veut livrer souvent | veut limiter les changements |
Le mur entre les deux produit des livraisons rares, grosses, risquées et stressantes.
DevOps = culture, pratiques et outils qui rassemblent développement et exploitation pour livrer rapidement et fiablement, avec une responsabilité partagée : « you build it, you run it ».
CALMS : les cinq piliers
| Lettre | Pilier | Idée |
|---|---|---|
| C | Culture | collaboration, confiance, responsabilité partagée, absence de blâme |
| A | Automation | automatiser build, tests, déploiement, infrastructure |
| L | Lean | petits lots, flux continu, éliminer le gaspillage |
| M | Measurement | décider avec des mesures, pas des opinions |
| S | Sharing | partager connaissances, outils, incidents |
Les trois voies (The Phoenix Project)
- Le flux : accélérer le passage du code vers la production (petits lots, automatisation).
- Le retour : obtenir vite des retours (tests, monitoring, utilisateurs) pour corriger tôt.
- L'apprentissage continu : expérimenter, tirer des leçons des incidents, partager.
Les quatre indicateurs DORA
Les recherches DORA (DevOps Research and Assessment) ont identifié quatre mesures qui distinguent les équipes performantes :
| Indicateur | Question | Sens |
|---|---|---|
| Fréquence de déploiement | À quelle fréquence livre-t-on en production ? | vitesse |
| Délai de livraison des changements (lead time) | Combien de temps entre un commit et sa mise en production ? | vitesse |
| Taux d'échec des changements | Quelle part des déploiements provoque un incident ou un retour arrière ? | stabilité |
| Temps de rétablissement (MTTR) | En combien de temps rétablit-on le service après un échec ? | stabilité |
Constat majeur : vitesse et stabilité ne s'opposent pas — les meilleures équipes sont les plus rapides et les plus fiables.
Le flux de valeur et le temps d'attente
Dans un flux de livraison, l'essentiel du délai est de l'attente (approbations, files d'attente, environnements indisponibles), pas du travail.
efficacité du flux = temps de travail actif / délai total
Une efficacité de 10 à 15 % est courante dans les organisations cloisonnées. Optimiser le travail actif (coder plus vite) apporte peu ; réduire l'attente apporte beaucoup.
Petits lots, grande différence
Loi de Little : pour un système stable, délai moyen = travail en cours ÷ débit. Pour le même débit, moins de travail en cours (lots plus petits) donne un délai plus court. De plus, un petit changement :
- est plus facile à comprendre et à relire ;
- cause des bugs plus faciles à localiser ;
- se retire (rollback) plus facilement ;
- expose moins de personnes et de temps à un risque.
La théorie des contraintes
Une chaîne va à la vitesse de son goulot d'étranglement. Améliorer une étape qui n'est pas le goulot n'accélère pas le tout. On identifie le goulot (la plus longue attente, la file la plus longue), on le traite, puis on cherche le suivant.
Culture sans blâme
Après un incident, on demande « comment le système l'a permis ? » et non « qui a fait l'erreur ? ». Une équipe qui a peur d'être blâmée cache ses erreurs et déploie moins souvent, donc plus gros et plus risqué.
🧠 Astuce : si déployer te fait peur, déploie plus souvent, pas moins. La peur vient de la taille et de la rareté, pas de l'acte.
🔍 Exemple pas à pas
Problème : à partir de l'historique de déploiements de deux équipes, calculer les indicateurs DORA, comparer, puis simuler l'effet de la taille des lots sur le délai.
import statistics
from datetime import datetime, timedelta
def d(s):
return datetime.fromisoformat(s)
# chaque déploiement : (date de mise en production, [dates des commits inclus], échec ?, date de rétablissement si échec)
EQUIPE_A = [ # grosses livraisons mensuelles
(d("2025-01-31 18:00"), [d("2025-01-06 10:00"), d("2025-01-14 15:00"), d("2025-01-22 09:00")], True, d("2025-02-01 14:00")),
(d("2025-02-28 18:00"), [d("2025-02-03 11:00"), d("2025-02-12 16:00"), d("2025-02-20 10:00")], True, d("2025-03-01 20:00")),
(d("2025-03-31 18:00"), [d("2025-03-05 09:00"), d("2025-03-18 14:00"), d("2025-03-27 11:00")], False, None),
]
EQUIPE_B = [ # petites livraisons quotidiennes
(d(f"2025-03-{jour:02d} 15:00"), [d(f"2025-03-{jour:02d} 09:30")], jour == 12, d("2025-03-12 15:40") if jour == 12 else None)
for jour in range(3, 8 + 7)
]
def dora():
delais = [(dep - c).total_seconds() / dep, commits, _, _ deploiements c commits]
echecs = [(dep, retab) dep, _, echec, retab deploiements echec]
{
: (deploiements) / (periode_jours / ),
: statistics.median(delais),
: (echecs) / (deploiements),
: statistics.mean((r - dep).total_seconds() / dep, r echecs) echecs ,
}
nom, equipe, jours ((, EQUIPE_A, ), (, EQUIPE_B, )):
m = dora(equipe, jours)
()
a, b = dora(EQUIPE_A, ), dora(EQUIPE_B, )
b[] > * a[]
b[] < a[] /
b[] < a[] /
():
attente = (taille_lot - ) / / changements_par_jour
attente + duree_deploiement_jours
lot (, , , ):
()
delai_moyen() < delai_moyen() < delai_moyen() < delai_moyen()
Lecture :
- L'équipe B déploie plus de vingt fois plus souvent (6 fois par semaine contre 0,23), avec un délai médian de 5,5 heures contre 16 jours, un taux d'échec de 8 % contre 67 %, et un rétablissement en moins d'une heure contre près d'une journée. La rapidité n'a donc pas été payée par de l'instabilité : les petits changements sont plus faciles à comprendre, à tester et à annuler.
- La simulation de lot illustre la loi de Little : à débit constant, plus le lot est gros, plus chaque changement attend.
Note : sur un petit échantillon, les pourcentages bougent beaucoup ; en vrai on mesure sur des mois.
✍️ À toi, avec aide (10 XP)
Voici un flux de livraison, avec pour chaque étape le temps de travail actif et le temps d'attente (en heures) :
| Étape | Travail | Attente avant |
|---|---|---|
| Revue de code | 1 | 20 |
| Tests manuels | 6 | 48 |
| Approbation du comité | 0,5 | 72 |
| Demande d'environnement | 0,5 | 40 |
| Déploiement | 2 | 8 |
Calcule : le délai total, le temps de travail total, l'efficacité du flux, l'étape qui contribue le plus au délai, et propose ce que tu automatiserais en premier.
💡 Indice 1
Délai total = somme (travail + attente).
💡 Indice 2
Efficacité = travail / délai.
💡 Indice 3
Le plus gros contributeur est souvent une attente, pas un travail.
✅ Réponse
etapes = [("Revue de code", 1, 20), ("Tests manuels", 6, 48), ("Approbation du comité", 0.5, 72), ("Demande d'environnement", 0.5, 40), ("Déploiement", 2, 8)]
travail = sum(t for _, t, _ in etapes)
total = sum(t + a for _, t, a in etapes)
print(f"travail {travail} h, délai {total} h, efficacité {travail / total:.1%}")
pire = max(etapes, key=lambda e: e[1] + e[2])
print("étape la plus longue :", pire[0], pire[1] + pire[2], "h")
assert total == 198 and travail == 10
assert pire[0] == "Approbation du comité"
Délai total : 198 h (≈ 8 jours) pour 10 h de travail actif : d'efficacité. L'étape qui pèse le plus est l' (72,5 h, presque toute en attente). À automatiser d'abord : les (40 h d'attente) et les (48 h), puis remplacer le comité par des portes de qualité automatiques (mission 6).
🚀 À toi, en solo (20 XP)
Simulation de goulot d'étranglement. Modélise une chaîne à 4 étapes (développement, revue, tests, déploiement) où chaque étape a une capacité (changements par jour) : 6, 4, 2, 5. Simule 30 jours avec 5 nouveaux changements par jour :
- suis la file d'attente devant chaque étape ;
- mesure le débit réel de bout en bout et le délai moyen de chaque changement ;
- identifie le goulot ;
- double la capacité d'une étape qui n'est pas le goulot, puis celle du goulot : compare le délai moyen dans les deux cas ;
- explique en 5 lignes pourquoi la première amélioration ne sert à rien.
✅ Pistes de correction
def simuler(capacites, arrivees_par_jour=5, jours=30):
files = [[] for _ in capacites] # chaque élément = jour d'arrivée du changement
termines = []
for jour in range(jours):
files[0].extend([jour] * arrivees_par_jour)
for i, cap in enumerate(capacites):
traites, files[i] = files[i][:cap], files[i][cap:]
if i + 1 < len(capacites):
files[i + 1].extend(traites)
else:
termines.extend((jour - arrivee) for arrivee in traites)
return len(termines) / jours, (sum(termines) / len(termines)) if termines else float("inf"), [len(f) for f in files]
base = (6, 4, 2, 5)
debit, delai, restes = simuler(base)
print(f"base : débit {debit:.1f}/j, délai moyen {delai:.1f} j, en attente ")
hors_goulot = simuler((, , , ))
goulot = simuler((, , , ))
()
()
debit < hors_goulot[] <= debit +
goulot[] > debit goulot[] < delai
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Réduire DevOps à des outils ou à un poste | Les silos restent, seul l'outil change | Responsabilité partagée, objectifs communs, mesures partagées |
| Mesurer la vitesse sans la stabilité | On livre vite des choses cassées | Les quatre indicateurs ensemble |
| Livrer rarement pour être plus sûr | Lots gros et risqués | Petits lots fréquents |
| Chercher un coupable après un incident | Les erreurs sont cachées | Analyse sans blâme centrée sur le système |
🐉 Mini-boss (40 XP)
Diagnostic de livraison de HashBox. À partir d'un historique fictif de 40 déploiements sur 12 semaines (que tu génères avec une graine fixée : dates, commits inclus, échecs, rétablissements) et d'une description du flux (7 étapes avec travail et attente) :
- calcule les quatre indicateurs DORA par mois et trace leur évolution en texte (tableau) ;
- classe l'équipe (élite / haute / moyenne / basse) selon des seuils que tu justifies ;
- fais la cartographie du flux de valeur : efficacité, goulot, 3 gaspillages ;
- propose un plan de 4 changements, estime l'effet de chacun sur le délai avec ta simulation, et ordonne-les par rapport gain/effort ;
- rédige 10 lignes pour convaincre un responsable prudent que livrer plus souvent réduit le risque.
✅ Pistes de correction
Un bon travail : un générateur de déploiements reproductible, des fonctions dora() par fenêtre mensuelle, une cartographie type (revue 20 h d'attente, comité 72 h, etc.), un plan priorisé (environnements à la demande, tests automatisés, remplacement des approbations manuelles par portes de qualité, déploiements quotidiens) avec l'effet simulé de chacun. L'argument final attendu : un petit changement est facile à comprendre, à localiser, à annuler ; la fréquence entraîne l'automatisation et la maîtrise ; les données DORA montrent la corrélation vitesse/stabilité.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. DevOps cherche surtout à :
- A. livrer vite et de façon fiable grâce à une responsabilité partagée
- B. remplacer les développeurs par des administrateurs
- C. supprimer les tests
2. Le délai de livraison (lead time) mesure :
- A. le temps d'exécution du code
- B. le temps entre un commit et sa mise en production
- C. la durée d'une réunion
3. Pour réduire le délai moyen à débit constant, on :
- A. augmente la taille des lots
- B. retarde les déploiements
- C. réduit le travail en cours et la taille des lots
4. 🔁 Révision HEF-110, mission 10 : Un pipeline place en premier :
- A. les étapes rapides et décisives
- B. les étapes les plus longues
- C. les tests E2E
5. 🔁 Révision HEF-110, mission 09 : Un test instable est un test qui :
- A. est très lent
- B. passe ou échoue sur le même code sans modification
- C. n'a pas d'assertion
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Combien de temps s'écoule entre « c'est prêt » et « c'est en production » dans ton équipe ? Où attend-on le plus ?
- Quelle peur freine tes déploiements, et quelle pratique la réduirait ?
🎒 À retenir
- DevOps = culture + automatisation + mesure, responsabilité partagée.
- CALMS et les trois voies : flux, retour, apprentissage.
- DORA : fréquence, délai, taux d'échec, temps de rétablissement.
- L'attente domine le délai ; optimiser le goulot, pas ailleurs.
- Petits lots : plus rapides et moins risqués.
flowchart LR
T(["Culture et flux DevOps"])
T --> R1["1. DevOps = culture + automatisation + mesure, responsabilité partagée."]
T --> R2["2. CALMS et les trois voies : flux, retour, apprentissage."]
T --> R3["3. DORA : fréquence, délai, taux d'échec, temps de rétablissement."]
T --> R4["4. L'attente domine le délai ; optimiser le goulot, pas ailleurs."]
T --> R5["5. Petits lots : plus rapides et moins risqués."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Passeur de pont
Mission 02 — Git et stratégie de collaboration →
HEF-120 — DevOps et livraison

