Livraison et déploiement continus

Point de départ

// ── 1. Quatre stratégies face au même bogue ───────────────────────────────
const TRAFIC = 1000;          // requêtes par minute
const TAUX_ERREUR = 0.30;     // 30 % des requêtes servies par v2 échouent

// paliers : [part du trafic, durée du palier en minutes]
const STRATEGIES = {
  "recréation":  { paliers: [[1.0, Infinity]], interruption: 2, retour: 8 },
  "bleu-vert":   { paliers: [[1.0, Infinity]], interruption: 0, retour: 0.2 },
  "progressif":  { paliers: [[0.2, 2], [0.4, 2], [0.6, 2], [0.8, 2], [1.0, Infinity]],
                   interruption: 0, retour: 3 },
  "canari":      { paliers: [[0.05, 10], [0.25, 10], [0.5, 10], [1.0, Infinity]],
                   interruption: 0, retour: 0.2 },
};

// detection : combien de minutes avant que quelqu'un s'en aperçoive.
function impact(strategie, detection) {
  let t = 0, requetesRatees = 0;
  for (const [part, duree] of strategie.paliers) {
    const restant = detection - t;
    if (restant <= 0) break;
    const passe = Math.min(duree, restant);
    // ← à écrire : requêtes ratées pendant ce palier
    t += passe;
  }
  // Puis le retour arrière, pendant lequel la part courante continue.
  return { requetesRatees: Math.round(requetesRatees), duree: detection + strategie.retour };
}

// ── 2. Migration de base et retour arrière ────────────────────────────────
// Un schéma, deux versions de code, et la question : peut-on revenir ?
const SCHEMA = { colonnes: ["id", "nom_complet"] };

const MIGRATION_DESTRUCTIVE = [
  { nom: "v2 : renommer nom_complet en nom", appliquer: (s) => ({
      colonnes: s.colonnes.map((c) => (c === "nom_complet" ? "nom" : c)) }) },
];

const CODE = {
  v1: { lit: ["id", "nom_complet"], ecrit: ["nom_complet"] },
  v2: { lit: ["id", "nom"],         ecrit: ["nom"] },
};

