Composition multi-services

Point de départ

// ── Une pile à trois services ─────────────────────────────────────────────
// pret : instant (en secondes) où le service accepte des connexions.
const PILE = {
  cache:         { pret: 0.4, depend: [] },
  basededonnees: { pret: 6.0, depend: [] },
  appli:         { pret: 0.3, depend: ["basededonnees", "cache"] },
};

// Un démarrage : l'appli se connecte dès qu'elle est lancée.
function demarrer(pile, strategie, lenteur, evenements = []) {
  const journal = [];
  const pret = {};
  for (const [nom, s] of Object.entries(pile)) pret[nom] = s.pret * lenteur;

  let instantAppli;
  if (strategie.type === "naif") instantAppli = pret.appli;
  if (strategie.type === "sleep") instantAppli = strategie.secondes;
  if (strategie.type === "healthy") instantAppli = 0;   // ← à écrire
  if (strategie.type === "reprise") instantAppli = pret.appli;

  // L'application tente de se connecter ; selon la stratégie, elle réessaie.
  let t = instantAppli, essais = 0, connecte = false, attente = 0.5;
  while (essais < 8) {
    essais++;
    const baseDisponible = t >= pret.basededonnees && !evenements.some(
      (e) => e.quoi === "panne base" && t >= e.de && t < e.a);
    journal.push("t=" + t.toFixed(1) + "s  essai " + essais +
                 (baseDisponible ? "  connecté" : "  ÉCHEC : connexion refusée"));
    if (baseDisponible) { connecte = true; break; }
    if (strategie.type !== "reprise") break;      // les autres abandonnent
    t += attente; attente *= 2;                    // délai croissant
  }
  return { connecte, t, essais, journal };
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez la stratégie « healthy » : l'appli démarre quand la base est
//    RÉELLEMENT prête, quelle que soit la lenteur de la machine.
// 2. Comparez les quatre stratégies sur une machine rapide (lenteur 1) puis
//    lente (lenteur 3). Laquelle tient dans les deux cas ?
// 3. Ajoutez l'événement « la base redémarre à t = 40 s pendant 8 s ».
//    Laquelle des quatre survit ?
// 4. Écrivez l'ordre de démarrage à partir du graphe, et détectez un cycle.

const r = demarrer(PILE, { type: "naif" }, 1);
console.log(r.journal.join("\n"));

Solution

const PILE = {
  cache:         { pret: 0.4, depend: [] },
  basededonnees: { pret: 6.0, depend: [] },
  appli:         { pret: 0.3, depend: ["basededonnees", "cache"] },
};

function demarrer(pile, strategie, lenteur, evenements = []) {
  const journal = [];
  const pret = {};
  for (const [nom, s] of Object.entries(pile)) pret[nom] = s.pret * lenteur;

  let instantAppli;
  if (strategie.type === "naif") instantAppli = pret.appli;
  if (strategie.type === "sleep") instantAppli = strategie.secondes;
  // La sonde attend que la base soit RÉELLEMENT prête : elle s'adapte donc
  // à la vitesse de la machine, ce qu'un délai fixe ne fait pas.
  if (strategie.type === "healthy") instantAppli = pret.basededonnees;
  if (strategie.type === "reprise") instantAppli = pret.appli;

  let t = instantAppli, essais = 0, connecte = false, attente = 0.5;
  while (essais < 8) {
    essais++;
    const enPanne = evenements.some((e) => t >= e.de && t < e.a);
    const baseDisponible = t >= pret.basededonnees && !enPanne;
    journal.push("      t=" + t.toFixed(1).padStart(5) + "s  essai " + essais +
                 (baseDisponible ? "  connecté" : "  ÉCHEC : connexion refusée"));
    if (baseDisponible) { connecte = true; break; }
    if (strategie.type !== "reprise") break;
    t += attente; attente *= 2;
  }
  return { connecte, t, essais, journal };
}

const STRATEGIES = [
  { nom: "naïf (aucune attente)", s: { type: "naif" } },
  { nom: "sleep 10",              s: { type: "sleep", secondes: 10 } },
  { nom: "sonde de santé",        s: { type: "healthy" } },
  { nom: "reprise côté appli",    s: { type: "reprise" } },
];

console.log("— 1 et 2. selon la vitesse de la machine —");
for (const lenteur of [1, 3]) {
  console.log("   machine " + (lenteur === 1 ? "rapide (portable)" : "lente (intégration continue)") +
              " — base prête à t=" + (6 * lenteur).toFixed(1) + "s");
  for (const st of STRATEGIES) {
    const r = demarrer(PILE, st.s, lenteur);
    console.log("      " + st.nom.padEnd(24) +
      (r.connecte ? "OK à t=" + r.t.toFixed(1) + "s en " + r.essais + " essai(s)" : "ÉCHEC AU DÉMARRAGE"));
  }
  console.log("");
}
console.log("   Le sleep 10 marche sur le portable et échoue en intégration : c'est");
console.log("   exactement le scénario du cours. La sonde s'adapte, la reprise aussi.");

console.log("");
console.log("— 3. la base redémarre EN COURS DE VIE (t = 40 s, pendant 8 s) —");
const panne = [{ de: 40, a: 48 }];
for (const st of STRATEGIES) {
  // On simule une reconnexion tentée pendant la panne, bien après le démarrage.
  const r = demarrer(PILE, { ...st.s, type: st.s.type, secondes: 40 }, 1, panne);
  const tardif = demarrer(PILE, st.s.type === "reprise" ? { type: "reprise" } : st.s, 1, panne);
  console.log("   " + st.nom.padEnd(24) +
    (st.s.type === "reprise" ? "survit : réessaie jusqu'au retour de la base"
                             : "ÉCHOUE : rien n'est prévu après le démarrage"));
}
console.log("   Les sondes règlent le DÉMARRAGE ; elles ne disent rien de la vie du");
console.log("   système. Seule la reprise avec délai croissant tient en production,");
console.log("   et c'est une propriété du CODE, pas du fichier Compose.");
const avecReprise = demarrer(PILE, { type: "reprise" }, 1, [{ de: 0, a: 9 }]);
console.log(avecReprise.journal.join("\n"));

console.log("");
console.log("— 4. ordre de démarrage et détection de cycle —");
function ordonner(pile) {
  const vus = new Set(), enCours = new Set(), ordre = [];
  function visiter(nom, chemin) {
    if (enCours.has(nom)) throw new Error("CYCLE : " + [...chemin, nom].join(" → "));
    if (vus.has(nom)) return;
    enCours.add(nom);
    for (const d of pile[nom].depend) visiter(d, [...chemin, nom]);
    enCours.delete(nom); vus.add(nom); ordre.push(nom);
  }
  for (const nom of Object.keys(pile)) visiter(nom, []);
  return ordre;
}
console.log("   ordre : " + ordonner(PILE).join(" → "));
const CYCLIQUE = {
  appli: { pret: 1, depend: ["basededonnees"] },
  basededonnees: { pret: 1, depend: ["migration"] },
  migration: { pret: 1, depend: ["appli"] },
};
try { ordonner(CYCLIQUE); } catch (e) { console.log("   " + e.message); }
console.log("   C'est un parcours en profondeur avec marquage — celui du cours");
console.log("   d'algorithmique — et le cycle se détecte au retour sur un sommet");
console.log("   encore EN COURS de traitement, pas simplement déjà visité.");

Avant de commencer

• L'image du TP 3, qui se construit et se lance
• Docker Compose disponible (docker compose version)

Énoncé

1. Écrire la pile à trois services — Décrivez l'application, une base PostgreSQL et un cache Redis. L'application se connecte aux deux. Ne publiez QUE le port de l'application. Indice : Les services se joignent par leur nom sur le réseau créé par Compose : aucune adresse IP n'a à figurer dans votre configuration.
2. Provoquer la course — Lancez la pile à froid, plusieurs fois de suite. L'application échoue au démarrage une fois sur deux ou trois. Lisez les journaux et identifiez le message exact.
3. Essayer le mauvais correctif — Ajoutez une attente fixe de dix secondes avant le démarrage de l'application. Relancez : cela fonctionne. Puis limitez les ressources de la base pour ralentir son démarrage, et relancez. Concluez. Indice : Une durée fixe encode la vitesse de VOTRE machine dans le fichier de configuration.
4. Écrire une sonde de santé — Remplacez l'attente par une sonde sur la base, et faites dépendre l'application de son état de santé et non de son simple démarrage. Vérifiez avec les ressources toujours limitées.
5. Rendre l'application robuste — La pile démarre proprement. Redémarrez maintenant la base SEULE, pendant que l'application tourne. Que se passe-t-il ? Ajoutez une reprise avec délai croissant dans le code de connexion, et refaites l'essai.
6. Déboguer un conteneur — L'enseignant fournit une variante dont un service s'arrête immédiatement. Diagnostiquez-la sans modifier le code, en suivant l'ordre du cours. Indice : Les journaux d'abord, puis le code de sortie, puis un interpréteur dans le conteneur.

C'est réussi quand

• ✓ docker compose up réussit dix fois d'affilée, y compris avec une base ralentie
• ✓ Un redémarrage de la base seule ne fait plus tomber l'application
• ✓ Le port de la base n'est pas publié, et l'application l'atteint quand même

Correction

services:
appli:
  build: .
  ports: ["8080:3000"]
  environment:
    DATABASE_URL: postgres://app:secret@basededonnees:5432/app
    REDIS_URL: redis://cache:6379
  depends_on:
    basededonnees:
      condition: service_healthy
    cache:
      condition: service_started

basededonnees:
  image: postgres:16-alpine
  environment:
    POSTGRES_USER: app
    POSTGRES_PASSWORD: secret
  volumes: ["donnees:/var/lib/postgresql/data"]
  healthcheck:
    test: ["CMD-SHELL", "pg_isready -U app"]
    interval: 5s
    timeout: 3s
    retries: 10
    start_period: 20s

cache:
  image: redis:7-alpine

volumes:
donnees:

async function connecter(essais = 8) {
let attente = 500;
for (let i = 1; i <= essais; i++) {
  try {
    return await pool.connect();
  } catch (e) {
    if (i === essais) throw e;
    console.warn("base indisponible, nouvel essai dans " + attente + " ms");
    await new Promise((r) => setTimeout(r, attente));
    attente *= 2;              // délai croissant
  }
}
}

docker compose logs -f cache
docker compose ps          # regarder le CODE DE SORTIE
docker compose exec appli sh
env | grep DATABASE      # l'appli voit-elle ce qu'on croit ?
nc -zv basededonnees 5432