Il est habituellement préférable de créer les serveurs primaire et secondaires de façon à ce qu'ils soient aussi similaires que possible, au moins du point de vue du serveur de bases de données. En particulier, les chemins associés avec les tablespaces seront passés d'un nœud à l'autre sans conversion, ce qui implique que les serveurs primaire et secondaires doivent avoir les mêmes chemins de montage pour les tablespaces si cette fonctionnalité est utilisée. Gardez en tête que si CREATE TABLESPACE est exécuté sur le primaire, tout nouveau point de montage nécessaire pour cela doit être créé sur le primaire et tous les secondaires avant que la commande ne soit exécutée. Le matériel n'a pas besoin d'être exactement le même, mais l'expérience monte que maintenir deux systèmes identiques est plus facile que maintenir deux différents sur la durée de l'application et du système. Quoi qu'il en soit, l'architecture hardware doit être la même -- répliquer par exemple d'un serveur 32 bits vers un 64 bits ne fonctionnera pas.

De manière générale, le log shipping entre serveurs exécutant des versions majeures différentes de PostgreSQL est impossible. La politique du PostgreSQL Global Development Group est de ne pas réaliser de changement sur les formats disques lors des mises à jour mineures, il est par conséquent probable que l'exécution de versions mineures différentes sur le primaire et le secondaire fonctionne correctement. Toutefois, il n'y a aucune garantie formelle de cela et il est fortement conseillé de garder le serveur primaire et celui de secondaire au même niveau de version autant que faire se peut. Lors d'une mise à jour vers une nouvelle version mineure, la politique la plus sûre est de mettre à jour les serveurs secondaires d'abord -- une nouvelle version mineure est davantage susceptible de lire les enregistrements WAL d'une ancienne version mineure que l'inverse.

Un serveur entre en mode standby si un fichier standby.signal existe dans le répertoire de données du serveur.

En mode standby, le serveur applique continuellement les WAL reçus du serveur primaire. Le serveur secondaire peut lire les WAL d'une archive WAL (voir restore_command) ou directement du primaire via une connexion TCP (réplication en flux). Le serveur secondaire essaiera aussi de restaurer tout WAL trouvé dans le répertoire pg_wal de l'instance du secondaire. Cela se produit habituellement après un redémarrage de serveur, quand le secondaire rejoue à nouveau les WAL qui ont été reçu du primaire avant le redémarrage, mais vous pouvez aussi copier manuellement des fichiers dans pg_wal à tout moment pour qu'ils soient rejoués.

Au démarrage, le serveur secondaire commence par restaurer tous les WAL disponibles à l'endroit où se trouvent les archives, en appelant la restore_command. Une fois qu'il a épuisé tous les WAL disponibles à cet endroit et que restore_command échoue, il essaie de restaurer tous les WAL disponibles dans le répertoire pg_wal. Si cela échoue, et que la réplication en flux a été activée, le serveur secondaire essaie de se connecter au serveur primaire et de démarrer la réception des WAL depuis le dernier enregistrement valide trouvé dans les archives ou pg_wal. Si cela échoue ou que la réplication en flux n'est pas configurée, ou que la connexion est plus tard déconnectée, le secondaire retourne à l'étape 1 et essaie de restaurer le fichier à partir de l'archive à nouveau. Cette boucle de retentatives de l'archive, pg_wal et par la réplication en flux continue jusqu'à ce que le serveur soit arrêté ou promu. déclenché.

Le mode standby est quitté et le serveur bascule en mode de fonctionnement normal quand pg_ctl promote est exécuté ou que pg_promote() est appelé. Avant de basculer, tout WAL immédiatement disponible dans l'archive ou le pg_wal sera restauré, mais aucune tentative ne sera faite pour se connecter au primaire.

Mettez en place un archivage en continu sur le primaire vers un répertoire d'archivage accessible depuis le secondaire, comme décrit dans Section 25.3. La destination d'archivage devrait être accessible du secondaire même quand le primaire est inaccessible, c'est à dire qu'il devrait se trouver sur le serveur secondaire lui-même ou un autre serveur de confiance, pas sur le serveur primaire.

Si vous voulez utiliser la réplication en flux, mettez en place l'authentification sur le serveur primaire pour autoriser les connexions de réplication à partir du (ou des) serveur(s) secondaire(s) ; c'est-à-dire, créez un rôle et mettez en place une ou des entrées appropriées dans pg_hba.conf avec le champ database positionné à replication. Vérifiez aussi que max_wal_senders est positionné à une valeur suffisamment grande dans le fichier de configuration du serveur primaire. Si des slots de réplication seront utilisés, il faut s'assurer que max_replication_slots est également positionné à une valeur suffisamment grande.

