Pourquoi le DevOps

Point de départ

// ── Un journal de déploiements ────────────────────────────────────────────
// heure en heures depuis le début de l'observation (720 h = un mois).
const JOURNAL_A = [
  { t: 2,   commit: 1,   ok: true },
  { t: 6,   commit: 5,   ok: true },
  { t: 9,   commit: 8.5, ok: false, retabli: 9.7 },
  { t: 14,  commit: 13,  ok: true },
  { t: 20,  commit: 19,  ok: true },
  { t: 26,  commit: 25,  ok: true },
  { t: 31,  commit: 30,  ok: true },
  { t: 38,  commit: 37,  ok: true },
];
const JOURNAL_B = [
  { t: 200, commit: 20,  ok: false, retabli: 380 },
  { t: 500, commit: 260, ok: true },
  { t: 700, commit: 520, ok: false, retabli: 900 },
];

function indicateurs(journal, dureeObservation) {
  const n = journal.length;
  const echecs = journal.filter((d) => !d.ok);
  return {
    frequence: 0,        // ← à écrire : déploiements par semaine
    delai: 0,            // ← à écrire : moyenne de (t − commit), en heures
    tauxEchec: 0,        // ← à écrire : part des déploiements ayant échoué
    retablissement: 0,   // ← à écrire : moyenne de (retabli − t) sur les échecs
  };
}

function classer(i) {
  const note = (v, seuils) => seuils.findIndex((s) => v <= s);
  return "à écrire";     // ← élite / haute / moyenne / faible
}

