<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>pgBackRest - Quelques pensées</title>
	<atom:link href="https://blog.neurozone.fr/tag/pgbackrest/feed/" rel="self" type="application/rss+xml" />
	<link>https://blog.neurozone.fr/tag/pgbackrest/</link>
	<description>Terres dévastées</description>
	<lastBuildDate>Mon, 02 Nov 2026 17:00:23 +0000</lastBuildDate>
	<language>fr-FR</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	

<image>
	<url>https://i0.wp.com/blog.neurozone.fr/wp-content/uploads/2024/03/cropped-2.png?fit=32%2C32&#038;ssl=1</url>
	<title>pgBackRest - Quelques pensées</title>
	<link>https://blog.neurozone.fr/tag/pgbackrest/</link>
	<width>32</width>
	<height>32</height>
</image> 
<site xmlns="com-wordpress:feed-additions:1">154219366</site>	<item>
		<title>Pas à pas : sauvegarder PostgreSQL avec pgBackRest et restaurer à la seconde</title>
		<link>https://blog.neurozone.fr/2026/11/16/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaurer-a-la-seconde/</link>
					<comments>https://blog.neurozone.fr/2026/11/16/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaurer-a-la-seconde/#respond</comments>
		
		<dc:creator><![CDATA[Hécate Raven]]></dc:creator>
		<pubDate>Mon, 16 Nov 2026 09:00:00 +0000</pubDate>
				<category><![CDATA[Informatique]]></category>
		<category><![CDATA[Français]]></category>
		<category><![CDATA[pas à pas]]></category>
		<category><![CDATA[pgBackRest]]></category>
		<category><![CDATA[PostgreSQL]]></category>
		<category><![CDATA[Rocky Linux]]></category>
		<category><![CDATA[sauvegarde]]></category>
		<guid isPermaLink="false">https://blog.neurozone.fr/?p=2066</guid>

					<description><![CDATA[<p>Sauvegarder PostgreSQL 18 avec pgBackRest : configuration, archivage du WAL, stanza, planification, dépôt distant et restauration juste avant l'erreur.</p>
<p>L’article <a href="https://blog.neurozone.fr/2026/11/16/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaurer-a-la-seconde/">Pas à pas : sauvegarder PostgreSQL avec pgBackRest et restaurer à la seconde</a> est apparu en premier sur <a href="https://blog.neurozone.fr">Quelques pensées</a>.</p>
]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Un <code>pg_dump</code> nocturne est mieux que rien, mais il a deux défauts sérieux : il fait perdre jusqu&rsquo;à vingt-quatre heures de données, et il ne sait pas revenir « juste avant le <code>DELETE</code> sans <code>WHERE</code> 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.</p>



<p class="wp-block-paragraph">pgBackRest résout les deux problèmes en combinant des copies physiques des fichiers de l&rsquo;instance et l&rsquo;archivage continu du journal de transactions (le WAL). Avec les deux, on peut restaurer l&rsquo;instance à n&rsquo;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.</p>



<figure class="wp-block-image size-full"><a href="https://i0.wp.com/blog.neurozone.fr/wp-content/uploads/2026/11/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaure_schema_fr.png?ssl=1"><img data-recalc-dims="1" fetchpriority="high" decoding="async" width="629" height="322" src="https://i0.wp.com/blog.neurozone.fr/wp-content/uploads/2026/11/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaure_schema_fr.png?resize=629%2C322&#038;ssl=1" alt="Schéma de pgBackRest : PostgreSQL, dépôt, copie hors serveur et les quatre étapes d'une restauration à la seconde" class="wp-image-4579" srcset="https://i0.wp.com/blog.neurozone.fr/wp-content/uploads/2026/11/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaure_schema_fr.png?w=1720&amp;ssl=1 1720w, https://i0.wp.com/blog.neurozone.fr/wp-content/uploads/2026/11/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaure_schema_fr.png?resize=300%2C153&amp;ssl=1 300w, https://i0.wp.com/blog.neurozone.fr/wp-content/uploads/2026/11/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaure_schema_fr.png?resize=1024%2C524&amp;ssl=1 1024w, https://i0.wp.com/blog.neurozone.fr/wp-content/uploads/2026/11/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaure_schema_fr.png?resize=768%2C393&amp;ssl=1 768w, https://i0.wp.com/blog.neurozone.fr/wp-content/uploads/2026/11/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaure_schema_fr.png?resize=1536%2C786&amp;ssl=1 1536w, https://i0.wp.com/blog.neurozone.fr/wp-content/uploads/2026/11/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaure_schema_fr.png?resize=900%2C460&amp;ssl=1 900w, https://i0.wp.com/blog.neurozone.fr/wp-content/uploads/2026/11/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaure_schema_fr.png?resize=1280%2C655&amp;ssl=1 1280w" sizes="(max-width: 629px) 100vw, 629px" /></a><figcaption class="wp-element-caption">Sauvegardes physiques et archivage du WAL, pour restaurer à la seconde près.</figcaption></figure>



<h2 class="wp-block-heading">Le principe en deux phrases</h2>



<p class="wp-block-paragraph">PostgreSQL écrit chaque modification dans le WAL avant de l&rsquo;appliquer aux fichiers de données. Si l&rsquo;on dispose d&rsquo;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&rsquo;arrêter où l&rsquo;on veut.</p>



<figure class="wp-block-table"><table><thead><tr><th>Type</th><th>Contenu</th><th>Pour restaurer, il faut</th></tr></thead><tbody><tr><td>complète (full)</td><td>tous les fichiers de l&rsquo;instance</td><td>cette sauvegarde + le WAL</td></tr><tr><td>différentielle (diff)</td><td>les fichiers modifiés depuis la dernière complète</td><td>la complète + cette différentielle + le WAL</td></tr><tr><td>incrémentale (incr)</td><td>les fichiers modifiés depuis la dernière sauvegarde, quelle qu&rsquo;elle soit</td><td>la complète + toute la chaîne + le WAL</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">Les incrémentales sont plus petites mais fragilisent la chaîne : la perte d&rsquo;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.</p>



<h2 class="wp-block-heading">Étape 1 : installer</h2>



<pre class="EnlighterJSRAW" data-enlighter-language="shell">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</pre>



<p class="wp-block-paragraph">pgBackRest tourne sous l&rsquo;utilisateur <code>postgres</code> : 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 <code>postgresql_t</code>) a le droit d&rsquo;y écrire lors de l&rsquo;archivage : un refus SELinux bloque l&rsquo;archivage sans autre symptôme qu&rsquo;un <code>pg_wal</code> qui grossit.</p>



