Quelques pensées

Terres dévastées

Vallée de montagne enneigée entre deux sommets rocheux, sous un ciel bleu
Carte des capacités systemd : directives d'identité, de limite, d'octroi et de blocage, et ce que chacune contrôle

Capacités systemd : de root à un seul privilège, avec un laboratoire testé

Les capacités systemd décident des privilèges qu’un service garde réellement. La plupart des services démarrent en root, donc ils détiennent bien plus de pouvoir que nécessaire. Cette troisième partie de la série « Systemd hardening, directive par directive » montre comment réduire ce pouvoir, une directive à la fois, avec un laboratoire que vous pouvez reconstruire en une demi-heure.

Chaque sortie ci-dessous vient d’une vraie exécution sur une machine de test, donc vous pouvez la comparer à vos propres résultats. Quand un résultat diffère de ce que le manuel laisse attendre, le texte le signale. L’article couvre User=, Group=, SupplementaryGroups=, DynamicUser=, NoNewPrivileges=, CapabilityBoundingSet=, AmbientCapabilities=, SecureBits= et RestrictSUIDSGID=. La directive PAMName= appartient à la même famille, mais elle n’a pas été testée, donc elle n’a droit qu’à une courte note.

Avant de commencer

  • Niveau : vous savez écrire un fichier d’unité et lire un journal. Vous n’avez pas besoin de connaître les capacités systemd.
  • Machine : une machine de test ou une machine virtuelle sous systemd. N’exécutez jamais ce laboratoire sur un serveur de production.
  • Droits : un accès root via sudo.
  • Outils : systemctl, journalctl, systemd-analyze, python3 et les outils libcap (capsh, getpcaps, getcap, setcap).
  • Durée : environ 30 minutes pour tout le laboratoire, et environ 5 minutes si vous ne faites que lire.
  • La partie 1 de la série explique comment mesurer une unité avec systemd-analyze security. Ici, ce score sert seulement de thermomètre.

Testé sur Rocky Linux 10.2, systemd 257, noyau WSL2 6.18.54.1-microsoft-standard-WSL2. SELinux n’est pas disponible sur ce banc (le système de fichiers selinuxfs est absent), donc aucun résultat ci-dessous ne fait intervenir SELinux. Sur un noyau natif avec SELinux en mode enforcing, certains résultats peuvent différer.

Le vocabulaire utile

Les capacités systemd ont leur propre vocabulaire, donc un court glossaire passe en premier. Lisez ce tableau une fois, puis revenez-y quand un terme devient flou.

TermeSens simple
UID 0 / rootLe compte administrateur. Historiquement, le noyau lui accorde tous les privilèges.
Capacité (capability)Une tranche du pouvoir de root. Par exemple CAP_NET_BIND_SERVICE autorise les ports inférieurs à 1024, et CAP_CHOWN autorise le changement de propriétaire d’un fichier. La liste complète figure dans la page de manuel capabilities(7).
Ensemble de limitation (bounding set)Le plafond. Une capacité hors de cet ensemble ne peut être utilisée ni par le processus ni par ce qu’il lance.
Ensemble ambiant (ambient set)Les capacités qu’un processus non-root conserve quand il lance un autre programme. C’est le moyen d’accorder un seul privilège à un service non privilégié.
Fichier setuid (set-user-ID)Un programme qui s’exécute avec l’identité de son propriétaire, souvent root (sudo et passwd en sont des exemples).
Capacité de fichierUne capacité stockée sur le fichier du programme lui-même, avec setcap.
no_new_privsUn drapeau du noyau. Une fois posé, execve() ne peut plus jamais donner davantage de privilèges au processus. NoNewPrivileges= le pose.
Drop-inUn petit fichier nommé unité.service.d/quelquechose.conf qui surcharge une partie d’une unité. Il survit aux mises à jour de paquets.
Niveau d’expositionLe score de systemd-analyze security, de 0 à 10. Un nombre plus haut signifie un service plus exposé.

Comment les capacités systemd s’articulent : qui limite, qui accorde, qui bloque

Neuf directives, cela semble beaucoup, mais elles jouent seulement quatre rôles, et l’image ci-dessous les montre côte à côte.

Carte des capacités systemd : directives d'identité, de limite, d'octroi et de blocage, et ce que chacune contrôle
Qui limite, qui accorde, qui bloque.
  • Identité : User=, Group=, SupplementaryGroups= et DynamicUser= choisissent qui est le service.
  • Limiter : CapabilityBoundingSet= fixe le plafond de ce que le service peut jamais détenir.
  • Accorder : AmbientCapabilities= donne à un service non-root les quelques capacités dont il a besoin.
  • Bloquer : NoNewPrivileges= et RestrictSUIDSGID= empêchent le service de remonter. SecureBits= règle finement l’interaction entre root et les capacités.

La recette est donc courte : d’abord choisir une identité, puis accorder seulement le nécessaire, fixer le plafond, et enfin fermer les portes qui ramènent à root. Les sections suivantes testent chaque étape dans cet ordre.

Construire le laboratoire

Le laboratoire utilise un script de sonde inoffensif, lancé avec des réglages différents. La sonde fait quatre choses. D’abord, elle tente de lier le port 80 sur l’adresse de bouclage. Ensuite, elle tente de donner un fichier à un autre propriétaire. Puis elle tente de poser le bit setuid sur son propre fichier. Enfin, elle lance un assistant setuid appartenant à root. Elle affiche aussi les masques de capacités de son propre processus. Rien ne quitte la machine, car la sonde ne touche qu’un répertoire temporaire privé.

Tous les noms commencent par demo-hardening-sd3-, et le compte s’appelle sd3demo. Ainsi, le nettoyage de fin d’article supprime exactement ce que le laboratoire a créé. Enregistrez le script ci-dessous sous le nom lab-setup.sh et lancez-le en root.

#!/bin/bash
# Creates the harmless demo files and units of the lab (all named demo-hardening-*).
set -e

# A dedicated system account for the demo (removed by the cleanup script).
id sd3demo >/dev/null 2>&1 || useradd --system --no-create-home --shell /usr/sbin/nologin sd3demo

cat > /usr/local/bin/demo-hardening-sd3-probe.sh <<'EOF'
#!/bin/bash
# Harmless probe: binds only to loopback, touches only a private temporary directory.
echo "identity: uid=$(id -u) user=$(id -un) groups=$(id -G)"
grep -E '^(NoNewPrivs|CapInh|CapPrm|CapEff|CapBnd|CapAmb):' /proc/self/status
d=$(mktemp -d)
if python3 -c 'import socket; s=socket.socket(); s.bind(("127.0.0.1", 80)); s.close()' 2>/dev/null; then
  echo "probe bind-80: allowed"
else
  echo "probe bind-80: refused"
fi
if [ "$(id -u)" = 0 ]; then target=nobody; else target=root; fi
touch "$d/owned"
if chown "$target" "$d/owned" 2>/dev/null; then
  echo "probe chown-to-$target: allowed"
else
  echo "probe chown-to-$target: refused"
fi
touch "$d/suid"
if chmod u+s "$d/suid" 2>/dev/null; then
  echo "probe chmod-u+s: allowed"
else
  echo "probe chmod-u+s: refused"
fi
echo "probe setuid-helper effective uid: $(/usr/local/bin/demo-hardening-sd3-setuid-id -u)"
rm -rf "$d"
EOF
chmod 755 /usr/local/bin/demo-hardening-sd3-probe.sh

# A copy of id(1) owned by root with the set-user-ID bit: it only prints IDs.
cp /usr/bin/id /usr/local/bin/demo-hardening-sd3-setuid-id
chown root:root /usr/local/bin/demo-hardening-sd3-setuid-id
chmod u+s,a+rx /usr/local/bin/demo-hardening-sd3-setuid-id

cat > /etc/systemd/system/demo-hardening-sd3-caps.service <<'EOF'
[Unit]
Description=Demo hardening: what may an unprivileged service do?

[Service]
Type=oneshot
User=sd3demo
ExecStart=/usr/local/bin/demo-hardening-sd3-probe.sh
StandardOutput=journal
EOF

cat > /etc/systemd/system/demo-hardening-sd3-root.service <<'EOF'
[Unit]
Description=Demo hardening: what may a root service do?

[Service]
Type=oneshot
ExecStart=/usr/local/bin/demo-hardening-sd3-probe.sh
StandardOutput=journal
EOF

cat > /etc/systemd/system/demo-hardening-sd3-dynamic.service <<'EOF'
[Unit]
Description=Demo hardening: dynamic user

[Service]
Type=oneshot
DynamicUser=yes
StateDirectory=demo-hardening-sd3-dynamic
ExecStart=/usr/bin/id -u
ExecStart=/usr/bin/id -un
ExecStart=/usr/bin/touch /var/lib/demo-hardening-sd3-dynamic/created-by-the-service
StandardOutput=journal
EOF

# Helper used by the following scripts: restart a unit, then print its own journal lines.
cat > /usr/local/bin/demo-hardening-sd3-run <<'EOF'
#!/bin/bash
# Restart a unit, then print only the lines this run wrote to the journal.
unit="$1"
since=$(date '+%Y-%m-%d %H:%M:%S')
systemctl daemon-reload
systemctl restart "$unit" 2>&1 | sed 's/^/restart: /' || true
sleep 1
journalctl -u "$unit" -o cat --no-pager --since "$since" | grep -vE '^(Starting |Finished |.*: Deactivated successfully)'
EOF
chmod 755 /usr/local/bin/demo-hardening-sd3-run

systemctl daemon-reload
sudo bash lab-setup.sh

L’assistant demo-hardening-sd3-run recharge systemd, redémarre une unité, puis affiche seulement les lignes de journal de cette exécution. Comme les unités sont de type oneshot, la sortie de la sonde arrive dans le journal, et l’assistant l’affiche.

Référence : un utilisateur dédié et un service root, sans durcissement

D’abord, lancez la sonde deux fois sans aucun durcissement. Une unité utilise le compte dédié. L’autre utilise l’identité par défaut, c’est-à-dire root.

sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-root.service
identity: uid=990 user=sd3demo groups=990
CapInh:	0000000000000000
CapPrm:	0000000000000000
CapEff:	0000000000000000
CapBnd:	000001ffffffffff
CapAmb:	0000000000000000
NoNewPrivs:	0
probe bind-80: refused
probe chown-to-root: refused
probe chmod-u+s: allowed
probe setuid-helper effective uid: 0

identity: uid=0 user=root groups=0
CapInh:	0000000000000000
CapPrm:	000001ffffffffff
CapEff:	000001ffffffffff
CapBnd:	000001ffffffffff
CapAmb:	0000000000000000
NoNewPrivs:	0
probe bind-80: allowed
probe chown-to-nobody: allowed
probe chmod-u+s: allowed
probe setuid-helper effective uid: 0

Lisez la sortie de haut en bas. D’abord, CapBnd est l’ensemble de limitation. La valeur 000001ffffffffff a 41 bits à 1, donc le service peut utiliser n’importe laquelle des 41 capacités de ce noyau. Ensuite, CapEff est ce que le processus peut utiliser tout de suite. Pour root, il égale l’ensemble complet, alors que pour l’utilisateur dédié il est vide.

Les sondes le confirment : le service root réussit les quatre tests, alors que l’utilisateur dédié ne peut ni lier le port 80 ni donner un fichier à root. Cependant, regardez les deux dernières lignes pour cet utilisateur. Poser le bit setuid sur son propre fichier est autorisé, car c’est normal pour un propriétaire de fichier. Pire, l’assistant appartenant à root annonce un UID effectif de 0. Un programme setuid rend donc root à un service censé être sans privilège. Les directives des capacités systemd ci-dessous servent à fermer cette brèche.

Choisir l’identité : User=, Group= et SupplementaryGroups=

La première étape de durcissement ne coûte rien : ne pas tourner en root. User= nomme le compte. Group= remplace son groupe primaire. SupplementaryGroups= ajoute des groupes, par exemple pour lire un répertoire de journaux. Le test suivant part du compte dédié et change les groupes.

d=/etc/systemd/system/demo-hardening-sd3-caps.service.d
sudo mkdir -p $d
printf '[Service]\nSupplementaryGroups=adm\n' | sudo tee $d/10-groups.conf
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service | head -1
printf '[Service]\nGroup=adm\n' | sudo tee $d/10-groups.conf
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service | head -1
sudo rm -rf $d && sudo systemctl daemon-reload
identity: uid=990 user=sd3demo groups=990
identity: uid=990 user=sd3demo groups=990 4
identity: uid=990 user=sd3demo groups=4

Ces trois lignes viennent de trois exécutions de la même unité. La première ligne est la référence de la section précédente, sans directive de groupe. La deuxième vient de la première exécution ci-dessus : SupplementaryGroups=adm a ajouté le groupe 4 à la liste. La troisième vient de la deuxième exécution ci-dessus, où Group=adm a remplacé le groupe primaire, donc le groupe 990 a disparu. La dernière commande supprime le drop-in, pour que les tests suivants repartent d’une base propre. La règle est simple : utilisez SupplementaryGroups= pour ajouter un accès, et Group= seulement quand le service doit posséder ses fichiers avec un autre groupe.

Voyons ensuite ce qui se passe si le compte n’existe pas. Comme l’utilisateur n’a jamais été créé, l’unité ci-dessous doit échouer.

[Service]
Type=oneshot
User=demo-hardening-sd3-nosuchuser
ExecStart=/usr/bin/true

Enregistrez-la sous /etc/systemd/system/demo-hardening-sd3-baduser.service, puis lancez sudo systemctl daemon-reload, sudo systemctl start demo-hardening-sd3-baduser.service et journalctl -u demo-hardening-sd3-baduser.service -o cat --no-pager -n 6.

[...]
Result=exit-code
ExecMainStatus=217
Starting demo-hardening-sd3-baduser.service...
demo-hardening-sd3-baduser.service: Failed to determine user credentials: No such process
demo-hardening-sd3-baduser.service: Failed at step USER spawning /usr/bin/true: No such process
demo-hardening-sd3-baduser.service: Main process exited, code=exited, status=217/USER
demo-hardening-sd3-baduser.service: Failed with result 'exit-code'.
Failed to start demo-hardening-sd3-baduser.service.

Le code de sortie est 217, et systemd nomme l’étape USER. Pourtant, le message dit No such process, qui ne mentionne pas un compte manquant. Donc, quand vous voyez status=217/USER, vérifiez que le compte existe avec getent passwd NOM.

DynamicUser= : un compte qui n’existe que pendant l’exécution

DynamicUser=yes (depuis systemd 232) va plus loin. Systemd crée un compte jetable au démarrage de l’unité, puis le libère à son arrêt. L’identifiant numérique vient d’une plage réservée, de 61184 à 65519. Le réglage active aussi plusieurs protections, donc c’est un choix solide pour les petits services. L’unité ci-dessous le combine avec StateDirectory=, qui donne au service un seul endroit où écrire.

[Service]
Type=oneshot
DynamicUser=yes
StateDirectory=demo-hardening-sd3-dynamic
ExecStart=/usr/bin/id -u
ExecStart=/usr/bin/id -un
ExecStart=/usr/bin/touch /var/lib/demo-hardening-sd3-dynamic/created-by-the-service
StandardOutput=journal
62604
demo-hardening-sd3-dynamic
--- state directory seen from the host
lrwxrwxrwx 1 root   root     34 Nov  2 14:57 /var/lib/demo-hardening-sd3-dynamic -> private/demo-hardening-sd3-dynamic
drwxr-xr-x 2 nobody nobody 4096 Nov  2 14:57 /var/lib/private/demo-hardening-sd3-dynamic
total 0
-rw-r--r-- 1 65534 65534 0 Nov  2 14:57 created-by-the-service
--- is the dynamic user in /etc/passwd after the run?
0
--- implied settings, as systemd reports them
DynamicUser=yes
RemoveIPC=yes
PrivateTmp=yes
ProtectHome=read-only
ProtectSystem=strict
NoNewPrivileges=yes
RestrictSUIDSGID=yes

Le service a tourné avec l’UID 62604, qui se trouve dans la plage documentée. De plus, le compte porte le nom de l’unité, et le nombre de lignes dans /etc/passwd est 0 : le compte n’existe jamais dans le fichier des mots de passe. Le répertoire d’état se trouve sous /var/lib/private, et /var/lib/demo-hardening-sd3-dynamic en est un lien symbolique.

Le dernier bloc montre ce que DynamicUser=yes active : RemoveIPC, PrivateTmp, ProtectHome=read-only, ProtectSystem=strict, NoNewPrivileges et RestrictSUIDSGID. Un détail surprend : vus depuis l’hôte, les fichiers appartiennent à nobody (UID 65534), alors que le service tournait avec 62604. Ce banc ne l’explique pas, et l’article ne devine pas.

AmbientCapabilities= : accorder un privilège à un service non-root

Un service sans privilège a parfois besoin d’exactement un privilège, et le cas classique est un serveur web sur le port 80. AmbientCapabilities= (depuis systemd 229) l’accorde. Le premier test accorde CAP_NET_BIND_SERVICE au compte dédié.

sudo mkdir -p /etc/systemd/system/demo-hardening-sd3-caps.service.d
sudo tee /etc/systemd/system/demo-hardening-sd3-caps.service.d/10-ambient.conf > /dev/null <<'EOF'
[Service]
AmbientCapabilities=CAP_NET_BIND_SERVICE
EOF
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service
identity: uid=990 user=sd3demo groups=990
CapInh:	0000000000000400
CapPrm:	0000000000000400
CapEff:	0000000000000400
CapBnd:	000001ffffffffff
CapAmb:	0000000000000400
NoNewPrivs:	0
probe bind-80: allowed
probe chown-to-root: refused
probe chmod-u+s: allowed
probe setuid-helper effective uid: 0

Le résultat correspond à l’objectif : le port 80 est maintenant autorisé, alors que le chown vers root reste refusé. La capacité ambiante apparaît dans quatre masques à la fois : CapInh, CapPrm, CapEff et CapAmb valent tous 0000000000000400. Cette valeur est le bit 10, soit CAP_NET_BIND_SERVICE. Mais la dernière ligne n’a pas bougé : l’assistant setuid renvoie toujours 0. Accorder une capacité ne supprime pas le chemin du retour vers root.

Ajoutez ensuite une deuxième capacité en écrasant le même fichier. Comme la liste est séparée par des espaces, la nouvelle valeur se lit facilement.

sudo mkdir -p /etc/systemd/system/demo-hardening-sd3-caps.service.d
sudo tee /etc/systemd/system/demo-hardening-sd3-caps.service.d/10-ambient.conf > /dev/null <<'EOF'
[Service]
AmbientCapabilities=CAP_NET_BIND_SERVICE CAP_CHOWN
EOF
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service
[...]
CapAmb:	0000000000000401
[...]
probe bind-80: allowed
probe chown-to-root: allowed
[...]

Le masque devient 0000000000000401. Le bit 0 est CAP_CHOWN, et la sonde chown réussit maintenant. Le masque est donc une image directe de votre liste, et vous pouvez le décoder à tout moment (voir la section sur l’inspection).

NoNewPrivileges= : fermer le chemin du retour vers root

NoNewPrivileges=yes (depuis systemd 187) pose le drapeau noyau no_new_privs sur le processus du service. Dès lors, le service et tout ce qu’il lance ne peuvent plus jamais gagner de privilèges via execve(). Les bits setuid et les capacités de fichier cessent de fonctionner. Le manuel précise que le drapeau ne couvre que les processus de l’unité et leurs enfants, pas les programmes lancés en son nom par at, crontab ou systemd-run.

Capacités systemd avec NoNewPrivileges=yes : un programme setuid ne change plus l'UID effectif
NoNewPrivileges=yes bloque le gain via un programme setuid.
sudo mkdir -p /etc/systemd/system/demo-hardening-sd3-caps.service.d
sudo tee /etc/systemd/system/demo-hardening-sd3-caps.service.d/20-nnp.conf > /dev/null <<'EOF'
[Service]
NoNewPrivileges=yes
EOF
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service
identity: uid=990 user=sd3demo groups=990
CapInh:	0000000000000401
CapPrm:	0000000000000401
CapEff:	0000000000000401
CapBnd:	000001ffffffffff
CapAmb:	0000000000000401
NoNewPrivs:	1
probe bind-80: allowed
probe chown-to-root: allowed
probe chmod-u+s: allowed
probe setuid-helper effective uid: 990

Deux choses ont changé. D’abord, NoNewPrivs vaut maintenant 1. Ensuite, l’assistant annonce un UID effectif de 990 au lieu de 0, donc le bit setuid ne fonctionne plus pour ce service. Pendant ce temps, les capacités ambiantes restent : le bind et le chown sont toujours autorisés. Les deux directives forment donc un couple. AmbientCapabilities= accorde le privilège, et NoNewPrivileges= empêche cette autorisation de grandir.

Notez le coût, car un service qui a besoin de sudo ou d’un autre assistant setuid cesse de fonctionner. Dans mon article précédent sur le durcissement systemd de services réels (à paraître le 17/09), le cas failsec le montre : un ensemble de limitation vide a bloqué sudo même avec NoNewPrivileges=false.

RestrictSUIDSGID= : interdire la création de fichiers setuid

L’assistant n’est plus dangereux, mais le service peut encore créer de nouveaux fichiers setuid. Un processus extérieur à l’unité pourrait ensuite les utiliser. RestrictSUIDSGID=yes (depuis systemd 242) s’appuie sur seccomp pour le refuser. Le défaut est désactivé, donc la directive est facultative.

sudo mkdir -p /etc/systemd/system/demo-hardening-sd3-caps.service.d
sudo tee /etc/systemd/system/demo-hardening-sd3-caps.service.d/30-suid.conf > /dev/null <<'EOF'
[Service]
RestrictSUIDSGID=yes
EOF
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-caps.service
identity: uid=990 user=sd3demo groups=990
CapInh:	0000000000200501
CapPrm:	0000000000000401
CapEff:	0000000000000401
CapBnd:	000001ffffffffff
CapAmb:	0000000000000401
NoNewPrivs:	1
probe bind-80: allowed
probe chown-to-root: allowed
probe chmod-u+s: refused
probe setuid-helper effective uid: 990

La sonde chmod-u+s est maintenant refusée. Avant cette étape, elle était autorisée, même avec les autres directives en place, parce qu’un propriétaire de fichier peut toujours poser le bit sur son fichier. Seule RestrictSUIDSGID= le bloque donc.

Une ligne mérite l’attention, car CapInh est passé de 0000000000000401 à 0000000000200501. Le décodage de la nouvelle valeur avec capsh --decode donne cap_chown,cap_setpcap,cap_net_bind_service,cap_sys_admin, donc deux bits supplémentaires sont apparus : cap_setpcap et cap_sys_admin. Les masques permis, effectif et ambiant n’ont pas changé. La documentation lue pour cet article ne l’explique pas. L’article rapporte l’observation sans deviner la cause.

CapabilityBoundingSet= : le plafond de tout le service

L’ensemble de limitation borne ce qu’un processus peut jamais détenir. Comme un service qui reste root possède toutes les capacités par défaut, cette directive compte surtout pour les services root parmi tous les réglages des capacités systemd. Les tests suivants utilisent donc l’unité root. D’abord, une liste simple nomme les capacités qui restent. Ensuite, une liste qui commence par ~ nomme les capacités à retirer. Enfin, une affectation vide retire tout.

Chaque test écrit le contenu indiqué dans 10-bounding.conf, dans le répertoire de drop-ins de l’unité root, remplace le contenu précédent, puis relance l’unité. Le premier test détaille les commandes.