// ── Simuler l'effet de la TAILLE DES LOTS ─────────────────────────────────
// Une même équipe, un même rythme de travail : 240 modifications par mois.
// Seule varie la fréquence de livraison.
function simuler(modificationsParMois, deploiementsParMois) {
  const parLot = modificationsParMois / deploiementsParMois;
  // Hypothèse empirique : la probabilité qu'un lot casse croît avec sa
  // taille, et le temps de diagnostic aussi — on ne sait pas quelle
  // modification est en cause parmi celles du lot.
  const probaEchec = Math.min(0.9, 1 - Math.pow(0.995, parLot));
  const diagnostic = 0.5 + parLot * 0.15;   // heures
  return { parLot, probaEchec, diagnostic };
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez indicateurs() et classer(), puis comparez les deux équipes.
// 2. Faites varier deploiementsParMois de 1 à 240 : que deviennent le taux
//    d'échec et le temps de rétablissement ?
// 3. Une équipe passe de 4 à 30 déploiements par mois mais son taux d'échec
//    monte de 10 % à 45 %. A-t-elle progressé ?

console.log(JSON.stringify(indicateurs(JOURNAL_A, 720)));

Solution

const JOURNAL_A = [
  { t: 2, commit: 1, ok: true }, { t: 6, commit: 5, ok: true },
  { t: 9, commit: 8.5, ok: false, retabli: 9.7 }, { t: 14, commit: 13, ok: true },
  { t: 20, commit: 19, ok: true }, { t: 26, commit: 25, ok: true },
  { t: 31, commit: 30, ok: true }, { t: 38, commit: 37, ok: true },
];
const JOURNAL_B = [
  { t: 200, commit: 20, ok: false, retabli: 380 },
  { t: 500, commit: 260, ok: true },
  { t: 700, commit: 520, ok: false, retabli: 900 },
];

const moyenne = (t) => t.reduce((s, x) => s + x, 0) / (t.length || 1);

function indicateurs(journal, dureeObservation) {
  const echecs = journal.filter((d) => !d.ok);
  return {
    frequence: (journal.length / dureeObservation) * 168,          // par semaine
    delai: moyenne(journal.map((d) => d.t - d.commit)),            // heures
    tauxEchec: echecs.length / journal.length,
    retablissement: moyenne(echecs.map((d) => d.retabli - d.t)),   // heures
  };
}

function classer(i) {
  // Seuils simplifiés d'après les paliers DORA.
  const niveau = (v, s) => (v <= s[0] ? "élite" : v <= s[1] ? "haute" : v <= s[2] ? "moyenne" : "faible");
  const inverse = (v, s) => (v >= s[0] ? "élite" : v >= s[1] ? "haute" : v >= s[2] ? "moyenne" : "faible");
  return {
    frequence: inverse(i.frequence, [7, 1, 0.25]),
    delai: niveau(i.delai, [1, 24, 168]),
    tauxEchec: niveau(i.tauxEchec, [0.15, 0.3, 0.45]),
    retablissement: niveau(i.retablissement, [1, 24, 168]),
  };
}

console.log("— 1. deux équipes, un mois d'observation —");
for (const [nom, j] of [["équipe A", JOURNAL_A], ["équipe B", JOURNAL_B]]) {
  const i = indicateurs(j, 720), c = classer(i);
  console.log("   " + nom);
  console.log("      fréquence      " + i.frequence.toFixed(1).padStart(6) + " /semaine   " + c.frequence);
  console.log("      délai          " + i.delai.toFixed(1).padStart(6) + " h          " + c.delai);
  console.log("      taux d'échec   " + (i.tauxEchec * 100).toFixed(0).padStart(6) + " %          " + c.tauxEchec);
  console.log("      rétablissement " + i.retablissement.toFixed(1).padStart(6) + " h          " + c.retablissement);
}
console.log("   L'équipe A n'est pas « meilleure » : elle a un FLUX différent, et");
console.log("   les quatre indicateurs basculent ENSEMBLE. C'est le point à vérifier.");

console.log("");
console.log("— 2. la taille des lots explique tout —");
function simuler(modificationsParMois, deploiementsParMois) {
  const parLot = modificationsParMois / deploiementsParMois;
  const probaEchec = Math.min(0.9, 1 - Math.pow(0.995, parLot));
  const diagnostic = 0.5 + parLot * 0.15;
  return { parLot, probaEchec, diagnostic };
}
console.log("   déploiements/mois | modifs/lot | taux d'échec | rétablissement");
for (const d of [1, 2, 4, 12, 30, 120, 240]) {
  const s = simuler(240, d);
  console.log("   " + String(d).padStart(17) + " | " + String(s.parLot).padStart(10) +
    " | " + (s.probaEchec * 100).toFixed(0).padStart(11) + " %" +
    " | " + s.diagnostic.toFixed(1).padStart(11) + " h");
}
console.log("   Même équipe, même volume de travail, même rythme de frappe : on n'a");
console.log("   changé QUE la fréquence de livraison, et les deux indicateurs de");
console.log("   STABILITÉ suivent la vitesse. Le compromis supposé entre les deux");
console.log("   n'existe pas — c'est l'accumulation en gros lots qui produit à la");
console.log("   fois la lenteur et l'instabilité.");

console.log("");
console.log("— 3. le piège de mesure —");
const avant = { frequence: 4 / 4.3, delai: 300, tauxEchec: 0.10, retablissement: 40 };
const apres = { frequence: 30 / 4.3, delai: 40, tauxEchec: 0.45, retablissement: 40 };
for (const [nom, i] of [["avant", avant], ["après", apres]]) {
  const c = classer(i);
  console.log("   " + nom + " : fréquence " + c.frequence.padEnd(8) +
    " | délai " + c.delai.padEnd(8) + " | échec " + c.tauxEchec);
}
console.log("   La vitesse a bondi, la stabilité s'est effondrée : l'équipe a");
console.log("   déplacé le problème, pas amélioré son flux. Les quatre indicateurs");
console.log("   se lisent ENSEMBLE, jamais un seul — et jamais pour évaluer");
console.log("   quelqu'un, sous peine de les rendre immédiatement inutiles.");

Avant de commencer

• Git installé, et un dépôt public actif de votre choix cloné en local
• Un tableur ou un langage de script pour les calculs

Énoncé

1. Extraire l'historique des livraisons — Clonez un dépôt public qui publie des versions étiquetées, et sortez la liste de ses étiquettes avec leur date. Vous voulez une ligne par livraison. Indice : git tag --sort=creatordate --format='%(creatordate:short) %(refname:short)' donne exactement cela.
2. Calculer la fréquence de déploiement — Sur les six derniers mois, combien de livraisons par semaine ? Situez le résultat dans les paliers du cours : élite, haute, moyenne, faible.
3. Calculer le délai de livraison — Pour cinq étiquettes prises au hasard, mesurez l'écart entre la date du commit le plus ancien qu'elles contiennent et la date de l'étiquette. C'est une approximation du délai entre l'écriture et la mise à disposition. Indice : git log --format=%ci v1.2.0..v1.3.0 | tail -1 donne la date du premier commit de l'intervalle.
4. Estimer les deux indicateurs de stabilité — Cherchez les versions correctives publiées moins de 48 h après une version : ce sont vos candidats « échec de changement ». Le délai entre les deux approxime le temps de rétablissement.
5. Rédiger un post-mortem — À partir de l'incident fourni ci-dessous, écrivez un compte rendu en cinq parties. INCIDENT : le 14 mars à 10 h 04, un déploiement fait passer le taux d'erreur de 0,1 % à 4 %. L'alerte part à 10 h 31. La cause est comprise à 10 h 44 : une migration a renommé une colonne, et l'ancienne version des travailleurs de fond, non redéployée, échouait. Retour arrière à 10 h 46 — sans effet, la colonne étant déjà renommée. Correctif appliqué à 11 h 20. Indice : Les cinq parties : ce qui s'est passé, la chronologie, l'impact MESURÉ, pourquoi c'était possible, et les actions avec responsable et échéance.

C'est réussi quand

• ✓ Vos quatre indicateurs sont chiffrés, et vous savez dire dans quel palier se situe le dépôt
• ✓ Votre post-mortem ne nomme personne
• ✓ Chacune de vos actions correctives est vérifiable et porte une échéance

Correction

git tag --sort=creatordate \
--format='%(creatordate:short) %(refname:short)' | tail -40

# Délai de livraison pour une étiquette donnée
git log --format=%ci v1.2.0..v1.3.0 | tail -1   # premier commit
git log -1 --format=%ci v1.3.0                   # publication