Point de départ

// ── 1. Le cache de couches ────────────────────────────────────────────────
// Chaque instruction : ce dont elle DÉPEND, et ce qu'elle coûte en secondes.
const NAIF = [
  { instr: "FROM node:20",            depend: [],                 cout: 0 },
  { instr: "WORKDIR /app",            depend: [],                 cout: 0 },
  { instr: "COPY . .",                depend: ["*"],              cout: 2 },
  { instr: "RUN npm ci",              depend: [],                 cout: 95 },
  { instr: "RUN npm run build",       depend: [],                 cout: 40 },
  { instr: "CMD node dist/serveur.js", depend: [],                cout: 0 },
];

const OPTIMISE = [
  { instr: "FROM node:20",            depend: [],                       cout: 0 },
  { instr: "WORKDIR /app",            depend: [],                       cout: 0 },
  { instr: "COPY package*.json ./",   depend: ["package.json"],         cout: 1 },
  { instr: "RUN npm ci",              depend: [],                       cout: 95 },
  { instr: "COPY . .",                depend: ["*"],                    cout: 2 },
  { instr: "RUN npm run build",       depend: [],                       cout: 40 },
  { instr: "CMD node dist/serveur.js", depend: [],                      cout: 0 },
];

// modifies : la liste des fichiers changés depuis la dernière construction.
function construire(nom, dockerfile, modifies) {
  let invalide = false;   // une fois invalidé, TOUT ce qui suit l'est aussi
  let total = 0;
  const detail = [];
  for (const c of dockerfile) {
    const touche = c.depend.some((d) => d === "*" ? modifies.length > 0 : modifies.includes(d));
    // ← à écrire : dès qu'une couche est touchée, elle et toutes les
    //   suivantes sont reconstruites. Sinon, cache réutilisé.
    detail.push(c.instr.padEnd(28) + "cache");
  }
  console.log("   " + nom + "  (" + total + " s)");
  for (const d of detail) console.log("      " + d);
  return total;
}

// ── 2. Construction en plusieurs étapes ───────────────────────────────────
const ETAPES = {
  monoEtape: [
    { nom: "node:20 (base complète)", mo: 1100 },
    { nom: "outils de compilation",   mo: 180 },
    { nom: "node_modules (dev inclus)", mo: 340 },
    { nom: "code source + .git",      mo: 45 },
    { nom: "artefact construit",      mo: 12 },
  ],
  finale: [
    { nom: "node:20-alpine",          mo: 55 },
    { nom: "node_modules (prod)",     mo: 58 },
    { nom: "artefact construit",      mo: 12 },
  ],
};

// ── 3. Revue de Dockerfile ────────────────────────────────────────────────
const A_RELIRE = {
  A: ["FROM node:latest", "COPY . .", "RUN npm ci", "CMD node serveur.js"],
  B: ["FROM node:20-alpine", "ENV API_TOKEN=sk-prod-8f3a91", "COPY . .", "CMD node serveur.js"],
  C: ["FROM node:20-alpine", "COPY package*.json ./", "RUN npm ci", "COPY . .",
      "CMD node serveur.js"],
  D: ["FROM node:20-alpine", "COPY package*.json ./", "RUN npm ci", "COPY . .",
      "USER node", "CMD node serveur.js"],
};

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez construire(), avec l'invalidation en cascade. Comparez les deux
//    Dockerfile sur deux scénarios : une ligne de code modifiée, puis une
//    dépendance ajoutée.
// 2. Calculez les deux tailles d'image et ce que la mono-étape embarque en
//    pur superflu.
// 3. Relisez les quatre Dockerfile : chacun a une faute (sauf un).

construire("naïf", NAIF, ["src/serveur.js"]);

Solution

const NAIF = [
  { instr: "FROM node:20", depend: [], cout: 0 },
  { instr: "WORKDIR /app", depend: [], cout: 0 },
  { instr: "COPY . .", depend: ["*"], cout: 2 },
  { instr: "RUN npm ci", depend: [], cout: 95 },
  { instr: "RUN npm run build", depend: [], cout: 40 },
  { instr: "CMD node dist/serveur.js", depend: [], cout: 0 },
];
const OPTIMISE = [
  { instr: "FROM node:20", depend: [], cout: 0 },
  { instr: "WORKDIR /app", depend: [], cout: 0 },
  { instr: "COPY package*.json ./", depend: ["package.json"], cout: 1 },
  { instr: "RUN npm ci", depend: [], cout: 95 },
  { instr: "COPY . .", depend: ["*"], cout: 2 },
  { instr: "RUN npm run build", depend: [], cout: 40 },
  { instr: "CMD node dist/serveur.js", depend: [], cout: 0 },
];