d=/etc/systemd/system/demo-hardening-sd3-root.service.d
sudo mkdir -p $d
printf '[Service]\nCapabilityBoundingSet=\n' | sudo tee $d/10-bounding.conf
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-root.service
identity: uid=0 user=root groups=0
CapInh:	0000000000000000
CapPrm:	0000000000000000
CapEff:	0000000000000000
CapBnd:	0000000000000000
CapAmb:	0000000000000000
NoNewPrivs:	0
probe bind-80: refused
probe chown-to-nobody: refused
probe chmod-u+s: allowed
probe setuid-helper effective uid: 0

Avec un ensemble vide, le service tourne avec l’UID 0 mais ne détient rien. Le bind et le chown sont tous deux refusés. Le manuel décrit ce comportement pour l’affectation vide, et la sortie le confirme : les cinq masques qui comptent valent zéro. Un ~ seul, sans nom de capacité, désigne l’ensemble complet d’après le manuel, mais cette forme n’a pas été testée ici.

Gardez maintenant seulement la capacité dont le service a besoin, puis essayez la forme inversée.

[Service]
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
[...]
CapPrm:	0000000000000400
CapEff:	0000000000000400
CapBnd:	0000000000000400
[...]
probe bind-80: allowed
probe chown-to-nobody: refused
[...]
[Service]
CapabilityBoundingSet=~CAP_CHOWN
[...]
CapPrm:	000001fffffffffe
CapEff:	000001fffffffffe
CapBnd:	000001fffffffffe
[...]
probe bind-80: allowed
probe chown-to-nobody: refused
[...]
RéglageCapBndLier le port 80Chown
(rien)000001ffffffffffautoriséautorisé
CapabilityBoundingSet=0000000000000000refusérefusé
CapabilityBoundingSet=CAP_NET_BIND_SERVICE0000000000000400autorisérefusé
CapabilityBoundingSet=~CAP_CHOWN000001fffffffffeautorisérefusé

La forme en liste blanche (CAP_NET_BIND_SERVICE) est la plus sûre, car un futur noyau peut ajouter des capacités, et une liste blanche les ignore. La forme inversée se lit plus vite quand on veut seulement en retirer quelques-unes. L’outil systemd-analyze security affiche ses contrôles sous la forme inversée, par exemple CapabilityBoundingSet=~CAP_SYS_ADMIN.

Regardez aussi ce qui n’a pas changé dans toutes ces exécutions. La sonde chmod est restée autorisée, et l’assistant setuid a toujours annoncé l’UID 0. C’est parce qu’un ensemble de limitation retire des capacités, mais il ne retire pas l’identité de root, et il n’empêche pas un propriétaire de fichier d’utiliser les permissions de fichier.

L’ensemble de limitation et les capacités de fichier

Une capacité de fichier est une capacité stockée sur le programme, avec setcap. L’ensemble de limitation interagit avec elle, donc le test copie /usr/bin/true, donne à la copie cap_net_bind_service=ep, et la lance avec l’utilisateur dédié sous trois ensembles de limitation.

sudo cp /usr/bin/true /usr/local/bin/demo-hardening-sd3-filecap
sudo setcap cap_net_bind_service=ep /usr/local/bin/demo-hardening-sd3-filecap
getcap /usr/local/bin/demo-hardening-sd3-filecap
/usr/local/bin/demo-hardening-sd3-filecap cap_net_bind_service=ep
[Service]
Type=oneshot
User=sd3demo
ExecStart=/usr/local/bin/demo-hardening-sd3-filecap

Enregistrez ce fichier sous /etc/systemd/system/demo-hardening-sd3-filecap.service. Le cas A n’a aucun drop-in. Pour le cas B, écrivez CapabilityBoundingSet= (vide) dans le fichier demo-hardening-sd3-filecap.service.d/10.conf, et pour le cas C écrivez-y CapabilityBoundingSet=CAP_NET_BIND_SERVICE. À chaque fois, lancez sudo systemctl daemon-reload, puis sudo systemctl start demo-hardening-sd3-filecap.service, puis systemctl show -p Result -p ExecMainStatus demo-hardening-sd3-filecap.service.

--- A: no bounding set directive
Result=success
ExecMainStatus=0
--- B: CapabilityBoundingSet= (empty)
[...]
Result=exit-code
ExecMainStatus=203
demo-hardening-sd3-filecap.service: Failed at step EXEC spawning /usr/local/bin/demo-hardening-sd3-filecap: Operation not permitted
demo-hardening-sd3-filecap.service: Main process exited, code=exited, status=203/EXEC
demo-hardening-sd3-filecap.service: Failed with result 'exit-code'.
Failed to start demo-hardening-sd3-filecap.service.
--- C: CapabilityBoundingSet=CAP_NET_BIND_SERVICE
Result=success
ExecMainStatus=0

Dans le cas B, le programme ne démarre jamais : systemd annonce 203/EXEC et Operation not permitted. Le fichier réclame une capacité que le plafond interdit, donc le noyau refuse de l’exécuter. Dans le cas C, en revanche, le plafond autorise exactement cette capacité, et le programme s’exécute. Par conséquent, quand un service livre un binaire avec des capacités de fichier, lancez getcap dessus avant d’écrire l’ensemble de limitation. Dans mon article sur SFTPGo, retirer cap_net_bind_service de l’ensemble de limitation a provoqué une boucle de plantage environ toutes les 40 secondes, et getcap a révélé la cause.

SecureBits= et PAMName=

SecureBits= règle des drapeaux du noyau qui changent l’interaction entre l’UID 0 et les capacités. La page systemd.exec liste les noms des drapeaux, et le sens côté noyau figure dans capabilities(7). Le test ci-dessous applique deux d’entre eux à l’unité root, puis observe le résultat. Il n’affirme rien de plus que ce que la sortie montre.

d=/etc/systemd/system/demo-hardening-sd3-root.service.d
sudo rm -f $d/10-bounding.conf
printf '[Service]\nSecureBits=noroot\n' | sudo tee $d/20-securebits.conf
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-root.service
printf '[Service]\nSecureBits=keep-caps\n' | sudo tee $d/20-securebits.conf
sudo /usr/local/bin/demo-hardening-sd3-run demo-hardening-sd3-root.service
sudo rm -rf $d && sudo systemctl daemon-reload
[...]
CapPrm:	0000000000000000
CapEff:	0000000000000000
CapBnd:	000001ffffffffff
[...]
probe bind-80: refused
[...]

[...]
CapPrm:	000001ffffffffff
CapEff:	000001ffffffffff
CapBnd:	000001ffffffffff
[...]
probe bind-80: allowed
[...]

Avec SecureBits=noroot, le service root démarre avec des ensembles permis et effectif vides, bien que l’ensemble de limitation reste complet. La sonde bind est refusée. En revanche, avec SecureBits=keep-caps, la sortie égale la référence pour un service qui tourne déjà en root. En résumé, le second drapeau n’a aucun effet dans ce test, et l’effet du premier est visible. Pour la plupart des services, vous n’aurez besoin ni de l’un ni de l’autre.

PAMName= n’a pas été testé. Elle rattache le service à une session PAM, et le laboratoire n’a aucun service PAM à observer, donc l’article ne donne aucun résultat pour elle.

Ouvrir un port bas sans root : trois conceptions

Lier un port inférieur à 1024 est la raison la plus courante de tourner en root. Trois conceptions le résolvent, et l’image ci-dessous les compare. Parmi les options des capacités systemd, la conception du milieu est celle à apprendre en premier.

Capacités systemd et ports inférieurs à 1024 : root, utilisateur dédié avec une capacité, ou reverse proxy
Trois façons de servir le port 80, du privilège le plus large à aucun.
  • Conception A, root : simple, mais le service détient toutes les capacités. C’est la référence du laboratoire.
  • Conception B, utilisateur dédié avec une capacité : User=, AmbientCapabilities=CAP_NET_BIND_SERVICE, CapabilityBoundingSet=CAP_NET_BIND_SERVICE et NoNewPrivileges=yes. C’est la combinaison testée plus haut.
  • Conception C, port haut derrière un reverse proxy : le service écoute sur un port comme 8080, et le proxy possède le port 80. Le service n’a besoin d’aucune capacité.

La conception C supprime le besoin de toute capacité, donc choisissez-la quand un proxy existe déjà. Sans proxy, la conception B convient. Dans mon article précédent, le serveur de messagerie mox suit la conception B : NoNewPrivileges=true avec AmbientCapabilities=CAP_NET_BIND_SERVICE CAP_SETUID CAP_SETGID CAP_CHOWN. Quand j’ai retiré CAP_DAC_OVERRIDE, le service a eu besoin de CAP_DAC_READ_SEARCH et de SupplementaryGroups=mox pour continuer à lire ses fichiers. Etherpad, enfin, montre l’extrémité minimale : un utilisateur dédié, aucune capacité, et un niveau d’exposition de 1,5.

Lire le résultat : cinq façons d’inspecter les capacités systemd

Ne faites jamais confiance à un drop-in avant d’avoir lu ce que systemd a chargé. Ces cinq contrôles fonctionnent donc sur n’importe quelle unité, et chacun répond à une question différente.

1. systemctl show

Le premier contrôle lit les propriétés que systemd détient pour l’unité. La page de manuel de systemctl ne promet pas que les réglages d’exécution y figurent, mais dans ce test ils y sont.

systemctl show -p User -p SupplementaryGroups -p CapabilityBoundingSet -p AmbientCapabilities -p NoNewPrivileges -p RestrictSUIDSGID -p SecureBits demo-hardening-sd3-caps.service
SecureBits=0
CapabilityBoundingSet=cap_net_bind_service
AmbientCapabilities=cap_net_bind_service
User=sd3demo
SupplementaryGroups=
NoNewPrivileges=yes
RestrictSUIDSGID=yes

Les noms reviennent en minuscules, et une valeur vide signifie que le réglage est absent. Notez que SecureBits=0 apparaît bien que AmbientCapabilities= soit défini. Je n’ai pas creusé ce point.

2. systemd-analyze capability

Le deuxième contrôle liste les noms de capacités avec leur numéro, ou les filtre.

systemd-analyze capability cap_net_bind_service cap_chown

NAME                 NUMBER
cap_chown                 0
cap_net_bind_service     10

3. Décoder un masque

Pour transformer un masque de /proc en noms, donnez-le à systemd-analyze capability -m ou à capsh --decode.

systemd-analyze capability -m 0000000000000401

NAME                 NUMBER
cap_chown                 0
cap_net_bind_service     10

capsh --decode=0000000000000401

0x0000000000000401=cap_chown,cap_net_bind_service

4. Le processus lui-même

Le contrôle le plus fiable lit le processus vivant. D’abord, une unité transitoire, lancée par systemd-run, dort pendant deux minutes. Ensuite, le test lit son fichier d’état et lance getpcaps.

sudo systemd-run --unit=demo-hardening-sd3-sleep -p User=sd3demo -p AmbientCapabilities=CAP_NET_BIND_SERVICE -p NoNewPrivileges=yes /usr/bin/sleep 120
pid=$(systemctl show -p MainPID --value demo-hardening-sd3-sleep.service)
grep -E '^(CapInh|CapPrm|CapEff|CapBnd|CapAmb|NoNewPrivs):' /proc/$pid/status
getpcaps $pid
CapInh:	0000000000000400
CapPrm:	0000000000000400
CapEff:	0000000000000400
CapBnd:	000001ffffffffff
CapAmb:	0000000000000400
NoNewPrivs:	1
--- getpcaps
6192: cap_net_bind_service=eip

Dans la sortie de getpcaps, cap_net_bind_service=eip signifie que la capacité est à la fois effective, héritable et permise.

5. systemd-analyze security

Le dernier contrôle est le score. Comme la même unité obtient un score différent avec et sans les quatre directives de cet article, les chiffres montrent leur effet.

[sans le drop-in]
→ Overall exposure level for demo-hardening-sd3-caps.service: 9.2 UNSAFE 😨

[avec User=, AmbientCapabilities=CAP_NET_BIND_SERVICE, CapabilityBoundingSet=CAP_NET_BIND_SERVICE,
 NoNewPrivileges=yes et RestrictSUIDSGID=yes]
→ Overall exposure level for demo-hardening-sd3-caps.service: 6.5 MEDIUM 😐

Le niveau d’exposition passe de 9.2 UNSAFE à 6.5 MEDIUM avec ces seules directives. Le reste du score dépend du système de fichiers, du noyau et des appels système, que couvrent les parties 2, 4, 5, 6 et 7. Voici quelques lignes du second rapport :

[...]
✓ User=/DynamicUser=                                          Service runs under a static non-root user identity
✓ NoNewPrivileges=                                            Service processes cannot acquire new privileges
✗ AmbientCapabilities=                                        Service process receives ambient capabilities                           0.1
✓ SupplementaryGroups=                                        Service has no supplementary groups
✓ CapabilityBoundingSet=~CAP_SYS_ADMIN                        Service has no administrator privileges
✗ CapabilityBoundingSet=~CAP_NET_(BIND_SERVICE|BROADCAST|RAW) Service has elevated networking privileges                              0.1
✓ CapabilityBoundingSet=~CAP_SET(UID|GID|PCAP)                Service cannot change UID/GID identities/capabilities
✓ RestrictSUIDSGID=                                           SUID/SGID file creation by service is restricted
[...]
→ Overall exposure level for demo-hardening-sd3-caps.service: 6.5 MEDIUM 😐

Deux lignes coûtent 0.1 chacune : AmbientCapabilities= et les capacités réseau. C’est le prix du seul privilège dont le service a vraiment besoin, et ce prix est faible.

Drop-ins complets à copier

Utilisez ces drop-ins pour les capacités systemd comme point de départ. D’abord, remplacez app01 et appuser par vos propres noms. Le premier drop-in est la combinaison mesurée plus haut. Gardez aussi les commentaires, car ils aident la personne qui relira le fichier.

Drop-in 1 : un utilisateur dédié avec un seul privilège

sudo useradd --system --no-create-home --shell /usr/sbin/nologin appuser

sudo mkdir -p /etc/systemd/system/app01.service.d
sudo tee /etc/systemd/system/app01.service.d/10-privileges.conf > /dev/null <<'EOF'
[Service]
# Identité : jamais root.
User=appuser
# Accorder : le seul privilège dont ce service a besoin (lier les ports inférieurs à 1024).
AmbientCapabilities=CAP_NET_BIND_SERVICE
# Limiter : rien d'autre ne peut jamais être détenu, même via une capacité de fichier.
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
# Bloquer : aucun gain via les bits setuid ou les capacités de fichier.
NoNewPrivileges=yes
# Bloquer : le service ne peut pas créer de fichiers setuid ou setgid.
RestrictSUIDSGID=yes
EOF

sudo systemctl daemon-reload
sudo systemctl restart app01.service
systemd-analyze security app01.service | tail -1

Drop-in 2 : aucun compte fixe

sudo mkdir -p /etc/systemd/system/app01.service.d
sudo tee /etc/systemd/system/app01.service.d/10-privileges.conf > /dev/null <<'EOF'
[Service]
# Identité : un compte temporaire, créé au démarrage et libéré à l'arrêt.
DynamicUser=yes
# Le seul endroit où le service peut écrire (devient /var/lib/app01).
StateDirectory=app01
# DynamicUser=yes implique déjà NoNewPrivileges et RestrictSUIDSGID.
EOF

sudo systemctl daemon-reload
sudo systemctl restart app01.service

Drop-in 3 : un service qui doit rester root

sudo mkdir -p /etc/systemd/system/app01.service.d
sudo tee /etc/systemd/system/app01.service.d/10-privileges.conf > /dev/null <<'EOF'
[Service]
# Le service tourne toujours en root, mais il ne garde qu'une capacité.
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
NoNewPrivileges=yes
EOF

sudo systemctl daemon-reload
sudo systemctl restart app01.service

Parmi ces trois drop-ins, le laboratoire a mesuré le premier en entier. Le deuxième a été testé pour le compte, le répertoire d’état et les réglages impliqués. Le troisième a été testé pour l’ensemble de limitation seulement, sans NoNewPrivileges=yes. Lisez toujours systemctl show après un changement, puis testez le vrai service.

Erreurs courantes avec les capacités systemd

Ces erreurs viennent du laboratoire lui-même, donc chacune a une vraie sortie.

Une faute dans un nom de capacité reste silencieuse

L’unité ci-dessous orthographie mal le nom, avec un S en trop.

[Service]
AmbientCapabilities=CAP_NET_BIND_SERVICES
AmbientCapabilities=
Result=success
ExecMainStatus=0
--- journal search for the misspelled name (whole boot)
(end of journal search)
--- systemd-analyze verify
verify exit code: 0

Systemd charge l’unité sans aucun message. La propriété est simplement vide, et l’unité démarre avec Result=success. Une recherche du mauvais nom dans tout le journal du démarrage ne trouve rien, et systemd-analyze verify n’affiche rien et sort avec le code 0. Le seul signe visible est la propriété vide. Lancez donc toujours systemctl show -p AmbientCapabilities UNITE après une modification. En revanche, la forme en minuscules cap_net_bind_service est acceptée.

Un drop-in sans l’en-tête [Service]

AmbientCapabilities=
/etc/systemd/system/demo-hardening-sd3-caps.service.d/10-noheader.conf:1: Assignment outside of section. Ignoring.
/etc/systemd/system/demo-hardening-sd3-caps.service.d/10-noheader.conf:1: Assignment outside of section. Ignoring.

L’avertissement est clair : Assignment outside of section. Ignoring. Il est apparu deux fois dans le journal. Il n’est apparu qu’après daemon-reload et après le chargement de l’unité par un systemctl show, donc lancez une commande qui charge l’unité avant de chercher dans le journal.

Un fichier de drop-in qui ne se termine pas par .conf

Le fichier 10-ambient.txt a été ignoré, car AmbientCapabilities= est resté vide. En revanche, le journal n’a pas été examiné pour ce cas.

Autres erreurs aux symptômes clairs

  • Compte absent : status=217/USER et le texte étrange No such process (vu plus haut).
  • Ensemble de limitation vide avec un binaire à capacité de fichier : status=203/EXEC et Operation not permitted (vu plus haut).
  • Capacité ambiante sans NoNewPrivileges=yes : l’assistant setuid renvoie toujours l’UID 0 (étape A).
  • Trop de durcissement sur un service qui appelle sudo : il échoue avec NoNewPrivileges=yes ou un ensemble de limitation vide.
  • Un systemctl daemon-reload oublié : systemd garde l’ancienne unité, et le nouveau fichier semble ne rien faire.

Checklist finale pour les capacités systemd

  1. Le service a-t-il besoin de root ? Sinon, définissez User= (ou DynamicUser=yes).
  2. A-t-il besoin d’un privilège ? Nommez exactement une capacité dans AmbientCapabilities=.
  3. Le plafond est-il posé ? Écrivez la même liste dans CapabilityBoundingSet=.
  4. NoNewPrivileges=yes est-il posé, et le service fonctionne-t-il sans sudo ?
  5. RestrictSUIDSGID=yes est-il posé, sauf si le service crée des fichiers setuid volontairement ?
  6. Un binaire du service porte-t-il des capacités de fichier ? Lancez getcap avant de fixer le plafond.
  7. Après chaque modification, lancez systemctl daemon-reload, puis systemctl show -p pour chaque directive.
  8. Lisez le processus vivant : /proc/PID/status et getpcaps.
  9. Mesurez avec systemd-analyze security et gardez le chiffre dans la fiche de changement.

Ce que ce laboratoire n’a pas testé

  • PAMName= n’a pas été testé.
  • SELinux n’est pas disponible sur le banc, donc l’interaction entre les capacités systemd et la politique SELinux sort du cadre de cet article.
  • Un CapabilityBoundingSet=~ seul (l’ensemble complet, d’après le manuel) n’a pas été testé.
  • SecureBits= n’a été observé que sur un service root. Ses drapeaux n’ont pas été testés avec User=.
  • Les bits supplémentaires de CapInh après RestrictSUIDSGID=yes sont une observation sans explication.
  • La propriété du répertoire d’état de l’utilisateur dynamique (UID 65534 vu de l’hôte) est une observation sans explication.
  • Les résultats viennent d’un noyau WSL2, donc un noyau natif peut différer.

Nettoyer le laboratoire

Lancez le script ci-dessous en root. Il supprime seulement les unités, drop-ins, fichiers et le compte que le laboratoire a créés.

for u in demo-hardening-sd3-caps demo-hardening-sd3-root demo-hardening-sd3-dynamic demo-hardening-sd3-baduser demo-hardening-sd3-filecap demo-hardening-sd3-sleep; do
  systemctl stop "$u.service" 2>/dev/null
  systemctl reset-failed "$u.service" 2>/dev/null
  rm -rf "/etc/systemd/system/$u.service" "/etc/systemd/system/$u.service.d"
