Couverture des certifications

• Les ports : un processus écoute, ou rien ne répond

Ce qui manque: Les leçons lisent des paramètres du noyau avec `sysctl` pour expliquer ce que fait un port ou un socket ; aucune n'en modifie un, et `/etc/sysctl.d/` — où un réglage survit au redémarrage — n'est pas enseigné.

• Ce qui tourne : les processus
• Les signaux, et pourquoi kill -9 est le dernier recours
• Premier plan, arrière-plan et tâches
• Lire un statut, et les quatre verbes
• Lire les journaux avec journalctl
• Politiques de redémarrage, et la boucle qu'elles cachent
• Du symptôme à un composant : ce que l'hypothèse interdit

• Planifier une tâche : cron ou timer systemd
• Quand la sauvegarde précédente tourne encore
• Un script qu'on peut relancer

• Mettre à jour un serveur avec apt
• Installer et supprimer des logiciels
• Où un paquet range ses fichiers
• Installer Docker : le dépôt officiel, pas celui d'Ubuntu
• Savoir ce qui a changé sur le disque

• Reconstruire la machine entière, dans le bon ordre
• Restaurer, et faire de l'exercice une routine
• Restaurer des fichiers, et les propriétaires que personne n'a sauvegardés
• Vérifier avant de se déclarer terminé, et ce qu'un retour n'annule pas

Ce qui manque: Récupérer des données et reconstruire une machine à partir de ses sauvegardes est enseigné en entier ; récupérer une machine qui ne démarre plus — le shell de secours, `fsck` sur un système de fichiers démonté, un chargeur d'amorçage cassé — ne l'est pas.

Ce qui manque: Rien dans le cursus ne fait tourner un hyperviseur. `libvirt`, `virsh` et les images de machines virtuelles sont absents ; chaque leçon administre une machine que quelqu'un d'autre a provisionnée.

• Image, conteneur, volume — et quand s'en passer
• Installer Docker : le dépôt officiel, pas celui d'Ubuntu
• Un Dockerfile pour une application Node
• Les données survivent au conteneur, le port traverse le pare-feu
• Compose : l'application et sa base dans un seul fichier
• Le fichier de journal que personne ne fait tourner
• Un conteneur sans limite de mémoire, et le processus que le noyau tue à sa place

• AppArmor : le refus que les permissions n'expliquent pas

Ce qui manque: Le programme nomme SELinux. Le cursus enseigne le contrôle d'accès obligatoire par AppArmor, ce qu'Ubuntu embarque — le concept se transfère, pas les commandes : `getenforce`, `semanage`, `restorecon` et les contextes de fichiers s'apprennent ailleurs.

• Adresses, interfaces et routes
• Lire un préfixe, bit par bit
• La réparation qui tient jusqu'au prochain redémarrage
• Une adresse statique complète, sans gateway4
• La seconde famille d'adresses, déjà active chez vous
• Le chemin d'une requête, et le mythe de la propagation
• Ce que demande l'application, et pourquoi dig répond à une autre question

Ce qui manque: La configuration statique en IPv4 est désormais enseignée de bout en bout — le préfixe calculé, l'adresse, la route par défaut et les résolveurs écrits dans Netplan, et la distinction entre l'état vivant et le fichier qui décide au démarrage. IPv6 est lu et non configuré : aucune leçon n'attribue une adresse IPv6 statique.

• Deux journaux qui disent 14:02 : l'heure n'est pas un nombre
• Des horloges qui s'accordent entre elles

• Les ports : un processus écoute, ou rien ne répond
• Refusé ou silencieux : ce que chaque échec prouve
• Injoignable : trouver la couche en panne avant de toucher à quoi que ce soit
• Ça marche sur le serveur, refusé depuis l'extérieur
• Jeté ici, ou jamais arrivé : une capture tranche
• Ce qu'un échec de résolution dit, et à qui est la panne

• Se connecter pour la première fois
• Passer SSH en authentification par clé
• L'agent, la phrase de passe, et ce que ssh -A prête vraiment
• Une clé est une ligne, et la ligne accepte des options
• Durcir le serveur SSH sans perdre la main

• ufw : refuser par défaut sans se verrouiller dehors
• Trois auteurs, un seul jeu de règles : lire ce que le noyau détient
• L'annulation qu'on programme avant d'en avoir besoin
• Rediriger un port, ce n'est pas l'autoriser
• Quand les adresses ont manqué : la table qui réécrit vos paquets
• Les données survivent au conteneur, le port traverse le pare-feu

• Adresses, interfaces et routes
• Voisin ou pas : le test que la machine refait à chaque paquet
• Une seconde route, et la certitude qu'elle sert

• Un pont : le commutateur que vous avez déjà
• Agréger deux cartes, sans doubler le débit
• Un VLAN n'est pas un sous-réseau

Ce qui manque: Pont, agrégat et interface VLAN sont construits et relus, chacun exécuté avant d'être imprimé. Une réserve : la moitié `802.3ad` de l'agrégation exige une configuration du commutateur, que les leçons nomment sans l'enseigner — le cursus ne configure pas d'équipement réseau.

• Deux backends derrière un seul Nginx
• Une adresse qui change de machine
• Reverse proxy vers une application Node
• Quel bloc serveur répond, et pourquoi c'est parfois le mauvais site
• Les limites qui refusent : 413 et 504
• Lire le journal d'erreurs : pourquoi le 502 a eu lieu

