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
• 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: Lire les adresses, les routes et les interfaces avec `ip`, et la façon dont un nom se résout, sont enseignés. Attribuer une adresse — une configuration statique dans Netplan — ne l'est pas.

• Deux journaux qui disent 14:02 : l'heure n'est pas un nombre

Ce qui manque: Lire l'heure, le fuseau et l'état de synchronisation d'une machine avec `timedatectl`, et ce qu'une horloge corrigée d'un saut fait aux preuves, sont enseignés dans une leçon et un lab. Diriger `systemd-timesyncd` vers vos propres serveurs dans `timesyncd.conf` ne l'est pas.

• 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
• Les données survivent au conteneur, le port traverse le pare-feu

Ce qui manque: Filtrer avec `ufw`, lire le jeu de règles nftables que le noyau tient réellement, et la façon dont Docker écrit son propre NAT devant lui sont enseignés. Écrire à la main une redirection de port ou une règle de NAT ne l'est pas.

• Adresses, interfaces et routes

Ce qui manque: Lire la table de routage et la route par défaut est enseigné ; ajouter une route statique, et la rendre persistante, ne l'est pas.

Ce qui manque: Aucune leçon ne crée un pont ni un agrégat de liens. Le réseau en pont de Docker apparaît comme un fait dont les leçons sur les conteneurs dépendent, jamais comme un périphérique que vous configurez.

• 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: La moitié « mandataire inverse » est enseignée en profondeur — Nginx devant une application Node, avec ses délais et son journal d'erreurs. La moitié « répartiteur de charge » ne l'est pas : aucune leçon ne place deux serveurs derrière un même bloc `upstream {}`, parce que le cursus s'arrête à une machine.

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.