function construire(nom, dockerfile, modifies, silencieux) {
  let invalide = false, total = 0;
  const detail = [];
  for (const c of dockerfile) {
    const touche = c.depend.some((d) => (d === "*" ? modifies.length > 0 : modifies.includes(d)));
    // LA règle : une fois qu'une couche est invalidée, toutes les suivantes
    // le sont aussi, qu'elles dépendent ou non des fichiers modifiés.
    if (touche) invalide = true;
    if (invalide) { total += c.cout; detail.push(c.instr.padEnd(28) + "RECONSTRUITE  (" + c.cout + " s)"); }
    else detail.push(c.instr.padEnd(28) + "cache");
  }
  if (!silencieux) {
    console.log("   " + nom.padEnd(34) + total + " s");
    for (const d of detail) console.log("      " + d);
  }
  return total;
}

console.log("— 1. modifier UNE LIGNE de code —");
const a1 = construire("Dockerfile naïf", NAIF, ["src/serveur.js"]);
const b1 = construire("Dockerfile optimisé", OPTIMISE, ["src/serveur.js"]);
console.log("   rapport : " + (a1 / b1).toFixed(1) + " fois plus long pour le naïf.");
console.log("   L'installation des dépendances a été refaite alors que rien n'avait");
console.log("   changé de ce côté : c'est l'invalidation EN CASCADE.");

console.log("");
console.log("— ajouter une dépendance —");
const a2 = construire("Dockerfile naïf", NAIF, ["package.json"], true);
const b2 = construire("Dockerfile optimisé", OPTIMISE, ["package.json"], true);
console.log("   naïf " + a2 + " s | optimisé " + b2 + " s — là, les deux reconstruisent :");
console.log("   c'est normal, les dépendances ont réellement changé.");

console.log("");
console.log("— sur vingt constructions par jour, dont 18 pour du code seul —");
const parJourNaif = 18 * a1 + 2 * a2;
const parJourOpt = 18 * b1 + 2 * b2;
console.log("   naïf     : " + Math.round(parJourNaif / 60) + " min/jour d'attente");
console.log("   optimisé : " + Math.round(parJourOpt / 60) + " min/jour");
console.log("   Deux lignes déplacées dans le Dockerfile.");

console.log("");
console.log("— 2. construction en plusieurs étapes —");
const ETAPES = {
  monoEtape: [
    { nom: "node:20 (base complète)", mo: 1100 }, { nom: "outils de compilation", mo: 180 },
    { nom: "node_modules (dev inclus)", mo: 340 }, { nom: "code source + .git", mo: 45 },
    { nom: "artefact construit", mo: 12 },
  ],
  finale: [
    { nom: "node:20-alpine", mo: 55 }, { nom: "node_modules (prod)", mo: 58 },
    { nom: "artefact construit", mo: 12 },
  ],
};
const somme = (t) => t.reduce((s, x) => s + x.mo, 0);
const mono = somme(ETAPES.monoEtape), fin = somme(ETAPES.finale);
console.log("   mono-étape : " + mono + " Mo");
for (const c of ETAPES.monoEtape) console.log("      " + String(c.mo).padStart(5) + " Mo  " + c.nom);
console.log("   finale     : " + fin + " Mo   (" + (mono / fin).toFixed(1) + " fois plus petite)");
console.log("   Superflu embarqué par la mono-étape : " + (mono - fin) + " Mo — dont les");
console.log("   outils de compilation et le .git, qui sont aussi de la surface d'attaque.");

