Point de départ

// ── Trois sources de vérité ───────────────────────────────────────────────
const IMMUABLES = ["zone", "moteur"];   // modifier cela impose un remplacement

// Ce que le code décrit.
const CODE = {
  "instance.web":     { type: "t3.small", zone: "eu-west-1a" },
  "instance.web2":    { type: "t3.micro", zone: "eu-west-1b" },
  "securite.web":     { port: 443 },
  "base.principale":  { taille: 100, moteur: "postgres16" },
};

// Ce que l'outil croit avoir créé.
const ETAT = {
  "instance.web":     { type: "t3.micro", zone: "eu-west-1a" },
  "securite.web":     { port: 443 },
  "base.principale":  { taille: 100, moteur: "postgres15" },
  "instance.ancienne": { type: "t3.micro", zone: "eu-west-1a" },
};

// Ce qui existe réellement chez le fournisseur.
const REEL = { ...ETAT };

function plan(code, etat) {
  const actions = [];
  for (const [nom, voulu] of Object.entries(code)) {
    const connu = etat[nom];
    if (!connu) { actions.push({ signe: "+", nom, quoi: "sera créée" }); continue; }
    const differents = Object.keys(voulu).filter((k) => voulu[k] !== connu[k]);
    if (differents.length === 0) continue;
    // ← à écrire : si un attribut IMMUABLE change, c'est un remplacement
    actions.push({ signe: "~", nom, quoi: "modifiée sur place : " + differents.join(", ") });
  }
  // ← à écrire : ce qui est dans l'état mais plus dans le code sera détruit
  return actions;
}

