Terres dévastées

Vallée de montagne enneigée entre deux sommets rocheux, sous un ciel bleu

Étiquette : pas à pas Page 1 of 2

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

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

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

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

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

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

Pourquoi un second résolveur casse le filtre

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

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

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

Avant de commencer

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

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

Étape 1 : entrer en mode sûr

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

Étape 2 : changer les serveurs DNS de MikroTik

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

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

Étape 3 : tester depuis un poste du LAN

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

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

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

Étape 4 : garder le changement

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

Étape 5 : confirmer le lendemain matin

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

Si quelque chose se passe mal

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

Ce que j’en retiens

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

Sources

Articles liés

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

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

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

É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

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

Schéma du parcours CrowdSec : journaux, agent, API locale, bouncer pare-feu, liste communautaire et liste blanche

Pas à pas : installer CrowdSec, bloquer au pare-feu et ne jamais se bannir

CrowdSec est souvent présenté comme « un fail2ban moderne ». C’est vrai en partie : lui aussi lit les journaux et bannit les adresses agressives. Mais il ajoute deux choses que fail2ban n’a pas. D’abord des scénarios plus riches, qui reconnaissent un balayage de chemins web, une attaque par dictionnaire répartie ou une exploitation de faille connue, au lieu de simplement compter des lignes. Ensuite une intelligence collective : chaque installation signale les attaques qu’elle voit, et reçoit en échange une liste d’adresses déjà repérées ailleurs, bloquées avant même qu’elles ne vous atteignent.

Ce tutoriel installe CrowdSec 1.8 sur Rocky Linux, le branche sur SSH et nginx, ajoute le blocage au pare-feu, et surtout explique comment ne pas se bannir soi-même, ce qui arrive plus vite qu’on ne le croit.

Schéma du parcours CrowdSec : journaux, agent, API locale, bouncer pare-feu, liste communautaire et liste blanche
De la ligne de journal au blocage, et comment ne jamais se bannir soi-même.

Les pièces du puzzle

ÉlémentRôle
l’agent (crowdsec)lit les journaux, les découpe (parseurs), les compare à des scénarios, émet des alertes
l’API locale (LAPI)stocke les alertes et transforme celles qui le méritent en décisions (bannir telle adresse pendant tant de temps)
les bouncersappliquent les décisions : pare-feu (nftables), serveur web, application
l’API centrale (CAPI)reçoit vos signalements et vous renvoie une liste de blocage communautaire
le Huble catalogue de collections, parseurs, scénarios, installés par cscli

Point important : l’agent ne bloque rien. Sans bouncer, CrowdSec détecte et prend des décisions, mais personne ne les applique. C’est l’erreur la plus fréquente lors d’une première installation.

Étape 1 : installer

CrowdSec publie ses paquets dans un dépôt packagecloud. Déclarez-le dans /etc/yum.repos.d/ avec sa clé GPG, puis :

dnf install crowdsec crowdsec-firewall-bouncer-nftables
systemctl enable --now crowdsec
cscli version

À l’installation, le paquet détecte les services présents (sshd, nginx…) et installe les collections correspondantes. Vérifiez ce qu’il a choisi plutôt que de lui faire confiance : cscli collections list.

Une précaution sur Debian : si vous installez CrowdSec et le bouncer dans la même commande sur une machine neuve, le script post-installation du bouncer peut s’exécuter avant que l’API locale soit prête et échouer à s’enregistrer. Installez l’agent, attendez qu’il démarre, puis le bouncer.

Étape 2 : les collections

cscli collections install crowdsecurity/linux crowdsecurity/sshd crowdsecurity/nginx
cscli collections list
systemctl reload crowdsec

Une collection regroupe des parseurs (qui savent lire un format de journal) et des scénarios (qui reconnaissent un comportement). crowdsecurity/nginx apporte ainsi le parseur des journaux nginx et une dizaine de scénarios : balayage de chemins, sondes de fichiers sensibles, recherche de pages d’administration, robots agressifs. Les collections se mettent à jour avec cscli hub update && cscli hub upgrade, à planifier chaque jour.

Étape 3 : dire à CrowdSec quoi lire

La configuration d’acquisition liste les sources et leur type, qui détermine le parseur utilisé :

# /etc/crowdsec/acquis.yaml
filenames:
  - /var/log/secure
labels:
  type: syslog
---
filenames:
  - /var/log/messages
labels:
  type: syslog