Effectuez une sauvegarde de base comme décrit dans Section 25.3.2 pour initialiser le serveur secondaire.

Pour paramétrer le serveur secondaire, restaurez la sauvegarde de base effectué sur le serveur primaire (voir Section 25.3.5). Créez un fichier standby.signal dans le répertoire de données de l'instance du secondaire. Positionnez restore_command à une simple commande qui recopie les fichiers de l'archive de WAL. Si vous comptez disposer de plusieurs serveurs secondaires pour mettre en œuvre de la haute disponibilité, assurez-vous que recovery_target_timeline est configuré à latest (la valeur par défaut), pour indiquer que le serveur secondaire devra prendre en compte la ligne temporelle définie lors de la bascule à un autre serveur secondaire.

Si vous souhaitez utiliser la réplication en flux, renseignez primary_conninfo avec une chaîne de connexion libpq, contenant le nom d'hôte (ou l'adresse IP) et tout détail supplémentaire nécessaire pour se connecter au serveur primaire. Si le primaire a besoin d'un mot de passe pour l'authentification, le mot de passe doit aussi être spécifié dans primary_conninfo.

Si vous mettez en place le serveur secondaire pour des besoins de haute disponibilité, mettez en place l'archivage de WAL, les connexions et l'authentification à l'identique du serveur primaire, parce que le serveur secondaire fonctionnera comme un serveur primaire après la bascule.

Si vous utilisez une archive WAL, sa taille peut être réduite en utilisant l'option archive_cleanup_command pour supprimer les fichiers qui ne sont plus nécessaires au serveur secondaire. L'outil pg_archivecleanup est conçu spécifiquement pour être utilisé avec archive_cleanup_command dans des configurations typiques de secondaire, voir pg_archivecleanup. Notez toutefois que si vous utilisez l'archive à des fins de sauvegarde, vous avez besoin de garder les fichiers nécessaires pour restaurer à partir de votre dernière sauvegarde de base, même si ces fichiers ne sont plus nécessaires pour le serveur secondaire.

Voici un simple exemple :

primary_conninfo = 'host=192.168.1.50 port=5432 user=foo password=foopass options=''-c wal_sender_timeout=5000'''
restore_command = 'cp /path/to/archive/%f %p'
archive_cleanup_command = 'pg_archivecleanup /path/to/archive %r'
    

Vous pouvez avoir n'importe quel nombre de serveurs secondaires, mais si vous utilisez la réplication en flux, assurez vous d'avoir positionné max_wal_senders suffisamment haut sur le primaire pour leur permettre de se connecter simultanément.

La réplication en flux permet à un serveur secondaire de rester plus à jour qu'il n'est possible avec l'envoi de journaux par fichiers. Le standby se connecte au primaire, qui envoie au standby les enregistrements de WAL dès qu'ils sont générés, sans attendre qu'un fichier de WAL soit rempli.

La réplication en flux est asynchrone par défaut (voir Section 26.2.8), auquel cas il y a un petit délai entre la validation d'une transaction sur le primaire et le moment où les changements sont visibles sur le standby. Le délai est toutefois beaucoup plus petit qu'avec l'envoi de fichiers, habituellement en dessous d'une seconde en partant de l'hypothèse que le standby est suffisamment puissant pour supporter la charge. Avec la réplication en flux, archive_timeout n'est pas nécessaire pour réduire la fenêtre de perte de données.

Si vous utilisez la réplication en flux sans archivage en continu des fichiers, le serveur primaire pourrait recycler de vieux journaux de transactions avant que le serveur en standby ne les ait reçus. Si cela arrive, le serveur en standby devra être recréé à partir d'une nouvelle sauvegarde de l'instance. Vous pouvez éviter cela en positionnant wal_keep_size à une valeur suffisamment grande pour s'assurer que les journaux de transactions ne sont pas recyclés trop tôt, ou en configurant un slot de réplication pour le serveur en standby. Si un archivage des journaux de transactions est en place, et que les fichiers archivés sont disponibles depuis le serveur en standby, cette solution n'est pas nécessaire, puisque le serveur en standby peut toujours utiliser les fichiers archivés pour rattraper son retard, sous réserve que suffisamment de fichiers soient conservés.

Pour utiliser la réplication en flux, mettez en place un serveur secondaire en mode fichier comme décrit dans Section 26.2. L'étape qui transforme un secondaire en mode fichier en secondaire dans une réplication en flux est de faire pointer primary_conninfo vers le serveur primaire. Positionnez listen_addresses et les options d'authentification (voir pg_hba.conf) sur le primaire pour que le serveur secondaire puisse se connecter à la pseudo-base replication sur le serveur primaire (voir Section 26.2.5.1).

