CLAUDE.md, contenus, prompt et référentiel

CLAUDE.md

@@ -0,0 +1,240 @@
+# CLAUDE.md — Projet Paillasse
+
+> Lis ce fichier en entier avant toute action. Il fait foi sur le contexte, les priorités, l'architecture, la sécurité et le style.
+> Nom de travail : **Paillasse**. Porteur : Adam Belkacemi (Esquisse Formation).
+
+---
+
+## 1. Contexte et objectifs
+
+**Paillasse** : une plateforme de labs Linux et réseau pour l'enseignement (lycée NSI, BTS SIO SISR, BTS CIEL, BUT R&T, titres pro TSSR). Chaque élève obtient une vraie VM Debian dans le navigateur, en moins de 5 secondes, sur un cloud **OpenStack** hébergé en Europe (Hetzner). Correction automatique par scripts. **Aucune IA dans le produit.**
+
+Trois objectifs, dans cet ordre :
+
+1. **Candidature Senior SRE / Cloud Engineer chez Infomaniak.** Pouvoir dire : « J'opère un cloud OpenStack en production pour des classes : voici mes métriques, ma dernière montée de version, mon dernier incident. »
+2. **Candidature Backend Software Engineer (kDrive) chez Infomaniak**, en repli ou en parallèle. Pouvoir dire : « J'ai conçu une API Laravel documentée, performante (MariaDB, Redis), testée, avec stockage S3/Ceph. »
+3. **Un produit professionnel** pour les établissements et organismes de formation.
+
+Le choix de la pile (section 3) suit **la stack d'Infomaniak** : MariaDB, Laravel, Go, Redis, Grafana, ElasticSearch, S3/Ceph, WebDAV, Kubernetes. Chaque techno doit répondre à **un vrai besoin** de Paillasse, jamais être ajoutée « pour le CV ».
+
+Cahier des charges complet : `docs/cahier-des-charges.md` (à exporter depuis l'artifact « Paillasse »).
+
+### Règle d'or pour Claude
+
+Adam doit **comprendre et pouvoir expliquer** tout ce qui est construit (il en parlera en entretien technique). Pour chaque étape :
+- explique ce que tu vas faire et pourquoi, **avant** de le faire ;
+- après, résume ce qui a changé et comment le vérifier ;
+- propose à Adam de refaire lui-même les manipulations et le code clés ;
+- ajoute une entrée dans `docs/journal.md` (date, ce qui a été fait, ce qui a cassé, ce qu'on a appris).
+
+---
+
+## 2. Priorités
+
+Ne commence pas un bloc avant que le précédent soit terminé, sauf demande explicite d'Adam.
+
+### Bloc A — Infra (poste SRE), semaines 1 à 8
+
+| Semaine | Livrable | Critère de fin |
+|---|---|---|
+| 1 | Serveur dédié installé (Debian 13, RAID 1), durci, sauvegardé | SSH par clé seulement, pare-feu actif, `docs/runbooks/serveur.md` |
+| 2 | OpenStack tout-en-un (Kolla-Ansible) fonctionnel | Une VM Debian créée, joignable en console série |
+| 3 | Supervision hors du serveur (CX23) : Prometheus, **Grafana**, Uptime Kuma, alertes | Une alerte reçue lors d'une panne provoquée |
+| 4 | Portail minimal **Laravel** : comptes, une classe, lancement d'un lab, console web (xterm.js) | Un élève test fait le lab « Premiers pas dans le shell » |
+| 5 | Stock chaud de VM (files **Redis**) + correction automatique (agent invité QEMU) | Terminal ouvert en < 5 s (p95), vérification OK |
+| 6 | Self-healing : VM figée relancée, stock reconstitué, service redémarré | Panne provoquée → réparée sans intervention, post-mortem écrit |
+| 7 | Montée de version d'OpenStack documentée | Runbook + retour d'expérience |
+| 8 | Pilote avec une vraie classe | Métriques réelles, retours des élèves et du prof |
+
+### Bloc B — Backend (poste kDrive)
+
+1. API publique Laravel versionnée (`/api/v1`), documentée en OpenAPI, tests Pest, jetons Sanctum, quotas et limites de débit dans Redis.
+2. Cache Redis sur les lectures lourdes (catalogue, tableau de bord prof) ; mesure avant/après dans Grafana.
+3. Optimisation MariaDB : index, `EXPLAIN`, requêtes N+1 supprimées, jeu de données de charge (ex. 500 classes, 20 000 élèves).
+4. Stockage des travaux d'élèves et des rendus sur **S3** (Hetzner Object Storage), avec versioning.
+
+### Bloc C — Plus tard
+
+- **Ceph** comme stockage d'OpenStack (Glance, Cinder) : démo mono-serveur d'abord, vrai cluster au 2ᵉ serveur.
+- **WebDAV** : dossier de l'élève montable comme lecteur réseau.
+- **ElasticSearch** : recherche plein texte dans les cours et labs (seulement si le besoin est réel).
+- 2ᵉ serveur, passage à **OCI** (Debian + Puppet), haute disponibilité (Galera, Ceph), **Kubernetes** pour le portail.
+- MCP pour développeurs (voir section 6).
+
+---
+
+## 3. Architecture
+
+```
+Navigateurs (élèves, profs)          Développeurs (API, MCP)
+        │ HTTPS 443 uniquement (réseaux scolaires filtrés)
+        ▼
+Hetzner Cloud CX23 ── Caddy (TLS) ── Front (Inertia + React) ── Laravel (API + portail)
+        │                            MariaDB · Redis (cache, files, sessions, quotas)
+        │                            Workers Laravel Horizon : stock chaud, ordonnanceur
+        │                            Proxy console WebSocket (Go)
+        │                            Prometheus · Grafana · Uptime Kuma (page de statut)
+        │ API OpenStack (TLS, IP du CX23 autorisée seulement)
+        ▼
+Serveur dédié Server Auction : i7-6700, 64 Go, 2 × 500 Go SSD RAID 1, Debian 13
+        OpenStack Kolla-Ansible tout-en-un : Keystone, Nova, Neutron (OVN), Glance, Cinder (LVM, puis Ceph),
+        Placement, Heat, nova-serialproxy
+        Un projet par établissement · un réseau par classe · pas d'IP publique par VM (NAT)
+        Filtrage sortant : seuls les miroirs de paquets (cache apt) sont joignables
+        ▼
+Hetzner Object Storage (S3) : travaux d'élèves, sauvegardes MariaDB, config, images
+```
+
+### Choix techniques (à respecter)
+
+- **Console élève** : console série Nova (`nova-serialproxy`), relayée par un petit **proxy WebSocket en Go**, affichée avec **xterm.js**. Elle doit marcher même si l'élève casse le réseau de sa VM.
+- **Correction** : service sur l'hyperviseur qui exécute les vérifications via **l'agent invité QEMU** (`hw_qemu_guest_agent=yes`). Pas de réseau vers la VM.
+- **Topologies** : chaque lab est un **modèle Heat**.
+- **Stock chaud** : N VM démarrées en permanence, gérées par des jobs Laravel dans Redis ; taille ≈ lancements/min × 45 s + marge (8 au départ). Les séances réservées pré-créent les VM 10 min avant.
+- **Capacité** : ~56 VM de 768 Mo sur 64 Go (à mesurer). Refuser proprement une réservation qui dépasse.
+- **Gros labs réseau** : Kathará (routeurs en conteneurs dans une seule VM).
+- **Pas de Windows** avant d'avoir étudié les licences (SPLA). Utiliser Samba AD.
+- **Octavia, Magnum** : pas avant le deuxième serveur.
+
+### Pile logicielle
+
+| Couche | Choix |
+|---|---|
+| Backend | PHP 8.3+, **Laravel** (Sanctum, Horizon, Pest), **MariaDB**, **Redis**, client OpenStack (API REST ou `php-opencloud/openstack`) |
+| Front | Inertia.js + React + TypeScript, Tailwind CSS, shadcn/ui, Radix |
+| Services en Go | Proxy console WebSocket ; correcteur sur l'hyperviseur (Go ou Python, au choix d'Adam) |
+| Consoles | xterm.js (texte), noVNC (graphique, plus tard) |
+| Stockage | Hetzner Object Storage (S3) ; Ceph au bloc C |
+| LTI Moodle (V2) | `packbackbooks/lti-1p3-tool` |
+| SSO ENT (V3) | Keycloak |
+| Infra as code | Ansible, Kolla-Ansible puis OCI/Puppet, Heat, Terraform pour Hetzner Cloud |
+| Supervision | Prometheus, **Grafana**, Uptime Kuma, Alertmanager ; métriques Laravel (temps de réponse, files Redis) |
+| Sauvegardes | restic vers Object Storage, restauration testée chaque semaine |
+| CI | **Forgejo Actions** (syntaxe proche de GitLab CI / GitHub Actions) |
+| Tests | Pest, Playwright (parcours), axe-core (accessibilité) |
+
+---
+
+## 4. Sécurité : règles non négociables
+
+1. **Secrets** : jamais dans le code, jamais dans Git, jamais affichés en clair. Fichier `.env` (dans `.gitignore`) ou gestionnaire de secrets. Ne demande jamais à Adam de coller un secret dans la conversation.
+2. **Clé SSH dédiée** à Claude Code (`~/.ssh/paillasse_claude`), révocable. Jamais la clé personnelle d'Adam.
+3. **Projet Hetzner séparé** pour Paillasse, jetons d'API aux droits minimaux. **Ne touche jamais au serveur `tripoli-cloud`** ni à ses ressources.
+4. **Avant toute commande destructrice** (`installimage`, `rm -rf`, `mkfs`, suppression de ressource, `DROP`, `migrate:fresh`, réinstallation, pare-feu, routes) : explique, montre la commande exacte, vérifie la sauvegarde, **attends la confirmation explicite d'Adam**.
+5. **Ne jamais te couper l'accès** : avant de modifier SSH ou le pare-feu, garde une session ouverte et prévois le retour arrière (mode rescue Hetzner).
+6. **Commandes et dépenses** : jamais par Claude. Adam commande à la main.
+7. **Données d'élèves** : minimisation (nom, prénom, groupe), pas d'e-mail pour les mineurs, suppression automatique 90 jours après l'archivage de fin d'année.
+8. **Anti-abus** : trafic sortant des VM bloqué par défaut, quotas CPU/RAM/durée, journaux.
+9. **API** : jetons hachés, droits par jeton, limites de débit, en-têtes de sécurité, validation stricte des entrées (cf. « API hardening » demandé par Infomaniak).
+10. **Pas de `--dangerously-skip-permissions`** sur une machine qui touche aux serveurs.
+
+---
+
+## 5. Code source et dépôt
+
+- **Forge privée Forgejo** sur le serveur d'Adam. **Aucun dépôt public** (pas de GitHub public). Le code n'est montré à un recruteur que s'il le demande.
+- Licence des contenus pédagogiques : **au choix d'Adam** (à décider plus tard). Ne pas écrire de mention de licence sans son accord.
+
+```
+paillasse/
+├── CLAUDE.md
+├── docs/
+│   ├── cahier-des-charges.md
+│   ├── journal.md              # journal d'apprentissage et de bord
+│   ├── runbooks/               # une procédure par opération (install, upgrade, restauration…)
+│   ├── postmortems/            # AAAA-MM-JJ-titre.md
+│   └── adr/                    # 0001-kolla-avant-oci.md, 0002-laravel-plutot-que-fastapi.md…
+├── infra/
+│   ├── ansible/  kolla/  heat/  images/  terraform/
+├── app/                        # Laravel (API + portail + front Inertia/React)
+├── console-proxy/              # Go
+├── grader/                     # service de correction sur l'hyperviseur
+├── labs/                       # consignes (Markdown), vérifications, indices (format YAML du pack de contenus)
+└── ops/                        # supervision, alertes, tableaux de bord Grafana
+```
+
+### Conventions
+
+- Commits en français, courts, au présent : « ajoute le stock chaud de VM ».
+- Une branche par fonctionnalité, fusion après tests et relecture.
+- Chaque décision structurante → un ADR. Chaque incident réel ou provoqué → un post-mortem.
+- Code PHP : PSR-12, types stricts, Laravel Pint, PHPStan (Larastan) niveau 6 minimum.
+- Textes de l'interface en français, du point de vue de l'utilisateur (« Lancer le lab », pas « Provisionner l'instance »).
+
+---
+
+## 6. Produit : points clés (détails dans le cahier des charges)
+
+- **Rôles** : administrateur d'établissement, enseignant, élève, formateur, opérateur.
+- **5 façons d'ajouter des élèves** : code ou QR de classe (validation par le prof), import CSV, saisie rapide, invitation e-mail (V2), Moodle LTI 1.3 (V2).
+- **Élèves mineurs** : identifiant + code secret imprimés sur une fiche de connexion (PDF, QR à usage unique).
+- **Espace de lab** : consignes à gauche, consoles au centre (un onglet par VM), topologie + vérification + indices à droite, bouton « Lever la main ».
+- **Séance en direct** : tuiles par élève (étape, bloqué > 8 min, main levée), lecture et prise de main de la console, mode examen.
+- **Bibliothèque** : séquences cours + TD + quiz + lab, reliées aux référentiels, « Dupliquer et adapter ». Refuser à l'import tout contenu « non commercial » (NC). Quiz en GIFT / Moodle XML.
+- **Cours texte gratuits** (Linux, réseau), pratique sur VM payante.
+- **API payante et MCP** : un seul cœur d'API, trois portes (site, API, MCP). Quotas par jeton dans Redis. Les classes restent prioritaires sur la capacité.
+- **Tout passe par le port 443** et doit marcher sur de vieux PC, Chromebooks et connexions lentes.
+
+---
+
+## 7. Design : beaucoup de style, sans sacrifier la clarté
+
+### Direction artistique
+
+- **Idée** : la paillasse de labo et l'établi d'atelier. Précis, technique, chaleureux. Pas le look « SaaS générique ».
+- **Typographies** : Bricolage Grotesque (titres, avec retenue), IBM Plex Sans (texte), IBM Plex Mono (terminal, chiffres, identifiants).
+- **Palette de départ** (jetons CSS, thèmes clair et sombre) :
+  - encre `#13233A` · vert paillasse `#2F5D50` · ambre `#C98404` · fond `#F4F6F2`
+  - sémantique : succès `#3C8A5A`, alerte ambre, erreur `#A63D2A`
+- **Le terminal est le héros** : couleurs, curseur, police mono soignés.
+- **Deux registres** : pages vitrines expressives (effet wow) ; application sobre, dense, lisible.
+- **Mouvement** : quelques moments orchestrés, jamais gratuits, respecter `prefers-reduced-motion`.
+- **À éviter** : dégradé violet-bleu, emojis comme icônes, tout centré, ombres et arrondis identiques partout.
+
+### Source de vérité : Figma
+
+- Les jetons (couleurs, typo, espacements, rayons) sont définis en **variables Figma**, puis reportés dans `app/resources/css/tokens.css`.
+- Les écrans clés sont maquettés dans Figma **avant** d'être codés. Claude lit les maquettes via le **MCP Figma** et reprend les jetons et composants existants ; il ne réinvente pas un style.
+
+### Accessibilité (obligatoire : clients publics)
+
+- Contraste AA, navigation au clavier, focus visible, libellés sur tous les champs.
+- Tests axe-core dans la CI ; parcours clés vérifiés avec Playwright. Référence : RGAA.
+
+### Outils de design pour Claude Code
+
+Vérifier chaque commande dans la documentation officielle avant de la lancer.
+
+| Outil | Rôle | Installation (à vérifier) |
+|---|---|---|
+| Figma MCP | Lire les maquettes et variables Figma | `claude mcp add --transport http figma https://mcp.figma.com/mcp` |
+| frontend-design (Anthropic) | Direction esthétique | dépôt `anthropics/skills` |
+| taste-skill | Variété, mouvement, densité | `npx skills add https://github.com/Leonxlnx/taste-skill --skill "design-taste-frontend"` |
+| UI/UX Pro Max | Styles, polices, ergonomie | dépôt `nextlevelbuilder/ui-ux-pro-max-skill` |
+| 21st.dev Magic MCP | Composants React pour les pages vitrines | voir `21st.dev/mcp` |
+| shadcn MCP | Composants shadcn/ui | documentation shadcn |
+| Playwright MCP | Voir et tester les écrans | `claude mcp add playwright npx @playwright/mcp@latest` |
+| Context7 | Documentation à jour (Laravel, OpenStack…) | dépôt `upstash/context7` |
+
+**Avant d'installer un skill** : lire son `SKILL.md`.
+
+### Méthode
+
+1. Jetons d'abord, puis une page `/design` qui montre tous les composants.
+2. Base de l'application : shadcn/ui restylé avec nos jetons.
+3. 21st.dev surtout pour les pages vitrines, chaque composant adapté aux jetons.
+4. Après chaque écran : capture Playwright, comparaison avec la maquette Figma, test axe-core.
+
+---
+
+## 8. Ce que Claude ne doit pas faire
+
+- Ajouter de l'IA dans le produit.
+- Ajouter une techno sans besoin réel dans Paillasse.
+- Commander, supprimer ou modifier des ressources payantes sans accord explicite.
+- Toucher à `tripoli-cloud`.
+- Publier du code ou créer un dépôt public.
+- Réutiliser des contenus sous licence NC dans le catalogue.
+- Intégrer une bibliothèque GPL/AGPL côté service sans signaler la question de licence.
+- Commencer un bloc avant la fin du précédent (section 2), sauf demande explicite d'Adam.
+- Faire à la place d'Adam une étape qu'il veut apprendre : dans le doute, demande.

docs/prompt-deploiement-paillasse.md

@@ -0,0 +1,298 @@
+# Prompt Claude Code : déploiement complet de Paillasse
+
+> À coller dans Claude Code, lancé depuis la racine du dépôt `Paillasse` sur le Mac d'Adam.
+> Remplacer les valeurs entre `<...>` avant de lancer.
+
+---
+
+## 0. Contexte
+
+Tu vas déployer **Paillasse** de bout en bout sur un serveur bare metal, jusqu'à une version utilisable par une vraie classe.
+
+Lis d'abord `CLAUDE.md` et `paillasse-contenus/README.md`. Ils contiennent le contexte complet du projet, la stack et les règles.
+
+**Paillasse** : une plateforme de labs Linux et réseau pour les écoles. Chaque élève a une vraie VM Debian, avec une console dans le navigateur et une correction automatique par scripts. Pas d'IA dans le produit.
+
+**Le serveur**
+- Scaleway Dedibox **Start-2-L**, datacenter DC2 (France).
+- Xeon D-1531 (6 cœurs / 12 threads), **32 Go de RAM**, 2 × 250 Go SSD.
+- **Une seule IP publique** : `<IP_SERVEUR>`.
+- Debian `<12 ou 13>`, installé par Adam depuis la console Dedibox.
+- Accès SSH : `ssh <UTILISATEUR>@<IP_SERVEUR>`, avec la clé dédiée `~/.ssh/<CLE_CLAUDE>`. Crée l'alias `paillasse` dans `~/.ssh/config`.
+- Sauvegardes : **Dedibackup 100 Go** (FTP, joignable uniquement depuis le serveur). Adam a déposé les identifiants dans `/root/.dedibackup` (`chmod 600`). Ne les affiche jamais.
+
+**La forge** : `ssh://git@forge.adam.belkacemi.me:2222/adam/Paillasse.git`. Tu n'y fais que `git push` : aucune connexion SSH à la machine qui l'héberge.
+
+**Le domaine** : `<DOMAINE>`. Adam l'achète et configure le DNS lui-même.
+
+---
+
+## 1. Règles non négociables
+
+1. **Ne jamais toucher à `tripoli-cloud`** ni à aucune autre machine que le serveur Paillasse et le Mac d'Adam.
+2. **Aucun secret** dans le code, dans Git, dans le journal ou dans la conversation.
+   - Les secrets vivent dans des fichiers `chmod 600` sur le serveur, ou dans un `.env` ignoré par Git.
+   - Les secrets Ansible passent par **Ansible Vault**. Le mot de passe du vault reste hors du dépôt.
+   - Kolla : `passwords.yml` n'est jamais commité en clair.
+3. **Commandes à risque : explique, montre la commande, vérifie la sauvegarde, puis attends le « OK » d'Adam.** Sont concernés :
+   - suppressions (`rm -rf`, `DROP`, `kolla-ansible destroy`…) ;
+   - disques, partitions, RAID ;
+   - toute modification du **réseau**, du **pare-feu** ou de **SSH** ;
+   - redémarrage du serveur.
+4. **Anti-coupure SSH** : avant toute modification du réseau, du pare-feu ou de SSH, programme un retour automatique à l'ancienne configuration dans 5 minutes (par exemple avec `systemd-run --on-active=5min`), puis annule-le une fois l'accès vérifié depuis une **nouvelle** session SSH.
+5. **Tu ne commandes et ne paies jamais rien.**
+6. **Élèves mineurs** : minimisation des données.
+   - Un élève = un pseudonyme et un code. Pas d'e-mail, pas de nom complet obligatoire.
+   - Suppression automatique 90 jours après l'archivage d'une classe.
+7. **Tout est du code** :
+   - chaque configuration passe par un rôle Ansible idempotent dans `ansible/` ;
+   - une commande tapée à la main pour explorer doit ensuite être codifiée ;
+   - relancer un playbook ne doit rien casser.
+8. **Vérifie les versions dans la documentation officielle**, jamais de mémoire : Kolla-Ansible, OS supportés, Laravel, PHP, Go. Utilise Context7 ou le web.
+9. **Documentation en français** (docs, commentaires, messages de commit).
+
+---
+
+## 2. Méthode de travail
+
+### Pour chaque étape
+
+1. Annonce l'étape et son critère de réussite.
+2. Fais le travail.
+3. **Vérifie le critère par un test réel** et montre la sortie.
+4. Écris dans `docs/journal.md` :
+   - ce qui a été fait ;
+   - les commandes clés ;
+   - les problèmes rencontrés et leur solution ;
+   - un paragraphe **« Comprendre »** de 3 à 6 phrases, qui explique simplement le pourquoi à Adam.
+5. `git commit`, puis `git push`.
+6. Passe à l'étape suivante sans attendre, sauf si une règle de la section 1 impose l'accord d'Adam.
+
+### Limite de temps
+
+**1 h 30 maximum par étape.** Si elle est dépassée :
+- arrête-toi ;
+- écris le blocage dans `docs/journal.md` (symptôme, pistes essayées, hypothèses) ;
+- propose 2 options à Adam et attends sa décision.
+
+### Arborescence du dépôt
+
+```
+ansible/          inventaire, playbooks, rôles
+kolla/            globals.yml, inventaire all-in-one (passwords.yml : chiffré ou hors Git)
+openstack/        modèles Heat, flavors, scripts de construction d'images
+portail/          application Laravel
+proxy-console/    service Go
+labs/             copie de travail des labs YAML
+docs/             journal.md, runbooks/, inventaire-serveur.md, post-mortems/
+```
+
+---
+
+## 3. Les étapes
+
+### Étape 1 : Reconnaissance (lecture seule)
+
+- Relève sur le serveur :
+  - OS, noyau, CPU ;
+  - virtualisation matérielle (`vmx`) et `/dev/kvm` ;
+  - RAM, disques, RAID ;
+  - interfaces réseau, IP, passerelle, DNS.
+- Vérifie quelle version stable de Kolla-Ansible supporte la Debian installée. Si elle ne supporte pas Debian 13, **arrête-toi** et recommande à Adam de réinstaller en Debian 12.
+- Écris `docs/inventaire-serveur.md`.
+
+**Critère :** inventaire écrit, KVM disponible, version de Kolla-Ansible choisie et justifiée.
+
+### Étape 2 : Durcissement (Ansible depuis le Mac)
+
+- Installe Ansible sur le Mac s'il manque. Crée `ansible/inventory.ini` et un rôle `durcissement` :
+  - utilisateur d'administration, `sudo` ;
+  - SSH par clé uniquement, `PermitRootLogin no` ;
+  - fail2ban, `unattended-upgrades`, chrony, fuseau `Europe/Paris` ;
+  - pare-feu nftables : seuls **22, 80 et 443** ouverts sur l'IP publique.
+- Attention : `kolla-ansible bootstrap-servers` peut désactiver le pare-feu. Prévois-le dès maintenant (réglage Kolla adapté, ou rôle nftables rejoué après Kolla).
+
+**Critère :**
+- connexion par clé OK ;
+- connexion par mot de passe refusée, root refusé ;
+- depuis le Mac, `nmap <IP_SERVEUR>` ne montre que 22, 80 et 443.
+
+### Étape 3 : Sauvegardes vers Dedibackup
+
+- Utilise **restic**, chiffré, avec **rclone** comme backend FTP vers Dedibackup.
+- Le mot de passe restic est dans un fichier root en `chmod 600`.
+- À sauvegarder : `/etc`, `/home`, `/root`, `/etc/kolla` (plus tard), les dumps MariaDB de l'app (plus tard), le dossier du portail.
+- Programmation : timer systemd quotidien, rétention 7 jours / 4 semaines / 3 mois.
+- Écris `docs/runbooks/sauvegardes.md`.
+
+**Critère :** une sauvegarde est faite et **un fichier est restauré avec succès** dans `/tmp`.
+
+### Étape 4 : Réseau pour OpenStack (accord d'Adam obligatoire)
+
+L'objectif est de ne jamais mettre Neutron sur l'interface publique.
+
+- Crée une interface `dummy0` avec une IP privée (par exemple `10.10.0.1/24`). Elle servira à `network_interface` et `kolla_internal_vip_address` (Kolla sans HAProxy).
+- Crée une paire veth. `neutron_external_interface` utilise un bout de la paire. L'autre bout porte la passerelle du réseau externe OpenStack, avec un NAT masquerade nftables.
+- Rends le tout persistant avec systemd-networkd et le rôle Ansible `reseau-openstack`.
+- Applique la règle anti-coupure SSH, puis **redémarre, avec l'accord d'Adam**.
+
+**Critère :** après redémarrage, le SSH répond, `dummy0` et la paire veth sont présents, et Internet reste joignable depuis le serveur.
+
+### Étape 5 : Kolla-Ansible tout-en-un
+
+- Dans un venv Python : la version de Kolla-Ansible choisie à l'étape 1, puis `kolla-ansible install-deps`.
+- Dans `kolla/globals.yml` (**vérifie les noms exacts dans la doc de la version**), les idées sont :
+  - `enable_haproxy: "no"`, `enable_horizon: "no"` ;
+  - `enable_heat: "yes"`, `enable_nova_serialconsole_proxy: "yes"` ;
+  - `nova_compute_virt_type: "kvm"` ;
+  - `enable_prometheus` et `enable_grafana` si c'est le plus simple pour l'étape 7.
+- Mots de passe : `kolla-genpwd`. Jamais de `passwords.yml` en clair dans Git.
+- Lance `bootstrap-servers`, `prechecks`, `deploy`, puis `post-deploy`. Installe le client `openstack`.
+- Rejoue le rôle pare-feu si Kolla l'a modifié.
+
+**Critère :**
+- `openstack service list` et `openstack compute service list` sont OK ;
+- aucune API OpenStack n'est joignable depuis l'IP publique (vérifie avec `nmap`).
+
+### Étape 6 : Première VM en console série
+
+1. Crée le projet `paillasse` et un utilisateur de service avec des **application credentials**, stockés dans un fichier `chmod 600`.
+2. Construis l'image `paillasse-debian` avec `virt-customize`, à partir de l'image cloud Debian officielle :
+   - `qemu-guest-agent` ;
+   - un getty sur `ttyS0` ;
+   - l'utilisateur `eleve` ;
+   - les outils réseau des labs (iproute2, iputils, tcpdump, traceroute, dnsutils, et frr si le lab l'exige).
+3. Propriété de l'image : `hw_qemu_guest_agent=yes`.
+4. Crée la flavor `eleve.petit` : 1 vCPU, 768 Mo, 5 Go.
+5. Démarre une VM et récupère l'adresse de sa console série avec l'API Nova `remote-consoles` (protocole `serial`).
+
+**Critère :** un petit script (websocat ou Python) connecté au WebSocket de la console série affiche l'invite de connexion, et une commande tapée s'exécute.
+
+### Étape 7 : Supervision et alertes
+
+- Prometheus, node_exporter et Grafana : ceux de Kolla si possible.
+- Uptime Kuma en conteneur Docker, écoutant sur `127.0.0.1`.
+- Alertes : disque > 80 %, RAM > 90 %, service OpenStack arrêté, dernière sauvegarde de plus de 26 h, serveur injoignable.
+- Notifications par webhook : l'URL est un secret.
+- Tant qu'il n'y a pas de domaine, accès par tunnel SSH uniquement.
+
+**Critère :** une alerte de test est **reçue** par Adam.
+
+### Étape 8 : Portail Laravel minimal
+
+- Nginx et PHP-FPM, avec une version de PHP compatible avec la dernière version de Laravel.
+- MariaDB et Redis **pour l'app** en Docker Compose, liés à `127.0.0.1`, sur des ports différents de ceux de Kolla (par exemple 3307 et 6380).
+- Laravel, avec Inertia et React (starter kit officiel), dans `portail/`.
+- Modèles :
+  - `Etablissement`, `User` (prof), `Classe`, `Eleve` (pseudonyme et code uniquement) ;
+  - `Lab`, `Seance`, `LabSession` (élève, lab, id de la stack ou des VM, état, expiration).
+- Connexion :
+  - le prof avec un e-mail et un mot de passe ;
+  - l'élève avec un code de classe et un code élève, sur un seul écran `/connexion`.
+- Un prof crée une classe et génère les codes de ses élèves.
+- Design : la palette et les polices de `CLAUDE.md`, sobre.
+- Tests **Pest** pour la connexion et la création de classe.
+
+**Critère :** les tests Pest passent, et un élève fictif se connecte et voit son tableau de bord.
+
+### Étape 9 : Proxy console Go et xterm.js
+
+- Service Go dans `proxy-console/`, écoutant sur `127.0.0.1:8081`, lancé par systemd. Nginx relaie `/console` en WebSocket sur le port 443.
+- Déroulé :
+  1. Laravel demande à Nova l'adresse de la console série.
+  2. Laravel la range dans Redis sous un **jeton aléatoire**, pour 5 minutes.
+  3. Le navigateur reçoit uniquement ce jeton.
+  4. Le proxy lit Redis, ouvre le WebSocket vers nova-serialproxy et recopie les octets dans les deux sens.
+- La console série n'accepte qu'**une seule connexion** : c'est le proxy qui duplique le flux vers la vue du prof, en lecture seule.
+- Côté front : xterm.js, avec un onglet par VM du lab.
+
+**Critère :** dans le navigateur, l'élève tape `ip a` dans sa VM et voit le résultat, et un autre élève ne peut pas ouvrir cette console.
+
+### Étape 10 : Liaison Laravel ↔ OpenStack et lab 08
+
+- Client OpenStack dans Laravel, avec le client HTTP de Laravel ou `php-opencloud/openstack`, via les application credentials.
+- Modèle Heat du lab 08 (deux LAN et un routeur), d'après `paillasse-contenus/` :
+  - réseaux de lab **sans DHCP**, avec `port_security_enabled: false` ;
+  - **aucun routeur vers l'extérieur** : les VM des labs n'ont pas accès à Internet.
+- Jobs dans une file Redis :
+  - `CreerStackLab` ;
+  - `SupprimerStackLab` ;
+  - expiration automatique des sessions.
+
+**Critère :** le bouton « Lancer le lab 08 » crée une stack `CREATE_COMPLETE`, et les terminaux de chacune de ses VM s'ouvrent.
+
+### Étape 11 : Stock chaud et correction automatique
+
+**Stock chaud**
+- Une liste Redis de stacks prêtes par lab, remplie par un job.
+- Taille par défaut : calculée par toi selon la RAM disponible, et configurable.
+- Pré-remplissage automatique 10 minutes avant une séance.
+
+**Correction**
+- Un petit service `correcteur`, lancé par systemd, écoutant sur un socket Unix.
+- Il accepte **uniquement** : uuid d'instance, id du lab, id de la vérification.
+- Il exécute les vérifications **définies dans le YAML du lab** avec `guest-exec` de l'agent QEMU (par `virsh`, dans le conteneur `nova_libvirt`).
+- Jamais de commande libre venant du portail.
+- Laravel enregistre la note et le message pour l'élève.
+
+**Critère :**
+- un lab pris dans le stock s'ouvre en **moins de 5 s** ;
+- une configuration correcte donne « réussi » ;
+- une configuration incorrecte donne « échoué » avec un message utile.
+
+### Étape 12 : Domaine, HTTPS et sécurité (Adam a configuré le DNS)
+
+- Certificat Let's Encrypt (certbot, plugin Nginx) et renouvellement automatique.
+- En-têtes de sécurité : HSTS, CSP adaptée à xterm.js, etc.
+- Grafana et Uptime Kuma derrière authentification, et la page de statut publique.
+- Vérifie à nouveau que seuls 22, 80 et 443 sont ouverts, et qu'aucune VM élève n'a d'IP publique ni d'accès sortant.
+
+**Critère :** `https://<DOMAINE>` affiche un certificat valide, et le parcours prof → élève → lab → correction fonctionne en HTTPS.
+
+### Étape 13 : Tests de capacité et de résistance
+
+- Lance 20 VM `eleve.petit` en même temps. Mesure la RAM, le CPU et les temps de démarrage, puis écris `docs/capacite.md`.
+- Restaure une sauvegarde complète du portail sur une copie de test.
+- **Avec l'accord d'Adam**, redémarre le serveur : tout doit revenir seul (Kolla, portail, proxy, correcteur, supervision).
+
+**Critère :**
+- les chiffres de capacité sont écrits ;
+- la restauration est réussie ;
+- tout est revenu seul après le redémarrage.
+
+### Étape 14 : Pages légales et RGPD
+
+Pages à créer :
+- `/legal` : mentions légales (Esquisse Formation ; le SIREN et l'adresse sont à compléter par Adam) ;
+- la politique de confidentialité ;
+- la page de statut.
+
+Job de purge : suppression 90 jours après l'archivage d'une classe.
+
+Interdits :
+- logo Marianne ou ministère ;
+- drapeau de l'UE ;
+- faux « logo RGPD » ;
+- KPI inventés ou faux clients.
+
+Formulations autorisées : « Hébergé en France » (c'est vrai), et « Conforme au RGPD » avec un lien vers la politique de confidentialité.
+
+**Critère :** pages en ligne, et un test Pest prouve que la purge fonctionne.
+
+---
+
+## 4. Fin de mission
+
+Écris `docs/bilan.md`, avec :
+
+- ce qui fonctionne, avec la preuve de chaque critère ;
+- le temps réel passé par étape ;
+- la capacité mesurée (nombre d'élèves en même temps) ;
+- les dettes et les risques connus ;
+- **ce qu'Adam doit faire lui-même** : secrets à changer, comptes à créer, tests avec un prof, etc. ;
+- les prochaines étapes du bloc A :
+  - self-healing et post-mortem ;
+  - montée de version d'OpenStack ;
+  - pilote avec une vraie classe.
+
+Commence par l'étape 1.

docs/referentiel-pedagogique-paillasse.md

@@ -0,0 +1,661 @@
+# Référentiel pédagogique Paillasse (brouillon pour les maquettes)
+
+> **Source :** connaissance générale des programmes (BO, référentiels de BTS, programme national du BUT, RNCP).
+> **À vérifier** chapitre par chapitre sur les textes officiels **avant toute publication**.
+> Les licences pro et les bachelors n'ont **pas de programme national** : ce qui suit décrit les contenus habituels.
+> Le **DUT n'existe plus**, il est remplacé par le **BUT**.
+
+## Légende des activités
+
+| Tag | Activité |
+|---|---|
+| `[C]` | Cours texte gratuit |
+| `[Q]` | Quiz ou QCM auto-corrigé |
+| `[TD]` | Exercices papier ou calcul, corrigés en ligne |
+| `[LAB]` | TP sur une VM, avec correction automatique |
+| `[LAB+]` | Lab à plusieurs VM (topologie Heat ou Kathará) |
+| `[EXAM]` | Mode examen : chronométré, noté, sans aide |
+| `[PROJ]` | Projet sur plusieurs séances (SAÉ, projet de BTS) |
+| `[CTF]` | Défi de sécurité |
+| `(hors VM)` | Pas faisable sur une VM Debian : cours et quiz seulement, ou alternative indiquée |
+
+---
+
+# PARTIE 1 : PAR FORMATION
+
+## 1. Lycée, voie générale
+
+### SNT (Seconde)
+
+1. **Internet** : protocole IP, paquets, routage, DNS, TCP. `[C][Q][LAB]` (`ping`, `traceroute`, `dig`)
+2. **Le Web** : URL, HTTP, HTML/CSS, navigateur, moteurs de recherche. `[C][Q][LAB]` (`curl`, page HTML)
+3. **Réseaux sociaux** : graphes, petit monde, modèle économique. `[C][Q][TD]` (graphes)
+4. **Données structurées** : CSV, métadonnées, tables, cloud. `[C][Q][LAB]` (`grep`, `sort`, CSV en Python)
+5. **Localisation et cartographie** : GPS, NMEA, OpenStreetMap. `[C][Q][TD]` (trames NMEA)
+6. **Informatique embarquée et objets connectés** : capteurs, actionneurs, IHM. `[C][Q][LAB]` (MQTT simulé)
+7. **La photographie numérique** : pixels, RVB, EXIF, traitements. `[C][Q][LAB]` (`exiftool`, Pillow)
+8. **Transversal : programmation Python** (variables, conditions, boucles, fonctions). `[C][Q][LAB]`
+
+### NSI Première
+
+1. **Histoire de l'informatique.** `[C][Q]`
+2. **Représentation des données, types de base** :
+   - binaire, hexadécimal, entiers relatifs (complément à 2), flottants ;
+   - booléens, algèbre de Boole ;
+   - caractères (ASCII, Unicode, UTF-8).
+   `[C][Q][TD][LAB]`
+3. **Types construits** : tuples, listes, dictionnaires, p-uplets nommés. `[C][Q][LAB]`
+4. **Traitement de données en tables** : CSV, recherche, tri, fusion. `[C][Q][LAB]`
+5. **Interactions homme-machine sur le Web** :
+   - événements, formulaires, GET et POST ;
+   - client et serveur, HTTP.
+   `[C][Q][LAB]`
+6. **Architectures matérielles et systèmes d'exploitation** :
+   - modèle de von Neumann, circuits logiques, assembleur ;
+   - réseau : protocoles, bit alterné, TCP/IP, adresses ;
+   - OS : commandes Linux, droits, processus.
+   `[C][Q][TD][LAB]`
+7. **Langages et programmation** : spécification, tests, bibliothèques, mise au point. `[C][Q][LAB]`
+8. **Algorithmique** : parcours séquentiel, tris (insertion, sélection), dichotomie, glouton, k plus proches voisins, invariants, coût. `[C][Q][TD][LAB]`
+9. **Projets.** `[PROJ]`
+
+### NSI Terminale
+
+1. **Structures de données** : programmation objet, listes, piles, files, dictionnaires, arbres, arbres binaires de recherche, graphes. `[C][Q][TD][LAB]`
+2. **Bases de données** :
+   - modèle relationnel, schéma, contraintes ;
+   - SGBD, SQL (`SELECT`, `JOIN`, `INSERT`, `UPDATE`, `DELETE`).
+   `[C][Q][TD][LAB]` (MariaDB ou SQLite)
+3. **Architectures, OS et réseaux** :
+   - composants intégrés (SoC) ;
+   - processus, ordonnancement, interblocage ;
+   - routage RIP et OSPF ;
+   - sécurisation : chiffrement symétrique et asymétrique, HTTPS.
+   `[C][Q][TD][LAB][LAB+]`
+4. **Langages et programmation** : calculabilité, décidabilité, récursivité, modularité, paradigmes, mise au point. `[C][Q][LAB]`
+5. **Algorithmique** : parcours d'arbres et de graphes, diviser pour régner, programmation dynamique, recherche textuelle (Boyer-Moore). `[C][Q][TD][LAB]`
+6. **Épreuves** : épreuve écrite et **épreuve pratique chronométrée** (exercices de programmation Python). `[EXAM]`
+7. **Grand oral et projets.** `[PROJ]`
+
+---
+
+## 2. Bac technologique
+
+### STI2D, tronc commun « Ingénierie, innovation et développement durable » (I2D)
+
+- Chaîne d'information et chaîne d'énergie. `[C][Q]`
+- Numération, codage de l'information, logique combinatoire. `[C][Q][TD]`
+- Réseaux et communication : trames, adressage, protocoles. `[C][Q][LAB]`
+- Programmation, algorigrammes. `[C][Q][LAB]`
+
+### STI2D, spécialité SIN (Systèmes d'information et numérique)
+
+- Architecture des réseaux : modèle OSI, Ethernet, IP, masque, passerelle, commutation, routage. `[C][Q][TD][LAB+]`
+- Protocoles : TCP, UDP, HTTP, MQTT, Modbus TCP (simulé). `[C][Q][LAB]`
+- Objets connectés : capteurs, microcontrôleurs, IoT, cloud. `[C][Q][LAB]` (MQTT, Node-RED)
+- Programmation : Python, C/Arduino (simulé), machines à états, IHM. `[C][Q][LAB]`
+- Traitement du signal et de l'information : numérisation, échantillonnage, CAN. `[C][Q][TD]`
+- Cybersécurité de base. `[C][Q][LAB]`
+- Projet de terminale. `[PROJ]`
+
+### STMG, spécialité SIG (Systèmes d'information de gestion)
+
+- Système d'information et organisation, processus métier. `[C][Q]`
+- Données : modèle relationnel, **SQL**, requêtes, tableurs. `[C][Q][TD][LAB]`
+- Réseaux et infrastructure du SI : poste, serveur, réseau local, cloud. `[C][Q][LAB]`
+- Sécurité du SI : authentification, sauvegarde, RGPD, cybermenaces. `[C][Q][LAB]`
+- Programmation web simple (formulaires, pages dynamiques). `[C][Q][LAB]`
+- Projet. `[PROJ]`
+
+---
+
+## 3. Bac pro CIEL (Cybersécurité, informatique et réseaux, électronique)
+
+- **Préparer une installation** : lire un dossier technique, un plan d'adressage, le câblage. `[C][Q][TD]`
+- **Installer et configurer** :
+  - poste Linux, services réseau (DHCP, DNS, web) ;
+  - switch, VLAN, routage de base.
+  `[C][Q][LAB][LAB+]`
+- **Maintenir et dépanner** : diagnostic réseau, journaux, sauvegarde et restauration. `[C][Q][LAB]`
+- **Cybersécurité** :
+  - comptes, droits, mots de passe, pare-feu, mises à jour ;
+  - sensibilisation (hameçonnage).
+  `[C][Q][LAB][CTF]`
+- **Électronique et IoT** : capteurs, protocoles, objets connectés. `[C][Q][LAB]` (en partie hors VM)
+- **Relation client, documentation, compte rendu d'intervention.** `[C][Q]`
+- **Épreuves pratiques.** `[EXAM]`
+
+---
+
+## 4. BTS SIO (Services informatiques aux organisations)
+
+### Bloc 1 : Support et mise à disposition de services (commun)
+
+- Gérer le patrimoine informatique : inventaire, licences, GLPI. `[C][Q][LAB]` (GLPI dans une VM)
+- Répondre aux incidents et aux demandes : ticketing, ITIL. `[C][Q]`
+- Développer la présence en ligne : web, CMS, DNS, hébergement. `[C][Q][LAB]`
+- Travailler en mode projet : planning, Git. `[C][Q][LAB]`
+- Mettre à disposition un service : déploiement, documentation, tests. `[C][Q][LAB]`
+- Organiser son développement professionnel : veille. `[C]`
+
+### Bloc 2, option SISR : Administration des systèmes et des réseaux
+
+- Concevoir une solution d'infrastructure réseau : plan d'adressage, VLAN, routage. `[C][Q][TD][LAB+]`
+- Installer, tester, déployer :
+  - DHCP, DNS (Bind), web, annuaire (LDAP, **Samba AD** à la place d'AD) ;
+  - partage de fichiers (Samba, NFS), messagerie.
+  `[C][Q][LAB][LAB+]`
+- Exploiter, dépanner, superviser : Zabbix, Nagios, Prometheus, journaux, sauvegardes. `[C][Q][LAB]`
+- Haute disponibilité : Keepalived (VRRP), répartition de charge (HAProxy), RAID, réplication. `[C][Q][LAB+]`
+- Virtualisation : KVM, Proxmox (théorie), conteneurs Docker. `[C][Q][LAB]`
+- Scripts d'automatisation : Bash, Python, PowerShell (hors VM Linux). `[C][Q][LAB]`
+- Windows Server et Active Directory : `(hors VM)`, alternative Samba AD.
+
+### Bloc 2, option SLAM : Conception et développement d'applications
+
+- Conception : UML, cas d'utilisation, diagrammes de classes, MCD/MLD. `[C][Q][TD]`
+- Développement :
+  - objet (PHP, Java, C#, Python), MVC, frameworks ;
+  - API REST, tests unitaires.
+  `[C][Q][LAB]`
+- Bases de données : SQL avancé, procédures stockées, triggers, transactions. `[C][Q][TD][LAB]`
+- Web : HTML, CSS, JS, PHP, sessions, authentification. `[C][Q][LAB]`
+- Mobile `(hors VM)`.
+- Versioning Git, intégration continue. `[C][Q][LAB]`
+
+### Bloc 3 : Cybersécurité des services informatiques (commun, plus la spécialisation SISR ou SLAM)
+
+- Protéger les données personnelles : RGPD, registre de traitement. `[C][Q]`
+- Préserver l'identité numérique : authentification, MFA, mots de passe. `[C][Q][LAB]`
+- Sécuriser les équipements et les usages : durcissement, mises à jour, pare-feu. `[C][Q][LAB]`
+- Garantir la disponibilité, l'intégrité et la confidentialité : sauvegardes, chiffrement, PKI, certificats. `[C][Q][LAB]`
+- Cybersécurité d'une infrastructure (SISR) : VPN, DMZ, IDS, segmentation, journaux. `[C][Q][LAB+][CTF]`
+- Cybersécurité d'une application (SLAM) : OWASP Top 10, injection SQL, XSS, CSRF, hachage des mots de passe. `[C][Q][LAB][CTF]`
+- Réagir à un incident : analyse des journaux, remédiation. `[C][Q][LAB]`
+
+### Mathématiques pour l'informatique (BTS SIO)
+
+- Numération : bases 2, 8, 10, 16, conversions, codage. `[C][Q][TD]`
+- Arithmétique : divisibilité, PGCD, congruences, **modulo**, chiffrement (César, affine, RSA). `[C][Q][TD][LAB]` (RSA en Python)
+- Logique : calcul propositionnel, algèbre de Boole, tables de vérité, Karnaugh. `[C][Q][TD]`
+- Ensembles et relations. `[C][Q][TD]`
+- Matrices : opérations, matrice d'adjacence. `[C][Q][TD]`
+- Graphes : chemins, plus court chemin (Dijkstra, lien avec OSPF), ordonnancement (PERT). `[C][Q][TD][LAB]`
+- Suites et algorithmes, fonctions. `[C][Q][TD]`
+- Algorithmique appliquée. `[C][Q][LAB]`
+
+### Autres matières (cours et quiz seulement)
+
+- CEJM : culture économique, juridique et managériale (dont le droit du numérique et le RGPD). `[C][Q]`
+- Culture générale et expression. `(hors VM)`
+- Anglais technique : vocabulaire réseau et système. `[C][Q]`
+
+### Épreuves
+
+- **E4** : support et mise à disposition de services (portfolio de réalisations).
+- **E5** : administration des systèmes et des réseaux (SISR) ou conception et développement d'applications (SLAM). Contient une **partie pratique**.
+- **E6** : cybersécurité.
+
+Côté app : épreuves blanches chronométrées `[EXAM]`, et un **portfolio exportable** des labs réussis.
+
+---
+
+## 5. BTS CIEL (remplace le BTS SN depuis 2023)
+
+### Option IR (Informatique et réseaux)
+
+- Réseaux : Ethernet, VLAN, routage statique et dynamique, Wi-Fi (théorie), IPv6. `[C][Q][TD][LAB+]`
+- Systèmes : Linux (administration, services, scripts), virtualisation, conteneurs. `[C][Q][LAB]`
+- Cybersécurité : pare-feu, VPN, IDS, durcissement, audit, gestion des incidents, norme IEC 62443 (théorie). `[C][Q][LAB][LAB+][CTF]`
+- Développement : C/C++, Python, programmation objet, réseau (sockets), web, bases de données. `[C][Q][LAB]`
+- Systèmes communicants, IoT : MQTT, Modbus, protocoles industriels (simulés). `[C][Q][LAB]`
+- Projet technique en équipe. `[PROJ]`
+
+### Option ER (Électronique et réseaux)
+
+- Électronique analogique et numérique `(hors VM)`, cours et quiz seulement.
+- Réseaux et télécoms, IoT, cybersécurité de base. `[C][Q][LAB]`
+
+### Commun aux deux options
+
+- Mathématiques : suites, fonctions, complexes, équations différentielles, **Fourier**, probabilités. `[C][Q][TD]`
+- Physique appliquée `(hors VM)`.
+- Anglais technique. `[C][Q]`
+
+---
+
+## 6. BUT R&T (Réseaux et télécommunications), 3 ans
+
+### Tronc commun (1re année et suite) : « Administrer », « Connecter », « Programmer »
+
+**Réseaux locaux**
+- Câblage, Ethernet, commutation, VLAN, spanning tree (théorie). `[C][Q][TD][LAB+]`
+
+**Architecture des réseaux**
+- Modèles OSI et TCP/IP, IPv4, sous-réseaux, IPv6, routage statique, RIP, OSPF. `[C][Q][TD][LAB+]`
+
+**Systèmes d'exploitation**
+- Linux (shell, droits, processus, services, scripts).
+- Windows `(hors VM)`.
+`[C][Q][LAB]`
+
+**Services réseau**
+- DHCP, DNS, web, messagerie, annuaire LDAP, partage de fichiers. `[C][Q][LAB]`
+
+**Programmation**
+- Python : bases, programmation objet, fichiers, sockets, API.
+- Bash, web (HTML, CSS, JS, PHP), bases de données SQL.
+`[C][Q][LAB]`
+
+**Hygiène informatique et cybersécurité**
+- Durcissement, pare-feu, chiffrement, TLS, VPN. `[C][Q][LAB]`
+
+**Transmission et signal**
+- Supports de transmission, fibre, radio, modulation, codage en ligne. `[C][Q][TD]`
+
+**Téléphonie et VoIP**
+- SIP, Asterisk, qualité de service. `[C][Q][LAB+]`
+
+**Supervision**
+- SNMP, Zabbix, Prometheus. `[C][Q][LAB]`
+
+**Mathématiques**
+- Numération, logique, trigonométrie, **nombres complexes**, **logarithmes et décibels**, dérivées, intégrales, **Fourier**, probabilités et statistiques, graphes, arithmétique modulaire (cryptographie). `[C][Q][TD][LAB]` (en Python)
+
+**Autres**
+- Anglais technique, expression et communication, projet personnel et professionnel. `[C][Q]`
+
+**SAÉ**
+- Situations d'apprentissage et d'évaluation : projets par équipe, par exemple « se sensibiliser à l'hygiène informatique », « construire un réseau informatique pour une petite structure », « mettre en place une solution informatique pour l'entreprise ». `[PROJ][LAB+]`
+
+### Parcours de 2e et 3e année
+
+**Cybersécurité**
+- Pentest : reconnaissance, `nmap`, exploitation contrôlée.
+- SOC : SIEM, journaux, Suricata, Wazuh.
+- Durcissement, PKI, gestion des vulnérabilités, analyse forensique, réponse à incident, ISO 27001 (théorie), EBIOS RM (théorie).
+`[C][Q][LAB][LAB+][CTF]`
+
+**DevCloud (Développement système et cloud)**
+- Docker, Compose, Kubernetes (k3s), Ansible, Terraform (théorie), CI/CD, GitOps, supervision, virtualisation, OpenStack (théorie). `[C][Q][LAB][LAB+]`
+
+**IoM (Internet des objets et mobilité)**
+- Capteurs, LoRaWAN et 5G (théorie), MQTT, CoAP, plateformes IoT, applications mobiles `(hors VM)`. `[C][Q][LAB]`
+
+**PilPro (Pilotage de projets de réseaux)**
+- Gestion de projet, ITIL, conduite du changement, déploiement d'infrastructures. `[C][Q][PROJ]`
+
+**ROM (Réseaux opérateurs et multimédia)**
+- **BGP**, **MPLS**, QoS, IPv6 avancé, VoIP, réseaux d'opérateurs, fibre et radio (théorie). `[C][Q][LAB+]` (FRR et Kathará)
+
+---
+
+## 7. BUT Informatique, 3 ans
+
+### Six compétences
+
+1. **Réaliser un développement d'application** : programmation, POO, web, mobile `(hors VM)`, tests. `[C][Q][LAB]`
+2. **Optimiser des applications** : algorithmique, structures de données, complexité. `[C][Q][TD][LAB]`
+3. **Administrer des systèmes informatiques communicants complexes** :
+   - architecture machine, OS, Linux ;
+   - réseau, services, virtualisation, conteneurs, cloud.
+   `[C][Q][LAB][LAB+]`
+4. **Gérer des données de l'information** : SQL, modélisation, NoSQL, entrepôts de données, analyse. `[C][Q][TD][LAB]`
+5. **Conduire un projet** : méthodes agiles, gestion de projet. `[C][Q][PROJ]`
+6. **Travailler dans une équipe informatique** : Git, communication. `[C][Q][LAB]`
+
+### Parcours
+
+- **A. Réalisation d'applications** : conception, développement, validation.
+- **B. Déploiement d'applications communicantes et sécurisées** : **le plus proche de Paillasse**.
+- **C. Administration, gestion et exploitation des données.**
+- **D. Intégration d'applications et management du SI.**
+
+### Mathématiques
+
+- Logique, ensembles, arithmétique, graphes, matrices et algèbre linéaire, probabilités, statistiques, analyse numérique, cryptographie. `[C][Q][TD][LAB]`
+
+### Autres
+
+- Économie, droit du numérique, anglais, communication. `[C][Q]`
+
+---
+
+## 8. Autres BUT, plus éloignés
+
+- **BUT GEII** (Génie électrique et informatique industrielle) : informatique embarquée, réseaux industriels (Modbus, Profinet en théorie), automatismes, Linux embarqué, IoT. `[C][Q][LAB]` (en partie)
+- **BUT MMI** (Métiers du multimédia et de l'internet) : développement web, hébergement, déploiement, Linux de base, sécurité web. `[C][Q][LAB]`
+
+---
+
+## 9. Licences professionnelles (pas de programme national)
+
+Mentions courantes et contenus habituels :
+
+- **Métiers des réseaux informatiques et télécommunications** (dont les parcours ASUR, administration et sécurité des réseaux) :
+  - routage avancé, VPN, pare-feu, IDS, supervision ;
+  - virtualisation, VoIP, Wi-Fi sécurisé (théorie).
+  `[LAB][LAB+][CTF]`
+- **Métiers de l'informatique : administration et sécurité des systèmes et des réseaux** (dont le type ASRALL, logiciels libres) :
+  - Linux avancé, services, annuaires, messagerie, haute disponibilité ;
+  - Ansible, conteneurs, sécurité.
+  `[LAB][LAB+]`
+- **Cybersécurité** (plusieurs universités) : pentest, SOC, forensique, gouvernance. `[LAB][CTF]`
+- **Cloud et DevOps** : Docker, Kubernetes, CI/CD, IaC, supervision. `[LAB]`
+- **Métiers de l'informatique : applications web** : développement, déploiement, sécurité web. `[LAB]`
+- **Systèmes d'information et gestion de données** : SQL, administration de SGBD, ETL. `[LAB]`
+
+---
+
+## 10. Bachelors (pas de programme national, souvent des titres RNCP de niveau 6)
+
+- **Bachelor Cybersécurité** : sécurité offensive et défensive, SOC, gouvernance, RGPD, ISO 27001. `[LAB][LAB+][CTF]`
+- **Bachelor Administrateur systèmes, réseaux et cloud** : Linux, virtualisation, cloud, automatisation, supervision. `[LAB][LAB+]`
+- **Bachelor DevOps** : conteneurs, CI/CD, IaC, observabilité. `[LAB]`
+- **Bachelor Développement** : web, API, bases de données, tests, sécurité applicative. `[LAB]`
+
+---
+
+## 11. Titres professionnels (ministère du Travail)
+
+- **TSSR** (Technicien supérieur systèmes et réseaux, niveau 5), en 3 CCP :
+  1. assister les utilisateurs ;
+  2. maintenir l'infrastructure et la sécuriser ;
+  3. exploiter les serveurs Windows et Linux.
+  `[LAB][LAB+]`
+- **AIS** (Administrateur d'infrastructures sécurisées, niveau 6), en 3 CCP :
+  1. administrer et sécuriser les infrastructures ;
+  2. concevoir et mettre en œuvre une solution répondant à un besoin d'évolution ;
+  3. participer à la gestion de la cybersécurité.
+  `[LAB][LAB+][CTF]`
+- **ASD** (Administrateur système DevOps, niveau 6) : automatiser, conteneuriser, superviser, CI/CD. `[LAB]`
+- Plus éloignés : **DWWM** (Développeur web et web mobile), **CDA** (Concepteur développeur d'applications). `[LAB]`
+
+---
+
+## 12. Bonus : préparation aux certifications (offre possible, à vérifier juridiquement)
+
+- Préparation de type **LPIC-1 / LFCS** (Linux). `[LAB][EXAM]`
+- Préparation « réseau fondamental », type CCNA, sans le matériel Cisco (FRR). `[LAB+][EXAM]`
+- Sensibilisation cybersécurité, type SecNumacadémie. `[C][Q]`
+
+Ne jamais utiliser les logos ni les noms déposés sans autorisation. Écrire « préparation à… », jamais « certifiant ».
+
+---
+
+# PARTIE 2 : CATALOGUE COMPLET PAR THÈME
+
+Chaque chapitre ci-dessous correspond à une fiche de la bibliothèque. Le code d'une fiche = le préfixe du thème + un numéro.
+
+## LIN : Linux et systèmes
+
+1. Découverte du terminal, commandes de base. `[C][Q][LAB]`
+2. Arborescence FHS, chemins absolus et relatifs. `[C][Q][LAB]`
+3. Fichiers : `cp`, `mv`, `rm`, liens, `find`, `locate`. `[C][Q][LAB]`
+4. Lire et éditer : `cat`, `less`, `nano`, `vim`. `[C][Q][LAB]`
+5. Redirections, tubes, filtres : `grep`, `sed`, `awk`, `cut`, `sort`, `uniq`, `wc`. `[C][Q][LAB]`
+6. Droits : `chmod`, `chown`, `umask`, SUID, SGID, sticky bit, ACL. `[C][Q][TD][LAB]`
+7. Utilisateurs et groupes, `sudo`. `[C][Q][LAB]`
+8. Processus : `ps`, `top`, `kill`, signaux, priorités, avant-plan et arrière-plan. `[C][Q][LAB]`
+9. systemd : services, unités, timers, `journalctl`. `[C][Q][LAB]`
+10. Paquets : `apt`, dépôts, `dpkg`, compilation depuis les sources. `[C][Q][LAB]`
+11. Disques : partitions, systèmes de fichiers, `mount`, `fstab`. `[C][Q][LAB]`
+12. LVM. `[C][Q][LAB]`
+13. RAID logiciel (`mdadm`). `[C][Q][LAB]`
+14. Démarrage : BIOS/UEFI, GRUB, initramfs, runlevels et targets. `[C][Q][LAB]`
+15. Planification : `cron`, `at`, timers systemd. `[C][Q][LAB]`
+16. Journaux : rsyslog, journald, `logrotate`. `[C][Q][LAB]`
+17. Scripts Bash : variables, conditions, boucles, fonctions, arguments, codes retour. `[C][Q][LAB]`
+18. Archivage et compression : `tar`, `gzip`, `zstd`. `[C][Q][LAB]`
+19. Sauvegardes : `rsync`, restic, stratégie 3-2-1, restauration. `[C][Q][LAB]`
+20. Performance : `vmstat`, `iostat`, `free`, `df`, `du`, `htop`. `[C][Q][LAB]`
+21. Noyau et modules : `lsmod`, `sysctl`, `/proc`, `/sys`. `[C][Q][LAB]`
+22. Variables d'environnement, shell, alias, profils. `[C][Q][LAB]`
+23. Dépannage : machine qui ne démarre plus, disque plein, service en échec. `[LAB][EXAM]`
+24. Mode examen « Admin Linux » (type LPIC-1). `[EXAM]`
+
+## NET : Réseaux
+
+1. Histoire et vocabulaire : LAN, WAN, topologies. `[C][Q]`
+2. Modèle OSI et TCP/IP, encapsulation. `[C][Q][TD]`
+3. Couche physique : câbles, fibre, Wi-Fi (théorie). `[C][Q]`
+4. Ethernet, adresses MAC, trames, commutation. `[C][Q][LAB]`
+5. ARP. `[C][Q][LAB]`
+6. IPv4 : classes, CIDR, masques. `[C][Q][TD][LAB]`
+7. Sous-réseaux et VLSM. `[TD][Q]` (générateur d'exercices aléatoires)
+8. IPv6 : adresses, SLAAC, NDP, double pile. `[C][Q][TD][LAB]`
+9. ICMP, `ping`, `traceroute`, MTU. `[C][Q][LAB]`
+10. TCP et UDP : ports, poignée de main, états, `ss`, `netstat`. `[C][Q][LAB]`
+11. Configuration IP sous Linux : `ip`, NetworkManager, `/etc/network/interfaces`, systemd-networkd. `[C][Q][LAB]`
+12. **Deux LAN et un routeur** (lab 08 du MVP). `[LAB+]`
+13. Routage statique, table de routage, route par défaut. `[C][Q][TD][LAB+]`
+14. RIP. `[C][Q][LAB+]`
+15. OSPF (monozone, puis multizone). `[C][Q][LAB+]`
+16. BGP (eBGP, iBGP, politiques). `[C][Q][LAB+]`
+17. MPLS (théorie et lab FRR). `[C][Q][LAB+]`
+18. VLAN 802.1Q, trunk, routage inter-VLAN. `[C][Q][LAB+]`
+19. Spanning tree (théorie, et démo avec des bridges Linux). `[C][Q][LAB+]`
+20. Agrégation de liens (bonding). `[C][Q][LAB]`
+21. NAT et PAT, masquerade. `[C][Q][LAB+]`
+22. DHCP : serveur, relais, baux. `[C][Q][LAB+]`
+23. DNS : résolution, zones, enregistrements, Bind, DNSSEC (théorie). `[C][Q][LAB]`
+24. VRRP et Keepalived (passerelle redondante). `[C][Q][LAB+]`
+25. QoS : files, marquage, `tc`. `[C][Q][LAB]`
+26. Analyse de trames : `tcpdump`, fichiers pcap. `[C][Q][LAB]`
+27. Proxy et reverse proxy. `[C][Q][LAB]`
+28. Wi-Fi : normes, sécurité WPA2/WPA3 `(hors VM)`, cours et quiz. `[C][Q]`
+29. Dépannage : réseau cassé à réparer. `[LAB+][EXAM]`
+30. Mode examen « Réseau ». `[EXAM]`
+
+## SRV : Services
+
+1. Serveur web Apache, virtual hosts. `[C][Q][LAB]`
+2. Nginx, reverse proxy, répartition de charge. `[C][Q][LAB]`
+3. HTTPS avec certificats (autorité interne). `[C][Q][LAB]`
+4. PHP-FPM, pile LAMP ou LEMP. `[C][Q][LAB]`
+5. SSH avancé : clés, tunnels, rebonds, `sshd_config`. `[C][Q][LAB]`
+6. SFTP, FTP (théorie de sa faiblesse). `[C][Q][LAB]`
+7. NFS. `[C][Q][LAB+]`
+8. Samba (partages). `[C][Q][LAB]`
+9. Samba AD (alternative à Active Directory). `[C][Q][LAB+]`
+10. OpenLDAP. `[C][Q][LAB]`
+11. Messagerie : Postfix, Dovecot, SPF, DKIM, DMARC (théorie). `[C][Q][LAB]`
+12. Supervision : SNMP, Zabbix. `[C][Q][LAB+]`
+13. Prometheus, Grafana, alertes. `[C][Q][LAB]`
+14. Centralisation des journaux (rsyslog distant). `[C][Q][LAB+]`
+15. Serveur de temps (NTP, chrony). `[C][Q][LAB]`
+16. GLPI (inventaire et ticketing). `[C][Q][LAB]`
+17. VoIP : Asterisk, SIP. `[C][Q][LAB+]`
+18. Haute disponibilité : HAProxy et Keepalived. `[C][Q][LAB+]`
+
+## SEC : Cybersécurité
+
+1. Hygiène numérique, les 42 mesures ANSSI (résumé). `[C][Q]`
+2. Menaces : hameçonnage, rançongiciels, ingénierie sociale. `[C][Q]`
+3. Mots de passe : hachage, sel, attaque par dictionnaire, MFA. `[C][Q][LAB]`
+4. Chiffrement symétrique (AES) et asymétrique (RSA, ECC). `[C][Q][TD][LAB]` (`openssl`)
+5. Hachage et signatures, intégrité. `[C][Q][LAB]`
+6. PKI, autorité de certification, certificats X.509. `[C][Q][LAB]`
+7. TLS, HTTPS, analyse d'une poignée de main. `[C][Q][LAB]`
+8. GPG. `[C][Q][LAB]`
+9. Pare-feu : `nftables`, `iptables`, politique par défaut. `[C][Q][LAB+]`
+10. DMZ et segmentation réseau. `[C][Q][LAB+]`
+11. VPN : WireGuard, OpenVPN, IPsec (strongSwan). `[C][Q][LAB+]`
+12. Durcissement Linux : CIS, Lynis, services inutiles, mises à jour. `[C][Q][LAB]`
+13. fail2ban et protection contre la force brute. `[C][Q][LAB]`
+14. Scan et reconnaissance : `nmap`. `[C][Q][LAB+]`
+15. Vulnérabilités : CVE, CVSS, gestion des correctifs. `[C][Q]`
+16. OWASP Top 10 : injection SQL, XSS, CSRF, contrôle d'accès, sur une appli volontairement vulnérable. `[C][Q][LAB][CTF]`
+17. IDS : Suricata, règles, alertes. `[C][Q][LAB+]`
+18. SIEM et SOC : Wazuh, corrélation de journaux. `[C][Q][LAB+]`
+19. Analyse forensique : chronologie, journaux, fichiers suspects. `[C][Q][LAB]`
+20. Réponse à incident : confinement, éradication, retour d'expérience. `[C][Q][LAB]`
+21. Élévation de privilèges sous Linux (en environnement contrôlé). `[C][Q][CTF]`
+22. Sécurité des conteneurs. `[C][Q][LAB]`
+23. Gouvernance : ISO 27001, EBIOS RM, PSSI (théorie). `[C][Q]`
+24. Droit : RGPD, CNIL, loi Godfrain, NIS2. `[C][Q]`
+25. CTF de fin de parcours. `[CTF][EXAM]`
+
+## BDD : Bases de données
+
+1. Modèle relationnel, tables, clés. `[C][Q]`
+2. Modélisation : MCD, MLD, Merise, UML. `[C][Q][TD]`
+3. `SELECT`, `WHERE`, `ORDER BY`. `[C][Q][LAB]`
+4. Jointures. `[C][Q][LAB]`
+5. Agrégats : `GROUP BY`, `HAVING`. `[C][Q][LAB]`
+6. Sous-requêtes. `[C][Q][LAB]`
+7. DDL : `CREATE`, `ALTER`, contraintes. `[C][Q][LAB]`
+8. DML : `INSERT`, `UPDATE`, `DELETE`. `[C][Q][LAB]`
+9. Vues, procédures stockées, triggers. `[C][Q][LAB]`
+10. Transactions et ACID. `[C][Q][LAB]`
+11. Utilisateurs et droits (`GRANT`). `[C][Q][LAB]`
+12. Index, `EXPLAIN`, performance. `[C][Q][LAB]`
+13. Sauvegarde et restauration (`mysqldump`, `mariabackup`). `[C][Q][LAB]`
+14. Réplication. `[C][Q][LAB+]`
+15. NoSQL : Redis, MongoDB (découverte). `[C][Q][LAB]`
+16. Normalisation (1FN, 2FN, 3FN). `[C][Q][TD]`
+17. Mode examen « SQL ». `[EXAM]`
+
+## PRG : Programmation et algorithmique
+
+1. Python : variables, types, conditions, boucles. `[C][Q][LAB]`
+2. Fonctions, portée, modules. `[C][Q][LAB]`
+3. Listes, tuples, dictionnaires, ensembles. `[C][Q][LAB]`
+4. Chaînes de caractères, fichiers, CSV, JSON. `[C][Q][LAB]`
+5. Programmation objet. `[C][Q][LAB]`
+6. Récursivité. `[C][Q][LAB]`
+7. Tests : `assert`, pytest. `[C][Q][LAB]`
+8. Tris, recherche dichotomique, complexité. `[C][Q][TD][LAB]`
+9. Piles, files, listes chaînées. `[C][Q][LAB]`
+10. Arbres, arbres binaires de recherche. `[C][Q][LAB]`
+11. Graphes : parcours en largeur et en profondeur, Dijkstra. `[C][Q][LAB]`
+12. Algorithmes gloutons, diviser pour régner, programmation dynamique. `[C][Q][LAB]`
+13. Python pour l'administration : `subprocess`, `os`, `pathlib`, journaux. `[C][Q][LAB]`
+14. Sockets réseau (client et serveur TCP/UDP). `[C][Q][LAB+]`
+15. API REST : `requests`, `curl`, JSON. `[C][Q][LAB]`
+16. Git : commit, branches, fusion, conflits, dépôt distant. `[C][Q][LAB]`
+17. C : bases, pointeurs, compilation, `make`. `[C][Q][LAB]`
+18. PHP : bases, formulaires, sessions, PDO. `[C][Q][LAB]`
+19. JavaScript : bases, DOM, `fetch`. `[C][Q][LAB]`
+20. HTML et CSS. `[C][Q][LAB]`
+21. Java ou C# (bases) : possible dans une VM, mais lourd. `[C][Q][LAB]`
+22. Expressions régulières. `[C][Q][LAB]`
+23. Mode examen « épreuve pratique NSI ». `[EXAM]`
+
+## DEV : Virtualisation, conteneurs, cloud, DevOps
+
+1. Virtualisation : hyperviseurs de type 1 et 2, KVM (théorie). `[C][Q]`
+2. Docker : images, conteneurs, volumes, réseaux. `[C][Q][LAB]`
+3. Dockerfile et bonnes pratiques. `[C][Q][LAB]`
+4. Docker Compose. `[C][Q][LAB]`
+5. Ansible : inventaire, playbooks, rôles. `[C][Q][LAB+]`
+6. CI/CD : pipelines (Forgejo Actions, GitLab CI). `[C][Q][LAB]`
+7. Kubernetes (k3s) : pods, déploiements, services. `[C][Q][LAB]`
+8. Infrastructure en code : Terraform et OpenTofu (théorie et démo). `[C][Q]`
+9. Cloud : IaaS, PaaS, SaaS, OpenStack (théorie). `[C][Q]`
+10. Observabilité : métriques, journaux, traces. `[C][Q][LAB]`
+
+## IOT : Objets connectés et systèmes embarqués
+
+1. Architecture IoT : capteur, passerelle, cloud. `[C][Q]`
+2. MQTT : broker Mosquitto, publication et abonnement. `[C][Q][LAB]`
+3. Node-RED : flux de traitement. `[C][Q][LAB]`
+4. Modbus TCP (simulé). `[C][Q][LAB]`
+5. CoAP, LoRaWAN (théorie). `[C][Q]`
+6. Sécurité IoT. `[C][Q][LAB]`
+7. Linux embarqué (théorie, Raspberry Pi `(hors VM)`). `[C][Q]`
+
+## TEL : Télécoms et signal (surtout BUT R&T et BTS CIEL)
+
+1. Signal analogique et numérique, échantillonnage, Shannon. `[C][Q][TD]`
+2. Modulation (AM, FM, QAM). `[C][Q][TD]`
+3. Décibels et bilan de liaison. `[C][Q][TD]`
+4. Codage en ligne, multiplexage. `[C][Q][TD]`
+5. Fibre optique, réseaux radio, 4G et 5G (théorie). `[C][Q]`
+6. VoIP et codecs. `[C][Q][LAB+]`
+
+## MAT : Mathématiques pour l'informatique
+
+1. Numération : binaire, octal, hexadécimal, conversions. `[C][Q][TD]`
+2. Codage des entiers (complément à 2) et des flottants (IEEE 754). `[C][Q][TD]`
+3. Logique propositionnelle, tables de vérité. `[C][Q][TD]`
+4. Algèbre de Boole, tableaux de Karnaugh. `[C][Q][TD]`
+5. Ensembles, relations, applications. `[C][Q][TD]`
+6. Arithmétique : division euclidienne, PGCD, Bézout, congruences. `[C][Q][TD]`
+7. Cryptographie : César, affine, Vigenère, RSA. `[C][Q][TD][LAB]` (en Python)
+8. Matrices : opérations, inverse, applications. `[C][Q][TD]`
+9. Graphes : vocabulaire, matrice d'adjacence, chemins, Dijkstra, PERT. `[C][Q][TD][LAB]`
+10. Suites : arithmétiques, géométriques, récurrentes. `[C][Q][TD]`
+11. Fonctions : dérivées, exponentielle, logarithme. `[C][Q][TD]`
+12. Nombres complexes. `[C][Q][TD]`
+13. Trigonométrie. `[C][Q][TD]`
+14. Intégrales. `[C][Q][TD]`
+15. Séries de Fourier. `[C][Q][TD][LAB]` (en Python)
+16. Probabilités : dénombrement, lois, espérance. `[C][Q][TD]`
+17. Statistiques : moyenne, écart-type, régression. `[C][Q][TD][LAB]`
+18. Équations différentielles (BTS CIEL). `[C][Q][TD]`
+19. Complexité et notation O. `[C][Q][TD]`
+
+## ARC : Architecture des ordinateurs
+
+1. Modèle de von Neumann. `[C][Q]`
+2. Portes logiques, circuits combinatoires, additionneur. `[C][Q][TD]`
+3. Mémoire, cache, bus. `[C][Q]`
+4. Assembleur (simulateur). `[C][Q][LAB]`
+5. Systèmes sur puce (SoC). `[C][Q]`
+6. Ordonnancement des processus, interblocage. `[C][Q][TD][LAB]`
+
+## PRO : Méthodes et métier
+
+1. Gestion de projet : cycle en V, agile, Scrum, Kanban. `[C][Q]`
+2. ITIL : incidents, problèmes, changements. `[C][Q]`
+3. Rédiger une documentation technique et un compte rendu. `[C][Q]`
+4. Veille technologique. `[C]`
+5. Relation client et support utilisateur. `[C][Q]`
+6. Anglais technique (vocabulaire réseau, système, sécurité). `[C][Q]`
+7. Droit du numérique : contrats, licences libres, RGPD. `[C][Q]`
+
+---
+
+# PARTIE 3 : POUR LA MAQUETTE
+
+## Modèle de données suggéré
+
+```
+Formation (ex. BTS SIO SISR)
+ └─ Bloc / Semestre / Thème officiel (ex. Bloc 2)
+     └─ Chapitre (ex. NET-15 OSPF)
+         └─ Activités : Cours · Quiz · TD · Lab · Lab+ · Examen · Projet · CTF
+```
+
+Un même chapitre (par exemple NET-15 OSPF) sert **plusieurs formations** : NSI Tle, BTS SIO SISR, BTS CIEL, BUT R&T, TSSR, AIS.
+
+## Attributs d'une activité
+
+- type ;
+- niveau : découverte, intermédiaire, avancé ;
+- durée ;
+- prérequis ;
+- nombre de VM ;
+- RAM nécessaire ;
+- gratuit ou payant ;
+- lien vers le texte officiel (BO ou RNCP) ;
+- compétences couvertes ;
+- licence du contenu.
+
+## Écrans à enrichir
+
+- **Bibliothèque du prof**, avec des filtres :
+  - formation, bloc, thème, type d'activité ;
+  - durée, niveau ;
+  - VM ou non.
+- **Page formation** : programme officiel chapitre par chapitre, avec, pour chaque chapitre, cours gratuit, quiz et lab payant.
+- **Tableau compétences ↔ labs**, pour montrer la couverture du référentiel.
+- **Mode examen** :
+  - chronomètre ;
+  - pas d'accès aux cours ;
+  - copier-coller limité ;
+  - note finale et export PDF.
+- **Portfolio de l'élève** : les labs réussis, exportables (utile pour l'épreuve E4 du BTS SIO).
+- **Générateur de TD** (sous-réseaux, conversions) : des exercices aléatoires, corrigés automatiquement.
+- **CTF** : classement de la classe par pseudonymes, jamais public.