Ce qui manque: Les deux moitiés sont enseignées depuis le 2026-09-21, date à laquelle la limite d'une seule machine a été franchie pour ce seul chapitre : un bloc `upstream {}` à deux serveurs, ce que `max_fails` fait réellement, et une adresse flottante en VRRP. Une réserve à connaître : ces deux leçons reposent sur la documentation des éditeurs et non sur une exécution vérifiée, Nginx et keepalived n'étant pas installables sur la machine d'écriture. Elles le disent elles-mêmes.

Ce qui manque: Aucune leçon ne touche à LVM. Chaque système de fichiers du cursus est celui que l'installateur a créé.

• Ce qui tourne : les processus
• Occupé à quoi : lire la ligne du processeur

Ce qui manque: `/proc` est lu là où il explique quelque chose — le répertoire courant d'un processus, les compteurs que `top` lit — et `/etc/fstab` apparaît là où systemd transforme ses lignes en unités de montage. Écrire un montage vous-même, et ce que le noyau expose sous `/sys`, ne sont pas enseignés.

• Disque, mémoire et charge : lire sans se tromper
• Restaurer des fichiers, et les propriétaires que personne n'a sauvegardés

Ce qui manque: Dépanner un système de fichiers — un disque plein sans rien à supprimer, des inodes épuisés, des propriétaires perdus à la restauration — est enseigné avec des labs. En créer un avec `mkfs`, le vérifier avec `fsck` et le monter vous-même ne le sont pas.

Ce qui manque: Ni NFS, ni iSCSI, ni périphérique bloc en réseau. Les copies distantes voyagent par `rsync` sur SSH, ce qui est un transfert, pas un système de fichiers monté.

• Disque, mémoire et charge : lire sans se tromper

Ce qui manque: Lire le swap comme un signe de pression mémoire, dans `free` et `vmstat`, est enseigné. Créer, dimensionner ou retirer un swap ne l'est pas.

Ce qui manque: Rien dans le cursus ne monte à la demande. `.automount` est nommé une fois, comme l'un des onze types d'unité de systemd, et jamais employé ; `autofs` n'apparaît pas.

• Quel disque, et combien de temps chaque requête a pris
• Des tendances, pas des instantanés
• pg_wal se remplit, et quelque chose le retient

• Ce qu'un commit contient réellement
• Répondre à « qu'est-ce qui a changé ? »
• Ce qui n'entre jamais dans l'historique
• Revenir en arrière sans réécrire l'historique
• Faire circuler l'historique entre machines
• Lire un dépôt que quelqu'un d'autre a branché
• Nommer ce qui est déployable

• Votre première unité systemd
• Unités, cibles, et qui dépend de quoi
• Configuration et secrets qu'une unité peut lire
• Modifier une unité de paquet sans perdre la modification
• Désactiver un service, ce n'est pas l'arrêter

• Disque, mémoire et charge : lire sans se tromper
• Occupé à quoi : lire la ligne du processeur
• Quel disque, et combien de temps chaque requête a pris
• Une vérification automatique qui sert à quelque chose
• Ce qu'une sortie prouve, et ce que « succès » ne prouve pas
• Le contrôle qui passe toujours, et la purge qui ne prouve rien

• Modifier une unité de paquet sans perdre la modification
• Cent connexions, et l'arithmétique qui les dépasse
• Les limites qui refusent : 413 et 504
• Un conteneur sans limite de mémoire, et le processus que le noyau tue à sa place

• Disque, mémoire et charge : lire sans se tromper
• Maîtriser la croissance des journaux
• Pourquoi un DELETE ne rend pas d'espace
• pg_wal se remplit, et quelque chose le retient
• Le fichier de journal que personne ne fait tourner

• Quatre-vingt-dix jours, et personne ne vous préviendra
• Vérifier depuis l'extérieur de la machine

• Qui suis-je sur ce système ?
• Créer et supprimer des comptes
• Verrouiller un mot de passe ne ferme pas un compte
• sudo, et pourquoi personne ne travaille en root
• Devenir quelqu'un d'autre, et quel shell on obtient

• Planifier une tâche : cron ou timer systemd
• Configuration et secrets qu'une unité peut lire
• Qu'est-ce qu'un shell ?

Ce qui manque: La différence entre l'environnement d'un shell interactif et celui d'un service est enseignée là où elle mord — un script qui marche à l'invite et échoue sous cron ou systemd. `/etc/profile`, `/etc/environment` et l'ordre de chargement de `~/.bashrc` et de ses semblables ne le sont pas.

• Modifier une unité de paquet sans perdre la modification
• Cent connexions, et l'arithmétique qui les dépasse

Ce qui manque: Les limites sont enseignées par service — `LimitNOFILE=` dans une unité, le plafond de connexions d'une base — jamais par compte : `ulimit`, `/etc/security/limits.conf` et le rôle de PAM dans leur application sont absents.

• Un répertoire partagé entre deux comptes, proprement
• D'où viennent les permissions d'un nouveau fichier
• Restaurer des fichiers, et les propriétaires que personne n'a sauvegardés

Ce qui manque: Chaque compte du cursus est local. Aucune leçon ne rattache une machine à un annuaire.