Configuration

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