<h2 class="wp-block-heading">Étape 2 : la configuration de pgBackRest</h2>



<pre class="EnlighterJSRAW" data-enlighter-language="ini"># /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</pre>



<h3 class="wp-block-heading">La section [global]</h3>



<ul class="wp-block-list"><li><strong>repo1-path</strong> : 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&rsquo;affaire ;</li><li><strong>repo1-retention-full=2</strong> : 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&rsquo;une à deux semaines ;</li><li><strong>repo1-retention-diff=14</strong> : le nombre de différentielles conservées ; il doit couvrir au moins l&rsquo;intervalle entre deux complètes ;</li><li><strong>compress-type=lz4</strong> : lz4 compresse un peu moins que zstd mais beaucoup plus vite, ce qui raccourcit à la fois la sauvegarde et la restauration ;</li><li><strong>log-level-console / log-level-file</strong> : peu de bruit à l&rsquo;écran, le détail dans <code>/var/log/pgbackrest</code> ;</li><li><strong>start-fast=y</strong> : déclenche un checkpoint immédiat au début de la sauvegarde au lieu d&rsquo;attendre le prochain, qui peut être dans plusieurs minutes ;</li><li><strong>delta=y</strong> : à 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&rsquo;est la différence entre une heure et quelques minutes.</li></ul>



<h3 class="wp-block-heading">La section [main]</h3>



<p class="wp-block-paragraph">C&rsquo;est la <strong>stanza</strong> : une instance PostgreSQL à sauvegarder, désignée par un nom libre. <code>pg1-path</code> est son répertoire de données, <code>pg1-port</code> son port. Plusieurs instances sur la même machine font plusieurs stanzas.</p>



<h2 class="wp-block-heading">Étape 3 : brancher l&rsquo;archivage du WAL</h2>



<pre class="EnlighterJSRAW" data-enlighter-language="ini"># postgresql.conf
wal_level        = replica
archive_mode     = on
archive_command  = &#x27;pgbackrest --stanza=main archive-push %p&#x27;
archive_timeout  = 300
max_wal_senders  = 3</pre>



<ul class="wp-block-list"><li><strong>wal_level = replica</strong> : le WAL contient assez d&rsquo;informations pour reconstruire l&rsquo;instance (c&rsquo;est la valeur par défaut des versions récentes) ;</li><li><strong>archive_mode = on</strong> : active l&rsquo;archivage. Ce réglage demande un redémarrage ;</li><li><strong>archive_command</strong> : la commande lancée pour chaque segment de WAL terminé (16 Mo). <code>%p</code> est le chemin du segment ;</li><li><strong>archive_timeout = 300</strong> : force un changement de segment toutes les cinq minutes même si le segment n&rsquo;est pas plein. Sur une base peu active, sans cela, les dernières transactions peuvent rester des heures dans un segment non archivé : c&rsquo;est autant de données perdues si le serveur disparaît.</li></ul>