done
rm -f /usr/local/bin/demo-hardening-sd3-probe.sh /usr/local/bin/demo-hardening-sd3-setuid-id /usr/local/bin/demo-hardening-sd3-run /usr/local/bin/demo-hardening-sd3-filecap
rm -rf /var/lib/demo-hardening-sd3-dynamic /var/lib/private/demo-hardening-sd3-dynamic
id sd3demo >/dev/null 2>&1 && userdel sd3demo
systemctl daemon-reload
ls -d /etc/systemd/system/*sd3* /usr/local/bin/*sd3* /var/lib/*sd3* 2>/dev/null; getent passwd sd3demo

Les deux dernières commandes ne doivent rien afficher, et c’était le cas sur le banc de test après le nettoyage.

Sources

  • systemd.exec(5) : les directives User=, DynamicUser=, NoNewPrivileges=, CapabilityBoundingSet=, AmbientCapabilities=, SecureBits=, RestrictSUIDSGID=.
  • capabilities(7) : la liste des capacités et les règles de chaque ensemble.
  • systemd-analyze(1) : les commandes security et capability.

Plus tôt dans la série

Articles liés

Serveurs DNS MikroTik avant et après : un second résolveur public contourne Pi-hole, un seul serveur garde le filtre

Pas à pas : changer les serveurs DNS d’un routeur MikroTik sans contourner Pi-hole

Pour changer les serveurs DNS de MikroTik, j’ai remplacé la liste de deux résolveurs de mon routeur par un seul : mon Pi-hole. Le routeur répond aux requêtes DNS de mes pairs WireGuard et des clients IPv6 de mon réseau local, donc un second résolveur public dans sa liste laissait passer des domaines filtrés. Voici la procédure que je suis, étape par étape, avec le mode sûr de RouterOS comme filet de sécurité.

Réponse rapide — faire résoudre un routeur RouterOS 7 uniquement par Pi-hole.

# Dans un terminal Winbox ou en SSH, appuyez d'abord sur Ctrl+X (mode sûr)
/ip dns set servers=192.168.88.19
/ip dns cache flush
/ip dns print
# Testez depuis un poste du LAN, puis appuyez de nouveau sur Ctrl+X pour garder le changement

Les détails, les explications et les vérifications suivent plus bas. Les adresses sont des exemples.

Pourquoi un second résolveur casse le filtre

Mon routeur n’est pas seulement une passerelle. Il répond aussi aux requêtes DNS de deux groupes de clients. D’abord, les pairs WireGuard : mon téléphone utilise une interface WireGuard, et mes serveurs en utilisent une autre. Ensuite, les clients IPv6 du réseau local, parce que le routeur se déclare comme leur serveur DNS dans les annonces de routeur (/ipv6 nd avec advertise-dns=yes).

Jusqu’en octobre 2026, la liste des serveurs DNS de MikroTik contenait mon Pi-hole et Quad9 (servers=192.168.88.19,9.9.9.9). À cause de cette seconde entrée, les domaines que Pi-hole bloque étaient résolus par Quad9, donc le filtrage était contourné. La correction est simple : ne laisser que le Pi-hole dans la liste.

Serveurs DNS MikroTik avant et après : un second résolveur public contourne Pi-hole, un seul serveur garde le filtre
Avant, le routeur avait deux résolveurs et le second contournait le filtre. Après, il n’a plus que le Pi-hole.

Avant de commencer

  • Un routeur sous RouterOS 7. Le mien n’est pas géré par Ansible.
  • Une copie récente de sa configuration. La mienne vient d’une sauvegarde nocturne de la configuration du routeur.
  • Un terminal sur le routeur : un nouveau terminal Winbox, ou SSH avec admin.
  • L’adresse de votre Pi-hole. Dans cet article, le routeur est 192.168.88.1 et le Pi-hole 192.168.88.19, des valeurs d’exemple.

Ensuite, apprenez le mode sûr (Safe Mode), car il vous protège si vous coupez votre propre accès. Dans le terminal, vous appuyez sur Ctrl+X pour l’activer. Tant qu’il est actif, RouterOS suit vos changements. Si la connexion tombe, le routeur les annule, et la documentation de RouterOS indique que cela arrive après le délai TCP, qu’elle donne à 9 minutes. Quand tout fonctionne, vous appuyez de nouveau sur Ctrl+X pour quitter le mode sûr et garder les changements.

Étape 1 : entrer en mode sûr

Ouvrez le terminal et appuyez sur Ctrl+X. À partir de là, une session coupée annule tout.

Étape 2 : changer les serveurs DNS de MikroTik

Lancez les quatre commandes ci-dessous. La première fixe l’unique serveur, puis la deuxième vide le cache pour que le routeur cesse de répondre avec les anciennes entrées. La troisième affiche le résultat. La dernière vérifie que le client DHCP du WAN n’ajoute aucun serveur DNS du fournisseur.

# Seul le Pi-hole répond désormais
/ip dns set servers=192.168.88.19
# Vider le cache DNS du routeur
/ip dns cache flush
# Afficher le résultat
/ip dns print
# Le client DHCP du WAN ne doit pas ajouter de DNS du fournisseur (cherchez use-peer-dns=no)
/ip dhcp-client print detail where interface=<votre-interface-wan>

Étape 3 : tester depuis un poste du LAN

Avant de quitter le mode sûr, interrogez le routeur depuis une autre machine. Trois réponses montrent que la chaîne fonctionne.

# Un domaine bloqué par Pi-hole : 0.0.0.0 signifie que la requête est passée par Pi-hole
dig +short doubleclick.net @192.168.88.1
# Un domaine normal : une vraie adresse
dig +short example.com @192.168.88.1
# Le nom d'un de mes pairs WireGuard : le routeur sait toujours le résoudre
dig +short peer01.example.net @192.168.88.1

Si le domaine bloqué renvoie une vraie adresse, le filtre est toujours contourné, donc restez en mode sûr et relisez la liste. Si le troisième nom échoue, le routeur a perdu le lien avec ses pairs, donc ne gardez pas le changement.

Étape 4 : garder le changement

Quand les trois tests passent, appuyez de nouveau sur Ctrl+X. RouterOS quitte le mode sûr et garde vos changements.

Étape 5 : confirmer le lendemain matin

Le lendemain matin, j’ouvre la sauvegarde nocturne de la configuration du routeur. Elle montre la nouvelle section /ip dns, ce qui prouve que le changement a tenu et qu’il est archivé.

Si quelque chose se passe mal

  • Si votre session tombe pendant le changement, le routeur annule tout seul, grâce au mode sûr.
  • Si le Pi-hole tombe, le routeur ne résout plus rien de nouveau. Les tunnels WireGuard existants survivent.
  • Le bon plan de secours est un second Pi-hole, jamais un résolveur public, car un résolveur public ramène le contournement.

Ce que j’en retiens

  • Un routeur qui répond au DNS pour d’autres clients doit suivre le même filtre que le réseau local.
  • Vérifiez les serveurs DNS de MikroTik de chaque routeur qui relaie des requêtes, pas seulement ceux des clients.
  • Utilisez le mode sûr pour tout changement à distance, et testez avant d’appuyer sur Ctrl+X la seconde fois.

Sources

Articles liés

Répertoires de données de Cassandra : commitlog, data, hints et saved_caches, avec les huit fichiers d’une SSTable

Dans les fichiers d’une base de données (5/3+2) : Cassandra

Les trois premières parties de cette série ont regardé des moteurs qui modifient des pages de taille fixe sur place, ou à côté de leurs anciennes versions. Apache Cassandra prend une autre route : il ne modifie jamais un fichier. Chaque écriture finit dans une SSTable Cassandra, un fichier trié, écrit une fois et jamais changé. Cette partie bonus (5/3+2 dans la numérotation de la série, après SQLite) ouvre un vrai nœud pour montrer ce que cela donne sur le disque.

Je ne fais pas tourner Cassandra chez moi. Tout ce qui suit vient d’un laboratoire à un nœud monté pour ce billet (Rocky Linux 10.2 sous WSL2, Apache Cassandra 5.0.9, Java 17.0.21 de Temurin) et de la documentation d’Apache. Les sorties sont réelles : je coupe seulement des lignes, et je marque chaque coupure par [...]. Avec un seul nœud, il n’y a ni réplication, ni réparation, ni streaming : je dis quand cela compte.

Le répertoire de données de Cassandra

Répertoires de données de Cassandra : commitlog, data, hints et saved_caches, avec les huit fichiers d’une SSTable
Les répertoires d’un nœud Cassandra et les fichiers d’une SSTable.

Un nœud range ses fichiers dans quatre répertoires. Leur emplacement vient de cassandra.yaml, et l’installation par archive les place sous data/.

  • commitlog/ : le journal des commits, découpé en segments de 32 Mio, la valeur par défaut documentée. Un nœud neuf en avait déjà deux, de 33 554 432 octets chacun.
  • data/ : les SSTables. L’arborescence est data/<keyspace>/<table>-<identifiant de table>/. Ma table s’est retrouvée dans demo/readings-b5b8f990…. Les keyspaces système (system, system_schema…) sont à côté et utilisent le même format.
  • hints/ : l’endroit où les écritures attendent un nœud en panne. La référence le relie à max_hint_window, la durée pendant laquelle un hôte mort reçoit des hints. Il est resté vide.
  • saved_caches/ : les caches de clés, de lignes et de compteurs, sauvegardés pour qu’un redémarrage ne reparte pas à froid. Vide aussi.

Dans les parties précédentes, une base de données était un répertoire. Ici, un keyspace est un répertoire, et chaque table est un répertoire à l’intérieur, avec un long suffixe qui identifie la table.

Le chemin d’écriture : journal des commits, memtable, flush

Chemin d’écriture de Cassandra : journal des commits et memtable, flush vers des SSTables immuables, puis compactage
Une écriture va au journal et à la memtable ; les flushs créent des SSTables.

Une écriture va à deux endroits. D’abord le journal des commits : Cassandra ajoute le changement à un segment sur disque, pour qu’il survive à un crash. Ensuite la memtable, une structure triée en mémoire, en général une par table. Par défaut, le journal est synchronisé toutes les 10 secondes (commitlog_sync: periodic, commitlog_sync_period: 10000ms), donc une écriture est acquittée avant d’être sur le disque. L’alternative, batch, attend la synchronisation.

Dans le labo, j’ai inséré sept lignes dans une table neuve et j’ai regardé avant le flush. Le répertoire de la table était vide. Sept cellules étaient dans la memtable, et le journal des commits tenait leur seule copie sur disque :

SSTable count: 0
Old SSTable count: 0
Memtable cell count: 7
Memtable data size: 367
Memtable switch count: 0

Le journal des commits n’est pas compressé tant qu’on ne le demande pas, donc les clés sont lisibles dans un segment. J’ai regardé avec strings :

strings CommitLog-7-*.log | grep -E "sensor-[abc]" | head -5
sensor-a
sensor-a
sensor-a
sensor-b
sensor-b

Un flush transforme la memtable en SSTable. Chaque SSTable Cassandra naît d’un flush. Il se déclenche quand la mémoire manque, quand le journal approche de sa limite, ou à la demande. J’ai lancé nodetool flush demo readings et huit fichiers sont apparus :

ls -l | awk '{print $5, $9}'
47 nb-1-big-CompressionInfo.db
123 nb-1-big-Data.db
10 nb-1-big-Digest.crc32
16 nb-1-big-Filter.db
36 nb-1-big-Index.db
4855 nb-1-big-Statistics.db
68 nb-1-big-Summary.db
92 nb-1-big-TOC.txt

Après le flush, les deux segments du journal étaient toujours là. La documentation dit qu’un segment ne peut être supprimé ou recyclé qu’une fois toutes ses données écrites dans des SSTables, et les segments sont partagés entre toutes les tables : je n’en ai donc vu aucun disparaître.

Anatomie d’une SSTable Cassandra

Les huit composants d’une SSTable Cassandra et l’ordre dans lequel une lecture les utilise
Tailles des composants dans le labo, et les quatre étapes d’une lecture.

Une SSTable Cassandra est un ensemble de fichiers qui partagent un préfixe. Dans le labo, nb-1-big- se lit comme une version de format (nb), un numéro de génération et le nom du format (big, celui par défaut). La documentation n’explicite pas ce motif : c’est ma lecture des noms. Elle décrit aussi un format à base de trie dont l’index vit dans Partitions.db et Rows.db à la place de Index.db ; je ne l’ai pas testé. Le fichier TOC.txt liste les composants :

cat nb-1-big-TOC.txt
CompressionInfo.db
Data.db
Digest.crc32
Filter.db
Index.db
Statistics.db
Summary.db
TOC.txt
  • Data.db (123 octets) : les lignes, groupées par partition et compressées par blocs. Le compresseur par défaut est LZ4, et le taux de compression était de 0,68.
  • Index.db (36 octets) : les clés de partition et leurs positions dans Data.db.
  • Summary.db (68 octets) : un échantillon de l’index, une entrée sur 128 par défaut.
  • Filter.db (16 octets) : le filtre de Bloom des clés de partition.
  • CompressionInfo.db (47 octets) : les positions et les tailles des blocs compressés.
  • Statistics.db (4 855 octets) : des métadonnées comme les horodatages, les tombstones et les TTL. C’est le plus gros fichier ici, et sstablemetadata en tire des histogrammes.
  • Digest.crc32 (10 octets) : une empreinte CRC-32 de Data.db.

Une lecture ne parcourt pas ces fichiers. Pour une clé de partition, Cassandra interroge d’abord le filtre de Bloom. Une réponse négative est définitive, alors qu’une réponse positive peut être fausse (la probabilité de faux positif de la table était de 0,01). Ensuite il réduit la recherche avec le résumé, trouve la position exacte dans l’index, et décompresse le bloc. Après deux flushs, nodetool getsstables indique quels fichiers peuvent contenir une clé :

nodetool getsstables demo readings sensor-a
data/data/demo/readings-b5b8f990d6fb11f197b7370581990151/nb-1-big-Data.db
data/data/demo/readings-b5b8f990d6fb11f197b7370581990151/nb-2-big-Data.db

Partitions, lignes et cellules dans Data.db

Dans une SSTable Cassandra : positions de Index.db et disposition des partitions, lignes et cellules de Data.db
Index.db et Data.db lus avec hexdump et sstabledump.

Dans Data.db, les lignes sont groupées par partition. Les partitions se suivent dans l’ordre des tokens, le hachage de la clé de partition, et les lignes d’une partition suivent la clé de clustering. C’est pourquoi mes trois capteurs ne sont pas dans l’ordre alphabétique : sensor-b vient d’abord, puis sensor-c, puis sensor-a. sstabledump affiche une partition ainsi :

sstabledump nb-1-big-Data.db
[
  {
    "partition" : {
      "key" : [ "sensor-b" ],
      "position" : 22
    },
    "rows" : [
      {
        "type" : "row",
        "position" : 22,
        "clustering" : [ 1 ],
        "liveness_info" : { "tstamp" : "2026-11-02T20:26:44.439221Z" },
        "cells" : [
          { "name" : "temp", "value" : 15 }
        ]
      },
      {
        "type" : "row",
        "position" : 37,
        "clustering" : [ 2 ],
        "liveness_info" : { "tstamp" : "2026-11-02T20:26:44.441834Z" },
        "cells" : [
          { "name" : "temp", "value" : 16 }
        ]
      }
    ]
  },
  [...]
]

Chaque ligne porte l’horodatage de son INSERT dans liveness_info, et chaque cellule peut porter le sien. L’outil de métadonnées confirme l’ordre des tokens, la compression et l’absence de tombstones :

sstablemetadata nb-1-big-Data.db
Partitioner: org.apache.cassandra.dht.Murmur3Partitioner
Bloom Filter FP chance: 0.01
Compressor: org.apache.cassandra.io.compress.LZ4Compressor
Compression ratio: 0.68
First token: -2257014703785893100 (sensor-b)
Last token: 6459236691210746121 (sensor-a)
Covered clusterings: [1, 3]
Estimated droppable tombstones: 0.0
totalRows: 7

Le fichier d’index est assez petit pour se lire à la main :

xxd nb-1-big-Index.db
00000000: 0008 7365 6e73 6f72 2d62 0000 0008 7365  ..sensor-b....se
00000010: 6e73 6f72 2d63 3500 0008 7365 6e73 6f72  nsor-c5...sensor
00000020: 2d61 6c00                                -al.

Chaque entrée est une longueur sur deux octets (0008), la clé, une position et un zéro. Les positions sont 00, 35 et 6c : 0, 53 et 108 dans le flux de données non compressé. sstabledump indique 22, 75 et 130 pour la première ligne de chaque partition, soit 22 octets après chaque début. Cela correspond à un en-tête fait d’une longueur de clé sur deux octets, de la clé sur huit octets et d’une date de suppression sur douze octets. La documentation ne décrit pas la disposition des octets de Data.db : prenez ce décodage pour ma lecture de la sortie, pas pour une spécification.

Un UPDATE ou un DELETE est une nouvelle écriture

Rien dans une SSTable Cassandra n’est jamais modifié. Pour le voir, j’ai changé une valeur, ajouté une ligne, supprimé une ligne, supprimé une partition entière, puis refait un flush :

UPDATE demo.readings SET temp = 25 WHERE device='sensor-a' AND ts=2;
INSERT INTO demo.readings (device, ts, temp) VALUES ('sensor-a', 4, 23);
DELETE FROM demo.readings WHERE device='sensor-b' AND ts=2;
DELETE FROM demo.readings WHERE device='sensor-c';

La deuxième SSTable, nb-2, ne contient que ces changements. La mise à jour est une cellule avec son propre horodatage, et les suppressions sont des tombstones, un pour une ligne et un pour une partition entière :

sstabledump nb-2-big-Data.db
[
  {
    "partition" : {
      "key" : [ "sensor-b" ],
      "position" : 22
    },
    "rows" : [
      {
        "type" : "row",
        "position" : 22,
        "clustering" : [ 2 ],
        "deletion_info" : { "marked_deleted" : "2026-11-02T20:27:29.783855Z", "local_delete_time" : "2026-11-02T20:27:29Z" },
        "cells" : [ ]
      }
    ]
  },
  {
    "partition" : {
      "key" : [ "sensor-c" ],
      "position" : 57,
      "deletion_info" : { "marked_deleted" : "2026-11-02T20:27:29.787731Z", "local_delete_time" : "2026-11-02T20:27:29Z" }
    },
    "rows" : [ ]
  },
  {
    "partition" : {
      "key" : [ "sensor-a" ],
      "position" : 80
    },
    "rows" : [
      {
        "type" : "row",
        "position" : 80,
        "clustering" : [ 2 ],
        "cells" : [
          { "name" : "temp", "value" : 25, "tstamp" : "2026-11-02T20:27:29.773920Z" }
        ]
      },
      {
        "type" : "row",
        "position" : 94,
        "clustering" : [ 4 ],
        "liveness_info" : { "tstamp" : "2026-11-02T20:27:29.779577Z" },
        "cells" : [
          { "name" : "temp", "value" : 23 }
        ]
      }
    ]
  }
]

Les anciennes valeurs, 21 et 16 et les lignes de sensor-c, sont toujours dans nb-1, intactes. Une lecture fusionne les deux fichiers et garde la réponse la plus récente : le SELECT a renvoyé cinq lignes avec temp = 25. La documentation le dit simplement : Cassandra traite une suppression comme une insertion.

Le compactage réécrit les fichiers

Laissées à elles-mêmes, les SSTables s’accumulent et chaque lecture doit en regarder davantage. Le compactage les fusionne en une SSTable Cassandra neuve et abandonne ce qui est périmé. Dans le labo, j’ai désactivé le compactage automatique de la table pour le lancer à la main :

nodetool compact demo readings
141 nb-3-big-Data.db

nodetool compactionhistory
Compaction History: 
id                                   keyspace_name columnfamily_name compacted_at            bytes_in bytes_out rows_merged compaction_properties             
f61913d0-d6fb-11f1-97b7-370581990151 demo          readings          2026-11-02T21:28:28.031 213      132       {2:3}       {compaction_type:Major compaction}

Deux SSTables de 123 et 90 octets sont devenues une seule de 141 octets. Dans l’historique, rows_merged {2:3} devrait vouloir dire que trois partitions étaient présentes dans deux SSTables chacune (ma lecture). L’historique annonce 132 octets écrits alors que le fichier Data.db en fait 141 ; je n’ai pas creusé cet écart. Le fichier fusionné a gardé la mise à jour (25 a remplacé 21) et abandonné les valeurs couvertes par des tombstones, mais les tombstones eux-mêmes sont toujours là :

sstabledump nb-3-big-Data.db
[
  {
    "partition" : {
      "key" : [ "sensor-b" ],
      "position" : 22
    },
    "rows" : [
      {
        "type" : "row",
        "position" : 22,
        "clustering" : [ 1 ],
        "liveness_info" : { "tstamp" : "2026-11-02T20:26:44.439221Z" },
        "cells" : [
          { "name" : "temp", "value" : 15 }
        ]
      },
      {
        "type" : "row",
        "position" : 37,
        "clustering" : [ 2 ],
        "deletion_info" : { "marked_deleted" : "2026-11-02T20:27:29.783855Z", "local_delete_time" : "2026-11-02T20:27:29Z" },
        "cells" : [ ]
      }
    ]
  },
  {
    "partition" : {
      "key" : [ "sensor-c" ],
      "position" : 74,
      "deletion_info" : { "marked_deleted" : "2026-11-02T20:27:29.787731Z", "local_delete_time" : "2026-11-02T20:27:29Z" }
    },
    "rows" : [ ]
  },
  {
    "partition" : {
      "key" : [ "sensor-a" ],
      "position" : 97
    },
    "rows" : [
      {
        "type" : "row",
        "position" : 97,
        "clustering" : [ 1 ],
        "liveness_info" : { "tstamp" : "2026-11-02T20:26:44.426582Z" },
        "cells" : [
          { "name" : "temp", "value" : 20 }
        ]
      },
      {
        "type" : "row",
        "position" : 111,
        "clustering" : [ 2 ],
        "liveness_info" : { "tstamp" : "2026-11-02T20:26:44.432537Z" },
        "cells" : [
          { "name" : "temp", "value" : 25, "tstamp" : "2026-11-02T20:27:29.773920Z" }
        ]
      },
      {
        "type" : "row",
        "position" : 130,
        "clustering" : [ 3 ],
        "liveness_info" : { "tstamp" : "2026-11-02T20:26:44.435827Z" },
        "cells" : [
          { "name" : "temp", "value" : 22 }
        ]
      },
      {
        "type" : "row",
        "position" : 145,
        "clustering" : [ 4 ],
        "liveness_info" : { "tstamp" : "2026-11-02T20:27:29.779577Z" },
        "cells" : [
          { "name" : "temp", "value" : 23 }
        ]
      }
    ]
  }
]

La stratégie par défaut est celle par paliers de taille (STCS), celle qu’utilisait la table. La documentation décrit aussi les compactages par niveaux (LCS), par fenêtres de temps (TWCS) et unifié (UCS), et recommande UCS pour les nouvelles charges. Je n’ai lancé que STCS.

Pourquoi les fichiers ne rétrécissent pas tout de suite

Tailles d’une SSTable Cassandra après un chargement en volume, des suppressions, un compactage et la purge des tombstones
Octets de Data.db à chaque étape, et les SSTables du petit test.

Un tombstone doit survivre aux données qu’il couvre, pour que chaque réplica apprenne la suppression. C’est le rôle de gc_grace_seconds, dix jours par défaut. La documentation ajoute qu’un tombstone n’est retiré que par un compactage après ce délai, et seulement si toutes les SSTables qui contiennent des données plus anciennes participent au même compactage.

Pour voir l’effet sur la taille, j’ai chargé 60 000 lignes dans une seconde table (100 partitions de 600 lignes), supprimé 90 partitions, et mesuré les fichiers Data.db à chaque étape :

ÉtapeOctets de Data.dbSSTables
Chargé et vidé sur disque6 206 4951
Après suppression de 90 partitions et flush6 207 3882
Après nodetool compact621 8291
Après gc_grace_seconds = 0 et garbagecollect620 5841

La suppression a fait grossir le répertoire, de 6 221 956 à 6 229 063 octets, parce que les tombstones sont des données neuves. Seul le compactage a rendu la place, et les données sont passées d’environ 6,2 Mo à 0,62 Mo. La dernière étape a retiré 1 245 octets de plus, ce qui correspond aux 90 tombstones de partition. Je l’ai fait dans le labo ainsi :

ALTER TABLE demo.bulk WITH gc_grace_seconds = 0;
nodetool garbagecollect demo bulk

Ne copiez pas cela sur un vrai cluster. Si un réplica était en panne pendant que le tombstone existait, et que le tombstone est purgé avant son retour, les données supprimées peuvent réapparaître. La documentation appelle cela des zombies. Sur un seul nœud, il n’y a pas de risque.

Un détail sur les outils : sstablemetadata estime les tombstones supprimables avec un délai de grâce nul, sauf si vous passez --gc_grace_seconds. Il a affiché 0,0136 par défaut, et 0,0 avec 864000, le vrai réglage de la table.

Cassandra à côté des trois moteurs

InnoDBPostgreSQLOracleCassandra
Unité sur disquepage de 16 Kopage de 8 Kobloc de 8 Ko par défautune SSTable Cassandra immuable
UPDATEsur place, ancienne version dans l’undoune nouvelle version de tuple dans la tablesur place, image avant dans l’undoune nouvelle cellule avec un horodatage plus récent, dans une nouvelle SSTable
DELETEenregistrement marqué, purgé plus tardtuple laissé en place jusqu’au VACUUMligne retirée dans le bloc, la marque haute resteun tombstone, une nouvelle écriture
La place revient avecune reconstruction de tableVACUUMSHRINK SPACE ou MOVEle compactage, après gc_grace_seconds

Aucun de ces choix n’est meilleur dans l’absolu. Cassandra paie des écritures rapides et séquentielles avec du travail en arrière-plan : chaque mise à jour laisse une ancienne version derrière elle, et le compactage doit nettoyer plus tard. Quand on le sait, un répertoire de données qui grossit après une grosse suppression ne surprend plus.


Ce billet fait partie d’une série de notes d’administration système (tag « carnet d’admin »).
Série « Dans les fichiers d’une base de données », partie 5/3+2 (bonus). · Partie 3/3 et la comparaison · English version

Sources

Articles liés

Schéma des six étapes du test de restauration hebdomadaire dans un conteneur Podman jetable

Pas à pas : tester ses restaurations automatiquement chaque semaine

Des sauvegardes qui tournent chaque nuit, des journaux qui disent « OK », un tableau de bord tout vert : rien de tout cela ne prouve qu’on saura restaurer. Les causes d’échec sont nombreuses et silencieuses : un fichier de configuration oublié dans la sauvegarde, un trou dans l’archive des journaux de transactions, une version majeure qui a changé entre-temps, des droits incorrects, une clé de chiffrement perdue. La seule preuve qu’une sauvegarde fonctionne, c’est une restauration réussie : d’où l’intérêt d’un test de restauration automatique, chaque semaine.

Ce tutoriel automatise cette preuve : chaque semaine, la dernière sauvegarde PostgreSQL (pgBackRest) et la dernière sauvegarde MariaDB (mariadb-backup) sont restaurées dans un conteneur Podman jetable, l’instance est démarrée, chaque base est interrogée, puis tout est détruit. Un message arrive dans tous les cas. La production n’est jamais touchée.

Schéma des six étapes du test de restauration hebdomadaire dans un conteneur Podman jetable
Un test chaque dimanche, dans un conteneur détruit à la fin.

Les règles du jeu

RèglePourquoi
ne jamais toucher la productionrestauration dans un répertoire de travail, conteneur détruit à la fin quoi qu’il arrive, dépôt monté en lecture seule
les mêmes paquets qu’en productionune sauvegarde physique ne se restaure que dans la même version majeure, avec les mêmes chemins
un message dans tous les casun test silencieux est vite oublié ; un test qui échoue en silence est pire que pas de test
un seul test à la foisdeux restaurations simultanées saturent le disque et se marchent dessus
vérifier le contenu, pas seulement le démarrageune instance qui démarre sur des bases vides n’est pas une sauvegarde

Pourquoi un conteneur

On pourrait restaurer dans un répertoire de la machine et lancer une seconde instance sur un autre port. Le conteneur apporte trois choses de plus : une isolation complète (pas de risque qu’une instance de test écrive dans les fichiers de la production ou réponde sur son port), un environnement identique d’une semaine à l’autre, et un nettoyage garanti par un simple podman rm -f. Podman fonctionne sans démon et s’intègre bien à systemd et SELinux.

Étape 1 : des images fidèles à la production

N’utilisez pas les images officielles postgres ou mariadb de Docker Hub : elles sont construites sur Debian, avec d’autres chemins, d’autres options de compilation, parfois une autre version mineure. Le test doit utiliser exactement les paquets du serveur : on part de rockylinux:10 et on copie les fichiers de dépôt de la machine elle-même, plutôt que de les réécrire.

# Containerfile.postgres
FROM rockylinux:10
COPY repos/pgdg-redhat-all.repo /etc/yum.repos.d/
RUN dnf -y install postgresql18-server pgbackrest && dnf clean all
ENV PATH=/usr/pgsql-18/bin:$PATH
# Containerfile.mariadb
FROM rockylinux:10
COPY repos/MariaDB.repo /etc/yum.repos.d/MariaDB.repo
RUN dnf -y install MariaDB-server MariaDB-backup MariaDB-client MariaDB-common \
    && dnf clean all
podman build -t localhost/restore-test-postgres:18 -f Containerfile.postgres .
podman build -t localhost/restore-test-mariadb:12.3 -f Containerfile.mariadb .

Reconstruisez les images après chaque mise à jour majeure du serveur, et de préférence chaque mois pour suivre les versions mineures. Un test qui restaure une sauvegarde PostgreSQL 18 dans un binaire 17 échouera, et c’est tant mieux : il aura détecté un écart.

Étape 2 : le squelette commun

#!/bin/bash
set -uo pipefail
DATE=$(date +%Y%m%d_%H%M%S)
SCRATCH=/data/restore-test-scratch/pg-$DATE-$$
NAME=restore-test-pg-$DATE-$$
LOCK=/run/lock/restore-test-pg.lock

notify() { /usr/local/bin/notify.sh backups "Test de restauration PostgreSQL" "$1"; }
fail()   { notify "ÉCHEC : $1"; exit 1; }
cleanup() { podman rm -f "$NAME" >/dev/null 2>&1 || true; rm -rf "$SCRATCH"; }
trap cleanup EXIT INT TERM

exec 9>"$LOCK"
flock -n 9 || fail "un autre test est déjà en cours"
mkdir -p "$SCRATCH/data"
  • set -uo pipefail sans -e : on veut gérer chaque erreur explicitement pour envoyer un message clair, pas laisser le script mourir sans rien dire ;
  • trap cleanup EXIT INT TERM : le conteneur et le répertoire de travail sont supprimés quoi qu’il arrive, y compris si le service est arrêté par systemd au bout de son délai ;
  • flock : un verrou empêche deux tests de tourner en même temps, par exemple si un lancement manuel croise le lancement planifié ;
  • un nom unique par exécution (date et numéro de processus) : un conteneur orphelin d’un test précédent ne bloque pas le suivant.

Étape 3 : le test de restauration PostgreSQL

podman run -d --name "$NAME" \
  -v /data/backup/pgbackrest:/data/backup/pgbackrest:ro,Z \
  -v /etc/pgbackrest/pgbackrest.conf:/etc/pgbackrest/pgbackrest.conf:ro,Z \
  -v "$SCRATCH/data":/var/lib/pgsql/data:Z \
  localhost/restore-test-postgres:18 sleep infinity || fail "démarrage du conteneur"

podman exec -u root "$NAME" chown -R postgres:postgres /var/lib/pgsql/data
podman exec -u postgres "$NAME" pgbackrest --stanza=main \
  --pg1-path=/var/lib/pgsql/data --archive-mode=off restore || fail "pgbackrest restore"
podman exec -u postgres "$NAME" pg_ctl -D /var/lib/pgsql/data -w -t 900 \
  -o "-c archive_mode=off -c port=5432" start || fail "PostgreSQL ne démarre pas"

dbs=$(podman exec -u postgres "$NAME" psql -Atc \
  "select datname from pg_database where not datistemplate and datname <> 'postgres'")
[ -n "$dbs" ] || fail "aucune base restaurée"
for db in $dbs; do
  n=$(podman exec -u postgres "$NAME" psql -d "$db" -Atc \
      "select count(*) from pg_class c join pg_namespace n on n.oid=c.relnamespace
       where c.relkind='r' and n.nspname not in ('pg_catalog','information_schema')")
  [ "${n:-0}" -gt 0 ] || fail "base $db vide"
done
notify "RÉUSSI : $(echo $dbs | wc -w) bases restaurées et vérifiées"

Les points délicats

  • le dépôt en lecture seule (:ro) : le test ne peut pas abîmer les sauvegardes, même par erreur ;
  • –archive-mode=off à la restauration et archive_mode=off au démarrage : l’instance de test ne doit surtout pas archiver son propre WAL dans le dépôt de production, ce qui créerait une timeline parasite ;
  • pg_ctl -w -t 900 : attend jusqu’à quinze minutes que PostgreSQL ait rejoué le WAL et accepte les connexions. La durée dépend du volume de WAL depuis la dernière sauvegarde ; ajustez-la en regardant la durée réelle des premiers tests ;
  • les vérifications : chaque base doit exister et contenir des tables. Une base sans aucune table après restauration est suspecte. On peut aller plus loin avec une requête métier par application (« la table des articles contient-elle au moins mille lignes ? ») ;
  • SELinux et les volumes : le suffixe :Z réétiquette le répertoire pour le conteneur. Ne l’utilisez jamais sur un répertoire partagé avec un service de la machine, il changerait son étiquette ; pour ce cas, --security-opt label=disable sur ce seul conteneur est l’option raisonnable.

Étape 4 : le test de restauration MariaDB

Le principe est le même avec une sauvegarde physique mariadb-backup, avec quelques différences :

  • préparer avant de démarrer : une sauvegarde physique MariaDB doit passer par mariadb-backup --prepare, qui applique le journal redo copié pendant la sauvegarde. Si votre procédure de sauvegarde le fait déjà (c’est préférable), le test démarre directement ; sinon, le test doit le faire, sur une copie ;
  • copier, ne pas monter : MariaDB écrit dans ses fichiers dès le démarrage. On copie donc la sauvegarde dans le répertoire de travail (cp -a) au lieu de la monter en lecture seule ;
  • la même configuration : montez une copie du my.cnf de production. Si la production place ses tablespaces d’annulation (innodb_undo_directory), ses binlogs ou ses journaux dans des répertoires séparés, recréez-les dans le répertoire de travail et déplacez-y les fichiers correspondants, sinon InnoDB refusera de démarrer ;
  • l’identifiant de l’utilisateur mysql : il n’est pas forcément le même dans l’image et sur la machine. Lisez-le dans l’image (podman run --rm image id -u mysql) et donnez-lui les fichiers ;
  • les vérifications : mariadb-admin ping en boucle jusqu’à ce que le serveur réponde, puis pour chaque base hors schémas système, le nombre de tables et une estimation du nombre de lignes depuis information_schema.TABLES. Une base sans table ou sans ligne fait échouer le test.

Étape 5 : planifier le test de restauration

# /etc/systemd/system/restore-test-pgbackrest.timer
[Timer]
OnCalendar=Sun *-*-* 05:00:00
RandomizedDelaySec=15min
Persistent=true
[Install]
WantedBy=timers.target

# /etc/systemd/system/restore-test-pgbackrest.service
[Unit]
After=pgbackrest-full.service
[Service]
Type=oneshot
ExecStart=/usr/local/bin/restore-test-pgbackrest.sh
TimeoutStartSec=3h
Nice=10
IOSchedulingClass=idle
  • dimanche 5 h : après la sauvegarde complète du dimanche, pour tester la plus fraîche ;
  • Persistent=true : rattrape un test manqué si la machine était éteinte ;
  • TimeoutStartSec=3h : un test bloqué finit par être tué, et le trap nettoie ;
  • Nice et IOSchedulingClass=idle : le test cède la priorité aux services. Il durera plus longtemps, mais personne ne le remarquera.

Étape 6 : la notification

Le message doit arriver dans les deux cas, et dire quelque chose d’utile : quelle sauvegarde a été testée, combien de bases, et en cas d’échec, l’étape fautive et le chemin du journal. Un script notify.sh commun à tous les services (courriel, Mattermost, ntfy, peu importe) évite de dupliquer ce code. Un test qui réussit chaque dimanche finit par devenir un bruit de fond : c’est voulu. Le jour où le message manque, ou dit autre chose, on le remarque.

Complétez par une alerte de supervision sur l’absence de succès récent : si aucun message « RÉUSSI » n’est arrivé depuis dix jours, quelque chose ne va pas, même si aucun échec n’a été signalé (timer désactivé, machine éteinte, script supprimé).

Le passage de dimanche dernier

Les deux tests tels qu’ils ont tourné le dimanche 1er novembre 2026 sur mon serveur de la maison, tirés de leurs fichiers journaux (extraits ; pgBackRest journalise en UTC, le script en heure locale, d’où l’heure d’écart) :

[2026-11-01 05:00:04] Starting pgbackrest restore-test for stanza 'main'
[2026-11-01 05:00:04] Stanza 'main' has 25 backup(s) on record — proceeding with restore
04:00:05.311 P00 INFO: repo1: restore backup set 20261101-010003F, recovery will start at 2026-11-01 00:00:03
04:05:51.113 P00 INFO: restore size = 93.5MB, file total = 5756
04:05:51.114 P00 INFO: restore command end: completed successfully (345892ms)
[2026-11-01 05:05:57] PostgreSQL is ready (took ~6s)
[2026-11-01 05:05:57] Found 4 database(s): forgejo semaphore paperless netbox
[2026-11-01 05:05:58]   forgejo: 131 table(s) — OK
[2026-11-01 05:05:58]   netbox: 208 table(s) — OK
[2026-11-01 05:05:58] pgbackrest restore-test PASSED — 4 database(s) restored and verified non-empty

[2026-11-01 06:30:26]   blog_flo_wp: 93 table(s), ~568925 row(s) — OK
[2026-11-01 06:30:32]   piwigo: 35 table(s), ~1008323 row(s) — OK
[2026-11-01 06:30:38]   wiki: 41 table(s), ~1440630 row(s) — OK
[2026-11-01 06:30:38] MariaDB restore-test PASSED — 21 database(s) restored and verified non-empty (backup: 20261101_020001)
  • La restauration a pris 5 min 46 s pour 93,5 Mo : c’est justement le chiffre utile : à peu près ce que coûterait une vraie restauration de cette base, mesuré chaque semaine au lieu d’être deviné le jour J.
  • PostgreSQL prêt en 6 s : l’instance restaurée a rejoué ses WAL et accepté les connexions, ce qui prouve que la sauvegarde est cohérente, et pas seulement complète.
  • Les tables comptées base par base : une base vide ou tronquée fait échouer le test, même si la restauration elle-même a « réussi ».
  • Des nombres de lignes précédés d’un tilde côté MariaDB : ils viennent des statistiques (information_schema), rapides mais approximatives. Assez pour repérer une table vide, pas pour comparer exactement deux sauvegardes.

Ce que le test prouve, et ce qu’il ne prouve pas

Il prouve que la sauvegarde est complète et lisible, que l’archive des journaux est continue jusqu’à la sauvegarde, qu’une instance de la bonne version démarre dessus, et que chaque base contient des données. C’est déjà beaucoup : la plupart des sauvegardes qui échouent le jour J échouent sur l’un de ces points.

Il ne prouve pas que l’application fonctionne sur ces données, que la restauration à un instant précis aboutit au bon moment, ni que vous savez dérouler la procédure sous pression, à 3 heures du matin. Pour cela, rien ne remplace un exercice complet fait à la main, une ou deux fois par an : restaurer sur une machine vierge, rebrancher une application, chronomètre en main, en suivant la documentation écrite. Les trous dans la documentation apparaissent toujours à ce moment-là.

Et les autres données ?

Le même principe s’applique aux fichiers des applications (pièces jointes, médias, dépôts Git) : une fois par mois, extraire la dernière archive dans un répertoire temporaire, vérifier qu’elle n’est pas tronquée, que les fichiers attendus sont là et que leur nombre n’a pas chuté brutalement. Moins spectaculaire qu’une base de données, mais tout aussi précieux.


Ce billet fait partie d’une série de tutoriels d’administration système (tag « pas à pas »).
Série « Pas à pas », tutoriel 13/77. · ← Tutoriel précédent · Tutoriel suivant → (à paraître le 23/11) · English version

Articles liés

Auto-increment MariaDB après kill -9 : le compteur de table garde 10, la séquence saute de 1003 à 2001

MariaDB AUTO_INCREMENT et séquences : ce qui survit à un redémarrage ou à un crash, testé

En bref : j’ai fait un kill -9 sur mariadbd : l’auto-increment MariaDB a survécu (compteur à 10 avant et après, sans trou), mais un objet SEQUENCE perd son cache de 1000 à chaque redémarrage, propre ou non : 3 devient 1001, 1003 devient 2001. Pour une clé de substitution simple, prendre AUTO_INCREMENT. Ne prendre une séquence que pour partager un compteur, en réduisant son cache.

*MariaDB 10.11.18, InnoDB, innodb_autoinc_lock_mode=1, instance jetable sous Rocky Linux 10.2. Partie 2 sur 5. Toutes les sorties viennent de mes propres tests.*

Auto-increment MariaDB après kill -9 : le compteur de table garde 10, la séquence saute de 1003 à 2001
MariaDB 10.11.18 : le compteur de table survit au crash, le cache de séquence non.

Deux façons d’obtenir un auto-increment MariaDB

CREATE TABLE t_auto (id INT AUTO_INCREMENT PRIMARY KEY, v VARCHAR(20)) ENGINE=InnoDB;
INSERT INTO t_auto(v) VALUES ('a');
SELECT LAST_INSERT_ID();                                  -- 1
INSERT INTO t_auto(v) VALUES ('b') RETURNING id;          -- 2

CREATE SEQUENCE s1;
CREATE TABLE t_seq (id INT PRIMARY KEY DEFAULT NEXTVAL(s1), v VARCHAR(20)) ENGINE=InnoDB;
INSERT INTO t_seq(v) VALUES ('a') RETURNING id;           -- 1
SELECT NEXTVAL(s1), LASTVAL(s1);                          -- 2, 2
SELECT NEXT VALUE FOR s1;                                 -- 3

RETURNING sur INSERT existe dans MariaDB. NEXTVAL(s1) et NEXT VALUE FOR s1 sont équivalents ; LASTVAL(s1) donne la dernière valeur générée dans la session courante.

SHOW CREATE TABLE montre où vit le compteur :

`id` int(11) NOT NULL AUTO_INCREMENT,
...
) ENGINE=InnoDB AUTO_INCREMENT=3 ...

Pour la table adossée à la séquence, le défaut est DEFAULT nextval(shop.s1).

Rollback et échecs consomment des valeurs

BEGIN; INSERT INTO t_auto(v) VALUES ('rolled back'); SELECT LAST_INSERT_ID();   -- 3
ROLLBACK;
INSERT INTO t_auto(v) VALUES ('after rollback'); SELECT LAST_INSERT_ID();       -- 4

Avec une violation d’unicité : id 1, puis ERROR 1062 (23000): Duplicate entry 'x' for key 'code', puis l’insertion suivante reçoit 3. L’auto-increment MariaDB se comporte comme les autres moteurs de cette série.

Les insertions en masse font leurs propres trous

Avec innodb_autoinc_lock_mode=1, un INSERT ... SELECT de 5 lignes, puis une insertion d’une seule ligne :

ids_after_bulk: 1,2,3,4,5
id_of_next_single_insert: 8

Les id 6 et 7 ont été alloués à l’instruction en masse et jamais utilisés. Seul le résultat est testé ici, pas le mécanisme d’allocation ; c’est simplement une source de trous de plus.

Concurrence : l’ordre des id n’est pas l’ordre des commits

A insère en premier et valide environ 4 secondes plus tard, B insère en second et valide aussitôt :

B got id 2
B: committed 08:20:45.327
A got id 1
A: committed 08:20:47.825

La ligne de A s’affiche après celle de B à cause de la mise en tampon des sorties ; l’insertion de A est passée en premier, d’où l’id 1, et la table finit avec 1=A, 2=B. Ne pas utiliser le plus grand id vu comme curseur de polling.

Une valeur explicite fait avancer le compteur

C’est la différence principale avec PostgreSQL :

INSERT INTO t_x(id, v) VALUES (2, 'explicit 2');
INSERT INTO t_x(v) VALUES ('default 1');      -- 3
INSERT INTO t_x(v) VALUES ('default 2');      -- 4
INSERT INTO t_x(id, v) VALUES (100, 'explicit 100');
INSERT INTO t_x(v) VALUES ('after 100');      -- 101
INSERT INTO t_x(id, v) VALUES (0, 'explicit 0');   -- stocké comme 102

Le compteur suit toujours la plus grande valeur. Insérer 0 ou NULL demande une valeur générée (sauf si NO_AUTO_VALUE_ON_ZERO est dans sql_mode ; non testé ici).

Le CACHE d’une séquence est global, pas par session

CREATE SEQUENCE s_cache CACHE 10;
same session twice : 1  2
new session        : 3
another new session: 4

Contrairement à PostgreSQL, les sessions partagent le cache ; des appels successifs depuis des sessions différentes sont consécutifs. Le cache est une réservation côté serveur, et c’est lui qui est perdu au redémarrage (ci-dessous). Le défaut est cache 1000 :

SHOW CREATE SEQUENCE s1;
CREATE SEQUENCE `s1` start with 1 minvalue 1 maxvalue 9223372036854775806 increment by 1 cache 1000 nocycle ENGINE=InnoDB

Limites et CYCLE

ERROR 4084 (HY000): Sequence 'shop.s_small' has run out

Après ALTER SEQUENCE s_small CYCLE, la valeur suivante est 1. Pour un AUTO_INCREMENT sur TINYINT positionné à 126 : lignes 126 et 127, puis ERROR 167 (22003): Out of range value for column 'id' at row 1.

Redémarrage et crash

Trois lignes insérées, la dernière supprimée, redémarrage propre. Pour le compteur de table :

AUTO_INCREMENT before the restart: 4
AUTO_INCREMENT after the restart:  4
new id = 4

Pour une séquence au cache par défaut (valeurs 1, 2, 3 consommées avant) :

sequence after the restart: 1001

Cinq lignes de plus, la dernière supprimée (le compteur vaut donc 10 alors que le plus grand id est 8), puis kill -9 :

ids before the crash: 1,2,4,5,6,7,8
AUTO_INCREMENT before the crash: 10
AUTO_INCREMENT after the crash:  10
new id = 10
sequence before the crash: 1002  1003
sequence after the crash: 2001
ids now: 1,2,4,5,6,7,8,10

Le compteur de table est persistant à travers le crash (le mécanisme n’est pas testé ici) ; il n’y a même pas de trou par rapport à l’état d’avant le crash, et un dernier id supprimé n’est pas réutilisé. La séquence perd à chaque fois le reste de son cache : 3 devient 1001 après un redémarrage propre, 1003 devient 2001 après le crash.

Où lire l’état

SELECT table_name, table_type, auto_increment FROM information_schema.tables WHERE table_schema='shop';
SELECT * FROM s1\G            -- next_not_cached_value: 1001, cache_size: 1000, cycle_option: 0 ...
SHOW CREATE SEQUENCE s1\G

Une séquence apparaît dans information_schema.tables avec table_type = SEQUENCE ; SELECT * FROM s1 renvoie ses paramètres, dont next_not_cached_value.

Documentation officielle

MariaDB, site du projet

AUTO_INCREMENT, documentation MariaDB

CREATE SEQUENCE, documentation MariaDB

Sequence overview, documentation MariaDB

*Non testé ici : innodb_autoinc_lock_mode 0 et 2, NO_AUTO_VALUE_ON_ZERO, auto_increment_increment/offset (Galera et multi-maître), ALTER TABLE ... AUTO_INCREMENT= sur une table chargée, MySQL 8 (historique de persistance différent).*

Toutes les parties de la série

1/5 PostgreSQL

2/5 MariaDB

3/5 Oracle (à paraître le 24/11)

4/5 SQL Server (à paraître le 1/12)

5/5 TL;DR : les quatre moteurs comparés (à paraître le 8/12)

Articles liés

Dans les fichiers d’une base de données (1/3) : InnoDB, de MySQL à MariaDB

Dans les fichiers d’une base de données (2/3) : PostgreSQL

Dans les fichiers d’une base de données (3/3) : Oracle, et les trois côte à côte

Schéma de pgBackRest : PostgreSQL, dépôt, copie hors serveur et les quatre étapes d'une restauration à la seconde

Pas à pas : sauvegarder PostgreSQL avec pgBackRest et restaurer à la seconde

Un pg_dump nocturne est mieux que rien, mais il a deux défauts sérieux : il fait perdre jusqu’à vingt-quatre heures de données, et il ne sait pas revenir « juste avant le DELETE sans WHERE de 14 h 59 ». Sur une grosse base, il est aussi lent à produire et très lent à réimporter, index compris. pgBackRest répond à ces deux défauts.

pgBackRest résout les deux problèmes en combinant des copies physiques des fichiers de l’instance et l’archivage continu du journal de transactions (le WAL). Avec les deux, on peut restaurer l’instance à n’importe quelle seconde entre la plus ancienne sauvegarde conservée et maintenant. Ce tutoriel le met en place sur PostgreSQL 18 (dépôt PGDG, Rocky Linux), le planifie, puis déroule une vraie restauration à un instant précis.

Schéma de pgBackRest : PostgreSQL, dépôt, copie hors serveur et les quatre étapes d'une restauration à la seconde
Sauvegardes physiques et archivage du WAL, pour restaurer à la seconde près.

Le principe en deux phrases

PostgreSQL écrit chaque modification dans le WAL avant de l’appliquer aux fichiers de données. Si l’on dispose d’une copie des fichiers prise à un instant T et de tout le WAL produit depuis, on peut rejouer ce WAL sur la copie et s’arrêter où l’on veut.

TypeContenuPour restaurer, il faut
complète (full)tous les fichiers de l’instancecette sauvegarde + le WAL
différentielle (diff)les fichiers modifiés depuis la dernière complètela complète + cette différentielle + le WAL
incrémentale (incr)les fichiers modifiés depuis la dernière sauvegarde, quelle qu’elle soitla complète + toute la chaîne + le WAL

Les incrémentales sont plus petites mais fragilisent la chaîne : la perte d’un maillon rend inutilisables toutes celles qui suivent. Une complète par semaine et une différentielle par jour est un bon équilibre pour une base de quelques dizaines de gigaoctets.

Étape 1 : installer

dnf install pgbackrest            # depuis le dépôt PGDG, comme PostgreSQL
pgbackrest version
install -d -o postgres -g postgres -m 750 /data/backup/pgbackrest /var/log/pgbackrest

pgBackRest tourne sous l’utilisateur postgres : le dépôt et le répertoire de journaux doivent lui appartenir. Sous SELinux, si le dépôt est hors des chemins habituels, vérifiez que PostgreSQL (domaine postgresql_t) a le droit d’y écrire lors de l’archivage : un refus SELinux bloque l’archivage sans autre symptôme qu’un pg_wal qui grossit.

Étape 2 : la configuration de pgBackRest

# /etc/pgbackrest/pgbackrest.conf
[global]
repo1-path=/data/backup/pgbackrest
repo1-retention-full=2
repo1-retention-diff=14
compress-type=lz4
compress-level=6
log-level-console=warn
log-level-file=info
log-path=/var/log/pgbackrest
start-fast=y
delta=y

[main]
pg1-path=/data/postgresql/18/data
pg1-port=5432

La section [global]

  • repo1-path : le dépôt, ici sur un disque local. pgBackRest sait aussi écrire directement sur S3, Azure, GCS ou un autre serveur en SFTP ; pour commencer, un disque local copié ailleurs chaque nuit fait l’affaire ;
  • repo1-retention-full=2 : on garde deux sauvegardes complètes. Quand une troisième se termine avec succès, la plus ancienne est supprimée, avec ses différentielles et le WAL dont elle seule avait besoin. La fenêtre de restauration va donc d’une à deux semaines ;
  • repo1-retention-diff=14 : le nombre de différentielles conservées ; il doit couvrir au moins l’intervalle entre deux complètes ;
  • compress-type=lz4 : lz4 compresse un peu moins que zstd mais beaucoup plus vite, ce qui raccourcit à la fois la sauvegarde et la restauration ;
  • log-level-console / log-level-file : peu de bruit à l’écran, le détail dans /var/log/pgbackrest ;
  • start-fast=y : déclenche un checkpoint immédiat au début de la sauvegarde au lieu d’attendre le prochain, qui peut être dans plusieurs minutes ;
  • delta=y : à la restauration, pgBackRest compare les fichiers présents à ceux de la sauvegarde (par somme de contrôle) et ne recopie que ceux qui diffèrent. Sur une grosse instance, c’est la différence entre une heure et quelques minutes.

La section [main]

C’est la stanza : une instance PostgreSQL à sauvegarder, désignée par un nom libre. pg1-path est son répertoire de données, pg1-port son port. Plusieurs instances sur la même machine font plusieurs stanzas.

Étape 3 : brancher l’archivage du WAL

# postgresql.conf
wal_level        = replica
archive_mode     = on
archive_command  = 'pgbackrest --stanza=main archive-push %p'
archive_timeout  = 300
max_wal_senders  = 3
  • wal_level = replica : le WAL contient assez d’informations pour reconstruire l’instance (c’est la valeur par défaut des versions récentes) ;
  • archive_mode = on : active l’archivage. Ce réglage demande un redémarrage ;
  • archive_command : la commande lancée pour chaque segment de WAL terminé (16 Mo). %p est le chemin du segment ;
  • archive_timeout = 300 : force un changement de segment toutes les cinq minutes même si le segment n’est pas plein. Sur une base peu active, sans cela, les dernières transactions peuvent rester des heures dans un segment non archivé : c’est autant de données perdues si le serveur disparaît.

Si l’archivage échoue, PostgreSQL ne perd rien : il garde le segment et réessaie. Mais pg_wal/ grossit alors jusqu’à remplir le disque, et l’instance s’arrête. C’est la panne à surveiller en premier, par exemple avec la vue pg_stat_archiver :

SELECT archived_count, last_archived_time, failed_count, last_failed_time, last_failed_wal
FROM pg_stat_archiver;

Une alerte sur last_archived_time trop ancien (plus de dix minutes avec archive_timeout = 300) ou sur failed_count qui augmente prévient bien avant le disque plein.

Étape 4 : créer la stanza et vérifier

systemctl restart postgresql-18
sudo -u postgres pgbackrest --stanza=main stanza-create
sudo -u postgres pgbackrest --stanza=main check
sudo -u postgres pgbackrest --stanza=main --type=full backup
sudo -u postgres pgbackrest info

check force un changement de segment et attend de le voir arriver dans le dépôt : c’est le test de bout en bout de l’archivage. info affiche les sauvegardes, leur taille et l’intervalle de WAL disponible :

stanza: main
    status: ok
    wal archive min/max (18): 000000010000002A00000031/000000010000002C0000009E

    full backup: 20261101-010002F
        timestamp start/stop: 2026-11-01 01:00:02+01 / 2026-11-01 01:12:47+01
        database size: 41.2GB, database backup size: 41.2GB
        repo1: backup size: 9.8GB

Un vrai dépôt, après deux mois

Le dépôt du PostgreSQL 18 de mon serveur web le 2 novembre 2026, résumé à partir de pgbackrest info --output=json (la sortie texte liste toutes les sauvegardes, de la plus ancienne à la plus récente) :

status ok | wal 000000010000010C00000079 -> 000000010000010F000000DF
label                               type  start        took  db size  changed   stored
20261025-010001F_20261030-020003D   diff  10-30 02:00  128 s  6.6 GB   36.8 MB   12.4 MB
20261025-010001F_20261031-020002D   diff  10-31 02:00  136 s  6.6 GB   39.0 MB   12.9 MB
20261101-010006F                    full  11-01 01:00  370 s  6.6 GB  6710.8 MB  455.5 MB
20261101-010006F_20261102-020003D   diff  11-02 02:00  131 s  6.6 GB   32.0 MB   11.6 MB
backups in repo: 11

# time sudo -u postgres pgbackrest --stanza=main check
real	0m0.500s
  • 6,6 Go de base, 455 Mo dans le dépôt pour une sauvegarde complète : la compression divise la taille par quinze environ ici ; les fichiers de données PostgreSQL, pleins d’en-têtes de pages et de pages en partie vides, se compressent très bien.
  • Des différentielles de 32 à 39 Mo, stockées en 12 Mo : seuls les fichiers modifiés depuis la dernière complète sont copiés. Chaque différentielle ne dépend que d’une complète, jamais d’une autre différentielle : en perdre une ne coûte rien d’autre.
  • L’étiquette raconte la filiation : 20261101-010006F_20261102-020003D est une différentielle (D) du 2 novembre, fondée sur la complète (F) du 1er novembre.
  • La plage de WAL remonte jusqu’à la plus ancienne sauvegarde conservée : n’importe quel instant entre le 25 octobre et maintenant peut être restauré, à la seconde.
  • check en une demi-seconde, sans rien afficher, code de retour 0 : la commande d’archivage fonctionne et que le dépôt répond. À mettre dans la supervision, pas seulement dans les notes d’installation.

Étape 5 : planifier

# /etc/systemd/system/pgbackrest-full.service
[Unit]
Description=pgBackRest full backup
After=postgresql-18.service
[Service]
Type=oneshot
User=postgres
ExecStart=/usr/bin/pgbackrest --stanza=main --type=full backup

# /etc/systemd/system/pgbackrest-full.timer
[Timer]
OnCalendar=Sun *-*-* 01:00:00
Persistent=true
[Install]
WantedBy=timers.target

# pgbackrest-diff.service / .timer : identiques avec --type=diff
# et OnCalendar=Mon..Sat *-*-* 02:00:00

Persistent=true rattrape une sauvegarde manquée si le serveur était éteint à l’heure prévue. Ajoutez une notification en cas d’échec (OnFailure= vers une unité qui envoie un message) : une sauvegarde qui échoue en silence pendant trois semaines est une découverte désagréable le jour où on en a besoin.

Étape 6 : sortir le dépôt du serveur

Un dépôt sur le même serveur protège contre les erreurs humaines et logicielles, pas contre la perte du serveur. Copiez-le ailleurs chaque nuit, après la sauvegarde : un rsync vers une autre machine, ou un second dépôt pgBackRest (repo2-…) sur un stockage objet. Le second dépôt est plus élégant : pgBackRest y archive le WAL en parallèle et gère lui-même la rétention.

Étape 7 : restaurer juste avant l’erreur

Scénario : à 15 h 00, quelqu’un s’aperçoit qu’une requête lancée à 14 h 59 et quelques secondes a vidé une table. On veut revenir à 14 h 59 pile.

systemctl stop postgresql-18
sudo -u postgres pgbackrest --stanza=main --delta \
    --type=time "--target=2026-11-12 14:59:00+01" \
    --target-action=pause restore
systemctl start postgresql-18
sudo -u postgres psql -c "SELECT pg_is_in_recovery(), now()"
# vérifier les données, puis :
sudo -u postgres psql -c "SELECT pg_wal_replay_resume()"
  • –type=time et –target : la cible de restauration. Donnez toujours le fuseau horaire : sans lui, l’heure est interprétée dans le fuseau de la session, et un décalage d’une ou deux heures fait soit rejouer l’erreur, soit perdre le travail de la matinée ;
  • –target-action=pause : PostgreSQL s’arrête à la cible, en lecture seule. On peut vérifier tranquillement que la table est revenue et que rien de légitime ne manque, puis ouvrir l’instance avec pg_wal_replay_resume(). promote l’ouvre directement, sans cette étape de contrôle ;
  • –delta : ne recopie que les fichiers modifiés, la restauration est bien plus rapide ;
  • pgBackRest choisit seul la sauvegarde de départ (la plus récente antérieure à la cible) ; PostgreSQL rejoue ensuite le WAL jusqu’à la cible, puis démarre une nouvelle timeline : le WAL produit après l’erreur reste dans le dépôt, mais il ne sera plus jamais rejoué sur cette nouvelle branche.

Autres cibles possibles : --type=xid (un numéro de transaction), --type=lsn (une position précise dans le WAL), --type=name (un point nommé créé avant une opération risquée avec SELECT pg_create_restore_point('avant_migration')). Prenez l’habitude de créer un point nommé avant chaque migration de schéma : la restauration devient triviale.

Récupérer une seule base, ou une seule table

pgBackRest restaure une instance entière. Pour récupérer une seule base sans toucher à la production, restaurez sur une autre machine, ou dans un autre répertoire avec un autre port (--pg1-path=/srv/restore et port = 5499 dans son postgresql.conf), à l’instant voulu. Extrayez ensuite la base ou la table avec pg_dump -t et réimportez-la en production. C’est plus long, mais la production n’est jamais arrêtée.

Les pannes fréquentes

  • « archive-push » en échec : droits sur le dépôt, disque plein, ou refus SELinux. pg_stat_archiver et /var/log/pgbackrest/main-archive-push-async.log le disent ;
  • « WAL segment … not found » à la restauration : un trou dans l’archive, souvent parce que l’archivage a été désactivé un moment. Seule la dernière sauvegarde complète postérieure au trou est sûre ; lancez-en une immédiatement ;
  • restauration qui ne s’arrête pas à la bonne heure : le fuseau horaire, encore. Comparez avec SHOW timezone ;
  • « stanza-upgrade » après une mise à jour majeure de PostgreSQL : pgBackRest refuse de continuer tant qu’on ne lui a pas indiqué la nouvelle version. Lancez stanza-upgrade, puis immédiatement une sauvegarde complète.

Et surtout : testez la restauration régulièrement, automatiquement si possible. C’est l’objet du prochain tutoriel de la série. Une sauvegarde qui n’a jamais été restaurée n’est qu’une hypothèse.


Ce billet fait partie d’une série de tutoriels d’administration système (tag « pas à pas »).
Série « Pas à pas », tutoriel 12/77. · ← Tutoriel précédent · Tutoriel suivant → · English version

Articles liés

Nettoyage LanceDB en deux appels : d'abord les manifestes, puis les anciens fichiers de données, de 13,43 à 5,78 Gio

Nettoyage LanceDB : de 13,4 Gio à 5,8 Gio, et les versions qu’il coûte

J’ai lancé le nettoyage sur une copie de ma propre table LanceDB, et un assistant IA (Claude, d’Anthropic) m’a aidée à écrire le script de test et à rédiger cet article. Les chiffres ci-dessous sont la sortie réelle de ce lancement, avec LanceDB 0.41.0, sur une copie de la table de l’article précédent. La table d’origine n’a jamais été touchée.

Réponse rapide

Un nettoyage LanceDB prend deux appels. Le premier, optimize(cleanup_older_than=timedelta(0)), supprime en 0,4 seconde les manifestes des 264 anciennes versions, mais il laisse sur disque les 259 anciens fichiers de données, et le répertoire reste à 13,43 Gio. Un second appel avec delete_unverified=True supprime ces fichiers en 0,7 seconde et le répertoire tombe à 5,78 Gio, soit la taille de la version courante. Le prix à payer est l’historique : avant le nettoyage, je pouvais ouvrir la version 1 (2 697 lignes), la version 100 (371 946 lignes) et la version 264 (1 130 595 lignes), et après, seule la version 265 s’ouvre. Les 265 fichiers de transaction restent en place.

Nettoyage LanceDB en deux appels : d'abord les manifestes, puis les anciens fichiers de données, de 13,43 à 5,78 Gio
Deux appels à optimize sur une copie de la table et ce que chacun a supprimé.

Le test du nettoyage LanceDB

J’ai copié tout le répertoire de la table, 13,43 Gio répartis dans 260 fichiers de données, 265 manifestes et 265 fichiers de transaction, vers un dossier séparé, et j’ai ouvert la copie avec l’API Python. Le script mesure le répertoire, ouvre quelques anciennes versions avec checkout, appelle optimize, mesure à nouveau, et retente les mêmes anciennes versions. Le projet LanceDB documente optimize, et la docstring Python de optimize décrit les deux paramètres que j’ai utilisés.

Premier appel : les manifestes partent, les données restent

J’ai appelé table.optimize(cleanup_older_than=timedelta(0)). Python a affiché un avertissement : cette valeur supprime toutes les versions sauf la dernière, et un lecteur ou un écrivain qui utilise encore une ancienne version échouera. L’appel a renvoyé None au bout de 0,4 seconde. J’ai ensuite mesuré à nouveau :

avant    versions listées 265   fichiers de données 260   données 13,43 Gio   _versions 2,39 Mio   _transactions 265 fichiers
après    versions listées   1   fichiers de données 260   données 13,43 Gio   _versions 0,02 Mio   _transactions 265 fichiers

L’historique a disparu, et ce nettoyage LanceDB n’a pas rendu l’espace. La docstring de delete_unverified explique pourquoi : les fichiers laissés par une transaction échouée peuvent ressembler à une écriture en cours, donc ils ne sont pas supprimés tant qu’ils n’ont pas au moins 7 jours. Mes fichiers de données datent du 3 novembre, trois jours avant le test. Cela correspond à ce que j’ai vu, mais je ne l’ai pas testé avec des fichiers plus anciens, donc c’est ma lecture de la documentation.

Second appel : les fichiers de données partent

J’ai ensuite appelé table.optimize(cleanup_older_than=timedelta(0), delete_unverified=True), qui a pris 0,7 seconde :

après    versions listées   1   fichiers de données   1   données 5,78 Gio   _versions 0,02 Mio   _transactions 265 fichiers

Le répertoire est passé de 13,43 Gio à 5,78 Gio, et le nombre de lignes de la version 265 est toujours de 1 130 595. La docstring prévient que ce réglage ne doit servir que si aucun autre processus ne travaille sur la table, sinon la table pourrait se retrouver corrompue. Je n’ai pas testé de lecteur ou d’écrivain concurrent.

Ce que coûte un nettoyage LanceDB : le retour en arrière

Avant le nettoyage, checkout(1) renvoyait 2 697 lignes, checkout(100) 371 946 lignes et checkout(264) 1 130 595 lignes. Après, chacun de ces appels échoue avec ValueError: Version N no longer exists. Was it cleaned up?, et seul checkout(265) fonctionne. Gardez cela en tête avant de programmer un nettoyage à délai nul sur une table dont vous comptez sur les anciennes versions pour revenir en arrière après une mauvaise écriture. La fonction accepte un délai, donc un cleanup_older_than plus long conserve les versions récentes, et je n’ai pas testé cette valeur.

Ce qui reste

Le répertoire _transactions/ contient toujours ses 265 fichiers, environ 57 Kio, et le numéro de version de la table est toujours 265, parce que le nettoyage ne crée pas de version. Le répertoire _versions/ contient le manifeste de la version 265 et le fichier d’indice de 15 octets.

Ce que je n’ai pas testé

J’ai testé une table, une fois, sur un disque local. Je n’ai pas testé un délai supérieur à zéro, une table sur un stockage objet, un lecteur concurrent, ni les options de compactage de optimize. Les fichiers de la copie avaient trois jours, donc le comportement des 7 jours vient de la documentation et d’une observation, pas d’une comparaison contrôlée.

Documentation officielle

La page versions de Lance et l’agencement des fichiers d’une table Lance décrivent les versions et les répertoires, et le projet LanceDB documente l’API Python.

Protection du système de fichiers avec systemd : ProtectSystem true, full et strict, et les exceptions inscriptibles

Protection du système de fichiers avec systemd : durcissement, partie 2

La protection du système de fichiers par systemd décide quels fichiers un service peut lire, écrire ou même voir. Cet article est la partie 2 d’une série de huit, « Durcissement systemd, directive par directive ». J’y traite les directives qui façonnent l’arborescence d’un service : ProtectSystem, ProtectHome, PrivateTmp, ReadWritePaths et leurs cousines.

Quand un service est compromis, ou simplement bogué, c’est dans l’arborescence que les dégâts se produisent. Un service qui ne peut pas écrire dans /etc ne peut pas réécrire sa propre configuration, et un service qui ne voit pas /home ne peut pas lire vos clés SSH. La protection du système de fichiers coûte quelques lignes dans un fichier drop-in. Mais chaque ligne peut aussi bloquer une écriture légitime. Pour chaque directive, j’explique donc ce qu’elle fait, ce qu’elle peut casser et comment elle touche ma propre pile. Aucune expérience de systemd n’est nécessaire : chaque étape vient avec la commande complète et un commentaire.

Banc d’essai. Chaque sortie de cet article vient d’une vraie exécution sur Rocky Linux 10.2 avec systemd 257, dans une machine virtuelle WSL2 (noyau 6.18.54.1-microsoft-standard-WSL2, exécution en root). SELinux y est désactivé, et quelques fonctions du noyau diffèrent d’un serveur classique. Je le signale chaque fois que cela compte. Mes fichiers et répertoires de test commencent par _sd2_, ce qui permet de les retrouver et de les supprimer facilement. Quand je coupe une ligne d’une sortie, je la remplace par [...], et je marque ce que je n’ai pas exécuté comme non testé.

Protection du système de fichiers avec systemd : ProtectSystem true, full et strict, et les exceptions inscriptibles
Les trois niveaux de ProtectSystem, et les moyens d’ouvrir une exception inscriptible.

Avant de commencer

Lisez d’abord cette courte liste. Elle vous évite de durcir un service de production du premier coup.

  • Une machine de test. Utilisez une machine virtuelle ou un serveur de rechange qui fait tourner systemd. Je n’ai testé que sur Rocky Linux 10.2. Les directives appartiennent à systemd lui-même, donc les autres distributions devraient se comporter pareil, mais je ne l’ai pas vérifié.
  • **Un shell avec sudo.** Chaque commande qui modifie le système commence par sudo. Mon banc tournait en root, donc mes sorties viennent de commandes root.
  • Un service de démonstration. Le labo plus bas crée demo-hardening-fs.service, un service inoffensif qui essaie seulement de créer des fichiers vides. Vous ne touchez jamais à un vrai service.
  • Un retour en arrière. Chaque changement vit dans un fichier drop-in. systemctl revert le supprime, et le labo se termine par un nettoyage.
  • Un coup d’œil à votre version. Lancez systemctl --version. Je n’ai pu tester que la version 257 : si votre systemd rejette une directive, lisez son entrée dans la page de manuel systemd.exec.

Un petit glossaire

TermeCe que cela veut dire ici
Espace de noms de montageUne copie privée de la liste des systèmes de fichiers montés. Un changement fait à l’intérieur n’apparaît pas sur l’hôte.
Lecture seuleUn chemin où la lecture marche et où l’écriture échoue avec le message « Read-only file system ».
tmpfsUn système de fichiers gardé en mémoire. Il démarre vide et disparaît quand on le démonte.
Montage lié (bind mount)Le même répertoire rendu visible à un second endroit de l’arborescence.
Systèmes de fichiers d’API/proc, /sys et /dev, fournis par le noyau. Un service en a besoin pour tourner.
Drop-inUn petit fichier .conf dans un répertoire .d qui modifie une unité sans toucher au fichier d’origine.
DirectiveUn réglage d’un fichier d’unité, comme ProtectSystem=strict.
Unité transitoireUne unité temporaire que systemd-run crée à la volée. Elle disparaît quand elle s’arrête.
Utilisateur du serviceLe compte qui exécute le service, défini par User= dans l’unité.

En un coup d’œil

Ce tableau est la carte de la protection du système de fichiers dans cet article. La dernière colonne vient de mes notes de homelab : elle dit où la directive protège déjà, ou a déjà cassé, un de mes services.

DirectiveCe qu’elle faitCe qu’elle peut casserDans ma pile
ProtectSystem=Monte /usr, puis /etc, puis toute l’arborescence en lecture seuleToute écriture hors de vos exceptionsKavita, Navidrome, mktxp, mox et Etherpad tournent avec strict
ProtectHome=Cache ou fige /home, /root et /run/userLes programmes qui gardent caches ou clés dans leur répertoire personnelKavita utilise yes ; Oxidized a eu besoin de read-only
PrivateTmp=Donne au service son propre /tmp et /var/tmpLes services qui partagent des fichiers par /tmpKavita ouvre plutôt le /tmp de l’hôte
PrivateMounts=Place le service dans son propre espace de noms de montageLes montages que le service fait pour d’autresMes notes n’en parlent pas
ReadWritePaths=Ouvre des exceptions inscriptiblesUn chemin absent arrête le serviceLe correctif le plus fréquent de mes notes
ReadOnlyPaths=Fige un chemin dans une zone inscriptibleUne écriture à cet endroit échoueMes notes n’en parlent pas
InaccessiblePaths=Cache complètement un cheminToute lecture à cet endroit échoueMes notes n’en parlent pas
ExecPaths= et NoExecPaths=Autorisent ou interdisent d’exécuter des programmes depuis un cheminLes binaires d’un chemin interdit (erreur 203)Mes notes n’en parlent pas
BindPaths= et BindReadOnlyPaths=Montrent un répertoire à un second endroitUne mauvaise source ou destinationMes notes n’en parlent pas
TemporaryFileSystem=Remplace un répertoire par un tmpfs videTout ce que ce répertoire contenaitMes notes n’en parlent pas
StateDirectory= et cieCréent des répertoires gérés avec le bon propriétaireDes surprises de propriétaire et de modeNavidrome liste aujourd’hui ces chemins à la main
RestrictFileSystems=N’autorise que certains types de systèmes de fichiersDemande une fonction du noyau (BPF LSM)Mes notes n’en parlent pas
RootDirectory=, RootImage=Lancent le service dans un chroot ou une image disqueTout ce que le service s’attend à trouverMes notes n’en parlent pas

Protection du système de fichiers : comment un service obtient sa propre vue

Quand systemd démarre un service, il peut d’abord lui donner un espace de noms de montage privé. En clair, le service reçoit sa propre copie de la liste des montages. Systemd modifie ensuite cette copie : il remonte certains chemins en lecture seule, en cache d’autres et ajoute des répertoires temporaires privés. L’hôte ne change pas. Seuls les processus de ce service voient la différence.

Trois conséquences comptent pour un débutant. D’abord, les règles s’appliquent à tous les processus du service, root compris. Mon banc tournait en root, et les écritures ont quand même été refusées. Ensuite, une règle n’est pas une permission : le fichier reste inscriptible pour tous les autres processus de la machine. Enfin, un accès bloqué dit rarement « Permission denied ». Dans mes essais, il disait « Read-only file system » ou « No such file or directory », donc lisez ces messages avec cela en tête.

La méthode est toujours la même. On ferme d’abord une grande zone, puis on ouvre les quelques exceptions dont le service a besoin. ProtectSystem, ProtectHome et PrivateTmp ferment. Les directives de chemins et la famille *Directory= ouvrent. La suite de l’article suit cet ordre.

ProtectSystem : trois niveaux de lecture seule

ProtectSystem= est le cœur de la protection du système de fichiers, et il prend quatre valeurs. no est la valeur par défaut et ne change rien. yes (aussi écrit true) monte /usr et les répertoires du chargeur de démarrage en lecture seule. full ajoute /etc. strict monte toute l’arborescence en lecture seule, sauf /dev, /proc et /sys. Les exceptions inscriptibles viennent de ReadWritePaths=, des réglages *Directory= et de PrivateTmp=.

J’ai lancé une sonde par valeur. Elle essaie de créer un fichier vide à quatre endroits. L’option -P de systemd-run affiche la sortie dans votre terminal, donc vous voyez le résultat tout de suite. Voici la commande pour strict :

# Lancer une commande dans une unité temporaire qui a ProtectSystem=strict
# -P (--pipe) affiche la sortie ici, --wait attend la fin, -G (--collect) supprime l'unité ensuite
sudo systemd-run --quiet --pipe --wait --collect -p ProtectSystem=strict \
  sh -c 'for d in /usr /etc /var/tmp /tmp; do
    if err=$(touch "$d/_sd2_test" 2>&1); then echo "$d: write OK"
    else echo "$d: write refused -> ${err##*: }"; fi
  done'
# Avec ProtectSystem=no, les fichiers de test existent vraiment sur l'hôte : on les supprime
sudo rm -f /usr/_sd2_test /etc/_sd2_test /var/tmp/_sd2_test /tmp/_sd2_test

Et voici sa sortie :

/usr: write refused -> Read-only file system
/etc: write refused -> Read-only file system
/var/tmp: write refused -> Read-only file system
/tmp: write refused -> Read-only file system

J’ai lancé la même sonde pour les autres valeurs et pour deux combinaisons. Ce tableau résume les résultats, et chaque cellule est une vraie réponse :

Valeur/usr/etc/var/tmp/tmp
noécriture OKécriture OKécriture OKécriture OK
yesrefuséeécriture OKécriture OKécriture OK
fullrefuséerefuséeécriture OKécriture OK
strictrefuséerefuséerefuséerefusée
strict + PrivateTmp=yesrefuséerefuséeécriture OKécriture OK
strict + ReadWritePaths=/etcrefuséeécriture OKrefuséerefusée

Deux leçons ressortent de ce tableau. D’abord, strict fige aussi /tmp et /var/tmp, et beaucoup de programmes ne démarrent pas sans répertoire temporaire. Donc strict va en général avec PrivateTmp=yes. Ensuite, une exception de ReadWritePaths= n’ouvre que le chemin nommé : avec /etc ouvert, /tmp est resté en lecture seule.

Une surprise : /home et /root restent inscriptibles sous strict

Le manuel décrit strict comme une arborescence en lecture seule, hors systèmes de fichiers d’API. Mon banc le contredit pour deux répertoires. J’ai lancé une seconde sonde :

sudo systemd-run --quiet --pipe --wait --collect -p ProtectSystem=strict \
  sh -c 'for d in /home /root /opt /srv /var/lib; do
    if err=$(touch "$d/_sd2_diag" 2>&1); then echo "$d: write OK"
    else echo "$d: write refused -> ${err##*: }"; fi
  done'
sudo rm -f /home/_sd2_diag /root/_sd2_diag
/home: write OK
/root: write OK
/opt: write refused -> Read-only file system
/srv: write refused -> Read-only file system
/var/lib: write refused -> Read-only file system

Dans le service, findmnt montre la différence : /home est un montage séparé en lecture-écriture, alors que le montage qui contient /etc est en lecture seule.

# Quel montage contient /home et /etc dans le service, et avec quelles options ?
sudo systemd-run --quiet --pipe --wait --collect -p ProtectSystem=strict findmnt -T /home -o TARGET,FSTYPE,OPTIONS
sudo systemd-run --quiet --pipe --wait --collect -p ProtectSystem=strict findmnt -T /etc -o TARGET,FSTYPE,OPTIONS
TARGET FSTYPE OPTIONS
/home  ext4   rw,relatime,discard,errors=remount-ro,data=ordered
TARGET FSTYPE OPTIONS
/      ext4   ro,relatime,discard,errors=remount-ro,data=ordered

Je ne sais pas si cela vient de WSL2, de ce build de systemd ou de la façon dont le système de fichiers racine est monté, et je n’ai pas creusé plus loin. La règle pratique est simple : ne comptez jamais sur strict pour protéger les répertoires personnels. Ajoutez ProtectHome= et vérifiez le résultat sur votre propre serveur avec la sonde ci-dessus.

Quelle valeur choisir

Pour un service de longue durée, partez de strict et ajoutez les exceptions une par une. Mes notes montrent ce que cela donne en pratique. L’exporteur mktxp essayait d’écrire un fichier de configuration par défaut dans son répertoire de configuration, et strict l’en empêchait jusqu’à ce que j’ajoute ce répertoire à ReadWritePaths=. Navidrome avait un problème plus discret. Son répertoire de sauvegarde manquait dans ReadWritePaths=, donc sa propre tâche de sauvegarde échouait chaque nuit avec « unable to open database file ». Personne ne l’a remarqué pendant environ une semaine, et chaque archive nocturne pesait 122 octets. La leçon : après avoir ajouté strict, lisez pendant quelques jours le journal du service à la recherche de « Read-only file system ».

ProtectHome : cacher, figer ou remplacer /home

ProtectHome= étend la protection du système de fichiers aux données personnelles. Il agit sur /home, /root et /run/user. Avec yes (ou true), les trois répertoires paraissent vides et rien de ce qu’ils contiennent n’est accessible. Avec read-only, ils restent visibles mais figés. Avec tmpfs, le service voit à la place des systèmes de fichiers temporaires vides, et BindPaths= peut ramener des répertoires choisis.

Protection du système de fichiers et répertoires personnels : ProtectHome true, read-only et tmpfs
Ce qu’un service voit dans /home, /root et /run/user pour chaque valeur de ProtectHome.

J’ai créé un faux répertoire personnel avec un fichier, puis lancé une sonde par valeur. Changez la valeur après ProtectHome= pour la répéter :

# Préparer un faux répertoire personnel avec un fichier
sudo mkdir -p /home/_sd2_user && echo hello | sudo tee /home/_sd2_user/hello.txt > /dev/null
# Changer la valeur après ProtectHome= : no, yes, read-only, tmpfs
sudo systemd-run --quiet --pipe --wait --collect -p ProtectHome=yes \
  sh -c 'echo "ls -A /home:"; ls -A /home 2>&1
         echo "cat hello.txt:"; cat /home/_sd2_user/hello.txt 2>&1
         if err=$(touch /home/_sd2_user/new.txt 2>&1); then echo "write: OK"
         else echo "write: refused -> ${err##*: }"; fi'
# Supprimer le faux répertoire personnel
sudo rm -rf /home/_sd2_user

Avec yes, le service ne voit rien :

ls -A /home:
cat hello.txt:
cat: /home/_sd2_user/hello.txt: No such file or directory
write: refused -> No such file or directory

Avec read-only, le service lit le fichier mais ne peut pas écrire. Une ligne qui nomme le vrai répertoire personnel de mon compte est coupée :

ls -A /home:
[...]
_sd2_user
cat hello.txt:
hello
write: refused -> Read-only file system
ValeurListe du répertoireLecture du fichierÉcriture
novisibleOKOK
yesvideNo such file or directoryNo such file or directory
read-onlyvisibleOKRead-only file system
tmpfsvideNo such file or directoryNo such file or directory
yes + ReadWritePaths= sur le sous-répertoirevideNo such file or directoryNo such file or directory
read-only + ReadWritePaths= sur le sous-répertoirevisibleOKOK
tmpfs + BindPaths= sur le sous-répertoireseulement ce sous-répertoireOKOK

Les trois dernières lignes sont celles à retenir. ReadWritePaths= ne peut pas rouvrir un chemin sous ProtectHome=yes. Il marche sous read-only, et tmpfs avec BindPaths= marche aussi. Mes notes décrivent le même piège sur un vrai service : Oxidized, qui sauvegarde les configurations d’équipements réseau, ne pouvait pas utiliser son propre répertoire personnel sous ProtectHome=true, bien que ReadWritePaths= le liste. Passer à read-only a réglé le problème. Sur mon serveur, l’erreur était « permission denied » ; sur le banc, c’était « No such file or directory ». Les deux signifient que le chemin est hors d’atteinte. Mon banc tournait en root, ce qui peut expliquer la différence de message.

Nommer le sous-répertoire, pas /home

Un second piège : ReadWritePaths= demande le sous-répertoire exact. J’ai essayé le parent d’abord, puis le sous-répertoire, tous deux avec ProtectHome=read-only. La sonde essaie d’écrire aux deux endroits :

# Deux essais avec ProtectHome=read-only : ReadWritePaths sur /home lui-même, puis sur un sous-répertoire
sudo mkdir -p /home/_sd2_sub
for rw in /home /home/_sd2_sub; do
  echo "ReadWritePaths=$rw"
  sudo systemd-run --quiet --pipe --wait --collect -p ProtectHome=read-only -p ReadWritePaths=$rw \
    sh -c 'for d in /home /home/_sd2_sub; do
      if err=$(touch "$d/_sd2_p" 2>&1); then echo "  $d: write OK"
      else echo "  $d: write refused -> ${err##*: }"; fi
    done'
done
sudo rm -rf /home/_sd2_sub /home/_sd2_p
ReadWritePaths=/home
  /home: write refused -> Read-only file system
  /home/_sd2_sub: write refused -> Read-only file system
ReadWritePaths=/home/_sd2_sub
  /home: write refused -> Read-only file system
  /home/_sd2_sub: write OK

Lister /home n’a rien ouvert, pas même le sous-répertoire qu’il contient. Lister le sous-répertoire l’a ouvert, et /home est resté en lecture seule.

Quand le programme veut son répertoire personnel

Beaucoup de programmes écrivent des caches ou des clés sous $HOME. Si ProtectHome=yes le cache, ils échouent de façon déroutante. Deux cas réels de mes notes : Kavita n’arrivait pas à enregistrer son premier utilisateur, car le magasin de clés .NET utilise par défaut un dossier du répertoire personnel du compte de service. L’outil de build pnpm d’Etherpad ne trouvait pas non plus de répertoire personnel inscriptible sous strict. Dans les deux cas, je n’ai pas élargi le bac à sable. J’ai défini Environment=HOME= vers un répertoire déjà inscriptible, dans le dossier de l’application. Cela garde la protection et satisfait le programme.

PrivateTmp et PrivateMounts : des espaces privés

PrivateTmp=yes donne au service son propre /tmp et /var/tmp. Systemd les crée au démarrage du service et les supprime à son arrêt. Les autres services, et vous, ne voient pas leur contenu. Cela bloque toute une classe d’attaques qui reposent sur des noms de fichiers prévisibles dans /tmp. J’ai lancé la même commande sans, puis avec. Un fichier nommé _sd2_host_file existait déjà dans le /tmp de l’hôte :

touch /tmp/_sd2_host_file
# Même commande deux fois : sans, puis avec PrivateTmp=yes
sudo systemd-run --quiet --pipe --wait --collect \
  sh -c 'echo "files named _sd2_* seen in /tmp:"; ls -A /tmp | grep _sd2_; touch /tmp/_sd2_in_unit && echo "created /tmp/_sd2_in_unit"'
# Supprimer le fichier que ce premier essai a créé sur l'hôte
sudo rm -f /tmp/_sd2_in_unit
sudo systemd-run --quiet --pipe --wait --collect -p PrivateTmp=yes \
  sh -c 'echo "files named _sd2_* seen in /tmp:"; ls -A /tmp | grep _sd2_; touch /tmp/_sd2_in_unit && echo "created /tmp/_sd2_in_unit"'
# Que voit l'hôte ensuite ?
ls -A /tmp | grep _sd2_
sudo rm -f /tmp/_sd2_host_file /tmp/_sd2_in_unit
files named _sd2_* seen in /tmp:
_sd2_host_file
created /tmp/_sd2_in_unit
files named _sd2_* seen in /tmp:
created /tmp/_sd2_in_unit
_sd2_host_file

Sans PrivateTmp, le service voit le fichier de l’hôte. Avec lui, le service voit un /tmp vide, crée son propre fichier et ne laisse rien derrière lui. La dernière ligne vient de l’hôte : il a toujours son fichier d’origine et rien d’autre. Rappel : strict met /tmp en lecture seule, mais PrivateTmp=yes en redonne un privé et inscriptible.

Une troisième valeur existe dans les versions récentes, PrivateTmp=disconnected. J’ai seulement testé si elle est acceptée. Via systemd-run -p, systemd 257 l’a refusée sur mon banc :

# La troisième valeur, via systemd-run
sudo systemd-run --quiet --pipe --wait --collect -p PrivateTmp=disconnected true
Failed to parse PrivateTmp: disconnected

Écrite dans un fichier d’unité, la même valeur a été acceptée et le service one-shot est allé au bout sans se plaindre. Je n’ai pas testé ce qu’elle change : son comportement est non testé.

Dans ma pile, Kavita ouvre le /tmp de l’hôte avec ReadWritePaths= au lieu d’utiliser PrivateTmp=yes. Un /tmp privé serait plus strict. Je ne l’ai pas encore essayé.

PrivateMounts

PrivateMounts=yes place le service dans son propre espace de noms de montage et ne fait rien d’autre. Les montages que le service réalise ne fuient pas vers l’hôte. Je l’ai testé avec un tmpfs monté depuis l’intérieur du service :

sudo mkdir -p /mnt/_sd2_pm
# Monter un tmpfs dans le service, puis regarder depuis l'hôte
sudo systemd-run --quiet --pipe --wait --collect -p PrivateMounts=yes \
  sh -c 'mount -t tmpfs none /mnt/_sd2_pm && touch /mnt/_sd2_pm/x && findmnt -n -o TARGET,FSTYPE /mnt/_sd2_pm'
findmnt /mnt/_sd2_pm || echo "not mounted on the host"
sudo rmdir /mnt/_sd2_pm
/mnt/_sd2_pm tmpfs
not mounted on the host

La plupart des directives de cet article activent d’elles-mêmes un espace de noms de montage privé, donc il est rare de devoir écrire PrivateMounts=yes. Il compte pour un service qui monte des systèmes de fichiers et ne doit pas perturber l’hôte.

ReadWritePaths, ReadOnlyPaths et InaccessiblePaths

Ces trois directives vous laissent régler la protection du système de fichiers chemin par chemin. Chacune prend une liste de chemins séparés par des espaces. Vous pouvez les répéter, et les listes s’additionnent. ReadWritePaths= rend un chemin à nouveau inscriptible sous ProtectSystem. ReadOnlyPaths= fige un chemin dans une zone par ailleurs inscriptible. InaccessiblePaths= le cache. J’ai testé les deux dernières sur un répertoire jetable :

D=/var/tmp/_sd2_dir
mkdir -p $D && echo data > $D/file.txt
# Lecture seule : le fichier reste lisible, aucun fichier ne peut être créé, le reste de /var/tmp reste inscriptible
sudo systemd-run --quiet --pipe --wait --collect -p ReadOnlyPaths=$D \
  sh -c 'cat /var/tmp/_sd2_dir/file.txt
         if err=$(touch /var/tmp/_sd2_dir/new 2>&1); then echo "write in dir: OK"
         else echo "write in dir: refused -> ${err##*: }"; fi
         touch /var/tmp/_sd2_other && echo "write elsewhere in /var/tmp: OK"'
# Inaccessible : le répertoire paraît vide et rien ne peut être lu
sudo systemd-run --quiet --pipe --wait --collect -p InaccessiblePaths=$D \
  sh -c 'ls -A /var/tmp/_sd2_dir 2>&1; echo "---"; cat /var/tmp/_sd2_dir/file.txt 2>&1'
rm -rf $D /var/tmp/_sd2_other
data
write in dir: refused -> Read-only file system
write elsewhere in /var/tmp: OK
---
cat: /var/tmp/_sd2_dir/file.txt: No such file or directory

Le premier essai montre ReadOnlyPaths= : le fichier est lisible, un nouveau fichier dans le répertoire est refusé, et le reste de /var/tmp reste inscriptible. Le second montre InaccessiblePaths= : le répertoire paraît vide, puis le fichier ne peut pas être lu. Il existe toujours sur l’hôte.

Le tiret initial

Un chemin qui n’existe pas au démarrage du service arrête le service. Un tiret devant le chemin demande à systemd de l’ignorer s’il est absent :

# Un chemin qui n'existe pas, sans puis avec le tiret initial
sudo systemd-run --quiet --pipe --wait --collect -p ReadWritePaths=/nonexistent_sd2 true; echo "exit code: $?"
sudo systemd-run --quiet --pipe --wait --collect -p ReadWritePaths=-/nonexistent_sd2 true; echo "exit code: $?"
exit code: 226
exit code: 0

Le code de sortie 226 est la façon dont systemd signale un échec pendant la construction de l’espace de noms. Sans le tiret, le service n’a même pas démarré.

Trouver le chemin manquant

Dans mes notes, ReadWritePaths= est le correctif le plus fréquent. Kavita a demandé deux ajouts après sa première version. Il écrit sa base SQLite dans un dossier config sous son répertoire de travail, un chemin que je n’avais pas listé. Il réécrit aussi wwwroot/index.html à chaque démarrage, ce qui ne produisait qu’une erreur sans gravité mais bruyante. Chaque fois, le journal disait « Read-only file system ». Ma routine est donc courte : démarrer le service, lancer journalctl -u UNITÉ | grep -i 'read-only file system', ajouter le seul chemin qui apparaît, puis recommencer. Je n’ai pas lancé cette commande exacte sur le banc, mais elle ne fait que lire le journal.

ExecPaths et NoExecPaths : où les programmes peuvent tourner

NoExecPaths= interdit d’exécuter des programmes depuis un chemin, et ExecPaths= creuse une exception. Une application web qui accepte des envois de fichiers est un bon cas d’usage : rien de ce qui est envoyé ne doit jamais s’exécuter. J’ai copié true dans un répertoire jetable et essayé de le lancer trois fois :

D=/var/tmp/_sd2_dir
mkdir -p $D && cp /usr/bin/true $D/runme
# Lancer la copie de true : sans restriction, puis avec NoExecPaths, puis NoExecPaths sur le parent avec une exception ExecPaths
sudo systemd-run --quiet --pipe --wait --collect $D/runme; echo "no restriction, exit code: $?"
sudo systemd-run --quiet --pipe --wait --collect -p NoExecPaths=$D $D/runme; echo "NoExecPaths, exit code: $?"
sudo systemd-run --quiet --pipe --wait --collect -p NoExecPaths=/var/tmp -p ExecPaths=$D $D/runme; echo "with ExecPaths, exit code: $?"
rm -rf $D
no restriction, exit code: 0
NoExecPaths, exit code: 203
with ExecPaths, exit code: 0

Le code de sortie 203 signifie que systemd n’a pas pu exécuter le programme. Le dernier essai montre le schéma : interdire une grande zone, puis autoriser le seul sous-répertoire qui doit exécuter des programmes. Mes notes ne parlent pas encore de ces deux directives, donc ce sont des candidates pour les répertoires d’envoi de mes applications web.

BindPaths, BindReadOnlyPaths et TemporaryFileSystem

BindPaths= montre un répertoire à un second endroit, au format SOURCE:DESTINATION. BindReadOnlyPaths= fait pareil, mais en lecture seule. J’ai créé un répertoire avec un fichier et je l’ai lié deux fois :

S=/var/tmp/_sd2_src
mkdir -p $S && echo hi > $S/hi.txt
# Montrer $S à un second endroit : en écriture, puis en lecture seule
sudo systemd-run --quiet --pipe --wait --collect -p BindPaths=$S:/mnt/_sd2_dst \
  sh -c 'ls -A /mnt/_sd2_dst; if echo new > /mnt/_sd2_dst/new.txt; then echo "write OK"; fi'
# L'écriture est arrivée jusqu'à la source sur l'hôte
ls -A $S
sudo systemd-run --quiet --pipe --wait --collect -p BindReadOnlyPaths=$S:/mnt/_sd2_dst \
  sh -c 'if err=$(touch /mnt/_sd2_dst/x 2>&1); then echo "write OK"; else echo "write refused -> ${err##*: }"; fi'
# Systemd a créé le répertoire de destination sur l'hôte
ls -ld /mnt/_sd2_dst
sudo rmdir /mnt/_sd2_dst
hi.txt
write OK
hi.txt
new.txt
write refused -> Read-only file system
drwxr-xr-x 2 root root 4096 Nov  2 15:13 /mnt/_sd2_dst

Le premier essai a listé le fichier et en a écrit un nouveau. Le listing de l’hôte juste après montre que new.txt est arrivé dans le répertoire source. La variante en lecture seule a refusé l’écriture. Systemd a aussi créé sur l’hôte le répertoire de destination vide /mnt/_sd2_dst, et la dernière commande le montre. Supprimez-le vous-même après le test, comme le fait l’extrait.

TemporaryFileSystem= remplace un répertoire par un tmpfs vide. Combiné à un montage lié, il donne une liste blanche : cacher toute une zone, puis montrer seulement ce dont le service a besoin. Ici /var/tmp est caché, puis un répertoire revient :

S=/var/tmp/_sd2_src
mkdir -p $S && echo hi > $S/hi.txt
# Cacher tout /var/tmp ...
sudo systemd-run --quiet --pipe --wait --collect -p TemporaryFileSystem=/var/tmp:ro \
  sh -c 'echo "ls -A /var/tmp:"; ls -A /var/tmp'
# ... puis laisser passer un seul répertoire
sudo systemd-run --quiet --pipe --wait --collect -p TemporaryFileSystem=/var/tmp:ro -p BindReadOnlyPaths=$S \
  sh -c 'echo "ls -A /var/tmp:"; ls -A /var/tmp; cat /var/tmp/_sd2_src/hi.txt'
rm -rf $S
ls -A /var/tmp:
ls -A /var/tmp:
_sd2_src
hi

Le premier listing est vide, et le second ne montre que _sd2_src, dont le fichier est lisible. C’est la forme la plus précise de la protection du système de fichiers, et aussi la plus laborieuse. Je ne l’utilise nulle part pour l’instant.

StateDirectory et les autres directives de répertoire

Cinq directives créent un répertoire géré pour le service et l’ouvrent en écriture, même sous ProtectSystem=strict. Systemd définit aussi une variable d’environnement avec le chemin.

DirectiveRépertoireVariableSupprimé à l’arrêt ?
StateDirectory=/var/lib/NOMSTATE_DIRECTORYnon
CacheDirectory=/var/cache/NOMCACHE_DIRECTORYnon
LogsDirectory=/var/log/NOMLOGS_DIRECTORYnon
RuntimeDirectory=/run/NOMRUNTIME_DIRECTORYoui
ConfigurationDirectory=/etc/NOMCONFIGURATION_DIRECTORYnon

J’ai lancé les cinq d’un coup avec l’utilisateur nobody, sous strict. La sonde affiche les variables, écrit dans chaque répertoire, puis liste ce qui reste sur l’hôte :

N=sd2-demo
# Les cinq réglages *Directory=, sous ProtectSystem=strict, avec l'utilisateur nobody
sudo systemd-run --quiet --pipe --wait --collect -p ProtectSystem=strict -p User=nobody \
  -p StateDirectory=$N -p CacheDirectory=$N -p LogsDirectory=$N -p RuntimeDirectory=$N -p ConfigurationDirectory=$N \
  sh -c 'env | grep -E "^(STATE|CACHE|LOGS|RUNTIME|CONFIGURATION)_DIRECTORY" | sort
         for d in "$STATE_DIRECTORY" "$CACHE_DIRECTORY" "$LOGS_DIRECTORY" "$RUNTIME_DIRECTORY" "$CONFIGURATION_DIRECTORY"; do
           if err=$(touch "$d/x" 2>&1); then echo "$d: write OK"; else echo "$d: write refused -> ${err##*: }"; fi
         done'
# Que reste-t-il sur l'hôte une fois le service arrêté ? (propriétaire et mode)
for p in /var/lib/$N /var/cache/$N /var/log/$N /run/$N /etc/$N; do stat -c "%n %a %U:%G" $p 2>&1; done
CACHE_DIRECTORY=/var/cache/sd2-demo
CONFIGURATION_DIRECTORY=/etc/sd2-demo
LOGS_DIRECTORY=/var/log/sd2-demo
RUNTIME_DIRECTORY=/run/sd2-demo
STATE_DIRECTORY=/var/lib/sd2-demo
/var/lib/sd2-demo: write OK
/var/cache/sd2-demo: write OK
/var/log/sd2-demo: write OK
/run/sd2-demo: write OK
/etc/sd2-demo: write OK
/var/lib/sd2-demo 755 nobody:nobody
/var/cache/sd2-demo 755 nobody:nobody
/var/log/sd2-demo 755 nobody:nobody
stat: cannot statx '/run/sd2-demo': No such file or directory
/etc/sd2-demo 755 nobody:nobody

Les cinq variables existent et les cinq répertoires étaient inscriptibles sous strict. Une fois le service arrêté, quatre répertoires restent et appartiennent à l’utilisateur du service. Le répertoire d’exécution a disparu, car systemd le supprime à l’arrêt. Le mode par défaut est 755, et StateDirectoryMode= le change (les autres directives ont des réglages ...DirectoryMode= équivalents) :

# StateDirectoryMode= change le mode (755 par défaut)
sudo rm -rf /var/lib/sd2-demo
sudo systemd-run --quiet --pipe --wait --collect -p User=nobody -p StateDirectory=sd2-demo -p StateDirectoryMode=0700 \
  stat -c "%n %a %U:%G" /var/lib/sd2-demo
/var/lib/sd2-demo 700 nobody:nobody

Un résultat diffère de mon attente. D’après ma lecture du manuel, ConfigurationDirectory= se distingue des quatre autres pour le propriétaire, et je m’attendais à root. Sur mon banc, le répertoire appartenait à nobody, comme les autres. Je l’ai lancé seul pour vérifier, d’abord avec User=nobody, puis sans aucun User= :

# ConfigurationDirectory= seul : avec User=nobody, puis sans User=
sudo systemd-run --quiet --pipe --wait --collect -p User=nobody -p ConfigurationDirectory=sd2-cfg true
stat -c "%n %a %U:%G" /etc/sd2-cfg; sudo rm -rf /etc/sd2-cfg
sudo systemd-run --quiet --pipe --wait --collect -p ConfigurationDirectory=sd2-cfg true
stat -c "%n %a %U:%G" /etc/sd2-cfg; sudo rm -rf /etc/sd2-cfg
/etc/sd2-cfg 755 nobody:nobody
/etc/sd2-cfg 755 root:root

Le répertoire a donc suivi l’utilisateur du service sur ce système. Vérifiez-le sur votre version avant de vous y fier. Le manuel décrit aussi RuntimeDirectoryPreserve= pour garder le répertoire d’exécution après un arrêt ; je ne l’ai pas testé, il est non testé. Nettoyez maintenant les répertoires de test :

# Nettoyer les répertoires laissés par les tests
sudo rm -rf /var/lib/sd2-demo /var/cache/sd2-demo /var/log/sd2-demo /run/sd2-demo /etc/sd2-demo

Ces directives rendent la protection du système de fichiers plus facile à maintenir. Elles remplacent les lignes ReadWritePaths= écrites à la main et les tâches mkdir et chown qui vont avec. Navidrome, dans ma pile, liste aujourd’hui /var/lib/navidrome et /var/log/navidrome à la main, ce qui en fait un bon candidat pour StateDirectory= et LogsDirectory=.

RestrictFileSystems : une liste blanche de types de systèmes de fichiers

RestrictFileSystems= limite les types de systèmes de fichiers qu’un service peut utiliser, par exemple ext4 xfs seulement, ou ~tmpfs pour interdire tmpfs. Le manuel dit qu’elle repose sur une fonction du noyau, le module de sécurité BPF. Mon banc ne semble pas l’avoir, donc j’ai testé ce qui se passe :

# Le module de sécurité BPF est-il actif ? (RestrictFileSystems= en a besoin)
cat /sys/kernel/security/lsm
# Écrire dans un tmpfs (/dev/shm) alors que RestrictFileSystems=~tmpfs interdit tmpfs
sudo systemd-run --quiet --pipe --wait --collect -p RestrictFileSystems=~tmpfs \
  sh -c 'if err=$(touch /dev/shm/_sd2_rfs 2>&1); then echo "write to tmpfs OK"; else echo "write to tmpfs refused -> ${err##*: }"; fi'
sudo rm -f /dev/shm/_sd2_rfs
cat: /sys/kernel/security/lsm: No such file or directory
write to tmpfs OK

Le fichier qui liste les modules de sécurité actifs n’existe même pas sur ce noyau. L’écriture dans un tmpfs a réussi alors que j’avais interdit tmpfs, et systemd n’a levé aucune erreur. La directive n’a donc eu aucun effet, en silence. Sur un noyau doté du module BPF, elle devrait fonctionner, mais je n’ai pas pu le tester. Avant de vous y fier, lancez cat /sys/kernel/security/lsm sur votre serveur et cherchez bpf dans la liste.

RootDirectory, RootImage et MountAPIVFS

Ces directives vont plus loin que le reste de l’article : elles lancent le service dans une autre racine. RootDirectory= fonctionne comme un chroot, RootImage= monte une image disque comme racine, et MountAPIVFS=yes y ajoute /proc, /sys et /dev. Un tel service ne voit que ce que vous placez dans la nouvelle racine, en général les bibliothèques et outils dont il a besoin. La protection est forte, mais elle demande une vraie préparation, et je n’ai testé aucune des trois. Elles restent non testées ici, et mes services ne les utilisent pas.

Un flux de travail sûr pour tester chaque changement

La partie 1 de la série explique la méthode en détail. Voici la version courte appliquée à l’arborescence. Vous modifiez l’unité par un drop-in, redémarrez, lisez le journal et, si besoin, revenez en arrière :

# Ouvrir (ou créer) le drop-in override.conf d'une unité dans votre éditeur ; systemd le recharge à l'enregistrement
sudo systemctl edit myapp.service
# Afficher l'unité et tous ses drop-ins, fusionnés, dans l'ordre où systemd les lit
systemctl cat myapp.service
# Un rechargement ne suffit pas pour un processus en cours : redémarrer le service, puis lire le journal
sudo systemctl restart myapp.service
journalctl -u myapp.service -n 20 --no-pager -o cat
# Annuler : supprimer tous les drop-ins de l'unité
sudo systemctl revert myapp.service

Vous pouvez aussi essayer une directive sans aucun fichier. systemd-run -p démarre une unité temporaire avec les propriétés choisies, et systemctl show -p vous dit ce que systemd a réellement appliqué :

# Démarrer une unité temporaire de longue durée avec trois propriétés
sudo systemd-run --quiet --unit=demo-hardening-fs-show --collect \
  -p ProtectSystem=strict -p ReadWritePaths=/var/tmp -p PrivateTmp=yes sleep 30
# Demander à systemd ce qu'il a réellement appliqué
systemctl show demo-hardening-fs-show.service -p ProtectSystem -p ReadWritePaths -p PrivateTmp
sudo systemctl stop demo-hardening-fs-show.service
systemctl is-active demo-hardening-fs-show.service
ReadWritePaths=/var/tmp
PrivateTmp=yes
ProtectSystem=strict
inactive

systemctl show affiche les propriétés dans son propre ordre, pas dans celui des options -p. Après systemctl stop, l’unité transitoire avait disparu et systemctl is-active répondait « inactive ».

Labo pratique : voir l’arborescence changer

Ce labo montre la protection du système de fichiers à l’œuvre sur un service inoffensif qui essaie seulement de créer un fichier vide à cinq endroits. Vous le lancez huit fois, avec un drop-in différent à chaque fois. Commencez par créer le script et l’unité :

# 1. Un script inoffensif : il essaie seulement de créer un fichier vide à cinq endroits
sudo mkdir /home/demo-hardening-dir
sudo tee /usr/local/bin/demo-hardening-fs.sh > /dev/null <<'EOF'
#!/bin/sh
echo "entries in /home: $(ls -A /home | wc -l)"
for d in /etc /home /home/demo-hardening-dir /tmp /var/tmp; do
  if err=$(touch "$d/demo-hardening-test" 2>&1); then echo "$d: write OK"
  else echo "$d: write refused (${err##*: })"; fi
done
EOF
sudo chmod 755 /usr/local/bin/demo-hardening-fs.sh

# 2. Un service one-shot qui lance le script
sudo tee /etc/systemd/system/demo-hardening-fs.service > /dev/null <<'EOF'
[Unit]
Description=Filesystem protection demo (harmless)

[Service]
Type=oneshot
ExecStart=/usr/local/bin/demo-hardening-fs.sh
EOF
sudo systemctl daemon-reload

Définissez ensuite une petite fonction d’aide. Elle remplace le drop-in par le texte que vous lui donnez, lance le service et affiche le journal :

# try : remplacer le drop-in par le texte lu sur l'entrée standard, lancer l'unité, afficher les 9 dernières lignes du journal
try() {
  sudo rm -rf /etc/systemd/system/demo-hardening-fs.service.d
  local c; c="$(cat)"
  if [ -n "$c" ]; then
    sudo mkdir -p /etc/systemd/system/demo-hardening-fs.service.d
    printf '%s\n' "$c" | sudo tee /etc/systemd/system/demo-hardening-fs.service.d/override.conf > /dev/null
  fi
  sudo systemctl daemon-reload
  sudo systemctl start demo-hardening-fs.service
  sudo journalctl -u demo-hardening-fs.service -n 9 --no-pager -o cat
  # supprimer les fichiers de test créés par le script
  sudo rm -f /etc/demo-hardening-test /home/demo-hardening-test /home/demo-hardening-dir/demo-hardening-test \
             /tmp/demo-hardening-test /var/tmp/demo-hardening-test
}

Lancez la référence et la première expérience :

# E0 : aucun drop-in, rien n'est restreint
: | try
# E1 : toute l'arborescence en lecture seule
printf '[Service]\nProtectSystem=strict\n' | try

Sans drop-in (E0), les cinq écritures réussissent. Avec ProtectSystem=strict (E1), j’ai obtenu ce journal. Trois écritures sur cinq sont refusées, mais /home et le répertoire de démonstration qu’il contient restent inscriptibles, comme dans la sonde précédente :

Starting demo-hardening-fs.service - Filesystem protection demo (harmless)...
entries in /home: 2
/etc: write refused (Read-only file system)
/home: write OK
/home/demo-hardening-dir: write OK
/tmp: write refused (Read-only file system)
/var/tmp: write refused (Read-only file system)
demo-hardening-fs.service: Deactivated successfully.
Finished demo-hardening-fs.service - Filesystem protection demo (harmless).

Ajoutez maintenant PrivateTmp=yes (E2), puis ouvrez /etc (E3), et lisez l’unité fusionnée :

# E2 : ajouter un /tmp et un /var/tmp privés
printf '[Service]\nProtectSystem=strict\nPrivateTmp=yes\n' | try
# E3 : ouvrir aussi /etc
printf '[Service]\nProtectSystem=strict\nPrivateTmp=yes\nReadWritePaths=/etc\n' | try
# L'unité et son drop-in, fusionnés
systemctl cat demo-hardening-fs.service --no-pager
# /etc/systemd/system/demo-hardening-fs.service
[Unit]
Description=Filesystem protection demo (harmless)

[Service]
Type=oneshot
ExecStart=/usr/local/bin/demo-hardening-fs.sh

# /etc/systemd/system/demo-hardening-fs.service.d/override.conf
[Service]
ProtectSystem=strict
PrivateTmp=yes
ReadWritePaths=/etc

La vue fusionnée prouve que systemd a lu votre drop-in. En E2, /tmp et /var/tmp acceptent à nouveau les écritures. En E3, /etc aussi. Voyons maintenant le répertoire personnel, en quatre expériences :

# E4 : cacher /home complètement
printf '[Service]\nProtectSystem=strict\nPrivateTmp=yes\nProtectHome=yes\n' | try
# E5 : garder /home visible mais en lecture seule
printf '[Service]\nProtectSystem=strict\nPrivateTmp=yes\nProtectHome=read-only\n' | try
# E6 : /home en lecture seule, avec un sous-répertoire inscriptible
printf '[Service]\nProtectSystem=strict\nPrivateTmp=yes\nProtectHome=read-only\nReadWritePaths=/home/demo-hardening-dir\n' | try
# E7 : /home caché, avec le même sous-répertoire inscriptible
printf '[Service]\nProtectSystem=strict\nPrivateTmp=yes\nProtectHome=yes\nReadWritePaths=/home/demo-hardening-dir\n' | try

En E4, ProtectHome=yes cache tout, et le répertoire de démonstration est absent :

Starting demo-hardening-fs.service - Filesystem protection demo (harmless)...
entries in /home: 0
/etc: write refused (Read-only file system)
/home: write refused (Read-only file system)
/home/demo-hardening-dir: write refused (No such file or directory)
/tmp: write OK
/var/tmp: write OK
demo-hardening-fs.service: Deactivated successfully.
Finished demo-hardening-fs.service - Filesystem protection demo (harmless).

En E6, read-only plus le sous-répertoire exact est la combinaison qui marche :

Starting demo-hardening-fs.service - Filesystem protection demo (harmless)...
entries in /home: 2
/etc: write refused (Read-only file system)
/home: write refused (Read-only file system)
/home/demo-hardening-dir: write OK
/tmp: write OK
/var/tmp: write OK
demo-hardening-fs.service: Deactivated successfully.
Finished demo-hardening-fs.service - Filesystem protection demo (harmless).

Ce tableau résume les huit essais. Chaque cellule est une réponse des vrais journaux :

Essai/etc/home/home/demo-hardening-dir/tmp/var/tmp
E0 aucun drop-inOKOKOKOKOK
E1 ProtectSystem=strictrefuséeOKOKrefuséerefusée
E2 + PrivateTmp=yesrefuséeOKOKOKOK
E3 + ReadWritePaths=/etcOKOKOKOKOK
E4 + ProtectHome=yesrefuséerefuséeabsentOKOK
E5 + ProtectHome=read-onlyrefuséerefuséerefuséeOKOK
E6 read-only + sous-répertoire inscriptiblerefuséerefuséeOKOKOK
E7 yes + sous-répertoire inscriptiblerefuséerefuséeabsentOKOK

La ligne E7 est de nouveau le piège : le sous-répertoire inscriptible est invisible sous ProtectHome=yes. Enfin, annulez tout. La première commande montre ce que systemctl revert supprime :

# Annuler le drop-in avec systemctl revert, puis supprimer tout ce que le labo a créé
sudo systemctl revert demo-hardening-fs.service
sudo rm -f /etc/systemd/system/demo-hardening-fs.service /usr/local/bin/demo-hardening-fs.sh
sudo rmdir /home/demo-hardening-dir
sudo systemctl daemon-reload
ls /etc/systemd/system | grep demo-hardening-fs || echo "no demo-hardening-fs unit file left"
Removed '/etc/systemd/system/demo-hardening-fs.service.d/override.conf'.
Removed '/etc/systemd/system/demo-hardening-fs.service.d'.
no demo-hardening-fs unit file left

La dernière ligne confirme qu’aucun fichier d’unité ne reste. J’ai aussi vérifié que le script de démonstration, le répertoire de démonstration et les fichiers de test dans /etc, /home, /tmp et /var/tmp avaient disparu.

Un drop-in complet pour une application web typique

Assemblons les morceaux. Ce drop-in convient à un service qui garde ses données dans /var/lib, écrit un journal et enregistre une sauvegarde dans un répertoire supplémentaire. J’ai testé chacune de ses directives séparément, et ProtectSystem, PrivateTmp et ProtectHome ensemble dans le labo ci-dessus. Je n’ai pas lancé ce fichier exact sur une vraie application : adaptez donc les noms et testez-le comme dans la section sur le flux de travail.

[Service]
# Rendre toute l'arborescence en lecture seule, puis ouvrir les exceptions ci-dessous
ProtectSystem=strict
# Cacher /home, /root et /run/user
ProtectHome=yes
# /tmp et /var/tmp privés, supprimés à l'arrêt du service
PrivateTmp=yes
# systemd crée /var/lib/myapp, le donne à l'utilisateur du service et le garde inscriptible
StateDirectory=myapp
# Idem pour /var/log/myapp
LogsDirectory=myapp
# Un chemin inscriptible de plus ; le tiret initial ignore le chemin s'il n'existe pas encore
ReadWritePaths=-/srv/backup/myapp
Protection du système de fichiers dans une unité : lecture seule avec quatre exceptions voulues
Une hiérarchie en lecture seule où chaque chemin inscriptible est une décision voulue.

Chaque chemin qui reste inscriptible dans cette unité est une décision écrite dans le fichier. C’est tout l’intérêt de la protection du système de fichiers : l’unité documente ce que le service peut toucher.

Erreurs courantes

La plupart des échecs de la protection du système de fichiers viennent de six erreurs. Je les ai toutes faites au moins une fois.

Erreur 1 : un chemin inscriptible qui n’existe pas encore

Le service refuse de démarrer avec le code de sortie 226. Créez d’abord le répertoire, utilisez StateDirectory= ou ajoutez le tiret initial.

Erreur 2 : ReadWritePaths sous ProtectHome=yes

L’exception est invisible, sans message. Utilisez ProtectHome=read-only avec le sous-répertoire exact, ou tmpfs avec BindPaths=.

Erreur 3 : strict sans PrivateTmp

/tmp passe en lecture seule et le programme échoue à son premier fichier temporaire. Ajoutez PrivateTmp=yes.

Erreur 4 : se fier à strict pour les répertoires personnels

Sur mon banc, /home et /root sont restés inscriptibles sous strict. Ajoutez ProtectHome= et mesurez.

Erreur 5 : ouvrir tout un répertoire parent

ReadWritePaths=/var ouvre bien plus que ce dont le service a besoin. Nommez le seul sous-répertoire, ou laissez un réglage *Directory= le créer.

Erreur 6 : oublier de redémarrer

Un rechargement ne change pas un processus en cours. Redémarrez le service, puis testez son vrai travail et pas seulement son démarrage.

Une liste de contrôle à suivre

Suivez ces étapes chaque fois que vous ajoutez la protection du système de fichiers à un service.

  1. Lancez systemctl cat UNITÉ et notez où le service écrit aujourd’hui.
  2. Ajoutez ProtectSystem=strict et PrivateTmp=yes dans un drop-in.
  3. Ajoutez ProtectHome=yes, ou read-only si le service a besoin d’un chemin sous /home.
  4. Remplacez les répertoires faits à la main par StateDirectory=, CacheDirectory= et LogsDirectory=.
  5. Ajoutez ReadWritePaths= pour chaque chemin restant, avec un tiret pour les chemins facultatifs.
  6. Redémarrez le service et exercez son vrai travail, sauvegardes et tâches planifiées comprises.
  7. Lisez journalctl -u UNITÉ à la recherche de « Read-only file system » et reprenez à l’étape 5.
  8. Gardez le drop-in sous gestion de versions, pour que la décision reste documentée.

Ce que j’en retiens

  • La protection du système de fichiers est une liste de décisions. Chaque chemin inscriptible de l’unité est une décision, et l’unité la documente.
  • Fermer d’abord, ouvrir ensuite. strict plus quelques exceptions se relit plus facilement qu’une longue liste d’interdictions.
  • Les erreurs ont un autre visage. « Read-only file system » et « No such file or directory » signalent le plus souvent une règle du bac à sable, pas une permission.
  • Les exceptions demandent des chemins exacts. Le parent d’un chemin n’ouvre pas ce chemin, et ProtectHome=yes ne se rouvre pas.
  • Laissez systemd créer les répertoires. Les réglages *Directory= donnent le bon propriétaire et le bon mode.
  • Ne faites pas confiance aveuglément à une directive. Plusieurs résultats diffèrent ici de mon attente : /home sous strict, le propriétaire de ConfigurationDirectory=, PrivateTmp=disconnected via systemd-run et RestrictFileSystems=. Mesurez sur votre propre système.
  • Surveillez les échecs silencieux. Une sauvegarde qui ne peut pas écrire échoue sans aucune alarme, comme l’ont montré les archives de 122 octets.

Sources

Plus tôt dans la série

Articles liés

  • <a href= »https://blog.neurozone.fr/?p=2045″>Pas à pas : installer, configurer et vérifier un serveur mail avec mox</a>
  • <a href= »https://blog.neurozone.fr/?p=2930″>ZDI-CAN-33367 : quand une copie évitée écrit dans un fichier en lecture seule</a>
  • <a href= »https://blog.neurozone.fr/?p=2047″>Pas à pas : Suricata en IPS avec NFQUEUE, sans casser son serveur</a>
Mettre à jour Pi-hole en cinq étapes : versions, sauvegarde Teleporter, mise à jour, test du blocage, comparaison

Pas à pas : mettre à jour Pi-hole et vérifier qu’il bloque encore

Pour mettre à jour Pi-hole sur mon réseau domestique, je lance une seule commande, mais je ne lui fais jamais confiance seule. Dans ce pas à pas, je décris comment mettre à jour Pi-hole en six étapes. L’étape qui compte le plus vérifie que le blocage fonctionne encore, et pas seulement que les noms se résolvent.

Réponse rapide — mettre à jour Pi-hole et prouver qu’il bloque encore.

pihole -v                                   # versions avant
pihole-FTL --teleporter                     # sauvegarde de la configuration
PIHOLE_SKIP_OS_CHECK=true pihole -up        # mise à jour
dig +short doubleclick.net @192.0.2.19      # doit afficher 0.0.0.0 (bloqué)

Les détails, les explications et les vérifications suivent plus bas.

Mon Pi-hole tourne sur un Raspberry Pi avec Debian 12 et sert de seul serveur DNS de la maison. Par conséquent, chaque redémarrage du service DNS provoque une petite coupure. Mon rôle Ansible ne gère pas les versions de Pi-hole, donc je fais la mise à jour à la main. J’envoie les commandes avec une commande Ansible ad hoc depuis ma machine de contrôle, mais je montre ici les commandes elles-mêmes.

Mettre à jour Pi-hole en cinq étapes : versions, sauvegarde Teleporter, mise à jour, test du blocage, comparaison
Les cinq contrôles autour d’une commande. L’étape 4 est celle qui a détecté un vrai problème.

Avant de commencer

  • Un shell sur la machine Pi-hole avec les droits root.
  • L’adresse de votre Pi-hole et celle de votre routeur. Dans cet article, ce sont 192.0.2.19 et 192.0.2.1.
  • Quelques minutes de libres. Dans mes notes, le DNS du réseau local redémarre pendant quelques secondes, et le blocage des publicités peut s’arrêter pendant environ cinq minutes (voir l’étape 4).
  • Les notes de version de Pi-hole. La page officielle de mise à jour demande de les lire pour chaque composant avant de mettre à jour, surtout pour une version majeure.

Comment mettre à jour Pi-hole, étape par étape

Étape 1 : vérifier les versions

D’abord, je liste ce que j’utilise maintenant. La sortie donne les versions de Core, de Web et de FTL.

pihole -v

Étape 2 : sauvegarder la configuration

Ensuite, je sauvegarde deux fois : avec Teleporter, l’export propre à Pi-hole, et avec une simple copie du fichier TOML. Je travaille dans un dossier daté, pour que les deux restent ensemble.

mkdir -p /root/pre-update-$(date +%Y%m%d) && cd $_   # un dossier daté, puis on y entre
pihole-FTL --teleporter                                # l'archive Teleporter
cp -a /etc/pihole/pihole.toml pihole.toml.bak          # une copie du fichier de configuration
ls -la                                                 # vérifier que les deux sont là

La copie du fichier TOML sert encore à l’étape 5.

Étape 3 : lancer la mise à jour

Vient maintenant la mise à jour elle-même. Je garde les 20 dernières lignes de sa sortie, j’affiche à nouveau les versions, et je demande à systemd si le service DNS tourne.

PIHOLE_SKIP_OS_CHECK=true pihole -up 2>&1 | tail -20   # mise à jour, on garde les 20 dernières lignes
pihole -v                                              # versions après la mise à jour
systemctl is-active pihole-FTL                         # doit afficher : active

Mes notes utilisent PIHOLE_SKIP_OS_CHECK=true, qui saute le contrôle du système d’exploitation par l’installeur. La page de mise à jour de Pi-hole ne le mentionne pas, donc testez-le sur votre système avant de le copier.

Étape 4 : tester le blocage, pas seulement la résolution

Cette étape est obligatoire pour moi. Le 29 octobre 2026, FTL, le moteur DNS de Pi-hole, a pris de vitesse le remplacement de la base gravity. Le journal affichait no such table: main.gravity dans /var/log/pihole/FTL.log, et Pi-hole n’a rien bloqué pendant environ cinq minutes. Cela s’est arrêté seulement quand FTL a écrit son propre message : Gravity database has been replaced, reloading now.

Pendant ces minutes, les noms se résolvaient toujours. Donc un simple test de résolution m’aurait dit que tout allait bien.

dig +short doubleclick.net @192.0.2.19   # doit afficher 0.0.0.0 (bloqué)
dig +short example.com @192.0.2.19       # doit afficher une vraie adresse
dig +short doubleclick.net @192.0.2.1    # via le routeur : doit aussi afficher 0.0.0.0

La troisième requête passe par le routeur. Sur mon réseau, le routeur transmet ses requêtes à Pi-hole, donc une réponse bloquée à cet endroit prouve tout le chemin.

Si le blocage ne fonctionne pas après cinq minutes, je recharge la configuration DNS, puis je lis le journal de FTL.

pihole reloaddns

Étape 5 : vérifier que la configuration n’a pas changé

Une mise à jour peut toucher la configuration. Je compare donc ma sauvegarde avec le fichier en place, en écartant les commentaires et les lignes qui contiennent des empreintes de mot de passe.

diff <(grep -vE '^\s*#|pwhash|password|totp' /root/pre-update-*/pihole.toml.bak) \
     <(grep -vE '^\s*#|pwhash|password|totp' /etc/pihole/pihole.toml)