---
# /etc/crowdsec/acquis.d/nginx.yaml
filenames:
  - /var/log/nginx/*.log
labels:
  type: nginx
  • labels.type : syslog pour les journaux système (sshd y écrit sur Rocky Linux), nginx pour les journaux d’accès et d’erreur ;
  • une source, une seule fois : le piège classique est de lister les journaux nginx à la fois dans acquis.yaml et dans acquis.d/nginx.yaml. Chaque ligne est alors lue deux fois, chaque compteur double, et les bannissements tombent deux fois plus vite. Même chose avec une source journalctl ajoutée par-dessus un fichier qui contient déjà les mêmes lignes ;
  • les jokers (*.log) suivent automatiquement les nouveaux sites.

Pour vérifier que les lignes sont bien lues et comprises :

cscli metrics show acquisition parsers
# « Lines read » augmente, « Lines parsed » aussi ; beaucoup de « unparsed » = mauvais type

Étape 4 : ne jamais se bannir soi-même

C’est la partie à ne pas sauter. CrowdSec n’a aucune raison de faire confiance à vos propres adresses : un script de supervision qui reçoit une série de 403, des tests de connexion SSH ratés, un serveur qui interroge ses propres noms publics… et c’est votre propre serveur que le pare-feu rejette. J’ai vécu les deux : un serveur qui s’est banni lui-même pour « sondage HTTP », et un autre qui a banni l’adresse de mon poste d’administration pendant que je vérifiais des clés SSH.

La parade est une liste blanche locale, en parseur d’enrichissement :

# /etc/crowdsec/parsers/s02-enrich/local-whitelist.yaml
name: local/whitelists
description: "Adresses de confiance, jamais bannies"
whitelist:
  reason: "mes serveurs et mon adresse d'administration"
  ip:
    - "203.0.113.25"
    - "203.0.113.40"
    - "2001:db8::25"
    - "198.51.100.10"

Mettez-y les adresses publiques de chacun de vos serveurs (IPv4 et IPv6), celle de votre accès d’administration, et déployez la même liste sur toutes vos machines : une infrastructure personnelle où chaque serveur peut bannir les autres finit toujours par le faire. Une liste blanche s’applique avant les scénarios, donc aucune alerte n’est créée. Elle ne supprime pas une décision déjà prise : cscli decisions delete --ip … s’en charge.

Étape 5 : appliquer les décisions au pare-feu

cscli bouncers add firewall-bouncer     # affiche une clé à copier dans la configuration du bouncer
# /etc/crowdsec/bouncers/crowdsec-firewall-bouncer.yaml (extrait)
mode: nftables
update_frequency: 10s
api_url: http://127.0.0.1:8081/
api_key: <clé générée par cscli bouncers add>
disable_ipv6: false
deny_action: DROP
supported_decisions_types:
  - ban
nftables:
  ipv4:
    enabled: true
    table: crowdsec
  ipv6:
    enabled: true
    table: crowdsec6
  • mode: nftables : le bouncer crée ses propres tables et ensembles nftables, indépendants de firewalld. Les adresses bannies sont dans un ensemble, ce qui reste rapide même avec des dizaines de milliers d’entrées ;
  • update_frequency : toutes les 10 secondes, le bouncer récupère les nouvelles décisions ;
  • deny_action: DROP : le paquet est jeté sans réponse, l’attaquant n’apprend rien ;
  • IPv6 : à activer explicitement ; un attaquant qui dispose des deux familles d’adresses passera sinon par celle qui n’est pas filtrée.
systemctl enable --now crowdsec-firewall-bouncer
cscli bouncers list                    # « Last API pull » récent
nft list set ip crowdsec crowdsec-blacklists-cscli | head

Étape 6 : la liste communautaire

cscli capi register
cscli console enroll <clé de la console>   # facultatif : tableau de bord web
cscli capi status
systemctl restart crowdsec

Une fois inscrit, l’agent envoie les alertes de ses scénarios (adresse et scénario, jamais le contenu des journaux) et reçoit une liste de blocage d’environ quinze mille adresses, renouvelée régulièrement. C’est elle qui fait la plus grande différence au quotidien : la majorité des robots qui balaient Internet sont bloqués dès leur premier paquet. cscli decisions list --origin CAPI | wc -l donne la taille de la liste reçue.

Simuler avant de bannir

Un nouveau scénario, ou un nouveau serveur, peut être placé en simulation : les alertes et décisions sont enregistrées mais marquées « simulées », et aucun bouncer ne les applique. C’est le moyen de voir ce que CrowdSec aurait bloqué pendant une semaine, avant de lui confier la porte.

cscli simulation enable crowdsecurity/http-crawl-non_statics
cscli simulation status
cscli alerts list --since 24h

Exploiter au quotidien

cscli alerts list --since 24h           # ce qui a été détecté
cscli decisions list                    # qui est banni, pour combien de temps
cscli decisions delete --ip 192.0.2.66   # lever un bannissement
cscli decisions add --ip 192.0.2.99 --duration 72h --reason 'manuel'
cscli metrics                           # sources, parseurs, scénarios, bouncers

La durée de bannissement par défaut est de quatre heures ; un profil (profiles.yaml) permet de l’allonger pour les récidivistes ou de bannir une plage entière plutôt qu’une adresse.

Une heure d’un vrai serveur

Voici les chiffres de mon serveur web le 2 novembre 2026, 75 minutes après un redémarrage (CrowdSec 1.8.2, bouncer nftables 0.0.36). D’abord, ce que l’agent a lu :

# cscli metrics show acquisition          (extrait)
| Source                                      | Lines read | Lines parsed | Lines unparsed | Poured to bucket | Whitelisted |
| appsec:appsec                               | 136        | 136          | -              | 136              | -           |
| file:/var/log/messages                      | 1.31k      | -            | 1.31k          | -                | -           |
| file:/var/log/nginx/access.blog...log       | 716        | 716          | -              | 42               | 528         |
| file:/var/log/nginx/access.log              | 8.03k      | 8.03k        | -              | 4.29k            | 1.76k       |
  • Lines parsed égal à Lines read sur les journaux web : l’analyseur nginx comprend chaque ligne. Si un journal affiche tout en unparsed, la collection manque ou le format du journal a été personnalisé.
  • /var/log/messages : 1,31k non analysées : c’est attendu. La plupart des lignes du journal système ne sont pas des événements de sécurité et aucun analyseur ne les revendique. Les événements SSH et d’authentification sont dans /var/log/secure, lu par sa propre entrée : 3 020 lignes lues, 39 analysées, et c’est bien le but, puisque seules les connexions échouées et événements semblables intéressent CrowdSec.
  • Whitelisted : les requêtes venant de mes propres adresses et des sondes de supervision, ignorées volontairement (étape 4).
  • Poured to bucket : les lignes qui ont alimenté un scénario. La plupart ne deviennent jamais une alerte ; un compteur ne déborde que si le comportement se répète.

Puis le côté application des décisions, la seule preuve que la protection est réelle :

# cscli bouncers list
 crowdsec-firewall-bouncer  127.0.0.1  ✔️  2026-11-02T10:21:35+01:00  v0.0.36
 openresty-appsec           127.0.0.1  ✔️  2026-11-02T10:21:37+01:00  v1.2.3

# nft list set ip crowdsec crowdsec-blacklists-CAPI      → 14 752 adresses IPv4
# nft list set ip6 crowdsec6 crowdsec6-blacklists-CAPI   → 475 adresses IPv6
# nft list set ip crowdsec crowdsec-blacklists-crowdsec  → 8 décisions locales

# nft list counters table ip crowdsec
counter processed                     packets 1286809
counter crowdsec-blacklists-CAPI      packets 387   → jetés
counter crowdsec-blacklists-crowdsec  packets 60    → jetés

En 75 minutes, 447 paquets ont été jetés avant d’atteindre le moindre service : 387 venaient d’adresses de la liste communautaire, qui n’avaient jamais touché ce serveur, et 60 des 8 adresses bannies par mon propre serveur. La colonne Last API pull, vieille de quelques secondes pour les deux bouncers, est la première chose à regarder quand les bannissements semblent sans effet : un bouncer qui ne tire plus continue d’appliquer une liste figée.

Allonger les bannissements : profiles.yaml

Le profil décide de ce qu’une alerte devient. Celui par défaut bannit l’adresse quatre heures. On peut le rendre progressif, comme avec fail2ban, en s’appuyant sur le nombre de décisions déjà prises contre cette adresse :

# /etc/crowdsec/profiles.yaml
name: default_ip_remediation
filters:
  - Alert.Remediation == true && Alert.GetScope() == "Ip"
decisions:
  - type: ban
    duration: 4h
duration_expr: Sprintf('%dh', (GetDecisionsCount(Alert.GetValue()) + 1) * 4)
on_success: break
  • filters : le profil ne s’applique qu’aux alertes qui demandent une sanction et visent une adresse IP ;
  • duration_expr : 4 heures la première fois, 8 la deuxième, 12 la troisième… Le calcul utilise l’historique de l’API locale, il survit donc aux redémarrages ;
  • on_success: break : les profils suivants ne sont pas évalués. L’ordre des profils dans le fichier compte.

Les pannes fréquentes

Rien n’est jamais banni

Vérifiez dans l’ordre : cscli metrics show acquisition (les lignes sont-elles lues ?), cscli metrics show parsers (sont-elles comprises ?), cscli alerts list (des scénarios se déclenchent-ils ?), cscli bouncers list (le bouncer récupère-t-il les décisions ?). La panne se trouve presque toujours à la première étape qui reste à zéro.

Le bouncer ne démarre pas, « unauthorized »

La clé du bouncer ne correspond à aucune clé de l’API locale, typiquement après une réinstallation qui a vidé la base. Supprimez l’entrée (cscli bouncers delete), recréez-la et recopiez la clé.

L’API locale écoute sur un port déjà pris

Par défaut, l’API locale écoute sur 8080, port très demandé. Changez-le dans config.yaml (api.server.listen_uri) et dans local_api_credentials.yaml, puis dans la configuration de chaque bouncer. Oublier l’un des trois produit un agent qui démarre mais dont les outils ne parlent plus à personne.

Les parseurs ne comprennent pas les journaux SSH

Les versions récentes d’OpenSSH journalisent sous le nom sshd-session au lieu de sshd. Si les parseurs ne suivent pas, les échecs d’authentification ne sont plus reconnus du tout. Un cscli hub upgrade règle généralement la question ; vérifiez avec cscli explain --file /var/log/secure --type syslog, qui montre, ligne par ligne, quel parseur l’a acceptée ou rejetée.

Mettre à jour sans surprise

  • mettez à jour l’agent, puis vérifiez cscli metrics et la liste des bouncers avant de toucher aux bouncers ;
  • lisez les notes de version : la version 1.8 a par exemple changé la façon dont certains champs sont exposés aux scénarios ;
  • après une mise à jour du hub, un cscli hub upgrade peut remplacer un scénario que vous aviez modifié à la main. Les modifications locales vont dans des fichiers à vous, jamais dans ceux du hub.

Et fail2ban ?

Les deux cohabitent sans problème, et c’est ce que je fais : fail2ban réagit vite à mes propres journaux avec des bannissements progressifs, CrowdSec ajoute les scénarios web et la liste communautaire. Seul inconvénient : quand une adresse reste bloquée, il faut regarder des deux côtés (fail2ban-client status et cscli decisions list).

Pour aller plus loin

CrowdSec sait aussi inspecter le contenu des requêtes HTTP grâce à son moteur AppSec, et bloquer les attaques directement dans le serveur web. C’est l’objet d’un prochain tutoriel de cette série, avec OpenResty.


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

Articles liés

Schéma des quatre étapes d'un serveur mail mox : identité réseau, SPF DKIM DMARC, MTA-STS, ports, puis vérifications

Pas à pas : installer, configurer et vérifier un serveur mail avec mox

Pour tenir un serveur de courrier que Gmail et Outlook acceptent, quatre points doivent être justes avant que le logiciel compte : une adresse IP propre dont le DNS direct et le DNS inverse concordent, les enregistrements SPF, DKIM et DMARC, MTA-STS et TLS-RPT pour imposer le chiffrement, et les ports ouverts avec les vérifications qui prouvent que tout fonctionne. mox apporte le logiciel en un seul binaire. Ce tutoriel l’installe et vérifie chacun de ces points avec des commandes que vous pouvez lancer.

Héberger son courrier a mauvaise réputation : un serveur mal configuré voit ses messages finir en indésirables ou refusés, et un serveur mal protégé devient un relais pour les spammeurs. mox (code source sur GitHub) est un serveur de courrier complet écrit en Go et livré en un seul binaire : SMTP entrant et sortant, IMAP, webmail, SPF, DKIM, DMARC, MTA-STS, TLS-RPT, filtrage du courrier indésirable par réputation, et ses propres certificats Let’s Encrypt.

Exemple utilisé : le domaine example.org, le serveur mail.example.org en 203.0.113.25. Comptez une demi-journée, dont une bonne partie à attendre la propagation du DNS.

Schéma des quatre étapes d'un serveur mail mox : identité réseau, SPF DKIM DMARC, MTA-STS, ports, puis vérifications
Ce qui doit être juste avant d’envoyer le premier message.

Pourquoi mox plutôt que Postfix et Dovecot

La pile classique (Postfix, Dovecot, un filtre comme Rspamd, OpenDKIM, un webmail, certbot) fonctionne très bien, mais demande d’assembler et de maintenir six logiciels qui doivent s’entendre. mox fait tout cela d’un bloc, avec des valeurs par défaut sûres et des outils de vérification intégrés. Le revers : un projet plus jeune, dont la configuration change parfois d’une version à l’autre. Lisez les notes de version avant chaque mise à jour.

Prérequis : ce qui ne se rattrape pas

Une adresse IP fixe et propre : vérifiez qu’elle ne figure pas sur une liste de blocage (Spamhaus, Barracuda…) avant de commencer ; une adresse héritée d’un ancien spammeur est un boulet.

Le port 25 sortant ouvert : beaucoup d’hébergeurs le bloquent par défaut sur les VPS. Testez-le avant tout : nc -vz gmail-smtp-in.l.google.com 25. S’il est fermé, il faut le demander au support.

Le DNS inverse (PTR) modifiable chez l’hébergeur.

Un serveur dédié au courrier, de préférence : il n’y a alors aucun autre service à surveiller sur cette machine, et une compromission d’une application web n’atteint pas vos boîtes.

Étape 1 : l’identité réseau, avant tout le reste

Les grands hébergeurs de messagerie vérifient que l’adresse IP qui se présente correspond, dans les deux sens, au nom annoncé. Réglez le PTR chez l’hébergeur du VPS (pas dans la zone DNS du domaine), pour IPv4 et pour IPv6 si le serveur en a une :

dig +short -x 203.0.113.25          # mail.example.org.
dig +short mail.example.org A       # 203.0.113.25
dig +short -x 2001:db8::25          # mail.example.org. (sinon, désactivez l'IPv6 sortant pour le courrier)

Un PTR IPv6 manquant est un piège courant : si le serveur a une adresse IPv6, il l’utilise pour joindre Gmail, et Gmail peut refuser le message : son erreur indique « does not meet IPv6 sending guidelines regarding PTR records », et ses règles pour les expéditeurs exigent un enregistrement PTR pour chaque adresse IP d’envoi. Soit vous le réglez, soit vous empêchez mox d’envoyer en IPv6.

Étape 2 : installer

useradd -m -d /home/mox -s /sbin/nologin mox
cd /home/mox
# télécharger le binaire mox de la dernière version publiée, vérifier sa somme de contrôle
install -o root -g root -m 0755 mox-vX.Y.Z-linux-amd64 /home/mox/mox
./mox quickstart postmaster@example.org

quickstart fait beaucoup en une commande :

Il écrit config/mox.conf (le serveur : nom d’hôte, adresses d’écoute, ACME) et config/domains.conf (les domaines, les comptes, les adresses).

Il génère deux clés DKIM par domaine (une RSA, une Ed25519).

Il crée le compte postmaster et affiche son mot de passe, ainsi que celui de l’interface d’administration.

Il imprime la liste exacte des enregistrements DNS à créer, et une unité systemd prête à l’emploi.

Conservez cette sortie dans un endroit sûr : elle contient des mots de passe et les valeurs DNS. mox tourne sous le compte mox, sans droits root, et obtient seulement par systemd la capacité d’écouter sur les ports inférieurs à 1024.

Étape 3 : le pare-feu

PortUsageOuvrir à
25/tcpSMTP : réception depuis les autres serveurs, et envoi vers euxtout le monde
465/tcpsoumission chiffrée (TLS direct) pour vos clients de messagerietout le monde
587/tcpsoumission avec STARTTLS (anciens clients, relais de vos autres serveurs)tout le monde ou vos serveurs
993/tcpIMAP chiffrétout le monde
80, 443/tcpACME (certificats), MTA-STS, autoconfiguration, webmail, administrationtout le monde
firewall-cmd --permanent --add-service={smtp,smtps,smtp-submission,imaps,http,https}
firewall-cmd --reload

Le port 143 (IMAP non chiffré) n’a pas besoin d’être ouvert : tous les clients modernes savent utiliser 993.

Étape 4 : les enregistrements DNS, un par un

mail.example.org.                 A      203.0.113.25
mail.example.org.                 AAAA   2001:db8::25
example.org.                      MX     10 mail.example.org.
example.org.                      TXT    "v=spf1 mx ip4:127.0.0.1 ip6:::1 ~all"
2026a._domainkey.example.org.     TXT    "v=DKIM1; k=ed25519; p=…"
2026b._domainkey.example.org.     TXT    "v=DKIM1; k=rsa; p=…"
_dmarc.example.org.               TXT    "v=DMARC1; p=quarantine; rua=mailto:dmarc-reports@example.org"
mta-sts.example.org.              CNAME  mail.example.org.
_mta-sts.example.org.             TXT    "v=STSv1; id=20261105T120000"
_smtp._tls.example.org.           TXT    "v=TLSRPTv1; rua=mailto:tlsrpt@example.org"
autoconfig.example.org.           CNAME  mail.example.org.
_autodiscover._tcp.example.org.   SRV    0 1 443 mail.example.org.
_submissions._tcp.example.org.    SRV    0 1 465 mail.example.org.
_imaps._tcp.example.org.          SRV    0 1 993 mail.example.org.
example.org.                      CAA    0 issue "letsencrypt.org"

Être trouvé : A, AAAA, MX

Le MX dit aux autres serveurs où livrer le courrier de example.org. Il pointe toujours vers un nom, jamais vers une adresse IP, et ce nom doit avoir ses enregistrements A (et AAAA). La priorité (10) ne sert que s’il y a plusieurs MX.

Prouver qui envoie : SPF, DKIM, DMARC

SPF liste les machines autorisées à envoyer pour le domaine. mx autorise les serveurs du MX ; ip4:127.0.0.1 ip6:::1 sert au courrier que le serveur s’envoie à lui-même (voir plus bas) ; ~all marque les autres comme suspects sans les rejeter. N’utilisez -all que si vous êtes certain de connaître toutes vos sources d’envoi (lettres d’information, formulaires de sites…).

DKIM publie les clés publiques qui permettent de vérifier la signature que mox pose sur chaque message sortant. Deux sélecteurs (2026a, 2026b) permettent de changer de clé sans coupure : on publie la nouvelle, on signe avec, puis on retire l’ancienne quelques semaines plus tard.

DMARC dit aux destinataires quoi faire d’un message dont ni SPF ni DKIM ne sont alignés sur le domaine de l’expéditeur, et où envoyer leurs rapports. Commencez par p=none pendant une à deux semaines en lisant les rapports, passez à p=quarantine, puis à p=reject quand vous êtes sûr qu’aucun envoi légitime n’échoue.

Imposer le chiffrement : MTA-STS et TLS-RPT

Sans MTA-STS, un attaquant placé sur le chemin peut retirer l’offre STARTTLS d’une connexion SMTP et lire le courrier en clair. Avec MTA-STS, les serveurs qui vous écrivent apprennent que votre domaine exige TLS avec un certificat valide. mox sert lui-même la politique sur https://mta-sts.example.org/.well-known/mta-sts.txt. TLS-RPT vous fait envoyer chaque jour les rapports des échecs de chiffrement. Changez l’id de _mta-sts à chaque modification de la politique.

Configurer les clients : autoconfig et SRV

Thunderbird, l’application Mail d’Apple et d’autres trouvent seuls les bons serveurs et ports grâce à autoconfig, _autodiscover et aux enregistrements SRV. L’enregistrement CAA, facultatif, n’autorise que Let’s Encrypt à émettre des certificats pour le domaine.

Une commande imprime à tout moment les valeurs attendues : ./mox config dnsrecords example.org.

Étape 5 : démarrer, puis créer les comptes

systemctl enable --now mox
./mox config test
./mox config account add alice alice@example.org
./mox setaccountpassword alice
./mox config address add contact@example.org alice      # une adresse de plus pour le même compte
./mox config account list

Côté client de messagerie : IMAP sur mail.example.org:993 (SSL/TLS), envoi sur mail.example.org:465 (SSL/TLS) avec l’adresse complète comme identifiant. Le webmail et l’administration sont sur https://mail.example.org/.

Étape 6 : vérifier, sérieusement

./mox config dnscheck example.org     # SPF, DKIM, DMARC, MTA-STS, TLS-RPT, MX, PTR
./mox queue list                      # la file d'envoi : vide ou presque
journalctl -u mox -n 50 --no-pager
dig +short MX example.org @ns1.fournisseur-dns.example   # interrogez les serveurs faisant autorité

Interrogez toujours les serveurs DNS faisant autorité de votre zone : certains résolveurs publics renvoient des réponses vides trompeuses pendant la propagation, et on finit par corriger un problème qui n’existe pas.

Puis le test qui compte : envoyez un message vers une boîte Gmail et une boîte Outlook. Ouvrez l’en-tête complet (« Afficher l’original » dans Gmail) et cherchez spf=pass, dkim=pass et dmarc=pass. Répondez depuis ces boîtes et vérifiez que la réponse arrive. Les premiers jours, quelques messages peuvent tomber en indésirables le temps que votre adresse se fasse une réputation : demandez aux destinataires de les marquer comme légitimes.

Ce que donnent ces vérifications sur mon serveur mail

Mon propre serveur mox, vérifié le 2 novembre 2026. Les noms de domaine sont réécrits en example.org, les valeurs sont réelles.

# ./mox version
v0.0.17-go1.27.0
linux/amd64

# ./mox config test
config OK

# ss -ltn   (ports en écoute, mox seulement)
0.0.0.0:25  0.0.0.0:443  0.0.0.0:465  0.0.0.0:587  0.0.0.0:993   (et les mêmes sur [::])

# dig +short MX example.org
10 mail.example.org.
# dig +short TXT _dmarc.example.org
"v=DMARC1;p=reject;rua=mailto:dmarc-reports@example.org!10m"
# dig +short TXT _mta-sts.example.org
"v=STSv1; id=ansible20260915"
# dig +short TXT _smtp._tls.example.org
"v=TLSRPTv1; rua=mailto:tlsreports@example.org"

# openssl s_client -starttls smtp -connect mail.example.org:25 -servername mail.example.org
New, TLSv1.3, Cipher is TLS_AES_128_GCM_SHA256
Verify return code: 0 (ok)

config OK : les deux fichiers sont lisibles et cohérents. À lancer avant chaque redémarrage ; mox refuse de démarrer sur une configuration invalide, et un serveur mail qui ne redémarre pas, ce sont des messages qui s’accumulent chez les expéditeurs.

Cinq ports, en IPv4 et en IPv6 : 25 (réception depuis les autres serveurs), 465 et 587 (envoi par vos clients), 993 (IMAP), 443 (webmail, administration, politique MTA-STS et certificats automatiques). Le port 80 n’est pas ouvert : les certificats s’obtiennent sur le 443 avec le défi TLS-ALPN.

p=reject dans DMARC : n’y passez que lorsque les rapports agrégés montrent que toutes vos sources légitimes passent, sinon ce sont vos propres messages qui seront rejetés. Le suffixe !10m limite la taille des rapports à 10 Mo.

id=ansible20260915 dans l’enregistrement MTA-STS : l’identifiant signale aux expéditeurs que la politique a changé. Il faut le modifier à chaque changement du fichier de politique, sinon ils garderont la politique en cache jusqu’à l’expiration de son max_age (RFC 8461).

TLSv1.3, Verify return code: 0 : STARTTLS sur le port 25 présente un certificat valide pour le nom du serveur. C’est ce que vérifie un serveur expéditeur quand MTA-STS est en mode « enforce ».

Le courrier que le serveur s’envoie à lui-même

Les rapports de cron, de logwatch ou des sauvegardes sont souvent adressés à root@example.org, hébergé sur ce même serveur. mox n’a pas de livraison locale interne : il cherche le MX, trouve son propre nom, et repasse par son interface publique. Cela échoue par intermittence. La correction consiste à router ce courrier par la boucle locale :

# domains.conf : router le courrier de nos propres domaines par la boucle locale
Routes:
	-
		ToDomain:
			- example.org
		Transport: loopback

# mox.conf
Transports:
	loopback:
		SMTP:
			Host: mail-loopback.example.org   # 127.0.0.1 dans /etc/hosts
			Port: 25
			STARTTLSInsecureSkipVerify: true

Deux conséquences à traiter. mox applique ses contrôles à ce courrier comme à n’importe quel autre : il faut donc ip4:127.0.0.1 ip6:::1 dans le SPF (sans risque, personne d’extérieur ne se connecte depuis la boucle locale). Et le compte qui ne reçoit que ce courrier interne doit avoir NoFirstTimeSenderDelay: true : sinon mox applique à ces expéditeurs « inconnus » un délai de quinze secondes que le client de la boucle n’attend pas.

Faire envoyer vos autres serveurs par mox

Vos autres machines ont besoin d’envoyer du courrier (alertes, formulaires PHP, rapports). Plutôt que d’en faire autant de serveurs de courrier mal vus, configurez sur chacune un Postfix minimal qui confie tout à mox, en s’authentifiant sur le port 587 avec un compte dédié :

# /etc/postfix/main.cf sur un AUTRE serveur, qui confie tout son courrier à mox
relayhost = [mail.example.org]:587
smtp_sasl_auth_enable = yes
smtp_sasl_password_maps = hash:/etc/postfix/sasl_passwd
smtp_sasl_security_options = noanonymous
smtp_tls_security_level = encrypt
inet_interfaces = loopback-only

inet_interfaces = loopback-only : ce Postfix n’écoute que localement, il ne reçoit jamais de courrier de l’extérieur. Sur une machine sous SELinux, PHP a besoin du booléen httpd_can_sendmail pour utiliser mail().

Sauvegarder et restaurer

./mox backup /data/backup/mox/$(date +%Y%m%d)
./mox verifydata /data/backup/mox/20261105/data

mox backup produit une copie cohérente des bases de comptes et des messages sans arrêter le service ; mox verifydata vérifie le répertoire data de la sauvegarde. Copiez chaque nuit la sauvegarde hors du serveur. mox backup copie la configuration, qui contient les clés DKIM, dans config à côté de data : une seule copie couvre les deux. Un serveur de courrier, c’est aussi une identité : sans les clés DKIM d’origine, il faudrait republier le DNS. Pour restaurer, on arrête mox, on remplace le répertoire de données par la sauvegarde, on lance verifydata, puis on redémarre.

Mettre à jour

Une mise à jour consiste à remplacer le binaire et à redémarrer. Lisez les notes de version avant : certaines versions renomment des options de configuration. Lancez une sauvegarde juste avant, puis ./mox config test avec le nouveau binaire avant de redémarrer le service.

Diagnostiquer un message refusé

Gmail refuse, « PTR » ou « reverse DNS » dans le message d’erreur : PTR absent ou incohérent, souvent en IPv6.

Message en indésirables chez tout le monde : vérifiez que DKIM et DMARC passent, et l’adresse IP sur les listes de blocage.

Messages qui restent dans la file : ./mox queue list donne la dernière erreur de chaque message ; un délai d’attente vers tous les destinataires indique le port 25 sortant bloqué.

Refus pour spf-policy sur le courrier interne : il manque la boucle locale dans le SPF.

Les rapports DMARC arrivent chaque jour dans la boîte dmarc-reports : mox les lit et les présente dans son interface. C’est là qu’on découvre qu’un service tiers envoie en votre nom sans être autorisé.


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

Documentation officielle

mox (site du projet et documentation), mox sur GitHub (code source, README et versions), RFC 7208 (SPF), RFC 6376 (signatures DKIM), RFC 7489 (DMARC), RFC 8461 (MTA-STS), RFC 8460 (TLS-RPT), documentation de Let’s Encrypt (certificats) et règles de Google pour les expéditeurs (exigences PTR, SPF, DKIM et DMARC).

Articles liés

Installer WireGuard entre un serveur et la maison

Les réglages MariaDB qui comptent vraiment

Un /boot trop petit, des miroirs et des alertes

Schéma comparant Brotli, PHP2Shell et ZDI-CAN-33367 : mécanisme de chaque faille et présence ou non d'une corruption mémoire

Sous le capot des failles d’octobre 2026 : un octet de trop, un pointeur oublié, une page partagée

Cette semaine, j’ai publié quatre billets sur quatre failles d’octobre 2026 : PHP2Shell, la faille Brotli, les correctifs de Node.js et la faille noyau ZDI-CAN-33367. Chacun expliquait la faille et ce que j’ai fait sur mes serveurs. Celui-ci prend du recul et descend d’un niveau : comment un octet de trop ou un pointeur oublié (deux formes de corruption mémoire), ou une page partagée, deviennent une exécution de code, et pourquoi les protections modernes freinent certaines de ces failles et pas d’autres. Aucun détail d’exploitation, seulement les mécanismes, au niveau qu’un administrateur a besoin de comprendre pour juger d’une gravité et choisir une mesure.

Brotli (Node2Shell)PHP2ShellZDI-CAN-33367
classe de bugécriture hors limitesutilisation après libération, état incohérenterreur de logique : deux chemins se partagent une page
oùdécodeur en continu, code Cgestionnaire de mémoire et nettoyage de requête, code Cpile réseau du noyau
corruption mémoire ?ouiouinon : chaque écriture est « légitime »
déclencheurdonnées compressées reçuesrequête HTTPutilisateur local
freiné par ASLR, CFI…oui, en partieoui, en partienon
Schéma comparant Brotli, PHP2Shell et ZDI-CAN-33367 : mécanisme de chaque faille et présence ou non d'une corruption mémoire
Comment chaque faille devient une exécution de code, et pourquoi les protections n’agissent pas partout.

Ce que veut dire « corruption mémoire »

Un programme écrit en C gère lui-même sa mémoire : il demande une zone d’une certaine taille, y range des données, la rend quand il a fini. Le langage ne vérifie rien : écrire 9 octets dans une zone de 8, ou lire une zone déjà rendue, ne provoque aucune erreur immédiate. Le programme écrit simplement à côté, dans ce qui se trouve là. Toute la gravité dépend de ce qui se trouve là. On parle alors de corruption mémoire.

Pour un attaquant, le chemin typique comporte trois étapes. D’abord une primitive : la capacité, souvent très limitée au départ, d’écrire ou de lire un peu de mémoire qui ne devrait pas l’être. Ensuite l’élargissement : utiliser cette petite écriture pour modifier une structure qui contrôle d’autres accès (une longueur, un pointeur), jusqu’à pouvoir lire et écrire n’importe où. Enfin le détournement : modifier une adresse que le programme utilisera pour savoir quel code exécuter ensuite. Chaque étape est difficile ; les outils d’analyse assistés par IA qui ont découvert PHP2Shell et Node2Shell sont précisément bons à les enchaîner.

Brotli : une erreur prise pour une attente

Le format

flux Brotli
├─ en-tête du flux : taille de la fenêtre glissante (jusqu'à 16 Mio)
└─ méta-blocs, l'un après l'autre
   ├─ en-tête : longueur, dernier bloc ?
   ├─ 3 catégories de blocs, chacune avec jusqu'à 256 « types de bloc » :
   │    littéraux · longueurs insertion+copie · distances
   ├─ codes préfixes (Huffman) pour chaque type de bloc
   ├─ cartes de contexte : quel code utiliser selon les octets précédents
   └─ commandes : « insérer N littéraux, puis copier M octets situés D plus haut »
        … entrecoupées de CHANGEMENTS DE BLOC : « passe au type 3 pour les 500 prochains symboles »

Brotli est un format dense. Un flux est une suite de méta-blocs. Les données y sont décrites par des commandes : insérer quelques octets littéraux, puis recopier une séquence déjà produite plus haut dans la fenêtre. Chaque élément est codé par des codes préfixes (des codes de Huffman, où les symboles fréquents prennent peu de bits). Particularité de Brotli : il peut utiliser plusieurs jeux de codes, appelés types de bloc, et passer de l’un à l’autre en cours de route par des commandes de changement de bloc. C’est ce qui lui permet de bien compresser un document dont la nature change (du HTML, puis du JavaScript intégré, puis du texte). C’est aussi une complexité supplémentaire pour le décodeur, qui doit valider chaque changement : le type demandé existe-t-il, le nombre de symboles annoncé est-il cohérent ?

Le décodage en continu

appel 1 : entrée = 4 096 octets   → décode … il manque 3 bits pour finir le symbole
          → copie les octets restants dans le petit tampon interne (8 octets)
          → répond NEEDS_MORE_INPUT
appel 2 : entrée = 4 096 octets   → ajoute 1 octet au tampon, réessaie
          → succès : reprend le décodage normal
--- avec le bug ---
appel n : changement de bloc INVALIDE → répond NEEDS_MORE_INPUT au lieu d'ERROR
          → ajoute 1 octet au tampon, réessaie → toujours invalide → NEEDS_MORE_INPUT
          → ajoute 1 octet… 9e octet, 10e octet… → écriture au-delà des 8 octets

Un décodeur en continu reçoit les données par morceaux, au fil du réseau. Un symbole peut être à cheval sur deux morceaux : les derniers bits d’un morceau ne suffisent pas pour le décoder. Le décodeur de référence garde alors les octets en attente dans un très petit tampon interne de huit octets, répond à l’appelant « il me faut plus de données », puis, à l’appel suivant, ajoute les nouveaux octets un par un dans ce tampon et réessaie, jusqu’à ce que le symbole soit complet. Ce petit tampon suffit toujours, car aucun symbole valide ne dépasse cette taille.

Le bug tient dans une confusion entre deux réponses. Face à un changement de bloc invalide, le décodeur répondait « il me faut plus de données » au lieu de « ce flux est invalide ». Or un changement invalide ne deviendra jamais valide avec plus d’octets : le décodeur ajoutait donc un octet, réessayait, échouait, en ajoutait un autre… et finissait par écrire au-delà des huit octets du tampon, dans les champs voisins de sa propre structure d’état. Ces champs décrivent le décodage en cours : positions, longueurs, pointeurs vers la fenêtre de sortie. Et c’est l’attaquant qui choisit les octets qui y sont écrits. Le correctif ajoute un code d’erreur dédié, renvoyé au lieu de la demande de données.

La leçon dépasse Brotli : dans une machine à états, la frontière entre « incomplet » et « invalide » est un point de sécurité. Un analyseur qui confond les deux finit soit par boucler indéfiniment, soit, comme ici, par accumuler sans fin.

PHP2Shell : la mémoire qui survit à la requête

L’allocateur de PHP

mémoire d'une requête PHP (Zend Memory Manager)
├─ blocs de 2 Mio, découpés en pages de 4 Kio
├─ petites allocations : 30 classes de taille (8, 16, 24 … 3 072 octets)
│    une page est dédiée à une classe ; chaque case libre pointe vers la suivante
└─ fin de requête : tout est rendu d'un coup, sans libérer objet par objet

PHP n’utilise pas directement l’allocateur du système pour les données des scripts. Son propre gestionnaire, le Zend Memory Manager, réserve de gros blocs et les découpe en pages, chaque page étant dédiée à une classe de taille. Une allocation de 40 octets reçoit une case de la classe 40 ; une case libérée rejoint une liste de cases libres de sa classe, et sera la prochaine donnée à une allocation de même taille. C’est rapide et cela rend le comportement très prévisible, ce qui est un avantage pour les performances et un cadeau pour un attaquant : s’il sait qu’une case de 48 octets vient d’être libérée, il sait qu’une chaîne de 48 octets qu’il envoie prendra sa place.

Interrompre un nettoyage

Quand un script dépasse memory_limit, PHP lève une erreur fatale et interrompt l’exécution par un saut direct vers le point de reprise de la requête (le mécanisme bailout, construit sur longjmp en C). Tout le code qui devait s’exécuter entre les deux est sauté. Si l’interruption survient pendant le nettoyage de structures internes, certaines sont à moitié démontées : un compteur de références décrémenté sans que l’objet soit libéré, ou l’inverse. C’est le premier bug de PHP2Shell, intitulé « RCE via OOM corruption » : un manque de mémoire provoqué au bon moment laisse le gestionnaire dans un état incohérent.

L’état qui survit

requête 1 : objet A (48 octets) alloué ; une variable GLOBALE garde un pointeur vers A
            fin de requête → la mémoire de A est libérée, le pointeur global, lui, reste
requête 2 (même processus) : l'attaquant envoie une chaîne de 48 octets
            → l'allocateur la range dans la case libre… celle de A
            → le code qui suit le pointeur global lit la chaîne comme si c'était A

Le second bug, « RCE via stale global state », exploite la réutilisation des processus. Avec PHP-FPM, un même processus traite des milliers de requêtes. La mémoire de chaque requête est rendue en bloc à la fin, mais certaines variables globales, propres au processus, survivent. Si l’une d’elles garde un pointeur vers une donnée de la requête précédente, ce pointeur désigne désormais une case libre, que la requête suivante réutilisera. L’attaquant envoie alors une donnée de la bonne taille, qui prend la place de l’ancienne. Le code qui suit le pointeur interprète ses octets comme une structure interne de PHP : il lit, à la place d’une longueur ou d’un pointeur, ce que l’attaquant a écrit. C’est la confusion de types, point de départ classique vers une lecture et une écriture arbitraires.

ZDI-CAN-33367 : aucune corruption, une page partagée

La faille noyau est d’une autre nature, et c’est ce qui la rend si fiable. Aucune zone n’est dépassée, aucun pointeur n’est périmé. Une page du cache d’un fichier est référencée par un paquet réseau grâce à une optimisation sans copie ; le marqueur qui signale « cette page est partagée » se perd dans une fonction de transfert ; le module ESP déchiffre alors « sur place », c’est-à-dire qu’il écrit son résultat dans cette page. Chaque opération est correcte en elle-même. C’est leur combinaison qui fait écrire le noyau dans un fichier en lecture seule, avec un contenu choisi par l’attaquant, qui contrôle la clé et le texte chiffré.

Comme rien n’est corrompu, aucune protection contre la corruption ne s’applique. Pas d’adresse à deviner, pas de flot d’exécution à détourner : l’attaquant modifie un fichier (un programme setuid, un fichier de configuration), puis l’exécute normalement. C’est la même famille que Dirty COW et Dirty Pipe, réputées pour fonctionner presque à coup sûr.

Les protections, et leurs limites

readelf -h /usr/sbin/php-fpm | grep Type       → DYN   (exécutable à position indépendante)
readelf -h /usr/bin/node     | grep Type       → EXEC  (adresse fixe : l'ASLR ne déplace pas son code)
readelf -n /usr/sbin/php-fpm | grep -o 'IBT\|SHSTK'   → IBT SHSTK (compilé pour CET)
grep -wo 'ibt\|user_shstk' /proc/cpuinfo        → (rien : le processeur ne gère pas CET)
ps -eZ | grep php-fpm                           → httpd_t  (confiné par SELinux)

Les systèmes modernes empilent des protections qui rendent chaque étape d’une exploitation par corruption mémoire plus coûteuse. Aucune ne corrige le bug ; toutes rendent son exploitation plus difficile.

  • ASLR : les adresses de la pile, du tas et des bibliothèques changent à chaque démarrage, donc l’attaquant doit d’abord découvrir où se trouve ce qu’il veut modifier, souvent grâce à une seconde faille de lecture. Un exécutable non compilé en position indépendante garde son code à une adresse fixe : c’est le cas des binaires officiels de Node.js sur mes serveurs, contrairement à php-fpm ;
  • pile et données non exécutables : on ne peut plus écrire du code puis sauter dessus ; il faut réutiliser des morceaux du code existant ;
  • RELRO complet : les tables d’adresses de fonctions sont mises en lecture seule après le chargement, une cible classique de moins ;
  • CET (Intel) : une pile fantôme vérifie les adresses de retour et un marquage des cibles de saut limite les détournements. php-fpm est compilé pour, mais le processeur de mon serveur, de 2017, ne le gère pas : la protection est présente dans le binaire et inactive dans les faits ;
  • le confinement : même réussie, l’exploitation donne les droits du processus attaqué. php-fpm tourne dans le domaine SELinux httpd_t, qui limite ce qu’il peut lire, exécuter et contacter. Un service sans domaine dédié (unconfined_service_t) n’a pas ce filet.

Ces protections freinent Brotli et PHP2Shell, qui doivent passer de la corruption au détournement. Elles ne font rien contre ZDI-CAN-33367, qui ne détourne rien. Contre cette famille, les seules défenses sont le correctif, la réduction de la surface (modules bloqués, espaces de noms restreints) et le confinement de ce qui pourrait servir de point d’entrée local.

Ce que j’en tire pour juger une faille

  • la classe de bug compte autant que le score : une erreur de logique sur une page partagée est souvent plus fiable qu’une corruption mémoire notée plus haut ;
  • le déclencheur : qui fournit les données ? Un client distant sans authentification (PHP2Shell, corps de requête Brotli), un serveur que l’on contacte (fetch()), un utilisateur local (noyau) ;
  • la prévisibilité de l’allocateur et la réutilisation des processus augmentent l’exploitabilité ;
  • les protections réellement actives, sur le matériel réel : un binaire compilé pour CET sur un processeur qui ne le gère pas n’est pas protégé ;
  • le confinement détermine ce que coûte une exploitation réussie : c’est la dernière ligne, et la seule qui fonctionne contre une faille encore inconnue.

Sources : RFC 7932 (format Brotli) ; avis de sécurité de PHP, Node.js ; analyses d’Akamai et de TuxCare ; code source de php-src (Zend/zend_alloc.c) et de Brotli (c/dec/decode.c).


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

Articles liés

Schéma : six familles de réglages MariaDB (mémoire, durabilité, entrées/sorties, connexions, tables, binlogs) avec leur méthode de vérification

Pas à pas : les réglages MariaDB qui comptent vraiment, et comment les vérifier

On trouve sur Internet des fichiers my.cnf de cent lignes, copiés de serveur en serveur, dont personne ne sait plus pourquoi chaque ligne est là. La plupart des valeurs par défaut de MariaDB sont raisonnables ; une dizaine de réglages seulement font une vraie différence. Ce tutoriel les passe en revue à partir d’un serveur réel : MariaDB 12.3 sur Rocky Linux, une trentaine de sites (WordPress, Matomo, Piwigo…), 32 Go de RAM partagés avec PHP, nginx et d’autres services, des disques rotatifs.

Pour chaque réglage : ce qu’il fait, comment choisir la valeur, et surtout comment vérifier qu’elle est bonne. Un réglage qu’on ne sait pas mesurer est un réglage qu’on ne devrait pas toucher.

Schéma : six familles de réglages MariaDB (mémoire, durabilité, entrées/sorties, connexions, tables, binlogs) avec leur méthode de vérification
Les réglages MariaDB qui comptent vraiment, regroupés par famille, avec comment les vérifier.

Où vit la configuration de MariaDB, et comment lire la valeur réelle

MariaDB lit /etc/my.cnf puis les fichiers de /etc/my.cnf.d/. Les réglages du serveur vont dans une section [mariadb] (lue seulement par MariaDB) ou [mysqld] (lue aussi par les outils compatibles MySQL). Le piège classique : une même variable définie dans deux fichiers, la dernière lue l’emporte. Deux commandes donnent la vérité :

mariadbd --print-defaults          # ce que le serveur lira au prochain démarrage
mariadb -e "SHOW GLOBAL VARIABLES LIKE 'innodb_buffer_pool_size'"   # la valeur en cours

Une variable mal orthographiée dans le fichier est ignorée avec un simple avertissement dans le journal d’erreurs. Comparez toujours la valeur en cours avec celle que vous croyez avoir mise.

Le fichier, en entier

[mariadb]
# --- Mémoire -------------------------------------------------------------
innodb_buffer_pool_size        = 12G
innodb_log_file_size           = 2G
innodb_log_buffer_size         = 256M
tmp_table_size                 = 256M
max_heap_table_size            = 256M

# --- Durabilité ----------------------------------------------------------
innodb_flush_log_at_trx_commit = 1
sync_binlog                    = 1
innodb_flush_method            = O_DIRECT

# --- Entrées/sorties (disques rotatifs) ----------------------------------
innodb_io_capacity             = 200
innodb_io_capacity_max         = 400

# --- Connexions ----------------------------------------------------------
max_connections                = 400
thread_cache_size              = 64
wait_timeout                   = 28800

# --- Tables et fichiers --------------------------------------------------
table_open_cache               = 4096
table_open_cache_instances     = 8
table_definition_cache         = 4096
open_files_limit               = 68000

# --- Binlogs, réplication ------------------------------------------------
server_id                      = 10
log_bin                        = /data/mysql/binlogs/logbin
binlog_format                  = ROW
binlog_expire_logs_seconds     = 432000
max_binlog_size                = 512M
log_slave_updates              = ON

# --- Hygiène -------------------------------------------------------------
character_set_server           = utf8mb4
collation_server               = utf8mb4_uca1400_ai_ci
transaction_isolation          = READ-COMMITTED
skip_name_resolve              = ON
local_infile                   = OFF
max_allowed_packet             = 256M
slow_query_log                 = ON
long_query_time                = 5
log_slow_verbosity             = query_plan,explain

La mémoire

innodb_buffer_pool_size, le réglage qui compte le plus

C’est le cache dans lequel InnoDB garde les pages de tables et d’index. Tant que les données réellement utilisées y tiennent, les lectures ne touchent pas le disque, et c’est souvent un facteur cent sur les temps de réponse. La règle habituelle : 60 à 75 % de la RAM sur un serveur dédié à la base, 30 à 40 % sur un serveur qui fait aussi tourner l’application et le serveur web. Ici, 12 Go sur 32.

Pour savoir s’il suffit, mesurez la proportion de lectures servies par le cache :

SELECT ROUND(100 * (1 - r.v / q.v), 2) AS hit_ratio_pct
FROM (SELECT VARIABLE_VALUE v FROM information_schema.GLOBAL_STATUS
      WHERE VARIABLE_NAME = 'Innodb_buffer_pool_reads') r,
     (SELECT VARIABLE_VALUE v FROM information_schema.GLOBAL_STATUS
      WHERE VARIABLE_NAME = 'Innodb_buffer_pool_read_requests') q;

Au-dessus de 99 % sur une journée d’activité normale, la mémoire n’est pas votre problème. En dessous de 95 %, chaque requête qui touche des données froides va lire le disque : augmentez le cache si la RAM le permet, ou cherchez les requêtes qui balaient des tables entières. Depuis MariaDB 10.5, il n’y a plus lieu de découper le cache en innodb_buffer_pool_instances : c’est géré en interne.

innodb_log_file_size : dimensionner le journal redo

Chaque modification est d’abord écrite dans le journal redo, puis les pages modifiées sont écrites dans les fichiers de données en tâche de fond. Un journal trop petit oblige InnoDB à vider ses pages en urgence quand il se remplit, ce qui produit des pics de latence. Une bonne taille couvre environ une heure d’écritures. Mesurez-la :

SELECT VARIABLE_VALUE INTO @a FROM information_schema.GLOBAL_STATUS WHERE VARIABLE_NAME='Innodb_lsn_current';
SELECT SLEEP(3600);
SELECT VARIABLE_VALUE INTO @b FROM information_schema.GLOBAL_STATUS WHERE VARIABLE_NAME='Innodb_lsn_current';
SELECT ROUND((@b - @a) / 1024 / 1024) AS redo_mb_per_hour;

Si le résultat est de 400 Mo par heure, un journal de 512 Mo à 1 Go suffit ; ici 2 Go laissent de la marge pour les imports. Un journal plus grand allonge seulement la récupération après un crash, de quelques secondes à quelques minutes.

La mémoire par connexion : le piège de la multiplication

sort_buffer_size, join_buffer_size, read_buffer_size, read_rnd_buffer_size sont alloués par connexion, et parfois plusieurs fois par requête. Une valeur de 64 Mo pour join_buffer_size semble anodine, mais multipliée par 400 connexions elle peut théoriquement réclamer 25 Go. Gardez les valeurs par défaut sauf mesure contraire, et relevez-les seulement pour une session précise (SET SESSION) lors d’un traitement lourd.

tmp_table_size et max_heap_table_size vont ensemble : la plus petite des deux fixe la taille maximale d’une table temporaire en mémoire avant son passage sur disque. Surveillez le rapport entre Created_tmp_disk_tables et Created_tmp_tables : s’il dépasse 10 à 20 %, des requêtes trient ou regroupent de gros volumes.

La durabilité

innodb_flush_log_at_trx_commit = 1 écrit et synchronise le journal redo à chaque validation ; sync_binlog = 1 fait de même pour le binlog. Ensemble, ils garantissent qu’une coupure de courant ne fait perdre aucune transaction validée et que le réplica reste cohérent avec le serveur principal. Les valeurs 2 ou 0 réduisent le nombre d’écritures synchrones, au prix de jusqu’à une seconde de transactions perdues en cas de crash du système : acceptable sur un réplica qu’on reconstruit, jamais sur le principal.

innodb_flush_method = O_DIRECT fait écrire InnoDB directement sur le disque sans passer par le cache du système : les données ne sont pas mises en cache deux fois (dans le cache d’InnoDB et dans celui du noyau). C’est la valeur par défaut des versions récentes ; vérifiez-la plutôt que de la supposer.

Les entrées/sorties

innodb_io_capacity indique à InnoDB combien d’opérations par seconde le stockage peut absorber pour ses travaux de fond (vidage des pages, purge). La valeur par défaut convient aux SSD. Sur des disques rotatifs, 200 évite qu’InnoDB sature le disque au détriment des requêtes ; innodb_io_capacity_max fixe le plafond en cas de retard. Pour vérifier : iostat -x 5 pendant une période chargée, la colonne %util ne doit pas rester collée à 100.

Les connexions

max_connections doit couvrir la somme des connexions que les applications peuvent ouvrir, avec une marge, sans plus : chaque connexion consomme de la mémoire, et augmenter cette limite pour « réparer » des erreurs Too many connections cache souvent une application qui ne ferme pas ses connexions. Regardez le pic réel :

SHOW GLOBAL STATUS LIKE 'Max_used_connections';
SHOW GLOBAL STATUS LIKE 'Aborted_c%';
SHOW GLOBAL STATUS LIKE 'Threads_created';

thread_cache_size garde des fils d’exécution prêts à resservir : si Threads_created augmente rapidement, augmentez-le. wait_timeout ferme les connexions inactives ; 8 heures conviennent aux applications web, qui se reconnectent d’elles-mêmes.

Les tables et les fichiers

table_open_cache garde les tables ouvertes entre deux requêtes ; il est découpé en table_open_cache_instances pour limiter la contention entre fils. Si Opened_tables augmente sans cesse, le cache est trop petit.

Le piège qui m’a coûté du temps : ce cache dépend du nombre de fichiers que le processus a le droit d’ouvrir. MariaDB calcule ses limites à partir d’open_files_limit, mais systemd impose sa propre limite (LimitNOFILE). Si celle-ci est plus basse, MariaDB réduit silencieusement ses caches au démarrage : j’ai ainsi trouvé un serveur réglé sur 8 instances qui n’en utilisait que 3. La correction est un fichier de surcharge systemd :

# /etc/systemd/system/mariadb.service.d/limits.conf
[Service]
LimitNOFILE=68000
systemctl daemon-reload && systemctl restart mariadb
mariadb -e "SHOW GLOBAL VARIABLES WHERE Variable_name IN ('open_files_limit','table_open_cache_instances')"

Les binlogs et la réplication

Le binlog enregistre chaque modification ; il sert à la réplication et à la restauration à un instant précis. binlog_format = ROW enregistre les lignes modifiées plutôt que les requêtes : plus volumineux, mais sans ambiguïté (une requête avec NOW() ou RAND() ne donne pas le même résultat rejouée ailleurs). binlog_expire_logs_seconds purge les anciens fichiers : gardez au moins l’intervalle entre deux sauvegardes complètes, sinon la restauration à un instant précis devient impossible pour la période intermédiaire. server_id doit être unique dans toute la topologie de réplication, et log_slave_updates permet à un réplica de servir lui-même de source.

L’hygiène

  • utf8mb4 : le vrai UTF-8 sur 4 octets, émojis compris. Le jeu utf8 historique est limité à 3 octets et tronque certains caractères ;
  • collation_server : les versions récentes proposent les collations UCA 14.0 (utf8mb4_uca1400_ai_ci), plus justes pour les comparaisons et les tris en français ;
  • READ-COMMITTED : moins de verrous que le REPEATABLE-READ par défaut, adapté aux applications web ;
  • skip_name_resolve : aucune résolution DNS à chaque connexion (un DNS lent rendrait les connexions lentes), et les droits se donnent par adresse IP ;
  • local_infile = OFF : ferme une porte qui permet à un client de faire lire des fichiers ;
  • max_allowed_packet : la taille maximale d’une requête ou d’une ligne ; trop petite, les imports et les gros contenus échouent ;
  • le journal des requêtes lentes : au-delà de 5 secondes, avec le plan d’exécution. À relire chaque semaine : c’est la meilleure source d’optimisation qui soit.

La méthode

  • changez un seul réglage à la fois, et notez la mesure avant et après ;
  • beaucoup de variables se modifient à chaud (SET GLOBAL) pour un essai ; écrivez-les ensuite dans le fichier, sinon elles disparaissent au redémarrage ;
  • celles qui exigent un redémarrage (taille du journal redo, open_files_limit) se planifient ;
  • gardez la configuration sous gestion de version, avec en commentaire la raison de chaque valeur non standard. Dans six mois, ce commentaire vaudra plus que la valeur elle-même.

Vérifications de MariaDB après un changement

systemctl restart mariadb && systemctl is-active mariadb
journalctl -u mariadb -n 30 --no-pager | grep -iE 'warn|error'
mariadb -e "SHOW GLOBAL VARIABLES" > /tmp/vars.after
diff <(sort /tmp/vars.before) <(sort /tmp/vars.after)

Si un exporteur Prometheus surveille la base, comparez sur quelques jours le taux de réussite du cache, les tables temporaires sur disque, les connexions et la latence des requêtes. Un réglage n’est bon que si ces courbes le confirment.

Une vraie vérification, 75 minutes après un redémarrage

Pour montrer ce que donnent ces vérifications sur un vrai serveur, voici le MariaDB 12.3 de mon serveur web le 2 novembre 2026, lu avec le compte de supervision (qui n’a besoin que de lire variables et compteurs). La machine avait redémarré 75 minutes plus tôt, ce qui rend les chiffres plus instructifs, pas moins.

SELECT @@innodb_buffer_pool_size/1024/1024/1024 AS buffer_pool_gb,
       @@innodb_log_file_size/1024/1024        AS redo_mb,
       @@max_connections, @@innodb_flush_log_at_trx_commit, @@sync_binlog;
+----------------+---------+-------------------+---------------------------------+---------------+
| buffer_pool_gb | redo_mb | @@max_connections | @@innodb_flush_log_at_trx_commit| @@sync_binlog |
+----------------+---------+-------------------+---------------------------------+---------------+
|  12.31         | 2048    |               400 |                               1 |             1 |
+----------------+---------+-------------------+---------------------------------+---------------+

SHOW GLOBAL STATUS WHERE Variable_name IN (...);
| Uptime                           | 4487     |
| Innodb_buffer_pool_read_requests | 5163358  |
| Innodb_buffer_pool_reads         | 121600   |
| Innodb_log_waits                 | 0        |
| Max_used_connections             | 61       |
| Threads_created                  | 61       |
| Connections                      | 11846    |
| Created_tmp_tables               | 37637    |
| Created_tmp_disk_tables          | 5223     |

Ma lecture, ligne par ligne :

  • Taux de réussite du buffer pool : 1 − 121 600 / 5 163 358 = 97,6 %. Sur un serveur démarré depuis des semaines, j’attends plus de 99,9 %. Ici, le cache se remplit encore : chaque page lue sur disque depuis le redémarrage compte comme un échec. C’est pour cela que le taux se compare sur plusieurs jours, jamais juste après un redémarrage, et que la première heure qui suit est plus lente.
  • Innodb_log_waits = 0 : aucune transaction n’a dû attendre de la place dans le tampon du journal. Avec un journal de reprise de 2 Go, même l’activité du démarrage ne l’a pas saturé.
  • Max_used_connections = 61 sur 400 autorisées, et Threads_created = 61 pour 11 846 connexions : le cache de threads réutilise les threads au lieu d’en créer un par connexion. Si Threads_created grimpait presque aussi vite que Connections, thread_cache_size serait trop petit.
  • Tables temporaires sur disque : 5 223 sur 37 637, soit 14 %. Ce sont surtout des requêtes WordPress qui trient des colonnes de texte, lesquelles partent sur disque quelle que soit la valeur de tmp_table_size. Au-delà de 25 %, il vaut la peine de chercher les requêtes responsables avant de relever une limite.
  • innodb_flush_log_at_trx_commit = 1 et sync_binlog = 1 : durabilité complète sur le primaire. Le réplica tourne avec 2 et 0 ; les raisons sont dans la série consacrée à MariaDB.

Temps total : deux requêtes, une minute. Lancez-les avant et après chaque changement, et gardez les sorties : c’est ce qui transforme « j’ai l’impression que c’est plus rapide » en mesure.


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

Articles liés

Page 1 of 2

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