<p class="wp-block-paragraph">Si l&rsquo;archivage échoue, PostgreSQL ne perd rien : il garde le segment et réessaie. Mais <code>pg_wal/</code> grossit alors jusqu&rsquo;à remplir le disque, et l&rsquo;instance s&rsquo;arrête. <strong>C&rsquo;est la panne à surveiller en premier</strong>, par exemple avec la vue <code>pg_stat_archiver</code> :</p>



<pre class="EnlighterJSRAW" data-enlighter-language="sql">SELECT archived_count, last_archived_time, failed_count, last_failed_time, last_failed_wal
FROM pg_stat_archiver;</pre>



<p class="wp-block-paragraph">Une alerte sur <code>last_archived_time</code> trop ancien (plus de dix minutes avec <code>archive_timeout = 300</code>) ou sur <code>failed_count</code> qui augmente prévient bien avant le disque plein.</p>



<h2 class="wp-block-heading">Étape 4 : créer la stanza et vérifier</h2>



<pre class="EnlighterJSRAW" data-enlighter-language="shell">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</pre>



<p class="wp-block-paragraph"><code>check</code> force un changement de segment et attend de le voir arriver dans le dépôt : c&rsquo;est le test de bout en bout de l&rsquo;archivage. <code>info</code> affiche les sauvegardes, leur taille et l&rsquo;intervalle de WAL disponible :</p>



<pre class="EnlighterJSRAW" data-enlighter-language="shell">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</pre>


<!-- nz-enrich:pgbackrest-real -->


<h3 class="wp-block-heading">Un vrai dépôt, après deux mois</h3>



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



<pre class="EnlighterJSRAW" data-enlighter-language="shell">status ok | wal 000000010000010C00000079 -&gt; 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</pre>



<ul class="wp-block-list"><li><strong>6,6 Go de base, 455 Mo dans le dépôt</strong> pour une sauvegarde complète : la compression divise la taille par quinze environ ici ; les fichiers de données PostgreSQL, pleins d&rsquo;en-têtes de pages et de pages en partie vides, se compressent très bien.</li><li><strong>Des différentielles de 32 à 39 Mo</strong>, 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&rsquo;une complète, jamais d&rsquo;une autre différentielle : en perdre une ne coûte rien d&rsquo;autre.</li><li><strong>L&rsquo;étiquette raconte la filiation</strong> : <code>20261101-010006F_20261102-020003D</code> est une différentielle (D) du 2 novembre, fondée sur la complète (F) du 1er novembre.</li><li><strong>La plage de WAL</strong> remonte jusqu&rsquo;à la plus ancienne sauvegarde conservée : n&rsquo;importe quel instant entre le 25 octobre et maintenant peut être restauré, à la seconde.</li><li><strong>check en une demi-seconde</strong>, sans rien afficher, code de retour 0 : la commande d&rsquo;archivage fonctionne et que le dépôt répond. À mettre dans la supervision, pas seulement dans les notes d&rsquo;installation.</li></ul>



<h2 class="wp-block-heading">Étape 5 : planifier</h2>



<pre class="EnlighterJSRAW" data-enlighter-language="ini"># /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</pre>



