From 138235bd764167f2a426317ef852a6a3cac146dc Mon Sep 17 00:00:00 2001 From: Adam Belkacemi Date: Wed, 7 Oct 2026 00:11:20 +0200 Subject: [PATCH] =?UTF-8?q?CLAUDE.md,=20contenus,=20prompt=20et=20r=C3=A9f?= =?UTF-8?q?=C3=A9rentiel?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CLAUDE.md | 240 ++++++++ docs/prompt-deploiement-paillasse.md | 298 ++++++++++ docs/referentiel-pedagogique-paillasse.md | 661 ++++++++++++++++++++++ 3 files changed, 1199 insertions(+) create mode 100644 CLAUDE.md create mode 100644 docs/prompt-deploiement-paillasse.md create mode 100644 docs/referentiel-pedagogique-paillasse.md diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..6f48635 --- /dev/null +++ b/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. diff --git a/docs/prompt-deploiement-paillasse.md b/docs/prompt-deploiement-paillasse.md new file mode 100644 index 0000000..0162acb --- /dev/null +++ b/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** : ``. +- Debian `<12 ou 13>`, installé par Adam depuis la console Dedibox. +- Accès SSH : `ssh @`, avec la clé dédiée `~/.ssh/`. 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** : ``. 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 ` 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://` 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. diff --git a/docs/referentiel-pedagogique-paillasse.md b/docs/referentiel-pedagogique-paillasse.md new file mode 100644 index 0000000..08a56d4 --- /dev/null +++ b/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.