Kubernetes

Point de départ

// ── L'état déclaré, et le monde réel ──────────────────────────────────────
const desire = { replicas: 3, image: "appli:1.4" };
let pods = [];                    // le réel
let horloge = 0;
let prochainId = 1;

const nouveauPod = (image) => ({
  id: "pod-" + (prochainId++), image, pret: false, ne: horloge, redemarrages: 0,
});

// ── La boucle du contrôleur ───────────────────────────────────────────────
function reconcilier(journal) {
  const vivants = pods.filter((p) => p.image === desire.image);
  const ecart = desire.replicas - vivants.length;
  // ← à écrire : créer si l'écart est positif, supprimer s'il est négatif,
  //   et ne RIEN faire s'il est nul. C'est toute la boucle.
  return "aucune action";
}

// Les pods deviennent prêts quelques instants après leur création.
function avancer(secondes, sondePret) {
  horloge += secondes;
  for (const p of pods) {
    if (!p.pret && horloge - p.ne >= 2) p.pret = sondePret(p);
  }
}

function etat() {
  const prets = pods.filter((p) => p.pret).length;
  return "réel " + pods.length + " (" + prets + " prêts) | désiré " + desire.replicas +
         " | images " + [...new Set(pods.map((p) => p.image))].join(", ");
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez reconcilier(). Envoyez-lui quatre événements : démarrage,
//    panne d'un nœud, mise à l'échelle, changement d'image. Combien de
//    lignes de code chaque événement a-t-il demandées ?
// 2. Déploiement progressif avec une sonde qui ÉCHOUE sur la nouvelle
//    version : le déploiement doit s'arrêter. Relancez sans sonde et
//    comptez les requêtes perdues.
// 3. Reproduisez la cascade : vivacité et disponibilité pointant toutes
//    deux sur la base. La base ralentit — combien de redémarrages ?

console.log(reconcilier([]));

Solution

let desire = { replicas: 3, image: "appli:1.4" };
let pods = [];
let horloge = 0, prochainId = 1;

const nouveauPod = (image) => ({
  id: "pod-" + (prochainId++), image, pret: false, ne: horloge, redemarrages: 0,
});

function reconcilier() {
  // Toute la boucle tient en trois lignes : compter, comparer, agir.
  const conformes = pods.filter((p) => p.image === desire.image);
  const ecart = desire.replicas - conformes.length;
  if (ecart > 0) { for (let i = 0; i < ecart; i++) pods.push(nouveauPod(desire.image)); return "créé " + ecart; }
  if (ecart < 0) { pods = pods.slice(0, desire.replicas); return "supprimé " + -ecart; }
  // Reste à retirer les pods d'une ancienne image, un par un (progressif).
  const anciens = pods.filter((p) => p.image !== desire.image);
  if (anciens.length && conformes.filter((p) => p.pret).length >= desire.replicas - 1) {
    pods = pods.filter((p) => p !== anciens[0]);
    return "retiré un pod de l'ancienne version";
  }
  return "aucune action";
}

function avancer(secondes, sondePret) {
  horloge += secondes;
  for (const p of pods) if (!p.pret && horloge - p.ne >= 2) p.pret = sondePret(p);
}
function etat() {
  const parImage = {};
  for (const p of pods) parImage[p.image] = (parImage[p.image] ?? 0) + 1;
  return "réel " + pods.length + " (" + pods.filter((p) => p.pret).length + " prêts)" +
         " | désiré " + desire.replicas +
         " | " + Object.entries(parImage).map(([i, n]) => i + " ×" + n).join(", ");
}
const tourner = (n, sonde = () => true) => {
  for (let i = 0; i < n; i++) { const a = reconcilier(); avancer(2, sonde); 
    if (a !== "aucune action") console.log("      t=" + horloge + "s  " + a.padEnd(38) + etat()); }
};

console.log("— 1. quatre événements, aucun code supplémentaire —");
console.log("   [démarrage]");
tourner(4);
console.log("   [un nœud tombe : deux pods disparaissent]");
pods.splice(0, 2);
tourner(4);
console.log("   [mise à l'échelle : replicas 3 → 5]");
desire.replicas = 5;
tourner(4);
console.log("   [nouvelle image : 1.4 → 1.5]");
desire.image = "appli:1.5";
tourner(12);
console.log("   Aucun de ces quatre événements n'a demandé une ligne de plus : la");
console.log("   même boucle « comparer, agir » les traite tous.");

console.log("");
console.log("— 2. déploiement progressif avec une sonde qui échoue —");
function scenarioDeploiement(avecSonde) {
  pods = []; horloge = 0; prochainId = 1;
  desire = { replicas: 4, image: "appli:1.4" };
  tourner(6);
  desire.image = "appli:1.5";
  // La 1.5 est défaillante : sa sonde de disponibilité ne passera jamais.
  const sonde = (p) => (avecSonde ? p.image !== "appli:1.5" : true);
  let perdues = 0;
  for (let i = 0; i < 20; i++) {
    reconcilier(); avancer(2, sonde);
    // Le trafic va aux pods PRÊTS ; sans sonde, un pod cassé reçoit du trafic.
    const servants = pods.filter((p) => p.pret);
    const casses = servants.filter((p) => p.image === "appli:1.5").length;
    if (servants.length) perdues += Math.round(100 * casses / servants.length);
  }
  const anciens = pods.filter((p) => p.image === "appli:1.4").length;
  return { perdues, anciens, total: pods.length };
}
for (const avec of [true, false]) {
  const r = scenarioDeploiement(avec);
  console.log("   " + (avec ? "AVEC sonde de disponibilité " : "SANS sonde                 ") +
    ": " + r.anciens + "/" + r.total + " pods encore en 1.4 | " +
    r.perdues + " requêtes perdues (sur 2000)");
}
console.log("   Avec la sonde, aucun pod de la version défaillante n'entre dans le");
console.log("   service : le déploiement S'ARRÊTE DE LUI-MÊME et l'ancienne version");
console.log("   continue de servir. Sans elle, Kubernetes remplace joyeusement des");
console.log("   pods sains par des pods cassés — rien ne lui dit qu'ils le sont.");

console.log("");
console.log("— 3. la cascade de redémarrages —");
function scenarioSondes(vivaciteDependDeLaBase) {
  let pods = Array.from({ length: 6 }, (_, i) => ({ id: i, redemarrages: 0, dansLeService: true }));
  let chargeBase = 0.5;                  // la base ralentit
  const journal = [];
  for (let t = 0; t < 10; t++) {
    const baseLente = chargeBase > 0.8;
    for (const p of pods) {
      // Disponibilité : dépend légitimement de la base.
      p.dansLeService = !baseLente;
      // Vivacité : ne DOIT tester que le processus.
      const vivaciteEchoue = vivaciteDependDeLaBase ? baseLente : false;
      if (vivaciteEchoue) { p.redemarrages++; }
    }
    // Chaque redémarrage rouvre des connexions et charge davantage la base.
    const redemarres = vivaciteDependDeLaBase && baseLente ? pods.length : 0;
    chargeBase = Math.min(1, chargeBase + 0.12 + redemarres * 0.05);
    journal.push("t=" + t + "  charge base " + (chargeBase * 100).toFixed(0) + " %" +
      "  redémarrages cumulés " + pods.reduce((s, p) => s + p.redemarrages, 0));
  }
  return { journal, total: pods.reduce((s, p) => s + p.redemarrages, 0) };
}
for (const [nom, dep] of [["vivacité DÉPEND de la base", true], ["vivacité teste le processus seul", false]]) {
  const r = scenarioSondes(dep);
  console.log("   " + nom.padEnd(34) + r.total + " redémarrages");
  if (dep) for (const l of r.journal.slice(4, 8)) console.log("      " + l);
}
console.log("   Dans le premier cas, la supervision a transformé une lenteur en");
console.log("   panne totale : tous les pods redémarrent, se reconnectent en même");
console.log("   temps, et achèvent la base. Kubernetes ne peut rien détecter — il");
console.log("   applique ce qu'on a déclaré.");

Avant de commencer

• Un cluster local : k3s, kind ou minikube — aucun hébergement payant
• kubectl configuré, et kubectl get nodes qui répond
• L'image du TP 3 chargée dans le cluster

Énoncé

1. Un premier déploiement — Écrivez un Deployment de trois exemplaires de l'application. Appliquez-le, puis listez les pods et notez leurs noms.
2. Éprouver la réconciliation — Supprimez un pod à la main. Relistez immédiatement, puis dix secondes plus tard. Expliquez ce que vous observez, puis dites comment retirer RÉELLEMENT un exemplaire. Indice : Vous n'avez pas donné d'ordre, vous avez déclaré un nombre.
3. Exposer — Ajoutez un Service devant les pods, puis un Ingress pour y accéder depuis votre machine. Vérifiez que le trafic se répartit sur les trois exemplaires. Indice : Rien n'est relié par identifiant : tout l'est par ÉTIQUETTE. Une étiquette mal recopiée donne un service qui ne pointe sur rien, sans aucune erreur.
4. Sortir la configuration de l'image — Déplacez l'adresse de la base dans un ConfigMap et le mot de passe dans un Secret, puis injectez-les dans le conteneur. Affichez ensuite le contenu du Secret et commentez.
5. Mettre à l'échelle — Passez à dix exemplaires, puis redescendez à deux. Chronométrez chaque opération et observez où les pods sont placés.
6. Déployer une nouvelle version — Changez l'étiquette d'image et suivez le remplacement en direct. Combien d'exemplaires sont indisponibles au pire moment ?
7. Déployer une version cassée, AVEC sonde — Ajoutez une sonde de disponibilité, puis déployez une version dont cette sonde échoue. Que fait le déploiement ? Combien de requêtes sont perdues ?
8. Recommencer SANS sonde — Retirez la sonde et refaites l'essai. Comparez, puis exécutez un retour arrière.
9. Provoquer la cascade — Faites pointer la sonde de vivacité sur une adresse qui vérifie la base, puis arrêtez la base. Comptez les redémarrages. Corrigez et refaites l'essai.

C'est réussi quand

• ✓ Un pod supprimé revient seul, et vous savez expliquer pourquoi
• ✓ Le déploiement de la version cassée s'arrête TOUT SEUL, sans requête perdue
• ✓ Vous savez dire ce que le Secret protège réellement
• ✓ La correction des sondes fait tomber le nombre de redémarrages à zéro

Correction

apiVersion: apps/v1
kind: Deployment
metadata:
name: tickets
spec:
replicas: 3
selector:
  matchLabels: { app: tickets }
template:
  metadata:
    labels: { app: tickets }      # DOIT correspondre au selector
  spec:
    containers:
      - name: tickets
        image: registre/tickets:1.0
        ports: [{ containerPort: 3000 }]
        envFrom:
          - configMapRef: { name: tickets-config }
          - secretRef:    { name: tickets-secret }
        readinessProbe:
          httpGet: { path: /pret, port: 3000 }
          periodSeconds: 3
        livenessProbe:
          httpGet: { path: /vivant, port: 3000 }
          periodSeconds: 10

kubectl delete pod tickets-7d4b9-x2k4
kubectl get pods
# tickets-7d4b9-x2k4   Terminating
# tickets-7d4b9-m9p1   ContainerCreating   <-- déjà remplacé

# pour en retirer un RÉELLEMENT :
kubectl scale deployment tickets --replicas=2

kubectl get secret tickets-secret -o jsonpath='{.data.MOT_DE_PASSE}' | base64 -d
# secret

kubectl auth can-i get secrets --as=system:serviceaccount:default:default

AVEC sonde de disponibilité
kubectl rollout status deployment/tickets
Waiting for 1 pod to be ready...     (bloqué)
→ 3 pods en 1.0 servent toujours, 0 requête perdue
→ kubectl rollout undo deployment/tickets

SANS sonde
rollout terminé en 12 s
→ 3 pods en 1.1 « prêts » alors qu'ils renvoient des erreurs
→ ~100 % des requêtes en échec jusqu'au retour arrière

# la faute : les deux sondes vérifient la base
livenessProbe:
httpGet: { path: /sante-complete, port: 3000 }   # interroge la base

# base arrêtée :
kubectl get pods
# tickets-…  0/1  CrashLoopBackOff  RESTARTS: 7

# la correction
livenessProbe:
httpGet: { path: /vivant, port: 3000 }   # ne teste QUE le processus