Aucune sortie signifie aucune différence.

Étape 6 : synchroniser le mot de passe d’administration s’il a changé

Si le mot de passe d’administration a changé pour une raison quelconque, je mets à jour mon gestionnaire de secrets le jour même. En août 2026, je l’ai oublié une fois, et chaque déploiement de mon rôle Ansible a échoué jusqu’à la correction.

Vérifier que tout a fonctionné

  • pihole -v affiche les nouvelles versions.
  • systemctl is-active pihole-FTL affiche active.
  • La première et la troisième requête dig affichent 0.0.0.0, et la deuxième affiche une vraie adresse.
  • Le diff n’affiche rien.

Si quelque chose se passe mal

  • Le blocage ne fonctionne pas après cinq minutes : lancez pihole reloaddns, puis lisez /var/log/pihole/FTL.log.
  • Vous voulez revenir en arrière : pihole -up ne peut pas réinstaller une version précédente. À la place, restaurez l’archive Teleporter sur une installation neuve avec pihole-FTL --teleporter <zip>.

Ce que j’en retiens

  • Je sauvegarde deux fois avant de mettre à jour Pi-hole, parce qu’il n’existe pas de retour en arrière.
  • Je teste le blocage, parce que la résolution seule a caché un trou de cinq minutes.
  • Je compare la configuration, parce que je veux savoir ce que la mise à jour a changé.