Sur les systèmes qui supportent l'option de keepalive sur les sockets, positionner tcp_keepalives_idle, tcp_keepalives_interval et tcp_keepalives_count aide le primaire à reconnaître rapidement une connexion interrompue.

Positionnez le nombre maximum de connexions concurrentes à partir des serveurs secondaires (voir max_wal_senders pour les détails).

Quand le secondaire est démarré et que primary_conninfo est positionné correctement, le secondaire se connectera au primaire après avoir rejoué tous les fichiers WAL disponibles dans l'archive. Si la connexion est établie avec succès, vous verrez un processus walreceiver sur le secondaire, et un processus walsender correspondant sur le primaire.

# Autoriser l'utilisateur "foo" de l'hôte 192.168.1.100 à se connecter au primaire
# en tant que secondaire si le mot de passe de l'utilisateur est correctement fourni
#
# TYPE  DATABASE        USER            ADDRESS                 METHOD
host    replication     foo             192.168.1.100/32        md5
     

# Le secondaire se connecte au primaire qui s'exécute sur l'hôte 192.168.1.50
# et port 5432 en tant qu'utilisateur "foo" dont le mot de passe est "foopass"
primary_conninfo = 'host=192.168.1.50 port=5432 user=foo password=foopass'
     

Les slots de réplication fournissent une manière automatisée de s'assurer que le primaire ne supprime pas les journaux de transactions avant qu'ils n'aient été reçus par tous les serveurs secondaires, et que le serveur primaire ne supprime pas des lignes qui pourraient causer un conflit de restauration même si le serveur secondaire est déconnecté.

Au lieu d'utiliser des slots de réplication, il est possible d'empêcher la suppression des anciens journaux de transactions en utilisant wal_keep_size, ou en les stockant dans un répertoire d'archive en utilisant archive_command ou archive_library. Un inconvénient de ces méthodes est qu'elles ont souvent pour résultat le stockage de plus de journaux de transactions que nécessaire, alors que les slots de réplication ne conservent que le nombre nécessaire de journaux de transactions.

De façon similaire, hot_standby tout seul, sans slot de réplication, fournir une protection contre la suppression par vacuum des lignes pertinentes, mais ne fournit aucune protection lorsque le secondaire n'est pas connecté.

postgres=# SELECT * FROM pg_create_physical_replication_slot('node_a_slot');
  slot_name  | lsn
-------------+-----
 node_a_slot |

postgres=# SELECT slot_name, slot_type, active FROM pg_replication_slots;
  slot_name  | slot_type | active
-------------+-----------+--------
 node_a_slot | physical  | f
     

primary_conninfo = 'host=192.168.1.50 port=5432 user=foo password=foopass'
primary_slot_name = 'node_a_slot'
     

La fonctionnalité de réplication en cascade permet à un serveur secondaire d'accepter les connexions de réplication et d'envoyer un flux d'enregistrements de journaux de transactions à d'autres secondaires, agissant ainsi comme un relais. C'est généralement utilisé pour réduire le nombre de connexions directes au primaire et minimiser ainsi l'utilisation de bande passante entre sites distants.

Un serveur secondaire agissant à la fois comme un receveur et comme un émetteur est connu sous le nom de secondaire en cascade (cascading standby). Les secondaires qui sont plus proches du serveur primaire sont connus sous le nom de serveurs upstream alors que les serveurs secondaires en bout de chaîne sont des serveurs downstream. La réplication en cascade ne pose pas de limites sur le nombre ou l'arrangement des serveurs downstream. Chaque secondaire se connecte à un seul serveur upstream, qui finit par arriver à un seul serveur primaire.

Un secondaire en cascade envoie non seulement les enregistrements reçus de journaux de transactions mais aussi ceux restaurés des archives. Donc, même si la connexion de réplication d'une connexion upstream est rompue, la réplication en flux continue vers le serveur downstream tant que de nouveaux enregistrements de journaux de transactions sont disponibles.

La réplication en cascade est actuellement asynchrone. La réplication synchrone (voir Section 26.2.8) n'a aucun effet sur la réplication en cascade.

Les messages en retour des serveurs Hot Standby se propagent vers les serveurs upstream, quelle que soit la configuration de la réplication en cascade.

Si un serveur secondaire upstream est promu pour devenir le nouveau serveur primaire, les serveurs downstream continueront à recevoir le flux de réplication du nouveau primaire si le paramètre recovery_target_timeline est configuré à 'latest' (valeur par défaut).

