ajoute le portail Laravel : connexion prof/élève, session unique, gestion de classe, salle d'attente

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

ansible/portail.yml

@@ -0,0 +1,8 @@
+---
+# Étape 8 du déploiement Syllabus : portail Laravel.
+- name: Portail Laravel
+  hosts: syllabus
+  become: true
+  gather_facts: true
+  roles:
+    - portail

ansible/roles/portail/defaults/main.yml

@@ -0,0 +1,8 @@
+---
+portail_mysql_port: 3307
+portail_redis_port: 6380
+portail_mysql_database: portail
+portail_mysql_user: portail
+portail_dossier_docker: /etc/portail
+portail_dossier_app: /var/www/portail
+portail_php_version: "8.3"

ansible/roles/portail/handlers/main.yml

@@ -0,0 +1,4 @@
+---
+- name: recharger nginx
+  ansible.builtin.shell: nginx -t && systemctl reload nginx
+  changed_when: true

ansible/roles/portail/tasks/01-systeme.yml

@@ -0,0 +1,91 @@
+---
+- name: installer les prérequis pour le dépôt PHP Sury
+  ansible.builtin.apt:
+    name: [lsb-release, ca-certificates, curl, gnupg, rsync]
+    state: present
+    update_cache: true
+    cache_valid_time: 3600
+
+- name: télécharger le trousseau de clés du dépôt Sury
+  ansible.builtin.get_url:
+    url: https://packages.sury.org/debsuryorg-archive-keyring.deb
+    dest: /tmp/debsuryorg-archive-keyring.deb
+    mode: "0644"
+
+- name: installer le trousseau de clés Sury
+  ansible.builtin.apt:
+    deb: /tmp/debsuryorg-archive-keyring.deb
+    state: present
+
+- name: ajouter le dépôt PHP Sury
+  ansible.builtin.apt_repository:
+    repo: "deb [signed-by=/usr/share/keyrings/debsuryorg-archive-keyring.gpg] https://packages.sury.org/php/ {{ ansible_distribution_release }} main"
+    filename: php
+    state: present
+    update_cache: true
+
+- name: installer PHP {{ portail_php_version }}, Nginx et les extensions nécessaires
+  ansible.builtin.apt:
+    name:
+      - "php{{ portail_php_version }}-fpm"
+      - "php{{ portail_php_version }}-cli"
+      - "php{{ portail_php_version }}-mysql"
+      - "php{{ portail_php_version }}-redis"
+      - "php{{ portail_php_version }}-mbstring"
+      - "php{{ portail_php_version }}-xml"
+      - "php{{ portail_php_version }}-curl"
+      - "php{{ portail_php_version }}-zip"
+      - "php{{ portail_php_version }}-bcmath"
+      - "php{{ portail_php_version }}-gd"
+      - "php{{ portail_php_version }}-intl"
+      - "php{{ portail_php_version }}-opcache"
+      - nginx
+    state: present
+    update_cache: true
+
+- name: installer Composer (avec vérification de la somme d'installation officielle)
+  block:
+    - name: télécharger le programme d'installation de Composer
+      ansible.builtin.get_url:
+        url: https://getcomposer.org/installer
+        dest: /tmp/composer-setup.php
+        mode: "0644"
+
+    - name: récupérer la somme SHA384 officielle
+      ansible.builtin.uri:
+        url: https://composer.github.io/installer.sig
+        return_content: true
+      register: portail_composer_signature
+      when: not (ansible_check_mode | default(false))
+
+    - name: calculer la somme SHA384 du fichier téléchargé
+      ansible.builtin.stat:
+        path: /tmp/composer-setup.php
+        checksum_algorithm: sha384
+      register: portail_composer_setup_stat
+
+    - name: vérifier que la somme correspond (sinon, installateur corrompu)
+      ansible.builtin.fail:
+        msg: "La somme de l'installateur Composer ne correspond pas à la signature officielle : installation interrompue."
+      when:
+        - portail_composer_signature is defined
+        - portail_composer_setup_stat.stat.checksum != portail_composer_signature.content.strip()
+
+    - name: installer Composer (dernière version stable)
+      ansible.builtin.command:
+        cmd: php /tmp/composer-setup.php --install-dir=/usr/local/bin --filename=composer
+      args:
+        creates: /usr/local/bin/composer
+
+- name: installer Node.js 22 LTS (dépôt NodeSource)
+  block:
+    - name: ajouter le dépôt NodeSource
+      ansible.builtin.shell:
+        cmd: curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
+        creates: /etc/apt/sources.list.d/nodesource.list
+
+    - name: installer nodejs
+      ansible.builtin.apt:
+        name: nodejs
+        state: present
+        update_cache: true

ansible/roles/portail/tasks/02-bases-donnees.yml

@@ -0,0 +1,63 @@
+---
+- name: créer le dossier de configuration Docker du portail
+  ansible.builtin.file:
+    path: "{{ portail_dossier_docker }}"
+    state: directory
+    owner: root
+    group: root
+    mode: "0750"
+
+# Un seul fichier de secrets, nommé .env : docker compose le charge
+# automatiquement pour les substitutions ${...} de docker-compose.yml, et une
+# tâche plus loin le relit pour remplir le .env de Laravel avec les mêmes
+# valeurs (une seule source de vérité, jamais dans Git).
+- name: générer les secrets MariaDB/Redis de l'app (première fois seulement)
+  ansible.builtin.copy:
+    dest: "{{ portail_dossier_docker }}/.env"
+    content: |
+      MYSQL_ROOT_PASSWORD={{ lookup('community.general.random_string', length=32, special=false) }}
+      MYSQL_PASSWORD={{ lookup('community.general.random_string', length=32, special=false) }}
+      REDIS_PASSWORD={{ lookup('community.general.random_string', length=32, special=false) }}
+    owner: root
+    group: root
+    mode: "0600"
+    force: false
+  register: portail_secrets_generes
+
+- name: lire les secrets générés
+  ansible.builtin.slurp:
+    src: "{{ portail_dossier_docker }}/.env"
+  register: portail_secrets_brut
+
+- name: "exposer les secrets comme variables (jamais affichées, no_log)"
+  ansible.builtin.set_fact:
+    portail_secrets: "{{ dict(portail_secrets_lignes | map('split', '=', 1)) }}"
+  vars:
+    portail_secrets_lignes: "{{ (portail_secrets_brut.content | b64decode).splitlines() | select('string') | list }}"
+  no_log: true
+
+- name: déployer docker-compose.yml (MariaDB + Redis de l'app)
+  ansible.builtin.template:
+    src: docker-compose.yml.j2
+    dest: "{{ portail_dossier_docker }}/docker-compose.yml"
+    owner: root
+    group: root
+    mode: "0640"
+  vars:
+    portail_mysql_root_password: "${MYSQL_ROOT_PASSWORD}"
+    portail_mysql_password: "${MYSQL_PASSWORD}"
+    portail_redis_password: "${REDIS_PASSWORD}"
+  register: portail_compose_deploye
+
+- name: démarrer MariaDB et Redis (app)
+  community.docker.docker_compose_v2:
+    project_src: "{{ portail_dossier_docker }}"
+    state: present
+  register: portail_compose_resultat
+
+- name: attendre que MariaDB (app) accepte les connexions
+  ansible.builtin.wait_for:
+    host: 127.0.0.1
+    port: "{{ portail_mysql_port }}"
+    delay: 2
+    timeout: 60

ansible/roles/portail/tasks/03-code.yml

@@ -0,0 +1,113 @@
+---
+- name: créer le dossier de l'application
+  ansible.builtin.file:
+    path: "{{ portail_dossier_app }}"
+    state: directory
+    owner: "{{ ansible_user }}"
+    group: "{{ ansible_user }}"
+    mode: "0755"
+
+# storage/ et bootstrap/cache/ sont de l'état et du cache runtime, jamais du
+# code : on ne les synchronise jamais depuis le Mac (un rsync --delete les
+# effacerait sinon, y compris storage/app/ où atterriront plus tard les
+# travaux d'élèves). On crée leur structure une fois, puis on laisse
+# www-data (PHP-FPM) les posséder en continu.
+- name: créer la structure storage/ et bootstrap/cache/ (une seule fois)
+  ansible.builtin.file:
+    path: "{{ portail_dossier_app }}/{{ item }}"
+    state: directory
+    owner: www-data
+    group: www-data
+    mode: "0775"
+  loop:
+    - storage/app/public
+    - storage/framework/cache/data
+    - storage/framework/sessions
+    - storage/framework/views
+    - storage/logs
+    - bootstrap/cache
+
+- name: synchroniser le code du portail (sans vendor/node_modules/.env/storage)
+  become: false
+  ansible.posix.synchronize:
+    src: "{{ playbook_dir }}/../portail/"
+    dest: "{{ portail_dossier_app }}/"
+    delete: true
+    rsync_opts:
+      - "--exclude=/vendor"
+      - "--exclude=/node_modules"
+      - "--exclude=/.env"
+      - "--exclude=/database/database.sqlite"
+      - "--exclude=/storage"
+      - "--exclude=/bootstrap/cache"
+      - "--exclude=/public/build"
+      - "--exclude=/public/hot"
+      - "--exclude=/.git"
+  register: portail_code_synchronise
+
+- name: installer les dépendances PHP (composer)
+  ansible.builtin.command:
+    cmd: composer install --no-dev --optimize-autoloader --no-interaction
+  args:
+    chdir: "{{ portail_dossier_app }}"
+  environment:
+    COMPOSER_ALLOW_SUPERUSER: "1"
+  register: portail_composer_install_app
+  changed_when: "'Nothing to install' not in portail_composer_install_app.stdout"
+
+- name: vérifier si .env existe déjà
+  ansible.builtin.stat:
+    path: "{{ portail_dossier_app }}/.env"
+  register: portail_env_stat
+
+- name: générer une clé d'application (une seule fois)
+  ansible.builtin.command:
+    cmd: php artisan key:generate --show
+  args:
+    chdir: "{{ portail_dossier_app }}"
+  register: portail_app_key_generee
+  when: not portail_env_stat.stat.exists
+  changed_when: true
+
+- name: déployer .env de production (une seule fois, jamais réécrit ensuite)
+  ansible.builtin.template:
+    src: env.production.j2
+    dest: "{{ portail_dossier_app }}/.env"
+    owner: "{{ ansible_user }}"
+    group: www-data
+    mode: "0640"
+  vars:
+    portail_app_key: "{{ portail_app_key_generee.stdout }}"
+    portail_app_url: "http://{{ ansible_host }}"
+  when: not portail_env_stat.stat.exists
+
+- name: installer les dépendances JS (npm)
+  ansible.builtin.command:
+    cmd: npm ci
+  args:
+    chdir: "{{ portail_dossier_app }}"
+  register: portail_npm_ci
+  changed_when: true
+
+- name: compiler les assets (vite build)
+  ansible.builtin.command:
+    cmd: npm run build
+  args:
+    chdir: "{{ portail_dossier_app }}"
+  register: portail_npm_build
+  changed_when: true
+
+- name: appliquer les migrations
+  ansible.builtin.command:
+    cmd: php artisan migrate --force
+  args:
+    chdir: "{{ portail_dossier_app }}"
+  register: portail_migrate
+  changed_when: "'Nothing to migrate' not in portail_migrate.stdout"
+
+- name: mettre en cache la configuration et les routes
+  ansible.builtin.shell:
+    cmd: php artisan config:cache && php artisan route:cache && php artisan view:cache
+  args:
+    chdir: "{{ portail_dossier_app }}"
+  changed_when: true

ansible/roles/portail/tasks/04-nginx.yml

@@ -0,0 +1,29 @@
+---
+- name: déployer le vhost Nginx du portail
+  ansible.builtin.template:
+    src: nginx-portail.conf.j2
+    dest: /etc/nginx/sites-available/portail.conf
+    mode: "0644"
+  notify: recharger nginx
+
+- name: activer le vhost
+  ansible.builtin.file:
+    src: /etc/nginx/sites-available/portail.conf
+    dest: /etc/nginx/sites-enabled/portail.conf
+    state: link
+  notify: recharger nginx
+
+- name: désactiver le vhost par défaut de Nginx
+  ansible.builtin.file:
+    path: /etc/nginx/sites-enabled/default
+    state: absent
+  notify: recharger nginx
+
+- name: activer et démarrer php-fpm et nginx
+  ansible.builtin.systemd:
+    name: "{{ item }}"
+    enabled: true
+    state: started
+  loop:
+    - "php{{ portail_php_version }}-fpm"
+    - nginx

ansible/roles/portail/tasks/main.yml

@@ -0,0 +1,12 @@
+---
+- name: système (PHP, Nginx, Composer, Node)
+  ansible.builtin.import_tasks: 01-systeme.yml
+
+- name: bases de données de l'app (MariaDB, Redis)
+  ansible.builtin.import_tasks: 02-bases-donnees.yml
+
+- name: code de l'application
+  ansible.builtin.import_tasks: 03-code.yml
+
+- name: Nginx
+  ansible.builtin.import_tasks: 04-nginx.yml

ansible/roles/portail/templates/docker-compose.yml.j2

@@ -0,0 +1,28 @@
+services:
+  mariadb:
+    image: mariadb:11
+    container_name: portail_mariadb
+    restart: unless-stopped
+    ports:
+      - "127.0.0.1:{{ portail_mysql_port }}:3306"
+    environment:
+      MARIADB_ROOT_PASSWORD: "{{ portail_mysql_root_password }}"
+      MARIADB_DATABASE: "{{ portail_mysql_database }}"
+      MARIADB_USER: "{{ portail_mysql_user }}"
+      MARIADB_PASSWORD: "{{ portail_mysql_password }}"
+    volumes:
+      - portail_mariadb_data:/var/lib/mysql
+
+  redis:
+    image: redis:7
+    container_name: portail_redis
+    restart: unless-stopped
+    command: ["redis-server", "--requirepass", "{{ portail_redis_password }}"]
+    ports:
+      - "127.0.0.1:{{ portail_redis_port }}:6379"
+    volumes:
+      - portail_redis_data:/data
+
+volumes:
+  portail_mariadb_data:
+  portail_redis_data:

ansible/roles/portail/templates/env.production.j2

@@ -0,0 +1,29 @@
+APP_NAME=Syllabus
+APP_ENV=production
+APP_KEY={{ portail_app_key }}
+APP_DEBUG=false
+APP_URL={{ portail_app_url }}
+
+APP_LOCALE=fr
+APP_FALLBACK_LOCALE=fr
+
+LOG_CHANNEL=stack
+LOG_LEVEL=warning
+
+DB_CONNECTION=mysql
+DB_HOST=127.0.0.1
+DB_PORT={{ portail_mysql_port }}
+DB_DATABASE={{ portail_mysql_database }}
+DB_USERNAME={{ portail_mysql_user }}
+DB_PASSWORD={{ portail_secrets.MYSQL_PASSWORD }}
+
+SESSION_DRIVER=redis
+SESSION_LIFETIME=120
+CACHE_STORE=redis
+QUEUE_CONNECTION=redis
+
+REDIS_HOST=127.0.0.1
+REDIS_PORT={{ portail_redis_port }}
+REDIS_PASSWORD={{ portail_secrets.REDIS_PASSWORD }}
+
+MAIL_MAILER=log

ansible/roles/portail/templates/nginx-portail.conf.j2

@@ -0,0 +1,28 @@
+server {
+    listen 80;
+    listen [::]:80;
+    server_name _;
+
+    root {{ portail_dossier_app }}/public;
+    index index.php;
+
+    client_max_body_size 20m;
+
+    location / {
+        try_files $uri $uri/ /index.php?$query_string;
+    }
+
+    location ~ \.php$ {
+        fastcgi_pass unix:/run/php/php{{ portail_php_version }}-fpm.sock;
+        fastcgi_index index.php;
+        include fastcgi_params;
+        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+    }
+
+    location ~ /\.(?!well-known) {
+        deny all;
+    }
+
+    access_log /var/log/nginx/portail-access.log;
+    error_log /var/log/nginx/portail-error.log;
+}

docs/journal.md

@@ -272,3 +272,45 @@ La bonne nouvelle de cette étape, c'est que Kolla avait déjà fait le plus gro
 **Suite**
 
 Étape 8 : portail Laravel (Blade, Vite, MariaDB/Redis pour l'app, modèles, connexion prof/élève, salle d'attente). Le dossier `design/` doit exister : à vérifier avant de commencer.
+
+## 2026-10-07 — Étape 8 : portail Laravel
+
+**Fait**
+
+- Projet Laravel 13 créé dans `portail/` (développé en local sur le Mac : PHP 8.4/Composer/Node 22 y étaient déjà installés), plateforme Composer forcée à PHP 8.3 pour que les dépendances restent installables sur le serveur (PHP 8.3, via Sury). Pest 4 (Pest 5 exige PHP 8.4). `concurrently` retiré du starter (2 vulnérabilités critiques via `shell-quote`, et en réalité inutilisé : `php artisan dev` de Laravel 13 gère déjà le lancement parallèle nativement).
+- Vues, routes, JS, CSS, images de `design/` repris tels quels dans `portail/resources` et `portail/public`. Toutes les pages vitrine (une cinquantaine) fonctionnent sans rien construire de plus.
+- Modèles + migrations : `Etablissement`, `User` (+ `etablissement_id`, `jeton_session_actif`), `Classe` (code unique auto-généré), `Eleve` (identifiant unique, `code_secret` haché, `jeton_qr` à usage unique, `jeton_session_actif`), `Lab`, `Seance`, `LabSession`.
+- Deux guards d'authentification (`config/auth.php`) : `web` (profs, email/mot de passe) et `eleve` (identifiant/code secret, sans e-mail — minimisation des données mineurs). `App\Models\Eleve` authentifiable via le trait `Illuminate\Auth\Authenticatable` et `getAuthPasswordName()`.
+- **Session unique par compte** : trait `GereSessionUnique` (un jeton en base, recréé à chaque connexion) + middleware `VerifieSessionUnique` (`session.unique:web`/`session.unique:eleve`), qui déconnecte et prévient si le jeton de la session en cours ne correspond plus à celui, plus récent, enregistré en base.
+- Connexion (`/connexion`, un seul écran, deux formulaires), inscription (`/inscription` : crée établissement + prof + première classe en une transaction), gestion de classe (`/mes-classes/...` : ajout rapide, import CSV, génération identifiant + code à 6 caractères + QR à usage unique via `bacon/bacon-qr-code` en SVG, fiches imprimables), salle d'attente de séance (`/seances/...`, rafraîchissement automatique, le prof admet).
+- Service `GenerateurCompteEleve` : identifiant `prenom.initiale` (suffixe numérique si homonyme), code secret à 6 caractères sans caractères ambigus (`0/O`, `1/I/L`).
+- 11 tests Pest (connexion prof, connexion élève, session unique × 2, création de classe × 3) : tous passent, base SQLite en mémoire.
+- Déploiement : rôle Ansible `portail` (PHP 8.3 via Sury, Nginx, Composer avec vérification de signature officielle, Node 22 LTS via NodeSource, MariaDB+Redis de l'app en Docker Compose sur `127.0.0.1:3307`/`127.0.0.1:6380` — jamais sur `10.10.0.1`, réservé à Kolla), synchronisation du code par `rsync`, `.env` de production généré une seule fois (secrets jamais dans Git).
+
+**Deux décisions de design tranchées par Adam**
+
+1. Champ mot de passe ajouté au formulaire d'inscription (absent de la maquette) : sans lui, la connexion prof décrite dans le prompt n'aurait pas pu fonctionner sans serveur mail.
+2. Écrans sans maquette (gestion des élèves, salle d'attente) : design minimal sobre, mêmes jetons visuels que le reste du site, pas de recherche d'effet « wow ».
+
+**Problèmes rencontrés et solution**
+
+1. `@auth` (sans argument) dans le layout partagé retournait `true` pour un **élève** connecté, affichant le menu du prof. Cause : le middleware `auth:eleve` appelle `Auth::shouldUse('eleve')`, ce qui change le *guard par défaut* pour le reste de la requête — `@auth` nu teste alors ce guard-là, pas forcément `web`. Corrigé en précisant partout `@auth('web')` / `auth('eleve')`.
+2. Déploiement : j'ai modifié `kolla/globals.yml` et le script de sauvegarde dans le dépôt sans les repousser sur le serveur avant de relancer les outils correspondants (déjà rencontré à l'étape 7 — même piège, maintenant documenté deux fois).
+3. `php artisan key:generate` échouait : lancé avant `composer install`, donc avant que `vendor/autoload.php` existe. Réordonné : code → composer install → clé/`.env` → npm → migrations.
+4. `php artisan view:cache` échouait (« View path not found ») : `storage/framework/views` avait été exclu du `rsync` mais n'était créé par rien d'autre. Plus largement, **`storage/` et `bootstrap/cache/` ne doivent jamais être synchronisés depuis le poste de dev** (ce sont de l'état et du cache runtime, pas du code — un `rsync --delete` y effacerait un jour les travaux déposés par les élèves dans `storage/app/`). Corrigé : leur structure est créée une fois sur le serveur, propriété `www-data` dès le départ, et ils sont exclus en bloc du `rsync` (pas juste leurs sous-dossiers).
+5. **Un handler Ansible qui notifie un autre handler ne s'est pas propagé avant la fin du play** : Nginx a continué de servir sa page par défaut malgré un déploiement sans erreur apparente. Corrigé en fusionnant les deux handlers (`nginx -t` puis `systemctl reload nginx`) en un seul. Détecté uniquement parce que le critère de fin a été vérifié sur le serveur réel, pas seulement sur le code local.
+6. Vérification Playwright visuelle (demandée par le prompt) non faite : l'extension Chrome n'était pas connectée dans cette session. Vérification faite autrement : les mêmes fichiers Blade que `design/` sont repris sans changement de structure, et le flux complet a été vérifié par capture HTML (`curl`) côté connexion, tableau de bord et gestion de classe.
+
+**Critère vérifié (sur le serveur réel, pas seulement en local)**
+
+- 11/11 tests Pest passent (en local, avant déploiement).
+- Un élève fictif (`lea.m`) s'est connecté sur `http://163.172.4.195/connexion` et a vu son tableau de bord (« Salut Léa », nom de sa classe) — données de test supprimées après coup (accord d'Adam).
+- `nft list tables` après déploiement : toujours seulement `inet filter` + `ip nat` (+ `f2b-table`) — Nginx/PHP-FPM n'ont rien ajouté au pare-feu.
+
+**Comprendre**
+
+Cette étape a un piège intéressant pour la suite : Laravel a deux systèmes de comptes (profs et élèves), et un mécanisme Laravel conçu pour un seul système (« quel est l'utilisateur connecté ? ») suppose souvent qu'il n'y en a qu'un — le bug du menu qui affichait « Mes classes » à un élève connecté vient exactement de là. Chaque fois qu'on ajoutera un rôle (établissement, formateur, opérateur), il faudra se souvenir d'être explicite sur le guard, partout. L'autre leçon, plus générale : un déploiement qui se termine « sans erreur » ne veut pas dire que le résultat est correct — c'est en testant le vrai critère de fin sur le serveur réel (pas juste en relisant les logs Ansible) qu'on a trouvé le bug du handler Nginx.
+
+**Suite**
+
+Étape 9 : proxy console Go et xterm.js (jeton Redis à usage unique, relais WebSocket vers `nova-serialproxy`, lecture seule pour le prof).

docs/runbooks/portail.md

@@ -0,0 +1,97 @@
+# Runbook — Portail Laravel
+
+## Où sont les choses
+
+| Élément | Emplacement |
+|---|---|
+| Code de l'application | `/var/www/portail` (propriétaire `adam`, sauf `storage/` et `bootstrap/cache/` → `www-data`) |
+| Secrets Laravel (`.env`) | `/var/www/portail/.env`, `640 adam:www-data`, généré une seule fois, jamais dans Git |
+| Secrets MariaDB/Redis de l'app | `/etc/portail/.env`, `600 root:root`, générés une seule fois |
+| Config Docker Compose (MariaDB + Redis app) | `/etc/portail/docker-compose.yml` |
+| Vhost Nginx | `/etc/nginx/sites-available/portail.conf` |
+| PHP | 8.3 (dépôt Sury), FPM sur `/run/php/php8.3-fpm.sock` |
+
+Déployé par `ansible/portail.yml` (rôle `portail`) :
+```
+cd ansible && script -q /dev/null ansible-playbook portail.yml -i inventory.ini
+```
+
+## Architecture de l'app
+
+- Laravel 13, Blade + Vite (Tailwind v4 via le plugin Vite officiel).
+- Deux comptes distincts, deux guards (`config/auth.php`) :
+  - `web` → `User` (profs), email + mot de passe.
+  - `eleve` → `Eleve` (élèves), identifiant (`prenom.initiale`, suffixe numérique si homonyme) + code secret à 6 caractères (haché).
+- **Une seule session active par compte** (`App\Models\Concerns\GereSessionUnique` + middleware `session.unique`) : un jeton est stocké en session ET en base à chaque connexion ; s'ils ne correspondent plus, la session est coupée à la requête suivante avec un message.
+- Vues reprises telles quelles depuis `design/` (voir le journal du 2026-10-07, étape 8, pour les deux écarts assumés : mot de passe ajouté au formulaire d'inscription, sélecteur d'établissement retiré du formulaire de connexion).
+- Écrans sans maquette, construits sobres avec les jetons visuels existants : `resources/views/mes-classes/*` (gestion des élèves, import CSV, fiches QR) et `resources/views/seances/*` (salle d'attente).
+
+## Base de données et cache de l'app
+
+MariaDB et Redis **dédiés à l'app**, en Docker Compose, liés à `127.0.0.1` uniquement (jamais sur `10.10.0.1`, qui est le réseau de Kolla) :
+
+- MariaDB : port `3307` (celui de Kolla est sur `10.10.0.1:3306`).
+- Redis : port `6380`.
+
+```
+cd /etc/portail && docker compose ps
+```
+
+## Déployer une mise à jour du code
+
+```
+cd ansible && script -q /dev/null ansible-playbook portail.yml -i inventory.ini
+```
+
+Le rôle synchronise le code (`rsync`, sans `vendor/`, `node_modules/`, `.env`,
+ni `storage/`/`bootstrap/cache/` — ce sont de l'état runtime, jamais du code),
+puis `composer install --no-dev`, `npm ci && npm run build`,
+`php artisan migrate --force`, et recrée les caches
+(`config:cache`, `route:cache`, `view:cache`).
+
+**Après toute modification de code qui touche les routes ou la config**, les
+caches doivent être régénérés (le rôle le fait automatiquement). Si on modifie
+une vue sans repasser par Ansible, penser à `php artisan view:clear` à la main.
+
+## Lancer les tests (en local, avant tout déploiement)
+
+```
+cd portail && ./vendor/bin/pest
+```
+
+11 tests : connexion prof, connexion élève, session unique (prof et élève),
+création de classe + établissement. Base de test : SQLite en mémoire
+(`phpunit.xml`), aucun rapport avec MariaDB de prod.
+
+## Écarts au design assumés le 2026-10-07
+
+- `auth/inscription.blade.php` : champ mot de passe ajouté (absent de la
+  maquette), confirmé par Adam — sans lui, la connexion prof décrite dans le
+  prompt de déploiement n'aurait pas pu fonctionner sans serveur mail.
+- `auth/connexion.blade.php` : le sélecteur d'établissement du formulaire
+  enseignant a été retiré (un prof qui se connecte a déjà un établissement en
+  base ; ce sélecteur n'avait de sens que pour l'inscription).
+- `paillasse-contenus/README.md` corrigé : `tree` n'est pas préinstallé dans
+  l'image (le lab 02 demande à l'élève de l'installer lui-même).
+- Gestion des élèves (ajout, import CSV, fiches QR) et salle d'attente :
+  aucune maquette fournie, design minimal sobre construit avec les jetons
+  visuels existants (confirmé par Adam).
+
+## Piège vécu le 2026-10-07
+
+Un handler Ansible qui notifie un autre handler (`recharger nginx` →
+`redémarrer nginx`) ne s'est **pas** propagé avant la fin du play : Nginx a
+continué de servir sa page par défaut malgré un déploiement « réussi ».
+Corrigé en fusionnant les deux handlers en un seul
+(`nginx -t && systemctl reload nginx`). Si un jour un changement Nginx semble
+sans effet, vérifier d'abord `sudo nginx -T` sur le serveur, puis forcer
+`sudo systemctl reload nginx` à la main.
+
+## Vérifié le 2026-10-07
+
+- `curl http://163.172.4.195/connexion` : les deux formulaires s'affichent.
+- Un élève fictif (`lea.m` / code à 6 caractères) s'est connecté et a vu son
+  tableau de bord (« Salut Léa », nom de sa classe) — données de test
+  supprimées juste après (accord d'Adam).
+- `nft list tables` après déploiement : toujours seulement `inet filter` et
+  `ip nat` (+ `f2b-table` de fail2ban) — Nginx n'a rien ajouté au pare-feu.

portail/.editorconfig

@@ -0,0 +1,18 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.{yml,yaml}]
+indent_size = 2
+
+[{compose,docker-compose}.{yml,yaml}]
+indent_size = 4

portail/.env.example

@@ -0,0 +1,65 @@
+APP_NAME=Laravel
+APP_ENV=local
+APP_KEY=
+APP_DEBUG=true
+APP_URL=http://localhost:8000
+
+APP_LOCALE=en
+APP_FALLBACK_LOCALE=en
+APP_FAKER_LOCALE=en_US
+
+APP_MAINTENANCE_DRIVER=file
+# APP_MAINTENANCE_STORE=database
+
+# PHP_CLI_SERVER_WORKERS=4
+
+BCRYPT_ROUNDS=12
+
+LOG_CHANNEL=stack
+LOG_STACK=single
+LOG_DEPRECATIONS_CHANNEL=null
+LOG_LEVEL=debug
+
+DB_CONNECTION=sqlite
+# DB_HOST=127.0.0.1
+# DB_PORT=3306
+# DB_DATABASE=laravel
+# DB_USERNAME=root
+# DB_PASSWORD=
+
+SESSION_DRIVER=database
+SESSION_LIFETIME=120
+SESSION_ENCRYPT=false
+SESSION_PATH=/
+SESSION_DOMAIN=null
+
+BROADCAST_CONNECTION=log
+FILESYSTEM_DISK=local
+QUEUE_CONNECTION=database
+
+CACHE_STORE=database
+# CACHE_PREFIX=
+
+MEMCACHED_HOST=127.0.0.1
+
+REDIS_CLIENT=phpredis
+REDIS_HOST=127.0.0.1
+REDIS_PASSWORD=null
+REDIS_PORT=6379
+
+MAIL_MAILER=log
+MAIL_SCHEME=null
+MAIL_HOST=127.0.0.1
+MAIL_PORT=2525
+MAIL_USERNAME=null
+MAIL_PASSWORD=null
+MAIL_FROM_ADDRESS="hello@example.com"
+MAIL_FROM_NAME="${APP_NAME}"
+
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+AWS_DEFAULT_REGION=us-east-1
+AWS_BUCKET=
+AWS_USE_PATH_STYLE_ENDPOINT=false
+
+VITE_APP_NAME="${APP_NAME}"

portail/.gitattributes

@@ -0,0 +1,11 @@
+* text=auto eol=lf
+
+*.blade.php diff=html
+*.css diff=css
+*.html diff=html
+*.md diff=markdown
+*.php diff=php
+
+/.github export-ignore
+CHANGELOG.md export-ignore
+.styleci.yml export-ignore

portail/.gitignore

@@ -0,0 +1,28 @@
+*.log
+.DS_Store
+.env
+/database/database.sqlite
+.env.backup
+.env.production
+.phpactor.json
+.phpunit.result.cache
+/.codex
+/.cursor/
+/.idea
+/.nova
+/.phpunit.cache
+/.vscode
+/.zed
+/auth.json
+/node_modules
+/public/build
+/public/fonts-manifest.dev.json
+/public/hot
+/public/storage
+/storage/*.key
+/storage/pail
+/vendor
+_ide_helper.php
+Homestead.json
+Homestead.yaml
+Thumbs.db

portail/.npmrc

@@ -0,0 +1,2 @@
+ignore-scripts=true
+audit=true

portail/README.md

@@ -0,0 +1,58 @@
+<p align="center"><a href="https://laravel.com" target="_blank"><img src="https://raw.githubusercontent.com/laravel/art/master/logo-lockup/5%20SVG/2%20CMYK/1%20Full%20Color/laravel-logolockup-cmyk-red.svg" width="400" alt="Laravel Logo"></a></p>
+
+<p align="center">
+<a href="https://github.com/laravel/framework/actions"><img src="https://github.com/laravel/framework/workflows/tests/badge.svg" alt="Build Status"></a>
+<a href="https://packagist.org/packages/laravel/framework"><img src="https://img.shields.io/packagist/dt/laravel/framework" alt="Total Downloads"></a>
+<a href="https://packagist.org/packages/laravel/framework"><img src="https://img.shields.io/packagist/v/laravel/framework" alt="Latest Stable Version"></a>
+<a href="https://packagist.org/packages/laravel/framework"><img src="https://img.shields.io/packagist/l/laravel/framework" alt="License"></a>
+</p>
+
+## About Laravel
+
+Laravel is a web application framework with expressive, elegant syntax. We believe development must be an enjoyable and creative experience to be truly fulfilling. Laravel takes the pain out of development by easing common tasks used in many web projects, such as:
+
+- [Simple, fast routing engine](https://laravel.com/docs/routing).
+- [Powerful dependency injection container](https://laravel.com/docs/container).
+- Multiple back-ends for [session](https://laravel.com/docs/session) and [cache](https://laravel.com/docs/cache) storage.
+- Expressive, intuitive [database ORM](https://laravel.com/docs/eloquent).
+- Database agnostic [schema migrations](https://laravel.com/docs/migrations).
+- [Robust background job processing](https://laravel.com/docs/queues).
+- [Real-time event broadcasting](https://laravel.com/docs/broadcasting).
+
+Laravel is accessible, powerful, and provides tools required for large, robust applications.
+
+## Learning Laravel
+
+Laravel has the most extensive and thorough [documentation](https://laravel.com/docs) and video tutorial library of all modern web application frameworks, making it a breeze to get started with the framework.
+
+In addition, [Laracasts](https://laracasts.com) contains thousands of video tutorials on a range of topics including Laravel, modern PHP, unit testing, and JavaScript. Boost your skills by digging into our comprehensive video library.
+
+You can also watch bite-sized lessons with real-world projects on [Laravel Learn](https://laravel.com/learn), where you will be guided through building a Laravel application from scratch while learning PHP fundamentals.
+
+## Agentic Development
+
+Laravel's predictable structure and conventions make it ideal for AI coding agents like Claude Code, Cursor, and GitHub Copilot. Install [Laravel Boost](https://laravel.com/docs/ai) to supercharge your AI workflow:
+
+```bash
+composer require laravel/boost --dev
+
+php artisan boost:install
+```
+
+Boost provides your agent 15+ tools and skills that help agents build Laravel applications while following best practices.
+
+## Contributing
+
+Thank you for considering contributing to the Laravel framework! The contribution guide can be found in the [Laravel documentation](https://laravel.com/docs/contributions).
+
+## Code of Conduct
+
+In order to ensure that the Laravel community is welcoming to all, please review and abide by the [Code of Conduct](https://laravel.com/docs/contributions#code-of-conduct).
+
+## Security Vulnerabilities
+
+If you discover a security vulnerability within Laravel, please send an e-mail to Taylor Otwell via [taylor@laravel.com](mailto:taylor@laravel.com). All security vulnerabilities will be promptly addressed.
+
+## License
+
+The Laravel framework is open-sourced software licensed under the [MIT license](https://opensource.org/licenses/MIT).

portail/app/Http/Controllers/Auth/ConnexionController.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace App\Http\Controllers\Auth;
+
+use App\Http\Controllers\Controller;
+use App\Models\Eleve;
+use App\Models\User;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\RateLimiter;
+use Illuminate\Validation\ValidationException;
+
+class ConnexionController extends Controller
+{
+    public function connexionProf(Request $request): RedirectResponse
+    {
+        $donnees = $request->validate([
+            'email' => ['required', 'email'],
+            'password' => ['required', 'string'],
+        ]);
+
+        $this->appliquerLimiteTentatives($request, 'prof:'.$donnees['email']);
+
+        if (! Auth::guard('web')->attempt($donnees)) {
+            RateLimiter::hit($this->cleLimite($request, 'prof:'.$donnees['email']));
+
+            throw ValidationException::withMessages([
+                'email' => 'Identifiants incorrects.',
+            ]);
+        }
+
+        RateLimiter::clear($this->cleLimite($request, 'prof:'.$donnees['email']));
+        $request->session()->regenerate();
+
+        /** @var User $prof */
+        $prof = Auth::guard('web')->user();
+        $avaitDejaUneSession = $prof->jeton_session_actif !== null;
+        $request->session()->put('jeton_session_web', $prof->demarreNouvelleSession());
+
+        return redirect()->route('mes-classes.index')
+            ->with('session_precedente_fermee', $avaitDejaUneSession);
+    }
+
+    public function connexionEleve(Request $request): RedirectResponse
+    {
+        $donnees = $request->validate([
+            'identifiant' => ['required', 'string'],
+            'code' => ['required', 'string'],
+        ]);
+
+        $this->appliquerLimiteTentatives($request, 'eleve:'.$donnees['identifiant']);
+
+        $succes = Auth::guard('eleve')->attempt([
+            'identifiant' => $donnees['identifiant'],
+            'password' => $donnees['code'],
+        ]);
+
+        if (! $succes) {
+            RateLimiter::hit($this->cleLimite($request, 'eleve:'.$donnees['identifiant']));
+
+            throw ValidationException::withMessages([
+                'identifiant' => 'Identifiant ou code secret incorrect.',
+            ]);
+        }
+
+        RateLimiter::clear($this->cleLimite($request, 'eleve:'.$donnees['identifiant']));
+        $request->session()->regenerate();
+
+        /** @var Eleve $eleve */
+        $eleve = Auth::guard('eleve')->user();
+        $eleve->forceFill(['derniere_connexion_a' => now()])->save();
+        $request->session()->put('jeton_session_eleve', $eleve->demarreNouvelleSession());
+
+        return redirect()->route('eleve');
+    }
+
+    /**
+     * Connexion directe par QR (à usage unique, voir App\Services\GenerateurCompteEleve).
+     */
+    public function connexionParQr(Request $request, string $jeton): RedirectResponse
+    {
+        $eleve = Eleve::where('jeton_qr', $jeton)->first();
+
+        if ($eleve === null) {
+            abort(404);
+        }
+
+        $eleve->forceFill(['jeton_qr' => null, 'derniere_connexion_a' => now()])->save();
+        Auth::guard('eleve')->login($eleve);
+        $request->session()->regenerate();
+        $request->session()->put('jeton_session_eleve', $eleve->demarreNouvelleSession());
+
+        return redirect()->route('eleve');
+    }
+
+    public function deconnexion(Request $request): RedirectResponse
+    {
+        if (Auth::guard('web')->check()) {
+            Auth::guard('web')->user()->terminerSession();
+            Auth::guard('web')->logout();
+        }
+
+        if (Auth::guard('eleve')->check()) {
+            Auth::guard('eleve')->user()->terminerSession();
+            Auth::guard('eleve')->logout();
+        }
+
+        $request->session()->invalidate();
+        $request->session()->regenerateToken();
+
+        return redirect()->route('accueil');
+    }
+
+    private function cleLimite(Request $request, string $identifiant): string
+    {
+        return 'connexion:'.$identifiant.'|'.$request->ip();
+    }
+
+    private function appliquerLimiteTentatives(Request $request, string $identifiant): void
+    {
+        $cle = $this->cleLimite($request, $identifiant);
+
+        if (RateLimiter::tooManyAttempts($cle, 5)) {
+            $secondes = RateLimiter::availableIn($cle);
+
+            throw ValidationException::withMessages([
+                'identifiant' => "Trop de tentatives. Réessaie dans {$secondes} secondes.",
+            ]);
+        }
+    }
+}

portail/app/Http/Controllers/ClasseController.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Classe;
+use App\Models\Eleve;
+use App\Services\GenerateurCompteEleve;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Str;
+use Illuminate\View\View;
+
+class ClasseController extends Controller
+{
+    public function __construct(private readonly GenerateurCompteEleve $generateur) {}
+
+    public function index(): View
+    {
+        $classes = Auth::guard('web')->user()->classes()->withCount('eleves')->latest()->get();
+
+        return view('mes-classes.index', ['classes' => $classes]);
+    }
+
+    public function show(Classe $classe): View
+    {
+        $this->verifierProprietaire($classe);
+
+        return view('mes-classes.show', [
+            'classe' => $classe->load('eleves'),
+        ]);
+    }
+
+    public function storeEleve(Request $request, Classe $classe): RedirectResponse
+    {
+        $this->verifierProprietaire($classe);
+
+        $donnees = $request->validate([
+            'prenom' => ['required', 'string', 'max:100'],
+            'nom' => ['nullable', 'string', 'max:100'],
+        ]);
+
+        $fiche = $this->creerEleve($classe, $donnees['prenom'], $donnees['nom'] ?? null);
+
+        return redirect()->route('mes-classes.show', $classe)
+            ->with('fiches', [$fiche]);
+    }
+
+    public function importerCsv(Request $request, Classe $classe): RedirectResponse
+    {
+        $this->verifierProprietaire($classe);
+
+        $request->validate([
+            'fichier' => ['required', 'file', 'mimes:csv,txt'],
+        ]);
+
+        $lignes = file($request->file('fichier')->getRealPath(), FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
+        $fiches = [];
+
+        foreach ($lignes as $ligne) {
+            $colonnes = str_getcsv($ligne);
+            $prenom = trim($colonnes[0] ?? '');
+
+            if ($prenom === '' || Str::lower($prenom) === 'prenom') {
+                continue; // ligne vide ou en-tête
+            }
+
+            $nom = trim($colonnes[1] ?? '') ?: null;
+            $fiches[] = $this->creerEleve($classe, $prenom, $nom);
+        }
+
+        return redirect()->route('mes-classes.show', $classe)
+            ->with('fiches', $fiches)
+            ->with('nombre_importes', count($fiches));
+    }
+
+    public function regenererCode(Classe $classe, Eleve $eleve): RedirectResponse
+    {
+        $this->verifierProprietaire($classe);
+        abort_if($eleve->classe_id !== $classe->id, 404);
+
+        $codeSecret = $this->generateur->genererCodeSecret();
+        $jetonQr = Str::random(32);
+
+        $eleve->forceFill([
+            'code_secret' => Hash::make($codeSecret),
+            'jeton_qr' => $jetonQr,
+        ])->save();
+
+        return redirect()->route('mes-classes.show', $classe)
+            ->with('fiches', [[
+                'identifiant' => $eleve->identifiant,
+                'prenom' => $eleve->prenom,
+                'nom' => $eleve->nom,
+                'code_secret' => $codeSecret,
+                'jeton_qr' => $jetonQr,
+            ]]);
+    }
+
+    /**
+     * @return array{identifiant: string, prenom: string, nom: ?string, code_secret: string, jeton_qr: string}
+     */
+    private function creerEleve(Classe $classe, string $prenom, ?string $nom): array
+    {
+        $identifiant = $this->generateur->genererIdentifiant($prenom, $nom);
+        $codeSecret = $this->generateur->genererCodeSecret();
+        $jetonQr = Str::random(32);
+
+        $classe->eleves()->create([
+            'prenom' => $prenom,
+            'nom' => $nom,
+            'identifiant' => $identifiant,
+            'code_secret' => Hash::make($codeSecret),
+            'jeton_qr' => $jetonQr,
+        ]);
+
+        return [
+            'identifiant' => $identifiant,
+            'prenom' => $prenom,
+            'nom' => $nom,
+            'code_secret' => $codeSecret,
+            'jeton_qr' => $jetonQr,
+        ];
+    }
+
+    private function verifierProprietaire(Classe $classe): void
+    {
+        abort_if($classe->user_id !== Auth::guard('web')->id(), 403);
+    }
+}

portail/app/Http/Controllers/Controller.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace App\Http\Controllers;
+
+abstract class Controller
+{
+    //
+}

portail/app/Http/Controllers/EleveTableauDeBordController.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use Illuminate\Support\Facades\Auth;
+use Illuminate\View\View;
+
+class EleveTableauDeBordController extends Controller
+{
+    public function show(): View
+    {
+        $eleve = Auth::guard('eleve')->user()->load('classe');
+
+        return view('eleve', ['eleve' => $eleve]);
+    }
+}

portail/app/Http/Controllers/InscriptionController.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Classe;
+use App\Models\Etablissement;
+use App\Models\User;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Hash;
+
+class InscriptionController extends Controller
+{
+    public function store(Request $request): RedirectResponse
+    {
+        $donnees = $request->validate([
+            'prenom' => ['required', 'string', 'max:100'],
+            'nom' => ['required', 'string', 'max:100'],
+            'email' => ['required', 'email', 'unique:users,email'],
+            'password' => ['required', 'string', 'min:8', 'confirmed'],
+            'etablissement_nom_liste' => ['required', 'string'],
+            'etablissement_nom' => ['required_if:etablissement_nom_liste,autre', 'nullable', 'string', 'max:150'],
+            'etablissement_ville' => ['required_if:etablissement_nom_liste,autre', 'nullable', 'string', 'max:100'],
+            'etablissement_uai' => ['nullable', 'string', 'max:20'],
+            'formation' => ['nullable', 'string', 'max:100'],
+            'classe' => ['required', 'string', 'max:100'],
+        ]);
+
+        [$prof, $classe] = DB::transaction(function () use ($donnees) {
+            $etablissement = $donnees['etablissement_nom_liste'] === 'autre'
+                ? Etablissement::firstOrCreate(
+                    ['nom' => $donnees['etablissement_nom']],
+                    ['ville' => $donnees['etablissement_ville'], 'uai' => $donnees['etablissement_uai'] ?? null],
+                )
+                : Etablissement::firstOrCreate(['nom' => $donnees['etablissement_nom_liste']]);
+
+            $prof = User::create([
+                'name' => trim($donnees['prenom'].' '.$donnees['nom']),
+                'email' => $donnees['email'],
+                'password' => Hash::make($donnees['password']),
+                'etablissement_id' => $etablissement->id,
+            ]);
+
+            $classe = Classe::create([
+                'etablissement_id' => $etablissement->id,
+                'user_id' => $prof->id,
+                'nom' => $donnees['classe'],
+                'formation' => $donnees['formation'] ?? null,
+            ]);
+
+            return [$prof, $classe];
+        });
+
+        Auth::guard('web')->login($prof);
+        $request->session()->regenerate();
+        $request->session()->put('jeton_session_web', $prof->demarreNouvelleSession());
+
+        return redirect()->route('mes-classes.show', $classe)
+            ->with('classe_creee', true);
+    }
+}

portail/app/Http/Controllers/SeanceController.php

@@ -0,0 +1,85 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Classe;
+use App\Models\LabSession;
+use App\Models\Seance;
+use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\View\View;
+
+class SeanceController extends Controller
+{
+    public function store(Request $request, Classe $classe): RedirectResponse
+    {
+        abort_if($classe->user_id !== Auth::guard('web')->id(), 403);
+
+        $donnees = $request->validate([
+            'lab_id' => ['required', 'exists:labs,id'],
+        ]);
+
+        $seance = $classe->seances()->create([
+            'lab_id' => $donnees['lab_id'],
+            'statut' => Seance::SALLE_ATTENTE,
+            'demarree_a' => now(),
+        ]);
+
+        return redirect()->route('seances.attente', $seance);
+    }
+
+    public function attente(Seance $seance): View
+    {
+        abort_if($seance->classe->user_id !== Auth::guard('web')->id(), 403);
+
+        return view('seances.attente', [
+            'seance' => $seance->load(['classe', 'lab', 'labSessions.eleve']),
+        ]);
+    }
+
+    public function admettre(Seance $seance, LabSession $labSession): RedirectResponse
+    {
+        abort_if($seance->classe->user_id !== Auth::guard('web')->id(), 403);
+        abort_if($labSession->seance_id !== $seance->id, 404);
+
+        $labSession->update(['etat' => LabSession::ADMIS]);
+
+        return redirect()->route('seances.attente', $seance);
+    }
+
+    /**
+     * Un élève rejoint la séance : il patiente jusqu'à ce que le prof l'admette.
+     */
+    public function rejoindre(Request $request, Seance $seance): RedirectResponse
+    {
+        $eleve = Auth::guard('eleve')->user();
+        abort_if($eleve->classe_id !== $seance->classe_id, 403);
+
+        LabSession::firstOrCreate(
+            ['seance_id' => $seance->id, 'eleve_id' => $eleve->id],
+            ['lab_id' => $seance->lab_id, 'etat' => LabSession::EN_ATTENTE],
+        );
+
+        return redirect()->route('seances.eleve.attente', $seance);
+    }
+
+    public function attenteEleve(Seance $seance): View|RedirectResponse
+    {
+        $eleve = Auth::guard('eleve')->user();
+        abort_if($eleve->classe_id !== $seance->classe_id, 403);
+
+        $labSession = LabSession::where('seance_id', $seance->id)
+            ->where('eleve_id', $eleve->id)
+            ->first();
+
+        if ($labSession === null) {
+            return redirect()->route('eleve');
+        }
+
+        return view('seances.attente-eleve', [
+            'seance' => $seance->load('lab'),
+            'labSession' => $labSession,
+        ]);
+    }
+}

portail/app/Http/Middleware/VerifieSessionUnique.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use Closure;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * Une seule session active par compte (étape 8). Si le jeton que porte cette
+ * session ne correspond plus à celui enregistré sur le compte, c'est qu'une
+ * connexion plus récente a eu lieu ailleurs : on déconnecte et on le dit.
+ */
+class VerifieSessionUnique
+{
+    public function handle(Request $request, Closure $next, string $garde = 'web'): Response
+    {
+        $utilisateur = Auth::guard($garde)->user();
+
+        if ($utilisateur !== null) {
+            $cleSession = "jeton_session_{$garde}";
+
+            if (! $utilisateur->sessionEstEncoreValide($request->session()->get($cleSession))) {
+                Auth::guard($garde)->logout();
+                $request->session()->invalidate();
+                $request->session()->regenerateToken();
+
+                return redirect()->route('login')
+                    ->with('session_coupee', 'Vous avez été déconnecté : une nouvelle connexion a eu lieu sur votre compte.');
+            }
+        }
+
+        return $next($request);
+    }
+}

portail/app/Models/Classe.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Support\Str;
+
+class Classe extends Model
+{
+    use HasFactory;
+
+    protected $fillable = ['etablissement_id', 'user_id', 'nom', 'formation', 'code_classe'];
+
+    protected $casts = [
+        'archivee_a' => 'datetime',
+    ];
+
+    protected static function booted(): void
+    {
+        static::creating(function (Classe $classe) {
+            $classe->code_classe ??= static::genererCodeUnique();
+        });
+    }
+
+    public static function genererCodeUnique(): string
+    {
+        do {
+            $code = Str::upper(Str::random(6));
+        } while (static::where('code_classe', $code)->exists());
+
+        return $code;
+    }
+
+    public function etablissement(): BelongsTo
+    {
+        return $this->belongsTo(Etablissement::class);
+    }
+
+    public function prof(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'user_id');
+    }
+
+    public function eleves(): HasMany
+    {
+        return $this->hasMany(Eleve::class);
+    }
+
+    public function seances(): HasMany
+    {
+        return $this->hasMany(Seance::class);
+    }
+
+    public function estArchivee(): bool
+    {
+        return $this->archivee_a !== null;
+    }
+}

portail/app/Models/Concerns/GereSessionUnique.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Models\Concerns;
+
+use Illuminate\Support\Str;
+
+/**
+ * Une seule session active par compte (étape 8) : la précédente est coupée
+ * et son porteur en est averti à sa prochaine requête (voir
+ * App\Http\Middleware\VerifieSessionUnique).
+ */
+trait GereSessionUnique
+{
+    public function demarreNouvelleSession(): string
+    {
+        $jeton = Str::random(40);
+        $this->forceFill(['jeton_session_actif' => $jeton])->save();
+
+        return $jeton;
+    }
+
+    public function sessionEstEncoreValide(?string $jeton): bool
+    {
+        return $jeton !== null && $jeton === $this->jeton_session_actif;
+    }
+
+    public function terminerSession(): void
+    {
+        $this->forceFill(['jeton_session_actif' => null])->save();
+    }
+}

portail/app/Models/Eleve.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Models;
+
+use App\Models\Concerns\GereSessionUnique;
+use Illuminate\Auth\Authenticatable;
+use Illuminate\Contracts\Auth\Authenticatable as AuthenticatableContract;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class Eleve extends Model implements AuthenticatableContract
+{
+    use Authenticatable, GereSessionUnique, HasFactory;
+
+    protected $fillable = ['classe_id', 'prenom', 'nom', 'identifiant', 'code_secret', 'jeton_qr'];
+
+    protected $hidden = ['code_secret', 'jeton_session_actif', 'jeton_qr'];
+
+    protected $casts = [
+        'derniere_connexion_a' => 'datetime',
+    ];
+
+    public function getAuthPasswordName(): string
+    {
+        return 'code_secret';
+    }
+
+    public function classe(): BelongsTo
+    {
+        return $this->belongsTo(Classe::class);
+    }
+
+    public function labSessions(): HasMany
+    {
+        return $this->hasMany(LabSession::class);
+    }
+
+    public function nomAffiche(): string
+    {
+        return $this->nom
+            ? $this->prenom.' '.mb_substr($this->nom, 0, 1).'.'
+            : $this->prenom;
+    }
+}

portail/app/Models/Etablissement.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class Etablissement extends Model
+{
+    use HasFactory;
+
+    protected $fillable = ['nom', 'ville', 'uai'];
+
+    public function profs(): HasMany
+    {
+        return $this->hasMany(User::class);
+    }
+
+    public function classes(): HasMany
+    {
+        return $this->hasMany(Classe::class);
+    }
+}

portail/app/Models/Lab.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class Lab extends Model
+{
+    use HasFactory;
+
+    protected $fillable = ['identifiant', 'titre', 'niveau', 'duree_min'];
+
+    public function seances(): HasMany
+    {
+        return $this->hasMany(Seance::class);
+    }
+}

portail/app/Models/LabSession.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class LabSession extends Model
+{
+    use HasFactory;
+
+    public const EN_ATTENTE = 'en_attente';
+
+    public const ADMIS = 'admis';
+
+    public const ACTIF = 'actif';
+
+    public const TERMINE = 'termine';
+
+    public const EXPIRE = 'expire';
+
+    protected $fillable = ['seance_id', 'eleve_id', 'lab_id', 'stack_id', 'etat', 'expire_a'];
+
+    protected $casts = [
+        'expire_a' => 'datetime',
+    ];
+
+    public function seance(): BelongsTo
+    {
+        return $this->belongsTo(Seance::class);
+    }
+
+    public function eleve(): BelongsTo
+    {
+        return $this->belongsTo(Eleve::class);
+    }
+
+    public function lab(): BelongsTo
+    {
+        return $this->belongsTo(Lab::class);
+    }
+}

portail/app/Models/Seance.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+class Seance extends Model
+{
+    use HasFactory;
+
+    public const PLANIFIEE = 'planifiee';
+
+    public const SALLE_ATTENTE = 'salle_attente';
+
+    public const EN_COURS = 'en_cours';
+
+    public const TERMINEE = 'terminee';
+
+    protected $fillable = ['classe_id', 'lab_id', 'statut', 'demarree_a', 'terminee_a'];
+
+    protected $casts = [
+        'demarree_a' => 'datetime',
+        'terminee_a' => 'datetime',
+    ];
+
+    public function classe(): BelongsTo
+    {
+        return $this->belongsTo(Classe::class);
+    }
+
+    public function lab(): BelongsTo
+    {
+        return $this->belongsTo(Lab::class);
+    }
+
+    public function labSessions(): HasMany
+    {
+        return $this->hasMany(LabSession::class);
+    }
+}

portail/app/Models/User.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Models;
+
+// use Illuminate\Contracts\Auth\MustVerifyEmail;
+use App\Models\Concerns\GereSessionUnique;
+use Database\Factories\UserFactory;
+use Illuminate\Database\Eloquent\Attributes\Fillable;
+use Illuminate\Database\Eloquent\Attributes\Hidden;
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Foundation\Auth\User as Authenticatable;
+use Illuminate\Notifications\Notifiable;
+
+#[Fillable(['name', 'email', 'password', 'etablissement_id'])]
+#[Hidden(['password', 'remember_token', 'jeton_session_actif'])]
+class User extends Authenticatable
+{
+    /** @use HasFactory<UserFactory> */
+    use GereSessionUnique, HasFactory, Notifiable;
+
+    /**
+     * Get the attributes that should be cast.
+     *
+     * @return array<string, string>
+     */
+    protected function casts(): array
+    {
+        return [
+            'email_verified_at' => 'datetime',
+            'password' => 'hashed',
+        ];
+    }
+
+    public function etablissement(): BelongsTo
+    {
+        return $this->belongsTo(Etablissement::class);
+    }
+
+    public function classes(): HasMany
+    {
+        return $this->hasMany(Classe::class);
+    }
+}

portail/app/Providers/AppServiceProvider.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Providers;
+
+use Illuminate\Support\ServiceProvider;
+
+class AppServiceProvider extends ServiceProvider
+{
+    /**
+     * Register any application services.
+     */
+    public function register(): void
+    {
+        //
+    }
+
+    /**
+     * Bootstrap any application services.
+     */
+    public function boot(): void
+    {
+        //
+    }
+}

portail/app/Services/GenerateurCompteEleve.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\Eleve;
+use Illuminate\Support\Str;
+
+/**
+ * Génère les identifiants (prénom.initiale, avec un numéro pour les
+ * homonymes) et les codes secrets des élèves (étape 8 du déploiement).
+ */
+class GenerateurCompteEleve
+{
+    // Sans 0/O ni 1/I/L, pour qu'un élève ne confonde pas à la lecture.
+    private const ALPHABET_CODE = 'ABCDEFGHJKMNPQRSTUVWXYZ23456789';
+
+    public function genererIdentifiant(string $prenom, ?string $nom): string
+    {
+        $base = Str::slug($prenom, '');
+        if ($nom !== null && $nom !== '') {
+            $base .= '.'.Str::slug(mb_substr($nom, 0, 1));
+        }
+
+        $identifiant = $base;
+        $suffixe = 2;
+        while (Eleve::where('identifiant', $identifiant)->exists()) {
+            $identifiant = $base.$suffixe;
+            $suffixe++;
+        }
+
+        return $identifiant;
+    }
+
+    public function genererCodeSecret(): string
+    {
+        $code = '';
+        for ($i = 0; $i < 6; $i++) {
+            $code .= self::ALPHABET_CODE[random_int(0, strlen(self::ALPHABET_CODE) - 1)];
+        }
+
+        return $code;
+    }
+}

portail/app/Support/QrCode.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Support;
+
+use BaconQrCode\Renderer\Image\SvgImageBackEnd;
+use BaconQrCode\Renderer\ImageRenderer;
+use BaconQrCode\Renderer\RendererStyle\RendererStyle;
+use BaconQrCode\Writer;
+
+/**
+ * QR code en SVG (pas de dépendance Imagick/GD), pour les fiches de
+ * connexion imprimables de l'étape 8.
+ */
+class QrCode
+{
+    public static function svg(string $contenu, int $taille = 180): string
+    {
+        $rendu = new ImageRenderer(new RendererStyle($taille), new SvgImageBackEnd);
+
+        return (new Writer($rendu))->writeString($contenu);
+    }
+}

portail/artisan

@@ -0,0 +1,18 @@
+#!/usr/bin/env php
+<?php
+
+use Illuminate\Foundation\Application;
+use Symfony\Component\Console\Input\ArgvInput;
+
+define('LARAVEL_START', microtime(true));
+
+// Register the Composer autoloader...
+require __DIR__.'/vendor/autoload.php';
+
+// Bootstrap Laravel and handle the command...
+/** @var Application $app */
+$app = require_once __DIR__.'/bootstrap/app.php';
+
+$status = $app->handleCommand(new ArgvInput);
+
+exit($status);

portail/bootstrap/app.php

@@ -0,0 +1,23 @@
+<?php
+
+use Illuminate\Foundation\Application;
+use Illuminate\Foundation\Configuration\Exceptions;
+use Illuminate\Foundation\Configuration\Middleware;
+use Illuminate\Http\Request;
+
+return Application::configure(basePath: dirname(__DIR__))
+    ->withRouting(
+        web: __DIR__.'/../routes/web.php',
+        commands: __DIR__.'/../routes/console.php',
+        health: '/up',
+    )
+    ->withMiddleware(function (Middleware $middleware): void {
+        $middleware->alias([
+            'session.unique' => \App\Http\Middleware\VerifieSessionUnique::class,
+        ]);
+    })
+    ->withExceptions(function (Exceptions $exceptions): void {
+        $exceptions->shouldRenderJsonWhen(
+            fn (Request $request) => $request->is('api/*') || $request->expectsJson(),
+        );
+    })->create();

portail/bootstrap/cache/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

portail/bootstrap/providers.php

@@ -0,0 +1,7 @@
+<?php
+
+use App\Providers\AppServiceProvider;
+
+return [
+    AppServiceProvider::class,
+];

portail/composer.json

@@ -0,0 +1,92 @@
+{
+    "$schema": "https://getcomposer.org/schema.json",
+    "name": "laravel/laravel",
+    "type": "project",
+    "description": "The skeleton application for the Laravel framework.",
+    "keywords": ["laravel", "framework"],
+    "license": "MIT",
+    "require": {
+        "php": "^8.3",
+        "bacon/bacon-qr-code": "^3.1",
+        "laravel/framework": "^13.17",
+        "laravel/tinker": "^3.0"
+    },
+    "require-dev": {
+        "fakerphp/faker": "^1.23",
+        "laravel/pail": "^1.2.5",
+        "laravel/pao": "^1.0.6",
+        "laravel/pint": "^1.27",
+        "mockery/mockery": "^1.6",
+        "nunomaduro/collision": "^8.6",
+        "pestphp/pest": "^4.0",
+        "pestphp/pest-plugin-laravel": "^4.0",
+        "phpunit/phpunit": "^12.5.12"
+    },
+    "autoload": {
+        "psr-4": {
+            "App\\": "app/",
+            "Database\\Factories\\": "database/factories/",
+            "Database\\Seeders\\": "database/seeders/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Tests\\": "tests/"
+        }
+    },
+    "scripts": {
+        "setup": [
+            "composer install",
+            "@php -r \"file_exists('.env') || copy('.env.example', '.env');\"",
+            "@php artisan key:generate",
+            "@php artisan migrate --force",
+            "npm install --ignore-scripts",
+            "npm run build"
+        ],
+        "dev": [
+            "Composer\\Config::disableProcessTimeout",
+            "@php artisan dev"
+        ],
+        "test": [
+            "@php artisan config:clear --ansi @no_additional_args",
+            "@php artisan test"
+        ],
+        "post-autoload-dump": [
+            "Illuminate\\Foundation\\ComposerScripts::postAutoloadDump",
+            "@php artisan package:discover --ansi"
+        ],
+        "post-update-cmd": [
+            "@php artisan vendor:publish --tag=laravel-assets --ansi --force"
+        ],
+        "post-root-package-install": [
+            "@php -r \"file_exists('.env') || copy('.env.example', '.env');\""
+        ],
+        "post-create-project-cmd": [
+            "@php artisan key:generate --ansi",
+            "@php -r \"file_exists('database/database.sqlite') || touch('database/database.sqlite');\"",
+            "@php artisan migrate --graceful --ansi"
+        ],
+        "pre-package-uninstall": [
+            "Illuminate\\Foundation\\ComposerScripts::prePackageUninstall"
+        ]
+    },
+    "extra": {
+        "laravel": {
+            "dont-discover": []
+        }
+    },
+    "config": {
+        "optimize-autoloader": true,
+        "preferred-install": "dist",
+        "sort-packages": true,
+        "allow-plugins": {
+            "pestphp/pest-plugin": true,
+            "php-http/discovery": true
+        },
+        "platform": {
+            "php": "8.3.0"
+        }
+    },
+    "minimum-stability": "stable",
+    "prefer-stable": true
+}

portail/config/app.php

@@ -0,0 +1,126 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Name
+    |--------------------------------------------------------------------------
+    |
+    | This value is the name of your application, which will be used when the
+    | framework needs to place the application's name in a notification or
+    | other UI elements where an application name needs to be displayed.
+    |
+    */
+
+    'name' => env('APP_NAME', 'Laravel'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Environment
+    |--------------------------------------------------------------------------
+    |
+    | This value determines the "environment" your application is currently
+    | running in. This may determine how you prefer to configure various
+    | services the application utilizes. Set this in your ".env" file.
+    |
+    */
+
+    'env' => env('APP_ENV', 'production'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Debug Mode
+    |--------------------------------------------------------------------------
+    |
+    | When your application is in debug mode, detailed error messages with
+    | stack traces will be shown on every error that occurs within your
+    | application. If disabled, a simple generic error page is shown.
+    |
+    */
+
+    'debug' => (bool) env('APP_DEBUG', false),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application URL
+    |--------------------------------------------------------------------------
+    |
+    | This URL is used by the console to properly generate URLs when using
+    | the Artisan command line tool. You should set this to the root of
+    | the application so that it's available within Artisan commands.
+    |
+    */
+
+    'url' => env('APP_URL', 'http://localhost'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Timezone
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify the default timezone for your application, which
+    | will be used by the PHP date and date-time functions. The timezone
+    | is set to "UTC" by default as it is suitable for most use cases.
+    |
+    */
+
+    'timezone' => 'UTC',
+
+    /*
+    |--------------------------------------------------------------------------
+    | Application Locale Configuration
+    |--------------------------------------------------------------------------
+    |
+    | The application locale determines the default locale that will be used
+    | by Laravel's translation / localization methods. This option can be
+    | set to any locale for which you plan to have translation strings.
+    |
+    */
+
+    'locale' => env('APP_LOCALE', 'en'),
+
+    'fallback_locale' => env('APP_FALLBACK_LOCALE', 'en'),
+
+    'faker_locale' => env('APP_FAKER_LOCALE', 'en_US'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Encryption Key
+    |--------------------------------------------------------------------------
+    |
+    | This key is utilized by Laravel's encryption services and should be set
+    | to a random, 32 character string to ensure that all encrypted values
+    | are secure. You should do this prior to deploying the application.
+    |
+    */
+
+    'cipher' => 'AES-256-CBC',
+
+    'key' => env('APP_KEY'),
+
+    'previous_keys' => [
+        ...array_filter(
+            explode(',', (string) env('APP_PREVIOUS_KEYS', ''))
+        ),
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Maintenance Mode Driver
+    |--------------------------------------------------------------------------
+    |
+    | These configuration options determine the driver used to determine and
+    | manage Laravel's "maintenance mode" status. The "cache" driver will
+    | allow maintenance mode to be controlled across multiple machines.
+    |
+    | Supported drivers: "file", "cache", "array"
+    |
+    */
+
+    'maintenance' => [
+        'driver' => env('APP_MAINTENANCE_DRIVER', 'file'),
+        'store' => env('APP_MAINTENANCE_STORE', 'database'),
+    ],
+
+];

portail/config/auth.php

@@ -0,0 +1,130 @@
+<?php
+
+use App\Models\Eleve;
+use App\Models\User;
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Authentication Defaults
+    |--------------------------------------------------------------------------
+    |
+    | This option defines the default authentication "guard" and password
+    | reset "broker" for your application. You may change these values
+    | as required, but they're a perfect start for most applications.
+    |
+    */
+
+    'defaults' => [
+        'guard' => env('AUTH_GUARD', 'web'),
+        'passwords' => env('AUTH_PASSWORD_BROKER', 'users'),
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Authentication Guards
+    |--------------------------------------------------------------------------
+    |
+    | Next, you may define every authentication guard for your application.
+    | Of course, a great default configuration has been defined for you
+    | which utilizes session storage plus the Eloquent user provider.
+    |
+    | All authentication guards have a user provider, which defines how the
+    | users are actually retrieved out of your database or other storage
+    | system used by the application. Typically, Eloquent is utilized.
+    |
+    | Supported: "session"
+    |
+    */
+
+    'guards' => [
+        'web' => [
+            'driver' => 'session',
+            'provider' => 'users',
+        ],
+
+        // Les élèves ne sont pas des "users" : identifiant + code secret,
+        // jamais d'e-mail (voir CLAUDE.md, minimisation des données mineurs).
+        'eleve' => [
+            'driver' => 'session',
+            'provider' => 'eleves',
+        ],
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | User Providers
+    |--------------------------------------------------------------------------
+    |
+    | All authentication guards have a user provider, which defines how the
+    | users are actually retrieved out of your database or other storage
+    | system used by the application. Typically, Eloquent is utilized.
+    |
+    | If you have multiple user tables or models you may configure multiple
+    | providers to represent the model / table. These providers may then
+    | be assigned to any extra authentication guards you have defined.
+    |
+    | Supported: "database", "eloquent"
+    |
+    */
+
+    'providers' => [
+        'users' => [
+            'driver' => 'eloquent',
+            'model' => env('AUTH_MODEL', User::class),
+        ],
+
+        // 'users' => [
+        //     'driver' => 'database',
+        //     'table' => 'users',
+        // ],
+
+        'eleves' => [
+            'driver' => 'eloquent',
+            'model' => Eleve::class,
+        ],
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Resetting Passwords
+    |--------------------------------------------------------------------------
+    |
+    | These configuration options specify the behavior of Laravel's password
+    | reset functionality, including the table utilized for token storage
+    | and the user provider that is invoked to actually retrieve users.
+    |
+    | The expiry time is the number of minutes that each reset token will be
+    | considered valid. This security feature keeps tokens short-lived so
+    | they have less time to be guessed. You may change this as needed.
+    |
+    | The throttle setting is the number of seconds a user must wait before
+    | generating more password reset tokens. This prevents the user from
+    | quickly generating a very large amount of password reset tokens.
+    |
+    */
+
+    'passwords' => [
+        'users' => [
+            'provider' => 'users',
+            'table' => env('AUTH_PASSWORD_RESET_TOKEN_TABLE', 'password_reset_tokens'),
+            'expire' => 60,
+            'throttle' => 60,
+        ],
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Password Confirmation Timeout
+    |--------------------------------------------------------------------------
+    |
+    | Here you may define the number of seconds before a password confirmation
+    | window expires and users are asked to re-enter their password via the
+    | confirmation screen. By default, the timeout lasts for three hours.
+    |
+    */
+
+    'password_timeout' => env('AUTH_PASSWORD_TIMEOUT', 10800),
+
+];

portail/config/cache.php

@@ -0,0 +1,136 @@
+<?php
+
+use Illuminate\Support\Str;
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Cache Store
+    |--------------------------------------------------------------------------
+    |
+    | This option controls the default cache store that will be used by the
+    | framework. This connection is utilized if another isn't explicitly
+    | specified when running a cache operation inside the application.
+    |
+    */
+
+    'default' => env('CACHE_STORE', 'database'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Cache Stores
+    |--------------------------------------------------------------------------
+    |
+    | Here you may define all of the cache "stores" for your application as
+    | well as their drivers. You may even define multiple stores for the
+    | same cache driver to group types of items stored in your caches.
+    |
+    | Supported drivers: "array", "database", "file", "memcached",
+    |                    "redis", "dynamodb", "storage", "octane",
+    |                    "session", "failover", "null"
+    |
+    */
+
+    'stores' => [
+
+        'array' => [
+            'driver' => 'array',
+            'serialize' => false,
+        ],
+
+        'database' => [
+            'driver' => 'database',
+            'connection' => env('DB_CACHE_CONNECTION'),
+            'table' => env('DB_CACHE_TABLE', 'cache'),
+            'lock_connection' => env('DB_CACHE_LOCK_CONNECTION'),
+            'lock_table' => env('DB_CACHE_LOCK_TABLE'),
+        ],
+
+        'file' => [
+            'driver' => 'file',
+            'path' => storage_path('framework/cache/data'),
+            'lock_path' => storage_path('framework/cache/locks'),
+        ],
+
+        'storage' => [
+            'driver' => 'storage',
+            'disk' => env('CACHE_STORAGE_DISK'),
+            'path' => env('CACHE_STORAGE_PATH', 'framework/cache/data'),
+        ],
+
+        'memcached' => [
+            'driver' => 'memcached',
+            'persistent_id' => env('MEMCACHED_PERSISTENT_ID'),
+            'sasl' => [
+                env('MEMCACHED_USERNAME'),
+                env('MEMCACHED_PASSWORD'),
+            ],
+            'options' => [
+                // Memcached::OPT_CONNECT_TIMEOUT => 2000,
+            ],
+            'servers' => [
+                [
+                    'host' => env('MEMCACHED_HOST', '127.0.0.1'),
+                    'port' => env('MEMCACHED_PORT', 11211),
+                    'weight' => 100,
+                ],
+            ],
+        ],
+
+        'redis' => [
+            'driver' => 'redis',
+            'connection' => env('REDIS_CACHE_CONNECTION', 'cache'),
+            'lock_connection' => env('REDIS_CACHE_LOCK_CONNECTION', 'default'),
+        ],
+
+        'dynamodb' => [
+            'driver' => 'dynamodb',
+            'key' => env('AWS_ACCESS_KEY_ID'),
+            'secret' => env('AWS_SECRET_ACCESS_KEY'),
+            'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
+            'table' => env('DYNAMODB_CACHE_TABLE', 'cache'),
+            'endpoint' => env('DYNAMODB_ENDPOINT'),
+        ],
+
+        'octane' => [
+            'driver' => 'octane',
+        ],
+
+        'failover' => [
+            'driver' => 'failover',
+            'stores' => [
+                'database',
+                'array',
+            ],
+        ],
+
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Cache Key Prefix
+    |--------------------------------------------------------------------------
+    |
+    | When utilizing the APC, database, memcached, Redis, and DynamoDB cache
+    | stores, there might be other applications using the same cache. For
+    | that reason, you may prefix every cache key to avoid collisions.
+    |
+    */
+
+    'prefix' => env('CACHE_PREFIX', Str::slug((string) env('APP_NAME', 'laravel')).'-cache-'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Serializable Classes
+    |--------------------------------------------------------------------------
+    |
+    | This value determines the classes that can be unserialized from cache
+    | storage. By default, no PHP classes will be unserialized from your
+    | cache to prevent gadget chain attacks if your APP_KEY is leaked.
+    |
+    */
+
+    'serializable_classes' => false,
+
+];

portail/config/database.php

@@ -0,0 +1,184 @@
+<?php
+
+use Illuminate\Support\Str;
+use Pdo\Mysql;
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Database Connection Name
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify which of the database connections below you wish
+    | to use as your default connection for database operations. This is
+    | the connection which will be utilized unless another connection
+    | is explicitly specified when you execute a query / statement.
+    |
+    */
+
+    'default' => env('DB_CONNECTION', 'sqlite'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Database Connections
+    |--------------------------------------------------------------------------
+    |
+    | Below are all of the database connections defined for your application.
+    | An example configuration is provided for each database system which
+    | is supported by Laravel. You're free to add / remove connections.
+    |
+    */
+
+    'connections' => [
+
+        'sqlite' => [
+            'driver' => 'sqlite',
+            'url' => env('DB_URL'),
+            'database' => env('DB_DATABASE', database_path('database.sqlite')),
+            'prefix' => '',
+            'foreign_key_constraints' => env('DB_FOREIGN_KEYS', true),
+            'busy_timeout' => null,
+            'journal_mode' => null,
+            'synchronous' => null,
+            'transaction_mode' => 'DEFERRED',
+        ],
+
+        'mysql' => [
+            'driver' => 'mysql',
+            'url' => env('DB_URL'),
+            'host' => env('DB_HOST', '127.0.0.1'),
+            'port' => env('DB_PORT', '3306'),
+            'database' => env('DB_DATABASE', 'laravel'),
+            'username' => env('DB_USERNAME', 'root'),
+            'password' => env('DB_PASSWORD', ''),
+            'unix_socket' => env('DB_SOCKET', ''),
+            'charset' => env('DB_CHARSET', 'utf8mb4'),
+            'collation' => env('DB_COLLATION', 'utf8mb4_unicode_ci'),
+            'prefix' => '',
+            'prefix_indexes' => true,
+            'strict' => true,
+            'engine' => null,
+            'options' => extension_loaded('pdo_mysql') ? array_filter([
+                Mysql::ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
+            ]) : [],
+        ],
+
+        'mariadb' => [
+            'driver' => 'mariadb',
+            'url' => env('DB_URL'),
+            'host' => env('DB_HOST', '127.0.0.1'),
+            'port' => env('DB_PORT', '3306'),
+            'database' => env('DB_DATABASE', 'laravel'),
+            'username' => env('DB_USERNAME', 'root'),
+            'password' => env('DB_PASSWORD', ''),
+            'unix_socket' => env('DB_SOCKET', ''),
+            'charset' => env('DB_CHARSET', 'utf8mb4'),
+            'collation' => env('DB_COLLATION', 'utf8mb4_unicode_ci'),
+            'prefix' => '',
+            'prefix_indexes' => true,
+            'strict' => true,
+            'engine' => null,
+            'options' => extension_loaded('pdo_mysql') ? array_filter([
+                Mysql::ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
+            ]) : [],
+        ],
+
+        'pgsql' => [
+            'driver' => 'pgsql',
+            'url' => env('DB_URL'),
+            'host' => env('DB_HOST', '127.0.0.1'),
+            'port' => env('DB_PORT', '5432'),
+            'database' => env('DB_DATABASE', 'laravel'),
+            'username' => env('DB_USERNAME', 'root'),
+            'password' => env('DB_PASSWORD', ''),
+            'charset' => env('DB_CHARSET', 'utf8'),
+            'prefix' => '',
+            'prefix_indexes' => true,
+            'search_path' => 'public',
+            'sslmode' => env('DB_SSLMODE', 'prefer'),
+        ],
+
+        'sqlsrv' => [
+            'driver' => 'sqlsrv',
+            'url' => env('DB_URL'),
+            'host' => env('DB_HOST', 'localhost'),
+            'port' => env('DB_PORT', '1433'),
+            'database' => env('DB_DATABASE', 'laravel'),
+            'username' => env('DB_USERNAME', 'root'),
+            'password' => env('DB_PASSWORD', ''),
+            'charset' => env('DB_CHARSET', 'utf8'),
+            'prefix' => '',
+            'prefix_indexes' => true,
+            // 'encrypt' => env('DB_ENCRYPT', 'yes'),
+            // 'trust_server_certificate' => env('DB_TRUST_SERVER_CERTIFICATE', 'false'),
+        ],
+
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Migration Repository Table
+    |--------------------------------------------------------------------------
+    |
+    | This table keeps track of all the migrations that have already run for
+    | your application. Using this information, we can determine which of
+    | the migrations on disk haven't actually been run on the database.
+    |
+    */
+
+    'migrations' => [
+        'table' => 'migrations',
+        'update_date_on_publish' => true,
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Redis Databases
+    |--------------------------------------------------------------------------
+    |
+    | Redis is an open source, fast, and advanced key-value store that also
+    | provides a richer body of commands than a typical key-value system
+    | such as Memcached. You may define your connection settings here.
+    |
+    */
+
+    'redis' => [
+
+        'client' => env('REDIS_CLIENT', 'phpredis'),
+
+        'options' => [
+            'cluster' => env('REDIS_CLUSTER', 'redis'),
+            'prefix' => env('REDIS_PREFIX', Str::slug((string) env('APP_NAME', 'laravel')).'-database-'),
+            'persistent' => env('REDIS_PERSISTENT', false),
+        ],
+
+        'default' => [
+            'url' => env('REDIS_URL'),
+            'host' => env('REDIS_HOST', '127.0.0.1'),
+            'username' => env('REDIS_USERNAME'),
+            'password' => env('REDIS_PASSWORD'),
+            'port' => env('REDIS_PORT', '6379'),
+            'database' => env('REDIS_DB', '0'),
+            'max_retries' => env('REDIS_MAX_RETRIES', 3),
+            'backoff_algorithm' => env('REDIS_BACKOFF_ALGORITHM', 'decorrelated_jitter'),
+            'backoff_base' => env('REDIS_BACKOFF_BASE', 100),
+            'backoff_cap' => env('REDIS_BACKOFF_CAP', 1000),
+        ],
+
+        'cache' => [
+            'url' => env('REDIS_URL'),
+            'host' => env('REDIS_HOST', '127.0.0.1'),
+            'username' => env('REDIS_USERNAME'),
+            'password' => env('REDIS_PASSWORD'),
+            'port' => env('REDIS_PORT', '6379'),
+            'database' => env('REDIS_CACHE_DB', '1'),
+            'max_retries' => env('REDIS_MAX_RETRIES', 3),
+            'backoff_algorithm' => env('REDIS_BACKOFF_ALGORITHM', 'decorrelated_jitter'),
+            'backoff_base' => env('REDIS_BACKOFF_BASE', 100),
+            'backoff_cap' => env('REDIS_BACKOFF_CAP', 1000),
+        ],
+
+    ],
+
+];

portail/config/filesystems.php

@@ -0,0 +1,80 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Filesystem Disk
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify the default filesystem disk that should be used
+    | by the framework. The "local" disk, as well as a variety of cloud
+    | based disks are available to your application for file storage.
+    |
+    */
+
+    'default' => env('FILESYSTEM_DISK', 'local'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Filesystem Disks
+    |--------------------------------------------------------------------------
+    |
+    | Below you may configure as many filesystem disks as necessary, and you
+    | may even configure multiple disks for the same driver. Examples for
+    | most supported storage drivers are configured here for reference.
+    |
+    | Supported drivers: "local", "ftp", "sftp", "s3"
+    |
+    */
+
+    'disks' => [
+
+        'local' => [
+            'driver' => 'local',
+            'root' => storage_path('app/private'),
+            'serve' => true,
+            'throw' => false,
+            'report' => false,
+        ],
+
+        'public' => [
+            'driver' => 'local',
+            'root' => storage_path('app/public'),
+            'url' => rtrim(env('APP_URL', 'http://localhost'), '/').'/storage',
+            'visibility' => 'public',
+            'throw' => false,
+            'report' => false,
+        ],
+
+        's3' => [
+            'driver' => 's3',
+            'key' => env('AWS_ACCESS_KEY_ID'),
+            'secret' => env('AWS_SECRET_ACCESS_KEY'),
+            'region' => env('AWS_DEFAULT_REGION'),
+            'bucket' => env('AWS_BUCKET'),
+            'url' => env('AWS_URL'),
+            'endpoint' => env('AWS_ENDPOINT'),
+            'use_path_style_endpoint' => env('AWS_USE_PATH_STYLE_ENDPOINT', false),
+            'throw' => false,
+            'report' => false,
+        ],
+
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Symbolic Links
+    |--------------------------------------------------------------------------
+    |
+    | Here you may configure the symbolic links that will be created when the
+    | `storage:link` Artisan command is executed. The array keys should be
+    | the locations of the links and the values should be their targets.
+    |
+    */
+
+    'links' => [
+        public_path('storage') => storage_path('app/public'),
+    ],
+
+];

portail/config/logging.php

@@ -0,0 +1,140 @@
+<?php
+
+use Monolog\Handler\NullHandler;
+use Monolog\Handler\StreamHandler;
+use Monolog\Handler\SyslogUdpHandler;
+use Monolog\Processor\PsrLogMessageProcessor;
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Log Channel
+    |--------------------------------------------------------------------------
+    |
+    | This option defines the default log channel that is utilized to write
+    | messages to your logs. The value provided here should match one of
+    | the channels present in the list of "channels" configured below.
+    |
+    */
+
+    'default' => env('LOG_CHANNEL', 'stack'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Deprecations Log Channel
+    |--------------------------------------------------------------------------
+    |
+    | This option controls the log channel that should be used to log warnings
+    | regarding deprecated PHP and library features. This allows you to get
+    | your application ready for upcoming major versions of dependencies.
+    |
+    */
+
+    'deprecations' => [
+        'channel' => env('LOG_DEPRECATIONS_CHANNEL', 'null'),
+        'trace' => env('LOG_DEPRECATIONS_TRACE', false),
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Log Channels
+    |--------------------------------------------------------------------------
+    |
+    | Here you may configure the log channels for your application. Laravel
+    | utilizes the Monolog PHP logging library, which includes a variety
+    | of powerful log handlers and formatters that you're free to use.
+    |
+    | Available drivers: "single", "daily", "monthly", "slack", "syslog",
+    |                    "errorlog", "monolog", "custom", "stack"
+    |
+    */
+
+    'channels' => [
+
+        'stack' => [
+            'driver' => 'stack',
+            'channels' => explode(',', (string) env('LOG_STACK', 'single')),
+            'ignore_exceptions' => false,
+        ],
+
+        'single' => [
+            'driver' => 'single',
+            'path' => storage_path('logs/laravel.log'),
+            'level' => env('LOG_LEVEL', 'debug'),
+            'replace_placeholders' => true,
+        ],
+
+        'daily' => [
+            'driver' => 'daily',
+            'path' => storage_path('logs/laravel.log'),
+            'level' => env('LOG_LEVEL', 'debug'),
+            'max_files' => env('LOG_DAILY_DAYS', 14),
+            'replace_placeholders' => true,
+        ],
+
+        'monthly' => [
+            'driver' => 'monthly',
+            'path' => storage_path('logs/laravel.log'),
+            'level' => env('LOG_LEVEL', 'debug'),
+            'max_files' => 3,
+            'replace_placeholders' => true,
+        ],
+
+        'slack' => [
+            'driver' => 'slack',
+            'url' => env('LOG_SLACK_WEBHOOK_URL'),
+            'username' => env('LOG_SLACK_USERNAME', env('APP_NAME', 'Laravel')),
+            'emoji' => env('LOG_SLACK_EMOJI', ':boom:'),
+            'level' => env('LOG_LEVEL', 'critical'),
+            'replace_placeholders' => true,
+        ],
+
+        'papertrail' => [
+            'driver' => 'monolog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'handler' => env('LOG_PAPERTRAIL_HANDLER', SyslogUdpHandler::class),
+            'handler_with' => [
+                'host' => env('PAPERTRAIL_URL'),
+                'port' => env('PAPERTRAIL_PORT'),
+                'connectionString' => 'tls://'.env('PAPERTRAIL_URL').':'.env('PAPERTRAIL_PORT'),
+            ],
+            'processors' => [PsrLogMessageProcessor::class],
+        ],
+
+        'stderr' => [
+            'driver' => 'monolog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'handler' => StreamHandler::class,
+            'handler_with' => [
+                'stream' => 'php://stderr',
+            ],
+            'formatter' => env('LOG_STDERR_FORMATTER'),
+            'processors' => [PsrLogMessageProcessor::class],
+        ],
+
+        'syslog' => [
+            'driver' => 'syslog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'facility' => env('LOG_SYSLOG_FACILITY', LOG_USER),
+            'replace_placeholders' => true,
+        ],
+
+        'errorlog' => [
+            'driver' => 'errorlog',
+            'level' => env('LOG_LEVEL', 'debug'),
+            'replace_placeholders' => true,
+        ],
+
+        'null' => [
+            'driver' => 'monolog',
+            'handler' => NullHandler::class,
+        ],
+
+        'emergency' => [
+            'path' => storage_path('logs/laravel.log'),
+        ],
+
+    ],
+
+];

portail/config/mail.php

@@ -0,0 +1,118 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Mailer
+    |--------------------------------------------------------------------------
+    |
+    | This option controls the default mailer that is used to send all email
+    | messages unless another mailer is explicitly specified when sending
+    | the message. All additional mailers can be configured within the
+    | "mailers" array. Examples of each type of mailer are provided.
+    |
+    */
+
+    'default' => env('MAIL_MAILER', 'log'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Mailer Configurations
+    |--------------------------------------------------------------------------
+    |
+    | Here you may configure all of the mailers used by your application plus
+    | their respective settings. Several examples have been configured for
+    | you and you are free to add your own as your application requires.
+    |
+    | Laravel supports a variety of mail "transport" drivers that can be used
+    | when delivering an email. You may specify which one you're using for
+    | your mailers below. You may also add additional mailers if needed.
+    |
+    | Supported: "smtp", "sendmail", "mailgun", "ses", "ses-v2",
+    |            "postmark", "resend", "log", "array",
+    |            "failover", "roundrobin"
+    |
+    */
+
+    'mailers' => [
+
+        'smtp' => [
+            'transport' => 'smtp',
+            'scheme' => env('MAIL_SCHEME'),
+            'url' => env('MAIL_URL'),
+            'host' => env('MAIL_HOST', '127.0.0.1'),
+            'port' => env('MAIL_PORT', 2525),
+            'username' => env('MAIL_USERNAME'),
+            'password' => env('MAIL_PASSWORD'),
+            'timeout' => null,
+            'local_domain' => env('MAIL_EHLO_DOMAIN', parse_url((string) env('APP_URL', 'http://localhost'), PHP_URL_HOST)),
+        ],
+
+        'ses' => [
+            'transport' => 'ses',
+        ],
+
+        'postmark' => [
+            'transport' => 'postmark',
+            // 'message_stream_id' => env('POSTMARK_MESSAGE_STREAM_ID'),
+            // 'client' => [
+            //     'timeout' => 5,
+            // ],
+        ],
+
+        'resend' => [
+            'transport' => 'resend',
+        ],
+
+        'sendmail' => [
+            'transport' => 'sendmail',
+            'path' => env('MAIL_SENDMAIL_PATH', '/usr/sbin/sendmail -bs -i'),
+        ],
+
+        'log' => [
+            'transport' => 'log',
+            'channel' => env('MAIL_LOG_CHANNEL'),
+        ],
+
+        'array' => [
+            'transport' => 'array',
+        ],
+
+        'failover' => [
+            'transport' => 'failover',
+            'mailers' => [
+                'smtp',
+                'log',
+            ],
+            'retry_after' => 60,
+        ],
+
+        'roundrobin' => [
+            'transport' => 'roundrobin',
+            'mailers' => [
+                'ses',
+                'postmark',
+            ],
+            'retry_after' => 60,
+        ],
+
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Global "From" Address
+    |--------------------------------------------------------------------------
+    |
+    | You may wish for all emails sent by your application to be sent from
+    | the same address. Here you may specify a name and address that is
+    | used globally for all emails that are sent by your application.
+    |
+    */
+
+    'from' => [
+        'address' => env('MAIL_FROM_ADDRESS', 'hello@example.com'),
+        'name' => env('MAIL_FROM_NAME', env('APP_NAME', 'Laravel')),
+    ],
+
+];

portail/config/queue.php

@@ -0,0 +1,129 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Queue Connection Name
+    |--------------------------------------------------------------------------
+    |
+    | Laravel's queue supports a variety of backends via a single, unified
+    | API, giving you convenient access to each backend using identical
+    | syntax for each. The default queue connection is defined below.
+    |
+    */
+
+    'default' => env('QUEUE_CONNECTION', 'database'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Queue Connections
+    |--------------------------------------------------------------------------
+    |
+    | Here you may configure the connection options for every queue backend
+    | used by your application. An example configuration is provided for
+    | each backend supported by Laravel. You're also free to add more.
+    |
+    | Drivers: "sync", "database", "beanstalkd", "sqs", "redis",
+    |          "deferred", "background", "failover", "null"
+    |
+    */
+
+    'connections' => [
+
+        'sync' => [
+            'driver' => 'sync',
+        ],
+
+        'database' => [
+            'driver' => 'database',
+            'connection' => env('DB_QUEUE_CONNECTION'),
+            'table' => env('DB_QUEUE_TABLE', 'jobs'),
+            'queue' => env('DB_QUEUE', 'default'),
+            'retry_after' => (int) env('DB_QUEUE_RETRY_AFTER', 90),
+            'after_commit' => false,
+        ],
+
+        'beanstalkd' => [
+            'driver' => 'beanstalkd',
+            'host' => env('BEANSTALKD_QUEUE_HOST', 'localhost'),
+            'queue' => env('BEANSTALKD_QUEUE', 'default'),
+            'retry_after' => (int) env('BEANSTALKD_QUEUE_RETRY_AFTER', 90),
+            'block_for' => 0,
+            'after_commit' => false,
+        ],
+
+        'sqs' => [
+            'driver' => 'sqs',
+            'key' => env('AWS_ACCESS_KEY_ID'),
+            'secret' => env('AWS_SECRET_ACCESS_KEY'),
+            'prefix' => env('SQS_PREFIX', 'https://sqs.us-east-1.amazonaws.com/your-account-id'),
+            'queue' => env('SQS_QUEUE', 'default'),
+            'suffix' => env('SQS_SUFFIX'),
+            'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
+            'after_commit' => false,
+        ],
+
+        'redis' => [
+            'driver' => 'redis',
+            'connection' => env('REDIS_QUEUE_CONNECTION', 'default'),
+            'queue' => env('REDIS_QUEUE', 'default'),
+            'retry_after' => (int) env('REDIS_QUEUE_RETRY_AFTER', 90),
+            'block_for' => null,
+            'after_commit' => false,
+        ],
+
+        'deferred' => [
+            'driver' => 'deferred',
+        ],
+
+        'background' => [
+            'driver' => 'background',
+        ],
+
+        'failover' => [
+            'driver' => 'failover',
+            'connections' => [
+                'database',
+                'deferred',
+            ],
+        ],
+
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Job Batching
+    |--------------------------------------------------------------------------
+    |
+    | The following options configure the database and table that store job
+    | batching information. These options can be updated to any database
+    | connection and table which has been defined by your application.
+    |
+    */
+
+    'batching' => [
+        'database' => env('DB_CONNECTION', 'sqlite'),
+        'table' => 'job_batches',
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Failed Queue Jobs
+    |--------------------------------------------------------------------------
+    |
+    | These options configure the behavior of failed queue job logging so you
+    | can control how and where failed jobs are stored. Laravel ships with
+    | support for storing failed jobs in a simple file or in a database.
+    |
+    | Supported drivers: "database-uuids", "dynamodb", "file", "null"
+    |
+    */
+
+    'failed' => [
+        'driver' => env('QUEUE_FAILED_DRIVER', 'database-uuids'),
+        'database' => env('DB_CONNECTION', 'sqlite'),
+        'table' => 'failed_jobs',
+    ],
+
+];

portail/config/services.php

@@ -0,0 +1,38 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Third Party Services
+    |--------------------------------------------------------------------------
+    |
+    | This file is for storing the credentials for third party services such
+    | as Resend, Postmark, AWS, and more. This file provides the de facto
+    | location for this type of information, allowing packages to have
+    | a conventional file to locate the various service credentials.
+    |
+    */
+
+    'postmark' => [
+        'key' => env('POSTMARK_API_KEY'),
+    ],
+
+    'resend' => [
+        'key' => env('RESEND_API_KEY'),
+    ],
+
+    'ses' => [
+        'key' => env('AWS_ACCESS_KEY_ID'),
+        'secret' => env('AWS_SECRET_ACCESS_KEY'),
+        'region' => env('AWS_DEFAULT_REGION', 'us-east-1'),
+    ],
+
+    'slack' => [
+        'notifications' => [
+            'bot_user_oauth_token' => env('SLACK_BOT_USER_OAUTH_TOKEN'),
+            'channel' => env('SLACK_BOT_USER_DEFAULT_CHANNEL'),
+        ],
+    ],
+
+];

portail/config/session.php

@@ -0,0 +1,233 @@
+<?php
+
+use Illuminate\Support\Str;
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Session Driver
+    |--------------------------------------------------------------------------
+    |
+    | This option determines the default session driver that is utilized for
+    | incoming requests. Laravel supports a variety of storage options to
+    | persist session data. Database storage is a great default choice.
+    |
+    | Supported: "file", "cookie", "database", "memcached",
+    |            "redis", "dynamodb", "array"
+    |
+    */
+
+    'driver' => env('SESSION_DRIVER', 'database'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Lifetime
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify the number of minutes that you wish the session
+    | to be allowed to remain idle before it expires. If you want them
+    | to expire immediately when the browser is closed then you may
+    | indicate that via the expire_on_close configuration option.
+    |
+    */
+
+    'lifetime' => (int) env('SESSION_LIFETIME', 120),
+
+    'expire_on_close' => env('SESSION_EXPIRE_ON_CLOSE', false),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Encryption
+    |--------------------------------------------------------------------------
+    |
+    | This option allows you to easily specify that all of your session data
+    | should be encrypted before it's stored. All encryption is performed
+    | automatically by Laravel and you may use the session like normal.
+    |
+    */
+
+    'encrypt' => env('SESSION_ENCRYPT', false),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session File Location
+    |--------------------------------------------------------------------------
+    |
+    | When utilizing the "file" session driver, the session files are placed
+    | on disk. The default storage location is defined here; however, you
+    | are free to provide another location where they should be stored.
+    |
+    */
+
+    'files' => storage_path('framework/sessions'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Database Connection
+    |--------------------------------------------------------------------------
+    |
+    | When using the "database" or "redis" session drivers, you may specify a
+    | connection that should be used to manage these sessions. This should
+    | correspond to a connection in your database configuration options.
+    |
+    */
+
+    'connection' => env('SESSION_CONNECTION'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Database Table
+    |--------------------------------------------------------------------------
+    |
+    | When using the "database" session driver, you may specify the table to
+    | be used to store sessions. Of course, a sensible default is defined
+    | for you; however, you're welcome to change this to another table.
+    |
+    */
+
+    'table' => env('SESSION_TABLE', 'sessions'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Cache Store
+    |--------------------------------------------------------------------------
+    |
+    | When using one of the framework's cache driven session backends, you may
+    | define the cache store which should be used to store the session data
+    | between requests. This must match one of your defined cache stores.
+    |
+    | Affects: "dynamodb", "memcached", "redis"
+    |
+    */
+
+    'store' => env('SESSION_STORE'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Sweeping Lottery
+    |--------------------------------------------------------------------------
+    |
+    | Some session drivers must manually sweep their storage location to get
+    | rid of old sessions from storage. Here are the chances that it will
+    | happen on a given request. By default, the odds are 2 out of 100.
+    |
+    */
+
+    'lottery' => [2, 100],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Cookie Name
+    |--------------------------------------------------------------------------
+    |
+    | Here you may change the name of the session cookie that is created by
+    | the framework. Typically, you should not need to change this value
+    | since doing so does not grant a meaningful security improvement.
+    |
+    */
+
+    'cookie' => env(
+        'SESSION_COOKIE',
+        Str::slug((string) env('APP_NAME', 'laravel')).'-session'
+    ),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Cookie Path
+    |--------------------------------------------------------------------------
+    |
+    | The session cookie path determines the path for which the cookie will
+    | be regarded as available. Typically, this will be the root path of
+    | your application, but you're free to change this when necessary.
+    |
+    */
+
+    'path' => env('SESSION_PATH', '/'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Cookie Domain
+    |--------------------------------------------------------------------------
+    |
+    | This value determines the domain and subdomains the session cookie is
+    | available to. By default, the cookie will be available to the root
+    | domain without subdomains. Typically, this shouldn't be changed.
+    |
+    */
+
+    'domain' => env('SESSION_DOMAIN'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | HTTPS Only Cookies
+    |--------------------------------------------------------------------------
+    |
+    | By setting this option to true, session cookies will only be sent back
+    | to the server if the browser has a HTTPS connection. This will keep
+    | the cookie from being sent to you when it can't be done securely.
+    |
+    */
+
+    'secure' => env('SESSION_SECURE_COOKIE'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | HTTP Access Only
+    |--------------------------------------------------------------------------
+    |
+    | Setting this value to true will prevent JavaScript from accessing the
+    | value of the cookie and the cookie will only be accessible through
+    | the HTTP protocol. It's unlikely you should disable this option.
+    |
+    */
+
+    'http_only' => env('SESSION_HTTP_ONLY', true),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Same-Site Cookies
+    |--------------------------------------------------------------------------
+    |
+    | This option determines how your cookies behave when cross-site requests
+    | take place, and can be used to mitigate CSRF attacks. By default, we
+    | will set this value to "lax" to permit secure cross-site requests.
+    |
+    | See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#samesitesamesite-value
+    |
+    | Supported: "lax", "strict", "none", null
+    |
+    */
+
+    'same_site' => env('SESSION_SAME_SITE', 'lax'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Partitioned Cookies
+    |--------------------------------------------------------------------------
+    |
+    | Setting this value to true will tie the cookie to the top-level site for
+    | a cross-site context. Partitioned cookies are accepted by the browser
+    | when flagged "secure" and the Same-Site attribute is set to "none".
+    |
+    */
+
+    'partitioned' => env('SESSION_PARTITIONED_COOKIE', false),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Session Serialization
+    |--------------------------------------------------------------------------
+    |
+    | This value controls the serialization strategy for session data, which
+    | is JSON by default. Setting this to "php" allows the storage of PHP
+    | objects in the session but can make an application vulnerable to
+    | "gadget chain" serialization attacks if the APP_KEY is leaked.
+    |
+    | Supported: "json", "php"
+    |
+    */
+
+    'serialization' => 'json',
+
+];

portail/database/.gitignore

@@ -0,0 +1 @@
+*.sqlite*

portail/database/factories/ClasseFactory.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\Etablissement;
+use App\Models\User;
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+class ClasseFactory extends Factory
+{
+    public function definition(): array
+    {
+        return [
+            'etablissement_id' => Etablissement::factory(),
+            'user_id' => User::factory(),
+            'nom' => 'BTS SIO 1 · Groupe '.fake()->randomLetter(),
+            'formation' => 'BTS SIO SISR',
+        ];
+    }
+}

portail/database/factories/EleveFactory.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\Classe;
+use Illuminate\Database\Eloquent\Factories\Factory;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Str;
+
+class EleveFactory extends Factory
+{
+    public function definition(): array
+    {
+        $prenom = fake()->firstName();
+
+        return [
+            'classe_id' => Classe::factory(),
+            'prenom' => $prenom,
+            'nom' => fake()->lastName(),
+            'identifiant' => Str::slug($prenom, '').'.'.Str::random(4),
+            'code_secret' => Hash::make('123456'),
+            'jeton_qr' => Str::random(32),
+        ];
+    }
+}

portail/database/factories/EtablissementFactory.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Database\Factories;
+
+use Illuminate\Database\Eloquent\Factories\Factory;
+
+class EtablissementFactory extends Factory
+{
+    public function definition(): array
+    {
+        return [
+            'nom' => 'Lycée '.fake()->lastName(),
+            'ville' => fake()->city(),
+            'uai' => fake()->bothify('0###??#'),
+        ];
+    }
+}

portail/database/factories/LabFactory.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Database\Factories;
+
+use Illuminate\Database\Eloquent\Factories\Factory;
+use Illuminate\Support\Str;
+
+class LabFactory extends Factory
+{
+    public function definition(): array
+    {
+        $titre = fake()->unique()->sentence(3);
+
+        return [
+            'identifiant' => Str::slug($titre),
+            'titre' => $titre,
+            'niveau' => 'decouverte',
+            'duree_min' => 45,
+        ];
+    }
+}

portail/database/factories/UserFactory.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Database\Factories;
+
+use App\Models\Etablissement;
+use App\Models\User;
+use Illuminate\Database\Eloquent\Factories\Factory;
+use Illuminate\Support\Facades\Hash;
+use Illuminate\Support\Str;
+
+/**
+ * @extends Factory<User>
+ */
+class UserFactory extends Factory
+{
+    /**
+     * The current password being used by the factory.
+     */
+    protected static ?string $password;
+
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+            'name' => fake()->name(),
+            'email' => fake()->unique()->safeEmail(),
+            'email_verified_at' => now(),
+            'password' => static::$password ??= Hash::make('password'),
+            'remember_token' => Str::random(10),
+            'etablissement_id' => Etablissement::factory(),
+        ];
+    }
+
+    /**
+     * Indicate that the model's email address should be unverified.
+     */
+    public function unverified(): static
+    {
+        return $this->state(fn (array $attributes) => [
+            'email_verified_at' => null,
+        ]);
+    }
+}

portail/database/migrations/0001_01_01_000000_create_users_table.php

@@ -0,0 +1,49 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('users', function (Blueprint $table) {
+            $table->id();
+            $table->string('name');
+            $table->string('email')->unique();
+            $table->timestamp('email_verified_at')->nullable();
+            $table->string('password');
+            $table->rememberToken();
+            $table->timestamps();
+        });
+
+        Schema::create('password_reset_tokens', function (Blueprint $table) {
+            $table->string('email')->primary();
+            $table->string('token');
+            $table->timestamp('created_at')->nullable();
+        });
+
+        Schema::create('sessions', function (Blueprint $table) {
+            $table->string('id')->primary();
+            $table->foreignId('user_id')->nullable()->index();
+            $table->string('ip_address', 45)->nullable();
+            $table->text('user_agent')->nullable();
+            $table->longText('payload');
+            $table->integer('last_activity')->index();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('users');
+        Schema::dropIfExists('password_reset_tokens');
+        Schema::dropIfExists('sessions');
+    }
+};

portail/database/migrations/0001_01_01_000001_create_cache_table.php

@@ -0,0 +1,35 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('cache', function (Blueprint $table) {
+            $table->string('key')->primary();
+            $table->mediumText('value');
+            $table->bigInteger('expiration')->index();
+        });
+
+        Schema::create('cache_locks', function (Blueprint $table) {
+            $table->string('key')->primary();
+            $table->string('owner');
+            $table->bigInteger('expiration')->index();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('cache');
+        Schema::dropIfExists('cache_locks');
+    }
+};

portail/database/migrations/0001_01_01_000002_create_jobs_table.php

@@ -0,0 +1,59 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('jobs', function (Blueprint $table) {
+            $table->id();
+            $table->string('queue')->index();
+            $table->longText('payload');
+            $table->unsignedSmallInteger('attempts');
+            $table->unsignedInteger('reserved_at')->nullable();
+            $table->unsignedInteger('available_at');
+            $table->unsignedInteger('created_at');
+        });
+
+        Schema::create('job_batches', function (Blueprint $table) {
+            $table->string('id')->primary();
+            $table->string('name');
+            $table->integer('total_jobs');
+            $table->integer('pending_jobs');
+            $table->integer('failed_jobs');
+            $table->longText('failed_job_ids');
+            $table->mediumText('options')->nullable();
+            $table->integer('cancelled_at')->nullable();
+            $table->integer('created_at');
+            $table->integer('finished_at')->nullable();
+        });
+
+        Schema::create('failed_jobs', function (Blueprint $table) {
+            $table->id();
+            $table->string('uuid')->unique();
+            $table->string('connection');
+            $table->string('queue');
+            $table->longText('payload');
+            $table->longText('exception');
+            $table->timestamp('failed_at')->useCurrent();
+
+            $table->index(['connection', 'queue', 'failed_at']);
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('jobs');
+        Schema::dropIfExists('job_batches');
+        Schema::dropIfExists('failed_jobs');
+    }
+};

portail/database/migrations/2026_10_07_195113_create_etablissements_table.php

@@ -0,0 +1,24 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('etablissements', function (Blueprint $table) {
+            $table->id();
+            $table->string('nom');
+            $table->string('ville')->nullable();
+            $table->string('uai')->nullable();
+            $table->timestamps();
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('etablissements');
+    }
+};

portail/database/migrations/2026_10_07_195114_create_classes_table.php

@@ -0,0 +1,27 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('classes', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('etablissement_id')->constrained();
+            $table->foreignId('user_id')->constrained()->comment('le prof qui a créé la classe');
+            $table->string('nom');
+            $table->string('formation')->nullable();
+            $table->string('code_classe', 8)->unique()->comment('code que les élèves peuvent utiliser pour rejoindre (V2)');
+            $table->timestamp('archivee_a')->nullable();
+            $table->timestamps();
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('classes');
+    }
+};

portail/database/migrations/2026_10_07_195115_create_eleves_table.php

@@ -0,0 +1,29 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('eleves', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('classe_id')->constrained()->cascadeOnDelete();
+            $table->string('prenom');
+            $table->string('nom')->nullable()->comment('facultatif, visible uniquement du prof');
+            $table->string('identifiant')->unique()->comment('format prenom.initiale, suffixe numérique si homonyme');
+            $table->string('code_secret')->comment('haché, 6 caractères en clair à la génération');
+            $table->string('jeton_qr')->nullable()->unique()->comment('QR à usage unique de la fiche de connexion, vidé après le premier usage');
+            $table->string('jeton_session_actif')->nullable();
+            $table->timestamp('derniere_connexion_a')->nullable();
+            $table->timestamps();
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('eleves');
+    }
+};

portail/database/migrations/2026_10_07_195116_create_labs_table.php

@@ -0,0 +1,25 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('labs', function (Blueprint $table) {
+            $table->id();
+            $table->string('identifiant')->unique()->comment('ex: 08-deux-lan-routeur, nom du dossier paillasse-contenus');
+            $table->string('titre');
+            $table->string('niveau')->nullable();
+            $table->unsignedSmallInteger('duree_min')->nullable();
+            $table->timestamps();
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('labs');
+    }
+};

portail/database/migrations/2026_10_07_195117_create_seances_table.php

@@ -0,0 +1,26 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('seances', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('classe_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('lab_id')->constrained();
+            $table->string('statut')->default('planifiee')->comment('planifiee, salle_attente, en_cours, terminee');
+            $table->timestamp('demarree_a')->nullable();
+            $table->timestamp('terminee_a')->nullable();
+            $table->timestamps();
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('seances');
+    }
+};

portail/database/migrations/2026_10_07_195118_create_lab_sessions_table.php

@@ -0,0 +1,27 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('lab_sessions', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('seance_id')->nullable()->constrained()->cascadeOnDelete();
+            $table->foreignId('eleve_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('lab_id')->constrained();
+            $table->string('stack_id')->nullable()->comment('id de la stack Heat / des VM, rempli à l’étape 10');
+            $table->string('etat')->default('en_attente')->comment('en_attente, admis, actif, termine, expire');
+            $table->timestamp('expire_a')->nullable();
+            $table->timestamps();
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('lab_sessions');
+    }
+};

portail/database/migrations/2026_10_07_195119_add_etablissement_and_session_fields_to_users_table.php

@@ -0,0 +1,24 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('users', function (Blueprint $table) {
+            $table->foreignId('etablissement_id')->nullable()->after('id')->constrained();
+            $table->string('jeton_session_actif')->nullable()->after('remember_token');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('users', function (Blueprint $table) {
+            $table->dropConstrainedForeignId('etablissement_id');
+            $table->dropColumn('jeton_session_actif');
+        });
+    }
+};

portail/database/seeders/DatabaseSeeder.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Database\Seeders;
+
+use App\Models\User;
+use Illuminate\Database\Console\Seeds\WithoutModelEvents;
+use Illuminate\Database\Seeder;
+
+class DatabaseSeeder extends Seeder
+{
+    use WithoutModelEvents;
+
+    /**
+     * Seed the application's database.
+     */
+    public function run(): void
+    {
+        // User::factory(10)->create();
+
+        User::factory()->create([
+            'name' => 'Test User',
+            'email' => 'test@example.com',
+        ]);
+    }
+}

portail/package.json

@@ -0,0 +1,18 @@
+{
+    "$schema": "https://www.schemastore.org/package.json",
+    "private": true,
+    "type": "module",
+    "scripts": {
+        "build": "vite build",
+        "dev": "vite"
+    },
+    "devDependencies": {
+        "@tailwindcss/vite": "^4.0.0",
+        "laravel-vite-plugin": "^3.1",
+        "tailwindcss": "^4.0.0",
+        "vite": "^8.0.0"
+    },
+    "optionalDependencies": {
+        "@laravel/multiplex": "^0.4.1"
+    }
+}

portail/phpunit.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+>
+    <testsuites>
+        <testsuite name="Unit">
+            <directory>tests/Unit</directory>
+        </testsuite>
+        <testsuite name="Feature">
+            <directory>tests/Feature</directory>
+        </testsuite>
+    </testsuites>
+    <source>
+        <include>
+            <directory>app</directory>
+        </include>
+    </source>
+    <php>
+        <env name="APP_ENV" value="testing"/>
+        <env name="APP_MAINTENANCE_DRIVER" value="file"/>
+        <env name="BCRYPT_ROUNDS" value="4"/>
+        <env name="BROADCAST_CONNECTION" value="null"/>
+        <env name="CACHE_STORE" value="array"/>
+        <env name="DB_CONNECTION" value="sqlite"/>
+        <env name="DB_DATABASE" value=":memory:"/>
+        <env name="DB_URL" value=""/>
+        <env name="MAIL_MAILER" value="array"/>
+        <env name="QUEUE_CONNECTION" value="sync"/>
+        <env name="SESSION_DRIVER" value="array"/>
+        <env name="PULSE_ENABLED" value="false"/>
+        <env name="TELESCOPE_ENABLED" value="false"/>
+        <env name="NIGHTWATCH_ENABLED" value="false"/>
+    </php>
+</phpunit>

portail/public/.htaccess

@@ -0,0 +1,25 @@
+<IfModule mod_rewrite.c>
+    <IfModule mod_negotiation.c>
+        Options -MultiViews -Indexes
+    </IfModule>
+
+    RewriteEngine On
+
+    # Handle Authorization Header
+    RewriteCond %{HTTP:Authorization} .
+    RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
+
+    # Handle X-XSRF-Token Header
+    RewriteCond %{HTTP:x-xsrf-token} .
+    RewriteRule .* - [E=HTTP_X_XSRF_TOKEN:%{HTTP:X-XSRF-Token}]
+
+    # Redirect Trailing Slashes If Not A Folder...
+    RewriteCond %{REQUEST_FILENAME} !-d
+    RewriteCond %{REQUEST_URI} (.+)/$
+    RewriteRule ^ %1 [L,R=301]
+
+    # Send Requests To Front Controller...
+    RewriteCond %{REQUEST_FILENAME} !-d
+    RewriteCond %{REQUEST_FILENAME} !-f
+    RewriteRule ^ index.php [L]
+</IfModule>

portail/public/css/syllabus-theme.css

@@ -0,0 +1,151 @@
+/* Syllabus — thème global. Surcharge les anciennes classes néo-brutalistes pour appliquer la DA "SaaS doux" de la bibliothèque v2. */
+@import url('https://fonts.googleapis.com/css2?family=Mulish:wght@400;500;600;700;800&display=swap');
+:root { --sy-bg:#f5f6f8; --sy-surface:#fff; --sy-line:#b8c1cf; --sy-ink:#111827; --sy-muted:#6b7280; --sy-blue:#1d5cf5; --sy-blue-dark:#174bd0; --sy-navy:#1e3a8a; }
+html, body { background: var(--sy-bg) !important; color: var(--sy-ink) !important; font-family: Mulish, system-ui, sans-serif !important; }
+body * { font-family: inherit; }
+code, pre, kbd, .font-mono, [class*="font-mono"] { font-family: ui-monospace, "IBM Plex Mono", Menlo, monospace !important; }
+a { color: inherit; } a:hover { color: var(--sy-blue); }
+
+/* Bordures : fines et grises, coins arrondis */
+[class~="border-4"]:not([class~="border-transparent"]), [class~="border-2"]:not([class~="border-transparent"]), [class~="border"] { border-width: 1px !important; border-color: var(--sy-line) !important; }
+[class~="border-b-4"], [class~="border-b-2"] { border-bottom-width: 1px !important; border-bottom-color: var(--sy-line) !important; }
+[class~="border-t-4"], [class~="border-t-2"] { border-top-width: 1px !important; border-top-color: var(--sy-line) !important; }
+[class~="border-r-2"], [class~="border-l-2"] { border-color: var(--sy-line) !important; }
+[class~="divide-black"] > * + * { border-color: var(--sy-line) !important; }
+section[class*="border"], article[class*="border"], aside[class*="border"], div[class~="border-4"], div[class~="border-2"], li[class~="border-2"], figure[class*="border"], details[class*="border"], table { border-radius: 12px; }
+a[class~="border-2"], button[class~="border-2"], summary[class~="border-2"], span[class~="border-2"], input, select, textarea { border-radius: 6px !important; }
+[class*="border-dashed"] { border-style: dashed !important; }
+
+/* Ombres dures → ombres douces ; plus de rotations ni de décors flottants */
+[class*="shadow-["] { box-shadow: 0 1px 3px rgba(17,24,39,.06) !important; }
+[class*="hover:shadow-["]:hover { box-shadow: 0 6px 18px rgba(17,24,39,.08) !important; }
+[class*="rotate-"], [class*="-rotate-"] { transform: none !important; }
+[aria-hidden="true"][class*="absolute"][class*="pointer-events-none"] { display: none !important; }
+
+/* Palette : jaune/vert/rose/lavande fluo → pastels ; rouge/noir d'action → bleu */
+[class~="bg-[#FFD23F]"] { background-color: #dbe6ff !important; color: var(--sy-navy) !important; }
+[class~="bg-[#7CF2C0]"] { background-color: #dcfce7 !important; color: #166534 !important; }
+[class~="bg-[#FF6FB5]"] { background-color: #fce7f3 !important; color: #9d174d !important; }
+[class~="bg-[#C4B5FD]"] { background-color: #ede4ff !important; color: #5b21b6 !important; }
+[class~="bg-[#FFFBEA]"], [class~="bg-[#F6F5F1]"], [class*="hover:bg-[#FFFBEA]"]:hover { background-color: #f1f2f5 !important; }
+[class~="bg-[#ec3013]"] { background-color: var(--sy-blue) !important; color: #fff !important; }
+[class~="bg-black"]:not(pre):not([class*="h-2"]):not([class*="h-3"]):not([class*="h-full"]) { background-color: var(--sy-blue) !important; color: #fff !important; }
+[class*="hover:bg-black"]:hover { background-color: var(--sy-blue-dark) !important; color: #fff !important; }
+[class~="bg-[#13233A]"] { background-color: #0f172a !important; border-radius: 12px; }
+[class*="text-[#b3001b]"], [class*="text-[#ec3013]"] { color: #b91c1c !important; }
+[class~="bg-[#F6F5F1]"] { background-color: #f8f9fb !important; }
+body > header, header[class*="border-b"] { background: #fff !important; box-shadow: 0 1px 0 var(--sy-line) !important; }
+
+/* Titres un peu moins massifs */
+h1[class*="font-black"] { letter-spacing: -0.015em !important; }
+[class*="font-black"] { font-weight: 800 !important; }
+[class*="uppercase"][class*="tracking-wider"] { color: var(--sy-muted); }
+
+/* Focus */
+:focus-visible { outline: 2px solid var(--sy-blue) !important; outline-offset: 2px; }
+
+/* États : page courante, menu ouvert, survol */
+[aria-current="page"][class*="aria-[current=page]:bg-[#FFD23F]"], details[open] > [class*="group-open:bg-[#FFD23F]"] { background-color: #dbe6ff !important; color: var(--sy-blue) !important; border-color: transparent !important; border-radius: 6px; }
+[aria-current="page"][class*="aria-[current=page]:border-black"] { border-color: transparent !important; }
+[class*="hover:bg-[#FFD23F]"]:hover { background-color: #dbe6ff !important; }
+[class*="hover:border-black"]:hover { border-color: var(--sy-line) !important; }
+
+/* Ton posé : titres plus mesurés, moins de couleur, pas d'emoji ni d'effets */
+h1:not([style*="font-size"]) { font-size: clamp(28px, 3.2vw, 40px) !important; line-height: 1.15 !important; font-weight: 800 !important; }
+h2:not([style*="font-size"]) { font-size: clamp(22px, 2.2vw, 28px) !important; line-height: 1.2 !important; }
+h3:not([style*="font-size"]) { font-size: 18px !important; line-height: 1.3 !important; }
+[class*="text-7xl"], [class*="text-8xl"], [class*="text-6xl"] { font-size: clamp(30px, 3.4vw, 42px) !important; line-height: 1.15 !important; }
+[class*="text-5xl"] { font-size: clamp(26px, 2.6vw, 32px) !important; }
+[class*="leading-[0.9"], [class*="leading-[0.8"] { line-height: 1.15 !important; }
+[class*="tracking-tighter"] { letter-spacing: -0.01em !important; }
+[class*="hover:-translate-y"]:hover, [class*="hover:translate"]:hover { transform: none !important; }
+[class*="animate-"] { animation: none !important; }
+section[class~="bg-[#ec3013]"], section[class~="bg-black"], div[class~="bg-black"][class*="p-8"], div[class~="bg-black"][class*="p-6"] { background: #fff !important; color: var(--sy-ink) !important; border: 1px solid var(--sy-line) !important; }
+section[class~="bg-[#ec3013]"] *, div[class~="bg-black"][class*="p-8"] *, div[class~="bg-black"][class*="p-6"] * { color: inherit; }
+[class*="bg-[#FFD23F]"][class*="px-3"][class*="uppercase"] { background: transparent !important; color: var(--sy-blue) !important; padding-left: 0 !important; box-shadow: none !important; border: 0 !important; }
+
+[class*="E6FF3F"],[class*="E8FF3C"]{background-color:#eef2ff!important;color:#1e3a8a!important}
+
+/* Contraste : fond de page plus sombre, contours visibles partout, traits fins */
+html, body { background: #eef1f5 !important; }
+main section.bg-white, main section[class*="bg-white"] { background: #eef1f5 !important; }
+[class*="border-4"], [class*="border-2"], [class*="border-black"], [class*="border-y-4"], [class*="border-t-4"], [class*="border-b-4"] { border-color: #b8c1cf !important; }
+[class*="border-4"] { border-width: 1px !important; }
+[class*="border-2"] { border-width: 1px !important; }
+[class*="border-y-4"] { border-top-width: 1px !important; border-bottom-width: 1px !important; }
+[class*="border-t-4"] { border-top-width: 1px !important; }
+[class*="border-b-4"] { border-bottom-width: 1px !important; }
+[class*="border-r-4"], [class*="border-l-4"] { border-width: 0 1px 0 0 !important; }
+[class*="divide-black"] > * + * { border-color: #b8c1cf !important; }
+main article, main figure, main li[class*="border"], main div[class*="border"][class*="bg-"] { box-shadow: 0 1px 2px rgba(17,24,39,.06), 0 2px 8px rgba(17,24,39,.05) !important; }
+[class*="bg-white"][class*="border"], figure[style*="border"] { background: #fff !important; }
+/* Badges collés aux cartes : dans le flux, alignés en haut */
+main article > span[class*="absolute"], main li > span[class*="absolute"], main div[class*="relative"] > span[class*="absolute"][class*="border"] { position: static !important; display: inline-block !important; margin: 0 0 12px 0 !important; transform: none !important; }
+
+header a, header summary, nav a, header [class*="border-transparent"], nav [class*="border-transparent"] { border-color: transparent !important; }
+header a[aria-current="page"], header details[open] > summary { border-color: #bfd0f5 !important; }
+header ul[class*="absolute"] { border: 1px solid #b8c1cf !important; }
+main [class*="border-4"], main [class*="border-2"]:not([class*="border-transparent"]) { border-color: #b8c1cf !important; }
+main li[class*="min-h-[340px]"] { min-height: 0 !important; }
+main li[class*="min-h-[340px]"] > *:first-child + * { margin-top: 12px !important; }
+h1 span[class*="bg-"] { background: transparent !important; border: 0 !important; padding: 0 !important; color: #1d4ed8 !important; }
+[class*="border-transparent"] { border-color: transparent !important; }
+[class*="border-transparent"][aria-current="page"], [class*="border-transparent"]:hover { border-color: transparent !important; background: #e8eefc !important; }
+aside a[class*="border-black"][class*="bg-black"] { border-color: transparent !important; }
+
+/* === SOBRIÉTÉ (inspiration Google Workspace) : l'espace et la typographie structurent, un seul appel à l'action fort === */
+:root { --sy-ink:#0b1220; --sy-text:#3c4043; --sy-hair:#e3e5e8; --sy-soft:#f8f9fa; --sy-blue:#0b57d0; --sy-blue-dark:#0842a0; }
+html, body { background:#fff !important; }
+main p { color: var(--sy-text); }
+main h1, main h2, main h3 { color: var(--sy-ink) !important; text-wrap: balance; }
+main h1:not([style*="line-height"]) { font-weight:800 !important; line-height:1.06 !important; }
+main p, main li { text-wrap: pretty; }
+
+/* Fonds : blanc, et un gris très léger pour alterner les sections */
+main section[class*="bg-"], main div[class~="bg-[#F6F5F1]"], main div[class~="bg-[#FFFBEA]"] { background-color:#fff !important; }
+main section[class~="bg-[#F6F5F1]"], main section[class~="bg-[#FFFBEA]"] { background-color: var(--sy-soft) !important; }
+main section { border-color: transparent !important; box-shadow:none !important; }
+
+/* Pages vitrine : beaucoup plus d'air */
+main > section > div[class*="py-"] { padding-top: clamp(64px, 9vw, 112px) !important; padding-bottom: clamp(64px, 9vw, 112px) !important; }
+main > section > div[class*="max-w-"] > p[class*="text-xl"], main > section > div[class*="max-w-"] p[class*="text-lg"] { line-height:1.65 !important; }
+
+/* Cartes et encadrés : trait très fin, grands rayons, aucune ombre */
+[class~="border-4"]:not([class~="border-transparent"]), [class~="border-2"]:not([class~="border-transparent"]), [class~="border"] { border-color: var(--sy-hair) !important; }
+main article[class*="border"], main li[class~="border-2"], main div[class~="border-2"], main div[class~="border-4"], main figure[class*="border"], main details[class*="border"] { border-radius:16px !important; }
+[class*="shadow-["], [class*="shadow-md"], [class*="shadow-lg"] { box-shadow:none !important; }
+[class*="rotate-"], [class*="-rotate-"], [class*="md:rotate"], [class*="md:-rotate"], [class*="translate-y-8"] { transform:none !important; }
+main [aria-hidden="true"][class*="absolute"] { display:none !important; }
+
+/* Badges et pastilles : neutres, texte foncé */
+main span[class~="border-2"][class*="text-xs"], main span[class~="border-2"][class*="text-sm"][class*="px-2"], main span[class*="rounded-full"][class*="px-"] { background:#f1f3f4 !important; color:#3c4043 !important; border-color:transparent !important; border-radius:999px !important; }
+[class~="bg-[#FFD23F]"], [class~="bg-[#7CF2C0]"], [class~="bg-[#FF6FB5]"], [class~="bg-[#C4B5FD]"] { background-color:#f1f3f4 !important; color:#202124 !important; }
+main div[class*="bg-[#FFD23F]"][class*="p-"], main div[class*="bg-[#7CF2C0]"][class*="p-"], main div[class*="bg-[#C4B5FD]"][class*="p-"], main div[class*="bg-[#FF6FB5]"][class*="p-"] { background: var(--sy-soft) !important; }
+
+/* Boutons : pilules ; l'action principale en bleu plein, le reste en contour discret */
+a[class*="inline-flex"][class*="h-11"], a[class*="inline-flex"][class*="h-12"], a[class*="inline-flex"][class*="h-10"], button[class*="h-11"], button[class*="h-12"], button[class*="h-10"] { border-radius:999px !important; padding-left:24px !important; padding-right:24px !important; font-weight:700 !important; }
+a[class~="bg-[#ec3013]"], button[class~="bg-[#ec3013]"], a[class~="bg-black"], button[class~="bg-black"] { background-color: var(--sy-blue) !important; border-color: var(--sy-blue) !important; color:#fff !important; }
+a[class~="bg-[#ec3013]"]:hover, button[class~="bg-[#ec3013]"]:hover, a[class~="bg-black"]:hover, button[class~="bg-black"]:hover { background-color: var(--sy-blue-dark) !important; }
+main a[class~="bg-white"][class*="inline-flex"], main button[class~="bg-white"][class*="h-"] { background:#fff !important; color: var(--sy-blue) !important; border:1px solid #dadce0 !important; }
+main a[class~="bg-white"][class*="inline-flex"]:hover, main button[class~="bg-white"][class*="h-"]:hover { background:#f6f9fe !important; }
+
+/* En-tête : conservé, épuré */
+body > header { background:#fff !important; box-shadow:none !important; border-bottom:1px solid var(--sy-hair) !important; }
+body > header nav a, body > header nav summary { font-weight:600 !important; color:#3c4043 !important; text-decoration:none !important; }
+body > header nav a:hover, body > header nav summary:hover { color: var(--sy-ink) !important; background:transparent !important; }
+body > header nav ul a[aria-current="page"] { color: var(--sy-blue) !important; background:transparent !important; }
+body > header a[href*="inscription"] { background: var(--sy-blue) !important; color:#fff !important; border:0 !important; border-radius:999px !important; padding:0 22px !important; }
+body > header a[href*="inscription"] > span[aria-hidden="true"] { display:none !important; }
+body > header a[href*="inscription"]:hover { background: var(--sy-blue-dark) !important; color:#fff !important; }
+body > header a[href*="connexion"] { border:0 !important; background:transparent !important; }
+
+[class*="text-[#FFD23F]"], [class*="text-[#7CF2C0]"], [class*="text-[#FF6FB5]"], [class*="text-[#C4B5FD]"], [class*="text-[#E6FF3F]"], [class*="text-[#E8FF3C]"] { color: var(--sy-blue) !important; }
+main li[class*="min-h-[340px]"] { min-height:0 !important; aspect-ratio:auto !important; }
+main li[class*="min-h-[340px]"] > div[class*="justify-between"] { justify-content:flex-start !important; gap:16px !important; padding-bottom:0 !important; }
+main li[class*="min-h-[340px]"] > div > span[class*="self-end"] { align-self:flex-start !important; font-size:40px !important; color: var(--sy-blue) !important; }
+body > header a[href*="connexion"] { border:0 !important; background:transparent !important; box-shadow:none !important; padding-left:8px !important; padding-right:8px !important; }
+
+main h1:not([style*="letter-spacing"]), main h2:not([style*="letter-spacing"]) { letter-spacing:-0.02em !important; }
+
+header a[style*="background:#0b57d0"], header a[style*="background: #0b57d0"], nav a[style*="background:#0b57d0"] { color: #fff !important; }
+header a[style*="background:#0b57d0"]:hover, nav a[style*="background:#0b57d0"]:hover { color: #fff !important; background: #0842a0 !important; }

portail/public/index.php

@@ -0,0 +1,20 @@
+<?php
+
+use Illuminate\Foundation\Application;
+use Illuminate\Http\Request;
+
+define('LARAVEL_START', microtime(true));
+
+// Determine if the application is in maintenance mode...
+if (file_exists($maintenance = __DIR__.'/../storage/framework/maintenance.php')) {
+    require $maintenance;
+}
+
+// Register the Composer autoloader...
+require __DIR__.'/../vendor/autoload.php';
+
+// Bootstrap Laravel and handle the request...
+/** @var Application $app */
+$app = require_once __DIR__.'/../bootstrap/app.php';
+
+$app->handleRequest(Request::capture());

portail/public/js/contenus-1.js

@@ -0,0 +1,95 @@
+// Cours complets · lot 1 : représentation des données, terminal, droits Unix
+window.CONTENUS_PRO = (window.CONTENUS_PRO || []).concat([
+{ id: 'binaire', match: /binaire|hexad|représentation des (données|entiers)/i,
+  titre: 'Représentation des entiers : binaire et hexadécimal', duree: '4 h (CM 1 h 30 · TD 1 h 30 · TP 1 h)', niveau: 'NSI Première · BTS SIO / CIEL 1re année · BUT R&T / Info S1',
+  prerequis: ['Puissances de 10 et de 2', 'Division euclidienne'],
+  competences: ['NSI 1re · Représentation des données : types et valeurs de base', 'BTS SIO · Bloc 1 · Exploiter les éléments d’un réseau (adressage)', 'BUT R&T · Compétence « Administrer » · niveau 1'],
+  intro: 'Tout ce qu’un ordinateur stocke, du texte aux images en passant par les adresses IP, finit en suites de 0 et de 1. Savoir passer d’une base à l’autre est un geste de base de l’informaticien : il sert à calculer un masque de sous-réseau, lire une adresse MAC, choisir une couleur web ou comprendre un débordement d’entier.',
+  cm: [
+    { t: 'Les systèmes de numération', d: '15 min', html: 'Un système de numération positionnel en base <b>b</b> utilise b chiffres (de 0 à b − 1). La valeur d’un chiffre dépend de sa position : le chiffre de rang k vaut chiffre × b<sup>k</sup>, les rangs étant comptés à partir de 0, depuis la droite.<br><br>En base 10 : 2 047 = 2×10³ + 0×10² + 4×10¹ + 7×10⁰. En base 2, seuls 0 et 1 existent. En base 16, on utilise 0-9 puis A (10), B (11), C (12), D (13), E (14), F (15).', table: [['Base', 'Nom', 'Chiffres', 'Notation'], ['2', 'binaire', '0 1', '0b1011 ou 1011₂'], ['10', 'décimal', '0 à 9', '11'], ['16', 'hexadécimal', '0 à 9, A à F', '0xB ou B₁₆']] },
+    { t: 'Bits, octets et ordres de grandeur', d: '10 min', html: 'Un <b>bit</b> (binary digit) prend la valeur 0 ou 1. Avec n bits on code 2<sup>n</sup> valeurs, de 0 à 2<sup>n</sup> − 1. Un <b>octet</b> vaut 8 bits, donc 256 valeurs (0 à 255). Les préfixes normalisés sont décimaux (1 ko = 1 000 octets) ; les préfixes binaires s’écrivent Kio, Mio, Gio (1 Kio = 1 024 octets).', attention: 'Un disque de « 1 To » affiche environ 931 Gio dans le système : ce n’est pas une arnaque, c’est la différence entre 10¹² et 2⁴⁰.' },
+    { t: 'Du binaire au décimal', d: '15 min', html: 'On additionne les poids des bits à 1. Les poids d’un octet sont 128, 64, 32, 16, 8, 4, 2, 1.', exemple: '1011 0010₂ = 128 + 32 + 16 + 2 = 178\n0100 0001₂ = 64 + 1 = 65 (code ASCII de « A »)' },
+    { t: 'Du décimal au binaire', d: '20 min', html: '<b>Méthode 1, soustractions :</b> on retire la plus grande puissance de 2 possible, on écrit 1 à sa place, 0 sinon, et on recommence avec le reste.<br><b>Méthode 2, divisions successives :</b> on divise par 2 jusqu’à obtenir 0 ; les restes lus de bas en haut donnent le nombre binaire.', exemple: '45 ÷ 2 = 22 reste 1\n22 ÷ 2 = 11 reste 0\n11 ÷ 2 =  5 reste 1\n 5 ÷ 2 =  2 reste 1\n 2 ÷ 2 =  1 reste 0\n 1 ÷ 2 =  0 reste 1   → lecture de bas en haut : 101101₂', attention: 'On lit les restes de bas en haut. L’erreur la plus fréquente en devoir est de les lire dans l’ordre du calcul.' },
+    { t: 'L’hexadécimal', d: '15 min', html: 'Comme 16 = 2⁴, un chiffre hexadécimal correspond exactement à un groupe de 4 bits (un <i>quartet</i>). Pour convertir, on découpe le binaire en groupes de 4 à partir de la droite.', table: [['Binaire', '0000', '0101', '1001', '1010', '1100', '1111'], ['Hexa', '0', '5', '9', 'A', 'C', 'F']], exemple: '1011 0010₂ → B 2 → 0xB2\n#FF6FB5 → rouge FF = 255, vert 6F = 111, bleu B5 = 181' },
+    { t: 'Où les retrouve-t-on ?', d: '15 min', html: '<b>Adresses IPv4 :</b> 4 octets écrits en décimal pointé (192.168.10.65). <b>Masques :</b> /26 = 26 bits à 1 = 255.255.255.192. <b>Adresses MAC :</b> 6 octets en hexadécimal (3C:52:82:1A:0F:9B). <b>IPv6 :</b> 8 groupes de 16 bits en hexadécimal. <b>Couleurs web :</b> #RRVVBB. <b>Droits Unix :</b> notation octale, base 8 (chmod 755).' }],
+  synthese: ['n bits codent 2ⁿ valeurs, de 0 à 2ⁿ − 1', 'Poids d’un octet : 128 64 32 16 8 4 2 1', 'Décimal → binaire : divisions par 2, restes lus de bas en haut', '1 chiffre hexadécimal = 4 bits : on regroupe par 4 depuis la droite'],
+  qcm: [
+    ['Combien de valeurs différentes peut-on coder sur 10 bits ?', ['10', '100', '1 000', '1 024'], 3, '2¹⁰ = 1 024.'],
+    ['Que vaut 1100 1000₂ en décimal ?', ['200', '192', '208', '136'], 0, '128 + 64 + 8 = 200.'],
+    ['Comment s’écrit 172 en binaire ?', ['1010 1100', '1011 0100', '1100 1010', '1010 1010'], 0, '128 + 32 + 8 + 4 = 172.'],
+    ['Que vaut 0x3F en décimal ?', ['48', '63', '53', '36'], 1, '3 × 16 + 15 = 63.'],
+    ['Quel est le plus grand nombre codable sur 16 bits non signés ?', ['32 767', '65 535', '65 536', '16 383'], 1, '2¹⁶ − 1 = 65 535.'],
+    ['255.255.255.224 correspond à quel préfixe CIDR ?', ['/24', '/26', '/27', '/28'], 2, '224 = 1110 0000 : 24 + 3 = 27 bits à 1.'],
+    ['Combien d’octets compte une adresse MAC ?', ['4', '6', '8', '16'], 1, '48 bits = 6 octets.'],
+    ['Un disque vendu 500 Go contient environ :', ['500 Gio', '465 Gio', '512 Gio', '536 Gio'], 1, '500 × 10⁹ / 2³⁰ ≈ 465.']],
+  td: [
+    { n: 'Échauffement', c: 'Convertir en binaire sur 8 bits : 7, 64, 99, 128, 250.', r: '0000 0111 · 0100 0000 · 0110 0011 · 1000 0000 · 1111 1010' },
+    { n: 'Échauffement', c: 'Convertir en décimal : 1010 1010₂, 0x7F, 0xC0, 1111 0000₂.', r: '170 · 127 · 192 · 240' },
+    { n: 'Application', c: 'Écrire l’adresse 172.16.5.130 en binaire, octet par octet.', r: '10101100.00010000.00000101.10000010' },
+    { n: 'Application', c: 'Écrire le masque /20 en décimal pointé, puis en hexadécimal.', r: '255.255.240.0 · 0xFFFFF000' },
+    { n: 'Approfondissement', c: 'Un capteur code une température sur 12 bits. Combien de valeurs distinctes peut-il transmettre ? Si la plage mesurée va de −40 °C à +85 °C, quelle est la résolution ?', r: '2¹² = 4 096 valeurs. Résolution = 125 / 4 095 ≈ 0,031 °C.' },
+    { n: 'Approfondissement', c: 'Écrire en Python une fonction en_binaire(n) sans utiliser bin(), par divisions successives.', r: 'def en_binaire(n):\n    s = ""\n    while n > 0:\n        s = str(n % 2) + s\n        n //= 2\n    return s or "0"' }],
+  tp: { type: 'Générateur', url: 'apercu-generateur.html', desc: 'Conversions aléatoires à l’infini, corrigées au fil de l’eau.', etapes: ['Série de 10 conversions décimal → binaire', 'Série de 10 conversions binaire → hexadécimal', 'Défi chronométré : 20 conversions en 5 minutes'] },
+  plusLoin: [['Complément à deux et entiers signés', ''], ['Norme IEEE 754 des flottants', ''], ['Défis « Bit Manipulation » sur HackerRank', 'https://www.hackerrank.com/domains/algorithms?filters%5Bsubdomains%5D%5B%5D=bit-manipulation']] },
+
+{ id: 'terminal', match: /terminal|commandes de base|premiers pas|arborescence|FHS|shell/i,
+  titre: 'Le terminal Linux : se repérer et manipuler des fichiers', duree: '4 h (CM 1 h · TD 1 h · TP 2 h)', niveau: 'SNT · NSI · BTS SIO / CIEL · BUT R&T · Titre pro TSSR',
+  prerequis: ['Notion de fichier et de dossier'],
+  competences: ['BTS SIO · Bloc 1 · Gérer le patrimoine informatique', 'BTS CIEL · C04 · Installer un système', 'TSSR · Exploiter des serveurs Linux'],
+  intro: 'Les serveurs du monde entier se pilotent en ligne de commande. Le terminal est plus rapide que la souris, scriptable et accessible à distance par SSH. Ce cours pose les gestes que vous utiliserez dans tous les labs suivants.',
+  cm: [
+    { t: 'Shell, terminal et invite', d: '10 min', html: 'Le <b>terminal</b> est la fenêtre ; le <b>shell</b> (bash, zsh) est le programme qui lit vos commandes et les exécute. L’invite <code>eleve@debian:~$</code> indique l’utilisateur, la machine, le dossier courant (~ = dossier personnel) et le type de compte ($ utilisateur, # administrateur).' },
+    { t: 'L’arborescence Linux (FHS)', d: '15 min', html: 'Tout part de la racine <code>/</code>. Il n’y a pas de lettres de lecteur.', table: [['Dossier', 'Contenu'], ['/home', 'dossiers personnels des utilisateurs'], ['/etc', 'fichiers de configuration'], ['/var/log', 'journaux du système'], ['/bin, /usr/bin', 'commandes'], ['/tmp', 'fichiers temporaires, vidés au redémarrage'], ['/root', 'dossier personnel de l’administrateur']] },
+    { t: 'Chemins absolus et relatifs', d: '10 min', html: 'Un chemin <b>absolu</b> commence par / et part de la racine : <code>/home/eleve/notes.txt</code>. Un chemin <b>relatif</b> part du dossier courant : <code>projets/web</code>. <code>.</code> désigne le dossier courant, <code>..</code> le dossier parent.', exemple: 'eleve@debian:~$ pwd\n/home/eleve\neleve@debian:~$ cd projets/web\neleve@debian:~/projets/web$ cd ../..\neleve@debian:~$' },
+    { t: 'Lister et se déplacer', d: '10 min', html: '<code>pwd</code> affiche le dossier courant. <code>ls</code> liste ; <code>ls -l</code> détaille (droits, taille, date) ; <code>ls -a</code> montre les fichiers cachés (qui commencent par un point) ; <code>ls -lh</code> affiche les tailles lisibles. <code>cd</code> change de dossier.' },
+    { t: 'Créer, copier, déplacer, supprimer', d: '15 min', html: '<code>mkdir -p a/b/c</code> crée une arborescence, <code>touch f</code> un fichier vide, <code>cp src dest</code> copie (<code>-r</code> pour un dossier), <code>mv</code> déplace ou renomme, <code>rm</code> supprime (<code>-r</code> pour un dossier).', attention: 'Il n’y a pas de corbeille. rm -rf supprime sans confirmation. Relisez toujours la commande avant Entrée, surtout avec sudo.' },
+    { t: 'Aide et productivité', d: '10 min', html: '<code>man commande</code> ouvre le manuel (/ pour chercher, q pour quitter). <b>Tab</b> complète les noms, <b>↑</b> rappelle l’historique, <b>Ctrl+R</b> recherche dans l’historique, <b>Ctrl+C</b> interrompt une commande, <code>history</code> liste les commandes passées.' }],
+  synthese: ['/ est la racine, ~ le dossier personnel', 'Chemin absolu = commence par /', 'pwd, ls, cd pour se repérer ; mkdir, cp, mv, rm pour agir', 'Pas de corbeille : relire avant rm'],
+  qcm: [
+    ['Où se trouvent les fichiers de configuration du système ?', ['/home', '/etc', '/var', '/bin'], 1, '/etc regroupe la configuration.'],
+    ['Lequel est un chemin absolu ?', ['projets/web', '../notes', '/var/log/syslog', '~notes'], 2, 'Il commence par /.'],
+    ['Que fait mkdir -p a/b/c ?', ['Erreur si a n’existe pas', 'Crée toute l’arborescence', 'Crée un fichier', 'Supprime a/b/c'], 1, '-p crée les dossiers parents manquants.'],
+    ['Que signifie # à la fin de l’invite ?', ['Commentaire', 'Compte administrateur', 'Erreur', 'Dossier racine'], 1, '# indique root.'],
+    ['Quelle commande copie le dossier site et son contenu ?', ['cp site copie', 'cp -r site copie', 'mv site copie', 'mkdir site copie'], 1, '-r = récursif.'],
+    ['Quel raccourci recherche dans l’historique ?', ['Ctrl+C', 'Ctrl+R', 'Ctrl+Z', 'Tab'], 1, 'Ctrl+R lance la recherche inversée.'],
+    ['Où sont les journaux du système ?', ['/var/log', '/etc/log', '/tmp', '/home/log'], 0, '/var/log contient syslog, auth.log…'],
+    ['Depuis /home/eleve/projets, que désigne ../.. ?', ['/home', '/home/eleve', '/', '/projets'], 0, 'On remonte deux fois.']],
+  td: [
+    { n: 'Échauffement', c: 'Depuis /home/eleve, donner le chemin absolu puis relatif du fichier /home/eleve/projets/web/index.html.', r: 'Absolu : /home/eleve/projets/web/index.html · relatif : projets/web/index.html' },
+    { n: 'Application', c: 'Créer en une commande : tp/{reseau,systeme,web}.', r: 'mkdir -p tp/reseau tp/systeme tp/web  (ou mkdir -p tp/{reseau,systeme,web})' },
+    { n: 'Application', c: 'Copier /etc/hosts dans tp/reseau sous le nom hosts.bak, puis vérifier.', r: 'cp /etc/hosts tp/reseau/hosts.bak && ls -l tp/reseau' },
+    { n: 'Approfondissement', c: 'Trouver tous les fichiers .conf de /etc de plus de 10 Ko.', r: 'find /etc -name "*.conf" -size +10k 2>/dev/null' }],
+  tp: { type: 'Lab VM', url: 'apercu-lab-essai.html', desc: 'Un vrai terminal Debian, étapes vérifiées automatiquement dans la VM.', etapes: ['Se repérer : pwd, ls -la', 'Créer l’arborescence du projet', 'Copier et renommer des fichiers', 'Retrouver un fichier avec find', 'Nettoyer sans rien casser'] },
+  plusLoin: [['Le jeu OverTheWire Bandit (niveaux 0 à 10)', 'https://overthewire.org/wargames/bandit/'], ['Linux Journey', 'https://linuxjourney.com/']] },
+
+{ id: 'droits', match: /droits|chmod|chown|permissions|utilisateurs et groupes/i,
+  titre: 'Droits, utilisateurs et groupes sous Linux', duree: '5 h (CM 1 h 30 · TD 1 h 30 · TP 2 h)', niveau: 'BTS SIO SISR · BTS CIEL IR · BUT R&T · TSSR',
+  prerequis: ['Le terminal Linux', 'Binaire : poids des bits'],
+  competences: ['BTS SIO · Bloc 3 · Sécuriser les équipements et les usages', 'BTS CIEL · C08 · Sécuriser un système', 'BUT R&T · Compétence « Administrer »'],
+  intro: 'Sur un serveur partagé, chaque fichier appartient à quelqu’un et chacun n’a que les droits dont il a besoin : c’est le principe du moindre privilège. Une erreur de droits, c’est soit un service qui ne démarre pas, soit une fuite de données.',
+  cm: [
+    { t: 'Utilisateurs et groupes', d: '15 min', html: 'Chaque utilisateur a un identifiant (UID) et un groupe principal (GID), déclarés dans <code>/etc/passwd</code> et <code>/etc/group</code>. Les mots de passe hachés sont dans <code>/etc/shadow</code>, lisible par root seulement. <code>id</code> affiche vos identifiants.', exemple: 'root@srv:~# adduser alice\nroot@srv:~# addgroup profs\nroot@srv:~# usermod -aG profs alice\nroot@srv:~# id alice\nuid=1001(alice) gid=1001(alice) groupes=1001(alice),1002(profs)' },
+    { t: 'Lire les droits', d: '15 min', html: '<code>ls -l</code> affiche 10 caractères : le type puis trois triplets pour le <b>propriétaire (u)</b>, le <b>groupe (g)</b> et les <b>autres (o)</b>.', table: [['Droit', 'Sur un fichier', 'Sur un dossier'], ['r (4)', 'lire le contenu', 'lister les noms'], ['w (2)', 'modifier', 'créer, renommer, supprimer dedans'], ['x (1)', 'exécuter', 'traverser (cd)']], exemple: '-rwxr-x---  1 alice profs  812 sept. 29 10:14 sauvegarde.sh\n│└┬┘└┬┘└┬┘\n│ u  g  o' },
+    { t: 'chmod : octal et symbolique', d: '20 min', html: 'En <b>octal</b>, on additionne r = 4, w = 2, x = 1 pour chaque triplet : rwx = 7, r-x = 5, r-- = 4. En <b>symbolique</b>, on ajoute (+), retire (−) ou fixe (=) un droit pour u, g, o ou a.', exemple: 'chmod 750 sauvegarde.sh       # rwxr-x---\nchmod u+x,g-w rapport.txt\nchmod -R o= /srv/partage       # retire tout aux autres, récursivement' },
+    { t: 'chown et umask', d: '15 min', html: '<code>chown alice:profs fichier</code> change propriétaire et groupe (réservé à root). <code>umask</code> fixe les droits retirés à la création : avec umask 022, un fichier est créé en 644 et un dossier en 755 ; avec 027, en 640 et 750.' },
+    { t: 'Droits spéciaux', d: '15 min', html: '<b>SUID (4000)</b> : le programme s’exécute avec les droits de son propriétaire (ex. <code>passwd</code>). <b>SGID (2000)</b> sur un dossier : les fichiers créés héritent du groupe du dossier, idéal pour un partage. <b>Sticky bit (1000)</b> sur un dossier : seul le propriétaire d’un fichier peut le supprimer (ex. <code>/tmp</code>).', attention: 'Un script SUID root mal écrit est une porte d’entrée classique pour une élévation de privilèges. En audit, on les recherche avec find / -perm -4000.' },
+    { t: 'Au-delà : les ACL', d: '10 min', html: 'Les ACL permettent de donner des droits à un utilisateur précis sans changer le groupe : <code>setfacl -m u:bob:rw rapport.txt</code>, et <code>getfacl</code> pour les lire.' }],
+  synthese: ['u g o × r w x, avec r = 4, w = 2, x = 1', 'x sur un dossier = pouvoir y entrer', 'SGID sur un dossier partagé, sticky bit sur /tmp', 'Moindre privilège : ne donner que le nécessaire'],
+  qcm: [
+    ['rwxr-x--- en octal ?', ['750', '755', '740', '770'], 0, '7, 5, 0.'],
+    ['Quel fichier contient les hachages des mots de passe ?', ['/etc/passwd', '/etc/shadow', '/etc/group', '/etc/login'], 1, 'shadow, lisible par root uniquement.'],
+    ['Que fait chmod g+w rapport.txt ?', ['Donne l’écriture aux autres', 'Donne l’écriture au groupe', 'Retire l’écriture', 'Change le groupe'], 1, 'g = groupe, + = ajouter.'],
+    ['Avec umask 027, un nouveau dossier a les droits :', ['755', '750', '770', '700'], 1, '777 − 027 = 750.'],
+    ['Quel droit permet à un utilisateur de faire cd dans un dossier ?', ['r', 'w', 'x', 's'], 2, 'x sur un dossier = traverser.'],
+    ['Le sticky bit sur /tmp sert à :', ['Accélérer', 'Empêcher de supprimer les fichiers des autres', 'Chiffrer', 'Hériter du groupe'], 1, 'Chacun ne supprime que ses fichiers.'],
+    ['Comment ajouter alice au groupe profs sans retirer ses autres groupes ?', ['usermod -G profs alice', 'usermod -aG profs alice', 'chown profs alice', 'addgroup alice'], 1, '-a = append.'],
+    ['Quelle commande trouve les fichiers SUID ?', ['find / -perm -4000', 'ls -suid', 'chmod -find', 'grep suid /'], 0, '-perm -4000 cherche le bit SUID.']],
+  td: [
+    { n: 'Échauffement', c: 'Traduire en octal : rw-r--r--, rwx------, rwxrwxr-x, r--------.', r: '644 · 700 · 775 · 400' },
+    { n: 'Échauffement', c: 'Traduire en symbolique : 640, 755, 600.', r: 'rw-r----- · rwxr-xr-x · rw-------' },
+    { n: 'Application', c: 'Créer un dossier /srv/projet partagé par le groupe devs : les membres lisent et écrivent, les fichiers créés restent dans le groupe devs, les autres n’ont aucun accès.', r: 'mkdir /srv/projet\nchown root:devs /srv/projet\nchmod 2770 /srv/projet' },
+    { n: 'Application', c: 'Le script sauvegarde.sh refuse de se lancer (« Permission non accordée »). Diagnostiquer et corriger.', r: 'ls -l sauvegarde.sh → pas de x. chmod u+x sauvegarde.sh' },
+    { n: 'Approfondissement', c: 'Expliquer pourquoi un fichier en 777 dans un dossier en 700 appartenant à alice reste inaccessible à bob.', r: 'bob ne peut pas traverser le dossier (pas de x pour les autres) : il n’atteint jamais le fichier.' }],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Créer des comptes, un dossier partagé en SGID et tester les accès avec su.', etapes: ['Créer alice, bob et le groupe devs', 'Préparer /srv/projet en 2770', 'Tester l’écriture en tant qu’alice puis bob', 'Poser une ACL pour un stagiaire', 'Audit : lister les fichiers SUID'] },
+  plusLoin: [['ANSSI · Recommandations de sécurité relatives à un système GNU/Linux', 'https://cyber.gouv.fr/publications/recommandations-de-securite-relatives-un-systeme-gnulinux']] }
+]);

portail/public/js/contenus-2.js

@@ -0,0 +1,90 @@
+// Cours complets · lot 2 : tubes, réseaux (OSI), SQL
+window.CONTENUS_PRO = (window.CONTENUS_PRO || []).concat([
+{ id: 'tubes', match: /redirection|tubes|grep|filtres|sed|awk/i,
+  titre: 'Redirections, tubes et filtres de texte', duree: '4 h (CM 1 h · TD 1 h 30 · TP 1 h 30)', niveau: 'BTS SIO · BTS CIEL · BUT R&T · TSSR',
+  prerequis: ['Le terminal Linux'],
+  competences: ['BTS SIO · Bloc 1 · Exploiter des journaux', 'BUT R&T · Compétence « Administrer » · automatiser'],
+  intro: 'Un administrateur passe beaucoup de temps à lire des journaux de plusieurs milliers de lignes. Plutôt que de les lire à l’œil, on enchaîne de petites commandes spécialisées. C’est la philosophie Unix : chaque outil fait une chose, et bien.',
+  cm: [
+    { t: 'Les trois flux standard', d: '10 min', html: 'Chaque processus dispose de trois flux : <b>stdin (0)</b> l’entrée, <b>stdout (1)</b> la sortie normale, <b>stderr (2)</b> les erreurs. Les séparer permet de garder les résultats propres et d’isoler les erreurs.' },
+    { t: 'Rediriger', d: '15 min', html: 'On envoie un flux vers un fichier ou on lit un fichier comme entrée.', table: [['Opérateur', 'Effet'], ['>', 'stdout vers un fichier (écrase)'], ['>>', 'stdout ajouté à la fin'], ['2>', 'stderr vers un fichier'], ['&> ou > f 2>&1', 'les deux flux dans le même fichier'], ['<', 'le fichier devient stdin'], ['> /dev/null', 'jeter la sortie']], exemple: 'find / -name "*.conf" > resultats.txt 2> /dev/null' },
+    { t: 'Le tube', d: '10 min', html: 'Le tube <code>|</code> branche la sortie d’une commande sur l’entrée de la suivante, sans fichier intermédiaire. On construit une chaîne de traitement de gauche à droite.', exemple: 'cat /var/log/auth.log | grep "Failed password" | wc -l' },
+    { t: 'La boîte à outils', d: '20 min', html: '', table: [['Commande', 'Rôle', 'Exemple'], ['grep', 'garder les lignes qui correspondent', 'grep -i erreur syslog'], ['cut', 'extraire des colonnes', 'cut -d: -f1,7 /etc/passwd'], ['sort', 'trier', 'sort -n, sort -rn'], ['uniq -c', 'compter les lignes identiques consécutives', 'sort | uniq -c'], ['wc -l', 'compter les lignes', ''], ['head / tail', 'début / fin', 'tail -f pour suivre en direct'], ['awk', 'traiter par colonnes', "awk '{print $1}'"], ['sed', 'remplacer', "sed 's/http/https/g'"]], attention: 'uniq ne regroupe que les lignes consécutives : il faut presque toujours trier avant avec sort.' },
+    { t: 'Un cas réel : repérer une attaque SSH', d: '15 min', html: 'Objectif : trouver les adresses IP qui ont le plus échoué à se connecter.', exemple: "grep 'Failed password' /var/log/auth.log \\\n  | awk '{print $(NF-3)}' \\\n  | sort | uniq -c | sort -rn | head -5\n\n    412 203.0.113.42\n     87 198.51.100.7\n     12 192.0.2.19" }],
+  synthese: ['> écrase, >> ajoute, 2> capture les erreurs', '| enchaîne les traitements', 'sort | uniq -c | sort -rn : le classement le plus utile de l’administrateur', 'tail -f pour suivre un journal en direct'],
+  qcm: [
+    ['Où va l’erreur de ls /inexistant > sortie.txt ?', ['Dans sortie.txt', 'À l’écran', 'Nulle part', 'Dans /dev/null'], 1, '> ne redirige que stdout ; stderr s’affiche.'],
+    ['Comment jeter à la fois la sortie et les erreurs ?', ['> /dev/null', '2> /dev/null', '&> /dev/null', '| null'], 2, '&> redirige les deux flux.'],
+    ['Que fait cut -d: -f1 /etc/passwd ?', ['Supprime la ligne 1', 'Affiche la 1re colonne séparée par :', 'Compte les lignes', 'Trie'], 1, '-d = séparateur, -f = champ.'],
+    ['Pourquoi trier avant uniq -c ?', ['Pour aller plus vite', 'uniq ne regroupe que les lignes consécutives', 'Ce n’est pas utile', 'Pour supprimer les doublons'], 1, 'Sans tri, les doublons dispersés ne sont pas regroupés.'],
+    ['Quelle commande suit un journal en temps réel ?', ['head -f', 'tail -f', 'cat -f', 'less -r'], 1, 'tail -f affiche les nouvelles lignes au fil de l’eau.'],
+    ['Que fait sed "s/a/b/g" f.txt ?', ['Supprime a', 'Remplace tous les a par b à l’affichage', 'Modifie le fichier sur disque', 'Compte les a'], 1, 'Sans -i, sed ne modifie pas le fichier.']],
+  td: [
+    { n: 'Échauffement', c: 'Enregistrer la liste de /etc dans liste.txt, puis y ajouter celle de /var.', r: 'ls /etc > liste.txt && ls /var >> liste.txt' },
+    { n: 'Application', c: 'Afficher les comptes qui utilisent /bin/bash, avec seulement leur nom.', r: 'grep "/bin/bash$" /etc/passwd | cut -d: -f1' },
+    { n: 'Application', c: 'Dans acces.log (format Apache), classer les 10 pages les plus demandées.', r: "awk '{print $7}' acces.log | sort | uniq -c | sort -rn | head -10" },
+    { n: 'Approfondissement', c: 'Compter les erreurs 404 par heure dans acces.log.', r: "awk '$9 == 404 {print substr($4, 14, 2)}' acces.log | sort | uniq -c" }],
+  tp: { type: 'IDE Bash', url: 'apercu-ide.html?ex=bash-tp', desc: 'Scripts Bash sur de vrais journaux, vérifiés par des tests.', etapes: ['Compter les connexions échouées', 'Classer les IP suspectes', 'Écrire un rapport dans un fichier', 'Bonus : alerte si plus de 100 échecs'] },
+  plusLoin: [['Le jeu OverTheWire Bandit (niveaux 10 à 20)', 'https://overthewire.org/wargames/bandit/'], ['Défis « Linux Shell » sur HackerRank', 'https://www.hackerrank.com/domains/shell']] },
+
+{ id: 'osi', match: /OSI|TCP\/IP|modèle en couches|encapsulation|Internet : IP/i,
+  titre: 'Modèles OSI et TCP/IP, encapsulation', duree: '4 h (CM 1 h 30 · TD 1 h · TP 1 h 30)', niveau: 'SNT · BTS SIO · BTS CIEL · BUT R&T S1',
+  prerequis: ['Binaire et hexadécimal'],
+  competences: ['BTS SIO · Bloc 1 · Exploiter les éléments d’un réseau', 'BTS CIEL · C03 · Analyser un réseau', 'BUT R&T · Compétence « Connecter »'],
+  intro: 'Quand un réseau tombe en panne, l’administrateur raisonne couche par couche : le câble est-il branché ? le switch voit-il la carte ? l’adresse IP est-elle bonne ? le service écoute-t-il ? Le modèle en couches est d’abord une méthode de diagnostic.',
+  cm: [
+    { t: 'Pourquoi un modèle en couches', d: '10 min', html: 'Communiquer suppose de régler beaucoup de problèmes : transmettre des bits, les adresser, les acheminer, les remettre en ordre, les présenter à l’application. Chaque couche règle un problème et offre un service à la couche du dessus, sans connaître le détail des autres.' },
+    { t: 'Les 7 couches OSI', d: '20 min', html: '', table: [['N°', 'Couche', 'Rôle', 'Unité', 'Exemples'], ['7', 'Application', 'service rendu à l’utilisateur', 'données', 'HTTP, DNS, SSH, SMTP'], ['6', 'Présentation', 'format, chiffrement', 'données', 'TLS, UTF-8'], ['5', 'Session', 'dialogue', 'données', 'RPC'], ['4', 'Transport', 'bout en bout, ports', 'segment', 'TCP, UDP'], ['3', 'Réseau', 'adressage logique, routage', 'paquet', 'IP, ICMP'], ['2', 'Liaison', 'accès au support, MAC', 'trame', 'Ethernet, Wi-Fi'], ['1', 'Physique', 'signal', 'bit', 'RJ45, fibre, radio']] },
+    { t: 'Le modèle TCP/IP', d: '10 min', html: 'Le modèle réellement implémenté compte 4 couches : <b>Accès réseau</b> (OSI 1-2), <b>Internet</b> (3), <b>Transport</b> (4), <b>Application</b> (5-7).' },
+    { t: 'L’encapsulation', d: '20 min', html: 'À l’émission, chaque couche ajoute son en-tête aux données reçues de la couche supérieure. À la réception, chaque couche lit et retire le sien.', exemple: '[ HTTP : GET /index.html ]\n[ TCP  : port src 51234 → dst 443 ][ HTTP … ]\n[ IP   : 192.168.10.65 → 93.184.216.34 ][ TCP … ][ HTTP … ]\n[ Eth  : MAC src → MAC passerelle ][ IP … ][ TCP … ][ HTTP … ][ FCS ]' },
+    { t: 'Les équipements par couche', d: '10 min', html: '<b>Hub</b> : couche 1, répète le signal. <b>Switch</b> : couche 2, commute selon les adresses MAC. <b>Routeur</b> : couche 3, achemine selon les adresses IP. <b>Pare-feu</b> : couches 3-4, filtre IP et ports (voire 7 pour un pare-feu applicatif).' },
+    { t: 'Diagnostiquer couche par couche', d: '15 min', html: 'On part du bas : <code>ip link</code> (lien actif ?), <code>ip addr</code> (adresse ?), <code>ping</code> la passerelle (couche 3), <code>ss -tlnp</code> (le service écoute-t-il ?), <code>curl</code> (l’application répond-elle ?).', attention: 'Un ping qui échoue ne prouve pas que la machine est éteinte : ICMP est souvent filtré par les pare-feux.' }],
+  synthese: ['OSI 7 couches, TCP/IP 4 couches', 'bit → trame → paquet → segment → données', 'MAC couche 2, IP couche 3, port couche 4', 'On diagnostique toujours de bas en haut'],
+  qcm: [
+    ['À quelle couche travaille un switch classique ?', ['1', '2', '3', '4'], 1, 'Il commute selon les adresses MAC.'],
+    ['Quelle est l’unité de la couche Transport ?', ['Trame', 'Paquet', 'Segment', 'Bit'], 2, 'TCP et UDP manipulent des segments (datagrammes pour UDP).'],
+    ['Le port 443 est une information de couche :', ['2', '3', '4', '7'], 2, 'Les ports sont gérés par la couche Transport.'],
+    ['Quel protocole n’est PAS de couche application ?', ['DNS', 'SSH', 'ICMP', 'SMTP'], 2, 'ICMP accompagne IP, couche 3.'],
+    ['Dans une trame Ethernet, l’adresse MAC de destination est celle :', ['du serveur web distant', 'de la passerelle ou du voisin direct', 'du DNS', 'du switch'], 1, 'La MAC change à chaque saut, l’IP de destination reste la même.'],
+    ['Combien de couches compte le modèle TCP/IP ?', ['3', '4', '5', '7'], 1, 'Accès réseau, Internet, Transport, Application.'],
+    ['Un poste a une IP mais n’accède pas à Internet. Première vérification ?', ['Réinstaller', 'ping la passerelle', 'Changer le câble', 'Vider le cache DNS'], 1, 'On teste la couche 3 vers la passerelle avant d’aller plus haut.']],
+  td: [
+    { n: 'Échauffement', c: 'Classer par couche OSI : HTTP, IP, switch, TCP, câble RJ45, routeur, TLS, Wi-Fi.', r: '7 · 3 · 2 · 4 · 1 · 3 · 6 · 1-2' },
+    { n: 'Application', c: 'Dessiner l’encapsulation d’une requête DNS du poste 192.168.1.20 vers 1.1.1.1.', r: 'DNS (requête) → UDP (port src aléatoire → 53) → IP (192.168.1.20 → 1.1.1.1) → Ethernet (MAC poste → MAC box)' },
+    { n: 'Application', c: 'Un utilisateur ne peut pas ouvrir intranet.lycee.fr. Proposer une démarche de diagnostic en 5 commandes, de bas en haut.', r: 'ip link · ip addr · ping passerelle · nslookup intranet.lycee.fr · curl -I https://intranet.lycee.fr' },
+    { n: 'Approfondissement', c: 'Expliquer pourquoi l’adresse MAC de destination change à chaque routeur traversé alors que l’adresse IP de destination reste la même.', r: 'La couche 2 ne sert qu’à atteindre le voisin direct ; chaque routeur ré-encapsule dans une nouvelle trame. La couche 3 porte l’adresse finale.' }],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Capturer du trafic avec tcpdump et reconnaître chaque en-tête.', etapes: ['Lancer tcpdump sur eth0', 'Faire un curl vers un site', 'Identifier Ethernet, IP, TCP, HTTP', 'Comparer avec une requête DNS en UDP'] },
+  plusLoin: [['Cisco Networking Academy · cours gratuits', 'https://www.netacad.com/'], ['RFC 1122 (Requirements for Internet Hosts)', 'https://www.rfc-editor.org/rfc/rfc1122']] },
+
+{ id: 'sql', match: /SQL|SELECT|requête|bases de données relationnelles|jointure/i,
+  titre: 'SQL : interroger une base de données relationnelle', duree: '6 h (CM 2 h · TD 2 h · TP 2 h)', niveau: 'NSI Terminale · BTS SIO SLAM · BUT Informatique · MIAGE',
+  prerequis: ['Notion de tableau de données'],
+  competences: ['NSI Tle · Bases de données : langage SQL', 'BTS SIO SLAM · Bloc 2 · Concevoir et exploiter une base de données', 'BUT Info · Compétence « Gérer des données »'],
+  intro: 'Presque toutes les applications stockent leurs données dans une base relationnelle : un ENT, un site marchand, Syllabus elle-même. SQL est le langage standard pour les interroger. Il se lit presque comme une phrase.',
+  cm: [
+    { t: 'Le modèle relationnel', d: '20 min', html: 'Une base est un ensemble de <b>tables</b> (relations). Chaque ligne est un enregistrement, chaque colonne un attribut typé. La <b>clé primaire</b> identifie une ligne de façon unique ; une <b>clé étrangère</b> référence la clé primaire d’une autre table.', table: [['eleves', 'id (PK)', 'nom', 'prenom', 'classe_id (FK)'], ['', '1', 'Martin', 'Léa', '3'], ['', '2', 'Kaci', 'Inès', '3']] },
+    { t: 'Sélectionner : SELECT … FROM', d: '15 min', html: 'On choisit les colonnes, puis la table. <code>*</code> sélectionne toutes les colonnes, <code>DISTINCT</code> supprime les doublons, <code>AS</code> renomme.', exemple: 'SELECT nom, prenom FROM eleves;\nSELECT DISTINCT ville FROM eleves;\nSELECT nom AS "Nom de famille" FROM eleves;' },
+    { t: 'Filtrer et trier', d: '20 min', html: '<code>WHERE</code> filtre avec =, <>, <, >, BETWEEN, IN, LIKE (% = n’importe quelle suite), IS NULL, combinés par AND, OR, NOT. <code>ORDER BY</code> trie (ASC, DESC), <code>LIMIT</code> restreint.', exemple: "SELECT nom, moyenne FROM eleves\nWHERE classe_id = 3 AND moyenne >= 10\nORDER BY moyenne DESC\nLIMIT 5;" },
+    { t: 'Agréger : COUNT, AVG, GROUP BY', d: '20 min', html: 'Les fonctions d’agrégat calculent sur un ensemble de lignes : COUNT, SUM, AVG, MIN, MAX. <code>GROUP BY</code> forme des groupes, <code>HAVING</code> filtre les groupes (WHERE filtre les lignes avant).', exemple: 'SELECT classe_id, COUNT(*) AS effectif, AVG(moyenne) AS moy\nFROM eleves\nGROUP BY classe_id\nHAVING COUNT(*) > 20;', attention: 'Toute colonne du SELECT qui n’est pas agrégée doit figurer dans le GROUP BY.' },
+    { t: 'Joindre des tables', d: '25 min', html: 'La jointure relie deux tables par leurs clés. <b>INNER JOIN</b> garde les lignes qui ont une correspondance des deux côtés ; <b>LEFT JOIN</b> garde toutes les lignes de gauche, avec NULL s’il n’y a pas de correspondance.', exemple: 'SELECT e.nom, c.libelle\nFROM eleves e\nJOIN classes c ON e.classe_id = c.id;\n\n-- Classes sans aucun élève :\nSELECT c.libelle FROM classes c\nLEFT JOIN eleves e ON e.classe_id = c.id\nWHERE e.id IS NULL;' },
+    { t: 'Modifier les données', d: '15 min', html: '<code>INSERT INTO</code> ajoute, <code>UPDATE … SET … WHERE</code> modifie, <code>DELETE FROM … WHERE</code> supprime.', attention: 'Un UPDATE ou un DELETE sans WHERE touche toutes les lignes. On teste toujours d’abord le WHERE avec un SELECT.' },
+    { t: 'Sécurité : l’injection SQL', d: '10 min', html: 'Construire une requête en collant du texte saisi par l’utilisateur permet de détourner la requête (<code>\' OR 1=1 --</code>). On utilise toujours des <b>requêtes préparées</b> avec paramètres.' }],
+  synthese: ['SELECT colonnes FROM table WHERE condition ORDER BY tri', 'WHERE filtre les lignes, HAVING filtre les groupes', 'JOIN … ON relie clé étrangère et clé primaire', 'Jamais de DELETE ni d’UPDATE sans WHERE', 'Requêtes préparées contre l’injection'],
+  qcm: [
+    ['Quelle clause filtre les groupes après un GROUP BY ?', ['WHERE', 'HAVING', 'ORDER BY', 'LIMIT'], 1, 'HAVING s’applique aux groupes.'],
+    ['Que renvoie SELECT COUNT(*) FROM eleves WHERE moyenne IS NULL ?', ['Les élèves sans moyenne', 'Le nombre d’élèves sans moyenne', 'Une erreur', '0 toujours'], 1, 'COUNT compte les lignes retenues.'],
+    ['Quelle jointure garde les classes sans élève ?', ['INNER JOIN', 'LEFT JOIN depuis classes', 'CROSS JOIN', 'Aucune'], 1, 'LEFT JOIN conserve toutes les lignes de la table de gauche.'],
+    ['LIKE "Ma%" correspond à :', ['Ma exactement', 'tout texte commençant par Ma', 'tout texte finissant par Ma', 'tout texte contenant %'], 1, '% remplace n’importe quelle suite de caractères.'],
+    ['Que se passe-t-il avec DELETE FROM eleves; ?', ['Rien', 'Toutes les lignes sont supprimées', 'La table est supprimée', 'Erreur de syntaxe'], 1, 'Sans WHERE, toutes les lignes partent. La table reste.'],
+    ['Quel est le rôle d’une clé étrangère ?', ['Chiffrer', 'Référencer une ligne d’une autre table', 'Accélérer les tris', 'Rendre une colonne unique'], 1, 'Elle garantit l’intégrité référentielle.'],
+    ['Comment se protéger de l’injection SQL ?', ['Masquer les erreurs', 'Requêtes préparées', 'Mettre des guillemets', 'Utiliser HTTPS'], 1, 'Les paramètres ne sont jamais interprétés comme du SQL.'],
+    ['Classer les élèves du meilleur au moins bon :', ['ORDER BY moyenne', 'ORDER BY moyenne DESC', 'SORT BY moyenne', 'GROUP BY moyenne'], 1, 'DESC = décroissant.']],
+  td: [
+    { n: 'Échauffement', c: 'Afficher nom et prénom des élèves de la classe 3, triés par nom.', r: 'SELECT nom, prenom FROM eleves WHERE classe_id = 3 ORDER BY nom;' },
+    { n: 'Application', c: 'Afficher l’effectif et la moyenne de chaque classe, avec son libellé.', r: 'SELECT c.libelle, COUNT(e.id), AVG(e.moyenne)\nFROM classes c LEFT JOIN eleves e ON e.classe_id = c.id\nGROUP BY c.libelle;' },
+    { n: 'Application', c: 'Lister les élèves qui n’ont rendu aucun devoir (tables eleves, rendus).', r: 'SELECT e.nom FROM eleves e\nLEFT JOIN rendus r ON r.eleve_id = e.id\nWHERE r.id IS NULL;' },
+    { n: 'Approfondissement', c: 'Afficher les classes dont la moyenne est supérieure à la moyenne générale.', r: 'SELECT classe_id, AVG(moyenne) FROM eleves GROUP BY classe_id\nHAVING AVG(moyenne) > (SELECT AVG(moyenne) FROM eleves);' },
+    { n: 'Approfondissement', c: 'Réécrire en requête préparée (PHP PDO) : "SELECT * FROM users WHERE login = \'" . $login . "\'"', r: '$st = $pdo->prepare("SELECT * FROM users WHERE login = ?");\n$st->execute([$login]);' }],
+  tp: { type: 'IDE SQL', url: 'apercu-ide.html?ex=sql-select', desc: 'Une base SQLite dans le navigateur, requêtes vérifiées automatiquement.', etapes: ['Explorer les tables', '8 requêtes SELECT progressives', '3 jointures', '2 requêtes d’agrégat', 'Défi : le palmarès par classe'] },
+  plusLoin: [['SQLBolt · exercices interactifs', 'https://sqlbolt.com/'], ['Défis SQL sur HackerRank', 'https://www.hackerrank.com/domains/sql'], ['DataCamp · Introduction to SQL', 'https://www.datacamp.com/courses/introduction-to-sql']] }
+]);

portail/public/js/contenus-3.js

@@ -0,0 +1,92 @@
+// Cours complets · lot 3 : Python, Web, cryptographie
+window.CONTENUS_PRO = (window.CONTENUS_PRO || []).concat([
+{ id: 'python', match: /Python|programmation|boucle|variable|algorithm/i,
+  titre: 'Python : variables, conditions, boucles et fonctions', duree: '6 h (CM 2 h · TD 2 h · TP 2 h)', niveau: 'SNT · NSI Première · BTS SIO SLAM · BUT S1',
+  prerequis: ['Aucun'],
+  competences: ['NSI 1re · Langages et programmation', 'BTS SIO SLAM · Bloc 2 · Développer une solution applicative', 'BUT Info · Compétence « Réaliser »'],
+  intro: 'Python est le langage d’enseignement du lycée à l’université, mais aussi celui des administrateurs, des data engineers et de l’IA. Sa syntaxe courte permet de se concentrer sur l’essentiel : décomposer un problème en instructions.',
+  cm: [
+    { t: 'Variables et types', d: '20 min', html: 'Une variable associe un nom à une valeur. Le type est déduit de la valeur.', table: [['Type', 'Exemple', 'Usage'], ['int', '17', 'entiers'], ['float', '3.5', 'nombres à virgule'], ['str', '"Léa"', 'texte'], ['bool', 'True', 'vrai / faux'], ['list', '[12, 15, 9]', 'suite modifiable'], ['dict', '{"nom": "Léa"}', 'associations clé → valeur']], exemple: 'age = 17\nnom = "Léa"\nprint(f"{nom} a {age} ans")   # Léa a 17 ans\nprint(type(age))              # <class \'int\'>' },
+    { t: 'Opérateurs et entrées', d: '15 min', html: '+ − * / (division réelle), // (division entière), % (reste), ** (puissance). <code>input()</code> lit une saisie, toujours sous forme de texte : on la convertit avec <code>int()</code> ou <code>float()</code>.', attention: 'input() renvoie une chaîne : "3" + "4" donne "34", pas 7.' },
+    { t: 'Conditions', d: '20 min', html: 'Le bloc exécuté dépend d’une condition. Python délimite les blocs par l’<b>indentation</b> (4 espaces).', exemple: 'note = float(input("Note : "))\nif note >= 16:\n    print("Très bien")\nelif note >= 10:\n    print("Admis")\nelse:\n    print("À retravailler")' },
+    { t: 'Boucle for', d: '20 min', html: '<code>for</code> parcourt une séquence. <code>range(n)</code> produit 0, 1, …, n − 1 ; <code>range(a, b, pas)</code> va de a à b − 1.', exemple: 'notes = [12, 15, 9, 18]\ntotal = 0\nfor n in notes:\n    total += n\nprint(total / len(notes))   # 13.5' },
+    { t: 'Boucle while', d: '15 min', html: '<code>while</code> répète tant que la condition est vraie. On l’utilise quand on ne connaît pas le nombre de tours à l’avance.', exemple: 'essais = 0\nmdp = ""\nwhile mdp != "paillasse" and essais < 3:\n    mdp = input("Mot de passe : ")\n    essais += 1', attention: 'Si la condition ne devient jamais fausse, la boucle est infinie. Ctrl+C l’interrompt.' },
+    { t: 'Fonctions', d: '20 min', html: 'Une fonction regroupe des instructions réutilisables. Elle reçoit des <b>paramètres</b> et renvoie un résultat avec <code>return</code>. On la documente avec une docstring et on la teste avec <code>assert</code>.', exemple: 'def moyenne(valeurs):\n    """Renvoie la moyenne d\'une liste non vide."""\n    return sum(valeurs) / len(valeurs)\n\nassert moyenne([10, 20]) == 15' },
+    { t: 'Listes et dictionnaires', d: '10 min', html: 'Une liste s’indexe à partir de 0 : <code>notes[0]</code>, <code>notes[-1]</code> (dernier), <code>notes.append(14)</code>. Un dictionnaire associe des clés à des valeurs : <code>eleve["nom"]</code>.' }],
+  synthese: ['L’indentation délimite les blocs', 'input() renvoie du texte : convertir avec int() ou float()', 'for quand on connaît la séquence, while sinon', 'Une fonction = paramètres + return + tests'],
+  qcm: [
+    ['Que vaut 7 // 2 ?', ['3.5', '3', '4', '1'], 1, '// est la division entière.'],
+    ['Que vaut 7 % 2 ?', ['1', '3', '3.5', '0'], 0, '% donne le reste.'],
+    ['Combien de tours fait for i in range(2, 10, 3) ?', ['2', '3', '4', '8'], 1, 'i prend 2, 5, 8.'],
+    ['Que renvoie input() ?', ['Un int', 'Un str', 'Un float', 'Un bool'], 1, 'Toujours une chaîne.'],
+    ['Que vaut notes[-1] pour notes = [12, 15, 9] ?', ['12', '15', '9', 'Erreur'], 2, '-1 désigne le dernier élément.'],
+    ['Que fait return dans une fonction ?', ['Affiche une valeur', 'Renvoie une valeur et sort de la fonction', 'Recommence la fonction', 'Rien'], 1, 'return termine la fonction avec un résultat.'],
+    ['Quelle boucle convient pour « redemander tant que la saisie est invalide » ?', ['for', 'while', 'range', 'if'], 1, 'On ne connaît pas le nombre de tours.'],
+    ['Que produit "3" + "4" ?', ['7', '"34"', 'Erreur', '"7"'], 1, 'Concaténation de chaînes.']],
+  td: [
+    { n: 'Échauffement', c: 'Écrire un programme qui demande l’année de naissance et affiche l’âge en 2026.', r: 'annee = int(input("Année : "))\nprint(2026 - annee)' },
+    { n: 'Application', c: 'Écrire est_pair(n) qui renvoie True si n est pair, puis afficher les nombres pairs de 1 à 30.', r: 'def est_pair(n):\n    return n % 2 == 0\n\nfor i in range(1, 31):\n    if est_pair(i):\n        print(i)' },
+    { n: 'Application', c: 'Écrire mention(note) qui renvoie « TB », « B », « AB », « Passable » ou « Insuffisant ».', r: 'def mention(n):\n    if n >= 16: return "TB"\n    if n >= 14: return "B"\n    if n >= 12: return "AB"\n    if n >= 10: return "Passable"\n    return "Insuffisant"' },
+    { n: 'Approfondissement', c: 'Écrire maximum(liste) sans utiliser max(), avec ses tests.', r: 'def maximum(l):\n    m = l[0]\n    for x in l:\n        if x > m:\n            m = x\n    return m\n\nassert maximum([3, 9, 2]) == 9' },
+    { n: 'Approfondissement', c: 'Compter le nombre d’occurrences de chaque mot d’une phrase avec un dictionnaire.', r: 'compte = {}\nfor mot in phrase.split():\n    compte[mot] = compte.get(mot, 0) + 1' }],
+  tp: { type: 'IDE Python', url: 'apercu-ide.html?ex=py-pair', desc: 'Exercices corrigés par des tests automatiques, directement dans le navigateur.', etapes: ['Parité et multiples', 'Somme et moyenne d’une liste', 'Compter les voyelles', 'Jeu du nombre mystère', 'Défi : FizzBuzz'] },
+  plusLoin: [['France-IOI · parcours Python', 'https://www.france-ioi.org/'], ['HackerRank · Python', 'https://www.hackerrank.com/domains/python'], ['DataCamp · Introduction to Python', 'https://www.datacamp.com/courses/intro-to-python-for-data-science']] },
+
+{ id: 'web', match: /HTML|CSS|Le Web|HTTP|serveur web|Apache/i,
+  titre: 'Le Web : HTTP, HTML, CSS et serveur web', duree: '5 h (CM 1 h 30 · TD 1 h 30 · TP 2 h)', niveau: 'SNT · NSI Première · BTS SIO · BTS CIEL',
+  prerequis: ['Modèles OSI et TCP/IP (conseillé)'],
+  competences: ['SNT · Le Web', 'NSI 1re · Interactions entre l’homme et la machine sur le Web', 'BTS SIO · Bloc 1 · Mettre à disposition un service'],
+  intro: 'Chaque fois que vous ouvrez une page, votre navigateur échange des messages HTTP avec un serveur, puis affiche du HTML mis en forme par du CSS. Comprendre cet échange, c’est pouvoir créer un site, mais aussi le dépanner et le sécuriser.',
+  cm: [
+    { t: 'URL et architecture client-serveur', d: '15 min', html: 'Le <b>client</b> (navigateur) envoie une requête, le <b>serveur</b> (Apache, Nginx) répond. L’URL précise tout : <code>https://www.lycee.fr:443/cours/index.html?id=3</code> = protocole, nom d’hôte, port, chemin, paramètres.' },
+    { t: 'Le protocole HTTP', d: '20 min', html: 'HTTP est un protocole texte. La requête contient une méthode, un chemin et des en-têtes ; la réponse contient un code d’état, des en-têtes et un corps.', exemple: 'GET /index.html HTTP/1.1\nHost: www.lycee.fr\n\nHTTP/1.1 200 OK\nContent-Type: text/html; charset=utf-8\n\n<!doctype html>…', table: [['Code', 'Sens'], ['200', 'OK'], ['301 / 302', 'redirection'], ['403', 'accès interdit'], ['404', 'ressource introuvable'], ['500', 'erreur du serveur']] },
+    { t: 'HTML : la structure', d: '20 min', html: 'HTML décrit le sens du contenu avec des balises : titres <code>&lt;h1&gt;</code> à <code>&lt;h6&gt;</code>, paragraphes, listes, liens, images, formulaires. Une page bien structurée est lisible par les moteurs de recherche et les lecteurs d’écran.', exemple: '<!doctype html>\n<html lang="fr">\n<head><meta charset="utf-8"><title>Mon TP</title></head>\n<body>\n  <h1>Mon premier site</h1>\n  <p>Hébergé sur <a href="https://debian.org">Debian</a>.</p>\n</body>\n</html>' },
+    { t: 'CSS : la présentation', d: '20 min', html: 'Une règle CSS associe un sélecteur à des déclarations. Sélecteurs : balise (<code>p</code>), classe (<code>.carte</code>), identifiant (<code>#menu</code>). La mise en page moderne repose sur <code>display: flex</code> et <code>display: grid</code>.', exemple: '.carte {\n  border: 2px solid #000;\n  padding: 16px;\n}\n.grille { display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; }' },
+    { t: 'Formulaires : GET et POST', d: '10 min', html: 'Un formulaire envoie des données au serveur. <b>GET</b> les place dans l’URL (recherche, filtres). <b>POST</b> les place dans le corps de la requête (connexion, envoi de fichier).', attention: 'Un mot de passe ne doit jamais passer en GET : il finirait dans l’historique et les journaux du serveur.' },
+    { t: 'Héberger : le serveur web', d: '15 min', html: 'Sous Debian, <code>apt install apache2</code> installe le serveur ; les pages sont dans <code>/var/www/html</code>, la configuration dans <code>/etc/apache2</code>, les journaux dans <code>/var/log/apache2</code>. <b>HTTPS</b> ajoute TLS et un certificat (Let’s Encrypt).' }],
+  synthese: ['Client → requête HTTP → serveur → réponse avec code', 'HTML = structure, CSS = présentation', 'GET dans l’URL, POST dans le corps', 'Apache : /var/www/html et /var/log/apache2'],
+  qcm: [
+    ['Que signifie le code 403 ?', ['Introuvable', 'Accès interdit', 'Erreur serveur', 'Redirection'], 1, '403 Forbidden.'],
+    ['Quelle partie de l’URL est ?id=3 ?', ['Le chemin', 'Les paramètres', 'Le port', 'Le protocole'], 1, 'La chaîne de requête.'],
+    ['Quelle balise pour le titre principal ?', ['<title>', '<h1>', '<head>', '<header>'], 1, '<title> est le titre de l’onglet, <h1> celui de la page.'],
+    ['Quel sélecteur CSS cible class="carte" ?', ['#carte', '.carte', 'carte', '*carte'], 1, 'Le point cible une classe.'],
+    ['Pour un formulaire de connexion, on utilise :', ['GET', 'POST', 'PUT', 'HEAD'], 1, 'Les identifiants ne doivent pas apparaître dans l’URL.'],
+    ['Où Apache sert-il les pages par défaut sous Debian ?', ['/etc/apache2', '/var/www/html', '/home/www', '/srv/http'], 1, 'DocumentRoot par défaut.'],
+    ['Quel port utilise HTTPS ?', ['80', '443', '8080', '22'], 1, 'HTTP 80, HTTPS 443.']],
+  td: [
+    { n: 'Échauffement', c: 'Décomposer https://ent.lycee.fr:8443/notes?eleve=12 : protocole, hôte, port, chemin, paramètres.', r: 'https · ent.lycee.fr · 8443 · /notes · eleve=12' },
+    { n: 'Application', c: 'Écrire une page HTML avec un titre, une liste de 3 TP et un lien vers le lycée.', r: '<h1>Mes TP</h1>\n<ul><li>Terminal</li><li>Droits</li><li>Apache</li></ul>\n<a href="https://…">Mon lycée</a>' },
+    { n: 'Application', c: 'Écrire le CSS pour afficher 3 cartes côte à côte, avec une bordure noire.', r: '.grille { display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; }\n.carte { border: 2px solid #000; padding: 16px; }' },
+    { n: 'Approfondissement', c: 'Avec curl, afficher uniquement les en-têtes de réponse de https://example.org et relever le code et le type de contenu.', r: 'curl -I https://example.org → HTTP/2 200, content-type: text/html' }],
+  tp: { type: 'Lab web', url: 'apercu-lab-web.html', desc: 'Terminal et navigateur reliés : installer Apache, publier sa page, la voir en direct.', etapes: ['apt install apache2', 'Vérifier le service', 'Remplacer index.html', 'Actualiser le navigateur relié', 'Lire le journal d’accès'] },
+  plusLoin: [['MDN Web Docs (Mozilla)', 'https://developer.mozilla.org/fr/'], ['freeCodeCamp · Responsive Web Design', 'https://www.freecodecamp.org/']] },
+
+{ id: 'crypto', match: /mot de passe|hachage|chiffrement|crypto|cybers|sécurité des accès|SSH par clé/i,
+  titre: 'Cryptographie appliquée : hachage, chiffrement, clés', duree: '5 h (CM 2 h · TD 1 h 30 · TP 1 h 30)', niveau: 'BTS SIO · BTS CIEL · BUT R&T Cyber · Master cybersécurité',
+  prerequis: ['Binaire et hexadécimal', 'Le terminal Linux'],
+  competences: ['BTS SIO · Bloc 3 · Cybersécurité des services informatiques', 'BTS CIEL · C08 · Sécuriser', 'BUT R&T parcours Cyber · Compétence « Protéger »'],
+  intro: 'Mots de passe stockés, sites en HTTPS, connexions SSH, signatures de mises à jour : la cryptographie protège presque tout ce que nous faisons en ligne. L’objectif n’est pas de devenir cryptographe, mais de savoir choisir et configurer les bons outils.',
+  cm: [
+    { t: 'Les trois objectifs', d: '10 min', html: '<b>Confidentialité</b> : seul le destinataire lit le message (chiffrement). <b>Intégrité</b> : le message n’a pas été modifié (hachage, MAC). <b>Authenticité</b> : on sait qui l’a envoyé (signature, certificat).' },
+    { t: 'Les fonctions de hachage', d: '20 min', html: 'Une fonction de hachage produit une empreinte de taille fixe. Elle est à sens unique, et un seul bit changé en entrée change complètement l’empreinte. Usages : vérifier un fichier téléchargé, stocker un mot de passe, signer.', exemple: '$ echo -n "bonjour" | sha256sum\n2cb4b1431b84ec15d35ed83bb927e27e8967d75f4bcd9cc4b25c8d879ae23e18\n$ echo -n "Bonjour" | sha256sum\n9172e8eec99f144f72eca9a568759580edadb2cfd154857f07e657569493bc44', attention: 'MD5 et SHA-1 sont cassés (collisions) : ne plus les utiliser pour la sécurité.' },
+    { t: 'Stocker un mot de passe', d: '20 min', html: 'On ne stocke jamais un mot de passe en clair ni chiffré, mais un <b>hachage lent et salé</b>. Le <b>sel</b>, aléatoire et unique par compte, empêche les tables précalculées ; la lenteur (bcrypt, scrypt, Argon2) freine la force brute.', table: [['Méthode', 'Verdict'], ['En clair', 'interdit'], ['MD5 / SHA-1', 'cassé'], ['SHA-256 sans sel', 'insuffisant'], ['bcrypt, Argon2id', 'recommandé']] },
+    { t: 'Chiffrement symétrique', d: '15 min', html: 'Une même clé chiffre et déchiffre. <b>AES</b> (128 ou 256 bits) est le standard : très rapide, il chiffre les disques, les fichiers, le trafic une fois la session établie. Le problème est d’échanger la clé de façon sûre.' },
+    { t: 'Chiffrement asymétrique', d: '20 min', html: 'Chaque personne possède une paire de clés : la <b>publique</b>, diffusée, et la <b>privée</b>, gardée secrète. On chiffre avec la clé publique du destinataire ; lui seul déchiffre avec sa clé privée. À l’inverse, on <b>signe</b> avec sa clé privée et chacun vérifie avec la clé publique. Algorithmes : RSA, courbes elliptiques (Ed25519).' },
+    { t: 'En pratique : HTTPS et SSH', d: '15 min', html: '<b>HTTPS (TLS)</b> : le serveur présente un certificat signé par une autorité ; un échange asymétrique établit une clé de session, puis AES chiffre le trafic. <b>SSH</b> : l’authentification par clé remplace le mot de passe.', exemple: '$ ssh-keygen -t ed25519 -C "eleve@syllabus"\n$ ssh-copy-id eleve@192.168.10.10\n$ ssh eleve@192.168.10.10   # plus de mot de passe demandé' }],
+  synthese: ['Hachage = sens unique, pour l’intégrité', 'Mots de passe : bcrypt ou Argon2, avec sel', 'Symétrique (AES) rapide, asymétrique (RSA, Ed25519) pour échanger et signer', 'Chiffrer avec la clé publique, signer avec la clé privée'],
+  qcm: [
+    ['Quel objectif assure une fonction de hachage ?', ['Confidentialité', 'Intégrité', 'Disponibilité', 'Anonymat'], 1, 'Elle détecte toute modification.'],
+    ['Pourquoi ajouter un sel ?', ['Accélérer', 'Rendre chaque hachage unique et empêcher les tables précalculées', 'Chiffrer le mot de passe', 'Compresser'], 1, 'Deux mots de passe identiques n’ont plus la même empreinte.'],
+    ['Quel algorithme est recommandé pour stocker un mot de passe ?', ['MD5', 'SHA-1', 'Argon2id', 'AES'], 2, 'Lent, salé, conçu pour ça.'],
+    ['Pour envoyer un message confidentiel à Alice, on chiffre avec :', ['sa clé privée', 'sa clé publique', 'notre clé publique', 'un hachage'], 1, 'Seule sa clé privée le déchiffrera.'],
+    ['Pour signer un document, on utilise :', ['sa propre clé privée', 'la clé publique du destinataire', 'AES', 'SHA-1'], 0, 'Tout le monde vérifie avec notre clé publique.'],
+    ['Dans HTTPS, les données de la page sont chiffrées avec :', ['RSA uniquement', 'une clé de session symétrique', 'le certificat', 'un hachage'], 1, 'L’asymétrique sert à établir la clé de session.'],
+    ['Quelle commande génère une paire de clés SSH moderne ?', ['ssh-keygen -t ed25519', 'ssh-copy-id', 'openssl md5', 'gpg --hash'], 0, 'Ed25519 est recommandé.']],
+  td: [
+    { n: 'Échauffement', c: 'Pour chaque besoin, dire s’il faut hacher, chiffrer ou signer : stocker les mots de passe, envoyer un bulletin confidentiel, prouver qu’une mise à jour vient bien de l’éditeur.', r: 'hacher (lent, salé) · chiffrer · signer' },
+    { n: 'Application', c: 'Vérifier l’intégrité d’une image ISO téléchargée à partir de son fichier SHA256SUMS.', r: 'sha256sum -c SHA256SUMS --ignore-missing' },
+    { n: 'Application', c: 'Une base de 10 000 comptes a fuité, hachée en MD5 sans sel. Expliquer les risques et la correction.', r: 'Les mots de passe courants sont retrouvés instantanément (tables arc-en-ciel). Forcer la réinitialisation et passer à Argon2id avec sel.' },
+    { n: 'Approfondissement', c: 'Configurer un serveur SSH pour refuser les connexions par mot de passe et celles de root.', r: 'Dans /etc/ssh/sshd_config :\nPasswordAuthentication no\nPermitRootLogin no\npuis systemctl restart ssh' }],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Générer une paire de clés, se connecter sans mot de passe, durcir sshd.', etapes: ['Comparer des hachages SHA-256', 'Générer une clé Ed25519', 'Déposer la clé sur le serveur', 'Désactiver l’authentification par mot de passe', 'Vérifier dans /var/log/auth.log'] },
+  plusLoin: [['ANSSI · Guide de sélection d’algorithmes cryptographiques', 'https://cyber.gouv.fr/publications/mecanismes-cryptographiques'], ['CNIL · Recommandations sur les mots de passe', 'https://www.cnil.fr/fr/mots-de-passe-une-nouvelle-recommandation-pour-maitriser-sa-securite'], ['Root-Me · challenges cryptanalyse', 'https://www.root-me.org/']] }
+]);

portail/public/js/contenus-alias.js

@@ -0,0 +1,33 @@
+// Élargit la correspondance de cours complets existants aux chapitres qu’ils couvrent réellement
+(function () {
+var ext = {
+  terminal: /Fichiers : cp, mv|Lire et éditer|cat, less|Mode examen « Admin Linux »/i,
+  archi: /Performance : vmstat|Noyau et modules|lsmod|sysctl/i,
+  diagnostic0: /\bARP\b|ICMP, ping, traceroute|TCP et UDP : ports|Analyse de trames|Dépannage : réseau cassé|Mode examen « Réseau »/i,
+  sql: /Modèle relationnel|Agrégats : GROUP BY|DDL : CREATE|DML : INSERT|Vues, procédures|Transactions et ACID|Index, EXPLAIN/i,
+  tubes: /Expressions régulières/i,
+  binaire: /Codage des entiers/i,
+  crypto: /PKI, autorité de certification|X\.509|\bGPG\b/i,
+  pandas: /Nettoyage et qualité des données|Visualisation et tableaux de bord|Mode examen « Data »/i,
+  ml: /Sur-apprentissage|Biais, éthique|Sécurité des modèles/i,
+  neurones: /Traitement du langage et de la voix/i,
+  iot: /Node-RED|Modbus|CoAP/i,
+  python: /Mode examen « épreuve pratique NSI »|Types construits|Épreuve pratique chronométrée|Projets?$|Grand oral et projets|SAÉ|Projet technique|Projet de fin d’études|Projet data|Réaliser un développement d’application|Développement web et applications/i,
+  web2: /Photographie numérique|Histoire de l’informatique|Applications web|Développement : web, API/i,
+  iot2: /Chaîne d’information et chaîne d’énergie|Localisation et cartographie|GPS, NMEA/i,
+  ipv42: /Préparer une installation|plan d’adressage|Réseaux et infrastructure du SI/i,
+  dns2: /Présence en ligne/i,
+  sauvegarde: /Maintenir et dépanner : diagnostic, sauvegarde/i,
+  diagnostic2: /Épreuves pratiques|Épreuves blanches|Maintenir et sécuriser l’infrastructure|Administrer et sécuriser les infrastructures/i,
+  systemd: /Systèmes : Linux|Exploiter les serveurs Linux|LPIC-1|LFCS/i,
+  routagedyn: /réseau fondamental|CCNA/i,
+  vulns: /Sécurité offensive|pentest|exploitation/i,
+  ml2: /Éthique, biais et AI Act/i,
+  bigdata: /Ingénierie des données et big data/i,
+  modelisation: /Systèmes d’information et urbanisation|Génie logiciel et architecture/i
+};
+(window.CONTENUS_PRO || []).forEach(function (c) {
+  if (!c.intro) return;
+  Object.keys(ext).forEach(function (k) { if (k.replace(/\d+$/, '') === c.id) c.match = new RegExp(c.match.source + '|' + ext[k].source, 'i'); });
+});
+})();

portail/public/js/contenus-data-4.js

@@ -0,0 +1,171 @@
+// Cours complets · Data & IA lot 4 : pandas, apprentissage automatique, réseaux de neurones
+(function () {
+var reg = function (c) {
+  (window.CONTENUS_PRO = window.CONTENUS_PRO || []).unshift(c.cours);
+  (window.CONTENUS_PLUS = window.CONTENUS_PLUS || {})[c.cours.id] = c.plus;
+  (window.CONTENUS_EXEMPLES = window.CONTENUS_EXEMPLES || {})[c.cours.id] = c.exemples;
+  (window.CONTENUS_SCHEMAS = window.CONTENUS_SCHEMAS || {})[c.cours.id] = { termes: c.termes, figs: [] };
+};
+
+reg({
+cours: { id: 'pandas', match: /pandas|analyse de données|dataframe|traitement de données|données tabulaires|CSV/i,
+  titre: 'Analyse de données avec pandas : charger, nettoyer, agréger', duree: '',
+  niveau: 'NSI Terminale · BTS SIO SLAM · BUT Informatique / SD · Master data',
+  prerequis: ['Python : listes, dictionnaires, fonctions', 'SQL : SELECT, GROUP BY'],
+  competences: ['NSI · Traitement de données en tables', 'BTS SIO SLAM · Exploiter des données', 'BUT SD · Traiter des données'],
+  intro: 'Les données réelles arrivent sales : exports Pronote en point-virgule avec des virgules décimales, cellules vides, doublons, dates au format texte, noms mal orthographiés. Avant toute statistique ou tout modèle d’IA, un data engineer passe l’essentiel de son temps à les charger, les nettoyer et les restructurer. pandas est la bibliothèque Python de référence pour ce travail : elle manipule des tableaux de millions de lignes avec une syntaxe proche de SQL.',
+  cm: [
+    { t: 'Series et DataFrame', d: '', html: 'Une <b>Series</b> est une colonne typée avec un <b>index</b> ; un <b>DataFrame</b> est un tableau de Series partageant le même index. Chaque colonne a un <b>dtype</b> (int64, float64, object pour le texte, datetime64, category). Les opérations sont <b>vectorisées</b> : <code>df["note"] * 2</code> s’applique à toute la colonne en une instruction, bien plus vite qu’une boucle Python.' },
+    { t: 'Charger des données réelles', d: '', html: '<code>pd.read_csv</code> accepte de nombreux paramètres indispensables avec les exports français : <code>sep=";"</code>, <code>decimal=","</code>, <code>encoding="utf-8-sig"</code> ou <code>"latin-1"</code>, <code>parse_dates</code>, <code>dtype</code>. On inspecte toujours avant de calculer : <code>df.head()</code>, <code>df.info()</code> (types et valeurs manquantes), <code>df.describe()</code> (statistiques).', exemple: 'import pandas as pd\ndf = pd.read_csv("notes.csv", sep=";", decimal=",", encoding="utf-8-sig", parse_dates=["date"], dayfirst=True)\ndf.info()' },
+    { t: 'Sélectionner et filtrer', d: '', html: '<code>df["col"]</code> sélectionne une colonne, <code>df[["a","b"]]</code> plusieurs. <code>df.loc[lignes, colonnes]</code> sélectionne par étiquette, <code>df.iloc</code> par position. Le filtrage utilise des masques booléens combinés par <code>&amp;</code>, <code>|</code> et <code>~</code>, chaque condition entre parenthèses.', exemple: 'df.loc[(df["classe"] == "SIO1") & (df["note"] < 8), ["nom", "matiere", "note"]]', attention: 'Modifier le résultat d’un filtre (df[df.note < 8]["note"] = 8) ne modifie pas df et produit un avertissement SettingWithCopy. On écrit df.loc[df.note < 8, "note"] = 8.' },
+    { t: 'Nettoyer', d: '', html: 'Les valeurs manquantes sont <code>NaN</code>. <code>isna().sum()</code> les compte, <code>dropna</code> retire les lignes, <code>fillna</code> les remplace. Le choix est métier : une note absente n’est pas un zéro. <code>drop_duplicates</code> retire les doublons, <code>str.strip().str.upper()</code> normalise le texte, <code>astype</code> et <code>pd.to_numeric(errors="coerce")</code> convertissent les types en transformant les valeurs invalides en NaN.' },
+    { t: 'Agréger et joindre', d: '', html: '<code>groupby</code> découpe, applique, combine, exactement comme GROUP BY en SQL : <code>df.groupby("classe")["note"].agg(["mean","median","count"])</code>. <code>pivot_table</code> produit un tableau croisé. <code>merge</code> joint deux DataFrame comme un JOIN, avec <code>how="left"</code> pour garder toutes les lignes de gauche et <code>validate="m:1"</code> pour vérifier qu’on ne multiplie pas les lignes par erreur.' },
+    { t: 'Performances et export', d: '', html: 'Sur de gros volumes : lire seulement les colonnes utiles (<code>usecols</code>), typer le texte répétitif en <code>category</code>, éviter <code>apply</code> ligne à ligne au profit des opérations vectorisées, et stocker les résultats intermédiaires en <b>Parquet</b>, format colonne compressé et typé, bien plus rapide que le CSV. L’export final se fait avec <code>to_csv</code>, <code>to_excel</code> ou directement dans une base avec <code>to_sql</code>.' }
+  ],
+  synthese: ['DataFrame = colonnes typées partageant un index ; opérations vectorisées', 'read_csv avec sep, decimal, encoding, parse_dates', 'Inspecter : head, info, describe, isna().sum()', 'loc pour sélectionner et modifier ; masques entre parenthèses', 'Valeurs manquantes : décision métier', 'groupby, pivot_table, merge avec validate', 'Parquet et category pour les gros volumes'],
+  qcm: [
+    ['Quel paramètre pour lire « 12,5 » comme un nombre ?', ['sep=","', 'decimal=","', 'dtype=float', 'encoding'], 1, 'Virgule décimale française.'],
+    ['Que montre df.info() ?', ['Les 5 premières lignes', 'Types et nombre de valeurs non nulles par colonne', 'La moyenne', 'Le graphique'], 1, 'Premier réflexe.'],
+    ['Comment combiner deux conditions ?', ['and', '(c1) & (c2)', 'c1 && c2', 'c1 + c2'], 1, 'Opérateurs bit à bit sur des masques.'],
+    ['Une note absente doit-elle devenir 0 ?', ['Toujours', 'Non, c’est une décision métier (absence ≠ zéro)', 'Oui avec fillna', 'Peu importe'], 1, 'Elle fausserait la moyenne.'],
+    ['Équivalent pandas de GROUP BY ?', ['merge', 'groupby', 'pivot', 'concat'], 1, 'Découper, appliquer, combiner.'],
+    ['Pourquoi préférer Parquet au CSV pour les fichiers intermédiaires ?', ['Plus lisible', 'Typé, compressé, lecture par colonne rapide', 'Obligatoire', 'Compatible Excel'], 1, 'Format colonne.']
+  ],
+  td: [
+    { n: 'Application', c: 'Charger l’export notes.csv (point-virgule, virgule décimale), afficher le nombre de notes manquantes par matière, puis la moyenne par classe et par matière en tableau croisé.', r: 'df = pd.read_csv("notes.csv", sep=";", decimal=",")\ndf.groupby("matiere")["note"].apply(lambda s: s.isna().sum())\ndf.pivot_table(index="classe", columns="matiere", values="note", aggfunc="mean").round(1)' },
+    { n: 'Application', c: 'Joindre notes.csv et eleves.csv sur l’identifiant, en vérifiant qu’aucun élève n’est dupliqué, et lister les élèves sans aucune note.', r: 'm = eleves.merge(notes, on="id", how="left", validate="1:m")\nm[m["note"].isna()].drop_duplicates("id")[["nom","prenom"]]' },
+    { n: 'Approfondissement', c: 'Repérer les élèves dont la moyenne a baissé de plus de 3 points entre le 1er et le 2e trimestre.', r: 'p = df.pivot_table(index="id", columns="trimestre", values="note", aggfunc="mean")\np[(p[1] - p[2]) > 3]' }
+  ],
+  tp: { type: 'IDE Python', url: 'apercu-ide.html', desc: 'Jeu de données anonymisé d’un établissement, tests automatiques.', etapes: ['Charger et inspecter', 'Nettoyer types et doublons', 'Agrégats par classe', 'Jointure avec les effectifs', 'Exporter un bilan en CSV'] },
+  plusLoin: [['Documentation pandas', 'https://pandas.pydata.org/docs/'], ['DataCamp · Data Manipulation with pandas', 'https://www.datacamp.com/courses/data-manipulation-with-pandas'], ['data.gouv.fr · jeux de données ouverts', 'https://www.data.gouv.fr/']] },
+plus: { cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Le tableau de bord du conseil de classe affiche une moyenne générale de 4,2 pour la SIO1, alors que les enseignants constatent des moyennes autour de 12. Trouver et corriger l’erreur du script d’analyse.', etapes: [
+    ['Inspecter les types', 'df.info()\n note   1840 non-null  object\n→ La colonne note est du texte : read_csv n’a pas reconnu la virgule décimale.'],
+    ['Voir ce qui a été calculé', 'df["note"].head(3)\n0    12,5\n1      14\n2    abs\n→ Des valeurs « abs » et des virgules. Le script faisait pd.to_numeric(errors="coerce") : « 12,5 » et « abs » devenaient NaN puis étaient remplacés par 0 avec fillna(0).'],
+    ['Corriger le chargement', 'df = pd.read_csv("notes.csv", sep=";", decimal=",", na_values=["abs", "ABS", "disp"])\ndf["note"].dtype\nfloat64\n→ Les absences deviennent des valeurs manquantes, pas des zéros.'],
+    ['Recalculer', 'df.groupby("classe")["note"].mean().round(2)\nSIO1    11.87\n→ Moyenne cohérente avec le terrain.'],
+    ['Prévenir', '→ Ajout de contrôles automatiques dans le script : assert df["note"].between(0, 20).all(), et journalisation du nombre d’absences traitées. Aucun fillna(0) sur des notes.']
+  ] },
+  erreurs: ['Oublier decimal="," sur un export français', 'Remplacer les absences par zéro', 'Modifier un filtre au lieu d’utiliser loc', 'Boucler ligne par ligne avec iterrows', 'Joindre sans vérifier les doublons', 'Calculer sans avoir regardé info()'],
+  memo: [['Instruction', 'Usage'], ['pd.read_csv(f, sep=";", decimal=",")', 'lire un export français'], ['df.head() · df.info() · df.describe()', 'inspecter'], ['df.isna().sum()', 'valeurs manquantes par colonne'], ['df.loc[masque, cols]', 'filtrer et sélectionner'], ['df.groupby(k)[c].agg([...])', 'agréger'], ['df.pivot_table(index, columns, values)', 'tableau croisé'], ['a.merge(b, on, how, validate)', 'joindre'], ['df.drop_duplicates()', 'retirer les doublons'], ['pd.to_numeric(s, errors="coerce")', 'convertir en nombre'], ['df.to_parquet() · df.to_csv()', 'exporter']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Écrire le chargement d’un export fourni. (3 pts)', 'Nettoyer les valeurs manquantes en justifiant. (4 pts)', 'Produire trois agrégats demandés. (6 pts)', 'Joindre deux tables et détecter les incohérences. (4 pts)', 'Expliquer vectorisation et Parquet. (3 pts)'], r: ['read_csv paramétré', 'na_values, pas de 0', 'groupby / pivot_table', 'merge validate, how', 'voir cours'] },
+  prof: { deroule: [['Ouverture', 'Un vrai export raté projeté'], ['Cours', 'DataFrame, chargement, inspection'], ['Pratique', 'Nettoyage dans l’IDE'], ['Pratique', 'Agrégats et jointures'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : cellules à trous. Élèves avancés : Parquet, polars, DataCamp.', eval: 'Tests IDE, sujet type.' } },
+exemples: [
+ ['Inspecter un export', 'Premier chargement.', 'df.info()', 'RangeIndex: 1840 entries\n #  Column   Non-Null Count  Dtype\n 0  nom      1840 non-null   object\n 1  classe   1840 non-null   object\n 2  note     1712 non-null   float64\n 3  date     1840 non-null   datetime64[ns]', '128 notes manquantes (absences), types corrects : on peut calculer.'],
+ ['Compter par groupe', 'Effectifs par classe.', 'df.groupby("classe")["nom"].nunique()', 'classe\nSIO1    31\nSIO2    27', 'nunique compte les élèves distincts, pas le nombre de lignes de notes.'],
+ ['Détecter des doublons', 'Un élève apparaît deux fois.', 'eleves[eleves.duplicated("ine", keep=False)]', '      ine        nom     prenom\n12  070123456AB  MARTIN   Léa\n88  070123456AB  Martin   Lea', 'Même identifiant INE, casse et accents différents : on normalise avant de dédoublonner.'],
+ ['Jointure qui multiplie les lignes', 'Le nombre de lignes explose après merge.', 'notes.merge(eleves, on="nom", validate="m:1")', 'MergeError: Merge keys are not unique in right dataset; not a many-to-one merge', 'Deux élèves portent le même nom : on joint sur l’identifiant, jamais sur le nom.'],
+ ['Tableau croisé', 'Bilan pour le conseil.', 'df.pivot_table(index="classe", columns="matiere", values="note", aggfunc="mean").round(1)', 'matiere  Maths  Réseaux  Dev\nclasse\nSIO1     11.2   12.8     10.4\nSIO2     12.0   13.1     12.7', 'Le Dev de SIO1 est le point faible, piste pour le conseil.'],
+ ['Mesurer un gain de performance', 'Script lent sur 2 millions de lignes.', '%timeit df["total"] = df.apply(lambda r: r.note * r.coef, axis=1)\n%timeit df["total"] = df["note"] * df["coef"]', '8.41 s ± 120 ms\n6.2 ms ± 0.3 ms', 'La version vectorisée est plus de mille fois plus rapide.']
+],
+termes: ['pandas', 'DataFrame', 'Series', 'index', 'dtype', 'read_csv', 'loc', 'iloc', 'NaN', 'isna', 'fillna', 'dropna', 'groupby', 'agg', 'pivot_table', 'merge', 'validate', 'drop_duplicates', 'Parquet', 'category', 'vectorisé']
+});
+
+reg({
+cours: { id: 'ml', match: /apprentissage automatique|machine learning|scikit|régression|classification|intelligence artificielle|\bIA\b/i,
+  titre: 'Apprentissage automatique : du jeu de données au modèle évalué', duree: '',
+  niveau: 'NSI Terminale (k plus proches voisins) · BUT SD / Informatique · École d’ingénieurs · Master IA',
+  prerequis: ['Analyse de données avec pandas', 'Statistiques descriptives'],
+  competences: ['NSI · Algorithme des k plus proches voisins', 'BUT SD · Modéliser', 'Master · Concevoir un système d’apprentissage'],
+  intro: 'Un modèle d’apprentissage automatique apprend une règle à partir d’exemples plutôt qu’on ne la lui programme. Il détecte un courriel frauduleux, prédit le risque de décrochage d’un élève ou reconnaît un caractère manuscrit. Mais un modèle mal évalué donne des chiffres flatteurs et des décisions fausses. Ce module suit la démarche complète avec scikit-learn : préparer les données, séparer apprentissage et test, choisir un modèle, mesurer correctement, et comprendre les limites éthiques et réglementaires.',
+  cm: [
+    { t: 'Apprendre à partir d’exemples', d: '', html: 'En <b>apprentissage supervisé</b>, chaque exemple a des <b>variables explicatives</b> (X) et une <b>cible</b> (y) connue : on apprend à prédire y à partir de X. C’est une <b>classification</b> si y est une catégorie (décroche / ne décroche pas), une <b>régression</b> si y est un nombre (note finale). En <b>apprentissage non supervisé</b>, il n’y a pas de cible : on cherche une structure, par exemple des groupes d’élèves aux profils proches (clustering).' },
+    { t: 'Séparer apprentissage et test', d: '', html: 'Un modèle évalué sur les données qui ont servi à l’entraîner paraît toujours excellent : il les a apprises par cœur. On sépare donc un <b>jeu d’apprentissage</b> et un <b>jeu de test</b> jamais vu (<code>train_test_split</code>, souvent 80/20, stratifié pour garder la proportion des classes). Pour régler les hyperparamètres sans toucher au test, on utilise la <b>validation croisée</b> : l’apprentissage est découpé en k parts, chacune servant tour à tour de validation.<br><br>Le <b>surapprentissage</b> (overfitting) se voit quand le score d’apprentissage est très bon et celui de test nettement moins bon ; le <b>sous-apprentissage</b> quand les deux sont mauvais.', attention: 'La fuite de données (data leakage) fausse tout : normaliser toutes les données avant la séparation, ou inclure une variable connue seulement après coup (la note finale pour prédire le décrochage), donne un modèle parfait en test et inutile en réalité.' },
+    { t: 'Préparer les variables', d: '', html: 'Les modèles attendent des nombres. On <b>encode</b> les catégories (OneHotEncoder), on <b>normalise</b> les échelles (StandardScaler) pour les modèles sensibles aux distances comme les k plus proches voisins, on traite les valeurs manquantes (SimpleImputer). Un <b>Pipeline</b> enchaîne ces étapes et le modèle : il apprend les paramètres de préparation sur l’apprentissage uniquement et les applique au test, ce qui évite la fuite de données.', exemple: 'from sklearn.pipeline import make_pipeline\nfrom sklearn.compose import make_column_transformer\nfrom sklearn.preprocessing import StandardScaler, OneHotEncoder\nfrom sklearn.ensemble import RandomForestClassifier\n\nprep = make_column_transformer(\n    (StandardScaler(), ["absences", "moyenne_t1", "retards"]),\n    (OneHotEncoder(handle_unknown="ignore"), ["filiere"]))\nmodele = make_pipeline(prep, RandomForestClassifier(n_estimators=300, random_state=0))\nmodele.fit(X_train, y_train)' },
+    { t: 'Quelques modèles de référence', d: '', html: 'Les <b>k plus proches voisins</b> (au programme de NSI) classent un exemple selon la classe majoritaire de ses k voisins les plus proches. La <b>régression linéaire</b> et la <b>régression logistique</b> sont simples, rapides et interprétables. Les <b>arbres de décision</b> produisent des règles lisibles ; les <b>forêts aléatoires</b> et le <b>gradient boosting</b> en combinent des centaines et sont souvent les plus performants sur des données tabulaires. On commence toujours par une <b>référence simple</b> (prédire la classe majoritaire) pour savoir si le modèle apporte vraiment quelque chose.' },
+    { t: 'Mesurer correctement', d: '', html: 'L’<b>exactitude</b> (accuracy) trompe quand les classes sont déséquilibrées : si 5 % des élèves décrochent, prédire « personne ne décroche » donne 95 %. La <b>matrice de confusion</b> distingue vrais et faux positifs et négatifs. La <b>précision</b> mesure la part de vrais positifs parmi les alertes, le <b>rappel</b> la part des vrais cas détectés, le <b>F1</b> leur moyenne harmonique. Le choix dépend du coût des erreurs : manquer un élève en difficulté coûte plus cher qu’un entretien inutile, on privilégie donc le rappel. En régression, on utilise l’erreur absolue moyenne (MAE) ou la racine de l’erreur quadratique (RMSE).' },
+    { t: 'Éthique et cadre légal', d: '', html: 'Un modèle reproduit les biais de ses données : entraîné sur des décisions passées discriminantes, il les automatise. Pour des décisions qui touchent des personnes, et a fortiori des mineurs, on vérifie les performances par sous-groupe, on garde un humain dans la décision et on explique les facteurs du modèle. Le <b>RGPD</b> encadre les décisions individuelles automatisées (article 22) et impose la minimisation des données ; le <b>règlement européen sur l’IA</b> (AI Act) classe l’éducation parmi les usages à haut risque, soumis à des obligations de documentation, de qualité des données et de supervision humaine.' }
+  ],
+  synthese: ['Supervisé (classification, régression) ou non supervisé', 'Toujours évaluer sur un jeu de test jamais vu ; validation croisée pour régler', 'Pipeline pour préparer sans fuite de données', 'Partir d’une référence simple', 'Accuracy trompeuse si déséquilibre : matrice de confusion, précision, rappel, F1', 'Biais, supervision humaine, RGPD article 22, AI Act'],
+  qcm: [
+    ['Prédire la note finale d’un élève est une :', ['classification', 'régression', 'clustering', 'réduction de dimension'], 1, 'La cible est un nombre.'],
+    ['Score d’apprentissage 0,99, score de test 0,71 : c’est', ['du sous-apprentissage', 'du surapprentissage', 'normal', 'une fuite de données'], 1, 'Le modèle a appris par cœur.'],
+    ['5 % de décrocheurs : un modèle qui prédit « aucun » a une accuracy de :', ['5 %', '50 %', '95 %', '0 %'], 2, 'D’où les autres métriques.'],
+    ['Quelle métrique privilégier pour ne manquer aucun élève en difficulté ?', ['Précision', 'Rappel', 'Accuracy', 'MAE'], 1, 'Part des vrais cas détectés.'],
+    ['Pourquoi utiliser un Pipeline ?', ['Esthétique', 'Pour appliquer la préparation apprise sur l’apprentissage seulement, sans fuite', 'Plus rapide', 'Obligatoire'], 1, 'Évite la fuite de données.'],
+    ['Selon l’AI Act, l’usage de l’IA dans l’éducation est classé :', ['interdit', 'à haut risque', 'sans risque', 'non concerné'], 1, 'Obligations renforcées.']
+  ],
+  td: [
+    { n: 'Échauffement', c: 'Implémenter les k plus proches voisins en Python pur pour classer un point à partir d’une liste de points étiquetés.', r: 'def knn(pts, x, k):\n    d = sorted(pts, key=lambda p: (p[0]-x[0])**2 + (p[1]-x[1])**2)[:k]\n    etiq = [p[2] for p in d]\n    return max(set(etiq), key=etiq.count)' },
+    { n: 'Application', c: 'Entraîner une régression logistique et une forêt aléatoire sur le jeu fourni, comparer leur F1 en validation croisée à 5 plis, puis évaluer la meilleure sur le test.', r: 'from sklearn.model_selection import cross_val_score\nfor m in [logit, foret]:\n    print(cross_val_score(m, X_train, y_train, cv=5, scoring="f1").mean())\nmeilleur.fit(X_train, y_train); f1_score(y_test, meilleur.predict(X_test))' },
+    { n: 'Approfondissement', c: 'Vérifier si le modèle de détection du décrochage a un rappel différent pour les filles et les garçons, et proposer une conduite à tenir.', r: 'for g in ["F","M"]: m = X_test["sexe"] == g; recall_score(y_test[m], pred[m])\nSi écart important : examiner les données, rééquilibrer, ajuster le seuil par sous-groupe avec prudence, documenter, et garder la décision humaine.' }
+  ],
+  tp: { type: 'IDE Python', url: 'apercu-ide.html', desc: 'scikit-learn dans le navigateur (Pyodide), jeu de données synthétique.', etapes: ['Séparer apprentissage et test', 'Construire un Pipeline', 'Comparer trois modèles en validation croisée', 'Lire la matrice de confusion', 'Analyser les performances par sous-groupe'] },
+  plusLoin: [['scikit-learn · guide utilisateur', 'https://scikit-learn.org/stable/user_guide.html'], ['CNIL · IA : dossiers et recommandations', 'https://www.cnil.fr/fr/intelligence-artificielle'], ['DataCamp · Supervised Learning with scikit-learn', 'https://www.datacamp.com/courses/supervised-learning-with-scikit-learn'], ['Kaggle Learn · Intro to Machine Learning', 'https://www.kaggle.com/learn/intro-to-machine-learning']] },
+plus: { cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Un prototype de détection du décrochage affiche 98 % d’exactitude et 0,97 de F1 en test. Mis en service sur la nouvelle année, il ne détecte presque aucun élève. Trouver pourquoi.', etapes: [
+    ['Regarder les variables', 'modele[-1].feature_importances_ triées\nnb_absences_annee   0.71\nmoyenne_t1          0.08\n→ Le nombre d’absences sur l’année entière domine. En septembre, cette variable n’est pas encore connue.'],
+    ['Identifier la fuite', '→ La variable résume toute l’année, y compris la période où l’élève a déjà décroché : le modèle « prédit » à partir d’un effet du décrochage. C’est une fuite de données temporelle.'],
+    ['Reconstruire le jeu', 'Variables limitées à ce qui est connu au 15 octobre : absences et retards de septembre, moyenne des premières évaluations, filière.\nSéparation temporelle : apprentissage sur 2022-2024, test sur 2025.\n→ On évalue comme on utilisera le modèle.'],
+    ['Réévaluer', 'F1 test : 0.58, rappel 0.71, précision 0.49\n→ Scores plus modestes mais honnêtes : le modèle repère 71 % des futurs décrocheurs, avec une alerte sur deux justifiée.'],
+    ['Décider de l’usage', '→ Usage limité à une aide au repérage pour l’équipe de vie scolaire, jamais une décision automatique ; analyse d’impact (AIPD) et information des familles. Documentation du modèle et de ses limites.']
+  ] },
+  erreurs: ['Évaluer sur les données d’apprentissage', 'Normaliser avant de séparer', 'Utiliser une variable connue après coup', 'Se fier à l’accuracy sur des classes déséquilibrées', 'Pas de référence simple', 'Décision automatique sur des élèves sans supervision humaine'],
+  memo: [['Instruction', 'Usage'], ['train_test_split(X, y, test_size=0.2, stratify=y)', 'séparer'], ['make_pipeline(prep, modele)', 'préparer sans fuite'], ['cross_val_score(m, X, y, cv=5, scoring="f1")', 'validation croisée'], ['GridSearchCV', 'régler les hyperparamètres'], ['DummyClassifier', 'référence simple'], ['confusion_matrix · classification_report', 'mesurer'], ['precision_score · recall_score · f1_score', 'métriques'], ['mean_absolute_error', 'régression'], ['feature_importances_ · permutation_importance', 'comprendre le modèle']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Distinguer classification, régression, clustering. (3 pts)', 'Construire et évaluer un pipeline sur un jeu fourni. (8 pts)', 'Interpréter une matrice de confusion. (4 pts)', 'Identifier une fuite de données dans un cas donné. (3 pts)', 'Citer deux obligations RGPD ou AI Act. (2 pts)'], r: ['voir cours', 'split, pipeline, cv, test', 'précision, rappel', 'variable postérieure', 'art. 22, haut risque'] },
+  prof: { deroule: [['Ouverture', 'Un modèle à 95 % qui ne sert à rien'], ['Cours', 'Supervisé, séparation, métriques'], ['Pratique', 'kNN à la main'], ['Pratique', 'Pipeline scikit-learn'], ['Débat', 'IA et décisions sur les élèves'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : notebook guidé. Élèves avancés : gradient boosting, interprétabilité (SHAP), Kaggle.', eval: 'Notebook rendu, sujet type.' } },
+exemples: [
+ ['Séparer proprement', 'Préparer l’évaluation.', 'X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, stratify=y, random_state=0)\nprint(y_tr.mean(), y_te.mean())', '0.0512 0.0508', 'stratify garde la même proportion de cas positifs dans les deux jeux.'],
+ ['Référence simple', 'Savoir si le modèle apporte quelque chose.', 'DummyClassifier(strategy="most_frequent").fit(X_tr, y_tr).score(X_te, y_te)', '0.949', 'Toute accuracy inférieure à 95 % est pire que ne rien faire : il faut regarder rappel et F1.'],
+ ['Matrice de confusion', 'Évaluer le modèle.', 'confusion_matrix(y_te, pred)', '[[1782   31]\n [  28   69]]', '69 décrocheurs repérés sur 97 (rappel 0,71), 31 fausses alertes sur 100 alertes (précision 0,69).'],
+ ['Rapport complet', 'Présenter les résultats.', 'print(classification_report(y_te, pred, target_names=["reste", "décroche"]))', '              precision  recall  f1-score  support\n       reste       0.98    0.98      0.98     1813\n    décroche       0.69    0.71      0.70       97', 'La classe minoritaire est celle qui compte ; ses scores sont bien plus faibles que ceux de la majorité.'],
+ ['Détecter le surapprentissage', 'Arbre de décision très profond.', 'arbre.score(X_tr, y_tr), arbre.score(X_te, y_te)', '(1.0, 0.89)', 'Score parfait en apprentissage, bien moindre en test : on limite max_depth ou on passe à une forêt aléatoire.'],
+ ['Importance par permutation', 'Expliquer le modèle à l’équipe.', 'r = permutation_importance(modele, X_te, y_te, scoring="f1", n_repeats=10)\nsorted(zip(r.importances_mean, X_te.columns), reverse=True)[:3]', '[(0.21, "absences_sept"), (0.09, "moyenne_eval1"), (0.04, "retards_sept")]', 'Les absences de septembre sont le premier signal, cohérent avec l’expérience des CPE.']
+],
+termes: ['apprentissage supervisé', 'classification', 'régression', 'clustering', 'jeu d’apprentissage', 'jeu de test', 'validation croisée', 'surapprentissage', 'fuite de données', 'Pipeline', 'StandardScaler', 'OneHotEncoder', 'k plus proches voisins', 'forêt aléatoire', 'matrice de confusion', 'précision', 'rappel', 'F1', 'accuracy', 'scikit-learn', 'AI Act', 'RGPD']
+});
+
+reg({
+cours: { id: 'neurones', match: /réseaux? de neurones|deep learning|apprentissage profond|PyTorch|TensorFlow|OCR|reconnaissance vocale/i,
+  titre: 'Réseaux de neurones : principe, entraînement et applications (OCR, voix)', duree: '',
+  niveau: 'BUT Informatique / SD · École d’ingénieurs · Master IA',
+  prerequis: ['Apprentissage automatique', 'Dérivées et matrices'],
+  competences: ['Master · Concevoir et entraîner un modèle d’apprentissage profond', 'École d’ingénieurs · Intégrer un modèle en production'],
+  intro: 'Reconnaître un caractère manuscrit, transcrire une voix, décrire une image : ces tâches, longtemps hors de portée des programmes classiques, sont aujourd’hui résolues par des réseaux de neurones. Ce module explique ce qu’est réellement un réseau, comment il apprend par descente de gradient et rétropropagation, quelles architectures conviennent aux images et au son, et comment on met un tel modèle en production.',
+  cm: [
+    { t: 'Le neurone et la couche', d: '', html: 'Un neurone artificiel calcule une somme pondérée de ses entrées, ajoute un biais et applique une <b>fonction d’activation</b> non linéaire : ReLU (max(0, x)) dans les couches cachées, sigmoïde ou softmax en sortie pour obtenir des probabilités. Une <b>couche dense</b> est un produit matriciel suivi d’une activation. Empiler des couches permet de représenter des fonctions très complexes ; sans non-linéarité, plusieurs couches se réduiraient à une seule transformation linéaire.' },
+    { t: 'Apprendre : perte, gradient, rétropropagation', d: '', html: 'L’entraînement minimise une <b>fonction de perte</b> (entropie croisée pour la classification, erreur quadratique pour la régression). La <b>descente de gradient</b> ajuste chaque poids dans la direction qui fait baisser la perte, d’un pas fixé par le <b>taux d’apprentissage</b>. La <b>rétropropagation</b> calcule efficacement ces gradients couche par couche grâce à la règle de dérivation des fonctions composées. On traite les données par <b>lots</b> (mini-batches) et on parcourt plusieurs fois le jeu (<b>époques</b>). Un taux trop grand fait diverger, trop petit rend l’apprentissage interminable.' },
+    { t: 'Images : réseaux convolutifs', d: '', html: 'Une image de 28×28 pixels a 784 entrées ; une photo en a des millions. Les <b>réseaux convolutifs</b> (CNN) appliquent de petits filtres qui glissent sur l’image et détectent des motifs locaux (bords, courbes), puis des motifs de plus en plus abstraits d’une couche à l’autre. Les poids d’un filtre sont partagés sur toute l’image, ce qui réduit énormément le nombre de paramètres et rend le réseau insensible à la position du motif. C’est le cœur des systèmes d’<b>OCR</b> : détection des zones de texte, puis reconnaissance des caractères.' },
+    { t: 'Séquences : son, texte et transformeurs', d: '', html: 'Le son est une séquence : on le convertit d’abord en <b>spectrogramme</b> (énergie par fréquence au cours du temps, souvent en échelle de Mel), que l’on traite comme une image ou comme une séquence. Les réseaux récurrents ont longtemps servi à la reconnaissance vocale ; ils sont aujourd’hui largement remplacés par les <b>transformeurs</b>, fondés sur le mécanisme d’<b>attention</b> qui relie chaque élément de la séquence à tous les autres. Whisper (transcription) et les grands modèles de langage reposent sur cette architecture.' },
+    { t: 'Entraîner en pratique', d: '', html: 'On entraîne rarement de zéro : l’<b>apprentissage par transfert</b> part d’un modèle pré-entraîné sur un grand corpus et l’ajuste (fine-tuning) sur ses propres données. Contre le surapprentissage : <b>augmentation de données</b> (rotations, bruit, variations de vitesse pour la voix), <b>dropout</b>, <b>arrêt précoce</b> quand la perte de validation remonte. Les calculs se font sur GPU ; un suivi des courbes de perte d’apprentissage et de validation est indispensable.' },
+    { t: 'Mettre en production', d: '', html: 'Un modèle en production doit être rapide et léger : export en format standard (ONNX), <b>quantification</b> (poids en 8 bits au lieu de 32), exécution sur CPU si possible. On surveille la <b>dérive</b> : les données réelles s’éloignent de celles de l’entraînement (nouvelle police de caractères, micro différent), et les performances baissent sans erreur visible. Côté réglementaire, la voix est une donnée biométrique potentielle au sens du RGPD : traitement local de préférence, finalité limitée, conservation minimale.' }
+  ],
+  synthese: ['Neurone = somme pondérée + biais + activation non linéaire', 'Perte, descente de gradient, rétropropagation, lots et époques', 'CNN pour les images et l’OCR ; spectrogrammes et transformeurs pour la voix', 'Transfert, augmentation, dropout, arrêt précoce', 'Production : ONNX, quantification, surveillance de la dérive, RGPD'],
+  qcm: [
+    ['Pourquoi une activation non linéaire ?', ['Pour accélérer', 'Sinon les couches se réduisent à une seule transformation linéaire', 'Pour normaliser', 'Obligatoire en Python'], 1, 'La non-linéarité donne la puissance.'],
+    ['Que calcule la rétropropagation ?', ['Les prédictions', 'Les gradients de la perte par rapport aux poids', 'Le taux d’apprentissage', 'Les lots'], 1, 'Règle de dérivation en chaîne.'],
+    ['Avantage principal d’une convolution sur une image ?', ['Couleurs', 'Partage des poids et détection de motifs locaux', 'Plus de paramètres', 'Aucun'], 1, 'Moins de paramètres, invariance à la position.'],
+    ['Comment représente-t-on souvent le son pour un réseau ?', ['En texte', 'En spectrogramme', 'En binaire brut', 'En CSV'], 1, 'Temps × fréquence.'],
+    ['La perte de validation remonte alors que celle d’apprentissage baisse :', ['tout va bien', 'surapprentissage, arrêt précoce', 'taux trop faible', 'données manquantes'], 1, 'On arrête ou on régularise.'],
+    ['Qu’est-ce que la quantification ?', ['Compter les données', 'Réduire la précision des poids pour alléger le modèle', 'Ajouter des couches', 'Chiffrer le modèle'], 1, 'Souvent 8 bits.']
+  ],
+  td: [
+    { n: 'Application', c: 'Calculer à la main la sortie d’un neurone : entrées (1, 2), poids (0,5 ; −1), biais 0,2, activation ReLU.', r: '0,5 × 1 + (−1) × 2 + 0,2 = −1,3 → ReLU = 0' },
+    { n: 'Application', c: 'Écrire en PyTorch un réseau à deux couches pour MNIST (784 → 128 → 10) et sa boucle d’entraînement.', r: 'model = nn.Sequential(nn.Flatten(), nn.Linear(784,128), nn.ReLU(), nn.Linear(128,10))\nopt = torch.optim.Adam(model.parameters(), 1e-3); loss = nn.CrossEntropyLoss()\nfor x, y in loader: opt.zero_grad(); l = loss(model(x), y); l.backward(); opt.step()' },
+    { n: 'Approfondissement', c: 'Un OCR entraîné sur des copies scannées échoue sur des photos prises au téléphone. Proposer trois actions.', r: 'Augmentation (perspective, flou, éclairage) · fine-tuning sur un échantillon de photos annotées · prétraitement (redressement, binarisation) et surveillance de la dérive.' }
+  ],
+  tp: { type: 'IDE Python', url: 'apercu-ide.html', desc: 'Réseau dense sur des chiffres manuscrits, dans le navigateur.', etapes: ['Visualiser le jeu de données', 'Construire le réseau', 'Tracer les courbes de perte', 'Mesurer l’exactitude par chiffre', 'Tester l’augmentation de données'] },
+  plusLoin: [['3Blue1Brown · Neural networks (vidéos)', 'https://www.3blue1brown.com/topics/neural-networks'], ['Tutoriels PyTorch', 'https://pytorch.org/tutorials/'], ['Fidle (CNRS) · formation deep learning en français', 'https://fidle.cnrs.fr/'], ['CNIL · la voix, une donnée à protéger', 'https://www.cnil.fr/']] },
+plus: { cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Le module de transcription vocale des consignes, déployé en salle de TP, fonctionnait bien en tests mais produit des transcriptions incohérentes depuis l’installation des nouveaux casques.', etapes: [
+    ['Comparer les entrées', 'soxi test_ancien.wav nouveau.wav\nSample Rate : 16000 | Sample Rate : 48000\n→ Les nouveaux casques enregistrent en 48 kHz ; le modèle attend du 16 kHz.'],
+    ['Vérifier le prétraitement', '→ Le code passait l’audio brut au modèle sans rééchantillonnage : le spectrogramme calculé était « compressé » en fréquence, comme une voix accélérée trois fois.'],
+    ['Corriger', 'audio = torchaudio.functional.resample(audio, orig_freq=sr, new_freq=16000)\n→ Rééchantillonnage systématique à l’entrée, avec contrôle du format.'],
+    ['Valider', 'WER sur 50 consignes de test : 38 % → 7 %\n→ Le taux d’erreur de mots revient au niveau des tests.'],
+    ['Prévenir', '→ Assertion sur la fréquence et le nombre de canaux, surveillance du WER sur un échantillon hebdomadaire, et traitement local sans conservation des enregistrements.']
+  ] },
+  erreurs: ['Pas de jeu de validation', 'Taux d’apprentissage choisi au hasard', 'Ignorer les courbes de perte', 'Prétraitement différent entre entraînement et production', 'Entraîner de zéro sans nécessité', 'Envoyer des voix d’élèves à un service tiers sans analyse RGPD'],
+  memo: [['Élément', 'À retenir'], ['nn.Linear · nn.Conv2d', 'couche dense · convolution'], ['nn.ReLU · softmax', 'activations'], ['nn.CrossEntropyLoss', 'perte de classification'], ['torch.optim.Adam(lr=1e-3)', 'optimiseur courant'], ['loss.backward() · opt.step()', 'rétropropagation et mise à jour'], ['model.eval() · torch.no_grad()', 'mode inférence'], ['Dropout · EarlyStopping', 'contre le surapprentissage'], ['torch.onnx.export', 'export pour la production'], ['WER · CER', 'erreurs de mots et de caractères (voix, OCR)']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Calculer la sortie d’un petit réseau. (4 pts)', 'Expliquer descente de gradient et rétropropagation. (5 pts)', 'Justifier le choix d’un CNN pour l’OCR. (4 pts)', 'Analyser des courbes de perte fournies. (4 pts)', 'Citer deux précautions de mise en production. (3 pts)'], r: ['produit matriciel + activation', 'voir cours', 'motifs locaux, partage des poids', 'surapprentissage ou non', 'dérive, quantification, RGPD'] },
+  prof: { deroule: [['Ouverture', 'Démonstration OCR sur une copie'], ['Cours', 'Neurone, perte, gradient'], ['Pratique', 'Réseau dense MNIST'], ['Cours', 'CNN et spectrogrammes'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : calculs à la main guidés. Élèves avancés : fine-tuning, Fidle.', eval: 'Notebook, sujet type.' } },
+exemples: [
+ ['Vérifier les dimensions', 'Erreur à la première passe.', 'x, y = next(iter(loader)); print(x.shape, model(x).shape)', 'torch.Size([64, 1, 28, 28]) torch.Size([64, 10])', 'Un lot de 64 images en entrée, 10 scores en sortie : les dimensions sont cohérentes.'],
+ ['Suivre l’apprentissage', 'Entraînement en cours.', 'for e in range(5): … print(e, perte_train, perte_val, acc_val)', '0 0.412 0.228 0.934\n1 0.191 0.160 0.953\n2 0.139 0.131 0.961\n3 0.108 0.129 0.962\n4 0.085 0.134 0.961', 'La perte de validation remonte à l’époque 4 : on garde le modèle de l’époque 3 (arrêt précoce).'],
+ ['Taux d’apprentissage trop grand', 'La perte explose.', 'opt = torch.optim.SGD(model.parameters(), lr=5.0)', 'époque 0 perte 2.30 → époque 1 perte nan', 'La perte devient NaN : les poids divergent. On revient à lr=1e-2 pour SGD ou 1e-3 pour Adam.'],
+ ['Mesurer l’OCR', 'Évaluer sur un jeu annoté.', 'jiwer.cer(references, predictions)', '0.043', '4,3 % de caractères erronés : acceptable pour du texte imprimé, à surveiller pour l’écriture manuscrite.'],
+ ['Alléger le modèle', 'Déploiement sur un mini-PC de salle.', 'q = torch.quantization.quantize_dynamic(model, {nn.Linear}, dtype=torch.qint8)\nprint(taille(model), taille(q))', '1.62 Mo 0.43 Mo', 'Le modèle quantifié est près de quatre fois plus léger, pour une perte d’exactitude généralement faible, à mesurer.'],
+ ['Transcrire localement', 'Consigne vocale en salle.', 'whisper consigne.wav --model small --language fr', '[00:00.000 --> 00:04.200] Ouvrez le terminal et tapez ip addr.', 'Le modèle tourne sur la machine locale : aucune voix d’élève ne sort de l’établissement.']
+],
+termes: ['réseau de neurones', 'neurone', 'couche', 'ReLU', 'softmax', 'fonction de perte', 'descente de gradient', 'rétropropagation', 'taux d’apprentissage', 'époque', 'lot', 'CNN', 'convolution', 'spectrogramme', 'transformeur', 'attention', 'apprentissage par transfert', 'dropout', 'arrêt précoce', 'ONNX', 'quantification', 'dérive', 'OCR', 'WER', 'PyTorch']
+});
+})();

portail/public/js/contenus-devops-1.js

@@ -0,0 +1,182 @@
+// Cours complets · DevOps lot 1 : Docker, Docker Compose, Ansible
+(function () {
+var reg = function (c) {
+  (window.CONTENUS_PRO = window.CONTENUS_PRO || []).unshift(c.cours);
+  (window.CONTENUS_PLUS = window.CONTENUS_PLUS || {})[c.cours.id] = c.plus;
+  (window.CONTENUS_EXEMPLES = window.CONTENUS_EXEMPLES || {})[c.cours.id] = c.exemples;
+  (window.CONTENUS_SCHEMAS = window.CONTENUS_SCHEMAS || {})[c.cours.id] = { termes: c.termes, figs: [] };
+};
+
+reg({
+cours: { id: 'docker', match: /Docker(?! Compose)|Dockerfile|conteneur/i,
+  titre: 'Conteneurs Docker : images, Dockerfile, réseaux et volumes', duree: '',
+  niveau: 'BTS SIO SISR / SLAM · BTS CIEL IR · BUT R&T parcours DevCloud · AIS · Master',
+  prerequis: ['Le terminal Linux', 'Processus et services systemd', 'Réseau : ports, NAT'],
+  competences: ['BTS SIO SISR · Bloc 2 · Virtualisation et conteneurs', 'BTS SIO SLAM · Bloc 2 · Déployer une solution applicative', 'BUT R&T DevCloud · Compétence « Automatiser le déploiement »', 'AIS · Administrer une infrastructure virtualisée'],
+  intro: '« Chez moi ça marche. » Pendant des années, le passage d’une application du poste du développeur au serveur de production a été la principale source d’incidents : version de PHP différente, bibliothèque manquante, configuration oubliée. Le conteneur règle ce problème en livrant l’application avec tout son environnement d’exécution, dans une image immuable qui s’exécute à l’identique partout. Docker a popularisé cette approche en 2013 ; elle est aujourd’hui le socle du déploiement moderne, des petites applications de lycée jusqu’aux plateformes Kubernetes des hébergeurs. Ce module explique ce qu’est réellement un conteneur pour le noyau Linux, comment construire des images propres et sûres, et comment les exploiter en production.',
+  cm: [
+    { t: 'Ce qu’est un conteneur pour le noyau', d: '', html: 'Un conteneur n’est pas une machine virtuelle. Il n’y a ni matériel émulé ni second noyau : c’est un <b>processus Linux ordinaire</b>, que le noyau isole grâce à deux mécanismes. Les <b>namespaces</b> donnent au processus sa propre vue du système : arborescence de processus (pid), interfaces réseau (net), points de montage (mnt), nom d’hôte (uts), utilisateurs (user), communications inter-processus (ipc). Les <b>cgroups</b> (control groups) limitent et mesurent les ressources qu’il consomme : processeur, mémoire, entrées-sorties.<br><br>Conséquences directes : un conteneur démarre en une fraction de seconde, consomme très peu de mémoire en plus de son application, et partage le noyau de l’hôte. C’est aussi sa limite de sécurité : une faille du noyau touche tous les conteneurs. Une VM isole plus fortement, un conteneur est plus léger ; en production, on combine souvent les deux (conteneurs dans des VM).', table: [['', 'Machine virtuelle', 'Conteneur'], ['Isolation', 'hyperviseur, noyau séparé', 'namespaces et cgroups, noyau partagé'], ['Démarrage', 'dizaines de secondes', 'fraction de seconde'], ['Taille', 'plusieurs Go', 'quelques Mo à centaines de Mo'], ['OS invité', 'n’importe lequel', 'même noyau que l’hôte (Linux)'], ['Usage type', 'serveur complet, isolation forte', 'application et ses dépendances']] },
+    { t: 'Images, couches et registres', d: '', html: 'Une <b>image</b> est un modèle en lecture seule, composé de <b>couches</b> superposées : chaque instruction d’un Dockerfile qui modifie le système de fichiers ajoute une couche. Le pilote de stockage (overlay2) les empile et ajoute au-dessus une couche inscriptible propre à chaque conteneur. Plusieurs conteneurs issus de la même image partagent ses couches sur le disque.<br><br>Une image est identifiée par un nom, un <b>tag</b> et un <b>digest</b> (empreinte SHA-256 du contenu). Le tag est une étiquette mobile : <code>nginx:latest</code> ne désigne pas la même image aujourd’hui et dans six mois. En production, on fixe une version précise (<code>nginx:1.27.2-alpine</code>) voire le digest, pour que chaque déploiement soit reproductible.<br><br>Les images sont stockées dans des <b>registres</b> : Docker Hub, GitHub Container Registry, ou un registre privé (Harbor, Forgejo, GitLab). <code>docker pull</code> télécharge, <code>docker push</code> publie.', attention: 'Ne jamais utiliser le tag latest en production : un redémarrage peut récupérer silencieusement une nouvelle version majeure et casser l’application.' },
+    { t: 'Écrire un Dockerfile de production', d: '', html: 'Le <b>Dockerfile</b> décrit la construction d’une image. Chaque instruction produit une couche, et Docker réutilise en cache les couches dont les instructions et les fichiers n’ont pas changé. L’ordre est donc décisif : on place en premier ce qui change rarement (système, dépendances) et en dernier ce qui change souvent (code).<br><br>Quatre bonnes pratiques font la différence entre un Dockerfile de TP et un Dockerfile de production. Partir d’une <b>image de base minimale et versionnée</b> (debian:bookworm-slim, alpine, distroless). Utiliser un <b>build multi-étapes</b> : on compile dans une première image complète, et on ne copie que le résultat dans une image finale légère, sans compilateurs. <b>Ne pas exécuter en root</b> : créer un utilisateur et le déclarer avec USER. Ajouter un <b>.dockerignore</b> pour ne pas envoyer .git, les secrets ou node_modules dans le contexte de construction.', exemple: '# syntax=docker/dockerfile:1\nFROM python:3.12-slim AS build\nWORKDIR /app\nCOPY requirements.txt .\nRUN pip install --no-cache-dir --prefix=/install -r requirements.txt\n\nFROM python:3.12-slim\nRUN useradd --create-home --uid 10001 app\nCOPY --from=build /install /usr/local\nWORKDIR /app\nCOPY --chown=app:app . .\nUSER app\nEXPOSE 8000\nHEALTHCHECK CMD python -c "import urllib.request;urllib.request.urlopen(\'http://localhost:8000/health\')"\nCMD ["gunicorn", "-b", "0.0.0.0:8000", "app:app"]' },
+    { t: 'Cycle de vie d’un conteneur', d: '', html: '<code>docker run</code> crée et démarre un conteneur à partir d’une image. Les options essentielles : <code>-d</code> en arrière-plan, <code>--name</code> pour le nommer, <code>-p 8080:80</code> pour publier un port, <code>-e</code> pour une variable d’environnement, <code>-v</code> pour un volume, <code>--restart unless-stopped</code> pour le redémarrer automatiquement, <code>--memory</code> et <code>--cpus</code> pour le limiter.<br><br>Le processus lancé par CMD ou ENTRYPOINT est le <b>PID 1</b> du conteneur : quand il s’arrête, le conteneur s’arrête. C’est pourquoi on ne lance pas un service en arrière-plan dans un conteneur, et pourquoi le programme doit traiter correctement le signal SIGTERM envoyé par <code>docker stop</code> (au bout de 10 secondes, Docker envoie SIGKILL).<br><br>Un conteneur est <b>jetable</b> : on ne le modifie pas à la main, on le recrée à partir d’une nouvelle image. Tout ce qui est écrit dans sa couche inscriptible disparaît avec <code>docker rm</code>.' },
+    { t: 'Persister les données : volumes et bind mounts', d: '', html: 'Puisque le conteneur est jetable, les données qui doivent survivre (base de données, fichiers envoyés, configuration) vont dans un <b>volume</b>. Un <b>volume nommé</b> est géré par Docker dans /var/lib/docker/volumes : c’est la solution recommandée pour les données d’application. Un <b>bind mount</b> monte un dossier précis de l’hôte : pratique pour la configuration ou le développement, mais il dépend de l’arborescence de l’hôte et de ses droits.<br><br>La sauvegarde ne se fait pas en copiant un volume de base de données à chaud : on utilise l’outil de la base (pg_dump, mariadb-dump) depuis le conteneur, ou on arrête le service le temps de la copie.', exemple: 'docker volume create pgdata\ndocker run -d --name db -e POSTGRES_PASSWORD_FILE=/run/secrets/pg -v pgdata:/var/lib/postgresql/data postgres:16\ndocker exec db pg_dump -U postgres app > app-$(date +%F).sql' },
+    { t: 'Réseaux Docker', d: '', html: 'Par défaut, chaque conteneur est relié au réseau <b>bridge</b> docker0 et reçoit une adresse privée en 172.17.0.0/16. Pour être joignable de l’extérieur, un port doit être publié avec <code>-p</code> : Docker crée alors une règle de <b>DNAT</b> dans netfilter vers le conteneur.<br><br>Sur un <b>réseau bridge utilisateur</b> (<code>docker network create</code>), les conteneurs se trouvent par leur <b>nom</b> grâce au DNS intégré de Docker (127.0.0.11) : l’application joint la base de données par le nom db, sans connaître son adresse. C’est la pratique recommandée. Le mode <b>host</b> supprime l’isolation réseau : le conteneur utilise directement les interfaces de l’hôte.', attention: 'Les ports publiés par Docker passent par ses propres règles netfilter, avant celles d’un pare-feu comme UFW : un -p 5432:5432 expose la base de données sur Internet même si UFW semble la bloquer. On publie uniquement sur la boucle locale (-p 127.0.0.1:5432:5432) ou pas du tout, en utilisant un réseau interne.' },
+    { t: 'Sécurité des conteneurs', d: '', html: 'Appartenir au groupe <b>docker</b> équivaut à être root sur l’hôte : on peut lancer un conteneur qui monte / et le modifier. On réserve ce groupe aux administrateurs, ou on utilise Docker en mode <b>rootless</b> ou Podman.<br><br>Les règles de base : images officielles ou construites en interne, <b>analyse de vulnérabilités</b> des images (Trivy, Docker Scout) dans la chaîne d’intégration, exécution en utilisateur non privilégié, jamais de <code>--privileged</code> sans raison impérative, secrets passés par fichiers ou gestionnaire de secrets plutôt qu’en variables d’environnement visibles dans <code>docker inspect</code>, et limites de ressources pour qu’un conteneur ne puisse pas saturer l’hôte.' }
+  ],
+  synthese: ['Conteneur = processus isolé par namespaces et limité par cgroups, noyau partagé', 'Image en couches, immuable, identifiée par tag et digest ; jamais latest en production', 'Dockerfile : base minimale versionnée, multi-étapes, USER non root, .dockerignore', 'PID 1 et SIGTERM : un processus au premier plan par conteneur', 'Données dans des volumes nommés, sauvegarde avec les outils de la base', 'Réseau bridge utilisateur et DNS par nom ; attention aux ports publiés qui contournent UFW', 'Groupe docker = root ; scanner les images, limiter les ressources'],
+  qcm: [
+    ['Quels mécanismes du noyau isolent un conteneur ?', ['Hyperviseur et BIOS', 'Namespaces et cgroups', 'chroot et sudo', 'SELinux uniquement'], 1, 'Namespaces pour la vue, cgroups pour les ressources.'],
+    ['Pourquoi éviter le tag latest en production ?', ['Il est payant', 'Il peut désigner une nouvelle version à chaque pull', 'Il est lent', 'Il n’existe pas'], 1, 'Le déploiement devient non reproductible.'],
+    ['Quel est l’intérêt d’un build multi-étapes ?', ['Accélérer le réseau', 'Obtenir une image finale sans outils de compilation', 'Lancer plusieurs conteneurs', 'Chiffrer l’image'], 1, 'Image plus petite et surface d’attaque réduite.'],
+    ['Que se passe-t-il quand le processus PID 1 d’un conteneur se termine ?', ['Rien', 'Le conteneur s’arrête', 'Docker le relance toujours', 'L’hôte redémarre'], 1, 'Le conteneur vit tant que son processus principal vit.'],
+    ['Où stocker les données d’une base PostgreSQL conteneurisée ?', ['Dans la couche du conteneur', 'Dans un volume nommé', 'Dans l’image', 'Dans /tmp'], 1, 'Elles survivent à la suppression du conteneur.'],
+    ['Comment une application joint-elle la base de données sur un réseau bridge utilisateur ?', ['Par l’adresse 172.17.0.1', 'Par le nom du conteneur', 'Par localhost', 'Impossible'], 1, 'DNS intégré de Docker.'],
+    ['Pourquoi -p 5432:5432 peut-il exposer la base malgré UFW ?', ['UFW est désactivé par Docker', 'Docker insère ses règles DNAT avant celles d’UFW', 'Le port 5432 est public par nature', 'Ce n’est pas possible'], 1, 'Publier sur 127.0.0.1 ou ne pas publier.'],
+    ['Être membre du groupe docker revient à :', ['n’avoir aucun droit', 'être root sur l’hôte', 'pouvoir seulement lire les journaux', 'être administrateur réseau'], 1, 'On peut monter / dans un conteneur.']
+  ],
+  td: [
+    { n: 'Échauffement', c: 'Classer VM ou conteneur : (a) serveur Windows pour un logiciel métier, (b) API Python déployée dix fois par jour, (c) isolation forte entre deux clients hébergés, (d) base de tests jetable pour chaque élève.', r: '(a) VM · (b) conteneur · (c) VM (ou conteneurs dans des VM séparées) · (d) conteneur' },
+    { n: 'Application', c: 'Réécrire ce Dockerfile pour la production : « FROM python:latest / COPY . /app / RUN pip install -r /app/requirements.txt / CMD python /app/app.py ».', r: 'Version fixée (python:3.12-slim), COPY requirements.txt avant le code pour le cache, pip --no-cache-dir, utilisateur non root et USER, .dockerignore, CMD en forme exec ["python","app.py"], éventuellement multi-étapes et HEALTHCHECK.' },
+    { n: 'Application', c: 'Lancer Nginx accessible uniquement depuis l’hôte sur le port 8080, redémarré automatiquement, limité à 256 Mo, avec un dossier de configuration en lecture seule.', r: 'docker run -d --name web --restart unless-stopped --memory 256m -p 127.0.0.1:8080:80 -v /srv/web/conf:/etc/nginx/conf.d:ro nginx:1.27-alpine' },
+    { n: 'Approfondissement', c: 'Montrer avec des commandes qu’un conteneur n’est qu’un processus de l’hôte, et retrouver son PID et ses cgroups.', r: 'docker inspect -f "{{.State.Pid}}" web → 4312\nps -fp 4312 · cat /proc/4312/cgroup · ls -l /proc/4312/ns' }
+  ],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Une VM Debian avec Docker : construire, publier, exploiter.', etapes: ['Construire l’image d’une API Python multi-étapes', 'La lancer avec limites de ressources et redémarrage automatique', 'Ajouter PostgreSQL sur un réseau utilisateur avec volume', 'Vérifier les ports réellement exposés', 'Scanner l’image avec Trivy'] },
+  plusLoin: [['Docker Docs · Dockerfile best practices', 'https://docs.docker.com/build/building/best-practices/'], ['ANSSI · Recommandations de sécurité relatives au déploiement de conteneurs Docker', 'https://cyber.gouv.fr/publications/recommandations-de-securite-relatives-au-deploiement-de-conteneurs-docker'], ['Trivy', 'https://trivy.dev/']] },
+plus: {
+  cas: { titre: '', texte: '' },
+  resolu: { enonce: 'L’application de réservation de salles, conteneurisée, redémarre en boucle depuis la mise à jour de ce matin. Les utilisateurs obtiennent une erreur 502 du reverse proxy. Diagnostiquer et rétablir.', etapes: [
+    ['Constater l’état', 'docker ps -a --filter name=resa\nNAMES  IMAGE              STATUS\nresa   resa-app:2.4.0     Restarting (1) 12 seconds ago\n→ Le conteneur démarre puis s’arrête avec le code 1, et la politique de redémarrage le relance sans fin. Le reverse proxy ne trouve donc jamais de backend : d’où les 502.'],
+    ['Lire les journaux', 'docker logs --tail 20 resa\nKeyError: \'DATABASE_URL\'\n→ L’application s’arrête au démarrage faute de la variable DATABASE_URL. La nouvelle version attend un nom de variable différent de l’ancienne (DB_URL).'],
+    ['Comparer avec la version précédente', 'docker inspect -f "{{range .Config.Env}}{{println .}}{{end}}" resa | grep -i db\nDB_URL=postgresql://resa@db/resa\n→ Le conteneur est lancé avec l’ancien nom de variable. Le changement était annoncé dans les notes de version 2.4.0, mais le fichier de déploiement n’a pas été adapté.'],
+    ['Rétablir le service', 'docker rm -f resa\ndocker run -d --name resa --network resa-net --restart unless-stopped -e DATABASE_URL=postgresql://resa@db/resa resa-app:2.4.0\ndocker ps --filter name=resa\nresa  resa-app:2.4.0  Up 20 seconds (healthy)\n→ On ne corrige pas le conteneur existant : on le recrée avec la bonne configuration. Le HEALTHCHECK confirme que l’application répond.'],
+    ['Vérifier et prévenir', 'curl -sI https://resa.lycee.local | head -1\nHTTP/2 200\n→ Service rétabli. Actions préventives : décrire le déploiement dans un fichier Compose versionné plutôt qu’une commande docker run tapée à la main, relire les notes de version, et tester la nouvelle image sur un environnement de préproduction avant la production.']
+  ] },
+  erreurs: ['Utiliser latest en production', 'Lancer le processus en root dans l’image', 'Stocker des données dans la couche du conteneur', 'Modifier un conteneur à la main au lieu de reconstruire l’image', 'Publier une base de données sur 0.0.0.0', 'Mettre des secrets dans le Dockerfile ou l’image', 'Oublier .dockerignore et embarquer .git', 'Donner le groupe docker à des utilisateurs non administrateurs'],
+  memo: [['Commande', 'Usage en production'], ['docker ps -a', 'conteneurs et leur état, y compris arrêtés'], ['docker logs -f --tail 100 <c>', 'journaux de l’application'], ['docker inspect <c>', 'configuration complète : env, montages, réseau'], ['docker exec -it <c> sh', 'shell dans un conteneur en cours'], ['docker stats', 'CPU et mémoire consommés en direct'], ['docker build -t app:1.2.0 .', 'construire une image versionnée'], ['docker image ls · docker image prune', 'lister et nettoyer les images'], ['docker volume ls', 'volumes de données'], ['docker network ls · inspect', 'réseaux et conteneurs rattachés'], ['docker system df', 'espace disque utilisé par Docker'], ['docker run --rm -it image sh', 'explorer une image sans la garder']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Comparer VM et conteneur en citant les mécanismes du noyau. (4 pts)', 'Critiquer et corriger un Dockerfile fourni. (6 pts)', 'Écrire la commande de lancement d’une application avec volume, réseau, limites et redémarrage. (4 pts)', 'Diagnostiquer un conteneur en redémarrage permanent à partir de sorties fournies. (4 pts)', 'Citer quatre mesures de sécurité des conteneurs. (2 pts)'], r: ['namespaces, cgroups, noyau partagé', 'version, cache, USER, multi-étapes, .dockerignore', 'docker run -d --name … --restart … --memory … -v … --network …', 'logs, inspect, code de sortie', 'non root, scan, pas de --privileged, secrets hors image'] },
+  prof: { deroule: [['Ouverture', 'Démonstration : la même application qui échoue sur deux machines, puis qui marche partout en conteneur'], ['Cours', 'Namespaces, cgroups, images et couches'], ['Démonstration', 'Dockerfile naïf puis Dockerfile de production, comparaison de taille'], ['Pratique', 'Lab : API + base de données, volumes et réseau'], ['Incident', 'Conteneur en boucle de redémarrage'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : Dockerfile à compléter, fiche mémo. Élèves avancés : mode rootless, scan Trivy dans une CI, image distroless.', eval: 'Étapes du lab validées, analyse du Dockerfile, sujet type.' }
+},
+exemples: [
+ ['Pourquoi ce conteneur s’arrête-t-il ?', 'Un conteneur passe en Exited juste après son lancement.', 'docker ps -a --filter name=api --format "{{.Names}} {{.Status}}"\ndocker logs api | tail -3', 'api Exited (137) 2 minutes ago\nKilled', 'Le code 137 = 128 + 9 : le processus a reçu SIGKILL. Sans docker stop, c’est presque toujours le noyau qui l’a tué pour dépassement de mémoire (OOM). On le confirme avec docker inspect -f "{{.State.OOMKilled}}" api, puis on augmente --memory ou on corrige la fuite.'],
+ ['Mesurer la consommation', 'Le serveur rame depuis le déploiement.', 'docker stats --no-stream --format "table {{.Name}}\\t{{.CPUPerc}}\\t{{.MemUsage}}"', 'NAME   CPU %   MEM USAGE / LIMIT\nresa   0.4%    182MiB / 512MiB\nglpi   187.3%  1.1GiB / 15.6GiB\ndb     3.1%    420MiB / 1GiB', 'Le conteneur glpi consomme presque deux cœurs et n’a pas de limite mémoire (la limite affichée est la RAM de l’hôte). On regarde ses journaux et on lui fixe --cpus et --memory pour protéger les autres services.'],
+ ['Vérifier les ports réellement exposés', 'Audit avant mise en production.', 'docker ps --format "{{.Names}} {{.Ports}}"', 'web  0.0.0.0:443->443/tcp\ndb   0.0.0.0:5432->5432/tcp\nredis 127.0.0.1:6379->6379/tcp', 'La base PostgreSQL est publiée sur toutes les interfaces : joignable depuis Internet malgré le pare-feu de l’hôte. On la retire du -p et on la laisse sur le réseau interne ; Redis, publié sur 127.0.0.1, est correct.'],
+ ['Comprendre le cache de construction', 'Chaque build prend trois minutes.', 'docker build -t app:dev .', ' => CACHED [2/5] WORKDIR /app\n => [3/5] COPY . .\n => [4/5] RUN pip install -r requirements.txt   172.4s', 'COPY . . est placé avant l’installation des dépendances : toute modification du code invalide le cache et relance pip. En copiant requirements.txt seul, puis en installant, puis en copiant le code, le build passe à quelques secondes.'],
+ ['Retrouver un conteneur par son nom', 'L’application ne joint pas la base de données.', 'docker exec api getent hosts db ; docker network inspect -f "{{range .Containers}}{{.Name}} {{end}}" appnet', '(aucune sortie)\napi', 'Le nom db ne se résout pas, car le conteneur de base de données n’est pas sur le réseau appnet. On le rattache : docker network connect appnet db.'],
+ ['Libérer de l’espace disque', 'Le disque de l’hôte est plein à 95 %.', 'docker system df', 'TYPE           TOTAL   ACTIVE   SIZE     RECLAIMABLE\nImages         48      6        21.3GB   18.9GB (88%)\nContainers     9       6        1.2GB    0.4GB\nLocal Volumes  12      5        8.7GB    3.1GB\nBuild Cache    —       —        6.4GB    6.4GB', 'Les anciennes images et le cache de construction occupent 25 Go récupérables. docker image prune -a et docker builder prune les suppriment. On évite docker volume prune sans vérifier : il supprimerait des données.']
+],
+termes: ['Docker', 'conteneur', 'image', 'Dockerfile', 'namespaces', 'cgroups', 'couche', 'tag', 'digest', 'registre', 'volume', 'bind mount', 'bridge', 'docker run', 'docker ps', 'docker logs', 'docker exec', 'docker inspect', 'docker stats', 'PID 1', 'SIGTERM', 'SIGKILL', 'multi-étapes', 'USER', 'HEALTHCHECK', 'latest', 'Trivy', 'rootless', 'OOM']
+});
+
+reg({
+cours: { id: 'compose', match: /Docker Compose/i,
+  titre: 'Docker Compose : décrire et exploiter une application multi-conteneurs', duree: '',
+  niveau: 'BTS SIO SISR / SLAM · BUT R&T DevCloud · AIS',
+  prerequis: ['Conteneurs Docker'],
+  competences: ['BTS SIO · Bloc 2 · Déployer une solution applicative', 'BUT R&T DevCloud · Automatiser le déploiement', 'AIS · Industrialiser le déploiement'],
+  intro: 'Une application réelle ne tient jamais dans un seul conteneur : un site Laravel a besoin d’un serveur web, de PHP-FPM, d’une base de données, souvent d’un cache Redis et d’un planificateur de tâches. Lancer et relier tout cela à coups de docker run est fragile et impossible à reproduire. Docker Compose décrit l’ensemble dans un fichier YAML versionné : services, réseaux, volumes, variables, ordre de démarrage. Ce fichier devient la documentation exécutable du déploiement.',
+  cm: [
+    { t: 'Le fichier compose.yaml', d: '', html: 'Le fichier <code>compose.yaml</code> (anciennement docker-compose.yml) déclare des <b>services</b>, chacun correspondant à un conteneur issu d’une image ou d’un Dockerfile, ainsi que des <b>volumes</b> et des <b>réseaux</b>. Compose crée automatiquement un réseau par projet : chaque service y est joignable par son nom.<br><br>La commande actuelle est <code>docker compose</code> (plugin intégré, version 2), qui remplace l’ancien binaire docker-compose écrit en Python.', exemple: 'services:\n  web:\n    image: nginx:1.27-alpine\n    ports: ["443:443"]\n    volumes: ["./nginx:/etc/nginx/conf.d:ro", "certs:/etc/ssl/app:ro"]\n    depends_on: [app]\n  app:\n    build: .\n    env_file: .env\n    depends_on:\n      db: { condition: service_healthy }\n  db:\n    image: postgres:16\n    environment:\n      POSTGRES_PASSWORD_FILE: /run/secrets/db_password\n    secrets: [db_password]\n    volumes: ["pgdata:/var/lib/postgresql/data"]\n    healthcheck:\n      test: ["CMD", "pg_isready", "-U", "postgres"]\n      interval: 5s\n      retries: 10\nvolumes:\n  pgdata:\n  certs:\nsecrets:\n  db_password:\n    file: ./secrets/db_password.txt' },
+    { t: 'Ordre de démarrage et healthchecks', d: '', html: '<code>depends_on</code> seul garantit uniquement que le conteneur de la base est <b>démarré</b> avant l’application, pas qu’il est <b>prêt</b> à accepter des connexions. PostgreSQL met plusieurs secondes à s’initialiser au premier lancement, et l’application qui s’y connecte trop tôt échoue.<br><br>La bonne pratique combine un <b>healthcheck</b> sur la base et <code>condition: service_healthy</code> dans le depends_on de l’application. L’application doit aussi savoir réessayer sa connexion : en production, un redémarrage de la base peut survenir à tout moment.' },
+    { t: 'Variables, fichiers .env et secrets', d: '', html: 'Compose lit automatiquement le fichier <code>.env</code> du dossier du projet pour substituer les variables <code>${VAR}</code> du fichier YAML, et <code>env_file</code> injecte des variables dans un conteneur. Ces fichiers ne doivent <b>jamais être versionnés</b> s’ils contiennent des mots de passe : on versionne un <code>.env.example</code> sans valeurs.<br><br>Les <b>secrets</b> de Compose montent un fichier en lecture seule dans <code>/run/secrets/</code> : le mot de passe n’apparaît ni dans les variables d’environnement, ni dans <code>docker inspect</code>. Les images officielles comme postgres ou mariadb acceptent les variables en <code>_FILE</code> pour lire leur valeur dans ce fichier.' },
+    { t: 'Exploiter un projet Compose', d: '', html: '<code>docker compose up -d</code> crée ou met à jour tout le projet ; il ne recrée que les services dont la configuration ou l’image a changé. <code>docker compose pull</code> récupère les nouvelles images, <code>docker compose up -d --build</code> reconstruit celles qui ont un Dockerfile. <code>docker compose ps</code>, <code>logs -f service</code>, <code>exec service sh</code> et <code>down</code> complètent l’exploitation courante.<br><br><code>docker compose down</code> supprime conteneurs et réseau mais <b>conserve les volumes</b> ; <code>down -v</code> supprime aussi les volumes, donc les données. Cette option ne doit jamais être tapée par réflexe en production.', attention: 'docker compose down -v sur le serveur de production efface la base de données. Sauvegarder avant toute opération de maintenance, et réserver -v aux environnements de test.' },
+    { t: 'Plusieurs environnements', d: '', html: 'Un même projet tourne en développement, en préproduction et en production avec des différences : ports, volumes de code montés, niveau de journalisation, nombre de répliques. Compose fusionne plusieurs fichiers : <code>compose.yaml</code> contient la base commune, <code>compose.override.yaml</code> (chargé automatiquement) les réglages de développement, et <code>compose.prod.yaml</code> ceux de production, appliqués avec <code>docker compose -f compose.yaml -f compose.prod.yaml up -d</code>. Les <b>profils</b> permettent d’activer des services optionnels (outils d’administration, tests).' },
+    { t: 'Limites de Compose', d: '', html: 'Compose pilote les conteneurs d’<b>une seule machine</b>. Il ne répartit pas la charge entre plusieurs serveurs, ne déplace pas un service quand un nœud tombe, et ne gère pas les mises à jour sans interruption. Pour un établissement ou une PME, c’est souvent largement suffisant et bien plus simple à maintenir. Au-delà, on passe à un orchestrateur comme <b>Kubernetes</b>, dont les notions (services, volumes, secrets, sondes de santé) prolongent directement celles de Compose.' }
+  ],
+  synthese: ['compose.yaml versionné = documentation exécutable du déploiement', 'Réseau par projet, services joignables par leur nom', 'depends_on + healthcheck + condition service_healthy', '.env jamais versionné ; secrets montés dans /run/secrets', 'up -d ne recrée que ce qui a changé ; down -v efface les données', 'Plusieurs fichiers pour plusieurs environnements', 'Une seule machine : au-delà, Kubernetes'],
+  qcm: [
+    ['Que garantit depends_on sans condition ?', ['Que la base accepte les connexions', 'Que le conteneur de la base est démarré avant', 'Que la base est sauvegardée', 'Rien'], 1, 'Démarré ne veut pas dire prêt.'],
+    ['Que fait docker compose down -v ?', ['Redémarre', 'Supprime conteneurs, réseau et volumes', 'Met à jour les images', 'Affiche la version'], 1, 'Les données sont effacées.'],
+    ['Comment le service app joint-il le service db ?', ['Par l’IP de l’hôte', 'Par le nom db', 'Par localhost', 'Par un port publié'], 1, 'DNS du réseau du projet.'],
+    ['Pourquoi préférer les secrets aux variables d’environnement pour un mot de passe ?', ['Plus rapide', 'Le mot de passe n’apparaît pas dans docker inspect', 'Obligatoire', 'Chiffrement automatique sur le disque'], 1, 'Fichier monté en lecture seule.'],
+    ['Quel fichier est chargé automatiquement en plus de compose.yaml ?', ['compose.prod.yaml', 'compose.override.yaml', 'docker.yaml', '.env.example'], 1, 'Réglages de développement.'],
+    ['Après modification de l’image d’un seul service, docker compose up -d :', ['recrée tous les services', 'recrée seulement ce service', 'ne fait rien', 'supprime les volumes'], 1, 'Mise à jour ciblée.']
+  ],
+  td: [
+    { n: 'Application', c: 'Écrire le compose.yaml d’un GLPI : service web (image diouxx/glpi ou équivalent), service MariaDB avec volume et healthcheck, mot de passe en secret, seul le web publié sur 443.', r: 'services: web (ports 443, depends_on db service_healthy) ; db (mariadb:11, MARIADB_ROOT_PASSWORD_FILE, secrets, volume dbdata, healthcheck healthcheck.sh --connect) ; volumes: dbdata ; secrets: db_root.' },
+    { n: 'Application', c: 'Écrire la procédure de mise à jour d’un projet Compose en production sans perte de données.', r: '1. Sauvegarde (docker compose exec db pg_dump …) · 2. docker compose pull · 3. docker compose up -d · 4. docker compose ps et logs · 5. test fonctionnel · 6. en cas d’échec : revenir au tag précédent dans compose.yaml puis up -d.' },
+    { n: 'Approfondissement', c: 'Séparer la configuration de développement (code monté, port 8000 publié, débogage) de celle de production (image construite, pas de port applicatif publié).', r: 'compose.yaml : base commune · compose.override.yaml : volumes ./:/app, ports 8000, APP_DEBUG=1 · compose.prod.yaml : image registre:tag, restart unless-stopped, pas de ports sur app · lancement prod : -f compose.yaml -f compose.prod.yaml.' }
+  ],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Déployer une application web, sa base et son cache avec Compose.', etapes: ['Écrire compose.yaml avec trois services', 'Ajouter healthcheck et secrets', 'Démarrer, vérifier ps et logs', 'Mettre à jour une image sans perte de données', 'Sauvegarder et restaurer la base'] },
+  plusLoin: [['Docker Docs · Compose file reference', 'https://docs.docker.com/reference/compose-file/'], ['Docker Docs · Secrets in Compose', 'https://docs.docker.com/compose/how-tos/use-secrets/']] },
+plus: {
+  cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Après un redémarrage du serveur, l’application Laravel du CDI affiche « SQLSTATE[HY000] [2002] Connection refused » pendant plusieurs minutes, puis parfois reste en erreur. Diagnostiquer et fiabiliser.', etapes: [
+    ['Observer l’ordre de démarrage', 'docker compose ps\nNAME     SERVICE  STATUS\ncdi-app  app      Up 3 minutes\ncdi-db   db       Up 3 minutes (health: starting)\n→ L’application tourne alors que la base n’est pas encore prête.'],
+    ['Lire les journaux', 'docker compose logs app | head -3\nSQLSTATE[HY000] [2002] Connection refused\ndocker compose logs db | tail -2\nInnoDB: Starting crash recovery...\nready for connections.\n→ Après un arrêt brutal, MariaDB effectue une récupération qui prend du temps. L’application a tenté de se connecter trop tôt et a mis la base en échec dans son cache de configuration.'],
+    ['Lire le fichier Compose', 'grep -A3 depends_on compose.yaml\n    depends_on:\n      - db\n→ depends_on sans condition : Compose attend seulement que le conteneur db soit lancé.'],
+    ['Corriger', 'db:\n  healthcheck:\n    test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]\n    interval: 5s\n    retries: 30\napp:\n  depends_on:\n    db: { condition: service_healthy }\n  restart: unless-stopped\ndocker compose up -d\n→ L’application ne démarre plus qu’une fois la base réellement prête, et redémarre automatiquement en cas d’échec.'],
+    ['Valider', 'sudo reboot  (sur la préproduction)\ndocker compose ps\ncdi-db   Up 2 minutes (healthy)\ncdi-app  Up 1 minute\n→ L’ordre est respecté. Compte rendu : cause (depends_on sans healthcheck), correction, test de redémarrage ajouté à la procédure de validation.']
+  ] },
+  erreurs: ['depends_on sans healthcheck', 'Versionner le fichier .env avec les mots de passe', 'Taper docker compose down -v en production', 'Publier les ports de la base de données', 'Ne pas fixer les versions des images', 'Mettre à jour sans sauvegarde préalable'],
+  memo: [['Commande', 'Usage'], ['docker compose up -d', 'créer ou mettre à jour le projet'], ['docker compose ps', 'état et santé des services'], ['docker compose logs -f <s>', 'journaux d’un service'], ['docker compose exec <s> sh', 'shell dans un service'], ['docker compose pull', 'récupérer les nouvelles images'], ['docker compose up -d --build', 'reconstruire et redéployer'], ['docker compose config', 'afficher la configuration fusionnée et validée'], ['docker compose down', 'arrêter en conservant les volumes'], ['docker compose -f a.yaml -f b.yaml up -d', 'combiner des fichiers d’environnement'], ['docker compose --profile outils up -d', 'activer des services optionnels']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Écrire le compose.yaml d’une application trois tiers. (8 pts)', 'Expliquer depends_on et les healthchecks. (4 pts)', 'Rédiger la procédure de mise à jour sans perte de données. (5 pts)', 'Justifier le passage à Kubernetes pour un cas donné. (3 pts)'], r: ['services, volumes, secrets, réseau', 'démarré ≠ prêt, condition service_healthy', 'sauvegarde, pull, up -d, contrôle, retour arrière', 'plusieurs nœuds, haute disponibilité'] },
+  prof: { deroule: [['Ouverture', 'Lancer à la main trois conteneurs reliés, puis la même chose en un fichier'], ['Cours', 'Services, réseaux, volumes, secrets'], ['Pratique', 'Lab application trois tiers'], ['Incident', 'Ordre de démarrage au redémarrage'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : compose.yaml à compléter. Élèves avancés : plusieurs environnements, profils, déploiement par CI.', eval: 'Lab validé, sujet type.' }
+},
+exemples: [
+ ['Valider le fichier avant déploiement', 'Une modification a été faite dans compose.yaml.', 'docker compose config --quiet && echo OK', 'services.app.depends_on.db.condition must be one of the following: "service_started", "service_healthy", "service_completed_successfully"', 'Faute de frappe dans la condition. docker compose config valide et fusionne les fichiers sans rien lancer : à exécuter avant chaque up.'],
+ ['Voir la santé des services', 'L’application répond lentement au démarrage.', 'docker compose ps --format "table {{.Service}}\\t{{.Status}}"', 'SERVICE  STATUS\ndb       Up 40 seconds (healthy)\nredis    Up 40 seconds\napp      Up 12 seconds (health: starting)', 'La base est prête, l’application exécute encore son healthcheck. Tant qu’elle n’est pas healthy, le reverse proxy peut renvoyer des erreurs : c’est normal pendant quelques secondes.'],
+ ['Mettre à jour une seule image', 'Correctif de sécurité publié pour Nginx.', 'docker compose pull web && docker compose up -d web', '[+] Pulling web … Pulled\n[+] Running 1/1  ✔ Container cdi-web  Recreated', 'Seul le service web est recréé ; la base et l’application continuent de tourner.'],
+ ['Sauvegarder la base d’un projet', 'Avant une mise à jour.', 'docker compose exec -T db pg_dump -U app app | gzip > backup-$(date +%F).sql.gz ; ls -lh backup-*', '-rw-r--r-- 1 admin admin 14M sept. 30 07:02 backup-2026-09-30.sql.gz', '-T désactive le pseudo-terminal pour que la sortie puisse être redirigée proprement dans un fichier.'],
+ ['Retrouver le nom réel des ressources', 'Un collègue cherche le volume de la base.', 'docker volume ls --filter label=com.docker.compose.project=cdi', 'DRIVER  VOLUME NAME\nlocal   cdi_pgdata', 'Compose préfixe les volumes et réseaux par le nom du projet (le dossier). Deux projets peuvent donc avoir chacun un volume pgdata sans conflit.'],
+ ['Afficher les journaux de plusieurs services', 'Erreur 500 intermittente.', 'docker compose logs --since 10m app web | grep -E " 500 |ERROR"', 'cdi-web  | "POST /reservations HTTP/1.1" 500\ncdi-app  | ERROR: duplicate key value violates unique constraint "resa_salle_creneau"', 'En croisant les journaux, on relie l’erreur 500 vue par Nginx à une violation de contrainte dans l’application : deux réservations simultanées du même créneau. C’est un bug applicatif, pas une panne d’infrastructure.']
+],
+termes: ['Docker Compose', 'compose.yaml', 'service', 'depends_on', 'healthcheck', 'service_healthy', 'secrets', '.env', 'env_file', 'docker compose up', 'docker compose down', 'docker compose ps', 'docker compose logs', 'docker compose config', 'profils', 'volume', 'Kubernetes']
+});
+
+reg({
+cours: { id: 'ansible', match: /Ansible|IaC|infrastructure as code/i,
+  titre: 'Ansible : automatiser la configuration des serveurs', duree: '',
+  niveau: 'BTS SIO SISR · BUT R&T DevCloud · AIS · Master',
+  prerequis: ['Le terminal Linux', 'SSH par clé', 'Paquets et services'],
+  competences: ['BTS SIO SISR · Bloc 2 · Automatiser les tâches d’administration', 'BUT R&T DevCloud · Automatiser le déploiement d’une infrastructure', 'AIS · Industrialiser l’administration'],
+  intro: 'Configurer un serveur à la main prend une heure ; en configurer quarante de façon identique est impossible sans erreur, et personne ne sait plus, six mois après, ce qui a été fait sur lequel. Ansible décrit l’état attendu des machines dans des fichiers YAML versionnés, et l’applique par SSH, sans agent à installer. Relancé autant de fois qu’on veut, il ne change que ce qui n’est pas conforme. C’est l’outil d’automatisation le plus répandu dans les services informatiques, des établissements scolaires aux grands hébergeurs.',
+  cm: [
+    { t: 'Principe : décrire un état, pas des commandes', d: '', html: 'Un script Bash enchaîne des actions : « installe Nginx, copie ce fichier, redémarre ». Lancé deux fois, il peut échouer ou dupliquer une ligne. Ansible décrit un <b>état désiré</b> : « Nginx doit être installé, ce fichier doit avoir ce contenu, le service doit être actif ». Chaque <b>module</b> vérifie l’état actuel et n’agit que si nécessaire : c’est l’<b>idempotence</b>. Un playbook relancé sur une machine déjà conforme affiche <code>changed=0</code>.<br><br>Ansible est <b>sans agent</b> : le poste de contrôle se connecte en SSH, envoie un petit programme Python, l’exécute et le supprime. Il suffit d’un accès SSH et de Python sur les machines gérées.' },
+    { t: 'L’inventaire', d: '', html: 'L’<b>inventaire</b> liste les machines gérées et les range en <b>groupes</b>. Il peut être statique (fichier INI ou YAML) ou dynamique (généré depuis un hyperviseur ou un fournisseur cloud). Les <b>variables</b> se placent dans <code>group_vars/</code> et <code>host_vars/</code>, ce qui sépare les données (quelle machine, quelle valeur) de la logique (les tâches).', exemple: '# inventaire/hosts.yaml\nall:\n  children:\n    web:\n      hosts:\n        web1.lycee.local:\n        web2.lycee.local:\n    db:\n      hosts:\n        db1.lycee.local:\n          ansible_host: 10.62.40.31\n  vars:\n    ansible_user: admin\n\n$ ansible -i inventaire all -m ping\nweb1.lycee.local | SUCCESS => {"changed": false, "ping": "pong"}' },
+    { t: 'Playbooks, tâches et modules', d: '', html: 'Un <b>playbook</b> est une liste de <b>plays</b> : chacun associe un groupe de machines à une liste de <b>tâches</b>. Chaque tâche appelle un <b>module</b> avec des paramètres : <code>ansible.builtin.apt</code> pour les paquets, <code>template</code> pour générer un fichier de configuration, <code>service</code> ou <code>systemd</code> pour les services, <code>user</code>, <code>lineinfile</code>, <code>copy</code>, <code>file</code>. On utilise les noms complets (FQCN) pour éviter toute ambiguïté.<br><br><code>become: true</code> élève les privilèges avec sudo. Les <b>handlers</b> sont des tâches déclenchées par <code>notify</code> seulement si une tâche a réellement changé quelque chose : on ne redémarre Nginx que si sa configuration a été modifiée.', exemple: '- name: Serveurs web\n  hosts: web\n  become: true\n  tasks:\n    - name: Installer nginx\n      ansible.builtin.apt:\n        name: nginx\n        state: present\n        update_cache: true\n    - name: Déployer la configuration du site\n      ansible.builtin.template:\n        src: site.conf.j2\n        dest: /etc/nginx/conf.d/site.conf\n        mode: "0644"\n      notify: Recharger nginx\n    - name: Nginx actif au démarrage\n      ansible.builtin.service:\n        name: nginx\n        state: started\n        enabled: true\n  handlers:\n    - name: Recharger nginx\n      ansible.builtin.service:\n        name: nginx\n        state: reloaded' },
+    { t: 'Templates Jinja2 et variables', d: '', html: 'Le module <code>template</code> génère un fichier à partir d’un modèle <b>Jinja2</b> : <code>{{ variable }}</code> insère une valeur, <code>{% for %}</code> et <code>{% if %}</code> ajoutent de la logique. La même configuration sert ainsi à toutes les machines, avec leurs valeurs propres. Les <b>facts</b> collectés automatiquement (adresse IP, distribution, mémoire) sont aussi disponibles comme variables.<br><br>Les variables ont un ordre de <b>priorité</b> : valeurs par défaut d’un rôle, group_vars, host_vars, variables du playbook, puis <code>-e</code> en ligne de commande, qui l’emporte sur tout. Mal maîtrisé, cet ordre explique des valeurs « inattendues ».' },
+    { t: 'Rôles et collections', d: '', html: 'Au-delà de quelques dizaines de tâches, on range le code en <b>rôles</b> : une arborescence normalisée (tasks, handlers, templates, defaults, vars, files) qui regroupe tout ce qu’il faut pour une fonction, par exemple « serveur web » ou « durcissement SSH ». Un rôle se réutilise dans plusieurs playbooks et se partage. Les <b>collections</b> distribuent rôles et modules (community.general, ansible.posix) et s’installent avec <code>ansible-galaxy</code>.' },
+    { t: 'Tester avant d’appliquer et protéger les secrets', d: '', html: '<code>--check</code> simule l’exécution sans rien modifier, <code>--diff</code> montre les différences de fichiers, <code>--limit web1</code> restreint à une machine, <code>--tags</code> à certaines tâches. En production, on valide toujours sur une machine avant tout le parc.<br><br>Les mots de passe et clés ne doivent pas être en clair dans le dépôt Git. <b>Ansible Vault</b> chiffre un fichier de variables avec AES-256 ; le mot de passe du coffre est fourni à l’exécution. <code>ansible-lint</code> détecte les mauvaises pratiques (tâches non nommées, modules shell là où un module dédié existe, droits de fichiers absents).', attention: 'Les modules command et shell ne sont pas idempotents par nature : ils s’exécutent à chaque passage. Préférer un module dédié, ou ajouter creates, removes ou changed_when pour décrire l’état.' }
+  ],
+  synthese: ['Ansible décrit un état désiré ; les modules sont idempotents', 'Sans agent : SSH et Python sur les machines gérées', 'Inventaire en groupes, variables dans group_vars et host_vars', 'Playbook → plays → tâches → modules ; become pour sudo', 'Handlers déclenchés uniquement en cas de changement', 'Templates Jinja2, rôles réutilisables', '--check --diff et --limit avant d’appliquer ; Vault pour les secrets'],
+  qcm: [
+    ['Que signifie qu’une tâche Ansible est idempotente ?', ['Elle est rapide', 'La relancer sur une machine conforme ne change rien', 'Elle s’exécute en parallèle', 'Elle est chiffrée'], 1, 'changed=0 au second passage.'],
+    ['De quoi Ansible a-t-il besoin sur les machines gérées ?', ['Un agent Ansible', 'SSH et Python', 'Docker', 'Un serveur web'], 1, 'Architecture sans agent.'],
+    ['Quand un handler s’exécute-t-il ?', ['À chaque tâche', 'Quand une tâche qui le notifie a produit un changement', 'Au début du playbook', 'Jamais automatiquement'], 1, 'Par exemple recharger Nginx seulement si sa configuration a changé.'],
+    ['Quelle option simule sans modifier ?', ['--dry', '--check', '--test', '--simulate'], 1, 'Souvent combinée avec --diff.'],
+    ['Où placer une variable commune à tous les serveurs web ?', ['host_vars/web1.yaml', 'group_vars/web.yaml', 'dans le template', 'dans /etc/ansible/ansible.cfg'], 1, 'Variables de groupe.'],
+    ['Comment protéger un mot de passe dans le dépôt ?', ['Le mettre en commentaire', 'Ansible Vault', 'Le coder en base64', 'Le mettre dans le template'], 1, 'Chiffrement AES-256.'],
+    ['Pourquoi éviter le module shell pour installer un paquet ?', ['Il est interdit', 'Il n’est pas idempotent et masque l’état réel', 'Il est plus lent', 'Il ne supporte pas sudo'], 1, 'Utiliser apt ou dnf.']
+  ],
+  td: [
+    { n: 'Application', c: 'Écrire un playbook qui crée l’utilisateur technicien, lui dépose une clé SSH publique, désactive l’authentification SSH par mot de passe et recharge sshd seulement si nécessaire.', r: 'user (name, groups: sudo, shell) · ansible.posix.authorized_key · lineinfile sur /etc/ssh/sshd_config avec regexp "^#?PasswordAuthentication" line "PasswordAuthentication no" validate "sshd -t -f %s" notify Recharger ssh · handler service ssh reloaded.' },
+    { n: 'Application', c: 'Transformer ce passage en tâche idempotente : « shell: echo "10.62.40.20 ent" >> /etc/hosts ».', r: 'ansible.builtin.lineinfile: path=/etc/hosts line="10.62.40.20 ent" (la ligne n’est ajoutée qu’une fois).' },
+    { n: 'Approfondissement', c: 'Organiser en rôle le déploiement d’un serveur web : arborescence, variables par défaut, template et handler.', r: 'roles/web/{tasks/main.yml, handlers/main.yml, templates/site.conf.j2, defaults/main.yml (web_port: 443, web_root: /var/www/site)} · playbook : roles: [web].' }
+  ],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Un poste de contrôle et trois VM Debian à configurer.', etapes: ['Écrire l’inventaire et tester ansible -m ping', 'Playbook : paquets et utilisateurs', 'Déployer Nginx avec un template et un handler', 'Vérifier l’idempotence (changed=0)', 'Chiffrer un secret avec Vault', 'Passer ansible-lint'] },
+  plusLoin: [['Documentation Ansible', 'https://docs.ansible.com/'], ['Ansible Lint', 'https://ansible.readthedocs.io/projects/lint/'], ['Xavki · tutoriels Ansible en français', 'https://www.youtube.com/@xavki']] },
+plus: {
+  cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Le playbook de mise à jour des 12 serveurs web s’est interrompu cette nuit : 4 serveurs ont la nouvelle configuration Nginx, 8 l’ancienne, et web3 ne répond plus. Diagnostiquer, rétablir et fiabiliser.', etapes: [
+    ['Lire le récapitulatif', 'PLAY RECAP\nweb1  ok=6 changed=2 failed=0\nweb3  ok=4 changed=1 failed=1\nweb4…web12  (non traités)\n→ Ansible s’est arrêté après l’échec sur web3 : par défaut, un play traite les machines par lots et s’arrête si toutes celles du lot échouent. L’état du parc est hétérogène.'],
+    ['Identifier l’erreur', 'TASK [Recharger nginx] fatal: [web3]: FAILED! => {"msg": "Unable to reload service nginx: Job for nginx.service failed"}\nssh web3 sudo nginx -t\nnginx: [emerg] unknown directive "ssl_protocol" in /etc/nginx/conf.d/site.conf:7\n→ Le template contient une faute (ssl_protocol au lieu de ssl_protocols). La configuration invalide a été déposée, le rechargement a échoué et Nginx s’est arrêté sur web3.'],
+    ['Rétablir web3', 'Correction du template site.conf.j2 (ssl_protocols TLSv1.2 TLSv1.3;)\nansible-playbook site.yml --limit web3 --diff\nweb3  ok=6 changed=2 failed=0\ncurl -sI https://web3.lycee.local | head -1\nHTTP/2 200\n→ On corrige la source (le template), jamais le fichier à la main sur le serveur : sinon le prochain passage réintroduirait l’erreur.'],
+    ['Fiabiliser le playbook', '- ansible.builtin.template:\n    src: site.conf.j2\n    dest: /etc/nginx/conf.d/site.conf\n    validate: nginx -t -c /etc/nginx/nginx.conf\n  notify: Recharger nginx\n- hosts: web\n  serial: 2\n  max_fail_percentage: 0\n→ validate teste le fichier avant de le mettre en place ; serial: 2 déploie deux serveurs à la fois et arrête tout au premier échec. Une erreur ne touche plus qu’un lot.'],
+    ['Appliquer au parc et contrôler', 'ansible-playbook site.yml --check --diff --limit web4\nansible-playbook site.yml\nweb1…web12  failed=0\nansible-playbook site.yml   (second passage)\nweb1…web12  changed=0\n→ Le parc est homogène et le second passage confirme l’idempotence. Compte rendu : cause, impact, correction, et règle d’équipe : --check sur une machine témoin avant tout déploiement, validation des templates dans la CI avec ansible-lint.']
+  ] },
+  erreurs: ['Utiliser shell ou command là où un module dédié existe', 'Modifier un fichier à la main sur un serveur géré par Ansible', 'Laisser des mots de passe en clair dans le dépôt', 'Déployer sur tout le parc sans --check ni serial', 'Redémarrer un service à chaque passage au lieu d’un handler', 'Déposer une configuration sans validate'],
+  memo: [['Commande', 'Usage'], ['ansible all -m ping', 'tester la connexion à tout l’inventaire'], ['ansible web -m ansible.builtin.setup', 'afficher les facts d’un groupe'], ['ansible-playbook site.yml --check --diff', 'simuler et voir les différences'], ['ansible-playbook site.yml --limit web1', 'restreindre à une machine'], ['ansible-playbook site.yml --tags nginx', 'n’exécuter que certaines tâches'], ['ansible-inventory --graph', 'visualiser l’inventaire'], ['ansible-vault create|edit|encrypt', 'gérer les secrets chiffrés'], ['ansible-playbook … --ask-vault-pass', 'fournir le mot de passe du coffre'], ['ansible-galaxy collection install', 'installer une collection'], ['ansible-lint', 'contrôler les bonnes pratiques']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Expliquer l’idempotence et l’architecture sans agent. (4 pts)', 'Écrire un inventaire et un playbook de déploiement avec template et handler. (8 pts)', 'Rendre idempotentes trois tâches shell fournies. (4 pts)', 'Proposer une stratégie de déploiement sûr sur 50 serveurs. (4 pts)'], r: ['État désiré, SSH + Python', 'hosts.yaml, apt, template, service, handler', 'lineinfile, apt, creates', '--check, serial, validate, max_fail_percentage'] },
+  prof: { deroule: [['Ouverture', 'Configurer trois VM à la main en chronométrant, puis avec Ansible'], ['Cours', 'Inventaire, playbooks, modules, idempotence'], ['Pratique', 'Lab trois VM'], ['Incident', 'Template invalide sur un parc'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : playbook à compléter. Élèves avancés : rôles, Vault, CI avec ansible-lint, Molecule.', eval: 'Lab validé (idempotence vérifiée), sujet type.' }
+},
+exemples: [
+ ['Tester l’accès à tout le parc', 'Avant un déploiement.', 'ansible -i inventaire all -m ping -o', 'web1.lycee.local | SUCCESS => {"changed": false,"ping": "pong"}\nweb2.lycee.local | UNREACHABLE! => {"msg": "Failed to connect to the host via ssh: Connection timed out"}', 'web2 est injoignable en SSH : on le traite avant de lancer le playbook, sinon le parc sera partiellement configuré.'],
+ ['Simuler un changement', 'Nouvelle version du template Nginx.', 'ansible-playbook site.yml --check --diff --limit web1', '--- before: /etc/nginx/conf.d/site.conf\n+++ after: site.conf.j2\n-    client_max_body_size 8m;\n+    client_max_body_size 64m;\nweb1 : ok=5 changed=1 failed=0', 'Seule la ligne attendue change. On peut appliquer sereinement.'],
+ ['Vérifier l’idempotence', 'Contrôle qualité d’un playbook.', 'ansible-playbook site.yml | tail -3', 'PLAY RECAP\nweb1 : ok=7 changed=1 unreachable=0 failed=0\nweb2 : ok=7 changed=1 unreachable=0 failed=0', 'Au second passage, une tâche est encore « changed » : c’est une tâche shell sans changed_when. Il faut la remplacer par un module dédié ou décrire sa condition de changement.'],
+ ['Lire les facts d’une machine', 'Adapter un template à la mémoire disponible.', 'ansible db1 -m ansible.builtin.setup -a "filter=ansible_memtotal_mb"', 'db1 | SUCCESS => {"ansible_facts": {"ansible_memtotal_mb": 7957}}', 'La variable ansible_memtotal_mb est utilisable dans un template, par exemple pour dimensionner shared_buffers de PostgreSQL au quart de la mémoire.'],
+ ['Chiffrer un secret', 'Mot de passe de la base dans group_vars.', 'ansible-vault encrypt group_vars/db/vault.yml ; head -1 group_vars/db/vault.yml', 'Encryption successful\n$ANSIBLE_VAULT;1.1;AES256', 'Le fichier peut être versionné : sans le mot de passe du coffre, il est illisible.'],
+ ['Détecter les mauvaises pratiques', 'Revue de code avant fusion.', 'ansible-lint site.yml', 'command-instead-of-module: apt-get used in place of apt module\nsite.yml:14 Task/Handler: shell apt-get install -y nginx\nname[missing]: All tasks should be named\nsite.yml:22', 'ansible-lint signale une installation via shell et une tâche sans nom. On l’intègre dans la CI pour bloquer ces erreurs avant qu’elles atteignent la production.']
+],
+termes: ['Ansible', 'playbook', 'inventaire', 'module', 'tâche', 'handler', 'notify', 'idempotence', 'become', 'group_vars', 'host_vars', 'Jinja2', 'template', 'facts', 'rôle', 'collection', 'ansible-galaxy', 'Ansible Vault', 'ansible-lint', '--check', '--diff', '--limit', 'serial', 'validate', 'changed=0']
+});
+})();

portail/public/js/contenus-devops-2.js

@@ -0,0 +1,122 @@
+// Cours complets · DevOps lot 2 : Git, CI/CD
+(function () {
+var reg = function (c) {
+  (window.CONTENUS_PRO = window.CONTENUS_PRO || []).unshift(c.cours);
+  (window.CONTENUS_PLUS = window.CONTENUS_PLUS || {})[c.cours.id] = c.plus;
+  (window.CONTENUS_EXEMPLES = window.CONTENUS_EXEMPLES || {})[c.cours.id] = c.exemples;
+  (window.CONTENUS_SCHEMAS = window.CONTENUS_SCHEMAS || {})[c.cours.id] = { termes: c.termes, figs: [] };
+};
+
+reg({
+cours: { id: 'git', match: /\bGit\b|versionn|gestion de versions/i,
+  titre: 'Git : versionner, collaborer et revenir en arrière', duree: '',
+  niveau: 'NSI Terminale · BTS SIO SLAM / SISR · BUT Informatique / R&T · Master',
+  prerequis: ['Le terminal Linux'],
+  competences: ['BTS SIO · Bloc 1 · Travailler en mode projet', 'BTS SIO SLAM · Bloc 2 · Gérer les versions d’une solution applicative', 'BUT Info · Compétence « Collaborer au sein d’une équipe informatique »'],
+  intro: 'Un fichier « rapport_final_v3_corrigé_VRAIMENT_final.docx » résume le problème que Git résout. Dès que plusieurs personnes modifient le même code, ou qu’une seule personne veut pouvoir revenir à la version d’hier, il faut un historique fiable. Git enregistre chaque état du projet, permet de travailler en parallèle sur des branches et de fusionner le travail de chacun. C’est l’outil commun à tous les développeurs et, de plus en plus, aux administrateurs qui versionnent leurs configurations, leurs playbooks et leurs fichiers Compose.',
+  cm: [
+    { t: 'Le modèle de Git : instantanés et empreintes', d: '', html: 'Git ne stocke pas des différences mais des <b>instantanés</b> complets du projet. Chaque fichier, chaque dossier et chaque <b>commit</b> est un objet identifié par l’empreinte de son contenu (SHA-1, en transition vers SHA-256). Deux fichiers identiques ne sont stockés qu’une fois, et toute modification de l’historique change les empreintes : l’intégrité est vérifiable.<br><br>Un commit contient un instantané, un auteur, une date, un message et un lien vers son ou ses <b>parents</b>. L’historique est donc un graphe orienté de commits. Une <b>branche</b> n’est qu’un pointeur mobile vers un commit, et <b>HEAD</b> désigne la branche ou le commit sur lequel on travaille.' },
+    { t: 'Les trois zones', d: '', html: 'Un fichier passe par trois zones. Le <b>répertoire de travail</b> contient les fichiers tels qu’on les édite. L’<b>index</b> (staging area) contient ce qui sera enregistré au prochain commit : on y ajoute les modifications avec <code>git add</code>. Le <b>dépôt</b> (.git) contient l’historique, et <code>git commit</code> y enregistre l’index.<br><br>Cette étape intermédiaire permet de faire des commits cohérents : on n’ajoute que les modifications qui vont ensemble, même si on a travaillé sur plusieurs sujets à la fois. <code>git status</code> montre à tout moment l’état des trois zones.', exemple: 'git init\ngit add index.html style.css\ngit commit -m "Page d’accueil du TP"\ngit status\ngit log --oneline --graph' },
+    { t: 'Branches et fusions', d: '', html: 'On crée une branche pour chaque fonctionnalité ou correction (<code>git switch -c correctif-login</code>). La branche principale (main) reste stable. Quand le travail est terminé, on le <b>fusionne</b>. Si main n’a pas bougé, Git avance simplement le pointeur (<b>fast-forward</b>). Sinon, il crée un <b>commit de fusion</b> qui a deux parents.<br><br>Si les deux branches ont modifié les mêmes lignes, Git ne peut pas choisir : c’est un <b>conflit</b>. Il marque les zones concernées dans le fichier (<code>&lt;&lt;&lt;&lt;&lt;&lt;&lt;</code>, <code>=======</code>, <code>&gt;&gt;&gt;&gt;&gt;&gt;&gt;</code>). On édite pour garder la bonne version, on ajoute le fichier et on termine le commit.<br><br>Le <b>rebase</b> est l’alternative à la fusion : il rejoue les commits d’une branche au-dessus d’une autre, pour un historique linéaire. Il réécrit les commits, donc on ne rebase jamais une branche déjà partagée.' },
+    { t: 'Travailler avec un dépôt distant', d: '', html: 'Un <b>dépôt distant</b> (GitHub, GitLab, Forgejo auto-hébergé) sert de point de rencontre. <code>git clone</code> copie un dépôt, <code>git fetch</code> récupère les nouveautés sans les appliquer, <code>git pull</code> récupère et fusionne, <code>git push</code> publie ses commits. Les branches distantes apparaissent sous le nom <code>origin/main</code>.<br><br>En équipe, on ne pousse pas directement sur main : on pousse une branche et on ouvre une <b>demande de fusion</b> (pull request ou merge request), relue par un collègue et validée par les tests automatiques avant d’être intégrée.', attention: 'Un push refusé (« rejected, non-fast-forward ») signifie que le dépôt distant a des commits que vous n’avez pas. On fait git pull (ou fetch puis rebase), jamais git push --force sur une branche partagée : on effacerait le travail des autres.' },
+    { t: 'Revenir en arrière', d: '', html: 'Git offre plusieurs façons d’annuler, selon ce qu’on veut défaire. <code>git restore fichier</code> annule les modifications non ajoutées. <code>git restore --staged fichier</code> retire un fichier de l’index. <code>git commit --amend</code> corrige le dernier commit s’il n’a pas été poussé. <code>git revert id</code> crée un nouveau commit qui annule un commit précédent : c’est la seule méthode sûre sur un historique partagé. <code>git reset</code> déplace la branche en arrière et réécrit l’historique local.<br><br>Même après une erreur, rien n’est perdu tout de suite : <code>git reflog</code> liste les positions successives de HEAD et permet de retrouver un commit « supprimé ».' },
+    { t: 'Ce qui ne va pas dans Git', d: '', html: 'Le fichier <code>.gitignore</code> exclut ce qui ne doit pas être versionné : dépendances (node_modules, vendor), fichiers générés, journaux, et surtout <b>secrets</b> (.env, clés). Un mot de passe poussé une fois reste dans l’historique même après suppression du fichier : il faut le considérer comme compromis et le changer.<br><br>Un bon <b>message de commit</b> décrit pourquoi, pas seulement quoi : « Corrige le calcul de la moyenne quand un élève est absent » plutôt que « fix ». Beaucoup d’équipes adoptent la convention Conventional Commits (feat:, fix:, docs:).' }
+  ],
+  synthese: ['Git stocke des instantanés identifiés par empreinte ; une branche est un pointeur', 'Répertoire de travail → index (add) → dépôt (commit)', 'Une branche par fonctionnalité, fusion ou rebase ; conflit = même ligne modifiée des deux côtés', 'fetch, pull, push ; demande de fusion relue avant main', 'revert sur l’historique partagé, reset seulement en local, reflog pour retrouver', '.gitignore et aucun secret dans l’historique'],
+  qcm: [
+    ['Que contient l’index ?', ['L’historique', 'Ce qui sera enregistré au prochain commit', 'Les branches distantes', 'Les fichiers ignorés'], 1, 'On y ajoute avec git add.'],
+    ['Qu’est-ce qu’une branche pour Git ?', ['Une copie du projet', 'Un pointeur mobile vers un commit', 'Un dossier', 'Un dépôt distant'], 1, 'Créer une branche est instantané.'],
+    ['Quand survient un conflit de fusion ?', ['Toujours', 'Quand les deux branches ont modifié les mêmes lignes', 'Quand on oublie git add', 'Quand le dépôt est trop gros'], 1, 'Git ne peut pas choisir seul.'],
+    ['Comment annuler proprement un commit déjà poussé sur main ?', ['git reset --hard', 'git revert', 'git push --force', 'supprimer .git'], 1, 'revert ajoute un commit d’annulation.'],
+    ['Différence entre fetch et pull ?', ['Aucune', 'fetch récupère sans fusionner, pull récupère et fusionne', 'fetch publie', 'pull supprime'], 1, 'fetch est sans risque.'],
+    ['Un mot de passe a été poussé puis supprimé au commit suivant. Il est :', ['effacé', 'toujours dans l’historique, à changer', 'chiffré', 'invisible'], 1, 'L’historique garde tout.'],
+    ['Quelle commande retrouve un commit perdu après un reset ?', ['git log', 'git reflog', 'git status', 'git show'], 1, 'Historique des positions de HEAD.']
+  ],
+  td: [
+    { n: 'Échauffement', c: 'Initialiser un dépôt, créer README.md, le versionner, le modifier, afficher la différence, puis faire un second commit.', r: 'git init · git add README.md · git commit -m "…" · git diff · git commit -am "…"' },
+    { n: 'Application', c: 'Créer une branche nouvelle-page, y faire deux commits, revenir sur main, faire un commit qui touche la même ligne, fusionner et résoudre le conflit.', r: 'git switch -c nouvelle-page … git switch main … git merge nouvelle-page → conflit → éditer, git add, git commit' },
+    { n: 'Application', c: 'Écrire le .gitignore d’un projet Laravel.', r: '/vendor\n/node_modules\n.env\n/storage/*.key\n/public/storage\n*.log' },
+    { n: 'Approfondissement', c: 'Vous avez fait git reset --hard HEAD~2 par erreur. Retrouver les deux commits.', r: 'git reflog → repérer l’id avant le reset · git reset --hard <id> (ou git branch secours <id>)' }
+  ],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Un dépôt partagé sur un Forgejo de lab, travail en binôme.', etapes: ['Cloner le dépôt', 'Créer une branche et ouvrir une demande de fusion', 'Provoquer et résoudre un conflit avec le binôme', 'Annuler un commit avec revert', 'Retrouver un commit avec reflog'] },
+  plusLoin: [['Pro Git (livre officiel, en français)', 'https://git-scm.com/book/fr/v2'], ['Learn Git Branching (exercices interactifs)', 'https://learngitbranching.js.org/?locale=fr_FR'], ['Conventional Commits', 'https://www.conventionalcommits.org/fr/']] },
+plus: {
+  cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Vendredi 17 h : un développeur a poussé sur main un commit qui casse la page de connexion de l’application de vie scolaire, puis un collègue a déjà poussé deux commits par-dessus. Rétablir sans perdre le travail du collègue.', etapes: [
+    ['Identifier le commit fautif', 'git log --oneline -5\n9c1e4f2 Traductions du menu\n51ab0d7 Ajout export CSV\ne73f210 Refonte formulaire connexion\n4d02a9b Correctif date\n→ La panne est apparue après e73f210. Les deux commits suivants ne touchent pas à la connexion.'],
+    ['Confirmer avec git bisect si le doute subsiste', 'git bisect start ; git bisect bad ; git bisect good 4d02a9b\n… git bisect good / bad à chaque étape\ne73f210 is the first bad commit\ngit bisect reset\n→ bisect teste par dichotomie et désigne le premier commit fautif.'],
+    ['Annuler ce seul commit', 'git revert e73f210\n[main 0f5a8c3] Revert "Refonte formulaire connexion"\n→ Un nouveau commit annule les modifications de e73f210 ; les commits du collègue sont conservés. Surtout pas de reset suivi d’un push --force sur main.'],
+    ['Publier et vérifier', 'git push origin main\n→ La chaîne d’intégration redéploie ; la connexion fonctionne à nouveau.'],
+    ['Reprendre le travail proprement', 'git switch -c refonte-connexion\ngit revert 0f5a8c3   (réapplique la refonte sur la branche)\n→ La refonte est corrigée sur une branche, testée, puis fusionnée par demande de fusion. Action préventive : protéger main (fusion uniquement par demande relue et tests verts).']
+  ] },
+  erreurs: ['Pousser directement sur main', 'Utiliser push --force sur une branche partagée', 'Versionner .env ou des clés', 'Faire un seul énorme commit pour tout', 'Messages de commit du type « fix » ou « modif »', 'Rebaser une branche déjà partagée'],
+  memo: [['Commande', 'Usage'], ['git status', 'état des trois zones'], ['git add -p', 'ajouter une partie des modifications'], ['git commit -m "…"', 'enregistrer'], ['git log --oneline --graph --all', 'voir le graphe des commits'], ['git diff · git diff --staged', 'différences non ajoutées / ajoutées'], ['git switch -c <branche>', 'créer une branche et s’y placer'], ['git merge <branche>', 'fusionner'], ['git pull --rebase', 'récupérer en gardant un historique linéaire'], ['git push -u origin <branche>', 'publier une branche'], ['git revert <id>', 'annuler un commit partagé'], ['git reflog', 'retrouver une position perdue'], ['git bisect', 'trouver le commit qui a introduit un bug']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Expliquer les trois zones de Git avec un schéma. (4 pts)', 'Décrire les commandes d’un travail en branche jusqu’à la demande de fusion. (5 pts)', 'Résoudre un conflit fourni. (4 pts)', 'Choisir entre revert et reset dans trois situations. (4 pts)', 'Rédiger le .gitignore d’un projet donné. (3 pts)'], r: ['working tree, index, dépôt', 'switch -c, add, commit, push -u, PR', 'selon le fichier', 'partagé → revert, local → reset', 'dépendances, secrets, fichiers générés'] },
+  prof: { deroule: [['Ouverture', 'Le fichier « final_v3_VRAIMENT_final » projeté'], ['Cours', 'Commits, index, branches'], ['Pratique', 'Exercices Learn Git Branching'], ['Pratique', 'Binômes sur un dépôt partagé, conflit provoqué'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : fiche mémo, un seul flux sans branches. Élèves avancés : rebase interactif, bisect, hooks.', eval: 'Historique du dépôt de binôme évalué, sujet type.' }
+},
+exemples: [
+ ['Lire l’état du dépôt', 'Avant un commit.', 'git status -s', ' M app/Http/Controllers/NoteController.php\nM  routes/web.php\n?? notes.csv', 'M en deuxième colonne : modifié, pas encore ajouté. M en première : ajouté à l’index. ?? : fichier non suivi ; ici un export de notes à ne surtout pas versionner, à ajouter au .gitignore.'],
+ ['Voir le graphe', 'Comprendre où en sont les branches.', 'git log --oneline --graph --all -6', '* 9c1e4f2 (HEAD -> main, origin/main) Traductions du menu\n| * 3aa71be (export-pdf) Export PDF des bulletins\n|/\n* 51ab0d7 Ajout export CSV', 'La branche export-pdf est partie de 51ab0d7 ; main a avancé depuis. La fusion créera un commit de fusion, ou un rebase rendra l’historique linéaire.'],
+ ['Push refusé', 'Publication de son travail.', 'git push', '! [rejected] main -> main (fetch first)\nhint: Updates were rejected because the remote contains work that you do not have locally.', 'Un collègue a poussé avant vous. git pull --rebase rejoue vos commits au-dessus des siens, puis git push passe.'],
+ ['Résoudre un conflit', 'Fusion de deux branches.', 'git merge nouvelle-page ; git diff --name-only --diff-filter=U', 'CONFLICT (content): Merge conflict in index.html\nAutomatic merge failed; fix conflicts and then commit the result.\nindex.html', 'On ouvre index.html, on choisit le contenu entre les marqueurs, on supprime les marqueurs, puis git add index.html et git commit.'],
+ ['Retrouver un travail « perdu »', 'Après un reset malheureux.', 'git reflog -4', '4d02a9b HEAD@{0}: reset: moving to HEAD~2\n9c1e4f2 HEAD@{1}: commit: Traductions du menu\n51ab0d7 HEAD@{2}: commit: Ajout export CSV', 'Le commit 9c1e4f2 existe toujours. git reset --hard 9c1e4f2 le récupère.'],
+ ['Trouver qui a modifié une ligne', 'Une règle de calcul semble fausse.', 'git blame -L 42,44 app/Services/Moyenne.php', '51ab0d7 (Inès K. 2026-09-24) $coef = $note->coef ?? 1;\ne73f210 (Tom L.  2026-09-27) $total += $note->valeur;\ne73f210 (Tom L.  2026-09-27) return $total / count($notes);', 'blame associe chaque ligne à son dernier commit. La division par count($notes) ignore les coefficients : on regarde le commit e73f210 avec git show pour comprendre le changement.']
+],
+termes: ['Git', 'commit', 'index', 'branche', 'HEAD', 'main', 'merge', 'rebase', 'conflit', 'fast-forward', 'git add', 'git commit', 'git status', 'git log', 'git diff', 'git switch', 'git pull', 'git push', 'git fetch', 'git revert', 'git reset', 'git reflog', 'git bisect', 'git blame', '.gitignore', 'pull request', 'origin']
+});
+
+reg({
+cours: { id: 'cicd', match: /CI\/CD|intégration continue|déploiement continu|pipeline/i,
+  titre: 'CI/CD : intégration et déploiement continus', duree: '',
+  niveau: 'BTS SIO SLAM / SISR · BUT Informatique / R&T DevCloud · AIS · Master',
+  prerequis: ['Git', 'Conteneurs Docker'],
+  competences: ['BTS SIO SLAM · Bloc 2 · Déployer et tester une solution applicative', 'BUT R&T DevCloud · Automatiser le déploiement', 'AIS · Industrialiser les mises en production'],
+  intro: 'Livrer à la main, c’est se connecter au serveur, tirer le code, lancer les migrations, vider les caches et espérer ne rien oublier. Une chaîne d’intégration et de déploiement continus automatise ces étapes : à chaque push, les tests s’exécutent, l’image est construite et, si tout est vert, l’application est déployée. Les erreurs sont détectées en minutes plutôt qu’en production, et chaque livraison devient un non-événement.',
+  cm: [
+    { t: 'Intégration, livraison, déploiement', d: '', html: 'L’<b>intégration continue</b> (CI) fusionne le travail de chacun fréquemment et vérifie automatiquement chaque modification : compilation, analyse statique, tests. La <b>livraison continue</b> (continuous delivery) produit à chaque fois un artefact prêt à déployer, la mise en production restant une décision humaine. Le <b>déploiement continu</b> (continuous deployment) va jusqu’à la production sans intervention.<br><br>Le principe commun : la branche principale est toujours dans un état déployable, et toute régression est signalée immédiatement à celui qui l’a introduite.' },
+    { t: 'Anatomie d’un pipeline', d: '', html: 'Un <b>pipeline</b> est une suite d’<b>étapes</b> (stages) composées de <b>jobs</b>, exécutés par des <b>runners</b> dans des environnements propres, souvent des conteneurs. On y trouve typiquement : vérification du style (lint), tests unitaires, construction de l’image, analyse de sécurité, publication dans un registre, déploiement en préproduction, puis en production.<br><br>Chaque job reçoit le code du commit, produit éventuellement des <b>artefacts</b> (paquet, rapport de tests, image) et renvoie un statut. Un seul échec arrête le pipeline.', exemple: '# .github/workflows/ci.yml  (GitHub Actions)\nname: ci\non: [push, pull_request]\njobs:\n  tests:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-python@v5\n        with: { python-version: "3.12" }\n      - run: pip install -r requirements.txt\n      - run: ruff check .\n      - run: pytest -q\n  image:\n    needs: tests\n    if: github.ref == \'refs/heads/main\'\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - run: docker build -t registre.lycee.local/resa:${{ github.sha }} .\n      - run: trivy image --exit-code 1 --severity HIGH,CRITICAL registre.lycee.local/resa:${{ github.sha }}\n      - run: docker push registre.lycee.local/resa:${{ github.sha }}' },
+    { t: 'Les tests, cœur de la CI', d: '', html: 'Une CI ne vaut que par ses tests. Les <b>tests unitaires</b> vérifient une fonction isolée, en millisecondes. Les <b>tests d’intégration</b> vérifient l’application avec sa base de données, souvent démarrée comme service du pipeline. Les <b>tests de bout en bout</b> pilotent un navigateur (Playwright, Cypress). On en écrit beaucoup des premiers, peu des derniers : c’est la pyramide des tests.<br><br>Un test instable (qui échoue une fois sur dix sans raison) est pire que pas de test : l’équipe apprend à ignorer le rouge. Il se corrige en priorité.' },
+    { t: 'Déployer sans interruption', d: '', html: 'Le déploiement tire l’image construite et testée, identifiée par l’empreinte du commit, jamais par latest. Plusieurs stratégies limitent le risque. Le <b>déploiement progressif</b> (rolling) remplace les instances une à une. Le <b>blue-green</b> prépare la nouvelle version à côté de l’ancienne puis bascule le trafic. Le <b>canary</b> envoie d’abord une petite part des utilisateurs sur la nouvelle version.<br><br>Dans tous les cas, on prévoit le <b>retour arrière</b> : redéployer l’image précédente doit prendre une commande. Les migrations de base de données doivent rester compatibles avec la version précédente le temps de la bascule.' },
+    { t: 'Secrets et sécurité de la chaîne', d: '', html: 'Le pipeline manipule des secrets : accès au registre, clés SSH de déploiement, jetons d’API. Ils se stockent dans le gestionnaire de secrets de la plateforme (secrets GitHub, variables masquées GitLab), jamais dans le dépôt, et avec des droits minimaux (une clé de déploiement ne peut que déployer).<br><br>La chaîne elle-même est une cible : une action tierce compromise ou une dépendance malveillante s’exécute avec les secrets du pipeline. On épingle les actions sur une version précise, on analyse les dépendances (Dependabot, Renovate) et on protège les branches : pas de déploiement en production depuis une branche non relue.' }
+  ],
+  synthese: ['CI : vérifier chaque modification ; CD : livrer ou déployer automatiquement', 'Pipeline = étapes → jobs → runners, arrêt au premier échec', 'Pyramide des tests ; un test instable se corrige en priorité', 'Image identifiée par le commit ; stratégie de déploiement et retour arrière prévus', 'Secrets dans la plateforme, actions épinglées, branches protégées'],
+  qcm: [
+    ['Différence entre livraison continue et déploiement continu ?', ['Aucune', 'La livraison laisse la mise en production à une décision humaine', 'Le déploiement ne teste pas', 'La livraison est manuelle'], 1, 'Continuous delivery vs deployment.'],
+    ['Que se passe-t-il quand un job échoue ?', ['Le pipeline continue', 'Le pipeline s’arrête et signale l’échec', 'Le job est ignoré', 'Le code est supprimé'], 1, 'On ne déploie pas du rouge.'],
+    ['Pourquoi taguer l’image avec l’empreinte du commit ?', ['Esthétique', 'Pour savoir exactement quel code tourne et pouvoir revenir en arrière', 'Obligatoire', 'Plus léger'], 1, 'Traçabilité et reproductibilité.'],
+    ['Quelle stratégie envoie d’abord 5 % des utilisateurs sur la nouvelle version ?', ['Rolling', 'Blue-green', 'Canary', 'Big bang'], 2, 'Détection précoce sur un petit échantillon.'],
+    ['Où stocker la clé de déploiement ?', ['Dans le dépôt', 'Dans les secrets de la plateforme CI', 'Dans le Dockerfile', 'Dans le README'], 1, 'Jamais dans le code.'],
+    ['Que faire d’un test qui échoue au hasard ?', ['L’ignorer', 'Le corriger en priorité', 'Le supprimer toujours', 'Relancer jusqu’au vert'], 1, 'Sinon on ne croit plus au rouge.']
+  ],
+  td: [
+    { n: 'Application', c: 'Écrire un pipeline GitLab CI (.gitlab-ci.yml) en trois étapes : lint, test, build, avec une base PostgreSQL en service pour les tests.', r: 'stages: [lint, test, build]\nlint: { stage: lint, image: python:3.12, script: [pip install ruff, ruff check .] }\ntest: { stage: test, image: python:3.12, services: [postgres:16], variables: { POSTGRES_PASSWORD: test, DATABASE_URL: postgresql://postgres:test@postgres/postgres }, script: [pip install -r requirements.txt, pytest] }\nbuild: { stage: build, image: docker:27, services: [docker:27-dind], script: [docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA ., docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA], rules: [{ if: $CI_COMMIT_BRANCH == "main" }] }' },
+    { n: 'Application', c: 'Proposer une procédure de retour arrière pour une application déployée avec Compose et des images taguées par commit.', r: 'Garder le tag précédent dans l’historique des déploiements · modifier le tag dans compose.yaml (ou variable IMAGE_TAG) · docker compose pull && up -d · vérifier · migrations compatibles N-1.' },
+    { n: 'Approfondissement', c: 'Lister les risques de sécurité d’un pipeline et une mesure pour chacun.', r: 'Secret fuité → secrets masqués, droits minimaux · action tierce compromise → épingler par empreinte · dépendance malveillante → analyse et verrouillage des versions · déploiement non relu → branches protégées.' }
+  ],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Un Forgejo avec runner, une API et son déploiement.', etapes: ['Écrire le workflow lint + tests', 'Casser un test et observer le blocage', 'Construire et scanner l’image', 'Déployer sur la VM de préproduction', 'Revenir à la version précédente'] },
+  plusLoin: [['GitHub Actions · documentation', 'https://docs.github.com/fr/actions'], ['GitLab CI/CD · documentation', 'https://docs.gitlab.com/ee/ci/'], ['Forgejo Actions', 'https://forgejo.org/docs/latest/user/actions/']] },
+plus: {
+  cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Le pipeline de l’application de réservation est rouge depuis ce matin sur l’étape tests, alors que les tests passent sur le poste du développeur. Plus aucune correction ne peut être déployée.', etapes: [
+    ['Lire le job en échec', 'tests / pytest\nE   sqlalchemy.exc.OperationalError: could not connect to server: Connection refused\n    Is the server running on host "localhost" and accepting TCP/IP connections on port 5432?\n→ Ce n’est pas un test fonctionnel qui échoue : l’application ne trouve pas sa base.'],
+    ['Comparer les environnements', 'Sur le poste : PostgreSQL installé localement, DATABASE_URL absente → valeur par défaut localhost.\nDans le pipeline : la base est un service nommé postgres.\n→ Un commit d’hier a supprimé la variable DATABASE_URL du workflow en « nettoyant » le fichier.'],
+    ['Corriger le workflow', 'services:\n  postgres:\n    image: postgres:16\n    env: { POSTGRES_PASSWORD: test }\n    options: --health-cmd pg_isready --health-interval 5s --health-retries 10\nenv:\n  DATABASE_URL: postgresql://postgres:test@localhost:5432/postgres\n→ Le service est déclaré avec un healthcheck et la variable est rétablie.'],
+    ['Vérifier', 'git push → pipeline : lint ✓ tests ✓ image ✓\n→ Le pipeline est vert ; la correction en attente est déployée.'],
+    ['Prévenir', '→ Le fichier de workflow passe sous relue obligatoire (CODEOWNERS), et un test de fumée vérifie au démarrage que DATABASE_URL est définie, avec un message explicite plutôt qu’une erreur de connexion.']
+  ] },
+  erreurs: ['Pipeline sans tests réels', 'Tolérer un pipeline rouge « connu »', 'Déployer l’image latest', 'Secrets en clair dans le workflow', 'Actions tierces non épinglées', 'Pas de procédure de retour arrière'],
+  memo: [['Élément', 'À retenir'], ['on: push / pull_request', 'déclencheurs d’un workflow GitHub'], ['needs:', 'ordre entre jobs'], ['services:', 'base de données pour les tests'], ['secrets.NOM', 'accès à un secret masqué'], ['rules / if', 'n’exécuter que sur main'], ['artifacts', 'conserver rapports et paquets'], ['cache', 'accélérer les dépendances'], ['${{ github.sha }} / $CI_COMMIT_SHA', 'taguer l’image par commit'], ['trivy image --exit-code 1', 'bloquer sur une vulnérabilité critique'], ['environments + approbation', 'validation humaine avant production']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Définir CI, livraison et déploiement continus. (3 pts)', 'Écrire un pipeline complet pour une application fournie. (8 pts)', 'Comparer trois stratégies de déploiement. (4 pts)', 'Diagnostiquer un pipeline en échec à partir d’un journal. (3 pts)', 'Citer deux risques de sécurité de la chaîne. (2 pts)'], r: ['voir cours', 'lint, tests, build, push, deploy', 'rolling, blue-green, canary', 'selon le journal', 'secrets, actions tierces'] },
+  prof: { deroule: [['Ouverture', 'Déploiement manuel chronométré, puis le même en un push'], ['Cours', 'Pipeline, tests, artefacts'], ['Pratique', 'Workflow lint + tests'], ['Pratique', 'Build et déploiement'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : workflow à compléter. Élèves avancés : déploiement canary, analyse de dépendances.', eval: 'Pipeline vert et retour arrière démontré, sujet type.' }
+},
+exemples: [
+ ['Lire l’état des pipelines', 'Après un push.', 'gh run list --limit 3', 'STATUS  TITLE                  WORKFLOW  BRANCH\n✓       Export CSV             ci        main\nX       Refonte connexion      ci        refonte\n✓       Traductions            ci        main', 'La branche refonte est rouge : elle ne pourra pas être fusionnée tant que la protection de branche exige des tests verts.'],
+ ['Voir le journal d’un job', 'Pipeline rouge.', 'gh run view --log-failed | tail -4', 'tests  FAILED tests/test_moyenne.py::test_absent - ZeroDivisionError\ntests  1 failed, 47 passed in 3.21s', 'Un seul test échoue, avec une erreur précise : la moyenne d’un élève sans note divise par zéro. La CI a attrapé le bug avant la production.'],
+ ['Relancer localement comme la CI', 'Reproduire un échec.', 'docker run --rm -v "$PWD":/app -w /app python:3.12 sh -c "pip install -q -r requirements.txt && pytest -q"', '1 failed, 47 passed', 'Exécuter les tests dans la même image que la CI élimine le « chez moi ça marche ».'],
+ ['Bloquer une image vulnérable', 'Étape de sécurité.', 'trivy image --exit-code 1 --severity CRITICAL registre.lycee.local/resa:9c1e4f2', 'Total: 1 (CRITICAL: 1)\nopenssl 3.0.2  CVE-2024-XXXX  fixed in 3.0.14', 'Le code de sortie 1 fait échouer le job : l’image n’est pas publiée. On met à jour l’image de base et on reconstruit.'],
+ ['Déployer une version précise', 'Déploiement depuis le pipeline.', 'ssh deploy@preprod "cd /srv/resa && IMAGE_TAG=9c1e4f2 docker compose up -d && docker compose ps"', 'resa-app  registre.lycee.local/resa:9c1e4f2  Up 5 seconds (healthy)', 'Le tag est l’empreinte du commit : on sait exactement quel code tourne.'],
+ ['Revenir en arrière', 'La nouvelle version provoque des erreurs.', 'ssh deploy@prod "cd /srv/resa && IMAGE_TAG=51ab0d7 docker compose up -d"', 'Container resa-app  Recreated', 'Retour à la version précédente en une commande, parce que chaque image est conservée avec son tag de commit.']
+],
+termes: ['CI/CD', 'intégration continue', 'déploiement continu', 'livraison continue', 'pipeline', 'job', 'runner', 'artefact', 'workflow', 'GitHub Actions', 'GitLab CI', 'Forgejo', 'tests unitaires', 'lint', 'canary', 'blue-green', 'rolling', 'retour arrière', 'secrets', 'Trivy']
+});
+})();

portail/public/js/contenus-exemples.js

@@ -0,0 +1,183 @@
+// Exemples concrets commentés : [titre, contexte, code, sortie, explication]
+window.CONTENUS_EXEMPLES = {
+binaire: [
+ ['Lire une adresse MAC', 'Sur l’étiquette d’une carte réseau.', '3C:52:82:1A:0F:9B', '6 octets · 3C = 0011 1100 = 60', 'Chaque paire hexadécimale est un octet. Les 3 premiers identifient le fabricant (OUI), les 3 derniers la carte.'],
+ ['Décoder une couleur web', 'Dans une feuille CSS.', '#FF6FB5', 'rouge 255 · vert 111 · bleu 181', 'Trois octets en hexadécimal. FF est le maximum : la couleur est très rouge, un peu bleue, c’est un rose.'],
+ ['Calculer un masque de tête', 'Un collègue demande « c’est quoi un /22 ? ».', '/22 = 11111111.11111111.11111100.00000000', '255.255.252.0 · 1 022 hôtes', '22 bits à 1 : deux octets pleins, puis 6 bits à 1 (128+64+32+16+8+4 = 252). Il reste 10 bits d’hôte : 2¹⁰ − 2 = 1 022.'],
+ ['Convertir en Python', 'Vérifier un calcul fait à la main.', 'bin(178), hex(178), int("B2", 16), int("10110010", 2)', "('0b10110010', '0xb2', 178, 178)", 'bin et hex convertissent vers le texte ; int avec une base convertit dans l’autre sens.'],
+ ['Débordement sur 8 bits', 'Un compteur de capteur repasse à zéro.', 'compteur = (255 + 1) % 256', '0', 'Sur un octet non signé, 255 + 1 ne tient plus : le 9e bit est perdu et l’on repart de 0.'],
+ ['Taille d’une image', 'Estimer le poids d’une photo non compressée.', '1920 × 1080 pixels × 3 octets', '6 220 800 octets ≈ 5,9 Mio', 'Chaque pixel a 3 couleurs sur 1 octet. C’est pour cela qu’on compresse en JPEG ou PNG.']],
+terminal: [
+ ['Préparer un TP', 'Créer d’un coup l’arborescence d’un projet.', 'mkdir -p ~/tp/{reseau,systeme,web} && ls ~/tp', 'reseau  systeme  web', 'Les accolades génèrent trois chemins. -p évite l’erreur si ~/tp existe déjà.'],
+ ['Retrouver un fichier perdu', 'Un élève ne sait plus où il a enregistré rapport.txt.', 'find ~ -name "rapport*.txt" 2>/dev/null', '/home/eleve/Documents/old/rapport-v2.txt', 'find part du dossier personnel ; 2>/dev/null masque les dossiers inaccessibles.'],
+ ['Voir les derniers événements', 'Le service web ne démarre pas.', 'sudo journalctl -u apache2 -n 20 --no-pager', 'AH00072: make_sock: could not bind to address [::]:80', 'Le port 80 est déjà pris par un autre programme : on le cherche avec sudo ss -tlnp | grep :80.'],
+ ['Sauvegarder un dossier', 'Avant une modification risquée.', 'tar czf site-$(date +%F).tar.gz /var/www/site', 'site-2026-09-30.tar.gz', '$(date +%F) insère la date du jour : chaque sauvegarde a un nom unique.'],
+ ['Repérer ce qui ralentit la machine', 'Le serveur répond lentement.', 'ps aux --sort=-%cpu | head -5', 'www-data 8812 97.3 … php-fpm', 'Un processus PHP consomme presque tout le processeur : on regarde le script en cause avant de le tuer.'],
+ ['Rejouer une commande', 'Vous avez tapé une longue commande hier.', 'Ctrl+R puis « rsync »', '(reverse-i-search)`rsync\': rsync -av site/ srv:/var/www/', 'La recherche dans l’historique évite de tout retaper.']],
+droits: [
+ ['Lire une ligne de ls -l', 'Comprendre pourquoi un fichier est inaccessible.', 'ls -l notes.csv', '-rw-r----- 1 alice profs 4096 sept. 30 notes.csv', 'alice lit et écrit, le groupe profs lit, les autres rien. Un élève ne peut pas l’ouvrir.'],
+ ['Rendre un script exécutable', '« Permission non accordée » au lancement.', 'chmod u+x sauvegarde.sh && ./sauvegarde.sh', 'Sauvegarde terminée.', 'Seul le propriétaire reçoit le droit d’exécution, pas tout le monde.'],
+ ['Créer un espace partagé', 'Les profs de SIO veulent un dossier commun.', 'sudo mkdir /srv/sio && sudo chown root:profsio /srv/sio && sudo chmod 2770 /srv/sio', 'drwxrws--- root profsio /srv/sio', 'Le s du groupe (SGID) fait que chaque fichier créé appartient à profsio.'],
+ ['Vérifier ses groupes', 'Après avoir été ajouté à un groupe.', 'id', 'uid=1001(bob) … groupes=1001(bob),1002(devs)', 'Si devs n’apparaît pas, il faut se déconnecter puis se reconnecter.'],
+ ['Trouver les fichiers trop ouverts', 'Audit rapide d’un serveur.', 'sudo find /var/www -perm -o+w -type f', '/var/www/site/config.php', 'Un fichier de configuration modifiable par tous est une faille : chmod o-w config.php.'],
+ ['Donner un accès ponctuel', 'Un stagiaire doit lire un seul rapport.', 'setfacl -m u:stagiaire:r rapport.pdf && getfacl rapport.pdf', 'user:stagiaire:r--', 'L’ACL donne l’accès à une seule personne sans toucher au groupe.']],
+tubes: [
+ ['Compter les comptes humains', 'Combien d’utilisateurs ont un shell ?', 'grep -c "/bin/bash$" /etc/passwd', '14', 'grep -c compte au lieu d’afficher ; $ ancre la recherche en fin de ligne.'],
+ ['Top des pages visitées', 'Préparer un bilan pour la direction.', "awk '{print $7}' /var/log/apache2/access.log | sort | uniq -c | sort -rn | head -3", '  812 /\n  430 /planning\n  211 /cours', 'Le 7e champ d’une ligne Apache est le chemin demandé.'],
+ ['Suivre les connexions en direct', 'Pendant un examen en ligne.', 'tail -f /var/log/auth.log | grep --line-buffered sshd', 'Accepted publickey for prof from 10.0.0.12', 'tail -f affiche au fil de l’eau ; --line-buffered évite que grep retienne les lignes.'],
+ ['Nettoyer les vieux journaux', 'Libérer de l’espace chaque semaine.', 'find /var/log/app -name "*.log" -mtime +30 | xargs rm -v', "supprimé '/var/log/app/2026-07-01.log'", 'xargs transforme la liste en arguments pour rm.'],
+ ['Remplacer dans un fichier', 'Passer toutes les URL en HTTPS.', "sed -i 's#http://#https://#g' index.html", '(aucune sortie)', '-i modifie le fichier sur place ; # remplace / comme séparateur pour éviter d’échapper les barres.'],
+ ['Garder une trace d’un diagnostic', 'Envoyer le résultat au support.', './diagnostic.sh 2>&1 | tee rapport.txt', '(affichage à l’écran + fichier rapport.txt)', '2>&1 fusionne les erreurs dans la sortie, tee écrit tout dans le fichier.']],
+osi: [
+ ['Tester la couche 3', 'Le poste accède-t-il à la passerelle ?', 'ping -c 3 192.168.10.1', '3 packets transmitted, 3 received, 0% packet loss', 'La couche réseau fonctionne jusqu’à la passerelle.'],
+ ['Suivre le chemin d’un paquet', 'Un site distant est lent.', 'traceroute www.lycee.fr', ' 1  192.168.10.1  1 ms\n 2  10.0.0.1  4 ms\n 3  * * *\n 4  93.184.216.34  18 ms', 'Chaque ligne est un routeur. Les étoiles indiquent un routeur qui ne répond pas à ICMP, pas forcément une panne.'],
+ ['Voir les services qui écoutent', 'Le site ne répond pas.', 'sudo ss -tlnp', 'LISTEN 0 511 *:80 users:(("apache2",pid=812))', 'Apache écoute bien sur le port 80 en TCP : le problème est ailleurs (pare-feu, DNS).'],
+ ['Interroger le DNS', 'Vérifier une nouvelle entrée.', 'dig +short intranet.lycee.fr', '192.168.10.20', 'Le nom se résout : la couche application peut être testée avec curl.'],
+ ['Lire la table ARP', 'Suspicion de conflit d’adresse.', 'ip neigh', '192.168.10.1 dev eth0 lladdr 3c:52:82:1a:0f:9b REACHABLE', 'Si deux IP différentes affichent la même MAC, on soupçonne une usurpation ARP.'],
+ ['Capturer une poignée de main', 'Observer TCP en vrai.', 'sudo tcpdump -i eth0 -n "tcp port 443 and tcp[tcpflags] & tcp-syn != 0"', 'Flags [S] … Flags [S.] …', '[S] = SYN envoyé, [S.] = SYN-ACK reçu.']],
+sql: [
+ ['Liste de classe', 'Imprimer la liste de BTS SIO 1.', "SELECT nom, prenom FROM eleves e JOIN classes c ON c.id = e.classe_id WHERE c.libelle = 'BTS SIO 1' ORDER BY nom;", 'Diallo Adam · Kaci Inès · Martin Léa …', 'La jointure permet de filtrer par libellé plutôt que par numéro.'],
+ ['Moyenne par classe', 'Préparer le conseil de classe.', 'SELECT c.libelle, ROUND(AVG(e.moyenne), 1) AS moy FROM eleves e JOIN classes c ON c.id = e.classe_id GROUP BY c.libelle;', 'BTS SIO 1 | 11.8\nBTS SIO 2 | 12.6', 'AVG calcule la moyenne de chaque groupe, ROUND arrondit.'],
+ ['Élèves sans rendu', 'Relancer ceux qui n’ont pas rendu le DM.', 'SELECT e.nom FROM eleves e LEFT JOIN rendus r ON r.eleve_id = e.id AND r.devoir_id = 3 WHERE r.eleve_id IS NULL;', 'Petit · Leroy', 'LEFT JOIN garde tout le monde ; IS NULL isole ceux qui n’ont pas de correspondance.'],
+ ['Top 3', 'Afficher les meilleures notes du DM.', 'SELECT e.nom, r.note FROM rendus r JOIN eleves e ON e.id = r.eleve_id WHERE r.devoir_id = 3 ORDER BY r.note DESC LIMIT 3;', 'Kaci 19 · Nguyen 16 · Martin 11', 'ORDER BY … DESC puis LIMIT pour un classement.'],
+ ['Corriger une erreur de saisie', 'Une note a été saisie à 1,5 au lieu de 15.', 'UPDATE rendus SET note = 15 WHERE eleve_id = 7 AND devoir_id = 3;', '1 ligne modifiée', 'Le WHERE est testé d’abord avec un SELECT pour vérifier qu’il ne vise qu’une ligne.'],
+ ['Bloquer une injection', 'Formulaire de connexion en PHP.', '$st = $pdo->prepare("SELECT id FROM users WHERE login = ?");\n$st->execute([$_POST["login"]]);', '(la saisie n’est jamais interprétée comme du SQL)', 'Même si l’utilisateur tape \' OR 1=1 --, la requête cherche ce texte littéral.']],
+python: [
+ ['Moyenne d’une classe', 'Calcul rapide à partir d’une liste.', 'notes = [12, 15, 9, 18, 7]\nprint(round(sum(notes) / len(notes), 2))', '12.2', 'sum additionne, len compte ; round arrondit à 2 décimales.'],
+ ['Saisie robuste', 'Le programme ne doit pas planter sur « douze ».', 'try:\n    n = int(input("Note : "))\nexcept ValueError:\n    print("Entrez un nombre")', 'Note : douze\nEntrez un nombre', 'L’exception est capturée ; le programme continue.'],
+ ['Compter les mots', 'Analyser un texte.', 'texte = "le chat et le chien"\nc = {}\nfor m in texte.split():\n    c[m] = c.get(m, 0) + 1\nprint(c)', "{'le': 2, 'chat': 1, 'et': 1, 'chien': 1}", 'get(m, 0) renvoie 0 si le mot n’est pas encore dans le dictionnaire.'],
+ ['Filtrer en une ligne', 'Lister les élèves admis.', 'eleves = {"Léa": 12, "Tom": 8, "Inès": 17}\nprint([n for n, v in eleves.items() if v >= 10])', "['Léa', 'Inès']", 'Liste en compréhension : on lit « les noms n pour chaque paire si la note ≥ 10 ».'],
+ ['Lire un CSV exporté', 'Fichier de notes du logiciel de vie scolaire.', 'import csv\nwith open("notes.csv", encoding="utf-8") as f:\n    for l in csv.DictReader(f, delimiter=";"):\n        if float(l["note"]) < 8: print(l["nom"])', 'Petit\nLeroy', 'DictReader donne chaque ligne comme un dictionnaire, indexé par les en-têtes.'],
+ ['Jeu du nombre mystère', 'Premier programme complet.', 'import random\ns = random.randint(1, 100)\nwhile (p := int(input("? "))) != s:\n    print("plus" if p < s else "moins")\nprint("Trouvé !")', '? 50\nplus\n? 75\nmoins\n? 62\nTrouvé !', 'while répète tant que la proposition est fausse ; l’opérateur := affecte et teste en même temps.']],
+web: [
+ ['Voir une requête HTTP', 'Comprendre ce qu’envoie le serveur.', 'curl -I https://example.org', 'HTTP/2 200\ncontent-type: text/html; charset=UTF-8', '-I n’affiche que les en-têtes : code, type de contenu, taille.'],
+ ['Page minimale valide', 'Point de départ de tout site.', '<!doctype html>\n<html lang="fr">\n<head><meta charset="utf-8"><title>TP</title></head>\n<body><h1>Bonjour</h1></body>\n</html>', '(une page avec un titre)', 'lang aide les lecteurs d’écran, charset évite les accents cassés.'],
+ ['Grille de 3 cartes', 'Mise en page moderne.', '.grille { display: grid; grid-template-columns: repeat(3, 1fr); gap: 16px; }\n@media (max-width: 700px) { .grille { grid-template-columns: 1fr; } }', '3 colonnes sur ordinateur, 1 sur téléphone', 'Deux règles suffisent pour une mise en page adaptative.'],
+ ['Réagir à un clic', 'Bouton « Lever la main ».', 'document.querySelector("#main").addEventListener("click", () => {\n  document.body.style.background = "#FFD23F";\n});', '(la page devient jaune au clic)', 'addEventListener branche une fonction sur un événement.'],
+ ['Diagnostiquer une 404', 'Une image ne s’affiche pas.', 'sudo tail -1 /var/log/apache2/access.log', '"GET /img/Logo.png HTTP/1.1" 404', 'Linux distingue les majuscules : le fichier s’appelle logo.png.'],
+ ['Empêcher une XSS', 'Afficher un commentaire de visiteur en PHP.', 'echo htmlspecialchars($commentaire, ENT_QUOTES, "UTF-8");', '&lt;script&gt; s’affiche comme du texte', 'Les caractères spéciaux sont échappés : le navigateur n’exécute rien.']],
+crypto: [
+ ['Vérifier un téléchargement', 'Image ISO de Debian.', 'sha256sum -c SHA256SUMS --ignore-missing', 'debian-13.iso: Réussi', 'L’empreinte du fichier correspond à celle publiée : le fichier est intact.'],
+ ['Constater l’effet avalanche', 'Changer une seule lettre.', 'echo -n bonjour | sha256sum\necho -n Bonjour | sha256sum', '2cb4b143… \n9172e8ee…', 'Une majuscule suffit à changer complètement l’empreinte.'],
+ ['Hacher un mot de passe en Python', 'Application web.', 'import bcrypt\nh = bcrypt.hashpw(b"Soleil2026!", bcrypt.gensalt())\nbcrypt.checkpw(b"Soleil2026!", h)', 'True', 'gensalt produit un sel aléatoire, stocké dans le hachage lui-même.'],
+ ['Générer une clé SSH', 'Première connexion à un serveur.', 'ssh-keygen -t ed25519 -C "eleve@syllabus"', 'Your public key has been saved in ~/.ssh/id_ed25519.pub', 'Deux fichiers : la clé privée (à garder) et la clé publique (.pub, à déposer).'],
+ ['Lire un certificat', 'Vérifier qui a signé le certificat d’un site.', 'echo | openssl s_client -connect example.org:443 2>/dev/null | openssl x509 -noout -issuer -dates', "issuer=… DigiCert …\nnotAfter=Jan 15 2027", 'On voit l’autorité et la date d’expiration.'],
+ ['Chiffrer un fichier', 'Envoyer les bulletins à la direction.', 'gpg -c --cipher-algo AES256 bulletins.pdf', 'bulletins.pdf.gpg', 'Le mot de passe se transmet par un autre canal (téléphone), jamais dans le même mail.']]
+};
+
+// === DIAGNOSTIC RÉSEAU === Cours complet : ip, ping, traceroute, ss, ARP, tcpdump / Wireshark
+(function () {
+window.CONTENUS_PRO = window.CONTENUS_PRO || [];
+window.CONTENUS_PRO.unshift({
+  id: 'diagnostic',
+  match: /diagnostic réseau|outils de diagnostic|dépannage réseau/i,
+  titre: 'Diagnostic réseau en ligne de commande : ip, ping, traceroute, ss, ARP, tcpdump',
+  duree: '',
+  niveau: 'BTS SIO SISR · BTS CIEL IR · BUT R&T · Titre pro TSSR / AIS',
+  prerequis: ['Modèles OSI et TCP/IP, encapsulation', 'Adressage IPv4 et masques', 'Le terminal Linux'],
+  competences: ['BTS SIO · Bloc 1 · Répondre aux incidents et aux demandes d’assistance', 'BTS SIO SISR · Bloc 2 · Exploiter, dépanner et superviser une solution d’infrastructure réseau', 'BTS CIEL · C09 · Maintenir un réseau', 'BUT R&T · Compétence « Administrer les réseaux et l’Internet »', 'TSSR · Exploiter et maintenir les serveurs et le réseau'],
+  intro: 'Un serveur de production n’a presque jamais d’interface graphique. Il est rangé dans une baie, dans un datacenter à Paris ou à Roubaix, et l’on s’y connecte en SSH depuis un poste qui peut être à l’autre bout du pays. Quand un utilisateur appelle pour dire « le site ne marche plus », il n’y a ni fenêtre de paramètres réseau ni icône Wi-Fi à regarder : il y a un terminal, et une poignée d’outils en ligne de commande. Ce cours présente ces outils un par un, explique précisément ce que chacun mesure et ce qu’il ne mesure pas, puis les assemble en une méthode de diagnostic que vous pourrez appliquer à n’importe quel incident.',
+  cm: [
+    { t: 'La méthode avant les outils', d: '', html: 'Le réflexe du débutant est de tout essayer en même temps : redémarrer le service, changer le câble, vider le cache du navigateur, relancer la machine. Parfois cela marche, mais on ne sait pas pourquoi, et la panne reviendra. Le professionnel suit une <b>démarche par couches</b>, du bas vers le haut, et ne passe à la couche suivante que lorsque la précédente est validée.<br><br>Concrètement, on se pose cinq questions dans l’ordre. Le lien est-il actif (couche 1-2) ? La machine a-t-elle une adresse IP correcte et une route vers la destination (couche 3 locale) ? Les paquets atteignent-ils la passerelle, puis la destination (couche 3 de bout en bout) ? Le service écoute-t-il sur le bon port et le pare-feu le laisse-t-il passer (couche 4) ? L’application répond-elle correctement (couche 7) ? Chaque outil de ce cours répond à une de ces questions.<br><br>Enfin, on <b>note tout</b>. Une commande, sa sortie, l’heure. Un diagnostic écrit peut être relu par un collègue, joint à un ticket, et sert de preuve quand le problème vient d’un prestataire.', table: [['Question', 'Couche', 'Outil principal'], ['Le lien est-il monté ?', '1-2', 'ip link'], ['Ai-je une adresse et une route ?', '3 locale', 'ip addr, ip route'], ['Mon voisin direct répond-il ?', '2-3', 'ip neigh, ping passerelle'], ['La destination est-elle joignable ?', '3', 'ping, traceroute, mtr'], ['Le service écoute-t-il ?', '4', 'ss'], ['Que se passe-t-il vraiment sur le fil ?', 'toutes', 'tcpdump, Wireshark'], ['Le nom se résout-il ?', '7', 'dig'], ['L’application répond-elle ?', '7', 'curl']] },
+    { t: 'ip : l’état réseau de la machine', d: '', html: 'La commande <code>ip</code>, du paquet iproute2, remplace depuis longtemps les anciens <code>ifconfig</code>, <code>route</code> et <code>arp</code>, qui ne sont plus installés par défaut sur Debian. Elle se décline en sous-commandes : <code>ip link</code> pour les interfaces, <code>ip addr</code> pour les adresses, <code>ip route</code> pour la table de routage, <code>ip neigh</code> pour la table de voisinage (ARP).<br><br><b>ip link</b> indique si l’interface est administrativement activée (UP) et si la couche physique détecte une porteuse (LOWER_UP). Une interface « UP » sans « LOWER_UP » a été activée mais ne voit pas de câble ou de switch en face : le problème est physique. <code>ip -s link</code> ajoute les compteurs de paquets, d’erreurs et de pertes, très utiles pour repérer un câble abîmé ou un duplex mal négocié.<br><br><b>ip addr</b> affiche les adresses. L’option <code>-br</code> (brief) donne une ligne par interface, idéale pour un coup d’œil. On y vérifie l’adresse, mais surtout le <b>masque</b> : un poste en 192.168.10.65/24 alors que le réseau est un /26 croira que 192.168.10.130 est sur son réseau local et ne passera jamais par la passerelle.<br><br><b>ip route</b> montre la table de routage. La ligne <code>default via 192.168.10.1</code> est la passerelle par défaut : sans elle, la machine ne sait joindre que son propre réseau. La commande <code>ip route get 8.8.8.8</code> est précieuse : elle indique quelle route, quelle interface et quelle adresse source seraient utilisées pour joindre une destination donnée, sans envoyer le moindre paquet.', exemple: '$ ip -br link\nlo      UNKNOWN  00:00:00:00:00:00 <LOOPBACK,UP,LOWER_UP>\nens18   UP       bc:24:11:5e:2a:10 <BROADCAST,MULTICAST,UP,LOWER_UP>\n\n$ ip -br addr\nlo      UNKNOWN  127.0.0.1/8 ::1/128\nens18   UP       192.168.10.20/24 fe80::be24:11ff:fe5e:2a10/64\n\n$ ip route\ndefault via 192.168.10.1 dev ens18 proto static\n192.168.10.0/24 dev ens18 proto kernel scope link src 192.168.10.20\n\n$ ip route get 1.1.1.1\n1.1.1.1 via 192.168.10.1 dev ens18 src 192.168.10.20 uid 1000', attention: 'Les modifications faites avec ip addr add ou ip route add sont perdues au redémarrage. Sur Debian, la configuration permanente est dans /etc/network/interfaces ou gérée par systemd-networkd / NetworkManager. On teste avec ip, on pérennise dans le fichier.' },
+    { t: 'ping : la preuve de joignabilité', d: '', html: '<code>ping</code> envoie des messages <b>ICMP Echo Request</b> et attend des <b>Echo Reply</b>. Il mesure trois choses : si la destination répond, en combien de temps (le RTT, round-trip time, aller et retour), et quelle proportion des messages se perd en route.<br><br>Chaque ligne de réponse contient un numéro de séquence (<code>icmp_seq</code>), un <b>TTL</b> et un temps. Des numéros de séquence qui sautent indiquent des pertes. Le TTL de la réponse donne un indice sur la distance et le système distant : Linux part en général de 64, Windows de 128, beaucoup d’équipements réseau de 255 ; un TTL reçu de 57 signifie qu’un paquet parti à 64 a traversé 7 routeurs.<br><br>Le résumé final est la partie la plus importante. <code>packet loss</code> doit être à 0 % sur un réseau sain ; quelques pour cent de pertes suffisent à rendre une visioconférence pénible et un transfert de fichiers très lent, car TCP réduit son débit à chaque perte. La ligne <code>rtt min/avg/max/mdev</code> donne le temps minimum, moyen, maximum et l’écart moyen (<b>gigue</b>). Une gigue élevée révèle un lien saturé ou un Wi-Fi perturbé.<br><br>Options utiles : <code>-c 5</code> limite le nombre de paquets (sans elle, ping tourne jusqu’à Ctrl+C), <code>-i 0.2</code> accélère l’envoi, <code>-s 1472 -M do</code> envoie un gros paquet interdit de fragmentation pour tester la MTU d’un chemin, <code>-I ens18</code> force l’interface de sortie.', exemple: '$ ping -c 4 192.168.10.1\nPING 192.168.10.1 (192.168.10.1) 56(84) bytes of data.\n64 bytes from 192.168.10.1: icmp_seq=1 ttl=64 time=0.412 ms\n64 bytes from 192.168.10.1: icmp_seq=2 ttl=64 time=0.387 ms\n64 bytes from 192.168.10.1: icmp_seq=3 ttl=64 time=0.401 ms\n64 bytes from 192.168.10.1: icmp_seq=4 ttl=64 time=0.395 ms\n\n--- 192.168.10.1 ping statistics ---\n4 packets transmitted, 4 received, 0% packet loss, time 3055ms\nrtt min/avg/max/mdev = 0.387/0.398/0.412/0.009 ms', attention: 'Un ping qui échoue ne prouve pas qu’une machine est éteinte. De nombreux pare-feux, dont celui de Windows par défaut et ceux des hébergeurs, bloquent ICMP. À l’inverse, un ping qui répond ne prouve pas qu’un service fonctionne : la machine peut répondre au ping avec un serveur web planté.' },
+    { t: 'traceroute et mtr : voir le chemin', d: '', html: 'Quand la destination ne répond pas ou répond lentement, il faut savoir <b>où</b> se situe le problème. <code>traceroute</code> exploite astucieusement le champ TTL de l’en-tête IP. Chaque routeur décrémente ce TTL de 1 ; lorsqu’il atteint 0, le routeur détruit le paquet et renvoie un message <b>ICMP Time Exceeded</b> à l’expéditeur. traceroute envoie donc un premier paquet avec un TTL de 1 (il meurt au premier routeur, qui se dénonce), puis un TTL de 2 (il meurt au deuxième), et ainsi de suite jusqu’à la destination.<br><br>Chaque ligne correspond à un saut, avec trois mesures de temps. Des <b>étoiles</b> (* * *) signifient qu’aucune réponse n’est revenue pour ce saut. Si les sauts suivants répondent, ce n’est pas une panne : le routeur est simplement configuré pour ne pas répondre ou pour limiter ses réponses ICMP. Si tout s’arrête à un saut et que plus rien ne répond ensuite, le problème se situe à cet endroit ou juste après.<br><br>Par défaut, traceroute sous Linux envoie des datagrammes UDP vers des ports élevés. Les pare-feux les bloquent souvent ; <code>traceroute -I</code> utilise ICMP comme Windows (tracert), et <code>traceroute -T -p 443</code> utilise des paquets TCP SYN vers le port 443, qui passent presque partout puisqu’ils ressemblent à une connexion web.<br><br><code>mtr</code> combine ping et traceroute : il interroge chaque saut en continu et affiche pour chacun le taux de perte et les temps. C’est l’outil de référence pour documenter un problème de qualité auprès d’un opérateur. Attention à l’interprétation : une perte affichée sur un saut intermédiaire mais pas sur les suivants vient d’un routeur qui limite ses réponses, pas d’une vraie perte. Seule compte la perte qui persiste jusqu’à la destination.', exemple: '$ traceroute -n 1.1.1.1\ntraceroute to 1.1.1.1, 30 hops max, 60 byte packets\n 1  192.168.10.1   0.512 ms  0.470 ms  0.455 ms\n 2  10.255.0.1     2.118 ms  2.097 ms  2.230 ms\n 3  * * *\n 4  62.34.2.57     9.874 ms  9.812 ms  9.930 ms\n 5  1.1.1.1       10.402 ms 10.377 ms 10.361 ms', attention: 'Un temps qui augmente brusquement à un saut puis reste élevé indique un lien lent ou long (câble sous-marin, par exemple). Un temps élevé sur un seul saut, suivi de temps normaux, n’indique rien : le routeur traite simplement ses réponses ICMP avec une faible priorité.' },
+    { t: 'ss : qui écoute, qui est connecté', d: '', html: '<code>ss</code> (socket statistics) remplace <code>netstat</code>. Il liste les <b>sockets</b> ouvertes sur la machine, c’est-à-dire les points de communication entre un programme et le réseau. C’est l’outil qui répond à la question « le service écoute-t-il ? », la plus fréquente après « la machine est-elle joignable ? ».<br><br>La combinaison à connaître par cœur est <code>ss -tlnp</code> : <b>t</b> pour TCP, <b>l</b> pour les sockets en écoute (LISTEN), <b>n</b> pour afficher les numéros de port au lieu des noms, <b>p</b> pour afficher le processus propriétaire (nécessite sudo). Remplacez t par u pour UDP, ou mettez les deux.<br><br>La colonne <b>Local Address:Port</b> est décisive. <code>0.0.0.0:80</code> ou <code>*:80</code> signifie que le service écoute sur toutes les interfaces. <code>127.0.0.1:3306</code> signifie qu’il n’écoute que sur la boucle locale : il est invisible depuis le réseau, ce qui est voulu pour une base de données, mais une erreur classique pour un service censé être public.<br><br>Sans l’option l, ss montre les connexions établies et leurs <b>états TCP</b>. ESTAB : connexion établie. SYN-SENT : on a envoyé un SYN et on attend la réponse, souvent le signe d’un pare-feu qui jette les paquets. TIME-WAIT : connexion fermée récemment, normal en grand nombre sur un serveur web. CLOSE-WAIT en grand nombre : l’application ne referme pas ses connexions, c’est un bug applicatif. Des filtres permettent d’être précis : <code>ss -tn state established &#39;( dport = :443 )&#39;</code>.', exemple: '$ sudo ss -tlnp\nState   Recv-Q  Send-Q  Local Address:Port  Peer Address:Port  Process\nLISTEN  0       128           0.0.0.0:22         0.0.0.0:*      users:(("sshd",pid=611,fd=3))\nLISTEN  0       511           0.0.0.0:80         0.0.0.0:*      users:(("apache2",pid=842,fd=4))\nLISTEN  0       80          127.0.0.1:3306       0.0.0.0:*      users:(("mariadbd",pid=790,fd=21))\n\n$ ss -tn state established\nRecv-Q Send-Q  Local Address:Port   Peer Address:Port\n0      0       192.168.10.20:22     192.168.10.54:51522' },
+    { t: 'ARP et ip neigh : le voisinage', d: '', html: 'Pour envoyer une trame Ethernet, il faut l’adresse MAC du destinataire direct, c’est-à-dire la machine elle-même si elle est sur le même réseau, sinon la passerelle. Le protocole <b>ARP</b> fait la correspondance : la machine diffuse à tout le réseau local « qui a 192.168.10.1 ? », la passerelle répond avec sa MAC, et la réponse est gardée en cache.<br><br><code>ip neigh</code> affiche ce cache avec l’état de chaque entrée. <b>REACHABLE</b> : le voisin a été confirmé récemment. <b>STALE</b> : l’entrée est ancienne mais encore utilisable, elle sera vérifiée au prochain envoi. <b>INCOMPLETE</b> : une requête ARP est partie, aucune réponse n’est encore arrivée. <b>FAILED</b> : le voisin n’a jamais répondu.<br><br>Une passerelle en FAILED explique à elle seule une panne complète : la machine a une adresse, une route, mais ne parvient même pas à parler à son routeur. Les causes sont souvent au niveau 2 : mauvais VLAN sur le port du switch, câble dans la mauvaise prise, passerelle éteinte.<br><br><code>arping</code> envoie des requêtes ARP directement et permet de détecter un <b>conflit d’adresse</b> : si deux MAC différentes répondent pour la même IP, deux machines ont été configurées avec la même adresse. Le même phénomène peut signaler une attaque par <b>usurpation ARP</b> (ARP spoofing), où un attaquant se fait passer pour la passerelle afin d’intercepter le trafic.', exemple: '$ ip neigh\n192.168.10.1 dev ens18 lladdr 3c:52:82:1a:0f:9b REACHABLE\n192.168.10.54 dev ens18 lladdr 00:15:5d:0a:11:03 STALE\n192.168.10.99 dev ens18 FAILED\n\n$ sudo arping -c 3 -I ens18 192.168.10.30\nUnicast reply from 192.168.10.30 [00:15:5D:0A:11:07]  0.645ms\nUnicast reply from 192.168.10.30 [08:00:27:3B:C4:12]  0.702ms\nUnicast reply from 192.168.10.30 [00:15:5D:0A:11:07]  0.610ms', attention: 'Deux adresses MAC différentes pour une même IP, comme ci-dessus : conflit d’adresse à traiter immédiatement. Les symptômes typiques sont des coupures aléatoires de quelques secondes pour les deux machines.' },
+    { t: 'tcpdump et Wireshark : regarder le fil', d: '', html: 'Tous les outils précédents déduisent ce qui se passe. <b>tcpdump</b> montre ce qui passe réellement sur l’interface, paquet par paquet. C’est l’outil de dernier recours, et souvent celui qui tranche les débats entre équipes (« le pare-feu bloque » contre « l’application ne répond pas »).<br><br>tcpdump s’exécute avec sudo et accepte un <b>filtre BPF</b> qui limite la capture à ce qui nous intéresse : <code>host 192.168.10.54</code>, <code>port 443</code>, <code>tcp</code>, <code>icmp</code>, combinables avec and, or, not. Sans filtre, sur un serveur actif, l’écran défile trop vite pour être lu, et votre propre session SSH apparaît dans la capture ; on l’exclut avec <code>not port 22</code>. Les options essentielles : <code>-i ens18</code> choisit l’interface, <code>-n</code> évite la résolution des noms (plus rapide, plus lisible), <code>-c 20</code> s’arrête après 20 paquets, <code>-w capture.pcap</code> enregistre dans un fichier.<br><br>Chaque ligne TCP affiche des <b>drapeaux</b> entre crochets. [S] : SYN, demande d’ouverture. [S.] : SYN-ACK, le serveur accepte. [.] : simple ACK. [P.] : données poussées. [F.] : fin de connexion. [R] ou [R.] : RST, refus ou coupure brutale. Savoir lire ces drapeaux permet de distinguer en une seconde un port <b>fermé</b> (le serveur répond RST) d’un port <b>filtré</b> (aucune réponse, les SYN se répètent).<br><br><b>Wireshark</b> est l’interface graphique de référence pour analyser une capture. Sur un serveur sans écran, on capture avec <code>tcpdump -w</code>, on rapatrie le fichier .pcap avec scp, puis on l’ouvre dans Wireshark sur son poste. Wireshark décode chaque protocole couche par couche, reconstitue les échanges avec « Suivre le flux TCP » et permet des filtres d’affichage comme <code>tcp.flags.syn == 1 && tcp.flags.ack == 0</code> ou <code>http.response.code == 500</code>.', exemple: '$ sudo tcpdump -ni ens18 -c 6 "tcp port 80 and host 192.168.10.54"\n10:14:02.118 IP 192.168.10.54.51544 > 192.168.10.20.80: Flags [S], seq 3308715651, win 64240\n10:14:02.118 IP 192.168.10.20.80 > 192.168.10.54.51544: Flags [S.], seq 1920458830, ack 3308715652\n10:14:02.119 IP 192.168.10.54.51544 > 192.168.10.20.80: Flags [.], ack 1\n10:14:02.119 IP 192.168.10.54.51544 > 192.168.10.20.80: Flags [P.], length 78: HTTP: GET / HTTP/1.1\n10:14:02.121 IP 192.168.10.20.80 > 192.168.10.54.51544: Flags [P.], length 3460: HTTP: HTTP/1.1 200 OK\n10:14:02.122 IP 192.168.10.54.51544 > 192.168.10.20.80: Flags [.], ack 3461', attention: 'Capturer du trafic, c’est potentiellement lire des données personnelles et des mots de passe transmis en clair. Sur un réseau d’entreprise ou d’établissement, on ne capture qu’avec une autorisation et on supprime les fichiers après analyse. C’est une obligation liée au RGPD et à la charte informatique.' },
+    { t: 'Les compléments indispensables : dig, curl, nc', d: '', html: 'Trois outils finissent le diagnostic au niveau applicatif. <b>dig</b> interroge le DNS et montre la réponse brute : <code>dig +short intranet.lycee.fr</code> donne l’adresse, <code>dig @1.1.1.1 intranet.lycee.fr</code> interroge un serveur précis pour comparer, et le champ <code>status: NXDOMAIN</code> indique que le nom n’existe pas. Beaucoup de « pannes réseau » sont en réalité des pannes DNS.<br><br><b>curl</b> joue le rôle du navigateur sans navigateur. <code>curl -I</code> affiche les en-têtes de réponse, <code>curl -v</code> détaille toute la négociation (résolution, connexion TCP, poignée de main TLS, requête, réponse), <code>curl --resolve site.fr:443:192.168.10.20 https://site.fr</code> teste un serveur précis en contournant le DNS.<br><br><b>nc</b> (netcat) teste l’ouverture d’un port TCP sans protocole applicatif : <code>nc -zv 192.168.10.20 3306</code> répond « succeeded » ou « Connection refused ». C’est le moyen le plus rapide de vérifier qu’un pare-feu laisse passer un flux entre deux serveurs.' }
+  ],
+  synthese: ['On diagnostique de bas en haut et on note chaque résultat', 'ip link / ip addr / ip route : lien, adresse, masque, passerelle', 'ping mesure joignabilité, latence, pertes ; ICMP peut être filtré', 'traceroute et mtr localisent l’endroit du problème ; seule compte la perte qui persiste jusqu’à la destination', 'ss -tlnp : le service écoute-t-il, et sur quelle adresse ?', 'ip neigh : une passerelle en FAILED oriente vers la couche 2', 'tcpdump tranche : RST = port fermé, silence = port filtré', 'dig, curl, nc terminent le diagnostic applicatif'],
+  qcm: [
+    ['ip link affiche ens18 en UP mais sans LOWER_UP. Que faut-il vérifier en priorité ?', ['Le DNS', 'Le câble et le port du switch', 'Le pare-feu', 'Le service web'], 1, 'L’interface est activée mais ne détecte pas de lien physique.'],
+    ['Quelle commande indique la route et l’adresse source utilisées pour joindre 8.8.8.8, sans rien envoyer ?', ['ping 8.8.8.8', 'ip route get 8.8.8.8', 'traceroute 8.8.8.8', 'ss -r'], 1, 'ip route get interroge la table de routage.'],
+    ['Un ping renvoie « 100 % packet loss » vers un serveur web qui affiche pourtant bien son site. Explication la plus probable ?', ['Le serveur est éteint', 'ICMP est filtré par un pare-feu', 'Le DNS est en panne', 'Le câble est coupé'], 1, 'Le site répond, donc la machine est joignable ; seul ICMP est bloqué.'],
+    ['Sur quel mécanisme repose traceroute ?', ['Le numéro de séquence TCP', 'La décrémentation du TTL et les messages ICMP Time Exceeded', 'Les requêtes ARP', 'Le DNS inverse'], 1, 'Chaque routeur qui met le TTL à 0 se signale.'],
+    ['Dans mtr, le saut 4 affiche 40 % de pertes, les sauts 5 à 9 et la destination 0 %. Conclusion ?', ['Le lien du saut 4 est défaillant', 'Le routeur 4 limite ses réponses ICMP, pas de vraie perte', 'La destination est saturée', 'Il faut changer d’opérateur'], 1, 'Une perte qui ne se propage pas n’est pas une vraie perte.'],
+    ['ss -tlnp montre 127.0.0.1:8080 pour l’application. Les postes du réseau ne peuvent pas y accéder. Pourquoi ?', ['Le port 8080 est interdit', 'L’application n’écoute que sur la boucle locale', 'Il manque sudo', 'Le pare-feu est désactivé'], 1, 'Il faut la configurer pour écouter sur 0.0.0.0 ou l’IP du serveur.'],
+    ['Que signifie l’état SYN-SENT persistant dans ss ?', ['Connexion établie', 'On attend une réponse au SYN, souvent un pare-feu qui jette les paquets', 'Connexion fermée proprement', 'Le serveur a refusé'], 1, 'Un refus donnerait un RST immédiat.'],
+    ['ip neigh affiche la passerelle en FAILED. Où chercher ?', ['Au niveau DNS', 'Au niveau 2 : VLAN, câble, passerelle éteinte', 'Dans Apache', 'Dans le navigateur'], 1, 'La machine n’obtient même pas la MAC de son routeur.'],
+    ['Dans tcpdump, un SYN reçoit immédiatement une réponse [R.]. Le port est :', ['filtré', 'fermé', 'ouvert', 'chiffré'], 1, 'La machine répond activement qu’il n’y a rien sur ce port.'],
+    ['Pourquoi ajouter not port 22 à une capture tcpdump lancée en SSH ?', ['Pour aller plus vite', 'Pour ne pas capturer sa propre session', 'C’est obligatoire', 'Pour chiffrer la capture'], 1, 'Sinon chaque ligne affichée génère du trafic SSH capturé.'],
+    ['Quel est le rôle de l’option -n de tcpdump et ss ?', ['Capturer moins', 'Afficher les adresses et ports en numérique, sans résolution de noms', 'Ignorer IPv6', 'Afficher en couleur'], 1, 'Plus rapide et plus lisible pour le diagnostic.'],
+    ['Deux MAC différentes répondent à arping pour la même IP. C’est :', ['normal', 'un conflit d’adresse ou une usurpation ARP', 'un problème DNS', 'un effet du Wi-Fi'], 1, 'À traiter immédiatement.']
+  ],
+  td: [
+    { n: 'Échauffement', c: 'Pour chaque symptôme, indiquer la couche concernée et la première commande à lancer : (a) « la carte réseau n’a pas de voyant », (b) « je n’ai pas d’adresse IP », (c) « je ping la passerelle mais pas Internet », (d) « le site s’ouvre par son IP mais pas par son nom ».', r: '(a) couches 1-2 · ip link\n(b) couche 3 locale · ip addr puis journal DHCP\n(c) couche 3 au-delà de la passerelle · ip route puis traceroute\n(d) couche 7 · dig nom-du-site' },
+    { n: 'Échauffement', c: 'Interpréter la ligne : « 64 bytes from 10.0.0.5: icmp_seq=7 ttl=121 time=38.2 ms ». Que peut-on dire du système distant et de la distance ?', r: 'TTL initial probablement 128 (Windows) : 128 − 121 = 7 routeurs traversés. RTT de 38 ms aller-retour.' },
+    { n: 'Application', c: 'Un serveur répond au ping mais le site ne s’affiche pas. Écrire la suite de commandes, sur le serveur, qui permet de savoir si Apache tourne, sur quel port et sur quelle adresse il écoute, et s’il répond localement.', r: 'systemctl status apache2\nsudo ss -tlnp | grep -E ":80|:443"\ncurl -I http://127.0.0.1\n(puis, depuis un poste client : curl -I http://IP-du-serveur)' },
+    { n: 'Application', c: 'Écrire la commande tcpdump qui capture, sur ens18, les 50 premiers paquets échangés avec 192.168.10.54 sur le port 443, sans résolution de noms, dans le fichier https.pcap.', r: 'sudo tcpdump -ni ens18 -c 50 -w https.pcap "host 192.168.10.54 and tcp port 443"' },
+    { n: 'Application', c: 'À partir de la sortie mtr fournie par l’enseignant, déterminer si la perte vient du réseau local, de l’opérateur ou de la destination, et rédiger le message à envoyer au support de l’opérateur.', r: 'Repérer le premier saut où la perte apparaît ET persiste jusqu’à la destination. Si c’est un saut de l’opérateur, joindre la sortie mtr -rwc 100, l’heure, l’IP source et l’IP destination.' },
+    { n: 'Approfondissement', c: 'Proposer une méthode, avec les commandes, pour distinguer un port fermé d’un port filtré par un pare-feu, depuis un client Linux.', r: 'nc -zv IP port : « refused » immédiat = fermé ; attente puis timeout = filtré.\nConfirmation : sudo tcpdump -ni ens18 host IP and port N → RST reçu (fermé) ou SYN répétés sans réponse (filtré).' },
+    { n: 'Approfondissement', c: 'Un transfert de gros fichiers entre deux sites échoue alors que les petites requêtes passent. Formuler une hypothèse sur la MTU et la vérifier avec ping.', r: 'Hypothèse : un tunnel ou un lien réduit la MTU et les paquets ICMP « Fragmentation needed » sont filtrés.\nTest : ping -M do -s 1472 IP (1500 octets) puis réduire -s jusqu’à ce que ça passe, par exemple 1392 → MTU 1420.' }
+  ],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Deux VM Debian reliées, pannes injectées par l’enseignant, diagnostic vérifié étape par étape.', etapes: ['Relever l’état réseau complet avec ip -br link, ip -br addr, ip route', 'Mesurer latence et pertes vers la passerelle et vers Internet', 'Localiser une panne avec traceroute -n puis mtr', 'Trouver pourquoi le service web est injoignable avec ss et curl', 'Capturer une connexion avec tcpdump et identifier SYN, SYN-ACK, ACK', 'Rédiger le compte rendu d’incident'] },
+  plusLoin: [['Documentation iproute2 (man ip, man ss)', 'https://man7.org/linux/man-pages/man8/ip.8.html'], ['Documentation officielle de tcpdump et des filtres pcap', 'https://www.tcpdump.org/manpages/pcap-filter.7.html'], ['Wireshark User’s Guide', 'https://www.wireshark.org/docs/wsug_html_chunked/'], ['RFC 792 · ICMP', 'https://www.rfc-editor.org/rfc/rfc792'], ['RFC 9293 · TCP', 'https://www.rfc-editor.org/rfc/rfc9293']]
+});
+
+window.CONTENUS_PLUS = window.CONTENUS_PLUS || {};
+window.CONTENUS_PLUS.diagnostic = {
+  cas: { titre: 'Mise en situation · Le lundi où l’ENT n’a plus répondu', texte: 'Lundi, 8 h 05. Le service informatique du lycée reçoit une dizaine d’appels : l’intranet pédagogique ne s’affiche plus, ni en salle de classe ni en salle des professeurs. Le serveur est une VM Debian hébergée sur l’hyperviseur de l’établissement. Le technicien s’y connecte en SSH, suit sa méthode couche par couche, découvre que le service web a bien redémarré après la mise à jour du week-end mais qu’il n’écoute plus que sur la boucle locale à cause d’une directive Listen modifiée, corrige la configuration, vérifie depuis un poste client puis rédige un compte rendu d’incident pour l’équipe. Temps d’indisponibilité : 25 minutes, dont 5 de diagnostic effectif.' },
+  erreurs: ['Conclure qu’une machine est éteinte parce qu’elle ne répond pas au ping', 'Interpréter les étoiles d’un saut de traceroute comme une panne alors que les sauts suivants répondent', 'Lancer tcpdump sans filtre en SSH et capturer sa propre session', 'Oublier sudo avec ss -p : la colonne Process reste vide', 'Vérifier l’adresse IP sans vérifier le masque', 'Modifier la configuration avec ip addr add et oublier de la rendre permanente', 'Tout redémarrer avant d’avoir compris, et perdre les traces de la panne', 'Tester uniquement depuis le serveur lui-même (curl localhost) sans tester depuis un client'],
+  memo: [
+    ['Commande', 'À quoi ça sert', 'Ce qu’on regarde'],
+    ['ip -br link', 'état des interfaces', 'UP et LOWER_UP'],
+    ['ip -br addr', 'adresses et masques', 'IP attendue, bon préfixe /24, /26…'],
+    ['ip route', 'table de routage', 'ligne default via <passerelle>'],
+    ['ip neigh', 'cache ARP', 'passerelle en REACHABLE, pas FAILED'],
+    ['ping -c 4 <ip>', 'joignabilité, latence', '% packet loss, rtt avg et mdev'],
+    ['traceroute -n <ip>', 'chemin saut par saut', 'dernier saut qui répond'],
+    ['mtr -rwc 100 <ip>', 'pertes par saut dans la durée', 'perte qui persiste jusqu’à la destination'],
+    ['sudo ss -tlnp', 'services en écoute', 'port attendu, adresse 0.0.0.0 ou 127.0.0.1'],
+    ['sudo tcpdump -ni <if> <filtre>', 'trafic réel', 'drapeaux [S] [S.] [R.], absence de réponse'],
+    ['dig +short <nom>', 'résolution DNS', 'adresse renvoyée, NXDOMAIN'],
+    ['curl -Iv <url>', 'réponse applicative', 'connexion, TLS, code HTTP'],
+    ['nc -zv <ip> <port>', 'test d’ouverture de port', 'succeeded, refused ou timeout']
+  ],
+  resolu: { enonce: 'Le serveur web intranet (192.168.10.20) ne répond plus depuis les postes du lycée. Diagnostiquer et rétablir le service.', etapes: [
+    ['1 · Qualifier le symptôme depuis un client', 'curl -I --max-time 5 http://192.168.10.20\ncurl: (7) Failed to connect to 192.168.10.20 port 80: Connection refused\n→ « Connection refused » est une information précieuse : la machine a répondu, et elle a refusé. Elle est donc allumée et joignable. Un timeout aurait orienté vers un problème réseau ou un pare-feu.'],
+    ['2 · Confirmer la couche 3', 'ping -c 3 192.168.10.20\n3 packets transmitted, 3 received, 0% packet loss\n→ Réseau et routage fonctionnent. Inutile de regarder les câbles, les switchs ou le DHCP. On passe sur le serveur.'],
+    ['3 · Vérifier l’état réseau du serveur', 'ssh admin@192.168.10.20\nip -br addr\nens18  UP  192.168.10.20/24\nip route | head -1\ndefault via 192.168.10.1 dev ens18\n→ Adresse, masque et passerelle corrects. Le problème est au-dessus de la couche 3.'],
+    ['4 · Le service tourne-t-il et où écoute-t-il ?', 'systemctl is-active apache2\nactive\nsudo ss -tlnp | grep apache2\nLISTEN 0 511 127.0.0.1:80 0.0.0.0:* users:(("apache2",pid=1204,fd=4))\n→ Voilà la cause : Apache tourne, mais n’écoute que sur 127.0.0.1. Depuis le réseau, le port 80 est fermé, d’où le refus.'],
+    ['5 · Trouver l’origine et corriger', 'grep -rn "^Listen" /etc/apache2/\n/etc/apache2/ports.conf:5:Listen 127.0.0.1:80\nsudo sed -i "s/^Listen 127.0.0.1:80/Listen 80/" /etc/apache2/ports.conf\nsudo apachectl configtest && sudo systemctl restart apache2\nsudo ss -tlnp | grep apache2\nLISTEN 0 511 *:80 *:*\n→ La directive avait été modifiée lors de la maintenance du week-end. On valide la syntaxe avant de redémarrer.'],
+    ['6 · Vérifier depuis un client et documenter', 'curl -I http://192.168.10.20\nHTTP/1.1 200 OK\n→ Service rétabli. Compte rendu : heure de détection, symptôme, commandes et sorties clés, cause (directive Listen), correction, heure de rétablissement, action préventive (relecture des changements de configuration avant maintenance, supervision du port 80 depuis l’extérieur).']
+  ] },
+  vf: [['Un ping sans réponse prouve que la machine est éteinte.', 0, 'ICMP est souvent filtré.'], ['Des étoiles au saut 3 de traceroute, puis des réponses aux sauts 4 et 5, ne sont pas une panne.', 1, 'Le routeur 3 ne répond simplement pas à ICMP.'], ['127.0.0.1:3306 dans ss signifie que MariaDB est accessible depuis le réseau.', 0, 'Seulement depuis la machine elle-même.'], ['Une réponse RST à un SYN signifie que le port est fermé.', 1, 'Un port filtré ne répond pas du tout.']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Donner, dans l’ordre, les cinq vérifications d’une démarche de diagnostic par couches, avec une commande pour chacune. (5 pts)', 'Interpréter la sortie ping fournie : pertes, latence moyenne, gigue, et conclusion sur la qualité du lien. (3 pts)', 'Expliquer le fonctionnement de traceroute et interpréter une ligne « * * * ». (4 pts)', 'Un service écoute en 127.0.0.1:8080. Expliquer la conséquence et la correction. (3 pts)', 'Écrire la commande tcpdump qui capture les SYN vers le port 443 de 10.0.0.5, puis expliquer comment distinguer un port fermé d’un port filtré. (5 pts)'], r: ['ip link · ip addr / ip route · ping passerelle puis destination · ss -tlnp · curl / dig', 'Selon la sortie : % packet loss, avg, mdev', 'TTL croissant, ICMP Time Exceeded ; étoiles = pas de réponse du saut, pas forcément une panne', 'Injoignable depuis le réseau ; écouter sur 0.0.0.0:8080 ou l’IP du serveur', 'sudo tcpdump -ni ens18 "dst host 10.0.0.5 and tcp dst port 443 and tcp[tcpflags] & tcp-syn != 0" · RST = fermé, pas de réponse = filtré'] },
+  prof: { deroule: [['Ouverture', 'Scénario réel : « l’ENT ne répond plus », la classe propose des hypothèses, on les classe par couche'], ['Cours', 'ip, ping, traceroute, avec démonstration en direct sur une VM projetée'], ['Cours', 'ss, ARP, tcpdump ; lecture commentée d’une capture'], ['Pratique', 'Lab VM : pannes injectées (mauvais masque, passerelle absente, service sur 127.0.0.1, pare-feu)'], ['Clôture', 'Quiz flash, puis chaque binôme présente un diagnostic en 2 minutes']], diff: 'Élèves en difficulté : fiche mémo imprimée, un seul outil par panne, indices débloqués après 3 essais. Élèves avancés : analyse d’une capture dans Wireshark, diagnostic MTU, rédaction d’un compte rendu d’incident au format ITIL.', eval: 'Chaque panne du lab est validée automatiquement dans la VM. Le compte rendu d’incident est évalué sur la rigueur (commandes, sorties, cause, correction, prévention). Sujet type sur 20.' }
+};
+
+window.CONTENUS_EXEMPLES = window.CONTENUS_EXEMPLES || {};
+window.CONTENUS_EXEMPLES.diagnostic = [
+ ['Diagnostiquer un port bloqué avec ss', 'L’application métier est installée, mais aucun poste n’y accède sur le port 8080.', 'sudo ss -tlnp "sport = :8080"', 'State  Recv-Q Send-Q Local Address:Port Peer Address:Port Process\nLISTEN 0      4096       127.0.0.1:8080      0.0.0.0:*     users:(("java",pid=2214,fd=38))', 'Le processus Java écoute bien, mais uniquement sur 127.0.0.1 : il est invisible depuis le réseau. Il faut changer l’adresse d’écoute dans sa configuration (server.address=0.0.0.0 pour une application Spring, par exemple), puis vérifier que le pare-feu autorise le port 8080. Si la ligne avait affiché 0.0.0.0:8080, on aurait orienté la recherche vers le pare-feu avec nc -zv depuis un client.'],
+ ['Mesurer une perte de paquets', 'Les visioconférences de la salle B204 coupent régulièrement.', 'ping -c 100 -i 0.2 -q 192.168.20.1', '--- 192.168.20.1 ping statistics ---\n100 packets transmitted, 93 received, 7% packet loss, time 19821ms\nrtt min/avg/max/mdev = 0.9/14.6/212.4/31.8 ms', '7 % de pertes vers la passerelle locale, c’est énorme : sur un réseau filaire sain, on attend 0 %. La gigue (mdev) de 31,8 ms et un maximum à 212 ms confirment un lien instable. -q n’affiche que le résumé, -i 0.2 envoie 5 paquets par seconde. Suite du diagnostic : ip -s link pour chercher des erreurs sur l’interface, puis vérification du câble ou de la borne Wi-Fi.'],
+ ['Lire une poignée de main TCP', 'Vérifier qu’une connexion au serveur de base de données s’établit.', 'sudo tcpdump -ni ens18 -c 3 "host 192.168.10.30 and tcp port 5432"', '09:41:12.004 IP 192.168.10.20.40818 > 192.168.10.30.5432: Flags [S], seq 17290431, win 64240, options [mss 1460]\n09:41:12.005 IP 192.168.10.30.5432 > 192.168.10.20.40818: Flags [S.], seq 91022876, ack 17290432, win 65160\n09:41:12.005 IP 192.168.10.20.40818 > 192.168.10.30.5432: Flags [.], ack 1, win 502', 'Les trois temps de l’ouverture TCP sont visibles : [S] le client demande, [S.] le serveur accepte en acquittant le numéro de séquence + 1, [.] le client confirme. La connexion est établie en 1 ms. Le port source 40818 est choisi au hasard par le client, le port 5432 est celui de PostgreSQL. Si le problème persiste, il est donc applicatif (authentification, base inexistante), pas réseau.'],
+ ['Distinguer port fermé et port filtré', 'Un collègue affirme que « le pare-feu bloque le port 3306 ».', 'nc -zv -w 3 192.168.10.30 3306\nnc -zv -w 3 192.168.10.30 3307', 'nc: connect to 192.168.10.30 port 3306 (tcp) failed: Connection refused\nnc: connect to 192.168.10.30 port 3307 (tcp) timed out: Operation now in progress', 'Deux comportements différents. Sur 3306, « refused » immédiat : la machine a répondu par un RST, donc aucun pare-feu ne bloque, mais aucun service n’écoute ; il faut regarder MariaDB (arrêté ou en écoute sur 127.0.0.1). Sur 3307, « timed out » : aucun retour, les paquets sont jetés en route, c’est la signature d’un pare-feu. Deux commandes suffisent à trancher le débat.'],
+ ['Localiser une panne avec traceroute', 'Le serveur de sauvegarde distant (site B) est injoignable depuis le site A.', 'traceroute -n -T -p 22 10.50.0.10', 'traceroute to 10.50.0.10, 30 hops max\n 1  192.168.10.1  0.48 ms  0.44 ms  0.41 ms\n 2  10.255.0.1    2.31 ms  2.28 ms  2.40 ms\n 3  10.254.8.2    6.12 ms  6.05 ms  6.20 ms\n 4  * * *\n 5  * * *\n 6  * * *', 'Les trois premiers sauts répondent : réseau local, routeur du site, puis entrée du lien inter-sites. Plus rien au-delà du saut 3, et la destination ne répond pas non plus : le problème se situe sur le lien entre le site A et le site B ou sur le routeur du site B. -T -p 22 envoie des SYN TCP vers le port SSH, qui passent les pare-feux mieux que l’UDP par défaut. On transmet cette sortie à l’équipe réseau ou à l’opérateur.'],
+ ['Repérer un problème de voisinage ARP', 'Un serveur fraîchement déplacé dans une autre baie n’a plus aucun accès réseau.', 'ip neigh show dev ens18\nping -c 2 192.168.30.1', '192.168.30.1 dev ens18 FAILED\nFrom 192.168.30.15 icmp_seq=1 Destination Host Unreachable\nFrom 192.168.30.15 icmp_seq=2 Destination Host Unreachable', 'La passerelle est en FAILED : aucune réponse ARP. Le message « Destination Host Unreachable » émis par la machine elle-même (From 192.168.30.15) confirme qu’elle n’a jamais obtenu la MAC du routeur. Adresse et route peuvent être parfaites, rien ne sortira. La cause est presque toujours au niveau 2 : port du switch dans le mauvais VLAN après le déplacement, ou câble branché sur la mauvaise prise. Vérification côté switch : show mac address-table interface <port>.']
+];
+
+window.CONTENUS_LONG = window.CONTENUS_LONG || {};
+var K = 'stroke="#000" stroke-width="3"', F = 'font-family="Archivo,sans-serif" font-weight="800"';
+var bx = function (x, y, w, h, c, t) { return '<rect x="' + x + '" y="' + y + '" width="' + w + '" height="' + h + '" fill="' + c + '" ' + K + '/><text x="' + (x + w / 2) + '" y="' + (y + h / 2 + 5) + '" text-anchor="middle" ' + F + ' font-size="15">' + t + '</text>'; };
+window.CONTENUS_LONG.diagnostic = {
+  figure: '<svg viewBox="0 0 720 300" class="h-auto w-full" role="img">' + [['7 · Application', 'curl · dig', '#FF6FB5'], ['4 · Transport', 'ss · nc', '#C4B5FD'], ['3 · Réseau', 'ping · traceroute · mtr · ip route', '#7CF2C0'], ['2 · Liaison', 'ip neigh · arping', '#FFD23F'], ['1 · Physique', 'ip link · ip -s link', '#F6F5F1']].map(function (r, i) { return bx(20, 10 + i * 56, 220, 48, r[2], r[0]) + bx(260, 10 + i * 56, 440, 48, '#fff', r[1]); }).join('') + '</svg>',
+  legende: 'Chaque outil répond à une couche. On remonte de bas en haut, tcpdump observe toutes les couches à la fois.',
+  photo: 'Photo : baie serveur avec switchs et câbles RJ45 étiquetés',
+  lecture: [
+    'Sur un poste de travail, quand Internet ne fonctionne plus, on regarde l’icône réseau, on ouvre les paramètres, on clique sur « Résoudre les problèmes ». Sur un serveur, rien de tout cela n’existe. Les machines qui font tourner les ENT, les sites des établissements, les bases de données de vie scolaire ou les services des hébergeurs français sont installées sans interface graphique, pour des raisons de sécurité, de stabilité et de performances : chaque logiciel installé en plus est une faille potentielle et consomme de la mémoire. L’administrateur s’y connecte en SSH, et tout se fait au clavier.',
+    'Ces outils en ligne de commande ont un autre avantage décisif : leur sortie est du texte. On peut la copier dans un ticket, l’envoyer à un collègue, la comparer avec celle de la veille, la filtrer avec grep ou l’intégrer dans un script de supervision qui alerte automatiquement quand une valeur dérape. Une capture d’écran d’une fenêtre de paramètres ne se prête à rien de tout cela. Dans une équipe d’exploitation, on attend d’un technicien qu’il fournisse les commandes et les sorties qui prouvent son diagnostic, pas une impression.',
+    'Ils ont aussi l’avantage d’être partout. ip, ping, ss et tcpdump sont présents ou installables en une commande sur toutes les distributions Linux, dans les conteneurs, sur les routeurs et les pare-feux basés sur Linux, et leurs équivalents existent sur Windows Server et sur les équipements réseau. Ce que vous apprenez ici se transpose directement sur un switch Cisco, un pare-feu pfSense ou une instance cloud chez Scaleway ou OVHcloud.',
+    'La compétence visée n’est pas de connaître toutes les options, elles sont dans le manuel. C’est de savoir quel outil lancer pour quelle question, et de savoir lire ce qu’il répond, y compris ce qu’il ne dit pas. Un ping sans réponse ne dit pas qu’une machine est éteinte. Des étoiles dans un traceroute ne disent pas qu’un lien est coupé. Un service « active » dans systemctl ne dit pas qu’il est joignable. Savoir faire ces nuances, c’est ce qui distingue un technicien qui cherche au hasard d’un technicien qui résout un incident en cinq minutes.'
+  ]
+};
+window.CONTENUS_SCHEMAS = window.CONTENUS_SCHEMAS || {};
+window.CONTENUS_SCHEMAS.diagnostic = {
+  termes: ['ip link', 'ip addr', 'ip route', 'ip route get', 'ip neigh', 'ip -s link', 'ip -br', 'ping', 'traceroute', 'mtr', 'ss -tlnp', 'ss', 'netstat', 'ifconfig', 'arping', 'tcpdump', 'Wireshark', 'dig', 'curl', 'nc -zv', 'ICMP', 'TTL', 'RTT', 'ARP', 'SYN', 'SYN-ACK', 'RST', 'ACK', 'LISTEN', 'ESTAB', 'SYN-SENT', 'TIME-WAIT', 'CLOSE-WAIT', 'REACHABLE', 'STALE', 'FAILED', 'INCOMPLETE', 'LOWER_UP', 'MTU', '127.0.0.1', '0.0.0.0', 'BPF', 'Time Exceeded', 'Echo Request', 'Echo Reply'],
+  figs: [
+    [3, 'traceroute : le TTL augmente d’un cran à chaque essai', '<svg viewBox="0 0 720 230" class="h-auto w-full" role="img">' + bx(10, 90, 110, 48, '#FFD23F', 'Poste') + [1, 2, 3].map(function (n, i) { return bx(160 + i * 150, 90, 110, 48, '#F6F5F1', 'Routeur ' + n) + '<text x="' + (215 + i * 150) + '" y="' + (40 + i * 0) + '" text-anchor="middle" ' + F + ' font-size="14">TTL=' + n + '</text><text x="' + (215 + i * 150) + '" y="180" text-anchor="middle" ' + F + ' font-size="13">Time Exceeded</text>'; }).join('') + bx(610, 90, 100, 48, '#7CF2C0', 'Cible') + '<text x="660" y="180" text-anchor="middle" ' + F + ' font-size="13">réponse</text></svg>'],
+    [4, 'Lire la colonne Local Address de ss', '<svg viewBox="0 0 720 150" class="h-auto w-full" role="img">' + bx(20, 20, 220, 50, '#7CF2C0', '0.0.0.0:80') + '<text x="20" y="100" ' + F + ' font-size="14">toutes les interfaces : joignable</text>' + bx(260, 20, 220, 50, '#FFD23F', '192.168.10.20:80') + '<text x="260" y="100" ' + F + ' font-size="14">une seule interface</text>' + bx(500, 20, 200, 50, '#FF6FB5', '127.0.0.1:80') + '<text x="500" y="100" ' + F + ' font-size="14">boucle locale : invisible</text></svg>'],
+    [6, 'Port fermé ou port filtré, vu par tcpdump', '<svg viewBox="0 0 720 170" class="h-auto w-full" role="img">' + bx(20, 20, 330, 44, '#F6F5F1', 'Fermé : [S] → [R.] immédiat') + bx(20, 80, 330, 44, '#FF6FB5', 'Filtré : [S] … [S] … [S] sans réponse') + bx(380, 20, 320, 44, '#7CF2C0', 'Ouvert : [S] → [S.] → [.]') + '<text x="380" y="110" ' + F + ' font-size="14">nc -zv : succeeded / refused / timed out</text></svg>']
+  ]
+};
+})();

portail/public/js/contenus-infra-3.js

@@ -0,0 +1,172 @@
+// Cours complets · Infra lot 3 : Kubernetes, supervision, annuaire LDAP / Active Directory
+(function () {
+var reg = function (c) {
+  (window.CONTENUS_PRO = window.CONTENUS_PRO || []).unshift(c.cours);
+  (window.CONTENUS_PLUS = window.CONTENUS_PLUS || {})[c.cours.id] = c.plus;
+  (window.CONTENUS_EXEMPLES = window.CONTENUS_EXEMPLES || {})[c.cours.id] = c.exemples;
+  (window.CONTENUS_SCHEMAS = window.CONTENUS_SCHEMAS || {})[c.cours.id] = { termes: c.termes, figs: [] };
+};
+
+reg({
+cours: { id: 'k8s', match: /Kubernetes|k8s|orchestr/i,
+  titre: 'Kubernetes : orchestrer des conteneurs en production', duree: '',
+  niveau: 'BUT R&T DevCloud · BUT Informatique · AIS · Master',
+  prerequis: ['Conteneurs Docker', 'Docker Compose', 'Réseau : DNS, NAT, équilibrage'],
+  competences: ['BUT R&T DevCloud · Déployer et exploiter une plateforme de conteneurs', 'AIS · Administrer une infrastructure cloud', 'Master · Architecture des systèmes distribués'],
+  intro: 'Compose pilote une machine. Quand l’application doit tenir la charge de milliers d’utilisateurs, survivre à la panne d’un serveur et se mettre à jour sans coupure, il faut un orchestrateur. Kubernetes répartit les conteneurs sur un groupe de machines, les relance quand ils tombent, les déplace quand un nœud disparaît et ajuste leur nombre à la demande. Toutes les offres cloud françaises (Scaleway Kapsule, OVHcloud Managed Kubernetes, Outscale) le proposent. Ce module présente son architecture, ses objets principaux et le diagnostic d’un déploiement en panne.',
+  cm: [
+    { t: 'Architecture d’un cluster', d: '', html: 'Un cluster se compose d’un <b>plan de contrôle</b> et de <b>nœuds de travail</b>. Le plan de contrôle comprend l’<b>API server</b>, point d’entrée unique de toutes les commandes ; <b>etcd</b>, base clé-valeur qui stocke l’état du cluster ; le <b>scheduler</b>, qui choisit le nœud de chaque nouveau pod ; et le <b>controller manager</b>, qui fait converger l’état réel vers l’état désiré. Chaque nœud exécute <b>kubelet</b>, qui démarre les conteneurs via un moteur (containerd), et <b>kube-proxy</b> ou un équivalent qui programme le réseau des services.<br><br>Le principe central est la <b>boucle de réconciliation</b> : on déclare un état (« 3 répliques de cette image ») et des contrôleurs corrigent sans cesse tout écart. On ne dit jamais « démarre un conteneur », on décrit ce qui doit exister.' },
+    { t: 'Pods, Deployments et ReplicaSets', d: '', html: 'Le <b>pod</b> est la plus petite unité : un ou plusieurs conteneurs qui partagent une adresse IP et des volumes. On ne crée presque jamais un pod directement : un <b>Deployment</b> décrit l’image, le nombre de répliques et la stratégie de mise à jour, et crée un <b>ReplicaSet</b> qui maintient ce nombre de pods. Une mise à jour d’image crée un nouveau ReplicaSet et fait basculer progressivement les pods (rolling update) ; <code>kubectl rollout undo</code> revient à la version précédente.', exemple: 'apiVersion: apps/v1\nkind: Deployment\nmetadata: { name: resa, namespace: vie-scolaire }\nspec:\n  replicas: 3\n  selector: { matchLabels: { app: resa } }\n  template:\n    metadata: { labels: { app: resa } }\n    spec:\n      containers:\n        - name: app\n          image: registre.lycee.local/resa:9c1e4f2\n          ports: [{ containerPort: 8000 }]\n          resources:\n            requests: { cpu: 100m, memory: 128Mi }\n            limits: { memory: 256Mi }\n          readinessProbe: { httpGet: { path: /health, port: 8000 } }\n          livenessProbe: { httpGet: { path: /health, port: 8000 }, initialDelaySeconds: 10 }' },
+    { t: 'Services et Ingress', d: '', html: 'Les pods sont éphémères et changent d’adresse. Un <b>Service</b> fournit une adresse stable et un nom DNS (resa.vie-scolaire.svc.cluster.local) et répartit le trafic entre les pods dont les <b>labels</b> correspondent à son sélecteur. Le type <b>ClusterIP</b> est interne, <b>NodePort</b> ouvre un port sur chaque nœud, <b>LoadBalancer</b> demande un équilibreur au fournisseur cloud.<br><br>Pour le trafic HTTP, un <b>Ingress</b> route selon le nom d’hôte et le chemin vers les services, et termine TLS. Il nécessite un contrôleur d’Ingress (ingress-nginx, Traefik) ; cert-manager y ajoute des certificats Let’s Encrypt automatiques.', attention: 'Un Service qui ne sélectionne aucun pod (faute de frappe dans un label) ne renvoie aucune erreur à sa création : il n’a simplement aucun endpoint. kubectl get endpoints le révèle immédiatement.' },
+    { t: 'Configuration, secrets et stockage', d: '', html: 'Les <b>ConfigMap</b> portent la configuration non sensible, les <b>Secret</b> les mots de passe et clés ; ils s’injectent en variables ou en fichiers. Les Secret ne sont qu’encodés en base64 par défaut : on active le chiffrement d’etcd et on limite leur lecture par RBAC.<br><br>Le stockage persistant passe par des <b>PersistentVolumeClaim</b> : le pod demande « 10 Gi en lecture-écriture », et une <b>StorageClass</b> provisionne le volume chez le fournisseur. Pour une base de données, on utilise un <b>StatefulSet</b>, qui donne à chaque réplique un nom et un volume stables.' },
+    { t: 'Sondes, ressources et haute disponibilité', d: '', html: 'La <b>readinessProbe</b> indique si un pod peut recevoir du trafic : tant qu’elle échoue, le Service ne lui envoie rien. La <b>livenessProbe</b> indique s’il est vivant : en cas d’échec répété, kubelet redémarre le conteneur. Confondre les deux provoque des redémarrages en boucle au démarrage d’une application lente.<br><br>Les <b>requests</b> servent au scheduler pour placer les pods ; les <b>limits</b> plafonnent la consommation. Un conteneur qui dépasse sa limite mémoire est tué (OOMKilled). Le <b>HorizontalPodAutoscaler</b> ajuste le nombre de répliques selon la charge, et un <b>PodDisruptionBudget</b> garantit un nombre minimal de pods pendant une maintenance.' },
+    { t: 'Accès et sécurité', d: '', html: 'L’accès à l’API passe par des certificats ou des jetons, et les droits par <b>RBAC</b> : Role et ClusterRole définissent des verbes sur des ressources, RoleBinding les attribue. Les <b>namespaces</b> séparent les équipes ou les environnements. Les <b>NetworkPolicy</b> filtrent le trafic entre pods : sans elles, tout pod peut joindre tout autre pod. Les Pod Security Standards interdisent les conteneurs privilégiés ou en root.' }
+  ],
+  synthese: ['Plan de contrôle (API server, etcd, scheduler, contrôleurs) et nœuds (kubelet)', 'État désiré et boucle de réconciliation', 'Deployment → ReplicaSet → pods ; rollout et rollout undo', 'Service stable par labels, Ingress pour HTTP et TLS', 'ConfigMap, Secret, PVC et StatefulSet', 'readiness ≠ liveness ; requests et limits', 'RBAC, namespaces, NetworkPolicy'],
+  qcm: [
+    ['Quel composant stocke l’état du cluster ?', ['kubelet', 'etcd', 'kube-proxy', 'Ingress'], 1, 'Base clé-valeur répliquée.'],
+    ['Que se passe-t-il si l’on supprime un pod géré par un Deployment ?', ['Il disparaît définitivement', 'Le ReplicaSet en recrée un', 'Le Deployment est supprimé', 'Le cluster s’arrête'], 1, 'Réconciliation.'],
+    ['Comment un Service trouve-t-il ses pods ?', ['Par leur IP', 'Par sélecteur de labels', 'Par leur nom', 'Par le nœud'], 1, 'Les endpoints suivent les labels.'],
+    ['Une readinessProbe qui échoue provoque :', ['un redémarrage', 'le retrait du pod du Service', 'la suppression du nœud', 'rien'], 1, 'La liveness, elle, redémarre.'],
+    ['Que signifie OOMKilled ?', ['Réseau coupé', 'Dépassement de la limite mémoire', 'Image absente', 'Droits insuffisants'], 1, 'Le noyau tue le conteneur.'],
+    ['Quel objet pour une base de données répliquée ?', ['Deployment', 'StatefulSet', 'DaemonSet', 'Job'], 1, 'Identités et volumes stables.'],
+    ['Sans NetworkPolicy, les pods :', ['sont isolés', 'peuvent tous se joindre', 'n’ont pas de réseau', 'ne sortent pas'], 1, 'Tout est ouvert par défaut.']
+  ],
+  td: [
+    { n: 'Application', c: 'Écrire le Service ClusterIP et l’Ingress qui publient le Deployment resa sur resa.lycee.fr en HTTPS.', r: 'Service : selector app: resa, port 80 → targetPort 8000.\nIngress : host resa.lycee.fr, path /, backend service resa port 80, tls secretName resa-tls, annotation cert-manager.io/cluster-issuer.' },
+    { n: 'Application', c: 'Mettre à jour l’image vers le tag 51ab0d7, suivre le déploiement, puis revenir en arrière.', r: 'kubectl -n vie-scolaire set image deploy/resa app=registre.lycee.local/resa:51ab0d7\nkubectl -n vie-scolaire rollout status deploy/resa\nkubectl -n vie-scolaire rollout undo deploy/resa' },
+    { n: 'Approfondissement', c: 'Écrire une NetworkPolicy qui n’autorise vers la base PostgreSQL que les pods labellisés app: resa.', r: 'podSelector: { matchLabels: { app: postgres } }, policyTypes: [Ingress], ingress: [{ from: [{ podSelector: { matchLabels: { app: resa } } }], ports: [{ port: 5432 }] }]' }
+  ],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Un cluster k3s à trois nœuds.', etapes: ['Déployer l’application en 3 répliques', 'La publier par Service et Ingress', 'Tuer un pod et observer la réconciliation', 'Mettre à jour puis revenir en arrière', 'Isoler la base par NetworkPolicy'] },
+  plusLoin: [['Documentation Kubernetes (fr)', 'https://kubernetes.io/fr/docs/home/'], ['k3s', 'https://k3s.io/'], ['ANSSI · Recommandations de sécurité relatives au déploiement de conteneurs', 'https://cyber.gouv.fr/publications/recommandations-de-securite-relatives-au-deploiement-de-conteneurs-docker']] },
+plus: { cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Après la mise à jour de l’application de réservation, le site renvoie « 503 Service Temporarily Unavailable ». Diagnostiquer et rétablir.', etapes: [
+    ['Regarder les pods', 'kubectl -n vie-scolaire get pods -l app=resa\nNAME                    READY  STATUS            RESTARTS\nresa-7d9f6c5b8-2xkq4    0/1    CrashLoopBackOff  6\nresa-7d9f6c5b8-h7m2p    0/1    CrashLoopBackOff  6\n→ Aucun pod n’est prêt : l’Ingress n’a aucun backend, d’où les 503.'],
+    ['Lire les événements et les journaux', 'kubectl -n vie-scolaire describe pod resa-7d9f6c5b8-2xkq4 | tail -3\nWarning  Unhealthy  Liveness probe failed: Get "http://10.42.1.17:8000/health": connection refused\nWarning  BackOff    Back-off restarting failed container\nkubectl -n vie-scolaire logs resa-7d9f6c5b8-2xkq4 --previous | tail -1\nRunning database migrations… (this may take 40s)\n→ La nouvelle version exécute des migrations au démarrage ; la livenessProbe démarre à 10 s et tue le conteneur avant la fin.'],
+    ['Rétablir immédiatement', 'kubectl -n vie-scolaire rollout undo deploy/resa\nkubectl -n vie-scolaire rollout status deploy/resa\ndeployment "resa" successfully rolled out\n→ L’ancienne version est revenue ; le site répond.'],
+    ['Corriger la cause', 'Migrations déplacées dans un Job exécuté avant le déploiement, et ajout d’une startupProbe :\nstartupProbe: { httpGet: { path: /health, port: 8000 }, failureThreshold: 30, periodSeconds: 5 }\n→ La liveness n’est évaluée qu’une fois la startupProbe réussie.'],
+    ['Redéployer et documenter', 'kubectl apply -f resa.yaml ; kubectl -n vie-scolaire get pods -l app=resa\n3/3 Running\n→ Compte rendu : cause (liveness trop agressive face à des migrations), impact, rollback, correction, et test en préproduction avec une base de taille réelle.']
+  ] },
+  erreurs: ['Confondre readiness et liveness', 'Pas de requests ni de limits', 'Utiliser latest comme image', 'Laisser les Secret non chiffrés et lisibles par tous', 'Aucune NetworkPolicy', 'Faute de label entre Service et pods', 'Base de données en Deployment sans volume persistant'],
+  memo: [['Commande', 'Usage'], ['kubectl get pods -A -o wide', 'tous les pods et leur nœud'], ['kubectl describe pod <p>', 'événements, sondes, raisons d’échec'], ['kubectl logs <p> --previous', 'journaux du conteneur précédent'], ['kubectl get events --sort-by=.lastTimestamp', 'derniers événements'], ['kubectl get endpoints <svc>', 'pods réellement derrière un Service'], ['kubectl rollout status|undo deploy/<d>', 'suivre ou annuler un déploiement'], ['kubectl exec -it <p> -- sh', 'shell dans un pod'], ['kubectl top pods', 'consommation CPU et mémoire'], ['kubectl apply -f fichier.yaml', 'appliquer un état désiré'], ['kubectl auth can-i <verbe> <ressource>', 'tester des droits RBAC']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Décrire l’architecture d’un cluster. (4 pts)', 'Écrire Deployment, Service et Ingress pour une application donnée. (8 pts)', 'Expliquer readiness, liveness et startup probes. (3 pts)', 'Diagnostiquer un CrashLoopBackOff à partir de sorties fournies. (3 pts)', 'Citer deux mesures de sécurité. (2 pts)'], r: ['API server, etcd, scheduler, contrôleurs, kubelet', 'voir cours', 'trafic, redémarrage, démarrage lent', 'describe et logs --previous', 'RBAC, NetworkPolicy'] },
+  prof: { deroule: [['Ouverture', 'Arrêter un serveur Compose en direct, puis un nœud Kubernetes'], ['Cours', 'Architecture et réconciliation'], ['Pratique', 'Lab k3s'], ['Incident', 'CrashLoopBackOff'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : manifestes à compléter. Élèves avancés : Helm, HPA, GitOps avec Argo CD.', eval: 'Lab validé, sujet type.' } },
+exemples: [
+ ['Voir où tournent les pods', 'Un nœud va être mis en maintenance.', 'kubectl get pods -n vie-scolaire -o wide', 'NAME                  READY STATUS  NODE\nresa-6b8c7d-4kxz2     1/1   Running noeud-1\nresa-6b8c7d-9mpq7     1/1   Running noeud-1\nresa-6b8c7d-tt2r8     1/1   Running noeud-2', 'Deux répliques sont sur noeud-1 : drainer ce nœud en coupe deux sur trois. Un PodDisruptionBudget minAvailable: 2 et une règle d’anti-affinité répartiraient mieux la charge.'],
+ ['Service sans endpoints', 'Le site renvoie 503 alors que les pods tournent.', 'kubectl -n vie-scolaire get endpoints resa', 'NAME   ENDPOINTS   AGE\nresa   <none>      3d', 'Aucun pod ne correspond au sélecteur du Service. On compare kubectl get svc resa -o yaml (selector app: resa) avec les labels des pods (app: reservation) : faute de nommage.'],
+ ['Conteneur tué pour mémoire', 'Redémarrages fréquents.', 'kubectl -n vie-scolaire describe pod resa-6b8c7d-4kxz2 | grep -A2 "Last State"', 'Last State:  Terminated\n  Reason:    OOMKilled\n  Exit Code: 137', 'La limite de 256 Mi est trop basse pour la charge actuelle. On mesure avec kubectl top pods puis on ajuste requests et limits.'],
+ ['Suivre une mise à jour', 'Déploiement d’une nouvelle version.', 'kubectl -n vie-scolaire rollout status deploy/resa', 'Waiting for deployment "resa" rollout to finish: 1 of 3 updated replicas are available...\ndeployment "resa" successfully rolled out', 'Les pods sont remplacés un à un ; le service reste disponible pendant la mise à jour.'],
+ ['Tester un droit RBAC', 'Un enseignant doit pouvoir lire les journaux de son namespace.', 'kubectl auth can-i get pods/log -n vie-scolaire --as prof-sio', 'yes', 'La commande vérifie les droits effectifs sans les tester réellement.'],
+ ['Lire les derniers événements', 'Pod en Pending.', 'kubectl -n vie-scolaire get events --sort-by=.lastTimestamp | tail -2', 'Warning FailedScheduling pod/db-0  0/3 nodes are available: 3 Insufficient memory.', 'Aucun nœud n’a assez de mémoire libre pour la request demandée : réduire la request ou ajouter un nœud.']
+],
+termes: ['Kubernetes', 'cluster', 'pod', 'Deployment', 'ReplicaSet', 'StatefulSet', 'Service', 'ClusterIP', 'Ingress', 'ConfigMap', 'Secret', 'PersistentVolumeClaim', 'namespace', 'etcd', 'kubelet', 'API server', 'scheduler', 'readinessProbe', 'livenessProbe', 'startupProbe', 'requests', 'limits', 'OOMKilled', 'CrashLoopBackOff', 'RBAC', 'NetworkPolicy', 'kubectl', 'rollout', 'k3s']
+});
+
+reg({
+cours: { id: 'supervision', match: /supervision|Zabbix|Prometheus|Grafana|monitoring|Nagios/i,
+  titre: 'Supervision : mesurer, alerter et anticiper avec Prometheus et Zabbix', duree: '',
+  niveau: 'BTS SIO SISR · BTS CIEL IR · BUT R&T · TSSR / AIS',
+  prerequis: ['Diagnostic réseau en ligne de commande', 'Services systemd'],
+  competences: ['BTS SIO SISR · Bloc 2 · Superviser une infrastructure', 'BTS CIEL · C09 · Maintenir', 'TSSR · Superviser l’infrastructure'],
+  intro: 'Un service informatique qui apprend une panne par un appel d’utilisateur a déjà perdu. La supervision mesure en permanence l’état des serveurs, des réseaux et des applications, déclenche une alerte avant que les utilisateurs ne soient gênés et conserve l’historique qui permet de comprendre un incident ou d’anticiper une saturation. Ce module présente les notions (métriques, seuils, alertes), puis les deux outils les plus répandus dans les établissements et les entreprises : Zabbix et le couple Prometheus-Grafana.',
+  cm: [
+    { t: 'Que superviser ?', d: '', html: 'On distingue la <b>disponibilité</b> (le service répond-il ?), la <b>performance</b> (en combien de temps ?), la <b>capacité</b> (reste-t-il de la place, de la mémoire, de la bande passante ?) et les <b>erreurs</b> (taux de réponses 5xx, échecs de sauvegarde). Pour une application, la méthode des « quatre signaux d’or » résume l’essentiel : latence, trafic, erreurs, saturation.<br><br>On supervise à plusieurs niveaux : matériel (disques, température), système (CPU, mémoire, charge, espace disque), réseau (interfaces, pertes), services (ports, processus), et surtout <b>expérience utilisateur</b> : une sonde qui se connecte réellement à l’ENT et vérifie que la page de connexion s’affiche en moins de deux secondes.' },
+    { t: 'Collecte : agent, SNMP, export', d: '', html: 'Trois modes de collecte coexistent. Un <b>agent</b> installé sur la machine (Zabbix agent, node_exporter) remonte des métriques système détaillées. <b>SNMP</b> interroge les équipements réseau qui ne peuvent pas recevoir d’agent : switchs, bornes, onduleurs, imprimantes ; on lit des valeurs identifiées par des OID dans des MIB. Les applications modernes <b>exposent</b> elles-mêmes leurs métriques sur une page HTTP (/metrics).<br><br>SNMPv1 et v2c transmettent la communauté (le « mot de passe ») en clair ; on utilise <b>SNMPv3</b>, avec authentification et chiffrement, ou à défaut on limite v2c en lecture seule à l’adresse du serveur de supervision.' },
+    { t: 'Prometheus et Grafana', d: '', html: '<b>Prometheus</b> vient <b>chercher</b> (pull) les métriques des cibles à intervalle régulier et les stocke en séries temporelles, chaque série étant identifiée par un nom et des <b>labels</b> (instance, job, mountpoint). Le langage <b>PromQL</b> interroge ces séries : taux, moyennes, prédictions. Les <b>règles d’alerte</b> sont évaluées par Prometheus et envoyées à <b>Alertmanager</b>, qui regroupe, déduplique et notifie par courriel, messagerie ou SMS. <b>Grafana</b> affiche les tableaux de bord.', exemple: '# Espace disque libre en %\n100 * node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}\n\n# Règle : disque plein dans moins de 24 h au rythme actuel\n- alert: DisquePleinSous24h\n  expr: predict_linear(node_filesystem_avail_bytes{mountpoint="/"}[6h], 24*3600) < 0\n  for: 30m\n  labels: { severity: warning }\n  annotations: { summary: "{{ $labels.instance }} : disque plein sous 24 h" }' },
+    { t: 'Zabbix', d: '', html: '<b>Zabbix</b> est une solution intégrée très répandue dans les collectivités et les établissements : serveur, base de données, interface web et agents. On y définit des <b>hôtes</b>, auxquels on applique des <b>modèles</b> (templates) qui regroupent <b>éléments</b> (items, les valeurs collectées), <b>déclencheurs</b> (triggers, les conditions d’alerte) et graphiques. Les modèles fournis couvrent Linux, Windows, les principaux switchs et les services courants. La découverte automatique (LLD) crée les éléments pour chaque disque ou chaque interface détectée.' },
+    { t: 'Bien alerter', d: '', html: 'Une alerte doit être <b>actionnable</b> : si personne ne doit rien faire en la recevant, ce n’est pas une alerte mais une information pour un tableau de bord. Trop d’alertes produisent la <b>fatigue d’alerte</b> : l’équipe ne les lit plus, et la vraie panne passe inaperçue.<br><br>Les bonnes pratiques : alerter sur les symptômes vus par l’utilisateur plutôt que sur chaque cause possible ; ajouter une durée (for: 5m) pour ignorer les pics d’une seconde ; utiliser des seuils prédictifs (plein dans 24 h) plutôt que fixes ; hiérarchiser (info, avertissement, critique) ; et regrouper les alertes dépendantes : si le routeur d’un site tombe, on veut une alerte, pas cinquante.' },
+    { t: 'Journaux centralisés', d: '', html: 'Les métriques disent qu’il se passe quelque chose ; les <b>journaux</b> disent quoi. On les centralise pour les consulter en un seul endroit et les conserver même si un serveur est compromis : rsyslog ou journald vers un serveur central, ou des piles comme Loki avec Grafana, ou Elasticsearch. La centralisation est aussi une exigence de sécurité : l’ANSSI recommande de conserver et d’horodater les journaux d’authentification et d’administration.' }
+  ],
+  synthese: ['Disponibilité, performance, capacité, erreurs ; latence, trafic, erreurs, saturation', 'Agent, SNMP (v3), métriques exposées', 'Prometheus : pull, séries à labels, PromQL, Alertmanager ; Grafana pour l’affichage', 'Zabbix : hôtes, modèles, éléments, déclencheurs', 'Alertes actionnables, durée, seuils prédictifs, dépendances', 'Journaux centralisés et conservés'],
+  qcm: [
+    ['Quel protocole pour superviser un switch sans agent ?', ['SSH', 'SNMP', 'SMTP', 'DHCP'], 1, 'Lecture d’OID.'],
+    ['Pourquoi préférer SNMPv3 ?', ['Plus rapide', 'Authentification et chiffrement', 'Plus de métriques', 'Obligatoire'], 1, 'v2c envoie la communauté en clair.'],
+    ['Prometheus collecte les métriques en mode :', ['push', 'pull', 'SNMP trap', 'courriel'], 1, 'Il interroge les cibles.'],
+    ['Que fait for: 5m dans une règle d’alerte ?', ['Répète l’alerte', 'N’alerte que si la condition dure 5 minutes', 'Supprime l’alerte', 'Envoie 5 messages'], 1, 'Ignore les pics.'],
+    ['Qu’est-ce qu’une alerte actionnable ?', ['Une alerte rouge', 'Une alerte qui demande une action précise', 'Une alerte fréquente', 'Une alerte par SMS'], 1, 'Sinon c’est du bruit.'],
+    ['Dans Zabbix, un déclencheur est :', ['une valeur collectée', 'une condition qui génère un problème', 'un graphique', 'un agent'], 1, 'Trigger.']
+  ],
+  td: [
+    { n: 'Application', c: 'Lister ce qu’il faut superviser pour l’ENT d’un lycée, du matériel à l’expérience utilisateur, avec un seuil pour chaque élément.', r: 'Disque < 15 % · mémoire > 90 % pendant 10 min · charge > nb de cœurs · port 443 fermé · certificat expirant < 14 j · page de connexion > 2 s · taux de 5xx > 2 % · sauvegarde de la nuit en échec.' },
+    { n: 'Application', c: 'Écrire la requête PromQL du taux d’erreurs HTTP 5xx sur 5 minutes, et la règle d’alerte associée.', r: 'sum(rate(http_requests_total{status=~"5.."}[5m])) / sum(rate(http_requests_total[5m])) > 0.02 avec for: 10m.' },
+    { n: 'Approfondissement', c: 'Le routeur du site B tombe : 40 alertes arrivent en même temps. Proposer la configuration pour n’en recevoir qu’une.', r: 'Zabbix : dépendance des déclencheurs des hôtes du site B envers celui du routeur. Alertmanager : inhibit_rules qui masquent les alertes d’un site quand l’alerte « routeur injoignable » du même site est active.' }
+  ],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Prometheus, node_exporter, Alertmanager et Grafana sur deux VM.', etapes: ['Installer node_exporter', 'Déclarer la cible dans Prometheus', 'Créer un tableau de bord Grafana', 'Écrire une alerte disque prédictive', 'Remplir le disque et recevoir l’alerte'] },
+  plusLoin: [['Documentation Prometheus', 'https://prometheus.io/docs/'], ['Documentation Zabbix', 'https://www.zabbix.com/documentation/current/fr/manual'], ['Google SRE Book · Monitoring Distributed Systems', 'https://sre.google/sre-book/monitoring-distributed-systems/']] },
+plus: { cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Lundi 7 h 50 : l’alerte « DisquePleinSous24h » est arrivée à 2 h sur le serveur de fichiers, sans que personne ne réagisse. À 7 h 45 le disque est plein et les enseignants ne peuvent plus enregistrer. Rétablir puis fiabiliser la chaîne d’alerte.', etapes: [
+    ['Rétablir le service', 'df -h /srv\n/dev/sdb1  500G  500G  0  100% /srv\nsudo du -xh --max-depth=2 /srv | sort -h | tail -3\n180G  /srv/partage/tmp/exports-pronote\n→ Un script d’export mal configuré écrit un fichier toutes les minutes depuis vendredi.'],
+    ['Arrêter la cause et libérer de la place', 'sudo systemctl stop export-pronote.timer\nsudo find /srv/partage/tmp/exports-pronote -mtime +0 -delete\ndf -h /srv\n/dev/sdb1  500G  322G  178G  65% /srv\n→ Les enseignants peuvent de nouveau enregistrer.'],
+    ['Comprendre pourquoi l’alerte n’a servi à rien', 'amtool alert query DisquePleinSous24h\nalertname=DisquePleinSous24h severity=warning instance=fichiers:9100\n→ L’alerte a bien été émise, mais en severity warning, routée vers une adresse de courriel lue seulement en journée.'],
+    ['Corriger le routage', 'route:\n  routes:\n    - matchers: [severity="critical"]\n      receiver: astreinte-sms\n# nouvelle règle : disque plein sous 6 h → critical\n→ L’alerte à 24 h reste un avertissement par courriel ; une seconde règle à 6 h devient critique et part vers l’astreinte.'],
+    ['Superviser la cause', '→ Ajout d’une alerte sur le nombre de fichiers créés par heure dans /srv/partage/tmp, et correction du script d’export (rotation des anciens fichiers). Compte rendu : l’outil avait détecté le problème six heures à l’avance ; le défaut était dans l’organisation de la réponse.']
+  ] },
+  erreurs: ['Alerter sur tout, sans hiérarchie', 'Seuils fixes sans durée', 'Aucune supervision de l’expérience utilisateur', 'SNMP v2c en écriture avec la communauté public', 'Alertes envoyées à une boîte que personne ne lit', 'Oublier de superviser les sauvegardes et les certificats'],
+  memo: [['Outil / commande', 'Usage'], ['curl -s localhost:9100/metrics | head', 'vérifier un node_exporter'], ['promtool check config prometheus.yml', 'valider la configuration'], ['promtool check rules regles.yml', 'valider les règles d’alerte'], ['amtool alert query', 'alertes actives dans Alertmanager'], ['snmpwalk -v3 -l authPriv … <hôte> IF-MIB::ifOperStatus', 'lire l’état des ports d’un switch'], ['zabbix_get -s <hôte> -k system.cpu.load', 'tester un élément Zabbix'], ['systemctl status zabbix-agent2', 'état de l’agent'], ['journalctl -u prometheus', 'journaux du serveur'], ['rate(), increase(), predict_linear()', 'fonctions PromQL essentielles']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Proposer un plan de supervision pour un service donné. (6 pts)', 'Comparer agent, SNMP et métriques exposées. (4 pts)', 'Écrire deux règles d’alerte avec seuils et durées. (5 pts)', 'Analyser un incident de fatigue d’alerte. (5 pts)'], r: ['matériel → expérience utilisateur', 'voir cours', 'expr + for + severity', 'actionnable, hiérarchie, dépendances'] },
+  prof: { deroule: [['Ouverture', 'Quelle panne avez-vous apprise par un utilisateur ?'], ['Cours', 'Quoi superviser, comment collecter'], ['Pratique', 'Lab Prometheus et Grafana'], ['Incident', 'Alerte émise mais ignorée'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : tableau de bord importé, une seule alerte. Élèves avancés : SNMPv3, Loki, inhibitions.', eval: 'Alerte reçue pendant le lab, sujet type.' } },
+exemples: [
+ ['Vérifier une cible Prometheus', 'Un serveur n’apparaît plus dans Grafana.', 'curl -s http://prometheus:9090/api/v1/targets | jq -r \'.data.activeTargets[] | "\\(.labels.instance) \\(.health) \\(.lastError)"\'', 'fichiers:9100 up \nweb1:9100 down Get "http://web1:9100/metrics": dial tcp 10.62.40.21:9100: connect: connection refused', 'node_exporter ne tourne plus sur web1 (ou le pare-feu bloque 9100). systemctl status prometheus-node-exporter sur web1.'],
+ ['Lire l’état des ports d’un switch', 'Un bâtiment signale des coupures.', 'snmpwalk -v3 -l authPriv -u supervision -a SHA -A "…" -x AES -X "…" sw-bat-b IF-MIB::ifOperStatus | grep -v up', 'IF-MIB::ifOperStatus.10017 = INTEGER: down(2)', 'Le port 17 est tombé. Avec ifAlias, on retrouve qu’il s’agit de la liaison montante vers le bâtiment B.'],
+ ['Prédire la saturation', 'Planifier l’achat de disques.', 'predict_linear(node_filesystem_avail_bytes{instance="fichiers:9100",mountpoint="/srv"}[7d], 30*24*3600)', '-4.2e+10', 'Au rythme des sept derniers jours, il manquera environ 42 Go dans 30 jours : on commande avant l’incident.'],
+ ['Tester un élément Zabbix', 'Un élément reste vide dans l’interface.', 'zabbix_get -s 10.62.40.10 -k vfs.fs.size[/srv,pfree]', 'ZBX_NOTSUPPORTED: Cannot obtain filesystem information: [2] No such file or directory', 'Le point de montage n’existe pas sur cet hôte : le modèle appliqué ne correspond pas à la machine. On utilise la découverte automatique des systèmes de fichiers.'],
+ ['Voir les alertes actives', 'Point d’astreinte du matin.', 'amtool alert query --active', 'Alertname             Starts At             Summary\nCertificatExpire      2026-09-28 06:00      ent.lycee.fr expire dans 9 jours\nSauvegardeEchec       2026-09-30 03:12      sauvegarde nocturne de db1 en échec', 'Deux actions claires pour la journée : renouveler le certificat (vérifier certbot) et relancer la sauvegarde de db1.'],
+ ['Valider les règles avant rechargement', 'Nouvelle règle d’alerte.', 'promtool check rules /etc/prometheus/regles.yml', 'Checking /etc/prometheus/regles.yml\n  FAILED:\n  group "systeme", rule 3: could not parse expression: unexpected "}"', 'Une accolade en trop dans la règle 3. Sans ce contrôle, Prometheus aurait refusé de recharger toute la configuration.']
+],
+termes: ['supervision', 'métrique', 'alerte', 'seuil', 'SNMP', 'SNMPv3', 'OID', 'MIB', 'agent', 'Prometheus', 'PromQL', 'node_exporter', 'Alertmanager', 'Grafana', 'Zabbix', 'déclencheur', 'modèle', 'predict_linear', 'rate', 'fatigue d’alerte', 'Loki', 'rsyslog']
+});
+
+reg({
+cours: { id: 'annuaire', match: /LDAP|Active Directory|annuaire|AD DS|GPO|Samba/i,
+  titre: 'Annuaires : LDAP, Active Directory, GPO et Samba', duree: '',
+  niveau: 'BTS SIO SISR · BTS CIEL IR · BUT R&T · TSSR',
+  prerequis: ['DNS : résolution et zones', 'Droits et utilisateurs'],
+  competences: ['BTS SIO SISR · Bloc 2 · Administrer les services d’annuaire', 'BTS SIO · Bloc 3 · Gérer les identités et les accès', 'TSSR · Exploiter un annuaire'],
+  intro: 'Dans un établissement de 1 500 comptes, créer chaque utilisateur sur chaque serveur est impossible. L’annuaire centralise les identités, les groupes et les droits : un élève se connecte avec le même identifiant sur n’importe quel poste, au Wi-Fi, à l’imprimante et aux applications. Active Directory domine dans les établissements et les entreprises ; il repose sur des standards ouverts (LDAP, Kerberos, DNS) que l’on retrouve dans Samba et OpenLDAP. Ce module en décrit le fonctionnement, l’administration et la sécurisation.',
+  cm: [
+    { t: 'LDAP : un arbre d’objets', d: '', html: 'LDAP (Lightweight Directory Access Protocol) est le protocole d’interrogation des annuaires. Les données forment un <b>arbre</b> (DIT) : chaque entrée a un <b>DN</b> (Distinguished Name) unique, lu de la feuille vers la racine, par exemple <code>CN=Léa M.,OU=SIO1,OU=Eleves,DC=lycee,DC=local</code>. Les entrées appartiennent à des <b>classes d’objets</b> (user, group, organizationalUnit) qui définissent leurs <b>attributs</b> (sAMAccountName, mail, memberOf). LDAP écoute sur le port 389, LDAPS (chiffré) sur 636.' },
+    { t: 'Active Directory : domaine, forêt, contrôleurs', d: '', html: 'Un <b>domaine</b> AD regroupe comptes, groupes et ordinateurs sous une même autorité, avec un nom DNS (lycee.local, ou mieux un sous-domaine d’un domaine possédé : ad.lycee-exemple.fr). Les <b>contrôleurs de domaine</b> (DC) hébergent l’annuaire et le répliquent entre eux ; on en installe au moins deux. Plusieurs domaines peuvent former une <b>forêt</b>.<br><br>AD dépend entièrement du <b>DNS</b> : les clients trouvent les DC grâce aux enregistrements SRV (<code>_ldap._tcp.dc._msdcs.lycee.local</code>). Un poste qui n’utilise pas le DNS du domaine ne peut pas le rejoindre. L’authentification repose sur <b>Kerberos</b>, qui impose des horloges synchronisées à cinq minutes près.' },
+    { t: 'Organiser : OU, groupes et délégation', d: '', html: 'Les <b>unités d’organisation</b> (OU) rangent les objets pour appliquer des stratégies et déléguer l’administration : OU Eleves, Professeurs, Administration, Ordinateurs\\Salles. Les <b>groupes</b> portent les droits. La méthode AGDLP résume la bonne pratique : les comptes (A) vont dans des groupes globaux par fonction (G, « Profs-SIO »), placés dans des groupes locaux de domaine par ressource (DL, « Partage-SIO-Modification »), auxquels on donne les permissions (P). On ne donne jamais un droit directement à un utilisateur.' },
+    { t: 'Stratégies de groupe (GPO)', d: '', html: 'Une <b>GPO</b> applique des paramètres aux ordinateurs et aux utilisateurs d’une OU : fond d’écran, lecteurs réseau, imprimantes, mises à jour, pare-feu, restrictions, déploiement de logiciels. L’ordre d’application est LSDOU : local, site, domaine, OU (de la plus haute à la plus basse) ; la dernière appliquée l’emporte, sauf blocage ou application forcée. <code>gpupdate /force</code> applique immédiatement, <code>gpresult /r</code> montre les GPO effectivement reçues.' },
+    { t: 'Samba et intégration Linux', d: '', html: '<b>Samba</b> partage des fichiers et des imprimantes avec les postes Windows (protocole SMB) et peut même servir de <b>contrôleur de domaine</b> compatible AD, solution répandue dans les établissements attachés aux logiciels libres. Un serveur Linux rejoint un domaine AD avec <b>realmd</b> et <b>SSSD</b> (<code>realm join</code>) : les comptes du domaine s’y connectent en SSH et les groupes AD pilotent les droits sudo.', exemple: 'sudo realm discover lycee.local\nsudo realm join -U administrateur lycee.local\nid lea.martin@lycee.local\nuid=1854201103(lea.martin@lycee.local) … groupes=…(eleves-sio1@lycee.local)' },
+    { t: 'Sécurité de l’annuaire', d: '', html: 'L’annuaire est la cible principale des attaquants : compromettre un compte d’administrateur du domaine, c’est posséder tout le réseau. Les recommandations de l’ANSSI s’organisent en niveaux (tiering) : les comptes d’administration du domaine ne se connectent qu’aux DC, jamais à un poste utilisateur. Autres mesures : comptes d’administration séparés des comptes du quotidien, mots de passe longs, <b>LAPS</b> pour des mots de passe administrateur local différents sur chaque poste, désactivation des protocoles anciens (NTLMv1, SMBv1), LDAPS ou signature LDAP, et audit régulier avec des outils comme PingCastle.' }
+  ],
+  synthese: ['LDAP : arbre, DN, classes et attributs ; 389 et 636', 'AD : domaine, forêt, au moins deux DC ; dépend du DNS et de Kerberos', 'OU pour organiser et appliquer, groupes pour les droits (AGDLP)', 'GPO appliquées en LSDOU ; gpresult pour vérifier', 'Samba, realmd et SSSD pour Linux', 'Tiering, comptes séparés, LAPS, protocoles anciens désactivés'],
+  qcm: [
+    ['Que désigne un DN ?', ['Un nom DNS', 'Le chemin unique d’une entrée dans l’arbre LDAP', 'Un groupe', 'Un port'], 1, 'Distinguished Name.'],
+    ['Pourquoi un poste ne trouve-t-il pas le domaine ?', ['Pare-feu Windows', 'Il n’utilise pas le DNS du domaine', 'Mauvais fond d’écran', 'LAPS'], 1, 'Enregistrements SRV.'],
+    ['Quel écart d’horloge maximal tolère Kerberos par défaut ?', ['1 s', '5 min', '1 h', 'Aucun'], 1, 'D’où NTP obligatoire.'],
+    ['Où donner une permission sur un partage selon AGDLP ?', ['À l’utilisateur', 'À un groupe local de domaine', 'À l’OU', 'Au DC'], 1, 'Comptes → global → local → permission.'],
+    ['Quelle commande montre les GPO reçues par un poste ?', ['gpupdate', 'gpresult /r', 'ipconfig', 'netstat'], 1, 'Résultat de la stratégie.'],
+    ['Quel outil donne un mot de passe administrateur local différent à chaque poste ?', ['GPO', 'LAPS', 'SSSD', 'Kerberos'], 1, 'Local Administrator Password Solution.']
+  ],
+  td: [
+    { n: 'Application', c: 'Proposer l’arborescence d’OU et les groupes d’un lycée avec BTS SIO, sa salle de TP et le partage « Sujets » accessible en modification aux profs de SIO, en lecture aux élèves de SIO.', r: 'OU Utilisateurs\\Eleves\\SIO1, SIO2 · OU Utilisateurs\\Profs · OU Ordinateurs\\Salles\\B204 · groupes globaux G-Eleves-SIO, G-Profs-SIO · groupes locaux DL-Sujets-Lecture, DL-Sujets-Modif · permissions NTFS et partage sur ces DL.' },
+    { n: 'Application', c: 'Écrire la requête ldapsearch qui liste les comptes de l’OU SIO1 avec leur adresse mail.', r: 'ldapsearch -H ldaps://dc1.lycee.local -D "cn=lecture,…" -W -b "OU=SIO1,OU=Eleves,DC=lycee,DC=local" "(objectClass=user)" sAMAccountName mail' },
+    { n: 'Approfondissement', c: 'Expliquer pourquoi un administrateur du domaine ne doit pas ouvrir de session sur un poste d’élève.', r: 'Son jeton ou ses identifiants restent en mémoire du poste ; si celui-ci est compromis, l’attaquant les récupère et devient administrateur du domaine (modèle de tiering de l’ANSSI).' }
+  ],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Un contrôleur Samba AD, un client Windows et un serveur Linux.', etapes: ['Provisionner le domaine Samba AD', 'Vérifier les enregistrements SRV', 'Créer OU, comptes et groupes', 'Joindre le serveur Linux avec realmd', 'Appliquer une GPO de lecteur réseau'] },
+  plusLoin: [['ANSSI · Recommandations de sécurité relatives à Active Directory', 'https://cyber.gouv.fr/publications/recommandations-de-securite-relatives-active-directory'], ['Samba Wiki · Setting up Samba as an AD DC', 'https://wiki.samba.org/index.php/Setting_up_Samba_as_an_Active_Directory_Domain_Controller'], ['PingCastle', 'https://www.pingcastle.com/']] },
+plus: { cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Ce matin, aucun élève de la salle B204 ne parvient à ouvrir de session (« La relation d’approbation entre cette station de travail et le domaine principal a échoué » sur certains postes, « L’heure du serveur diffère » sur d’autres). Les autres salles fonctionnent.', etapes: [
+    ['Vérifier l’heure', 'Sur un poste de B204 (session locale) : w32tm /stripchart /computer:dc1.lycee.local /samples:1\n11:47:02, d:+00.0012s o:-00:07:41.3\n→ Le poste a 7 min 41 s de retard sur le DC : Kerberos refuse l’authentification au-delà de 5 minutes.'],
+    ['Trouver pourquoi', 'w32tm /query /source\nLocal CMOS Clock\n→ Les postes de B204, réinstallés pendant les vacances à partir d’une image, ne prennent plus l’heure du domaine.'],
+    ['Corriger l’heure', 'w32tm /config /syncfromflags:domhier /update\nnet stop w32time && net start w32time\nw32tm /resync\n→ Le poste se synchronise sur la hiérarchie du domaine.'],
+    ['Réparer la relation d’approbation', 'Sur les postes au message « relation d’approbation » :\nTest-ComputerSecureChannel -Repair -Credential lycee\\technicien\nTrue\n→ Le mot de passe du compte ordinateur, restauré depuis une image ancienne, ne correspondait plus à celui de l’annuaire ; le canal sécurisé est réinitialisé.'],
+    ['Généraliser et prévenir', '→ La correction est déployée par GPO sur l’OU Salles (source de temps du domaine) ; les images de poste sont préparées avec Sysprep et jointes au domaine après déploiement. Compte rendu rédigé.']
+  ] },
+  erreurs: ['Postes qui n’utilisent pas le DNS du domaine', 'Horloges non synchronisées', 'Un seul contrôleur de domaine', 'Droits donnés directement aux utilisateurs', 'Administrateur du domaine utilisé sur les postes', 'Même mot de passe administrateur local partout', 'LDAP simple non chiffré'],
+  memo: [['Commande', 'Usage'], ['nslookup -type=SRV _ldap._tcp.dc._msdcs.lycee.local', 'trouver les contrôleurs de domaine'], ['ldapsearch -H ldaps://… -b … "(filtre)"', 'interroger l’annuaire'], ['gpupdate /force', 'appliquer les GPO'], ['gpresult /r', 'GPO effectivement appliquées'], ['w32tm /query /status', 'source et écart de temps'], ['Test-ComputerSecureChannel -Repair', 'réparer la relation avec le domaine'], ['samba-tool user create|list', 'gérer les comptes Samba AD'], ['samba-tool drs showrepl', 'état de la réplication'], ['realm join -U admin domaine', 'joindre un Linux au domaine'], ['id utilisateur@domaine', 'vérifier un compte depuis Linux']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Décrire le rôle de DNS et Kerberos dans AD. (4 pts)', 'Proposer OU et groupes pour un cas donné selon AGDLP. (6 pts)', 'Expliquer l’ordre d’application des GPO et diagnostiquer une GPO non appliquée. (5 pts)', 'Citer cinq mesures de sécurité de l’annuaire. (5 pts)'], r: ['SRV, tickets, horloge', 'voir TD', 'LSDOU, gpresult', 'tiering, LAPS, comptes séparés, NTLMv1/SMBv1, audit'] },
+  prof: { deroule: [['Ouverture', 'Combien de mots de passe auriez-vous sans annuaire ?'], ['Cours', 'LDAP, AD, DNS, Kerberos'], ['Pratique', 'Lab Samba AD'], ['Incident', 'Heure et relation d’approbation'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : arborescence fournie. Élèves avancés : audit PingCastle, tiering.', eval: 'Lab validé, sujet type.' } },
+exemples: [
+ ['Trouver les contrôleurs de domaine', 'Un poste ne rejoint pas le domaine.', 'nslookup -type=SRV _ldap._tcp.dc._msdcs.lycee.local', '_ldap._tcp.dc._msdcs.lycee.local SRV service location:\n  priority = 0, weight = 100, port = 389, svr hostname = dc1.lycee.local\n  priority = 0, weight = 100, port = 389, svr hostname = dc2.lycee.local', 'Les deux DC sont annoncés. Si la commande échoue, le poste n’interroge pas le DNS du domaine : on vérifie sa configuration DNS avant tout le reste.'],
+ ['Chercher un compte', 'Retrouver les groupes d’un élève.', 'ldapsearch -LLL -H ldaps://dc1.lycee.local -D "CN=lecture,OU=Services,DC=lycee,DC=local" -W -b "DC=lycee,DC=local" "(sAMAccountName=lea.martin)" memberOf', 'dn: CN=Léa M.,OU=SIO1,OU=Eleves,DC=lycee,DC=local\nmemberOf: CN=G-Eleves-SIO,OU=Groupes,DC=lycee,DC=local', 'LDAPS chiffre l’échange ; le compte de lecture dédié n’a aucun autre droit.'],
+ ['Vérifier les GPO d’un poste', 'Le lecteur réseau n’apparaît pas.', 'gpresult /r /scope:user', 'Objets Stratégie de groupe appliqués\n    GPO-Eleves-Fond\nLes GPO suivants n’ont pas été appliqués car ils ont été filtrés\n    GPO-Lecteurs-SIO\n        Filtrage :  Refusé (Sécurité)', 'La GPO des lecteurs est filtrée par sécurité : le groupe de l’élève n’a pas le droit « Appliquer la stratégie de groupe ».'],
+ ['Contrôler la réplication', 'Un compte créé sur dc1 n’existe pas sur dc2.', 'sudo samba-tool drs showrepl | grep -A3 "INBOUND" | tail -3', 'DC=lycee,DC=local\n  Default-First-Site-Name\\DC1 via RPC\n    Last attempt @ … failed, result 1256 (WERR_NO_SUCH_SERVICE)', 'La réplication de dc1 vers dc2 échoue. On vérifie la résolution de dc1 depuis dc2 et l’ouverture des ports RPC.'],
+ ['Joindre un Linux au domaine', 'Nouveau serveur Debian.', 'sudo realm join -U technicien lycee.local && realm list | grep -E "realm-name|configured"', 'realm-name: LYCEE.LOCAL\nconfigured: kerberos-member', 'Le serveur est membre ; les comptes du domaine peuvent s’y connecter selon les règles de realm permit.'],
+ ['Repérer les mots de passe qui n’expirent pas', 'Audit des comptes.', 'Get-ADUser -Filter {PasswordNeverExpires -eq $true -and Enabled -eq $true} | Select Name', 'Name\n----\nsvc-sauvegarde\nancien.stagiaire', 'Un compte de stagiaire parti est encore actif avec un mot de passe éternel : on le désactive. Le compte de service doit devenir un compte de service géré (gMSA).']
+],
+termes: ['LDAP', 'LDAPS', 'DN', 'OU', 'Active Directory', 'domaine', 'forêt', 'contrôleur de domaine', 'Kerberos', 'SRV', 'GPO', 'LSDOU', 'AGDLP', 'gpupdate', 'gpresult', 'Samba', 'SSSD', 'realmd', 'LAPS', 'tiering', 'NTLM', 'SMB', 'ldapsearch', 'samba-tool']
+});
+})();

portail/public/js/contenus-long.js

@@ -0,0 +1,64 @@
+// Lecture longue, schémas et emplacements photo pour chaque cours complet
+(function () {
+var K = 'stroke="#000" stroke-width="3"';
+var box = function (x, y, w, h, fill, txt, fs) { return '<rect x="' + x + '" y="' + y + '" width="' + w + '" height="' + h + '" fill="' + fill + '" ' + K + '/><text x="' + (x + w / 2) + '" y="' + (y + h / 2 + (fs || 16) / 3) + '" text-anchor="middle" font-family="Archivo,sans-serif" font-weight="800" font-size="' + (fs || 16) + '">' + txt + '</text>'; };
+var arrow = function (x1, y1, x2, y2) { return '<line x1="' + x1 + '" y1="' + y1 + '" x2="' + x2 + '" y2="' + y2 + '" ' + K + ' marker-end="url(#fl)"/>'; };
+var svg = function (w, h, body) { return '<svg viewBox="0 0 ' + w + ' ' + h + '" class="h-auto w-full" role="img"><defs><marker id="fl" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto"><path d="M0 0 L10 5 L0 10 z"/></marker></defs>' + body + '</svg>'; };
+var bits = [128, 64, 32, 16, 8, 4, 2, 1], v = [1, 0, 1, 1, 0, 0, 1, 0];
+window.CONTENUS_LONG = Object.assign(window.CONTENUS_LONG || {}, {
+binaire: { figure: svg(720, 200, bits.map(function (b, i) { return box(20 + i * 85, 20, 80, 50, '#F6F5F1', b, 16) + box(20 + i * 85, 80, 80, 60, v[i] ? '#FFD23F' : '#fff', v[i], 26); }).join('') + '<text x="20" y="180" font-family="IBM Plex Mono,monospace" font-weight="600" font-size="18">1011 0010₂ = 128 + 32 + 16 + 2 = 178</text>'), legende: 'Chaque case d’un octet a un poids. On additionne les poids des bits à 1.',
+  photo: 'Photo : barrette de mémoire vive ou vue au microscope d’une puce',
+  lecture: ['Imaginez une rangée de huit interrupteurs. Chacun peut être allumé ou éteint. Si l’on convient que le premier vaut 1, le deuxième 2, le troisième 4, et ainsi de suite en doublant à chaque fois, on peut représenter n’importe quel nombre de 0 à 255 en choisissant quels interrupteurs allumer. C’est exactement ce que fait un octet dans la mémoire d’un ordinateur.',
+    'Pourquoi doubler ? Parce que chaque interrupteur n’a que deux positions. En base 10, on a dix chiffres, donc chaque position vaut dix fois la précédente : unités, dizaines, centaines. En base 2, on n’a que deux chiffres, donc chaque position vaut deux fois la précédente. La logique est la même, seule la base change.',
+    'L’hexadécimal n’est qu’une écriture plus compacte du binaire. Lire 32 zéros et uns d’affilée est pénible et source d’erreurs ; en les regroupant par quatre, on obtient huit symboles faciles à recopier. C’est pour cela que les adresses MAC, les couleurs web et les adresses IPv6 s’écrivent en hexadécimal : l’humain lit vite, et la machine retrouve les bits sans calcul.',
+    'Dans la pratique, un administrateur réseau manipule ces conversions tous les jours sans même y penser : un masque /26, c’est 26 bits à 1, donc un dernier octet à 1100 0000, soit 192. Ceux qui maîtrisent ce réflexe découpent un réseau en sous-réseaux de tête ; les autres sortent la calculatrice. L’objectif de ce cours est de vous faire passer dans la première catégorie.'] },
+terminal: { figure: svg(720, 260, box(310, 10, 100, 40, '#000', '<tspan fill="#fff">/</tspan>', 20) + [['etc', 20], ['home', 160], ['var', 300], ['usr', 440], ['tmp', 580]].map(function (d) { return arrow(360, 50, d[1] + 60, 95) + box(d[1], 100, 120, 40, '#fff', '/' + d[0], 16); }).join('') + arrow(220, 140, 220, 185) + box(160, 190, 120, 40, '#FFD23F', 'eleve', 16) + arrow(360, 140, 360, 185) + box(300, 190, 120, 40, '#7CF2C0', 'log', 16)), legende: 'L’arborescence Linux part d’une seule racine, /. Votre dossier personnel est /home/eleve.',
+  photo: 'Photo : une salle serveur ou un administrateur devant un terminal',
+  lecture: ['Quand on découvre le terminal, l’écran noir impressionne. Pourtant, il ne fait rien d’autre que ce que fait l’explorateur de fichiers : afficher des dossiers, en ouvrir, copier, déplacer. La différence, c’est qu’on écrit ce qu’on veut au lieu de cliquer, et que ce qu’on écrit peut être rejoué, partagé et automatisé.',
+    'Sur un serveur, il n’y a souvent pas d’interface graphique du tout. On s’y connecte à distance par SSH depuis un autre ordinateur, parfois depuis l’autre bout du monde, et le terminal est la seule porte d’entrée. Un technicien qui sait s’en servir intervient en quelques secondes là où un autre devrait se déplacer.',
+    'La première compétence est de toujours savoir où l’on est. L’invite vous le dit, pwd le confirme. La plupart des erreurs de débutant viennent d’une commande lancée dans le mauvais dossier : un fichier créé « nulle part », un rm qui supprime autre chose que prévu. Prenez l’habitude de regarder l’invite avant d’appuyer sur Entrée.',
+    'La deuxième compétence est de ne pas tout retenir. Personne ne connaît toutes les options de toutes les commandes. Les professionnels utilisent man, --help, la touche Tab et l’historique en permanence. Savoir chercher l’information est plus important que la connaître par cœur.'] },
+droits: { figure: svg(720, 190, box(20, 20, 60, 60, '#F6F5F1', '-', 26) + [['r', 'w', 'x', '#FFD23F', 'propriétaire (u)'], ['r', '-', 'x', '#7CF2C0', 'groupe (g)'], ['-', '-', '-', '#FF6FB5', 'autres (o)']].map(function (g, i) { var x = 100 + i * 205; return box(x, 20, 60, 60, g[3], g[0], 26) + box(x + 62, 20, 60, 60, g[3], g[1], 26) + box(x + 124, 20, 60, 60, g[3], g[2], 26) + '<text x="' + (x + 92) + '" y="110" text-anchor="middle" font-family="Archivo,sans-serif" font-weight="800" font-size="16">' + g[4] + '</text><text x="' + (x + 92) + '" y="150" text-anchor="middle" font-family="IBM Plex Mono,monospace" font-weight="600" font-size="26">' + [7, 5, 0][i] + '</text>'; }).join('')), legende: 'rwxr-x--- : trois triplets, un par catégorie. En octal, 750.',
+  photo: 'Photo : badge d’accès ou porte de salle serveur sécurisée',
+  lecture: ['Un serveur de lycée héberge à la fois les sujets d’examen des enseignants, les travaux des élèves et les fichiers de configuration du système. Sans règles, n’importe qui pourrait lire les sujets la veille de l’épreuve ou modifier la configuration. Les droits Unix sont ces règles, et elles s’appliquent à chaque fichier.',
+    'Le modèle est volontairement simple : trois catégories de personnes, trois actions possibles. Cette simplicité est une force, car elle se vérifie d’un coup d’œil avec ls -l. Elle a aussi des limites, que les ACL viennent combler quand il faut donner un accès à une seule personne sans créer de groupe.',
+    'Le piège classique est de « tout ouvrir » pour que ça marche : chmod 777. Le service redémarre, l’utilisateur est content, et le serveur vient de perdre toute protection. Un bon technicien cherche au contraire le droit minimum qui suffit. C’est le principe du moindre privilège, au cœur des recommandations de l’ANSSI.',
+    'Retenez enfin que sur un dossier, x ne veut pas dire « exécuter » mais « traverser ». Un dossier en r-- permet de voir les noms des fichiers sans pouvoir les ouvrir, ce qui surprend toujours la première fois.'] },
+tubes: { figure: svg(720, 130, [['auth.log', '#F6F5F1'], ['grep', '#FFD23F'], ['awk', '#7CF2C0'], ['sort | uniq -c', '#C4B5FD'], ['head', '#FF6FB5']].map(function (s, i) { return box(10 + i * 142, 40, 120, 50, s[1], s[0], 14) + (i < 4 ? arrow(130 + i * 142, 65, 150 + i * 142, 65) : ''); }).join('')), legende: 'Chaque commande transforme le flux et passe le résultat à la suivante.',
+  photo: 'Photo : un écran de supervision avec des journaux qui défilent',
+  lecture: ['Un journal système, c’est un fichier texte où chaque ligne raconte un événement : une connexion, une erreur, un démarrage de service. Sur un serveur exposé à Internet, auth.log peut grossir de plusieurs milliers de lignes par jour. Personne ne les lit une par une.',
+    'La philosophie Unix propose une réponse élégante : de petits outils qui font chacun une seule chose, et un moyen de les brancher entre eux. grep sait filtrer, sort sait trier, uniq sait compter les doublons. Aucun ne sait analyser un journal seul ; ensemble, ils répondent en une ligne à des questions complexes.',
+    'Construisez toujours une chaîne pas à pas. Lancez la première commande, regardez le résultat, ajoutez un tube et la commande suivante, regardez encore. Une chaîne de six commandes écrite d’un coup ne marche presque jamais du premier essai ; construite progressivement, elle se met au point en deux minutes.',
+    'Quand une chaîne est utile, on la sauvegarde dans un script et on la planifie. C’est le premier pas vers l’automatisation, compétence très recherchée chez les techniciens et les administrateurs.'] },
+osi: { figure: svg(720, 330, ['7 Application · HTTP, DNS', '6 Présentation · TLS', '5 Session', '4 Transport · TCP, UDP', '3 Réseau · IP', '2 Liaison · Ethernet', '1 Physique · câble, radio'].map(function (t, i) { return box(20, 10 + i * 44, 420, 40, ['#FF6FB5', '#FF6FB5', '#FF6FB5', '#C4B5FD', '#7CF2C0', '#FFD23F', '#F6F5F1'][i], t, 15); }).join('') + [['Application', 10, 130], ['Transport', 142, 40], ['Internet', 186, 40], ['Accès réseau', 230, 84]].map(function (c) { return box(470, c[1], 230, c[2], '#fff', c[0], 15); }).join('')), legende: 'À gauche les 7 couches OSI, à droite leurs équivalents dans le modèle TCP/IP.',
+  photo: 'Photo : baie de brassage avec switchs et câbles RJ45',
+  lecture: ['Quand vous ouvrez une page web, des dizaines d’équipements différents collaborent : votre carte Wi-Fi, la box, les routeurs de votre opérateur, ceux d’Internet, le serveur. Ils ont été fabriqués par des entreprises différentes, à des époques différentes. Ils se comprennent parce que chacun respecte des règles communes, rangées par couches.',
+    'L’analogie du courrier aide à fixer les idées. Vous écrivez une lettre (l’application), vous la mettez dans une enveloppe avec l’adresse (le réseau), la poste la place dans un sac à destination d’un centre de tri (la liaison), et un camion transporte le sac (le physique). À chaque étape, on ajoute un emballage sans ouvrir le précédent. À l’arrivée, on déballe dans l’ordre inverse.',
+    'Le modèle OSI à 7 couches est un modèle de référence, très utile pour raisonner et pour dialoguer entre techniciens (« c’est un problème de couche 2 »). Le modèle TCP/IP à 4 couches est celui qui est réellement implémenté. Vous devez connaître les deux et savoir passer de l’un à l’autre.',
+    'Le vrai intérêt du modèle en couches se révèle en panne. Plutôt que de tout tester au hasard, on part du bas : le lien, l’adresse, la passerelle, le nom, le service. La première couche qui échoue désigne le coupable. Cette méthode fait gagner un temps considérable.'] },
+sql: { figure: svg(720, 200, box(20, 20, 280, 40, '#FFD23F', 'ELEVE', 16) + box(20, 60, 280, 34, '#fff', 'id · nom · prenom · #classe_id', 14) + box(420, 20, 280, 40, '#7CF2C0', 'CLASSE', 16) + box(420, 60, 280, 34, '#fff', 'id · libelle · annee', 14) + arrow(300, 77, 418, 77) + '<text x="360" y="130" text-anchor="middle" font-family="IBM Plex Mono,monospace" font-weight="600" font-size="14">classe_id → id</text><text x="20" y="180" font-family="IBM Plex Mono,monospace" font-weight="600" font-size="15">SELECT e.nom, c.libelle FROM eleve e JOIN classe c ON e.classe_id = c.id;</text>'), legende: 'La clé étrangère classe_id relie chaque élève à sa classe. La jointure suit ce lien.',
+  photo: 'Photo : tableau de bord ou écran d’application de vie scolaire',
+  lecture: ['Un tableur suffit pour une classe. Pour un établissement entier, avec des milliers d’élèves, des centaines de devoirs et des notes qui arrivent en continu, il faut une base de données. Elle garantit que les données restent cohérentes, que plusieurs personnes peuvent écrire en même temps et qu’on retrouve n’importe quelle information en une fraction de seconde.',
+    'L’idée centrale du modèle relationnel est de ne jamais recopier une information. Le libellé d’une classe n’est écrit qu’une fois, dans la table des classes ; chaque élève ne contient que le numéro de sa classe. Si la classe change de nom, on ne modifie qu’une ligne. Les jointures reconstruisent l’information complète au moment de la requête.',
+    'SQL est un langage déclaratif : on décrit ce qu’on veut obtenir, pas comment le calculer. C’est la base de données qui choisit la meilleure façon d’y arriver. Cela rend les requêtes courtes et lisibles, presque comme des phrases, mais demande de bien comprendre l’ordre logique : FROM et JOIN d’abord, puis WHERE, GROUP BY, HAVING, SELECT et enfin ORDER BY.',
+    'Enfin, une base contient souvent des données personnelles. Le RGPD impose de les protéger : droits d’accès limités, requêtes préparées contre les injections, sauvegardes, et suppression des données qui ne sont plus nécessaires.'] },
+python: { figure: svg(720, 250, box(260, 10, 200, 44, '#F6F5F1', 'note = saisie', 16) + arrow(360, 54, 360, 84) + '<polygon points="360,86 470,126 360,166 250,126" fill="#FFD23F" ' + K + '/><text x="360" y="131" text-anchor="middle" font-family="Archivo,sans-serif" font-weight="800" font-size="16">note ≥ 10 ?</text>' + arrow(470, 126, 560, 126) + box(560, 104, 140, 44, '#7CF2C0', 'Admis', 16) + arrow(250, 126, 160, 126) + box(20, 104, 140, 44, '#FF6FB5', 'À revoir', 16) + '<text x="505" y="115" font-family="Archivo" font-weight="800" font-size="14">oui</text><text x="190" y="115" font-family="Archivo" font-weight="800" font-size="14">non</text><text x="20" y="220" font-family="IBM Plex Mono,monospace" font-weight="600" font-size="15">if note >= 10: print("Admis")  else: print("À revoir")</text>'), legende: 'Une condition est un embranchement : le programme suit une seule des deux branches.',
+  photo: 'Photo : élèves en séance de programmation',
+  lecture: ['Programmer, ce n’est pas taper du code : c’est découper un problème en étapes assez simples pour qu’une machine les exécute sans réfléchir. Le langage n’est qu’un moyen d’écrire ces étapes. Python est choisi dans l’enseignement parce que sa syntaxe gêne le moins possible cette réflexion.',
+    'Trois structures suffisent à écrire presque tous les programmes : la séquence (une instruction après l’autre), la condition (faire ceci ou cela) et la répétition (recommencer). Le reste, fonctions, listes, fichiers, sert à organiser ces trois briques pour que le programme reste lisible quand il grandit.',
+    'Un bon réflexe est d’écrire le programme en français avant de l’écrire en Python : « demander la note ; si elle est au moins 10, afficher admis ; sinon, afficher à revoir ». La traduction devient alors presque mécanique, et les erreurs de logique apparaissent avant la première ligne de code.',
+    'Enfin, testez tout le temps. Une fonction de trois lignes accompagnée de deux assert est plus précieuse qu’une fonction de trente lignes que personne n’ose modifier. C’est ce que font les développeurs professionnels, et c’est ce que vérifient les tests automatiques de l’IDE.'] },
+web: { figure: svg(720, 200, box(20, 60, 180, 70, '#C4B5FD', 'Navigateur', 18) + box(520, 60, 180, 70, '#7CF2C0', 'Serveur Apache', 18) + arrow(200, 80, 518, 80) + arrow(520, 115, 202, 115) + '<text x="360" y="70" text-anchor="middle" font-family="IBM Plex Mono,monospace" font-weight="600" font-size="14">GET /index.html</text><text x="360" y="140" text-anchor="middle" font-family="IBM Plex Mono,monospace" font-weight="600" font-size="14">200 OK + HTML</text><text x="20" y="185" font-family="Archivo,sans-serif" font-weight="700" font-size="14">Le navigateur affiche le HTML, applique le CSS, exécute le JavaScript.</text>'), legende: 'Un échange HTTP : une requête du client, une réponse du serveur.',
+  photo: 'Photo : outils de développement du navigateur ouverts sur une page',
+  lecture: ['Le Web repose sur une idée simple inventée au CERN en 1989 : des documents reliés par des liens, que l’on demande à un serveur avec un protocole commun. Trente ans plus tard, la même idée fait fonctionner les réseaux sociaux, les ENT et les applications de banque.',
+    'Ouvrez les outils de développement de votre navigateur (F12), onglet Réseau, et rechargez une page : vous verrez des dizaines de requêtes, chacune avec sa méthode, son code et sa durée. C’est le meilleur moyen de comprendre HTTP, et c’est l’outil numéro un d’un développeur web pour dépanner.',
+    'Séparer la structure (HTML) de la présentation (CSS) n’est pas un caprice : le même contenu peut ainsi s’afficher sur un téléphone, un grand écran ou être lu à voix haute par un lecteur d’écran pour une personne malvoyante. Une page bien structurée est aussi mieux référencée par les moteurs de recherche.',
+    'Côté serveur, héberger un site, c’est installer un logiciel qui écoute sur le port 80 ou 443 et renvoie des fichiers. Apache et Nginx font tourner une grande partie des sites du monde. Savoir les installer, les configurer et lire leurs journaux fait partie du socle du technicien.'] },
+crypto: { figure: svg(720, 210, box(20, 70, 150, 60, '#fff', 'Message', 18) + arrow(170, 100, 268, 100) + box(270, 60, 180, 80, '#FFD23F', 'Chiffrement', 18) + arrow(450, 100, 548, 100) + box(550, 70, 150, 60, '#13233A', '<tspan fill="#fff">x9#Qa…</tspan>', 18) + '<text x="360" y="40" text-anchor="middle" font-family="Archivo,sans-serif" font-weight="800" font-size="15">clé publique d’Alice</text><text x="360" y="185" text-anchor="middle" font-family="Archivo,sans-serif" font-weight="800" font-size="15">Seule la clé privée d’Alice peut déchiffrer</text>'), legende: 'Chiffrement asymétrique : on chiffre avec la clé publique du destinataire.',
+  photo: 'Photo : cadenas HTTPS dans la barre d’adresse ou clé de sécurité matérielle',
+  lecture: ['La cryptographie a longtemps été réservée aux militaires et aux diplomates. Aujourd’hui, elle protège chaque connexion HTTPS, chaque message sur une messagerie moderne, chaque paiement par carte. Vous l’utilisez des centaines de fois par jour sans le savoir.',
+    'Il faut d’abord bien distinguer les outils. Le hachage ne cache rien : il produit une empreinte qui permet de vérifier qu’un fichier ou un mot de passe n’a pas changé. Le chiffrement, lui, rend un message illisible sans la clé, et il est réversible. Confondre les deux est l’erreur la plus fréquente, en cours comme en entreprise.',
+    'Le chiffrement asymétrique a résolu un problème vieux de plusieurs siècles : comment se mettre d’accord sur une clé secrète sans jamais se rencontrer ? La réponse, publiée dans les années 1970, est d’utiliser deux clés liées mathématiquement. On peut diffuser l’une à tout le monde sans jamais compromettre l’autre.',
+    'En pratique, un technicien ne réinvente jamais un algorithme. Il choisit des outils éprouvés, suit les recommandations de l’ANSSI, active HTTPS partout, remplace les mots de passe SSH par des clés et vérifie que l’application stocke les mots de passe avec Argon2 ou bcrypt. La sécurité vient d’abord de la rigueur.'] }
+});
+})();

portail/public/js/contenus-lot-10.js

@@ -0,0 +1,227 @@
+// Cours complets · lot 10 : algorithmique et structures, développement web back-end, JavaScript et TypeScript, langage C
+(function () {
+var reg = function (c) {
+  (window.CONTENUS_PRO = window.CONTENUS_PRO || []).unshift(c.cours);
+  (window.CONTENUS_PLUS = window.CONTENUS_PLUS || {})[c.cours.id] = c.plus;
+  (window.CONTENUS_EXEMPLES = window.CONTENUS_EXEMPLES || {})[c.cours.id] = c.exemples;
+  (window.CONTENUS_SCHEMAS = window.CONTENUS_SCHEMAS || {})[c.cours.id] = { termes: c.termes, figs: [] };
+};
+
+reg({
+cours: { id: 'algo', match: /Tris|dichotomique|complexité|Complexité et notation O|Récursivité|Piles, files|listes chaînées|Graphes : parcours|Dijkstra|Listes, tuples|Fonctions, portée|Tests : assert/i,
+  titre: 'Algorithmique : complexité, tris, récursivité, structures de données et graphes', duree: '',
+  niveau: 'NSI Première et Terminale · BTS SIO SLAM · BUT Informatique · classes préparatoires',
+  prerequis: ['Python : variables, boucles, fonctions'],
+  competences: ['NSI · Algorithmique et structures de données', 'BTS SIO SLAM · Concevoir une solution applicative', 'BUT Info · Compétence « Optimiser »'],
+  intro: 'Deux programmes corrects peuvent avoir des comportements radicalement différents : l’un trie un million de lignes en une seconde, l’autre en plusieurs heures. L’algorithmique donne les outils pour choisir la bonne méthode et la bonne structure de données, et pour prévoir comment un programme se comportera quand les données grandiront. Ce module couvre la complexité, les tris et la recherche, la récursivité, les structures linéaires et les graphes, avec leurs applications concrètes en réseau et en informatique de gestion.',
+  cm: [
+    { t: 'Mesurer un algorithme : la complexité', d: '', html: 'La <b>complexité en temps</b> compte le nombre d’opérations élémentaires en fonction de la taille n des données, dans le pire cas. On ne garde que l’ordre de grandeur, noté <b>O</b> : une boucle simple est en <b>O(n)</b>, deux boucles imbriquées en <b>O(n²)</b>, une recherche qui divise l’espace par deux à chaque étape en <b>O(log n)</b>. Pour n = 1 000 000, O(n log n) représente environ 20 millions d’opérations, O(n²) mille milliards : la différence entre une seconde et plusieurs jours. La <b>complexité en espace</b> mesure la mémoire utilisée.', table: [['Complexité', 'Exemple', 'n = 10⁶'], ['O(1)', 'accès à un élément d’un tableau, d’un dictionnaire', '1'], ['O(log n)', 'recherche dichotomique', '≈ 20'], ['O(n)', 'parcours, recherche linéaire', '10⁶'], ['O(n log n)', 'tri fusion, tri de Python', '≈ 2 × 10⁷'], ['O(n²)', 'tri par sélection, double boucle', '10¹²'], ['O(2ⁿ)', 'tester tous les sous-ensembles', 'inenvisageable']] },
+    { t: 'Recherche et tris', d: '', html: 'La <b>recherche dichotomique</b> dans un tableau <b>trié</b> compare la valeur cherchée au milieu, puis continue dans la moitié qui convient : O(log n). Les tris simples, par <b>sélection</b> et par <b>insertion</b>, sont en O(n²) ; le tri par insertion est très efficace sur des données presque triées. Le <b>tri fusion</b> découpe le tableau en deux, trie chaque moitié récursivement et fusionne : O(n log n) garanti. Le <b>tri rapide</b> est en moyenne en O(n log n). En pratique, on utilise le tri de la bibliothèque (<code>sorted</code>, Timsort), mais comprendre ces algorithmes permet de raisonner sur les coûts et de réussir les épreuves.', exemple: 'def dichotomie(t, x):\n    g, d = 0, len(t) - 1\n    while g <= d:\n        m = (g + d) // 2\n        if t[m] == x:\n            return m\n        if t[m] < x:\n            g = m + 1\n        else:\n            d = m - 1\n    return -1' },
+    { t: 'Récursivité', d: '', html: 'Une fonction <b>récursive</b> s’appelle elle-même sur un problème plus petit, jusqu’à un <b>cas de base</b> qui s’arrête. Elle exprime naturellement les problèmes à structure récursive : parcours d’arborescence de fichiers, tri fusion, calculs sur des arbres. Chaque appel occupe une place sur la <b>pile d’appels</b> : sans cas de base atteint, on obtient un dépassement (RecursionError en Python, limite par défaut de 1 000 appels). Certaines récursions recalculent plusieurs fois les mêmes valeurs (Fibonacci naïf en O(2ⁿ)) : la <b>mémoïsation</b> (<code>functools.cache</code>) ou une version itérative corrige le problème.' },
+    { t: 'Structures de données linéaires', d: '', html: 'Une <b>pile</b> (LIFO, dernier entré premier sorti) sert à l’historique d’annulation, à la pile d’appels, à la vérification des parenthèses. Une <b>file</b> (FIFO) sert aux files d’attente : impressions, requêtes, mains levées dans l’ordre d’arrivée. En Python, une liste fait une bonne pile (<code>append</code>, <code>pop</code>), mais une mauvaise file (<code>pop(0)</code> en O(n)) : on utilise <code>collections.deque</code>. Une <b>liste chaînée</b> relie des maillons par des références : insertion en tête en O(1), accès au k-ième élément en O(k). Le <b>dictionnaire</b> (table de hachage) donne un accès moyen en O(1) par clé : c’est souvent la structure qui transforme un O(n²) en O(n).' },
+    { t: 'Graphes et parcours', d: '', html: 'Un <b>graphe</b> est un ensemble de sommets reliés par des arêtes, éventuellement orientées et pondérées : routeurs et liens, pages web, dépendances entre tâches. On le représente par une <b>matrice d’adjacence</b> ou, plus économiquement, par des <b>listes d’adjacence</b> (un dictionnaire de voisins). Le <b>parcours en largeur</b> (BFS, avec une file) visite par distance croissante et trouve le plus court chemin en nombre d’arêtes ; le <b>parcours en profondeur</b> (DFS, avec une pile ou la récursivité) sert à détecter des cycles ou des composantes connexes.' },
+    { t: 'Plus courts chemins : Dijkstra', d: '', html: 'L’algorithme de <b>Dijkstra</b> calcule les plus courts chemins depuis un sommet dans un graphe à poids positifs : il sélectionne à chaque étape le sommet non traité le plus proche et met à jour les distances de ses voisins. Avec une file de priorité (<code>heapq</code>), il s’exécute en O((V + E) log V). C’est exactement ce que fait chaque routeur <b>OSPF</b> pour construire sa table de routage à partir de la carte du réseau, avec un coût par lien inversement proportionnel au débit.', exemple: 'import heapq\ndef dijkstra(g, s):\n    dist = {s: 0}\n    file = [(0, s)]\n    while file:\n        d, u = heapq.heappop(file)\n        if d > dist[u]:\n            continue\n        for v, w in g[u].items():\n            if d + w < dist.get(v, float("inf")):\n                dist[v] = d + w\n                heapq.heappush(file, (d + w, v))\n    return dist' }
+  ],
+  synthese: ['Complexité O : O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ)', 'Dichotomie sur tableau trié en O(log n) ; tri fusion en O(n log n)', 'Récursivité : cas de base, pile d’appels, mémoïsation', 'Pile LIFO, file FIFO avec deque, dictionnaire en O(1) moyen', 'Graphes : listes d’adjacence ; BFS et DFS', 'Dijkstra et OSPF'],
+  qcm: [
+    ['Complexité de la recherche dichotomique ?', ['O(1)', 'O(log n)', 'O(n)', 'O(n²)'], 1, 'On divise par deux à chaque étape.'],
+    ['Condition pour utiliser la dichotomie ?', ['Tableau trié', 'Tableau court', 'Nombres entiers', 'Aucune'], 0, 'Sinon on ne sait pas quelle moitié choisir.'],
+    ['Quelle structure pour une file d’attente en Python ?', ['list avec pop(0)', 'collections.deque', 'set', 'tuple'], 1, 'popleft en O(1).'],
+    ['Que manque-t-il à une récursion qui provoque RecursionError ?', ['Un return', 'Un cas de base atteint', 'Une boucle', 'Un print'], 1, 'Elle ne s’arrête jamais.'],
+    ['Quel parcours trouve le plus court chemin en nombre d’arêtes ?', ['DFS', 'BFS', 'Tri fusion', 'Dichotomie'], 1, 'Par distance croissante.'],
+    ['Quel protocole de routage utilise Dijkstra ?', ['RIP', 'OSPF', 'DHCP', 'ARP'], 1, 'État de liens.'],
+    ['Deux boucles imbriquées sur n éléments :', ['O(n)', 'O(n²)', 'O(log n)', 'O(2n)'], 1, 'n × n.']
+  ],
+  td: [
+    { n: 'Échauffement', c: 'Donner la complexité de : parcourir une liste ; vérifier si deux listes ont un élément commun avec deux boucles ; même chose en transformant la seconde en ensemble.', r: 'O(n) · O(n × m) · O(n + m)' },
+    { n: 'Application', c: 'Écrire un tri par insertion, puis compter le nombre de comparaisons sur une liste déjà triée et sur une liste triée à l’envers de 1 000 éléments.', r: 'Déjà triée : environ n comparaisons (O(n)) · à l’envers : environ n²/2 = 500 000 (O(n²)).' },
+    { n: 'Application', c: 'Vérifier le bon parenthésage d’une expression avec une pile.', r: 'Empiler chaque ouvrante ; pour chaque fermante, la pile ne doit pas être vide et son sommet doit correspondre ; à la fin, la pile doit être vide.' },
+    { n: 'Approfondissement', c: 'Appliquer Dijkstra à la main sur un réseau de cinq routeurs fourni, puis en déduire la table de routage du routeur A.', r: 'Tableau des distances étape par étape ; la table associe à chaque destination le premier saut du plus court chemin.' }
+  ],
+  tp: { type: 'IDE Python', url: 'apercu-ide.html', desc: 'Exercices avec tests et mesure du temps d’exécution.', etapes: ['Dichotomie et tests', 'Tri fusion', 'Comparaison des temps selon n', 'File des mains levées avec deque', 'BFS sur un plan de salles', 'Dijkstra sur un réseau de routeurs'] },
+  plusLoin: [['France-IOI · parcours algorithmique', 'https://www.france-ioi.org/'], ['HackerRank · Data Structures et Algorithms', 'https://www.hackerrank.com/domains/algorithms'], ['VisuAlgo (visualisation)', 'https://visualgo.net/fr']] },
+plus: { cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Le calcul des doublons dans l’export des 12 000 élèves de l’académie prend 40 minutes. Rendre le traitement quasi instantané.', etapes: [
+    ['Lire le code', 'for a in eleves:\n    for b in eleves:\n        if a is not b and a["ine"] == b["ine"]: doublons.append(a)\n→ Deux boucles imbriquées : 144 millions de comparaisons, O(n²).'],
+    ['Choisir la structure', '→ Un dictionnaire (ou un Counter) compte les occurrences de chaque identifiant en un seul parcours.'],
+    ['Réécrire', 'from collections import Counter\nc = Counter(e["ine"] for e in eleves)\ndoublons = [e for e in eleves if c[e["ine"]] > 1]\n→ Deux parcours : O(n).'],
+    ['Mesurer', 'Temps : 40 min → 0,02 s\n→ Même résultat vérifié par un test sur un petit jeu de données connu.'],
+    ['Retenir', '→ Devant une double boucle de recherche, se demander quelle clé permettrait un accès direct par dictionnaire ou ensemble.']
+  ] },
+  erreurs: ['Dichotomie sur une liste non triée', 'Oublier le cas de base', 'list.pop(0) pour une file', 'Double boucle là où un dictionnaire suffit', 'Recalculer sans mémoïsation', 'Dijkstra avec des poids négatifs'],
+  memo: [['Outil', 'Usage'], ['len, in sur set/dict', 'O(1) en moyenne'], ['sorted(t, key=…)', 'tri O(n log n)'], ['bisect', 'dichotomie de la bibliothèque'], ['collections.deque', 'file'], ['collections.Counter', 'compter'], ['heapq', 'file de priorité'], ['functools.cache', 'mémoïsation'], ['timeit', 'mesurer le temps'], ['assert f(x) == y', 'tests simples'], ['sys.setrecursionlimit', 'limite de récursion (avec prudence)']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Déterminer la complexité de trois fonctions. (4 pts)', 'Écrire la recherche dichotomique et ses tests. (4 pts)', 'Écrire une fonction récursive et justifier sa terminaison. (4 pts)', 'Implémenter une file avec deque. (3 pts)', 'Appliquer Dijkstra à la main. (5 pts)'], r: ['O(n), O(n²), O(log n)', 'voir cours', 'cas de base, taille décroissante', 'append / popleft', 'tableau des distances'] },
+  prof: { deroule: [['Ouverture', 'Chronométrer une double boucle puis un dictionnaire'], ['Cours', 'Complexité'], ['Pratique', 'Tris et dichotomie'], ['Cours', 'Récursivité et structures'], ['Pratique', 'Graphes et Dijkstra'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : visualisations VisuAlgo. Élèves avancés : HackerRank Medium, A*.', eval: 'Tests IDE, sujet type.' } },
+exemples: [
+ ['Comparer deux complexités', 'Justifier un choix.', 'python3 -m timeit -s "l=list(range(10**5)); s=set(l)" "99999 in l"\npython3 -m timeit -s "l=list(range(10**5)); s=set(l)" "99999 in s"', '500 loops, best of 5: 612 usec per loop\n5000000 loops, best of 5: 42.1 nsec per loop', 'La recherche dans un ensemble est environ 15 000 fois plus rapide que dans une liste.'],
+ ['Dichotomie de la bibliothèque', 'Retrouver un seuil de note.', 'import bisect; bisect.bisect_left([8, 10, 12, 14, 16], 13)', '3', 'Position d’insertion de 13 dans la liste triée, en O(log n).'],
+ ['Limite de récursion', 'Fonction récursive sur une longue liste.', 'def somme(l): return 0 if not l else l[0] + somme(l[1:])\nsomme(list(range(5000)))', 'RecursionError: maximum recursion depth exceeded', 'Au-delà de 1 000 appels : on écrit une version itérative, plus adaptée ici.'],
+ ['Mémoïsation', 'Fibonacci lent.', 'from functools import cache\n@cache\ndef fib(n): return n if n < 2 else fib(n-1) + fib(n-2)\nfib(200)', '280571172992510140037611932413038677189525', 'Instantané grâce au cache ; la version naïve ne terminerait pas.'],
+ ['File des mains levées', 'Fonction Lever la main.', 'from collections import deque\nq = deque(["Nora", "Yanis"]); q.append("Léa"); q.popleft(), list(q)', "('Nora', ['Yanis', 'Léa'])", 'Premier arrivé, premier servi, en O(1).'],
+ ['Plus courts chemins', 'Réseau de quatre routeurs.', 'g = {"A":{"B":10,"C":1},"B":{"D":1},"C":{"B":1,"D":20},"D":{}}\ndijkstra(g, "A")', "{'A': 0, 'C': 1, 'B': 2, 'D': 3}", 'Le chemin vers D passe par C puis B (coût 3) plutôt que par le lien direct C–D (21).']
+],
+termes: ['complexité', 'O(n)', 'O(log n)', 'O(n²)', 'O(n log n)', 'recherche dichotomique', 'tri par insertion', 'tri fusion', 'récursivité', 'cas de base', 'pile d’appels', 'mémoïsation', 'pile', 'file', 'deque', 'liste chaînée', 'dictionnaire', 'graphe', 'BFS', 'DFS', 'Dijkstra', 'heapq']
+});
+
+reg({
+cours: { id: 'backend', match: /Laravel|MVC|API REST|OpenAPI|Authentification : sessions|OAuth|PHP : bases|Framework back|Déployer une application web|Sécurité web|CSP|CORS|Tests : unitaires, intégration/i,
+  titre: 'Développement web back-end : MVC avec Laravel, API REST, authentification et sécurité', duree: '',
+  niveau: 'BTS SIO SLAM · BUT Informatique · licence pro · Master',
+  prerequis: ['Le Web : HTTP et HTML', 'SQL', 'Git'],
+  competences: ['BTS SIO SLAM · Bloc 2 · Concevoir et développer une solution applicative', 'BTS SIO · Bloc 3 · Cybersécurité des services', 'BUT Info · Réaliser et déployer'],
+  intro: 'Une application web professionnelle se compose d’une interface, d’une logique métier, d’une base de données et d’une API, le tout sécurisé et testé. Les frameworks comme Laravel, sur lequel est construit Syllabus, apportent une organisation éprouvée et des protections intégrées. Ce module présente l’architecture MVC, le routage, l’ORM, la conception d’une API REST, l’authentification, les protections contre les failles courantes et le déploiement.',
+  cm: [
+    { t: 'Architecture MVC', d: '', html: 'Le motif <b>Modèle-Vue-Contrôleur</b> sépare les responsabilités. Le <b>modèle</b> représente les données et les règles métier (un élève, une classe, un devoir). La <b>vue</b> présente les données (templates Blade). Le <b>contrôleur</b> reçoit la requête, appelle le modèle et choisit la vue ou la réponse. Le <b>routeur</b> associe chaque URL et méthode HTTP à une action. Cette séparation rend le code testable et permet à plusieurs développeurs de travailler en parallèle.', exemple: '// routes/web.php\nRoute::middleware("auth")->group(function () {\n    Route::get("/classes/{classe}", [ClasseController::class, "show"])->name("classes.show");\n});\n\n// app/Http/Controllers/ClasseController.php\npublic function show(Classe $classe) {\n    $this->authorize("view", $classe);\n    return view("classes.show", [\n        "classe" => $classe->load("eleves"),\n    ]);\n}' },
+    { t: 'Modèles, ORM et migrations', d: '', html: 'L’<b>ORM</b> Eloquent associe chaque table à une classe : <code>Eleve::where("classe_id", 3)->orderBy("nom")->get()</code> produit une requête SQL <b>préparée</b>. Les <b>relations</b> (hasMany, belongsTo, belongsToMany) décrivent les clés étrangères. Les <b>migrations</b> versionnent le schéma de la base avec le code : chaque modification est un fichier, appliqué dans le même ordre partout. Piège de performance classique : le problème <b>N+1</b>, une requête par élément d’une liste, évité par le chargement anticipé (<code>with("eleves")</code>).' },
+    { t: 'Concevoir une API REST', d: '', html: 'Une API <b>REST</b> expose des <b>ressources</b> identifiées par des URL et manipulées par les méthodes HTTP : <code>GET /api/devoirs</code> liste, <code>POST /api/devoirs</code> crée, <code>GET /api/devoirs/12</code> lit, <code>PUT</code> ou <code>PATCH</code> modifie, <code>DELETE</code> supprime. Les réponses sont en <b>JSON</b> avec des codes cohérents : 200, 201 Created, 204 No Content, 400 et 422 pour une requête invalide, 401 non authentifié, 403 interdit, 404 introuvable. On <b>versionne</b> l’API (/api/v1), on pagine les listes, et on la documente avec <b>OpenAPI</b>, qui génère une documentation interactive et des clients.' },
+    { t: 'Authentification et autorisation', d: '', html: 'L’<b>authentification</b> établit qui est l’utilisateur ; l’<b>autorisation</b> décide de ce qu’il peut faire. Pour une application web, une <b>session</b> côté serveur, identifiée par un cookie <code>HttpOnly</code>, <code>Secure</code> et <code>SameSite</code>, reste la solution la plus sûre. Pour une API consommée par d’autres applications, on utilise des <b>jetons</b> (tokens d’API, Laravel Sanctum) ou <b>OAuth 2</b> / <b>OpenID Connect</b> pour déléguer l’authentification à un fournisseur d’identité (ENT, EduConnect). Les mots de passe sont hachés avec bcrypt ou Argon2. L’autorisation se centralise dans des <b>politiques</b> (policies) : un professeur ne voit que ses classes.' },
+    { t: 'Sécurité : les failles courantes', d: '', html: 'L’<b>OWASP Top 10</b> recense les failles les plus fréquentes. <b>Contrôle d’accès défaillant</b> : changer un identifiant dans l’URL donne accès aux données d’un autre (IDOR) ; on vérifie l’autorisation à chaque action. <b>Injection</b> : requêtes préparées systématiques. <b>XSS</b> : Blade échappe automatiquement <code>{{ }}</code> ; <code>{!! !!}</code> ne s’utilise que sur du contenu maîtrisé. <b>CSRF</b> : un jeton dans chaque formulaire (<code>@csrf</code>). <b>Assignation de masse</b> : déclarer les champs modifiables (<code>$fillable</code>). À quoi s’ajoutent les <b>en-têtes</b> : Content-Security-Policy contre l’injection de scripts, CORS limité aux origines autorisées, HSTS.', attention: 'Le mode débogage (APP_DEBUG=true) en production affiche les traces d’erreur, les variables d’environnement et parfois les mots de passe de la base. Il doit être désactivé, et le fichier .env ne doit jamais être accessible par le web ni versionné.' },
+    { t: 'Tester et déployer', d: '', html: 'Les <b>tests unitaires</b> vérifient une classe isolée, les <b>tests de fonctionnalité</b> envoient de vraies requêtes à l’application (<code>$this->actingAs($prof)->get("/classes/3")->assertOk()</code>), les tests de <b>bout en bout</b> pilotent un navigateur. Le déploiement suit toujours les mêmes étapes, automatisées par la CI : récupération du code, <code>composer install --no-dev</code>, migrations, mise en cache de la configuration et des routes, redémarrage des workers de file d’attente, derrière Nginx et PHP-FPM, avec un retour arrière possible.' }
+  ],
+  synthese: ['MVC : modèle, vue, contrôleur, routeur', 'ORM et migrations ; éviter le N+1 avec with()', 'REST : ressources, méthodes, codes HTTP, JSON, versionnement, OpenAPI', 'Session sécurisée ou jetons ; OAuth 2 / OIDC ; policies pour l’autorisation', 'OWASP : contrôle d’accès, injection, XSS, CSRF, assignation de masse ; en-têtes', 'APP_DEBUG=false, .env protégé ; tests et déploiement automatisés'],
+  qcm: [
+    ['Dans MVC, qui reçoit la requête et choisit la réponse ?', ['Le modèle', 'Le contrôleur', 'La vue', 'La base'], 1, 'Il orchestre.'],
+    ['Quelle méthode pour créer une ressource en REST ?', ['GET', 'POST', 'DELETE', 'HEAD'], 1, 'Réponse 201.'],
+    ['Code HTTP pour « authentifié mais pas autorisé » ?', ['401', '403', '404', '500'], 1, '401 = non authentifié.'],
+    ['Qu’est-ce que le problème N+1 ?', ['Une faille', 'Une requête SQL par élément d’une liste', 'Un code HTTP', 'Une erreur de migration'], 1, 'Chargement anticipé.'],
+    ['Protection contre le CSRF ?', ['Un jeton dans chaque formulaire', 'HTTPS seul', 'Un captcha', 'Le hachage'], 0, '@csrf.'],
+    ['Pourquoi désactiver APP_DEBUG en production ?', ['Performance', 'Il expose des informations sensibles', 'Obligation légale', 'Pour le cache'], 1, 'Traces, variables, secrets.']
+  ],
+  td: [
+    { n: 'Application', c: 'Concevoir les routes REST de la ressource « devoirs » d’une classe, avec les codes de réponse attendus.', r: 'GET /api/v1/classes/{c}/devoirs 200 · POST 201 · GET /devoirs/{d} 200/404 · PATCH 200/422 · DELETE 204 · 401 sans jeton, 403 si pas professeur de la classe.' },
+    { n: 'Application', c: 'Corriger la faille : « public function show($id) { return Eleve::find($id); } ».', r: 'Liaison de modèle + autorisation : show(Eleve $eleve) { $this->authorize("view", $eleve); return $eleve; } avec une policy vérifiant que l’élève appartient à une classe du professeur.' },
+    { n: 'Approfondissement', c: 'Écrire un test de fonctionnalité qui vérifie qu’un professeur ne peut pas voir la fiche d’un élève d’une autre classe.', r: '$prof = User::factory()->prof()->create(); $eleve = Eleve::factory()->create(); $this->actingAs($prof)->get(route("eleves.show", $eleve))->assertForbidden();' }
+  ],
+  tp: { type: 'IDE', url: 'apercu-ide.html', desc: 'Mini-application Laravel de gestion de devoirs.', etapes: ['Migration et modèle', 'Contrôleur et vues', 'API REST', 'Policy d’autorisation', 'Tests de fonctionnalité', 'Déploiement par CI'] },
+  plusLoin: [['Documentation Laravel', 'https://laravel.com/docs'], ['OWASP Top 10', 'https://owasp.org/Top10/fr/'], ['OpenAPI Specification', 'https://spec.openapis.org/oas/latest.html'], ['ANSSI · Recommandations pour la mise en œuvre d’un site web', 'https://cyber.gouv.fr/']] },
+plus: { cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Un élève signale qu’en modifiant le numéro dans l’adresse de sa page de résultats, il voit les notes d’un camarade.', etapes: [
+    ['Reproduire', 'Connecté comme élève 1204 : GET /resultats/1205 → 200 OK, notes de l’élève 1205.\n→ Faille de contrôle d’accès (IDOR).'],
+    ['Lire le code', 'public function show($id) { return view("resultats", ["eleve" => Eleve::findOrFail($id)]); }\n→ Aucune vérification que l’élève connecté est celui demandé.'],
+    ['Corriger', 'Policy EleveResultatsPolicy : un élève voit ses résultats, un professeur ceux de ses classes, la vie scolaire tout l’établissement.\npublic function show(Eleve $eleve) { $this->authorize("voirResultats", $eleve); … }\n→ Réponse 403 pour un autre élève.'],
+    ['Tester et vérifier les autres routes', '→ Test automatisé ajouté ; revue de toutes les routes prenant un identifiant : deux autres corrigées (exports, devoirs rendus).'],
+    ['Traiter les conséquences', '→ Analyse des journaux d’accès : consultations anormales par deux comptes. Information du DPO, qui évalue la notification à la CNIL et l’information des familles concernées.']
+  ] },
+  erreurs: ['Contrôler l’accès seulement dans l’interface', 'Requêtes SQL construites par concaténation', 'Utiliser {!! !!} sur une saisie utilisateur', 'APP_DEBUG=true en production', 'Pas de tests d’autorisation', 'Codes HTTP incohérents dans l’API'],
+  memo: [['Commande / élément', 'Usage'], ['php artisan route:list', 'lister les routes'], ['php artisan make:model -mcr Devoir', 'modèle, migration, contrôleur'], ['php artisan migrate', 'appliquer les migrations'], ['php artisan make:policy', 'politique d’autorisation'], ['$this->authorize()', 'vérifier un droit'], ['with("relation")', 'éviter le N+1'], ['@csrf', 'jeton de formulaire'], ['php artisan test', 'lancer les tests'], ['php artisan config:cache route:cache', 'optimiser en production'], ['curl -H "Authorization: Bearer …" /api/v1/…', 'tester une API']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Expliquer MVC sur un exemple. (3 pts)', 'Concevoir une API REST. (5 pts)', 'Écrire un contrôleur avec autorisation. (5 pts)', 'Identifier et corriger trois failles dans un code fourni. (5 pts)', 'Décrire un déploiement. (2 pts)'], r: ['voir cours', 'ressources et codes', 'authorize + policy', 'IDOR, XSS, injection', 'composer, migrate, cache'] },
+  prof: { deroule: [['Ouverture', 'Démonstration d’une faille IDOR sur une application de lab'], ['Cours', 'MVC et routage'], ['Pratique', 'Modèle et contrôleur'], ['Cours', 'API et sécurité'], ['Pratique', 'Policies et tests'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : squelette fourni. Élèves avancés : OAuth 2, files d’attente, OpenAPI.', eval: 'Application testée, sujet type.' } },
+exemples: [
+ ['Lister les routes', 'Audit d’une application.', 'php artisan route:list --path=api', 'GET|HEAD  api/v1/devoirs ...... devoirs.index › DevoirController@index\nPOST      api/v1/devoirs ...... devoirs.store › DevoirController@store\nDELETE    api/v1/devoirs/{devoir}  devoirs.destroy', 'On vérifie que chaque route sensible a un middleware d’authentification.'],
+ ['Détecter un N+1', 'Page lente.', 'DB::enableQueryLog(); $c = Classe::all(); foreach ($c as $x) $x->eleves->count(); count(DB::getQueryLog())', '31', '31 requêtes pour 30 classes. Avec Classe::withCount("eleves")->get(), une seule.'],
+ ['Tester une API', 'Création d’un devoir.', 'curl -s -X POST https://syllabus.local/api/v1/devoirs -H "Authorization: Bearer $T" -H "Content-Type: application/json" -d \'{"titre":"DM 3"}\'', '{"message":"The date limite field is required.","errors":{"date_limite":["…"]}}  (HTTP 422)', 'La validation renvoie 422 avec le détail des champs manquants.'],
+ ['Test d’autorisation', 'Non-régression.', 'php artisan test --filter=ResultatsTest', 'PASS  Tests\\Feature\\ResultatsTest\n✓ un élève voit ses résultats\n✓ un élève ne voit pas ceux d’un camarade', 'Le test échouerait si la faille réapparaissait.'],
+ ['Vérifier les en-têtes', 'Audit de sécurité.', 'curl -sI https://syllabus.local | grep -iE "content-security|set-cookie"', 'content-security-policy: default-src \'self\'; frame-ancestors \'none\'\nset-cookie: syllabus_session=…; secure; httponly; samesite=lax', 'CSP restrictive et cookie de session protégé.'],
+ ['Déploiement', 'Mise en production.', 'composer install --no-dev -o && php artisan migrate --force && php artisan optimize && php artisan queue:restart', 'INFO  Running migrations. 2026_10_01_create_rendus_table ....... DONE\nINFO  Caching framework bootstrap, configuration, and metadata.', 'Chaque étape est dans le pipeline CI, avec retour arrière en cas d’échec.']
+],
+termes: ['MVC', 'modèle', 'vue', 'contrôleur', 'routeur', 'Laravel', 'Blade', 'Eloquent', 'ORM', 'migration', 'N+1', 'API REST', 'JSON', 'OpenAPI', 'session', 'jeton', 'OAuth 2', 'OpenID Connect', 'policy', 'OWASP', 'IDOR', 'XSS', 'CSRF', 'CSP', 'CORS', 'APP_DEBUG']
+});
+
+reg({
+cours: { id: 'js', match: /JavaScript|TypeScript|DOM|fetch|Accessibilité web|RGAA|WCAG|Performance web/i,
+  titre: 'JavaScript et TypeScript côté navigateur : DOM, asynchrone, fetch, accessibilité', duree: '',
+  niveau: 'NSI Première · BTS SIO SLAM · BUT Informatique · Titre pro DWWM',
+  prerequis: ['Le Web : HTML et CSS', 'Python : bases de la programmation'],
+  competences: ['NSI · Interactions dans le navigateur', 'BTS SIO SLAM · Développer une interface', 'DWWM · Développer la partie front-end'],
+  intro: 'Tout ce qui réagit dans une page web, du bouton « Lever la main » au terminal xterm.js des labs, est écrit en JavaScript. Le langage s’exécute dans le navigateur, manipule la page, dialogue avec le serveur sans la recharger et doit rester utilisable par tous, y compris au clavier et avec un lecteur d’écran. Ce module présente le langage moderne, le DOM, la programmation asynchrone avec fetch, TypeScript et les exigences d’accessibilité et de performance.',
+  cm: [
+    { t: 'Le langage moderne', d: '', html: 'On déclare avec <code>const</code> (par défaut) et <code>let</code> ; <code>var</code> est à éviter. Les types de base : nombres, chaînes, booléens, <code>null</code>, <code>undefined</code>, objets et tableaux. Les <b>fonctions fléchées</b> (<code>x => x * 2</code>), la <b>déstructuration</b> (<code>const { nom, classe } = eleve</code>), les <b>gabarits</b> de chaînes (<code>`Bonjour ${nom}`</code>) et les méthodes de tableaux (<code>map</code>, <code>filter</code>, <code>reduce</code>, <code>find</code>) forment le socle quotidien. On compare avec <code>===</code>, qui ne convertit pas les types (<code>"1" == 1</code> est vrai, <code>"1" === 1</code> est faux). Les <b>modules</b> (<code>import</code> / <code>export</code>) organisent le code.' },
+    { t: 'Le DOM et les événements', d: '', html: 'Le <b>DOM</b> est la représentation de la page sous forme d’arbre d’objets. On sélectionne un élément (<code>document.querySelector("#liste")</code>), on modifie son contenu (<code>textContent</code>), ses classes (<code>classList.add</code>) ou ses attributs, on en crée (<code>createElement</code>). On réagit aux actions de l’utilisateur avec <code>addEventListener("click", …)</code>. La <b>délégation d’événements</b> place un seul écouteur sur un parent pour gérer de nombreux enfants, y compris ceux ajoutés plus tard.', attention: 'innerHTML avec une donnée saisie par un utilisateur ouvre une faille XSS : le texte peut contenir un script. On utilise textContent pour du texte, ou on échappe explicitement.' },
+    { t: 'Asynchrone : promesses et async/await', d: '', html: 'Le navigateur n’exécute qu’un seul fil de JavaScript ; une opération longue (requête réseau, minuterie) ne doit pas le bloquer. Elle renvoie une <b>promesse</b>, résolue plus tard. La syntaxe <code>async</code> / <code>await</code> permet d’écrire ce code de façon lisible, et <code>try</code> / <code>catch</code> gère les erreurs. <code>Promise.all</code> lance plusieurs requêtes en parallèle. La <b>boucle d’événements</b> exécute les rappels quand le fil principal est libre.' },
+    { t: 'Dialoguer avec le serveur : fetch', d: '', html: '<code>fetch</code> envoie une requête HTTP et renvoie une promesse de réponse. Il ne rejette la promesse qu’en cas d’erreur réseau : une réponse 404 ou 500 est une réponse « réussie », il faut tester <code>response.ok</code>. On envoie du JSON avec l’en-tête Content-Type et on joint le jeton CSRF ou d’authentification. Pour des mises à jour en temps réel (mains levées, présences du quiz), on utilise les <b>WebSockets</b> ou les Server-Sent Events plutôt qu’interroger le serveur toutes les secondes.', exemple: 'async function leverLaMain(labId) {\n  const r = await fetch(`/api/v1/labs/${labId}/mains`, {\n    method: "POST",\n    headers: { "Content-Type": "application/json", "X-CSRF-TOKEN": jeton },\n    body: JSON.stringify({ etape: 4 }),\n  });\n  if (!r.ok) throw new Error(`Erreur ${r.status}`);\n  const { position } = await r.json();\n  document.querySelector("#position").textContent = `Vous êtes ${position}e dans la file.`;\n}' },
+    { t: 'TypeScript', d: '', html: '<b>TypeScript</b> ajoute un typage statique à JavaScript : on déclare la forme des données (<code>interface Eleve { id: number; nom: string; classe?: string }</code>) et le compilateur signale les erreurs avant l’exécution : propriété mal orthographiée, valeur possiblement undefined, mauvais type d’argument. Le code est compilé en JavaScript standard. Sur un projet de plusieurs milliers de lignes, il réduit fortement les régressions et rend l’éditeur beaucoup plus utile (complétion, renommage sûr).' },
+    { t: 'Accessibilité et performance', d: '', html: 'Un site public en France doit respecter le <b>RGAA</b>, fondé sur les normes <b>WCAG</b>. Les règles de base : utiliser les bons éléments HTML (un <code>&lt;button&gt;</code> plutôt qu’un <code>&lt;div&gt;</code> cliquable, qui ne se commande pas au clavier), des étiquettes de formulaire liées, des textes alternatifs, un contraste suffisant (4,5:1 pour le texte), un focus visible, et <code>aria-live</code> pour annoncer les mises à jour dynamiques. Côté <b>performance</b> : réduire le JavaScript chargé, différer ce qui n’est pas indispensable (<code>defer</code>, chargement à la demande), optimiser les images, mettre en cache. Les outils de développement du navigateur et Lighthouse mesurent les deux.' }
+  ],
+  synthese: ['const/let, fonctions fléchées, déstructuration, ===, modules', 'DOM : querySelector, textContent, addEventListener, délégation', 'Jamais innerHTML avec une saisie utilisateur', 'Promesses, async/await, try/catch, Promise.all', 'fetch : tester response.ok ; WebSockets pour le temps réel', 'TypeScript : interfaces et vérification avant exécution', 'RGAA/WCAG : éléments natifs, clavier, contraste, aria-live ; performance'],
+  qcm: [
+    ['Que vaut "1" === 1 ?', ['true', 'false', 'undefined', 'erreur'], 1, 'Pas de conversion de type.'],
+    ['Quelle propriété insérer pour afficher un texte saisi par l’utilisateur ?', ['innerHTML', 'textContent', 'outerHTML', 'eval'], 1, 'Pas d’interprétation HTML.'],
+    ['Quand fetch rejette-t-il sa promesse ?', ['Sur un 404', 'Sur un 500', 'En cas d’erreur réseau', 'Jamais'], 2, 'Tester response.ok.'],
+    ['À quoi sert await ?', ['Bloquer le navigateur', 'Attendre le résultat d’une promesse dans une fonction async', 'Créer une boucle', 'Déclarer une variable'], 1, 'Sans bloquer le fil principal.'],
+    ['Pourquoi préférer <button> à une <div> cliquable ?', ['Esthétique', 'Accessible au clavier et aux lecteurs d’écran', 'Plus rapide', 'Obligatoire en HTML5'], 1, 'Comportement natif.'],
+    ['Quel est l’apport principal de TypeScript ?', ['Plus rapide à l’exécution', 'Détecter des erreurs de types avant l’exécution', 'Remplacer HTML', 'Chiffrer le code'], 1, 'Typage statique.']
+  ],
+  td: [
+    { n: 'Application', c: 'À partir d’un tableau d’élèves, afficher dans une liste ceux dont la moyenne est inférieure à 10, triés par moyenne, avec textContent.', r: 'eleves.filter(e => e.moyenne < 10).sort((a, b) => a.moyenne - b.moyenne).forEach(e => { const li = document.createElement("li"); li.textContent = `${e.nom} : ${e.moyenne}`; liste.append(li); });' },
+    { n: 'Application', c: 'Charger en parallèle la liste des classes et celle des devoirs, et afficher un message d’erreur accessible en cas d’échec.', r: 'try { const [c, d] = await Promise.all([fetch("/api/v1/classes"), fetch("/api/v1/devoirs")]); if (!c.ok || !d.ok) throw … } catch (e) { zone.textContent = "Chargement impossible"; } avec zone en aria-live="polite".' },
+    { n: 'Approfondissement', c: 'Auditer l’accessibilité d’un formulaire fourni et proposer cinq corrections.', r: 'label lié à chaque champ · message d’erreur associé (aria-describedby) · bouton réel · contraste · ordre de tabulation et focus visible.' }
+  ],
+  tp: { type: 'IDE web', url: 'apercu-ide.html', desc: 'Page interactive avec API simulée.', etapes: ['Manipuler le DOM', 'Gérer les événements par délégation', 'Appeler une API avec fetch', 'Gérer les erreurs', 'Typer avec TypeScript', 'Audit Lighthouse accessibilité'] },
+  plusLoin: [['MDN · JavaScript (fr)', 'https://developer.mozilla.org/fr/docs/Web/JavaScript'], ['TypeScript Handbook', 'https://www.typescriptlang.org/docs/'], ['RGAA 4', 'https://accessibilite.numerique.gouv.fr/'], ['freeCodeCamp · JavaScript', 'https://www.freecodecamp.org/']] },
+plus: { cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Le bouton « Lever la main » affiche parfois « Vous êtes undefinede dans la file » et, pour un élève malvoyant, ne produit aucune annonce.', etapes: [
+    ['Reproduire', 'Console : POST /api/v1/labs/7/mains → 419\n→ Le serveur refuse la requête (jeton CSRF expiré) mais le code lit quand même le JSON.'],
+    ['Lire le code', 'const r = await fetch(…); const { position } = await r.json();\n→ Aucun test de r.ok : la réponse d’erreur n’a pas de champ position.'],
+    ['Corriger la logique', 'if (!r.ok) { afficherErreur(r.status === 419 ? "Session expirée, rechargez la page." : "Envoi impossible."); return; }\n→ Message clair selon l’erreur.'],
+    ['Corriger l’accessibilité', 'Zone de message : <p id="position" aria-live="polite"></p> et bouton réel avec aria-pressed.\n→ Le lecteur d’écran annonce la position et l’état du bouton.'],
+    ['Tester', '→ Test automatisé du cas 419 et vérification avec NVDA. Ajout du typage TypeScript de la réponse (interface ReponseMain { position: number }).']
+  ] },
+  erreurs: ['== au lieu de ===', 'innerHTML avec des données utilisateur', 'Ne pas tester response.ok', 'Oublier await', 'Div cliquable au lieu d’un bouton', 'Mises à jour non annoncées aux lecteurs d’écran', 'Charger tout le JavaScript au démarrage'],
+  memo: [['Élément', 'Usage'], ['document.querySelector(sel)', 'sélectionner'], ['el.textContent = …', 'afficher du texte sûr'], ['el.addEventListener("click", f)', 'réagir'], ['async / await / try…catch', 'asynchrone'], ['fetch(url, { method, headers, body })', 'requête HTTP'], ['response.ok · response.json()', 'lire la réponse'], ['Promise.all([...])', 'requêtes parallèles'], ['aria-live="polite"', 'annoncer une mise à jour'], ['<script type="module" defer>', 'charger sans bloquer'], ['tsc --noEmit', 'vérifier les types']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Manipuler le DOM pour un besoin donné. (5 pts)', 'Écrire un appel fetch avec gestion d’erreur. (5 pts)', 'Expliquer la faille XSS liée à innerHTML. (3 pts)', 'Typer des données avec TypeScript. (3 pts)', 'Corriger quatre problèmes d’accessibilité. (4 pts)'], r: ['querySelector, createElement, textContent', 'async, ok, json, catch', 'interprétation du HTML', 'interface', 'label, bouton, contraste, aria-live'] },
+  prof: { deroule: [['Ouverture', 'Naviguer sur un site au clavier seul'], ['Cours', 'Langage et DOM'], ['Pratique', 'Liste dynamique'], ['Cours', 'Asynchrone et fetch'], ['Pratique', 'Appel d’API'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : exercices guidés MDN. Élèves avancés : TypeScript strict, WebSockets.', eval: 'Page rendue et auditée, sujet type.' } },
+exemples: [
+ ['Égalité stricte', 'Bug de comparaison.', 'console.log("0" == false, "0" === false)', 'true false', '== convertit les types de façon surprenante ; on utilise toujours ===.'],
+ ['Filtrer et trier', 'Élèves en difficulté.', 'eleves.filter(e => e.moyenne < 10).map(e => e.nom)', "[ 'Martin', 'Petit' ]", 'Deux élèves sous la moyenne.'],
+ ['Réponse d’erreur', 'Diagnostic dans la console.', 'const r = await fetch("/api/v1/devoirs/999"); console.log(r.ok, r.status)', 'false 404', 'La promesse est résolue même en cas de 404 : il faut tester ok.'],
+ ['Requêtes parallèles', 'Accélérer le chargement.', 'console.time("p"); await Promise.all([fetch(a), fetch(b)]); console.timeEnd("p")', 'p: 212 ms   (séquentiel : 405 ms)', 'Les deux requêtes partent en même temps.'],
+ ['Vérifier les types', 'Avant la mise en production.', 'npx tsc --noEmit', "src/main.ts:14:23 - error TS2339: Property 'posiiton' does not exist on type 'ReponseMain'.", 'Faute de frappe détectée avant l’exécution.'],
+ ['Audit d’accessibilité', 'Page de connexion.', 'npx lighthouse https://syllabus.local/connexion --only-categories=accessibility --quiet', 'Accessibility: 82\n- Form elements do not have associated labels\n- Background and foreground colors do not have a sufficient contrast ratio', 'Deux corrections prioritaires : étiquettes et contraste.']
+],
+termes: ['JavaScript', 'const', 'let', '===', 'fonction fléchée', 'DOM', 'querySelector', 'textContent', 'innerHTML', 'addEventListener', 'délégation', 'promesse', 'async', 'await', 'fetch', 'response.ok', 'JSON', 'WebSocket', 'TypeScript', 'interface', 'RGAA', 'WCAG', 'aria-live', 'Lighthouse']
+});
+
+reg({
+cours: { id: 'langc', match: /C : bases|pointeurs|compilation|make|Java ou C#|Sockets réseau/i,
+  titre: 'Langage C : compilation, pointeurs, mémoire et sockets réseau', duree: '',
+  niveau: 'BTS CIEL IR · BUT R&T · BUT Informatique · école d’ingénieurs',
+  prerequis: ['Algorithmique de base', 'Binaire et hexadécimal', 'Architecture des ordinateurs'],
+  competences: ['BTS CIEL · C05 · Développer un logiciel embarqué ou réseau', 'BUT R&T · Programmer des applications réseau', 'BUT Info · Réaliser un développement proche du système'],
+  intro: 'Le noyau Linux, les pilotes, les micrologiciels des objets connectés et une grande partie des outils réseau sont écrits en C. C’est un langage proche de la machine : il donne un contrôle total sur la mémoire, au prix d’une responsabilité totale. Comprendre le C, c’est comprendre ce que font réellement les langages de plus haut niveau, et pourquoi tant de failles de sécurité viennent de débordements de mémoire. Ce module couvre la compilation, les types, les pointeurs, l’allocation, les outils de détection d’erreurs et la programmation réseau avec les sockets.',
+  cm: [
+    { t: 'De la source à l’exécutable', d: '', html: 'Un programme C passe par plusieurs étapes. Le <b>préprocesseur</b> traite les directives (<code>#include</code>, <code>#define</code>). Le <b>compilateur</b> traduit chaque fichier .c en fichier objet .o (code machine). L’<b>éditeur de liens</b> assemble les objets et les bibliothèques en un exécutable. <code>gcc -Wall -Wextra -g -o prog main.c</code> compile avec les avertissements et les informations de débogage. Un <b>Makefile</b> décrit les dépendances pour ne recompiler que ce qui a changé.', exemple: '#include <stdio.h>\n\nint main(void) {\n    int notes[] = {12, 15, 9, 18};\n    int n = sizeof notes / sizeof notes[0];\n    int total = 0;\n    for (int i = 0; i < n; i++) total += notes[i];\n    printf("Moyenne : %.2f\\n", (double) total / n);\n    return 0;\n}' },
+    { t: 'Types, mémoire et tableaux', d: '', html: 'Chaque type occupe une taille fixe (<code>char</code> 1 octet, <code>int</code> généralement 4, <code>double</code> 8), consultable avec <code>sizeof</code> ; <code>stdint.h</code> fournit des types de taille garantie (<code>uint8_t</code>, <code>int32_t</code>) indispensables pour les protocoles et l’embarqué. Un <b>tableau</b> est une zone contiguë ; le C ne vérifie <b>jamais</b> les bornes : écrire en dehors corrompt la mémoire voisine. Une <b>chaîne</b> est un tableau de char terminé par <code>\'\\0\'</code> : oublier la place de ce caractère est une erreur classique.' },
+    { t: 'Pointeurs', d: '', html: 'Un <b>pointeur</b> contient une <b>adresse mémoire</b>. <code>&amp;x</code> donne l’adresse de x, <code>*p</code> la valeur pointée. Les pointeurs permettent de passer une variable à une fonction pour qu’elle la modifie (passage par adresse), de parcourir un tableau (le nom d’un tableau se convertit en pointeur vers son premier élément) et de manipuler des structures allouées dynamiquement. Un pointeur non initialisé ou <code>NULL</code> déréférencé provoque une erreur de segmentation (segfault).', exemple: 'void echanger(int *a, int *b) {\n    int tmp = *a;\n    *a = *b;\n    *b = tmp;\n}\n/* appel : echanger(&x, &y); */' },
+    { t: 'Allocation dynamique', d: '', html: 'Les variables locales vivent sur la <b>pile</b> et disparaissent à la fin de la fonction. Pour une taille connue seulement à l’exécution, on alloue sur le <b>tas</b> avec <code>malloc</code> (en vérifiant le retour NULL) et on libère avec <code>free</code>. Trois familles d’erreurs dominent : la <b>fuite</b> (oublier free), l’<b>utilisation après libération</b> (use after free) et le <b>débordement de tampon</b> (buffer overflow), à l’origine d’une grande partie des failles historiques. <b>Valgrind</b> et les sanitizers (<code>-fsanitize=address</code>) les détectent à l’exécution.', attention: 'Les fonctions gets et strcpy n’ont aucune limite de taille : on utilise fgets et snprintf. Les agences de sécurité recommandent désormais les langages sûrs en mémoire (Rust, Go) pour les nouveaux développements critiques.' },
+    { t: 'Structures et modularité', d: '', html: 'Une <b>struct</b> regroupe des champs de types différents : <code>struct eleve { char nom[40]; float moyenne; };</code>. On accède aux champs avec <code>.</code>, ou <code>-></code> à travers un pointeur. Un programme se découpe en modules : un fichier d’en-tête .h déclare les fonctions et les types, le fichier .c les implémente. Les tableaux de structures et les listes chaînées de structures sont la base de nombreux programmes système.' },
+    { t: 'Programmation réseau : sockets', d: '', html: 'L’API des <b>sockets</b> BSD, disponible en C sur tous les systèmes, est celle qu’utilisent tous les serveurs réseau. Un serveur TCP enchaîne <code>socket</code>, <code>bind</code> (adresse et port), <code>listen</code>, <code>accept</code> (bloquant, renvoie une socket par client), puis <code>recv</code> et <code>send</code>. Un client fait <code>socket</code> puis <code>connect</code>. Les nombres transmis doivent être convertis dans l’<b>ordre réseau</b> (big-endian) avec <code>htons</code> et <code>htonl</code>. Pour UDP, <code>sendto</code> et <code>recvfrom</code> échangent des datagrammes sans connexion. On retrouve exactement les états TCP vus avec ss.', exemple: 'int s = socket(AF_INET, SOCK_STREAM, 0);\nstruct sockaddr_in a = { .sin_family = AF_INET, .sin_port = htons(5000), .sin_addr.s_addr = htonl(INADDR_ANY) };\nbind(s, (struct sockaddr *)&a, sizeof a);\nlisten(s, 16);\nint c = accept(s, NULL, NULL);\nchar buf[256];\nssize_t n = recv(c, buf, sizeof buf - 1, 0);\nif (n > 0) { buf[n] = \'\\0\'; send(c, "OK\\n", 3, 0); }\nclose(c); close(s);' }
+  ],
+  synthese: ['Préprocesseur → compilateur → éditeur de liens ; gcc -Wall -Wextra -g ; make', 'Tailles de types, stdint.h ; aucune vérification des bornes ; chaînes terminées par \\0', 'Pointeurs : &, *, passage par adresse, NULL', 'malloc/free : fuites, use after free, débordements ; Valgrind et sanitizers', 'struct, en-têtes .h et modules', 'Sockets : socket, bind, listen, accept, recv, send ; htons ; UDP avec sendto/recvfrom'],
+  qcm: [
+    ['Quelle étape assemble les fichiers objets en exécutable ?', ['Préprocesseur', 'Compilateur', 'Éditeur de liens', 'Makefile'], 2, 'Linker.'],
+    ['Que contient un pointeur ?', ['Une valeur entière quelconque', 'Une adresse mémoire', 'Un fichier', 'Une chaîne'], 1, 'Adresse.'],
+    ['Taille nécessaire pour stocker « SIO1 » ?', ['4', '5', '8', '1'], 1, '4 caractères + \\0.'],
+    ['Que fait free ?', ['Alloue', 'Libère la mémoire allouée par malloc', 'Initialise', 'Copie'], 1, 'À appeler une seule fois.'],
+    ['Pourquoi htons ?', ['Chiffrer', 'Convertir en ordre d’octets réseau', 'Compresser', 'Vérifier'], 1, 'Big-endian.'],
+    ['Quel outil détecte les fuites mémoire ?', ['gcc', 'Valgrind', 'make', 'gdb uniquement'], 1, 'Et -fsanitize=address.']
+  ],
+  td: [
+    { n: 'Application', c: 'Écrire une fonction qui calcule la moyenne d’un tableau d’entiers et renvoie -1 si le tableau est vide.', r: 'double moyenne(const int *t, size_t n) { if (n == 0) return -1; long s = 0; for (size_t i = 0; i < n; i++) s += t[i]; return (double) s / n; }' },
+    { n: 'Application', c: 'Allouer dynamiquement un tableau de n structures eleve lu au clavier, puis le libérer. Vérifier avec Valgrind.', r: 'struct eleve *t = malloc(n * sizeof *t); if (!t) return 1; … free(t); · valgrind --leak-check=full ./prog → 0 bytes lost.' },
+    { n: 'Approfondissement', c: 'Écrire un client TCP qui se connecte au serveur du cours, envoie « PING » et affiche la réponse, puis observer la connexion avec ss et tcpdump.', r: 'socket, connect sur 127.0.0.1:5000, send, recv · ss -tn state established ; tcpdump -ni lo port 5000 montre SYN, SYN-ACK, ACK puis PSH.' }
+  ],
+  tp: { type: 'Lab VM', url: 'apercu-labs.html', desc: 'Compilation et débogage dans une VM Debian.', etapes: ['Compiler avec gcc et make', 'Pointeurs et passage par adresse', 'Allocation dynamique et Valgrind', 'Provoquer puis corriger un débordement avec -fsanitize=address', 'Serveur et client TCP', 'Observer l’échange avec tcpdump'] },
+  plusLoin: [['Beej’s Guide to Network Programming', 'https://beej.us/guide/bgnet/'], ['Documentation GCC', 'https://gcc.gnu.org/onlinedocs/'], ['ANSSI · Règles de programmation pour le développement sécurisé en C', 'https://cyber.gouv.fr/publications/regles-de-programmation-pour-le-developpement-securise-de-logiciels-en-langage-c']] },
+plus: { cas: { titre: '', texte: '' },
+  resolu: { enonce: 'Le petit serveur de collecte des capteurs de CO₂, écrit en C, plante de façon aléatoire après quelques heures.', etapes: [
+    ['Reproduire', 'journalctl -u collecteur | tail -1\ncollecteur.service: Main process exited, code=killed, status=11/SEGV\n→ Erreur de segmentation.'],
+    ['Compiler avec les sanitizers', 'gcc -g -fsanitize=address -o collecteur collecteur.c && ./collecteur\nERROR: AddressSanitizer: stack-buffer-overflow … WRITE of size 71 … in handle_message collecteur.c:48\n→ Écriture de 71 octets dans un tampon plus petit.'],
+    ['Lire le code', 'char salle[32];\nstrcpy(salle, message + 5);\n→ Un nom de topic plus long que prévu déborde du tableau.'],
+    ['Corriger', 'snprintf(salle, sizeof salle, "%s", message + 5);\n+ contrôle de la longueur et rejet des messages invalides.\n→ Plus aucun débordement, même avec des messages malformés.'],
+    ['Prévenir', '→ Compilation systématique avec -Wall -Wextra -Werror en CI, tests avec -fsanitize=address et un jeu de messages malformés (fuzzing simple). Ce type de faille est exploitable à distance : correction déployée en priorité.']
+  ] },
+  erreurs: ['Ignorer les avertissements du compilateur', 'Oublier la place du \\0', 'Utiliser gets ou strcpy', 'Ne pas vérifier le retour de malloc', 'Oublier free ou libérer deux fois', 'Oublier htons pour le port', 'Ne pas vérifier les retours de recv et send'],
+  memo: [['Commande / fonction', 'Usage'], ['gcc -Wall -Wextra -g -o p f.c', 'compiler'], ['make', 'recompiler selon les dépendances'], ['gdb ./p', 'déboguer'], ['valgrind --leak-check=full ./p', 'fuites et erreurs mémoire'], ['-fsanitize=address,undefined', 'détecter les débordements'], ['sizeof', 'taille d’un type ou d’un tableau'], ['malloc / free', 'allouer / libérer'], ['fgets · snprintf', 'lectures et copies bornées'], ['socket bind listen accept', 'serveur TCP'], ['htons · htonl · ntohs', 'ordre réseau']],
+  examen: { titre: 'Sujet type · 20 points', q: ['Décrire les étapes de compilation. (3 pts)', 'Écrire une fonction avec pointeurs. (4 pts)', 'Allouer et libérer une structure dynamique. (4 pts)', 'Identifier un débordement de tampon et le corriger. (4 pts)', 'Écrire les étapes d’un serveur TCP. (5 pts)'], r: ['préprocesseur, compilateur, éditeur de liens', 'passage par adresse', 'malloc, vérification, free', 'strcpy → snprintf', 'socket, bind, listen, accept, recv, send'] },
+  prof: { deroule: [['Ouverture', 'Même programme en Python et en C : temps et mémoire'], ['Cours', 'Compilation et types'], ['Pratique', 'Pointeurs'], ['Cours', 'Mémoire et sécurité'], ['Pratique', 'Sockets'], ['Clôture', 'Quiz flash']], diff: 'Élèves en difficulté : schémas de mémoire. Élèves avancés : serveur multi-clients avec poll, comparaison avec Rust.', eval: 'Programmes sans erreur Valgrind, sujet type.' } },
+exemples: [
+ ['Compiler avec avertissements', 'Premier programme.', 'gcc -Wall -Wextra -o moyenne moyenne.c', 'moyenne.c:6:9: warning: unused variable ‘i’ [-Wunused-variable]', 'Les avertissements signalent souvent de vraies erreurs ; on les corrige tous.'],
+ ['Tailles des types', 'Protocole binaire.', 'printf("%zu %zu %zu\\n", sizeof(char), sizeof(int), sizeof(double));', '1 4 8', 'Pour un format de trame, on préfère uint8_t, uint16_t, uint32_t, de taille garantie.'],
+ ['Erreur de segmentation', 'Programme qui plante.', 'gdb -q ./prog -ex run -ex bt', 'Program received signal SIGSEGV, Segmentation fault.\n#0  afficher (e=0x0) at eleves.c:21', 'Le pointeur e vaut NULL à la ligne 21 : un retour de recherche non vérifié.'],
+ ['Détecter une fuite', 'Contrôle qualité.', 'valgrind --leak-check=full ./prog | tail -3', '==4012== LEAK SUMMARY:\n==4012==    definitely lost: 1,280 bytes in 32 blocks', '32 blocs jamais libérés : un free manquant dans la boucle.'],
+ ['Tester le serveur TCP', 'Après compilation.', './serveur & echo "PING" | nc 127.0.0.1 5000', 'OK', 'Le serveur répond ; ss -tln montre LISTEN sur 0.0.0.0:5000.'],
+ ['Ordre des octets', 'Port mal configuré.', 'printf("%u\\n", (unsigned) htons(5000));', '34835', '5000 = 0x1388 devient 0x8813 en mémoire sur une machine little-endian : sans htons, le serveur écouterait sur le port 34835.']
+],
+termes: ['préprocesseur', 'compilateur', 'éditeur de liens', 'gcc', 'Makefile', 'sizeof', 'stdint.h', 'pointeur', 'adresse', 'NULL', 'segfault', 'malloc', 'free', 'pile', 'tas', 'fuite mémoire', 'use after free', 'débordement de tampon', 'Valgrind', 'AddressSanitizer', 'struct', 'socket', 'bind', 'listen', 'accept', 'htons']
+});
+})();