Intégration continue

Point de départ

// ── 1. Ordre des étapes et délai avant retour ─────────────────────────────
// duree en secondes, proba = probabilité que CETTE étape révèle un défaut.
const ETAPES = [
  { nom: "lint",            duree: 10,  proba: 0.25 },
  { nom: "tests unitaires", duree: 60,  proba: 0.35 },
  { nom: "intégration",     duree: 300, proba: 0.20 },
  { nom: "bout en bout",    duree: 900, proba: 0.10 },
];

// Le job s'arrête à la PREMIÈRE étape qui échoue : le délai avant retour
// dépend donc de l'ordre.
function delaiMoyen(etapes) {
  let cumul = 0, esperance = 0, resteVrai = 1;
  for (const e of etapes) {
    cumul += e.duree;
    // ← à écrire : probabilité d'arriver jusqu'ici ET d'échouer ici,
    //   pondérée par le temps écoulé
  }
  // Cas où tout passe : on paie la totalité.
  esperance += resteVrai * cumul;
  return esperance;
}

// ── 2. Cache et parallélisme ──────────────────────────────────────────────
const AVEC_CACHE = { installation: 8 };
const SANS_CACHE = { installation: 95 };

// Des jobs, chacun avec ses étapes et ses dépendances.
const JOBS = [
  { nom: "lint",         duree: 10,  depend: ["installation"] },
  { nom: "unitaires",    duree: 60,  depend: ["installation"] },
  { nom: "sécurité",     duree: 120, depend: ["installation"] },
  { nom: "intégration",  duree: 300, depend: ["unitaires"] },
  { nom: "bout en bout", duree: 900, depend: ["intégration"] },
];

function cheminCritique(jobs, installation) {
  const fin = { installation };
  // ← à écrire : la fin d'un job est le max des fins de ses dépendances,
  //   plus sa propre durée. Le pipeline dure jusqu'à la fin la plus tardive.
  return 0;
}