function peutTourner(version, schema) {
  const besoins = [...CODE[version].lit, ...CODE[version].ecrit];
  return besoins.every((c) => schema.colonnes.includes(c));
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez impact(). Comparez les quatre stratégies avec une détection à
//    2 min (supervision), puis à 45 min (une plainte utilisateur).
// 2. Appliquez la migration destructive, déployez v2, puis tentez le retour
//    à v1 : que se passe-t-il ?
// 3. Réécrivez la migration en TROIS étapes compatibles en avant, et
//    vérifiez qu'après chacune, les DEUX versions peuvent tourner.

console.log(JSON.stringify(impact(STRATEGIES["canari"], 2)));

Solution

const TRAFIC = 1000;
const TAUX_ERREUR = 0.30;

const STRATEGIES = {
  "recréation":  { paliers: [[1.0, Infinity]], interruption: 2, retour: 8 },
  "bleu-vert":   { paliers: [[1.0, Infinity]], interruption: 0, retour: 0.2 },
  "progressif":  { paliers: [[0.2, 2], [0.4, 2], [0.6, 2], [0.8, 2], [1.0, Infinity]],
                   interruption: 0, retour: 3 },
  "canari":      { paliers: [[0.05, 10], [0.25, 10], [0.5, 10], [1.0, Infinity]],
                   interruption: 0, retour: 0.2 },
};

function impact(strategie, detection) {
  let t = 0, requetesRatees = 0, partCourante = 0;
  for (const [part, duree] of strategie.paliers) {
    const restant = detection - t;
    if (restant <= 0) break;
    const passe = Math.min(duree, restant);
    partCourante = part;
    // Seule la fraction du trafic servie par la nouvelle version échoue.
    requetesRatees += TRAFIC * part * TAUX_ERREUR * passe;
    t += passe;
  }
  // Pendant le retour arrière, la part courante continue d'échouer.
  requetesRatees += TRAFIC * partCourante * TAUX_ERREUR * strategie.retour;
  // L'interruption de service, elle, rate TOUT le trafic.
  requetesRatees += TRAFIC * strategie.interruption;
  return { requetesRatees: Math.round(requetesRatees), duree: detection + strategie.retour,
           exposition: partCourante };
}

console.log("— 1. même bogue, quatre stratégies —");
for (const detection of [2, 45]) {
  console.log("   détection après " + detection + " min " +
    (detection === 2 ? "(supervision et seuil automatique)" : "(une plainte utilisateur)"));
  const lignes = Object.entries(STRATEGIES).map(([nom, s]) => ({ nom, ...impact(s, detection) }));
  lignes.sort((a, b) => a.requetesRatees - b.requetesRatees);
  for (const l of lignes) {
    console.log("      " + l.nom.padEnd(12) +
      String(l.requetesRatees).padStart(7) + " requêtes ratées" +
      " | exposition " + (l.exposition * 100).toFixed(0).padStart(3) + " %" +
      " | incident " + l.duree.toFixed(1) + " min");
  }
  console.log("");
}
console.log("   Le classement CHANGE avec le délai de détection. Avec supervision,");
console.log("   le canari est de loin le meilleur : il n'a exposé que 5 % du trafic.");
console.log("   Sans supervision, il a eu le temps de monter à 100 % avant qu'on ne");
console.log("   s'en aperçoive, et il ne vaut plus mieux que le bleu-vert.");
console.log("   Conclusion : le canari sans mesure est un canari décoratif — c'est");
console.log("   ce que le chapitre 10 vient compléter.");

console.log("");
console.log("— 2. migration destructive et retour arrière —");
const CODE = {
  v1: { lit: ["id", "nom_complet"], ecrit: ["nom_complet"] },
  v2: { lit: ["id", "nom"],         ecrit: ["nom"] },
};
function peutTourner(version, schema) {
  const besoins = [...CODE[version].lit, ...CODE[version].ecrit];
  return besoins.every((c) => schema.colonnes.includes(c));
}
function etat(etiquette, schema) {
  console.log("      " + etiquette.padEnd(38) + "colonnes [" + schema.colonnes.join(", ") + "]" +
    "  v1 " + (peutTourner("v1", schema) ? "ok " : "KO ") +
    "  v2 " + (peutTourner("v2", schema) ? "ok" : "KO"));
}
let schema = { colonnes: ["id", "nom_complet"] };
etat("départ", schema);
schema = { colonnes: schema.colonnes.map((c) => (c === "nom_complet" ? "nom" : c)) };
etat("après le renommage destructif", schema);
console.log("      → v2 tourne, mais le RETOUR À v1 EST IMPOSSIBLE : la colonne");
console.log("        dont elle a besoin n'existe plus. Le code revient en arrière,");
console.log("        les données non.");

console.log("");
console.log("— 3. la même migration, compatible en avant —");
let s2 = { colonnes: ["id", "nom_complet"] };
etat("départ", s2);
// Étape 1 : AJOUTER, sans rien retirer. Les deux colonnes coexistent.
s2 = { colonnes: [...s2.colonnes, "nom"] };
etat("étape 1 : ajouter nom, écrire dans les deux", s2);
// Étape 2 : déployer v2, qui lit la nouvelle colonne. v1 tourne toujours.
etat("étape 2 : déployer v2", s2);
console.log("      → à cet instant, LES DEUX versions fonctionnent : le retour");
console.log("        arrière reste possible à tout moment.");
// Étape 3 : seulement quand le retour arrière n'est plus envisagé.
s2 = { colonnes: s2.colonnes.filter((c) => c !== "nom_complet") };
etat("étape 3 : supprimer nom_complet (plus tard)", s2);
console.log("      → v1 n'est plus déployable, mais on ne l'envisage plus depuis");
console.log("        plusieurs jours. La règle : JAMAIS de suppression ni de");
console.log("        renommage dans le même déploiement que le code qui en dépend.");

Avant de commencer

• L'image publiée par le pipeline du TP 5, étiquetée par empreinte de commit
• La pile Compose du TP 4
• Un outil de charge simple (ab, hey, ou une boucle curl)

Énoncé

1. Monter le routage — Placez un répartiteur devant l'application. Faites tourner DEUX exemplaires de la pile, en version 1.0, et vérifiez que le trafic se répartit sur les deux. Indice : Un nginx en amont, avec un bloc upstream, suffit — inutile de sortir l'artillerie.
2. Déployer en bleu-vert — Construisez une version 1.1, déployez-la à côté sans lui envoyer de trafic, testez-la directement, puis basculez le routage d'un coup. Chronométrez la bascule et le retour arrière.
3. Fabriquer un bogue — Produisez une version 1.2 qui renvoie une erreur sur 30 % des requêtes. Déployez-la en bleu-vert pendant qu'une charge tourne, et comptez les requêtes en erreur avant que vous ne réagissiez.
4. Recommencer en canari — Même version fautive, mais en n'envoyant d'abord que 5 % du trafic, puis 25 %. Comptez à nouveau les requêtes en erreur, et comparez à l'étape précédente. Indice : Des poids sur les entrées du bloc upstream suffisent à répartir 5 / 95.
5. Décider automatiquement — Écrivez un script qui interroge le taux d'erreur toutes les dix secondes et déclenche le retour arrière au-delà d'un seuil que vous fixez d'avance. Relancez le scénario sans intervenir.
6. La migration destructive — Version 1.3 : renommez une colonne de la base et adaptez le code. Déployez, puis tentez un retour arrière vers 1.2. Constatez ce qui se passe.
7. La migration en trois étapes — Refaites la même évolution en la découpant, de sorte qu'à chaque étape les DEUX versions puissent tourner. Vérifiez le retour arrière après chacune.

C'est réussi quand

• ✓ Le retour arrière prend moins de cinq secondes et ne reconstruit rien
• ✓ Le canari expose au moins quatre fois moins de requêtes que le bleu-vert sur le même bogue
• ✓ Le script déclenche le retour arrière sans vous
• ✓ Après chaque étape de la migration découpée, l'ancienne version démarre encore

Correction

upstream tickets {
  server appli_bleu:3000  weight=95;
  server appli_vert:3000  weight=5;   # le canari
}

server {
  listen 80;
  location / {
      proxy_pass http://tickets;
      proxy_next_upstream off;   # ne pas masquer les erreurs du canari
  }
}

bleu-vert, réaction humaine à 4 min : ~21 600 requêtes en erreur
canari 5 % puis 25 %, même bogue     :  ~5 400 requêtes en erreur
canari + seuil automatique à 20 s    :    ~300 requêtes en erreur

#!/bin/sh
SEUIL=2          # % d'erreurs toléré, décidé À L'AVANCE
while true; do
taux=$(curl -s http://localhost/metriques | awk '/taux_erreur/ {print $2}')
echo "taux = $taux %"
if [ "$(echo "$taux > $SEUIL" | bc)" -eq 1 ]; then
  echo "seuil dépassé : retour arrière"
  sed -i 's/weight=5/weight=0/' nginx.conf
  docker compose exec -T proxy nginx -s reload
  exit 1
fi
sleep 10
done

-- 1.3 : migration destructive
ALTER TABLE tickets RENAME COLUMN titre TO intitule;

-- l'ancienne version cherche « titre », qui n'existe plus
-- ERROR: column "titre" does not exist

-- étape 1 : AJOUTER, sans rien retirer
ALTER TABLE tickets ADD COLUMN intitule text;
UPDATE tickets SET intitule = titre;
-- le code 1.2 écrit dans « titre », un déclencheur recopie dans « intitule »

-- étape 2 : déployer 1.3, qui LIT « intitule » et écrit dans les DEUX
--           → à cet instant, 1.2 et 1.3 fonctionnent toutes deux

-- étape 3 : plusieurs jours plus tard, quand le retour arrière
--           n'est plus envisagé
ALTER TABLE tickets DROP COLUMN titre;