Pour utiliser la réplication en cascade, configurez le secondaire en cascade de façon à ce qu'il accepte les connexions de réplication (configurez max_wal_senders et hot_standby, ainsi que l'authentification). Vous aurez aussi besoin de configurer la variable primary_conninfo dans le secondaire downstream pour qu'elle pointe vers le secondaire en cascade.

La réplication en flux mise en œuvre par PostgreSQL est asynchrone par défaut. Si le serveur primaire est hors-service, les transactions produites alors peuvent ne pas avoir été répliquées sur le serveur secondaire, impliquant une perte de données. La quantité de données perdues est proportionnelle au délai de réplication au moment de la bascule.

La réplication synchrone permet de confirmer que tous les changements effectués par une transaction ont bien été transférées vers un ou plusieurs serveurs secondaires synchrones. Cette propriété étend le niveau de robustesse standard offert par un commit. En science informatique, ce niveau de protection est appelé réplication à deux états (2-safe replication) et group-1-safe (group-safe et 1-safe) quand synchronous_commit est configuré à la valeur remote_write.

Lorsque la réplication synchrone est utilisée, chaque validation portant sur une écriture va nécessiter d'attendre la confirmation de l'écriture de cette validation dans les journaux de transaction sur les disques du serveur primaire et des serveurs secondaires. Le seul moyen possible pour que des données soient perdues est que les serveur primaire et secondaire soient hors service au même moment. Ce mécanisme permet d'assurer un niveau plus élevé de robustesse, en admettant que l'administrateur système ait pris garde à l'emplacement et à la gestion de ces deux serveurs. Attendre après la confirmation de l'écriture augmente la confiance que l'utilisateur pourra avoir sur la conservation des modifications dans le cas où un serveur serait hors service mais il augmente aussi en conséquence le temps de réponse de chaque requête. Le temps minimum d'attente est celui de l'aller-retour entre les serveurs primaire et secondaire.

Les transactions où seule une lecture est effectuée ou qui consistent à annuler une transaction ne nécessitent pas d'attendre les serveurs secondaires. Les validations concernant les transactions imbriquées ne nécessitent pas non plus d'attendre la réponse des serveurs secondaires, cela n'affecte en fait que les validations principales. De longues opérations comme le chargement de données ou la création d'index n'attendent pas le commit final pour synchroniser les données. Toutes les actions de validation en deux étapes nécessitent d'attendre la validation du secondaire, incluant autant l'opération de préparation que l'opération de validation.

Un secondaire synchrone peut être un secondaire de réplication physique ou un abonné d'une réplication logique. Il peut aussi être tout autre consommateur de flux de réplication physique ou logique qui sait comment gérer les messages de retour appropriés. En plus des systèmes intégrés de réplication physique et logique, cela inclut le support des outils tels que pg_receivewal et pg_recvlogical ainsi que les systèmes de réplication et outils personnalisés tiers.

synchronous_standby_names = 'FIRST 2 (s1, s2, s3)'
     

 synchronous_standby_names = 'ANY 2 (s1, s2, s3)'
     

Lorsque l'archivage continu est utilisé sur un secondaire, il existe deux scénarios possibles : soit les archives sont partagées entre le serveur primaire et le serveur secondaire, soit le secondaire peut avoir ses propres archives. Si le serveur possède ses propres archives, en définissant le paramètre archive_mode à always, le secondaire exécutera la commande d'archivage pour chaque segment de WAL qu'il aura reçu, peu importe qu'il utilise la réplication par les archives ou la réplication en flux. La gestion par archivage partagé peut être faite de la même manière, mais archive_command ou archive_library doit d'abord tester si le segment de WAL existe, et si le fichier existant contient les mêmes informations. Cela demande plus de précaution lors de la définition de la commande, car elle doit vérifier qu'elle n'écrase pas un fichier existant avec un contenu différent, et doit renvoyer un succès si le même fichier est archivé deux fois. Tout ceci devant être en plus effectué sans concurrence si deux serveurs essaient d'archiver le même fichier au même moment.

Si archive_mode est défini à on, l'archivage n'est pas actif pendant les modes recovery et standby. Si le serveur secondaire est promu, il commencera à réaliser l'archivage après sa promotion, et il archivera uniquement les fichiers (WAL et historique) qu'il a lui même produit. Pour être sûr d'obtenir un jeu complet d'archives, vous devez vous assurer que tous les fichiers WAL ont été archivés avant qu'ils atteignent le secondaire. C'est implicitement toujours le cas avec un log shipping s'appuyant sur les archives, car le secondaire ne récupère que des informations provenant de ces mêmes fichiers archivés. Ce n'est pas le cas dans le cadre de la réplication en flux. Lorsqu'un serveur n'est pas en mode recovery, il n'y a aucune différence entre les modes on et always.