// ── 3. Tests instables ────────────────────────────────────────────────────
function probaEchecPipeline(nbTests, instabilite) {
  return 0;   // ← à écrire : 1 − (1 − p)^n
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez delaiMoyen, puis comparez l'ordre rapide→lent et lent→rapide.
// 2. Écrivez cheminCritique. Que gagne le cache ? Et si l'on parallélise
//    seulement les étapes déjà rapides ?
// 3. Retrouvez les 63 % du cours, puis simulez une équipe qui relance
//    « pour voir » : combien de VRAIS échecs passent inaperçus ?

console.log("   délai moyen :", delaiMoyen(ETAPES).toFixed(0), "s");

Solution

const ETAPES = [
  { nom: "lint",            duree: 10,  proba: 0.25 },
  { nom: "tests unitaires", duree: 60,  proba: 0.35 },
  { nom: "intégration",     duree: 300, proba: 0.20 },
  { nom: "bout en bout",    duree: 900, proba: 0.10 },
];

function delaiMoyen(etapes) {
  let cumul = 0, esperance = 0, resteVrai = 1;
  for (const e of etapes) {
    cumul += e.duree;
    // Espérance : (probabilité d'arriver ici sans avoir échoué avant)
    // × (probabilité d'échouer ici) × (temps écoulé à cet instant).
    esperance += resteVrai * e.proba * cumul;
    resteVrai *= 1 - e.proba;
  }
  esperance += resteVrai * cumul;   // tout passe : on paie la totalité
  return esperance;
}

console.log("— 1. l'échec rapide, en secondes —");
const rapideDabord = [...ETAPES];
const lentDabord = [...ETAPES].reverse();
for (const [nom, ordre] of [["rapide → lent", rapideDabord], ["lent → rapide", lentDabord]]) {
  console.log("   " + nom.padEnd(16) + ordre.map((e) => e.nom).join(" → "));
  console.log("      délai moyen avant retour : " + Math.round(delaiMoyen(ordre)) + " s");
}
const gain = delaiMoyen(lentDabord) - delaiMoyen(rapideDabord);
console.log("   Écart : " + Math.round(gain) + " s en moyenne, pour TROIS LIGNES déplacées.");
console.log("   Et le pire cas compte autant : une faute de lint remonte en 10 s");
console.log("   au lieu de 1270 s — tant que le code est encore sous les yeux.");

console.log("");
console.log("— 2. cache et chemin critique —");
const JOBS = [
  { nom: "lint",         duree: 10,  depend: ["installation"] },
  { nom: "unitaires",    duree: 60,  depend: ["installation"] },
  { nom: "sécurité",     duree: 120, depend: ["installation"] },
  { nom: "intégration",  duree: 300, depend: ["unitaires"] },
  { nom: "bout en bout", duree: 900, depend: ["intégration"] },
];

function cheminCritique(jobs, installation) {
  const fin = { installation };
  let reste = [...jobs];
  while (reste.length) {
    const pret = reste.filter((j) => j.depend.every((d) => fin[d] !== undefined));
    if (!pret.length) throw new Error("dépendance circulaire");
    for (const j of pret) {
      // Un job démarre quand TOUTES ses dépendances sont finies.
      fin[j.nom] = Math.max(...j.depend.map((d) => fin[d])) + j.duree;
    }
    reste = reste.filter((j) => !pret.includes(j));
  }
  const total = Math.max(...Object.values(fin));
  const dernier = Object.entries(fin).find(([, v]) => v === total)[0];
  return { total, dernier, fin };
}

for (const [nom, inst] of [["sans cache", 95], ["avec cache", 8]]) {
  const r = cheminCritique(JOBS, inst);
  console.log("   " + nom.padEnd(12) + Math.round(r.total / 60) + " min " +
              (r.total % 60) + " s   (chemin critique se termine sur « " + r.dernier + " »)");
}
console.log("   Le cache gagne 87 s. Le chemin critique, lui, vaut " +
            Math.round(cheminCritique(JOBS, 8).total / 60) + " min :");
console.log("   installation → unitaires → intégration → bout en bout. Paralléliser");
console.log("   lint et sécurité ne change RIEN au total, puisqu'ils ne sont pas");
console.log("   sur ce chemin — c'est le chemin critique du cours d'architecture.");
console.log("   Pour descendre sous dix minutes, il faut découper le bout en bout.");

console.log("");
console.log("— 3. les tests instables —");
const probaEchecPipeline = (n, p) => 1 - Math.pow(1 - p, n);
console.log("   tests | instabilité | pipeline rouge sans cause");
for (const [n, p] of [[50, 0.005], [200, 0.005], [200, 0.001], [500, 0.002], [1000, 0.005]]) {
  console.log("   " + String(n).padStart(5) + " | " + (p * 100).toFixed(1).padStart(10) + " %" +
              " | " + (probaEchecPipeline(n, p) * 100).toFixed(0).padStart(20) + " %");
}
console.log("   200 tests à 0,5 % : 63 % des exécutions échouent sans raison.");

console.log("");
console.log("— ce que fait une équipe qui relance « pour voir » —");
let vraisEchecsRates = 0, relances = 0;
const N = 1000, INSTABILITE = 0.005, NB_TESTS = 200, VRAI_DEFAUT = 0.15;
for (let i = 0; i < N; i++) {
  const vraiDefaut = Math.random() < VRAI_DEFAUT;
  const instable = Math.random() < probaEchecPipeline(NB_TESTS, INSTABILITE);
  if (!vraiDefaut && !instable) continue;
  // L'équipe a appris que « rouge » signifie souvent « instable » : elle relance.
  relances++;
  // Une relance sur un vrai défaut échoue encore ; sur une instabilité, elle
  // passe souvent — d'où le réflexe. Mais certains vrais défauts sont aussi
  // intermittents, et ceux-là passent à la relance : ils sont ignorés.
  if (vraiDefaut && Math.random() < 0.3) vraisEchecsRates++;
}
console.log("   sur " + N + " exécutions : " + relances + " relances « pour voir »,");
console.log("   et " + vraisEchecsRates + " vrais défauts passés inaperçus parce qu'ils");
console.log("   étaient eux-mêmes intermittents.");
console.log("   C'est le vrai coût de l'instabilité : elle ne fait pas perdre du");
console.log("   temps, elle DÉTRUIT LE SIGNAL. Un test instable se répare ou se");
console.log("   supprime le jour même.");

Avant de commencer

• Le dépôt du TP 2 hébergé sur une forge disposant d'intégration continue
• La pile Compose du TP 4, qui démarre
• Une suite de tests, même minimale

Énoncé

1. Un premier pipeline qui échoue — Écrivez un pipeline déclenché sur chaque demande de fusion : installation, analyse statique, tests. Poussez une modification qui casse volontairement le lint, et vérifiez que la demande de fusion est bloquée.
2. Mesurer le délai avant retour — Placez délibérément les étapes de la plus lente à la plus rapide. Poussez une faute de lint et chronométrez le temps entre le push et le message d'échec. Réordonnez, refaites la mesure.
3. Mettre les dépendances en cache — Activez le cache du gestionnaire de paquets et comparez la durée d'installation sur deux exécutions consécutives.
4. Ajouter les tests d'intégration — Faites tourner les tests contre une vraie base, démarrée par le pipeline. Ils ne doivent PAS dépendre les uns des autres : chaque test crée et détruit ses propres données. Indice : Les forges offrent des services attachés à un job, avec une sonde de santé — c'est le depends_on du TP 4, transposé.
5. Paralléliser, et trouver la limite — Découpez en jobs indépendants et mesurez le gain. Identifiez ensuite le chemin critique : quelle suite d'étapes fixe la durée totale ? Que gagneriez-vous en parallélisant ce qui n'est PAS sur ce chemin ?
6. Éprouver l'instabilité — Introduisez un test qui échoue aléatoirement une fois sur vingt. Relancez le pipeline dix fois et comptez les échecs. Discutez : que fera l'équipe au bout d'une semaine ?
7. Publier l'image — Ajoutez un job final qui construit l'image du TP 3 et la pousse dans un registre, étiquetée avec l'empreinte du commit. C'est cet artefact que le TP 6 déploiera.

C'est réussi quand

• ✓ Une faute de lint est signalée en moins de trente secondes
• ✓ Le pipeline complet dure moins de dix minutes
• ✓ Deux exécutions consécutives sans changement de dépendances ne réinstallent rien
• ✓ L'image publiée porte l'empreinte du commit qui l'a produite

Correction

name: intégration
on:
pull_request:
push:
  branches: [main]

jobs:
rapide:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-node@v4
      with: { node-version: '20', cache: 'npm' }
    - run: npm ci
    - run: npm run lint          # 10 s : en premier
    - run: npm run test:unit     # 60 s

integration:
  runs-on: ubuntu-latest
  services:
    basededonnees:
      image: postgres:16-alpine
      env: { POSTGRES_USER: app, POSTGRES_PASSWORD: secret }
      options: >-
        --health-cmd "pg_isready -U app"
        --health-interval 5s --health-retries 10
  steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-node@v4
      with: { node-version: '20', cache: 'npm' }
    - run: npm ci
    - run: npm run test:integration
      env:
        DATABASE_URL: postgres://app:secret@localhost:5432/app

image:
  needs: [rapide, integration]
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - run: docker build -t registre/tickets:${{ github.sha }} .
    - run: docker push registre/tickets:${{ github.sha }}

ordre lent → rapide : faute de lint signalée après 16 min 10 s
ordre rapide → lent : faute de lint signalée après      12 s

installation 8 s ─┬─ lint 10 s
                ├─ unitaires 60 s ── intégration 300 s
                └─ sécurité 120 s

durée totale = 8 + 60 + 300 = 368 s

beforeEach(async () => {
schema = "test_" + Math.random().toString(36).slice(2, 8);
await db.query("CREATE SCHEMA " + schema);
await migrer(schema);
});

afterEach(async () => {
await db.query("DROP SCHEMA " + schema + " CASCADE");
});