Sources

Articles liés

Les fichiers SQLite : le fichier principal et ses voisins journal, WAL et mémoire partagée

Dans les fichiers d’une base de données (4/3+1) : SQLite

SQLite est l’intrus de cette série : pas de serveur, pas de répertoire de données, pas de processus d’arrière-plan. Les fichiers SQLite tiennent dans un seul fichier ordinaire que l’on peut lire avec un vidage hexadécimal. Cet article prolonge les trois premiers, InnoDB, PostgreSQL et Oracle avec les trois côte à côte. Le tableau final ne remplace rien : il ajoute une quatrième colonne à la comparaison.

J’ai rencontré SQLite dans d’autres outils, par exemple ProxySQL, qui garde sa configuration dans une base SQLite. Alors j’ai voulu voir les octets. Tout ce qui suit vient d’une base de laboratoire : testé sur Rocky Linux 10.2, SQLite 3.46.1, WSL2. Je prévois aussi une série plus détaillée en sept parties, « SQLite from the inside », pour 2027. Cet article reste court et suit le même plan que les trois autres.

Un fichier, jusqu’à trois voisins

Les fichiers SQLite : le fichier principal et ses voisins journal, WAL et mémoire partagée
Une base, c’est un fichier. Le journal, le WAL et le shm n’existent que lorsque SQLite en a besoin.