<p class="wp-block-paragraph"><code>Persistent=true</code> rattrape une sauvegarde manquée si le serveur était éteint à l&rsquo;heure prévue. Ajoutez une notification en cas d&rsquo;échec (<code>OnFailure=</code> 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.</p>



<h2 class="wp-block-heading">Étape 6 : sortir le dépôt du serveur</h2>



<p class="wp-block-paragraph">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 <code>rsync</code> vers une autre machine, ou un second dépôt pgBackRest (<code>repo2-…</code>) 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.</p>



<h2 class="wp-block-heading">Étape 7 : restaurer juste avant l&rsquo;erreur</h2>



<p class="wp-block-paragraph">Scénario : à 15 h 00, quelqu&rsquo;un s&rsquo;aperçoit qu&rsquo;une requête lancée à 14 h 59 et quelques secondes a vidé une table. On veut revenir à 14 h 59 pile.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="shell">systemctl stop postgresql-18
sudo -u postgres pgbackrest --stanza=main --delta \
    --type=time &quot;--target=2026-11-12 14:59:00+01&quot; \
    --target-action=pause restore
systemctl start postgresql-18
sudo -u postgres psql -c &quot;SELECT pg_is_in_recovery(), now()&quot;
# vérifier les données, puis :
sudo -u postgres psql -c &quot;SELECT pg_wal_replay_resume()&quot;</pre>



<ul class="wp-block-list"><li><strong>&#8211;type=time</strong> et <strong>&#8211;target</strong> : la cible de restauration. Donnez <strong>toujours le fuseau horaire</strong> : sans lui, l&rsquo;heure est interprétée dans le fuseau de la session, et un décalage d&rsquo;une ou deux heures fait soit rejouer l&rsquo;erreur, soit perdre le travail de la matinée ;</li><li><strong>&#8211;target-action=pause</strong> : PostgreSQL s&rsquo;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&rsquo;instance avec <code>pg_wal_replay_resume()</code>. <code>promote</code> l&rsquo;ouvre directement, sans cette étape de contrôle ;</li><li><strong>&#8211;delta</strong> : ne recopie que les fichiers modifiés, la restauration est bien plus rapide ;</li><li>pgBackRest choisit seul la sauvegarde de départ (la plus récente antérieure à la cible) ; PostgreSQL rejoue ensuite le WAL jusqu&rsquo;à la cible, puis démarre une nouvelle <em>timeline</em> : le WAL produit après l&rsquo;erreur reste dans le dépôt, mais il ne sera plus jamais rejoué sur cette nouvelle branche.</li></ul>



<p class="wp-block-paragraph">Autres cibles possibles : <code>--type=xid</code> (un numéro de transaction), <code>--type=lsn</code> (une position précise dans le WAL), <code>--type=name</code> (un point nommé créé avant une opération risquée avec <code>SELECT pg_create_restore_point('avant_migration')</code>). Prenez l&rsquo;habitude de créer un point nommé avant chaque migration de schéma : la restauration devient triviale.</p>



<h2 class="wp-block-heading">Récupérer une seule base, ou une seule table</h2>



<p class="wp-block-paragraph">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 (<code>--pg1-path=/srv/restore</code> et <code>port = 5499</code> dans son <code>postgresql.conf</code>), à l&rsquo;instant voulu. Extrayez ensuite la base ou la table avec <code>pg_dump -t</code> et réimportez-la en production. C&rsquo;est plus long, mais la production n&rsquo;est jamais arrêtée.</p>



<h2 class="wp-block-heading">Les pannes fréquentes</h2>



<ul class="wp-block-list"><li><strong>« archive-push » en échec</strong> : droits sur le dépôt, disque plein, ou refus SELinux. <code>pg_stat_archiver</code> et <code>/var/log/pgbackrest/main-archive-push-async.log</code> le disent ;</li><li><strong>« WAL segment … not found » à la restauration</strong> : un trou dans l&rsquo;archive, souvent parce que l&rsquo;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 ;</li><li><strong>restauration qui ne s&rsquo;arrête pas à la bonne heure</strong> : le fuseau horaire, encore. Comparez avec <code>SHOW timezone</code> ;</li><li><strong>« stanza-upgrade » après une mise à jour majeure de PostgreSQL</strong> : pgBackRest refuse de continuer tant qu&rsquo;on ne lui a pas indiqué la nouvelle version. Lancez <code>stanza-upgrade</code>, puis immédiatement une sauvegarde complète.</li></ul>



<p class="wp-block-paragraph">Et surtout : testez la restauration régulièrement, automatiquement si possible. C&rsquo;est l&rsquo;objet du prochain tutoriel de la série. Une sauvegarde qui n&rsquo;a jamais été restaurée n&rsquo;est qu&rsquo;une hypothèse.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<p class="wp-block-paragraph"><em>Ce billet fait partie d&rsquo;une série de tutoriels d&rsquo;administration système (tag « pas à pas »).</em><br>Série « Pas à pas », tutoriel 12/77. · <a href="https://blog.neurozone.fr/?p=2065">← Tutoriel précédent</a> · <span class="link-upcoming">Tutoriel suivant → (à paraître le 18/11)</span> · <a href="https://hecate.neurozone.fr/?p=621">English version</a></p>



<h2 class="wp-block-heading">Articles liés</h2>



<ul class="wp-block-list"><li><a href="https://blog.neurozone.fr/?p=1788">Les fichiers de PostgreSQL, de l&rsquo;intérieur</a></li><li><a href="https://blog.neurozone.fr/?p=2044">Les réglages MariaDB qui comptent vraiment</a></li><li><a href="https://blog.neurozone.fr/?p=1787">Les fichiers d&rsquo;InnoDB, de MySQL à MariaDB</a></li></ul>
<p>L’article <a href="https://blog.neurozone.fr/2026/11/16/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaurer-a-la-seconde/">Pas à pas : sauvegarder PostgreSQL avec pgBackRest et restaurer à la seconde</a> est apparu en premier sur <a href="https://blog.neurozone.fr">Quelques pensées</a>.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://blog.neurozone.fr/2026/11/16/pas-a-pas-sauvegarder-postgresql-avec-pgbackrest-et-restaurer-a-la-seconde/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">2066</post-id>	</item>
	</channel>
</rss>
