Quelques pensées

Terres dévastées

Vallée de montagne enneigée entre deux sommets rocheux, sous un ciel bleu
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

Échelle des bannissements fail2ban de 1 h à 30 jours, avec la prison recidive et les réglages importants

Pas à pas : fail2ban bien configuré, avec bannissements progressifs

fail2ban est l’un des outils les plus anciens et les plus répandus de la boîte à outils de l’administrateur : il lit les journaux, compte les échecs d’authentification et bannit au pare-feu les adresses trop insistantes. Simple sur le papier, il est pourtant souvent mal réglé : bannissements de dix minutes qui n’arrêtent personne, réglages écrits dans un fichier écrasé à la mise à jour, jail SSH qui ne voit aucune ligne parce qu’elle lit le mauvais journal, ou administrateur banni de son propre serveur.

Ce tutoriel part de la configuration réelle de mes serveurs Rocky Linux : bannissements progressifs, quatre niveaux de récidive, une jail pour une application maison, et les vérifications qui permettent de savoir que tout cela fonctionne vraiment.

Échelle des bannissements fail2ban de 1 h à 30 jours, avec la prison recidive et les réglages importants
Un bannissement qui grandit à chaque récidive, plafonné à 30 jours.

Trois notions

NotionCe que c’estOù
filtreles expressions régulières qui reconnaissent un échec dans un journalfilter.d/*.conf
actionce qui est fait pour bannir et débannir (règle firewalld, nftables, courriel…)action.d/*.conf
jaill’association d’un filtre, d’une source de journaux, d’une action et de seuilsjail.local, jail.d/*.local

fail2ban fournit des dizaines de filtres et d’actions prêts à l’emploi. Le travail consiste surtout à écrire les jails : quoi surveiller, avec quels seuils, et comment bannir.

Étape 1 : installer, et ne jamais toucher jail.conf

dnf install epel-release
dnf install fail2ban fail2ban-firewalld
systemctl enable --now fail2ban

Le paquet fail2ban-firewalld installe un fichier qui fait de firewalld l’action par défaut. Les fichiers jail.conf et fail2ban.conf appartiennent au paquet et seront remplacés à la prochaine mise à jour : tous vos réglages vont dans les fichiers .local, qui les surchargent clé par clé. Un jail.local peut donc ne contenir que les quelques lignes qui diffèrent.

Étape 2 : le service lui-même

# /etc/fail2ban/fail2ban.local
[DEFINITION]
logtarget  = /var/log/fail2ban/fail2ban.log
dbfile     = /var/lib/fail2ban/fail2ban.sqlite3
dbpurgeage = 35d
  • logtarget : un fichier dédié plutôt que le journal système. Il servira de source à la jail de récidive, et il est plus facile à lire ;
  • dbfile : la base SQLite où fail2ban garde les bannissements en cours et leur historique. C’est elle qui permet de rétablir les bannissements après un redémarrage, et de savoir combien de fois une adresse a déjà été bannie ;
  • dbpurgeage : la durée de conservation de l’historique. Par défaut, un jour seulement : trop court pour que les bannissements progressifs et la récidive à six mois aient une mémoire. 35 jours est un compromis ; la récidive longue s’appuie de toute façon sur le fichier journal.

Créez le répertoire et le fichier avant de redémarrer : install -d /var/log/fail2ban && touch /var/log/fail2ban/fail2ban.log. Pensez aussi à adapter la configuration logrotate du paquet à ce nouveau chemin.

Étape 3 : jail.local, ligne par ligne

# /etc/fail2ban/jail.local
[DEFAULT]
ignoreip  = 127.0.0.1/8 ::1 203.0.113.25 203.0.113.40 198.51.100.10
bantime   = 1h
findtime  = 10m
maxretry  = 5
bantime.increment = true
bantime.formula   = ban.Time * (1<<(ban.Count if ban.Count<20 else 20)) * banFactor
bantime.maxtime   = 720h
banaction          = firewallcmd-rich-rules
banaction_allports = firewallcmd-rich-rules

[sshd]
enabled  = true
backend  = systemd
maxretry = 5
bantime  = 2h

Ne pas se bannir soi-même

ignoreip liste les adresses jamais bannies : la boucle locale, l’adresse publique de chacun de vos serveurs, et celle de votre accès d’administration. Sans elle, quelques tests de connexion ratés suffisent à vous enfermer dehors, et un serveur qui interroge un autre serveur avec un mauvais mot de passe le fera bannir. Mettez la même liste partout.

Les seuils

findtime et maxretry : 5 échecs en 10 minutes déclenchent un bannissement. Plus bas, on bannit des utilisateurs qui se trompent de mot de passe ; plus haut, on laisse aux robots plus d’essais. Pour SSH, si seule l’authentification par clé est autorisée, un utilisateur légitime n’échoue presque jamais et on peut descendre à 3.

Les bannissements progressifs

bantime.increment active l’allongement automatique. La formule multiplie la durée de base par 2 à la puissance du nombre de bannissements précédents de cette adresse (1<<n vaut 2n), plafonné à 220 pour éviter les dépassements, puis par banFactor (1 par défaut). bantime.maxtime limite le résultat à 30 jours :

Bannissement n°Durée (bantime 1 h)Durée (jail sshd, 2 h)
11 h2 h
22 h4 h
34 h8 h
516 h32 h
8128 h (5 j)256 h (10 j)
10 et plusplafond : 30 jplafond : 30 j

L’effet est exactement celui qu’on veut : une erreur ponctuelle coûte une heure, un robot qui revient tous les jours se retrouve banni pour des semaines au bout d’une dizaine de passages.

L’action

banaction = firewallcmd-rich-rules : chaque bannissement devient une règle riche firewalld qui rejette l’adresse sur le port de la jail. banaction_allports est l’action utilisée par les jails qui bannissent sur tous les ports (la récidive). Sur un serveur sans firewalld, utilisez nftables-multiport et nftables-allports.

La jail SSH

backend = systemd est indispensable sur Rocky Linux : sshd écrit dans le journal systemd, et une jail qui lit un fichier ne verrait rien, sans aucune erreur. La jail lit les entrées de l’unité sshd.service. Une seconde subtilité : les versions récentes d’OpenSSH écrivent une partie de leurs messages sous le nom sshd-session. Si fail2ban-client status sshd reste à zéro alors que des échecs apparaissent dans journalctl, vérifiez que le filtre de votre version de fail2ban connaît ce nom (journalmatch).

Étape 4 : punir les récidivistes

La jail recidive lit le propre journal de fail2ban et compte les lignes « Ban ». Une adresse bannie plusieurs fois, quelle que soit la jail, est alors bannie sur tous les ports, pour plus longtemps. Quatre paliers complètent bien les bannissements progressifs :

[recidive1]
enabled   = true
filter    = recidive
logpath   = /var/log/fail2ban/fail2ban.log
banaction = %(banaction_allports)s
findtime  = 1d
maxretry  = 4
bantime   = 3h

[recidive2]
enabled   = true
filter    = recidive
logpath   = /var/log/fail2ban/fail2ban.log
banaction = %(banaction_allports)s
findtime  = 1w
maxretry  = 7
bantime   = 1d

[recidive3]
enabled   = true
filter    = recidive
logpath   = /var/log/fail2ban/fail2ban.log
banaction = %(banaction_allports)s
findtime  = 30d
maxretry  = 10
bantime   = 1w

[recidive4]
enabled   = true
filter    = recidive
logpath   = /var/log/fail2ban/fail2ban.log
banaction = %(banaction_allports)s
findtime  = 180d
maxretry  = 20
bantime   = 30d

Chaque palier a sa propre fenêtre : une adresse bannie 4 fois en une journée l’est pour 3 heures sur tous les ports ; 20 fois en six mois, pour un mois. Les fenêtres longues imposent de garder le journal assez longtemps : réglez la rotation pour conserver au moins six mois, compressés. La jail refuse de démarrer si le fichier journal n’existe pas encore, d’où sa création à l’étape 2.

Étape 5 : une jail pour sa propre application

Pour protéger une application qui n’a pas de filtre fourni, écrivez-en un. Prenons une application qui journalise en JSON :

# /etc/fail2ban/filter.d/monappli.conf
[Definition]
failregex = ^.*"msg":"login failed".*"remote_ip":"<HOST>".*$
ignoreregex =
datepattern = "time":"%%Y-%%m-%%dT%%H:%%M:%%S
  • <HOST> : la partie qui capture l’adresse à bannir ; fail2ban la remplace par une expression qui reconnaît IPv4 et IPv6 ;
  • datepattern : comment lire la date de la ligne. fail2ban ignore les lignes plus vieilles que findtime, il doit donc comprendre la date. Les %% sont des % échappés pour le format du fichier ;
  • ignoreregex : des lignes à ne jamais compter, même si elles correspondent.
# /etc/fail2ban/jail.d/monappli.local
[monappli]
enabled  = true
filter   = monappli
logpath  = /var/log/monappli/app.log
port     = 2022,8443
maxretry = 5

port limite le bannissement aux ports de l’application : l’adresse fautive garde l’accès au reste, à moins de récidiver.

Étape 6 : tester un filtre avant de l’activer

fail2ban-regex /var/log/monappli/app.log /etc/fail2ban/filter.d/monappli.conf
#   Failregex: 12 total
#   Lines: 4821 lines, 0 ignored, 12 matched, 4809 missed
fail2ban-regex --print-all-matched /var/log/monappli/app.log /etc/fail2ban/filter.d/monappli.conf

Un filtre qui ne trouve rien (« 0 matched ») sur un journal contenant des échecs connus est faux ; un filtre qui trouve trop (des connexions réussies) bannira vos utilisateurs. Vérifiez aussi la ligne « Date template hits » : si la date n’est pas reconnue, aucune ligne ne sera jamais comptée en production. Pour SSH avec le backend systemd : fail2ban-regex systemd-journal sshd.

Étape 7 : vérifier et exploiter

fail2ban-client -t                         # la configuration est-elle valide ?
systemctl restart fail2ban
fail2ban-client status                     # les jails actives
fail2ban-client status sshd                # échecs comptés, adresses bannies
fail2ban-client get sshd banip --with-time # avec la fin de chaque bannissement
fail2ban-client set sshd unbanip 192.0.2.66
fail2ban-client unban --all                # en cas d'urgence
firewall-cmd --list-rich-rules | grep -c reject

Faites le test pour de vrai, depuis une adresse qui n’est pas dans ignoreip (une connexion mobile, par exemple) : cinq mots de passe faux, puis vérifiez que la sixième tentative est refusée et que l’adresse apparaît dans le statut de la jail.

À quoi ça ressemble après quelques mois

Mon serveur web le 2 novembre 2026 (fail2ban 1.1.0). La jail SSH lit le journal systemd, et quatre jails de récidive s’empilent derrière elle :

# fail2ban-client status
|- Number of jail:	5
`- Jail list:	recidive1, recidive2, recidive3, recidive4, sshd

# fail2ban-client status sshd
|- Filter
|  |- Currently failed:	0
|  |- Total failed:	6
|  `- Journal matches:	_SYSTEMD_UNIT=sshd.service + _COMM=sshd + _COMM=sshd-session
`- Actions
   |- Currently banned:	2
   |- Total banned:	2

# for j in recidive1 recidive2 recidive3 recidive4; do ...; done
recidive1: bantime=10800   findtime=86400    maxretry=4
recidive2: bantime=86400   findtime=604800   maxretry=7
recidive3: bantime=604800  findtime=2592000  maxretry=10
recidive4: bantime=2592000 findtime=15552000 maxretry=20
  • Total failed: 6 depuis le redémarrage du matin. Les connexions par mot de passe étant désactivées, presque personne n’arrive même jusqu’à un échec : la plupart des robots abandonnent dès l’échange de clés. Les compteurs repartent de zéro avec le service ; l’historique est dans la base.
  • Journal matches cite à la fois sshd et sshd-session : depuis OpenSSH 9.8, les messages d’authentification viennent du processus sshd-session. Un filtre qui ne regarde que _COMM=sshd ne compte plus rien, sans le dire, sur un système récent.
  • Les quatre jails de récidive lisent le journal de fail2ban lui-même : 4 bannissements en un jour donnent 3 heures, 7 en une semaine une journée, 10 en un mois une semaine, 20 en six mois un mois.

Les bannissements progressifs se lisent dans la base SQLite de fail2ban, qui garde chaque adresse avec son nombre de bannissements :

# sqlite3 -readonly /var/lib/fail2ban/fail2ban.sqlite3 \
    "select jail, bancount, count(*) from bips group by jail, bancount"
recidive3|1|1
sshd|1|21
sshd|3|1
sshd|7|1
sshd|10|1

# sqlite3 -readonly /var/lib/fail2ban/fail2ban.sqlite3 "select max(bantime) from bips where jail='sshd'"
2592000

Vingt et une adresses ont été bannies une fois et ne sont jamais revenues : c’est l’essentiel du trafic, des robots opportunistes. Trois sont revenues, dont une dix fois. Pour celle-là, chaque bannissement a doublé la durée du précédent jusqu’à atteindre bantime.maxtime = 720h : 2 592 000 secondes, trente jours, le plafond. C’est tout l’intérêt de la progression : la première faute coûte peu, les obstinés finissent exclus un mois, sans liste manuelle à entretenir.

Les pannes fréquentes

La jail ne compte rien

Mauvais backend (fichier au lieu de systemd), mauvais chemin de journal, ou date non reconnue. fail2ban-client status <jail> montre la source lue ; fail2ban-regex dit si les lignes correspondent.

Les adresses sont bannies mais continuent de passer

L’action ne correspond pas au pare-feu réellement utilisé (une action iptables sur un système nftables pur, par exemple), ou le trafic arrive par un mandataire inverse et c’est l’adresse du mandataire qui est bannie. Derrière un mandataire, l’application doit journaliser l’adresse réelle du client (X-Forwarded-For), et le bannissement doit avoir lieu sur la machine qui reçoit la connexion.

Une adresse bloquée alors que fail2ban ne la bannit pas

Si CrowdSec tourne aussi, il a peut-être pris sa propre décision : cscli decisions list --ip …. Les deux se complètent bien (fail2ban réagit à vos propres journaux, CrowdSec ajoute des scénarios plus riches et une liste communautaire), mais il faut penser à regarder des deux côtés.

fail2ban met longtemps à démarrer

À chaque démarrage, il rétablit les bannissements en cours depuis sa base et relit la fin des journaux. Avec des milliers d’entrées et des règles riches firewalld, cela peut prendre une minute. Une action nftables par ensemble (nftables-allports) est bien plus rapide quand le nombre de bannissements grossit.


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

Articles liés

Séquences PostgreSQL après kill -9 : id 1 à 9, puis un trou de 27 valeurs, puis 37

Séquences et colonnes identity dans PostgreSQL : trous, rollbacks et crashs, testés

En bref : j’ai fait un kill -9 sur les processus postgres : une colonne identity PostgreSQL est passée de l’id 9 à 37, parce que les séquences PostgreSQL journalisent 32 valeurs d’avance dans le WAL. Rollbacks et insertions en échec brûlent aussi des valeurs, et une colonne BY DEFAULT ignore les id explicites. Préférer GENERATED ... AS IDENTITY à serial, et ne jamais compter sur des id continus.

PostgreSQL 18.6, cluster jetable sous Rocky Linux 10.2. Partie 1 sur 5 (PostgreSQL, MariaDB, Oracle, SQL Server, résumé). Toutes les sorties viennent de mes propres tests.

Séquences PostgreSQL après kill -9 : id 1 à 9, puis un trou de 27 valeurs, puis 37
Un kill -9 sur PostgreSQL 18.6 : 27 valeurs réservées et jamais distribuées.

Trois façons d’obtenir une valeur générée

CREATE TABLE t_ident  (id int GENERATED ALWAYS AS IDENTITY PRIMARY KEY, v text);
CREATE TABLE t_serial (id serial PRIMARY KEY, v text);
CREATE SEQUENCE s1;
CREATE TABLE t_seq    (id int PRIMARY KEY DEFAULT nextval('s1'), v text);

Chaque INSERT ... RETURNING id renvoie 1 sur une table neuve. Le catalogue montre la différence :

 column_name |            column_default            | is_identity | identity_generation
-------------+--------------------------------------+-------------+---------------------
 id          |                                      | YES         | ALWAYS
 id          | nextval('s1'::regclass)              | NO          |
 id          | nextval('t_serial_id_seq'::regclass) | NO          |

Une colonne identity n’a pas d’expression par défaut ; la séquence est attachée à la colonne (pg_get_serial_sequence('t_ident','id') renvoie public.t_ident_id_seq). serial est un raccourci : colonne entière plus défaut appelant nextval.

ALWAYS ou BY DEFAULT

Avec GENERATED BY DEFAULT, une valeur explicite est acceptée mais ne fait pas avancer le compteur :

INSERT INTO t_by(id, v) VALUES (2, 'explicit 2');         -- ok
INSERT INTO t_by(v) VALUES ('default 1') RETURNING id;    -- 1
INSERT INTO t_by(v) VALUES ('default 2') RETURNING id;    -- ERROR: duplicate key ... (id)=(2) already exists
INSERT INTO t_by(v) VALUES ('default 3') RETURNING id;    -- 3

L’insertion en échec a brûlé la valeur 2 du compteur. Avec GENERATED ALWAYS, une valeur explicite est refusée sauf demande expresse :

ERROR:  cannot insert a non-DEFAULT value into column "id"
DETAIL:  Column "id" is an identity column defined as GENERATED ALWAYS.
HINT:  Use OVERRIDING SYSTEM VALUE to override.

Après OVERRIDING SYSTEM VALUE VALUES (50, ...), l’insertion par défaut suivante a renvoyé 1 : le compteur est indépendant des données.

Rollback et échecs consomment des valeurs

BEGIN; INSERT INTO t_ident(v) VALUES ('rolled back') RETURNING id;   -- 2
ROLLBACK;
INSERT INTO t_ident(v) VALUES ('after rollback') RETURNING id;       -- 3

Idem avec une violation d’unicité : id 1, erreur sur le doublon, puis 3. Un compteur sans trou demande une autre conception (table de compteur verrouillée), au prix de la sérialisation des écritures.

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

La session A insère en premier et valide 3 secondes après B ; la session B insère en second et valide aussitôt :

A got id 1
B got id 2
B: committed 08:18:48.652
A: committed 08:18:51.154

La ligne de B est visible avant celle de A, bien que son id soit plus grand. Ne pas utiliser « max(id) déjà vu » comme curseur de réplication ou de polling.

CACHE est par session

CREATE SEQUENCE s_cache CACHE 10;
same session twice : 1|2
new session        : 11
another new session: 21

Avec les séquences PostgreSQL, chaque session réserve un bloc de 10. Les valeurs de sessions différentes s’entrelacent et des trous apparaissent dès qu’une session se termine.

Limites et CYCLE

ERROR:  nextval: reached maximum value of sequence "s_small" (3)

Après ALTER SEQUENCE s_small CYCLE, la valeur suivante est 1. Une identity sur smallint s’arrête à 32767 avec la même erreur sur t_small_id_seq. Les identity integer s’arrêtent à 2147483647 : prendre bigint pour les tables à longue vie.

Redémarrage et crash

Trois lignes insérées, la dernière supprimée, redémarrage propre :

sequence before the restart: 3|30|t     (last_value | log_cnt | is_called)
sequence after the restart:  3|30|t
new id = 4

Puis cinq lignes de plus (dernier id 9), kill -9 de tous les processus postgres, redémarrage :

sequence before the crash: 9|27|t
sequence after the crash:  36|0|t
new id = 37
ids now: 1,2,4,5,6,7,8,9,37

log_cnt est le nombre de valeurs encore couvertes par le dernier enregistrement WAL. PostgreSQL écrit un enregistrement WAL pour 32 valeurs ; après la récupération sur crash, il repart de la fin de la plage réservée (9 + 27 = 36), donc l’id suivant est 37. Un arrêt propre écrit l’état exact, sans trou.

Où lire l’état des séquences PostgreSQL

SELECT * FROM pg_sequences;                -- départ, incrément, max, cache_size, cycle, last_value
SELECT last_value, log_cnt, is_called FROM t_ident_id_seq;
SELECT attrelid::regclass, attname, attidentity FROM pg_attribute WHERE attidentity <> '';  -- 'a' ALWAYS, 'd' BY DEFAULT

Documentation officielle

PostgreSQL, site du projet

CREATE SEQUENCE, documentation PostgreSQL 18

Sequence manipulation functions, nextval, currval, setval

CREATE TABLE, GENERATED ... AS IDENTITY et serial

pg_sequences, la vue système utilisée plus haut

*Non testé ici : réplication logique des séquences, pg_upgrade, tables partitionnées, ALTER SEQUENCE ... RESTART en cours d’usage.*

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 du chemin d'un paquet via firewalld, NFQUEUE et Suricata, avec les quatre réglages clés et la leçon du loopback

Pas à pas : Suricata en IPS avec NFQUEUE, sans casser son serveur

Suricata est un moteur de détection d’intrusion réseau : il examine les paquets qui entrent et sortent d’une machine, reconstitue les connexions, comprend les protocoles (HTTP, TLS, DNS, SSH…) et compare le tout à des dizaines de milliers de règles décrivant des attaques connues. En mode IPS, il peut aussi bloquer : un paquet qui correspond à une règle de blocage n’arrive jamais à destination.

Ce tutoriel installe Suricata en IPS sur un serveur Rocky Linux exposé à Internet, avec NFQUEUE. C’est le mode le plus utile sur un serveur seul, et aussi le plus délicat : Suricata se retrouve sur le chemin de chaque paquet. Je décris donc aussi, en détail, les pannes que j’ai rencontrées, dont une qui bloquait des connexions locales en silence pendant des semaines.

Schéma du chemin d'un paquet via firewalld, NFQUEUE et Suricata, avec les quatre réglages clés et la leçon du loopback
Le chemin d’un paquet et les réglages qui évitent les mauvaises surprises.

IDS ou IPS

ModeFonctionnementRisque
IDS (af-packet)Suricata reçoit une copie des paquets et alerteaucun pour le trafic : au pire, des alertes manquées
IPS (NFQUEUE)le noyau confie chaque paquet à Suricata, qui l’accepte ou le jetteSuricata est sur le chemin : une erreur bloque le trafic

Commencez en IDS si vous découvrez l’outil. Passez en IPS quand vous savez lire ses alertes et que vous avez éliminé les faux positifs les plus bruyants.

Étape 1 : installer

dnf install epel-release
dnf install suricata
suricata --build-info | grep -E 'NFQueue|AF_PACKET'   # les deux doivent être « yes »

Deux modules noyau sont nécessaires pour NFQUEUE : nfnetlink_queue (la file elle-même) et xt_NFQUEUE (la cible utilisée par les règles de pare-feu). Le second est souvent oublié : la règle échoue alors avec un message peu clair sur un module manquant. Chargez-les et rendez-les permanents :

modprobe nfnetlink_queue
modprobe xt_NFQUEUE
printf 'nfnetlink_queue\nxt_NFQUEUE\n' > /etc/modules-load.d/nfqueue.conf

Étape 2 : suricata.yaml, l’essentiel

# /etc/suricata/suricata.yaml (extraits)
vars:
  address-groups:
    HOME_NET: "[203.0.113.25/32,2001:db8::25/128]"
    EXTERNAL_NET: "!$HOME_NET"

nfq:
  mode: accept
  fail-open: yes

flow-timeouts:
  tcp:
    established: 7200

stream:
  memcap: 256mb
  midstream: true
  reassembly:
    memcap: 512mb
    depth: 1mb

outputs:
  - eve-log:
      enabled: yes
      filename: eve.json
      types: [alert, drop, anomaly, stats]
  • HOME_NET : les adresses que vous protégez. Beaucoup de règles en dépendent (« trafic venant de l’extérieur vers HOME_NET ») ; une valeur fausse donne à la fois des faux positifs et des attaques manquées ;
  • nfq.mode: accept : Suricata rend son verdict (accepter ou jeter) et le paquet poursuit ensuite son chemin normal dans le pare-feu ;
  • fail-open: yes : si la file déborde parce que Suricata ne suit pas, les paquets passent au lieu d’être jetés. Sur un serveur seul, mieux vaut laisser passer quelques paquets non inspectés que couper le service ;
  • flow-timeouts.tcp.established: 7200 : le point qui m’a coûté le plus cher, détaillé plus bas. Par défaut, Suricata oublie une connexion TCP inactive au bout d’une heure ; une connexion qui reste ouverte plus longtemps sans trafic voit ses paquets suivants traités comme des paquets « hors connexion », et parfois jetés ;
  • midstream: true : Suricata accepte de prendre en compte une connexion dont il n’a pas vu le début, par exemple après son propre redémarrage. Sans cela, toutes les connexions établies avant le démarrage sont considérées comme invalides ;
  • memcap : les plafonds de mémoire pour le suivi des flux et la reconstitution des données. Trop bas, Suricata abandonne l’inspection des connexions sous charge ; surveillez les compteurs memcap dans les statistiques ;
  • eve.json : le journal structuré, une ligne JSON par événement. C’est ce fichier qu’on envoie à un SIEM.

Étape 3 : les règles

suricata-update                      # télécharge le jeu ET Open (gratuit)
suricata-update list-sources
suricata-update enable-source et/open
ls -l /var/lib/suricata/rules/suricata.rules

suricata-update assemble toutes les règles dans un seul fichier, en appliquant vos fichiers de modification. Deux d’entre eux sont essentiels en IPS :

# /etc/suricata/drop.conf : ces familles de règles bloquent au lieu d'alerter
re:classtype:trojan-activity
re:classtype:command-and-control
re:classtype:domain-c2
re:classtype:exploit-kit
re:classtype:coin-mining

# /etc/suricata/disable.conf : protocoles industriels absents ici
re:dnp3
re:modbus

Par défaut, toutes les règles alertent seulement. drop.conf transforme en blocages celles dont la catégorie ne laisse pas de doute : communication avec un serveur de commande, cheval de Troie, minage de cryptomonnaie. Évitez de tout passer en blocage : une règle générique de « trafic suspect » déclenchée par une application légitime coupe cette application sans prévenir. disable.conf retire les règles inutiles, ce qui économise mémoire et processeur.

Planifiez une mise à jour quotidienne par un timer systemd qui lance suricata-update, puis demande à Suricata de recharger ses règles sans redémarrer (suricatasc -c reload-rules).

Étape 4 : envoyer le trafic à Suricata

Le service lit la file 0 :

# /etc/systemd/system/suricata.service.d/ips.conf
[Service]
ExecStart=
ExecStart=/usr/sbin/suricata -c /etc/suricata/suricata.yaml -q 0 --pidfile /var/run/suricata.pid

Puis les règles de pare-feu, avec firewalld en mode « direct » :

# 1. la boucle locale ne passe jamais par Suricata (priorité -1 : avant tout)
firewall-cmd --permanent --direct --add-rule ipv4 filter INPUT  -1 -i lo -j ACCEPT
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT -1 -o lo -j ACCEPT
# 2. tout le reste est confié à la file 0 ; --queue-bypass : si Suricata est arrêté, le trafic passe
firewall-cmd --permanent --direct --add-rule ipv4 filter INPUT   0 -j NFQUEUE --queue-num 0 --queue-bypass
firewall-cmd --permanent --direct --add-rule ipv4 filter OUTPUT  0 -j NFQUEUE --queue-num 0 --queue-bypass
firewall-cmd --permanent --direct --add-rule ipv4 filter FORWARD 0 -j NFQUEUE --queue-num 0 --queue-bypass
# mêmes règles en ipv6
firewall-cmd --reload
  • –queue-bypass : sans lui, si Suricata est arrêté ou plante, plus aucun paquet ne passe, SSH compris. Avec lui, le noyau laisse passer le trafic quand personne n’écoute la file. C’est la ligne qui évite d’avoir à appeler la console de secours de l’hébergeur ;
  • la boucle locale exclue : la leçon la plus coûteuse de ce tutoriel, détaillée ci-dessous ;
  • l’ordre : les règles directes de priorité -1 passent avant celles de priorité 0.

La leçon de la boucle locale

Pendant six semaines, un service de mon serveur (un gestionnaire de tâches qui parle à Redis sur 127.0.0.1) s’est figé à intervalles irréguliers, toujours exactement 31 minutes et 40 secondes, avant de repartir. Les journaux de l’application ne montraient rien, ceux de Redis non plus. La cause : Suricata inspectait aussi le trafic de la boucle locale. Une longue connexion inactive dépassait le délai de suivi des flux ; au réveil, ses paquets n’appartenaient plus à aucune connexion connue de Suricata, qui les jetait ; il fallait attendre que TCP abandonne et se reconnecte.

Le diagnostic est venu d’eve.json : chaque paquet jeté y apparaît avec sa raison.

jq -c 'select(.event_type=="drop") | {timestamp, src_ip, dest_ip, dest_port, reason: .drop.reason}' /var/log/suricata/eve.json | tail

Trois corrections, toutes nécessaires : exclure la boucle locale (le trafic entre processus d’une même machine n’a rien à faire dans un IPS), allonger le délai TCP à deux heures, et activer midstream. Retenez le symptôme : une connexion longue qui se fige un temps fixe et reproductible, sans erreur nulle part, c’est presque toujours un équipement intermédiaire (pare-feu, IPS, traduction d’adresses) qui a oublié la connexion.

Le piège des cartes réseau

Les cartes et pilotes modernes regroupent plusieurs paquets en un seul « super-paquet » avant de les remettre au noyau (GRO, LRO). Suricata voit alors des paquets plus gros que la taille réelle du réseau, et sa reconstitution des connexions s’en trouve faussée. Désactivez ces optimisations sur l’interface surveillée, de façon permanente, par NetworkManager plutôt que par un simple ethtool -K qui serait annulé à la reconnexion suivante :

nmcli connection modify eth0 ethtool.feature-gro off ethtool.feature-lro off \
    ethtool.feature-gso off ethtool.feature-tso off
nmcli connection up eth0
ethtool -k eth0 | grep -E 'generic-receive|large-receive'

Étape 5 : démarrer et vérifier

suricata -T -c /etc/suricata/suricata.yaml        # test de configuration et des règles
systemctl enable --now suricata
tail -f /var/log/suricata/suricata.log            # « engine started »
curl -s http://testmynids.org/uid/index.html      # doit déclencher l'alerte 2100498
jq -c 'select(.event_type=="alert") | .alert.signature' /var/log/suricata/eve.json | tail -3

Vérifiez aussi que le trafic normal passe toujours : connexion SSH neuve, site web, envoi de courrier, résolution DNS. Puis surveillez les statistiques pendant quelques jours :

jq -c 'select(.event_type=="stats") | .stats | {drop: .ips.blocked, memcap: .tcp.ssn_memcap_drop, kernel: .capture}' /var/log/suricata/eve.json | tail -1

Les mêmes compteurs sur un serveur en production

Suricata 8.0.8 en mode IPS sur mon serveur web, lu par le socket de contrôle le 2 novembre 2026 après 75 minutes de fonctionnement. suricatasc donne les compteurs en direct, sans attendre la prochaine ligne de statistiques dans eve.json :

# suricatasc -c iface-list
{"message": {"count": 1, "ifaces": ["NFQ#0"]}, "return": "OK"}

# suricatasc -c ruleset-stats
[{"id": 0, "rules_loaded": 53325, "rules_failed": 0, "rules_skipped": 0}]

# suricatasc -c dump-counters | jq '.message | {uptime, ips, alerts: .detect.alert}'
uptime        4544 s
ips.accepted  2 076 277
ips.blocked   771
  drop_reason.stream_error    769
  drop_reason.applayer_error  2
  drop_reason.rules           0
alerts        23
  • NFQ#0 : Suricata est branché sur la file netfilter 0, il voit donc les paquets au passage et peut les jeter. En mode IDS, cette liste montrerait une interface réseau.
  • 53 325 règles chargées, 0 en échec : un rules_failed non nul signifie le plus souvent qu’une règle utilise un mot-clé que votre version ne connaît pas, après une mise à jour des règles ou du moteur.
  • 771 paquets bloqués, 769 pour stream_error, 0 par les règles : c’est le tableau normal d’un serveur web. Les rejets par règle sont rares ; la plupart des paquets jetés n’ont aucun sens pour le flux TCP auquel ils prétendent appartenir (retransmissions après la fermeture, numéros de séquence faux, sommes de contrôle invalides). Si ce nombre grimpe d’un coup, regardez les événements drop dans eve.json : la leçon de la boucle locale, plus haut, a commencé par exactement ce genre de pic.
  • 23 alertes en 75 minutes, aucune bloquante : des anomalies de protocole (trop de SYN pour une même poignée de main, protocoles applicatifs incohérents, horodatages invalides) journalisées pour le SIEM. Pourtant, 23 665 des règles chargées sont réglées pour bloquer, par classe (chevaux de Troie, serveurs de commande, kits d’exploitation, minage…) grâce à drop.conf : pendant cette heure, aucune ne s’est déclenchée. Une règle de blocage qui ne se déclenche jamais, c’est l’état attendu, pas le signe d’une panne.

Faire taire un faux positif

Une règle qui se déclenche sur un trafic légitime se neutralise, du plus précis au plus large : seuil ou suppression pour une adresse dans threshold.config, puis désactivation de la règle par son numéro dans disable.conf. Ne modifiez jamais le fichier de règles directement : la prochaine mise à jour l’écraserait.

# /etc/suricata/threshold.config
suppress gen_id 1, sig_id 2210045, track by_src, ip 203.0.113.40

Envoyer les alertes au SIEM

eve.json est lisible par Wazuh, Elastic, Graylog et la plupart des SIEM. Avec un agent Wazuh, quelques lignes suffisent (format json, chemin du fichier) et les alertes de Suricata apparaissent à côté des journaux système, ce qui permet de rapprocher une alerte réseau d’une connexion SSH ou d’un changement de fichier. Pensez à la rotation : eve.json grossit vite, et logrotate doit envoyer à Suricata le signal de rouvrir le fichier.

Mettre à jour Suricata

Après chaque mise à jour du paquet, relancez suricata -T avant le redémarrage : une option renommée ou une règle incompatible empêche le démarrage, et grâce à --queue-bypass le trafic passera alors sans inspection, sans que rien ne casse visiblement. C’est le revers de la sécurité de fonctionnement : surveillez l’état du service, pas seulement le trafic.


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

Articles liés

Page 1 of 33

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