Une base SQLite est un seul fichier, qu’un programme ouvre directement. Dans le mode par défaut, un deuxième fichier n’apparaît que pendant une transaction d’écriture. C’est le journal de retour arrière, et il garde la version d’origine de chaque page que la transaction modifie.

-rw-r--r--. 1 root root 8192 Nov  2 21:21 demo.db
-rw-r--r--. 1 root root 4616 Nov  2 21:21 demo.db-journal

Le journal fait 4 616 octets. Son en-tête l’explique : un secteur de 512 octets, puis un enregistrement de page de 4 + 4 096 + 4 octets (numéro de page, page, somme de contrôle). Au COMMIT, le journal a disparu. Pendant la transaction, ses huit premiers octets, là où se trouve la chaîne magique, valaient encore zéro. Je n’ai pas testé pourquoi, donc je rapporte seulement ce que j’ai vu.

En mode WAL, deux autres fichiers apparaissent : le fichier -wal, où s’ajoutent les nouvelles versions de pages, et le fichier -shm, un index de 32 Kio en mémoire partagée. Contrairement aux autres modes de journal, le mode WAL est enregistré dans la base : il survit à un redémarrage. Les deux fichiers disparaissent à la fermeture propre de la dernière connexion, comme le dit la documentation.

L’en-tête de 100 octets

