Provisionnement déclaratif

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