function afficher(actions) {
  if (!actions.length) { console.log("      No changes. Infrastructure is up-to-date."); return; }
  for (const a of actions) {
    console.log("      " + a.signe.padStart(3) + " " + a.nom.padEnd(20) + a.quoi);
  }
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Complétez plan() : remplacement sur attribut immuable, et destruction.
//    Repérez la ligne -/+ : que se passerait-il si l'on appliquait ?
// 2. Appliquez, puis replanifiez : vérifiez l'idempotence.
// 3. Simulez une DÉRIVE — quelqu'un modifie le monde réel depuis la console.
// 4. Simulez deux applications concurrentes sans verrou, puis avec.

afficher(plan(CODE, ETAT));

Solution

const IMMUABLES = ["zone", "moteur"];

const CODE = {
  "instance.web":    { type: "t3.small", zone: "eu-west-1a" },
  "instance.web2":   { type: "t3.micro", zone: "eu-west-1b" },
  "securite.web":    { port: 443 },
  "base.principale": { taille: 100, moteur: "postgres16" },
};
const ETAT_INITIAL = {
  "instance.web":      { type: "t3.micro", zone: "eu-west-1a" },
  "securite.web":      { port: 443 },
  "base.principale":   { taille: 100, moteur: "postgres15" },
  "instance.ancienne": { type: "t3.micro", zone: "eu-west-1a" },
};

function plan(code, etat) {
  const actions = [];
  for (const [nom, voulu] of Object.entries(code)) {
    const connu = etat[nom];
    if (!connu) { actions.push({ signe: "+", nom, quoi: "sera créée" }); continue; }
    const differents = Object.keys(voulu).filter((k) => voulu[k] !== connu[k]);
    if (differents.length === 0) continue;
    const immuablesTouches = differents.filter((k) => IMMUABLES.includes(k));
    if (immuablesTouches.length) {
      // Un attribut immuable ne se modifie pas : il faut détruire et recréer.
      actions.push({ signe: "-/+", nom,
        quoi: "DOIT ÊTRE REMPLACÉE (attribut immuable : " + immuablesTouches.join(", ") + ")" });
    } else {
      actions.push({ signe: "~", nom, quoi: "modifiée sur place : " + differents.join(", ") });
    }
  }
  for (const nom of Object.keys(etat)) {
    if (!code[nom]) actions.push({ signe: "-", nom, quoi: "sera détruite" });
  }
  return actions;
}

function afficher(actions) {
  if (!actions.length) { console.log("      No changes. Infrastructure is up-to-date."); return; }
  for (const a of actions) console.log("      " + a.signe.padStart(3) + " " + a.nom.padEnd(20) + a.quoi);
}

function appliquer(code, etat) {
  const nouveau = {};
  for (const [nom, voulu] of Object.entries(code)) nouveau[nom] = { ...voulu };
  return nouveau;   // après application, l'état reflète le code
}

console.log("— 1. le plan —");
afficher(plan(CODE, ETAT_INITIAL));
console.log("      ↑ La ligne -/+ est celle à repérer : appliquer ce plan DÉTRUIRAIT");
console.log("        la base de production et la recréerait vide. Il n'y a aucune");
console.log("        confirmation par ressource — la lecture du plan est la seule");
console.log("        protection, avec le verrou de prévention de destruction.");

console.log("");
console.log("— 2. idempotence —");
let etat = appliquer(CODE, ETAT_INITIAL);
console.log("   après application, second plan :");
afficher(plan(CODE, etat));
console.log("      Appliquer deux fois produit le même résultat qu'appliquer une");
console.log("      fois : c'est ce qui permet de relancer sans crainte après une");
console.log("      interruption.");

console.log("");
console.log("— 3. dérive : quelqu'un a modifié le monde réel à la main —");
const reel = { ...etat, "securite.web": { port: 22 } };   // un port SSH ouvert en console
console.log("   plan calculé contre le RÉEL observé :");
afficher(plan(CODE, reel));
console.log("      Le plan propose de revenir à ce que le code décrit. La bonne");
console.log("      réaction n'est pas d'accepter la dérive en modifiant le code,");
console.log("      mais de comprendre POURQUOI quelqu'un a eu besoin de contourner.");

console.log("");
console.log("— 4. deux applications concurrentes —");
function concurrent(avecVerrou) {
  const depart = { "securite.web": { port: 443 } };
  const codeA = { ...depart, "instance.a": { type: "t3.micro", zone: "eu-west-1a" } };
  const codeB = { ...depart, "instance.b": { type: "t3.micro", zone: "eu-west-1b" } };
  const reelFinal = { ...depart, "instance.a": codeA["instance.a"], "instance.b": codeB["instance.b"] };

  let etatFinal;
  if (avecVerrou) {
    // Sérialisé : B part de l'état laissé par A.
    const apresA = appliquer(codeA, depart);
    etatFinal = appliquer({ ...codeB, ...apresA }, apresA);
  } else {
    // Les deux partent du MÊME état ; la dernière écriture gagne.
    appliquer(codeA, depart);
    etatFinal = appliquer(codeB, depart);
  }
  const orphelines = Object.keys(reelFinal).filter((r) => !etatFinal[r]);
  return { etatFinal: Object.keys(etatFinal), orphelines };
}
for (const avec of [false, true]) {
  const r = concurrent(avec);
  console.log("   " + (avec ? "avec verrou  " : "sans verrou  ") +
    "état final : [" + r.etatFinal.join(", ") + "]");
  console.log("      ressources orphelines : " +
    (r.orphelines.length ? r.orphelines.join(", ") + "  ← existent, facturées, décrites par aucun code"
                         : "aucune"));
}
console.log("   Sans verrou, ce que le premier a créé disparaît de l'état mais pas");
console.log("   du monde réel. Un destroy ne les touchera pas : il faut comparer à");
console.log("   la main l'inventaire du fournisseur et l'état pour les retrouver.");

Avant de commencer

• Terraform ou OpenTofu installé
• Docker en fonctionnement
• Les images du TP 3 disponibles localement

Énoncé

1. Décrire la pile — Avec le fournisseur Docker, décrivez un réseau, un volume, un conteneur de base et un conteneur applicatif. Lancez un plan et LISEZ-LE avant d'appliquer. Indice : Le fournisseur kreuzwerker/docker expose docker_network, docker_volume, docker_image et docker_container.
2. Éprouver l'idempotence — Appliquez, puis replanifiez sans rien modifier. Notez ce qu'affiche le plan, et expliquez pourquoi.
3. Provoquer une dérive — Arrêtez un conteneur à la main avec Docker, sans passer par Terraform. Replanifiez. Que propose l'outil, et pourquoi ?
4. Repérer un remplacement — Modifiez un attribut modifiable sur place, puis un attribut immuable. Comparez les deux plans et repérez le symbole qui distingue une modification d'un remplacement. Indice : Changer le nom d'un conteneur ne se fait pas sur place.
5. Factoriser en module — Transformez la description en module paramétré par le nom de l'environnement et le nombre d'exemplaires, puis instanciez-le deux fois : recette et production.
6. Casser l'état, et le réparer — Faites une copie de sauvegarde du fichier d'état, puis supprimez-le. Replanifiez. Que propose Terraform ? Restaurez ensuite la sauvegarde.
7. La course — À deux, sur le même état partagé sans verrou, lancez une application simultanément. Comparez ensuite le contenu de l'état et la liste réelle des conteneurs.

C'est réussi quand

• ✓ Un second plan sans modification affiche « no changes »
• ✓ Vous savez repérer un remplacement dans un plan et dire ce qu'il détruirait
• ✓ Le module s'instancie deux fois sans duplication de code
• ✓ Vous pouvez nommer au moins une ressource orpheline produite par la course

Correction

terraform {
required_providers {
  docker = { source = "kreuzwerker/docker", version = "~> 3.0" }
}
}

resource "docker_network" "interne" {
name = "tickets-interne"
}

resource "docker_volume" "donnees" {
name = "tickets-donnees"
}

resource "docker_container" "base" {
name  = "tickets-base"
image = "postgres:16-alpine"
env   = ["POSTGRES_USER=app", "POSTGRES_PASSWORD=secret"]
networks_advanced { name = docker_network.interne.name }
volumes {
  volume_name    = docker_volume.donnees.name
  container_path = "/var/lib/postgresql/data"
}
}

# après application, sans modification
No changes. Your infrastructure matches the configuration.

# après avoir arrêté un conteneur à la main
~ docker_container.base will be updated in-place
  ~ must_run: false -> true

# attribut modifiable
~ docker_container.appli will be updated in-place

# attribut immuable (le nom)
-/+ docker_container.appli must be replaced

variable "environnement" { type = string }
variable "exemplaires"   { type = number, default = 1 }

# racine
module "recette" {
source        = "./modules/pile"
environnement = "recette"
}

module "production" {
source        = "./modules/pile"
environnement = "production"
exemplaires   = 3
}

# après suppression de terraform.tfstate
Plan: 4 to add, 0 to change, 0 to destroy.

Error: container name "tickets-base" is already in use

# A crée appli-1, B crée appli-2, les deux partis du même état
docker ps            # appli-1 ET appli-2 existent
terraform state list # seul appli-2 figure  <-- appli-1 est ORPHELIN

terraform destroy    # ne détruit pas appli-1 : il l'ignore

Point de départ

// ── Une machine simulée ───────────────────────────────────────────────────
function creerMachine() {
  return { paquets: new Set(), fichiers: new Map(), services: new Map() };
}

// ── Les modules : chacun COMPARE avant d'agir ─────────────────────────────
const MODULES = {
  package: (m, a) => {
    if (m.paquets.has(a.name)) return false;      // déjà là : rien à faire
    m.paquets.add(a.name);
    return true;                                   // changed
  },
  copy: (m, a) => {
    if (m.fichiers.get(a.dest) === a.contenu) return false;
    m.fichiers.set(a.dest, a.contenu);
    return true;
  },
  service: (m, a) => {
    if (m.services.get(a.name) === a.state) return false;
    m.services.set(a.name, a.state);
    return true;
  },
  get_url: (m, a) => {
    return false;   // ← à écrire : ne retélécharge pas si le fichier est là
  },
  // La porte de sortie : Ansible ne peut pas savoir si la commande a agi.
  shell: (m, a) => {
    if (a.creates && m.fichiers.has(a.creates)) return false;  // ← à honorer
    return true;                                   // sinon : TOUJOURS changed
  },
};

function executer(playbook, machine, tracer) {
  let ok = 0, changed = 0;
  const gestionnaires = new Set();
  for (const t of playbook) {
    const aChange = MODULES[t.module](machine, t);
    if (aChange) { changed++; if (t.notify) gestionnaires.add(t.notify); } else ok++;
    if (tracer) console.log("      " + (aChange ? "changed" : "ok     ") + "  " + t.name);
  }
  // Un gestionnaire ne part QUE si quelque chose a changé, et une seule fois.
  for (const g of gestionnaires) { if (tracer) console.log("      changed  [handler] " + g); changed++; }
  return { ok, changed };
}

const PLAYBOOK = [
  { module: "package", name: "nginx",                                      /* … */ },
  { module: "copy",    dest: "/etc/nginx/nginx.conf", contenu: "server{}", notify: "recharger nginx" },
  { module: "service", name: "nginx", state: "started" },
  { module: "shell",   cmd: "curl -o /opt/outil https://exemple.net/outil" },
];
PLAYBOOK.forEach((t, i) => { t.name = t.name ?? t.dest ?? t.cmd; });

// ── Détection de secrets ──────────────────────────────────────────────────
const MODIFICATIONS = [
  'const cle = "sk_live_4eC39HqLyjWDarjtT1zdp7dc";',
  'DATABASE_URL=postgres://app:Tr0ub4dor@db:5432/app',
  'const cle = process.env.STRIPE_KEY;',
  '// exemple : token = "xxxxxxxxxxxx"',
  'password_hash = "$2b$12$KIXQ2ei0Rl0Cq0Bl6Xa2yO"',
];

function detecter(ligne) {
  return false;   // ← à écrire, puis à mesurer sur les faux positifs
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Exécutez le playbook DEUX fois. Que vaut changed la seconde fois ?
// 2. Écrivez get_url et honorez creates dans shell. Corrigez la tâche
//    fautive de deux façons, et vérifiez changed=0.
// 3. Écrivez detecter(), puis comptez vrais et faux positifs.

const m = creerMachine();
console.log("   première exécution :");
console.log("   " + JSON.stringify(executer(PLAYBOOK, m, true)));

Solution

function creerMachine() {
  return { paquets: new Set(), fichiers: new Map(), services: new Map() };
}

const MODULES = {
  package: (m, a) => { if (m.paquets.has(a.name)) return false; m.paquets.add(a.name); return true; },
  copy: (m, a) => {
    if (m.fichiers.get(a.dest) === a.contenu) return false;
    m.fichiers.set(a.dest, a.contenu); return true;
  },
  service: (m, a) => {
    if (m.services.get(a.name) === a.state) return false;
    m.services.set(a.name, a.state); return true;
  },
  // Un module dédié COMPARE avant d'agir : c'est toute la différence.
  get_url: (m, a) => {
    if (m.fichiers.has(a.dest)) return false;
    m.fichiers.set(a.dest, "téléchargé"); return true;
  },
  shell: (m, a) => {
    if (a.creates && m.fichiers.has(a.creates)) return false;
    if (a.creates) m.fichiers.set(a.creates, "créé par shell");
    return true;
  },
};

function executer(playbook, machine, tracer) {
  let ok = 0, changed = 0;
  const gestionnaires = new Set();
  for (const t of playbook) {
    const aChange = MODULES[t.module](machine, t);
    if (aChange) { changed++; if (t.notify) gestionnaires.add(t.notify); } else ok++;
    if (tracer) console.log("      " + (aChange ? "changed" : "ok     ") + "  " + t.name);
  }
  for (const g of gestionnaires) { if (tracer) console.log("      changed  [handler] " + g); changed++; }
  return { ok, changed };
}

const nommer = (p) => p.map((t) => ({ ...t, name: t.name ?? t.dest ?? t.cmd }));

const FAUTIF = nommer([
  { module: "package", name: "nginx" },
  { module: "copy", dest: "/etc/nginx/nginx.conf", contenu: "server{}", notify: "recharger nginx" },
  { module: "service", name: "nginx", state: "started" },
  { module: "shell", cmd: "curl -o /opt/outil https://exemple.net/outil" },
]);
const CORRIGE_CREATES = nommer([
  ...FAUTIF.slice(0, 3),
  { module: "shell", cmd: "curl -o /opt/outil …", creates: "/opt/outil" },
]);
const CORRIGE_MODULE = nommer([
  ...FAUTIF.slice(0, 3),
  { module: "get_url", dest: "/opt/outil", name: "télécharger l'outil (get_url)" },
]);

console.log("— 1 et 2. idempotence —");
for (const [nom, pb] of [["playbook fautif (shell)", FAUTIF],
                          ["corrigé par creates:", CORRIGE_CREATES],
                          ["corrigé par get_url", CORRIGE_MODULE]]) {
  const m = creerMachine();
  const un = executer(pb, m, false);
  const deux = executer(pb, m, false);
  console.log("   " + nom.padEnd(26) +
    "1re : ok=" + un.ok + " changed=" + un.changed +
    "   |   2e : ok=" + deux.ok + " changed=" + deux.changed +
    (deux.changed === 0 ? "   idempotent" : "   NON IDEMPOTENT"));
}
console.log("");
console.log("   Détail de la seconde exécution du playbook corrigé :");
const m2 = creerMachine();
executer(CORRIGE_MODULE, m2, false);
executer(CORRIGE_MODULE, m2, true);
console.log("   Le gestionnaire n'est pas parti : rien n'avait changé. C'est ce qui");
console.log("   évite de recharger nginx à chaque exécution — et ce qui rend le");
console.log("   décompte utilisable comme indicateur de dérive.");

console.log("");
console.log("— 3. détection de secrets —");
const MODIFICATIONS = [
  { ligne: 'const cle = "sk_live_4eC39HqLyjWDarjtT1zdp7dc";', secret: true },
  { ligne: 'DATABASE_URL=postgres://app:Tr0ub4dor@db:5432/app', secret: true },
  { ligne: 'const cle = process.env.STRIPE_KEY;', secret: false },
  { ligne: '// exemple : token = "xxxxxxxxxxxx"', secret: false },
  { ligne: 'password_hash = "$2b$12$KIXQ2ei0Rl0Cq0Bl6Xa2yO"', secret: false },
  { ligne: 'AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCY', secret: true },
];

function detecter(ligne) {
  // Préfixes connus de fournisseurs : très fiables, peu de faux positifs.
  if (/\b(sk_live|ghp_|AKIA)[A-Za-z0-9_]{10,}/.test(ligne)) return true;
  // Mot de passe dans une chaîne de connexion.
  if (/:\/\/[^:\s]+:[^@\s]{6,}@/.test(ligne)) return true;
  // Affectation d'une variable au nom sensible avec une valeur longue…
  if (/(SECRET|PASSWORD|TOKEN|API_KEY)[A-Z_]*\s*[=:]\s*["']?[A-Za-z0-9\/+_-]{16,}/i.test(ligne)) {
    // …sauf si c'est une référence à une variable d'environnement, un
    // exemple manifeste, ou une empreinte déjà hachée.
    if (/process\.env|os\.environ|\bxxxx|\$2[aby]\$/.test(ligne)) return false;
    return true;
  }
  return false;
}

let vp = 0, fp = 0, fn = 0;
for (const m of MODIFICATIONS) {
  const d = detecter(m.ligne);
  if (d && m.secret) vp++;
  if (d && !m.secret) fp++;
  if (!d && m.secret) fn++;
  console.log("   " + (d ? "ALERTE " : "       ") + (m.secret ? "[vrai secret] " : "[inoffensif]  ") +
              m.ligne.slice(0, 52));
}
console.log("   vrais positifs " + vp + " | faux positifs " + fp + " | manqués " + fn);
console.log("   Les faux positifs comptent autant que les manqués : un détecteur");
console.log("   qui crie sur chaque hachage et chaque exemple est désactivé au bout");
console.log("   d'une semaine, et ne protège plus de rien. C'est déjà le bruit");
console.log("   d'alertes du chapitre 10.");

Avant de commencer

• Ansible installé
• Deux conteneurs cibles avec Python, servant de machines de laboratoire

Énoncé

1. Monter l'inventaire — Déclarez vos deux conteneurs comme cibles, en connexion locale par Docker plutôt que par SSH, et vérifiez la connectivité avec le module ping. Indice : ansible_connection: docker évite d'installer un serveur SSH dans les cibles.
2. Écrire le playbook — Installez nginx, déposez une page à partir d'un gabarit contenant le nom de la machine, et démarrez le service. Ajoutez un gestionnaire qui recharge nginx quand la configuration change.
3. Le test qui compte — Exécutez le playbook deux fois de suite. Relevez le décompte final des deux exécutions. Que doit valoir « changed » la seconde fois ?
4. Casser l'idempotence — Ajoutez une tâche qui télécharge un fichier avec une commande shell. Réexécutez deux fois et observez le décompte. Expliquez pourquoi Ansible ne peut pas faire mieux.
5. La réparer, de deux façons — Corrigez d'abord avec une condition de création, puis en remplaçant la commande par un module dédié. Vérifiez le décompte après chaque correction, et dites laquelle vous préférez.
6. Chiffrer un secret — Placez le mot de passe de la base dans un fichier de variables chiffré, versionnez-le, et vérifiez qu'il est illisible sans la clé. Le playbook doit continuer de fonctionner.
7. Vérifier le gestionnaire — Modifiez le gabarit et relancez : le gestionnaire doit partir. Relancez sans rien modifier : il ne doit pas partir. Expliquez l'intérêt de ce comportement.

C'est réussi quand

• ✓ La seconde exécution affiche changed=0
• ✓ Le fichier de variables est illisible dans le dépôt
• ✓ Le gestionnaire ne se déclenche que lorsque quelque chose a réellement changé

Correction

# inventaire.yml
web:
hosts:
  labo1: { ansible_connection: docker }
  labo2: { ansible_connection: docker }

# site.yml
- hosts: web
tasks:
  - name: installer nginx
    ansible.builtin.package: { name: nginx, state: present }

  - name: déposer la page
    ansible.builtin.template:
      src: index.html.j2
      dest: /usr/share/nginx/html/index.html
      mode: "0644"
    notify: recharger nginx

  - name: démarrer le service
    ansible.builtin.service: { name: nginx, state: started }

handlers:
  - name: recharger nginx
    ansible.builtin.service: { name: nginx, state: reloaded }

PLAY RECAP (1re exécution)
labo1 : ok=3  changed=3   labo2 : ok=3  changed=3

PLAY RECAP (2e exécution)
labo1 : ok=3  changed=0   labo2 : ok=3  changed=0

# NON idempotent : changed à chaque exécution
- ansible.builtin.shell: curl -o /opt/outil https://exemple.net/outil

# correction 1 : condition de création
- ansible.builtin.shell: curl -o /opt/outil https://exemple.net/outil
args: { creates: /opt/outil }

# correction 2, préférable : un module dédié
- ansible.builtin.get_url:
  url: https://exemple.net/outil
  dest: /opt/outil
  mode: "0755"

ansible-vault create group_vars/web/secrets.yml
# on y écrit :  mot_de_passe_base: secret

git add group_vars/web/secrets.yml     # versionné, illisible
cat group_vars/web/secrets.yml         # $ANSIBLE_VAULT;1.1;AES256 …

ansible-playbook site.yml --ask-vault-pass