L'en-tête de 100 octets d'un fichier de base SQLite avec les valeurs lues dans le laboratoire
L’en-tête, champ par champ, avec les valeurs lues dans la base du laboratoire.

Chaque fichier de base SQLite commence par un en-tête de 100 octets. Les 16 premiers octets sont le texte SQLite format 3 et un octet nul. Viennent ensuite la taille de page, le compteur de changements, la taille en pages, la liste libre, le cookie de schéma, l’encodage du texte et la version de la bibliothèque qui a écrit le fichier. Tous les nombres sont en gros-boutiste.

$ xxd -l 32 demo.db
00000000: 5351 4c69 7465 2066 6f72 6d61 7420 3300  SQLite format 3.
00000010: 1000 0101 0040 2020 0000 0002 0000 0002  .....@  ........

J’ai décodé les champs avec quelques lignes de Python, et le client en ligne de commande est d’accord.

$ sqlite3 demo.db ".dbinfo"
database page size:  4096
file change counter: 2
database page count: 2
freelist page count: 0
schema cookie:       1
text encoding:       1 (utf8)
[...]
software version:    3046001

Deux champs sont à ta disposition. PRAGMA user_version et PRAGMA application_id écrivent directement dans les octets 60 à 71 : après avoir réglé 42 et 1234567890, les octets valent 0000 002a et 4996 02d2. Beaucoup d’outils s’en servent pour marquer le format d’un fichier.

