Aller au contenu

Restaurer PostgreSQL à un instant donné

Restaurer à un instant donné, c’est reconstruire la base telle qu’elle était à une heure précise, à partir d’une sauvegarde de base et des journaux de transactions archivés depuis. CloudNativePG le fait en créant un nouveau cluster : l’original n’est jamais écrasé.

  • Une suppression ou une modification de données par erreur, dont on connaît l’heure approximative.
  • Une corruption logique introduite par une migration.

Elle ne répond pas à la perte du serveur. Dans ce cas, il faut d’abord recréer le nœud, puis appliquer cette procédure.

À vérifier Comment
Accès kubectl tsh kube ls puis kubectl get nodes
Plugin CNPG kubectl cnpg version
Sauvegardes présentes kubectl get backup -n <namespace>
Archivage des WAL sain kubectl cnpg status <cluster> -n <namespace>, section Continuous Backup

Valeurs à substituer dans toute la procédure :

  • <namespace> — le namespace du cluster
  • <cluster> — le nom du Cluster CloudNativePG d’origine
  • <cible> — le nom du cluster restauré, par exemple <cluster>-pitr
  • <instant> — l’horodatage cible, au format 2026-09-21 14:30:00.000000+00:00

Choisir l’instant cible avec une marge. Viser quelques minutes avant l’incident, pas l’heure exacte. Une restauration trop tardive réintroduit le problème, et il faut tout recommencer.

Noter l’heure de départ. Elle sert à mesurer la durée réelle, à reporter en bas de page.

Ne rien supprimer. La procédure crée un cluster à côté. L’original reste en place et continue de servir jusqu’à la bascule.

Étape 1 — Vérifier que la fenêtre de restauration couvre la cible

Section intitulée « Étape 1 — Vérifier que la fenêtre de restauration couvre la cible »
Fenêtre de terminal
kubectl cnpg status <cluster> -n <namespace>

Critère de vérification. La section Continuous Backup indique un archivage OK et un premier point de restauration antérieur à <instant>. Si <instant> est plus ancien que la plus vieille sauvegarde, la restauration est impossible — inutile d’aller plus loin.

Le cluster cible se déclare dans gitops, comme le reste. Pas de kubectl apply à la main : la restauration doit laisser une trace dans Git au même titre qu’un déploiement.

apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
name: <cible>
namespace: <namespace>
spec:
instances: 1
bootstrap:
recovery:
source: <cluster>
recoveryTarget:
targetTime: "<instant>"
externalClusters:
- name: <cluster>
barmanObjectStore:
# Mêmes réglages que l'archivage du cluster d'origine,
# en lecture seule.
destinationPath: "<chemin-du-stockage-objet>"
s3Credentials:
accessKeyId:
name: <secret-stockage>
key: ACCESS_KEY_ID
secretAccessKey:
name: <secret-stockage>
key: ACCESS_SECRET_KEY

Commiter sur gitops, puis laisser ArgoCD synchroniser.

Critère de vérification. kubectl get cluster -n <namespace> montre <cible> en phase Setting up primary, puis Cluster in healthy state.

Fenêtre de terminal
kubectl cnpg status <cible> -n <namespace>
kubectl logs -n <namespace> -l cnpg.io/cluster=<cible> -c postgres -f

C’est l’étape longue : PostgreSQL télécharge la sauvegarde de base puis rejoue les journaux jusqu’à <instant>. La durée dépend du volume de WAL à rejouer, pas de la taille de la base.

Critère de vérification. Les journaux affichent recovery stopping before commit of transaction ... puis database system is ready to accept connections.

Étape 4 — Contrôler les données avant de basculer

Section intitulée « Étape 4 — Contrôler les données avant de basculer »
Fenêtre de terminal
kubectl cnpg psql <cible> -n <namespace>

Trois contrôles, dans cet ordre :

-- 1. L'instant réellement atteint
SELECT pg_last_committed_xact();
-- 2. La donnée perdue est-elle revenue ?
SELECT count(*) FROM <table_concernée> WHERE <condition_de_l_incident>;
-- 3. La donnée postérieure à l'incident a-t-elle disparu, comme attendu ?
SELECT max(created_at) FROM <table_concernée>;

Critère de vérification. Le contrôle 2 rend le résultat attendu, et le contrôle 3 confirme que rien de postérieur à <instant> n’a été conservé. Si ce n’est pas le cas, ne pas basculer : supprimer <cible>, reprendre à l’étape 2 avec un <instant> plus ancien.

Le cluster restauré est indépendant. Pour que les applications l’utilisent, il faut modifier le Service ou le secret de connexion qu’elles consomment, dans gitops.

Fenêtre de terminal
kubectl get svc -n <namespace> | grep <cluster>

Basculer, commiter, laisser ArgoCD synchroniser.

Critère de vérification. Les pods applicatifs redémarrent et se connectent. Les alertes d’erreur de connexion retombent dans les minutes qui suivent.

  • Garder l’ancien cluster au moins 24 heures. Il ne coûte que du disque, et il est le seul recours si la restauration se révèle mauvaise.
  • Déclencher une sauvegarde de base immédiate sur le cluster restauré : il repart d’une timeline neuve.
  • Remplir le tableau ci-dessous, puis supprimer l’encadré d’avertissement en haut de page.

À compléter lors de la première exécution réelle. Ne pas estimer.

Étape Durée mesurée Date de la mesure
Étape 1 — vérification — —
Étape 2 — déclaration et synchronisation ArgoCD — —
Étape 3 — restauration et rejeu des WAL — —
Étape 4 — contrôles — —
Étape 5 — bascule — —
Total, incident à service rétabli — —

Volume de la base au moment de la mesure : — Fenêtre de WAL rejouée : —