console.log("");
console.log("— 3. revue de Dockerfile —");
const A_RELIRE = {
  A: ["FROM node:latest", "COPY . .", "RUN npm ci", "CMD node serveur.js"],
  B: ["FROM node:20-alpine", "ENV API_TOKEN=sk-prod-8f3a91", "COPY . .", "CMD node serveur.js"],
  C: ["FROM node:20-alpine", "COPY package*.json ./", "RUN npm ci", "COPY . .", "CMD node serveur.js"],
  D: ["FROM node:20-alpine", "COPY package*.json ./", "RUN npm ci", "COPY . .", "USER node",
      "CMD node serveur.js"],
};
function relire(lignes) {
  const f = [];
  if (lignes.some((l) => /:latest/.test(l))) f.push("étiquette latest : la base change sous vos pieds");
  if (lignes.some((l) => /ENV .*(TOKEN|SECRET|PASSWORD|KEY)=/i.test(l)))
    f.push("SECRET dans l'image : il reste dans l'historique des couches, à jamais");
  const iCopieTout = lignes.findIndex((l) => /^COPY \. \./.test(l));
  const iInstall = lignes.findIndex((l) => /npm ci/.test(l));
  if (iCopieTout !== -1 && iInstall !== -1 && iCopieTout < iInstall)
    f.push("COPY . . avant l'installation : cache invalidé à chaque commit");
  if (!lignes.some((l) => /^USER /.test(l))) f.push("aucun USER : le processus tourne en root");
  return f;
}
for (const [nom, lignes] of Object.entries(A_RELIRE)) {
  const f = relire(lignes);
  console.log("   Dockerfile " + nom + " : " + (f.length ? f.length + " faute(s)" : "correct"));
  for (const x of f) console.log("      - " + x);
}

Avant de commencer

• Docker installé et fonctionnel (docker run hello-world)
• Le dépôt tickets du TP 2, avec l'application qui démarre en local

Énoncé

1. Écrire un premier Dockerfile, volontairement naïf — Partez d'une image node complète, copiez tout le projet, installez les dépendances, lancez le serveur. Construisez, puis mesurez : temps de construction et taille de l'image. Indice : docker build affiche la durée ; docker images donne la taille.
2. Mesurer l'effet du cache — Modifiez une seule ligne d'un fichier source, reconstruisez, et notez le temps. Recommencez après avoir modifié package.json. Les deux durées devraient être identiques — expliquez pourquoi c'est un problème.
3. Réordonner les couches — Réécrivez le Dockerfile pour que l'installation des dépendances reste en cache quand seul le code change. Reprenez les deux mesures de l'étape précédente et comparez. Indice : Une couche invalidée invalide toutes les suivantes. Que faut-il donc copier en premier ?
4. Réduire l'image — Passez à une construction en deux étapes : une étape qui compile, une étape finale minimale qui ne reçoit que le résultat. Comparez la taille avant et après.
5. Ne plus tourner en root — Vérifiez sous quel identifiant tourne le processus dans le conteneur, puis faites-le tourner sous un compte non privilégié. Vérifiez à nouveau. Indice : docker exec conteneur id, puis l'instruction USER — attention à l'ordre par rapport aux instructions qui écrivent des fichiers.
6. Publier et joindre — Lancez le conteneur en publiant un port, et atteignez l'application depuis votre machine. Si rien ne répond, reprenez le diagnostic du TP 2 : sur quelle interface l'application écoute-t-elle À L'INTÉRIEUR du conteneur ?
7. Écrire le .dockerignore — Listez ce que COPY embarque et qui n'a rien à faire dans l'image. Écrivez le fichier, reconstruisez, et comparez la taille du contexte de construction.

C'est réussi quand

• ✓ Une modification de code seule ne relance PAS l'installation des dépendances
• ✓ L'image finale fait moins du quart de l'image naïve
• ✓ docker exec … id ne rend pas uid=0
• ✓ curl atteint l'application depuis l'hôte

Correction

FROM node:20
WORKDIR /app
COPY . .
RUN npm ci
RUN npm run build
CMD ["node", "dist/serveur.js"]

FROM node:20 AS construction
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
ENV NODE_ENV=production
COPY package.json package-lock.json ./
RUN npm ci --omit=dev
COPY --from=construction /app/dist ./dist
USER node
EXPOSE 3000
CMD ["node", "dist/serveur.js"]

                       naïf        corrigé
taille de l'image      1,18 Go     138 Mo
1re construction       118 s       121 s
modification de code   115 s       9 s
modification de deps   117 s       119 s

// AVANT : injoignable depuis l'hôte, même avec -p
app.listen(3000, "127.0.0.1");

// APRÈS : toutes les interfaces du conteneur
app.listen(3000, "0.0.0.0");

docker run -p 8080:3000 tickets
curl http://localhost:8080/sante

.git
node_modules
dist
.env
*.log
coverage
.vscode

docker exec tickets id
# avant : uid=0(root) gid=0(root)
# après : uid=1000(node) gid=1000(node)

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