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 → (à paraître le 18/11) · English version

Articles liés