Pages et arbres B dans les fichiers SQLite

Après l’en-tête, le fichier est une suite de pages de même taille, ici 4 096 octets. La page 1 contient l’en-tête et la table de schéma, sqlite_schema. Chaque table est un arbre B classé par son rowid, et chaque index est un autre arbre B. Chaque arbre a une page racine, dont le numéro est dans sqlite_schema. Ce numéro n’a jamais changé pendant mes tests, même quand l’arbre grandissait. La table virtuelle dbstat, compilée dans le paquet Rocky, compte les pages de chaque arbre.

name|pagetype|pages|cells|payload|unused
customers|internal|1|21|0|3917
customers|leaf|22|2000|77781|2282
idx_email|internal|1|13|316|3677
idx_email|leaf|14|1987|48449|2822
sqlite_schema|leaf|1|2|186|3794

Avec 2 000 lignes, la table a besoin d’une page interne et de 22 feuilles. L’index est un arbre à part, avec une page interne et 14 feuilles. Dans un index, les cellules internes portent aussi des entrées : 13 + 1 987 donnent les 2 000 clés. Une page interne de table ne porte que des clés et des pointeurs vers les enfants.

Deux arbres B SQLite, une table et un index, et une chaîne de débordement
La forme des arbres mesurée avec dbstat, et la règle de débordement vérifiée avec la documentation.

Une table déclarée WITHOUT ROWID est stockée dans un seul arbre, classé par sa clé primaire. Une table normale avec une clé texte a besoin de deux arbres, la table et un index automatique.

type|name|tbl_name|rootpage
table|kv|kv|45                      -- WITHOUT ROWID: one tree
table|kv2|kv2|46                    -- rowid table with a TEXT primary key: the table...
index|sqlite_autoindex_kv2_1|kv2|47 -- ...and a second tree for the key

Les grandes valeurs quittent la page. Avec une valeur de 20 000 caractères, la feuille a gardé 3 637 octets et quatre pages de débordement ont porté le reste, 4 092 octets chacune. La documentation donne la règle, avec U = 4 096 et une charge P = 20 005 : X = U – 35 = 4 061 et M = 489. Comme P dépasse X, la partie locale vaut K = M + ((P – M) % (U – 4)) = 3 637. C’est exactement ce que rapporte dbstat.

name|pageno|pagetype|ncell|payload|unused|mx_payload
notes|40|leaf|1|3637|441|20005
notes|41|overflow|0|4092|0|0
notes|42|overflow|0|4092|0|0
notes|43|overflow|0|4092|0|0
notes|44|overflow|0|4092|0|0

Anatomie d’une page

Anatomie d'une page feuille de table SQLite : en-tête, pointeurs, espace libre et cellules
La page 2 de la base du laboratoire. Les pointeurs croissent depuis le début, les cellules depuis la fin.

Une page d’arbre B a un en-tête de 8 octets sur une feuille (12 sur une page interne), puis un tableau de pointeurs de 2 octets vers les cellules. Les cellules elles-mêmes sont écrites depuis la fin de la page, donc l’espace libre se trouve au milieu. Sur la page 2 du laboratoire, le premier octet est 0d (une feuille de table), il y a 2 cellules, et le contenu commence au décalage 4 038.

$ xxd -s 4096 -l 16 demo.db
00001000: 0d00 0000 020f c600 0fe1 0fc6 0000 0000  ................
$ xxd -s 8128 -l 64 demo.db        # the end of page 2, where the cells live
00001fc0: 0000 0000 0000 1902 0500 132b 1142 6f62  ...........+.Bob
00001fd0: 626f 6240 6578 616d 706c 652e 6e65 7444  bob@example.netD
00001fe0: 451d 0105 0017 2f11 416c 6963 6561 6c69  E...../.Aliceali
00001ff0: 6365 4065 7861 6d70 6c65 2e6e 6574 4652  ce@example.netFR

L’espace libéré dans la zone de contenu devient un bloc libre, une petite liste chaînée dans la page. Les trous de 1 à 3 octets sont seulement comptés comme octets fragmentés dans l’en-tête.

Un enregistrement, octet par octet

Une cellule contient une taille de données, un rowid et un enregistrement. Les tailles et les rowids sont des entiers variables : 1 à 9 octets, 7 bits à la fois, et le bit de poids fort signifie qu’un octet suit. L’enregistrement commence par la taille de son en-tête, puis un type par colonne. Un type de 13 ou plus et impair désigne du texte, et la longueur vaut (type – 13) / 2. Le type 0 désigne NULL. Ici la colonne id est le rowid : SQLite stocke NULL et garde la valeur dans la clé de la cellule.

1d 01 05 00 17 2f 11 41 6c 69 63 65 61 6c 69 63 65 40 65 78 61 6d 70 6c 65 2e 6e 65 74 46 52
|  |  |  |  |  |  '----- 'Alice' 'alice@example.net' 'FR' (5 + 17 + 2 bytes)
|  |  |  |  |  '-- serial type 17: text of 2 bytes
|  |  |  |  '----- serial type 47: text of 17 bytes
|  |  |  '-------- serial type 23: text of 5 bytes
|  |  '----------- serial type 0: NULL (id is the rowid)
|  '-------------- record header: 5 bytes
'----------------- rowid 1, payload of 29 bytes (1d is the payload size, 01 the rowid)

SELECT rowid, id, name, email, country FROM customers renvoie 1|1|Alice|alice@example.net|FR : le décodage est juste.

UPDATE et DELETE sur le disque

Rien dans les fichiers SQLite ne fonctionne comme un stock d’annulation. SQLite modifie la page elle-même, et il garde l’ancienne version dans le journal ou le WAL. Chaque changement validé incrémente le compteur de changements dans l’en-tête. Un UPDATE de même taille a réécrit la valeur sur place, avec le même nombre de cellules et le même espace libre, mais le compteur est passé de 7 à 8.

-- page 3 is the first leaf of customers
before          change counter 7   page 3: ncell 102, payload 3655, unused 25    page_count 39
same-size UPDATE        counter 8   page 3: ncell 102, payload 3655, unused 25
larger UPDATE           counter 9   page 3: ncell  89, payload 3242, unused 490   page_count 40

L’UPDATE plus grand a fait davantage. La page était presque pleine, donc elle a dû se diviser : la page 3 est passée de 102 à 89 cellules, le fichier a gagné une page et la racine un pointeur. En bref, une ligne qui grossit peut coûter une page.

Un DELETE libère la cellule et transforme son espace en bloc libre. Le paquet Rocky est compilé avec SECURE_DELETE, donc PRAGMA secure_delete renvoie 1 et les octets libérés sont mis à zéro. Avec le réglage désactivé, deux occurrences de l’adresse e-mail sont restées dans le fichier.

$ sqlite3 del.db "PRAGMA secure_delete;"
1
-- page 3 header after DELETE FROM customers WHERE id=5:
cells 101 | first freeblock offset 3921 | fragmented bytes 0
freeblock at 3921: next 0, size 36 bytes
its bytes: 00 00 00 24 00 00 00 00 00 00 00 00 [...] 00 00 00 00     <- zeroed
$ grep -a -c "user5@example.net" del.db       # secure_delete on
0
$ sqlite3 del2.db "PRAGMA secure_delete=OFF; DELETE FROM customers WHERE id=5;"
$ grep -a -c "user5@example.net" del2.db      # secure_delete off
2

Pourquoi les fichiers SQLite ne rétrécissent pas

Quand une page entière se vide, elle rejoint la liste libre, que décrivent les octets 32 à 39 de l’en-tête. Le fichier garde sa taille. Après un DELETE de 1 800 lignes, 31 pages sur 39 étaient libres, et le fichier faisait toujours 159 744 octets. VACUUM l’a reconstruit en 32 768 octets.

before DELETE         page_count 39   freelist_count 0    size 159744
DELETE ... id > 200   page_count 39   freelist_count 31   size 159744   (header bytes 32-39: 0000 0006 0000 001f)
after VACUUM          page_count 8    freelist_count 0    size 32768

Avec auto_vacuum en mode incrémental, on peut rendre des pages par étapes. L’octet 52 de l’en-tête contient alors la plus grande page racine, et l’octet 64 passe à 1. La page 2 devient une table de pointeurs, faite d’entrées de 5 octets : un type et une page parente. dbstat saute cette page.

PRAGMA auto_vacuum=INCREMENTAL; VACUUM;    -> header byte 52 = 4, byte 64 = 1
DELETE ... id > 200                         page_count 40  freelist_count 31  size 163840
PRAGMA incremental_vacuum(5);               page_count 35  freelist_count 26  size 143360
PRAGMA incremental_vacuum;                  page_count  9  freelist_count  0  size  36864
page 2 (pointer map) starts: 01 00000000 | 01 00000000 | 05 00000003 | 05 00000003 | ...

Un type de page est documenté mais non testé ici : la page d’octet verrou, qui n’existe que si le fichier dépasse 1 Gio.

Le WAL

Comment le WAL de SQLite ajoute des trames et comment un point de contrôle les copie
Trois trames mesurées dans le WAL, puis des points de contrôle PASSIVE et TRUNCATE.

En mode WAL, les fichiers SQLite changent dans un autre ordre : un écrivain ajoute d’abord des trames au fichier -wal. Chaque trame est un en-tête de 24 octets suivi d’une page. Une trame dont le champ de taille n’est pas nul est un commit. Les lecteurs utilisent le dernier commit et l’index shm pour trouver la bonne version de chaque page.

-rw-r--r--. 1 root root 159744 Nov  2 21:23 wal.db
-rw-r--r--. 1 root root  32768 Nov  2 21:23 wal.db-shm
-rw-r--r--. 1 root root  12392 Nov  2 21:23 wal.db-wal
WAL magic       : 0x377f0682
format version  : 3007000
page size       : 4096
checkpoint seq  : 0
file size       : 12392 bytes = 32 + 3 frames x (24 + 4096)
  frame 1: page 24, commit-size-after 0 (not a commit frame)
  frame 2: page 39, commit-size-after 39
  frame 3: page 3, commit-size-after 39

Un point de contrôle copie les trames dans le fichier principal. Un point de contrôle PASSIVE l’a fait sans toucher au fichier WAL, alors que TRUNCATE l’a vidé. J’ai désactivé le point de contrôle automatique pour garder les trames visibles ; par défaut, il se déclenche à 1 000 pages.

PRAGMA wal_checkpoint(PASSIVE);     -> 0|3|3     (busy, frames in the WAL, frames copied)  -wal still 12392 bytes
PRAGMA wal_checkpoint(TRUNCATE);    -> 0|0|0                                              -wal now 0 bytes
last connection closes              -> demo.db-wal and demo.db-shm are gone

Les quatre moteurs côte à côte

Voici comment les fichiers SQLite se comparent aux trois premières parties, avec les valeurs par défaut.

InnoDBPostgreSQLOracleSQLite
Où vivent les donnéesfichiers de tablespace, un par table par défautun fichier par table ou index, en segmentsdatafiles dans des tablespacesun seul fichier pour tout
Unité d’E/Spage de 16 Kopage de 8 Kobloc, 8 Ko par défautpage, 4 096 octets ici
Format d’une ligneindex clusterisé : la table est l’arbre de la clé primairetas, les index y pointentbloc avec un répertoire de lignes et un ROWIDarbre B classé par rowid, ou par clé pour WITHOUT ROWID
Anciennes versionsjournaux d’annulation, à partdans la table, nettoyées par VACUUMtablespace d’annulationaucune : le journal ou le WAL les garde jusqu’au commit
Sécurité en cas de pannejournal de reprise et doublewrite bufferWAL et écriture de pages complètesjournaux de reprisejournal de retour arrière ou WAL
Récupérer de la placereconstruire la tableVACUUM, VACUUM FULLshrink, moveVACUUM, incremental_vacuum

Le plus proche cousin de SQLite ici est PostgreSQL pour le WAL, et InnoDB pour l’arbre. La grande différence est qu’aucun processus serveur ne se tient entre ton programme et le fichier : le format du fichier et les verrous de fichier du système portent les garanties.

Sources

Cet article fait partie d’une série de notes d’admin système (étiquette « carnet d’admin »).
Série « Dans les fichiers d’une base de données », partie 4/3+1. · ← Article précédent

Articles liés

Page 1 of 34

Propulsé par WordPress & Thème par Anders Norén