Réplication logique pour Amazon RDS for PostgreSQL - Amazon Relational Database Service
Compréhension de la réplication logique et du décodage logiqueUtilisation des emplacements de réplication logiqueRéplication des données au niveau des tables à l'aide de la réplication logique

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Réplication logique pour Amazon RDS for PostgreSQL

Dès la version 10.4, RDS for PostgreSQL prend en charge la syntaxe SQL de publication et d'abonnement qui a été introduite dans PostgreSQL 10. Pour en savoir plus, veuillez consulter Réplication logique dans la documentation PostgreSQL.

Note

Outre la fonctionnalité de réplication logique native de PostgreSQL introduite dans PostgreSQL 10, RDS for PostgreSQL prend également en charge l'extension pglogical. Pour de plus amples informations, veuillez consulter Utilisation de pglogical pour synchroniser les données entre les instances.

Ci-dessous, vous trouverez des informations sur la configuration de la réplication logique pour une instance de base de données RDS for PostgreSQL.

Compréhension de la réplication logique et du décodage logique

RDS for PostgreSQL prend en charge le streaming des modifications WAL (write-ahead log) à l'aide d'emplacements de réplication logique PostgreSQL. Il prend également en charge l'utilisation du décodage logique. Vous pouvez configurer des emplacements logiques de réplication sur votre instance et diffuser les modifications de base de données à travers ces emplacements pour un client comme pg_recvlogical. Les emplacements logiques de réplication sont créés au niveau de la base de données et prennent en charge les connexions de réplication avec une base de données unique.

Les clients les plus courants pour la réplication logique PostgreSQL AWS Database Migration Service sont les hôtes gérés de manière personnalisée sur une instance Amazon. EC2 L'emplacement de réplication logique ne contient aucune information sur le récepteur du flux. De plus, il n'est pas nécessaire que la cible soit une base de données de réplica. Si vous configurez un emplacement de réplication logique et que vous ne lisez pas à partir de l'emplacement, les données peuvent être écrites dans le stockage de votre instance de base de données et le remplir rapidement.

La réplication logique et le décodage logique PostgreSQL sur Amazon RDS sont activés avec un paramètre, un type de connexion de réplication et un rôle de sécurité. Le client pour le décodage logique peut être n'importe quel client capable d'établir une connexion de réplication avec une base de données sur une instance de base de données PostgreSQL.

Pour activer le décodage logique pour une instance de base de données RDS for PostgreSQL

  1. Assurez-vous que le compte utilisateur que vous utilisez possède les rôles suivants :

    • Le rôle rds_superuser de manière à ce que vous puissiez activer la réplication logique

    • Le rôle rds_replication pour accorder les autorisations de gérer des emplacements logiques et de diffuser les données à l'aide d'emplacements logiques

  2. Définissez le paramètre statique rds.logical_replication sur 1. Dans le cadre de l'application de ce paramètre, configurez également les paramètres wal_level, max_wal_senders, max_replication_slots et max_connections. Ces modifications de paramètres peuvent accroître la génération WAL de sorte que vous ne devez définir le paramètre rds.logical_replication que lorsque vous utilisez des emplacements logiques.

  3. Redémarrez l'instance de base de données pour que le paramètre statique rds.logical_replication prenne effet.

  4. Créez un emplacement de réplication logique comme expliqué dans la section suivante. Cela nécessite que vous précisiez un plugin de décodage. Actuellement, RDS for PostgreSQL prend en charge les plugins de sortie test_decoding et wal2json fournis avec PostgreSQL.

Pour plus d'informations sur le décodage logique PostgreSQL, consultez la documentation PostgreSQL.

Utilisation des emplacements de réplication logique

Vous pouvez utiliser les commandes SQL pour utiliser les emplacements logiques. Par exemple, la commande suivante crée un emplacement logique nommé test_slot à l'aide du plugin de sortie PostgreSQL par défaut test_decoding.

SELECT * FROM pg_create_logical_replication_slot('test_slot', 'test_decoding');
slot_name    | xlog_position
-----------------+---------------
regression_slot | 0/16B1970
(1 row)

Pour lister les emplacements logiques, utilisez la commande suivante.

SELECT * FROM pg_replication_slots;

Pour supprimer un emplacement logique, utilisez la commande suivante.

SELECT pg_drop_replication_slot('test_slot');
pg_drop_replication_slot
-----------------------
(1 row)

Pour plus d'exemples sur l'utilisation des emplacements de réplication logique, consultez Exemples de décodage logique dans la documentation PostgreSQL.

Après avoir créé l'emplacement de réplication logique, vous pouvez commencer le streaming. L'exemple suivant montre comment le décodage logique est contrôlé par le protocole de streaming. Celui-ci utilise le programme pg_recvlogical, qui est inclus dans la distribution PostgreSQL. Cela nécessite que l'authentification du client soit configurée pour autoriser les connexions de réplication.

pg_recvlogical -d postgres --slot test_slot -U postgres
    --host -instance-name.111122223333.aws-region.rds.amazonaws.com 
    -f -  --start

Pour afficher le contenu de la vue pg_replication_origin_status, interrogez la fonction pg_show_replication_origin_status.

SELECT * FROM pg_show_replication_origin_status();
local_id | external_id | remote_lsn | local_lsn
----------+-------------+------------+-----------
(0 rows)

Réplication des données au niveau des tables à l'aide de la réplication logique

Vous pouvez utiliser la réplication logique pour répliquer les données des tables sources vers les tables cibles dans RDS pour PostgreSQL. La réplication logique effectue d'abord un chargement initial des données existantes à partir des tables sources, puis continue à répliquer les modifications en cours.

  1. Création des tables sources

    Connectez-vous à la base de données source dans votre instance de base de données RDS pour PostgreSQL :

    
source=> CREATE TABLE testtab (slno int primary key);
CREATE TABLE
  2. Insérer des données dans les tables sources
    
source=> INSERT INTO testtab VALUES (generate_series(1,1000));
INSERT 0 1000
  3. Création d'une publication pour les tables sources

    • Créez une publication pour les tables sources :

      
source=> CREATE PUBLICATION testpub FOR TABLE testtab;
CREATE PUBLICATION

    • Utilisez une requête SELECT pour vérifier les détails de la publication créée :

      
source=> SELECT * FROM pg_publication;
  oid   | pubname | pubowner | puballtables | pubinsert | pubupdate | pubdelete | pubtruncate | pubviaroot
--------+---------+----------+--------------+-----------+-----------+-----------+-------------+------------
 115069 | testpub |    16395 | f            | t         | t         | t         | t           | f
(1 row)

    • Vérifiez que les tables sources sont ajoutées à la publication :

      
source=> SELECT * FROM pg_publication_tables; 
pubname | schemaname | tablename
---------+------------+-----------
 testpub | public     | testtab
(1 rows)

    • Pour répliquer toutes les tables d'une base de données, utilisez :

      
CREATE PUBLICATION testpub FOR ALL TABLES;

    • Si la publication est déjà créée pour une table individuelle et que vous devez ajouter une nouvelle table, vous pouvez exécuter la requête ci-dessous pour ajouter de nouvelles tables dans la publication existante :

      
ALTER PUBLICATION <publication_name> add table <new_table_name>;
  4. Connectez-vous à la base de données cible et créez des tables cibles

    • Connectez-vous à la base de données cible dans l'instance de base de données cible. Créez les tables cibles portant les mêmes noms que les tables sources :

      
target=> CREATE TABLE testtab (slno int primary key);
CREATE TABLE

    • Assurez-vous qu'aucune donnée n'est présente dans les tables cibles en exécutant une requête SELECT sur les tables cibles :

          
target=> SELECT count(*) FROM testtab;
 count
-------
     0
(1 row)
  5. Création et vérification de l'abonnement dans la base de données cible

    • Créez l'abonnement dans la base de données cible :

      
target=> CREATE SUBSCRIPTION testsub 
CONNECTION 'host=<source RDS/host endpoint> port=5432 dbname=<source_db_name> user=<user> password=<password>' 
PUBLICATION testpub;
NOTICE:  Created replication slot "testsub" on publisher
CREATE SUBSCRIPTION

    • Utilisez une requête SELECT pour vérifier que l'abonnement est activé :

      
target=> SELECT oid, subname, subenabled, subslotname, subpublications FROM pg_subscription;
  oid  | subname | subenabled | subslotname | subpublications
-------+---------+------------+-------------+-----------------
 16434 | testsub | t          | testsub     | {testpub}
(1 row)

    • Lorsque l'abonnement est créé, il charge toutes les données des tables sources vers les tables cibles. Exécutez une requête SELECT sur les tables cibles pour vérifier que les données initiales sont chargées :

      
target=> SELECT count(*) FROM testtab;
 count
-------
  1000
(1 row)
  6. Vérifier le slot de réplication dans la base de données source

    La création d'un abonnement dans la base de données cible crée un emplacement de réplication dans la base de données source. Vérifiez les détails du slot de réplication en exécutant la requête SELECT suivante sur la base de données source :

    
source=> SELECT * FROM pg_replication_slots;
 
slot_name |  plugin  | slot_type | datoid | database | temporary | active | active_pid | xmin | catalog_xmin | restart_lsn | confirmed_flush_lsn | wal_status | safe_wal_size
----------+----------+-----------+--------+----------+-----------+--------+------------+------+--------------+-------------+---------------------+------------+---------------
testsub   | pgoutput | logical   | 115048 | source   | f         | t      |        846 |      |         6945 | 58/B4000568 | 58/B40005A0         | reserved   |
(1 row)
  7. Tester la réplication

    • Vérifiez si les modifications apportées aux données dans les tables sources sont répliquées dans les tables cibles en insérant des lignes dans les tables sources :

      
source=> INSERT INTO testtab VALUES(generate_series(1001,2000));
INSERT 0 1000

source=> SELECT count(*) FROM testtab; 
 count
-------
  2000
(1 row)

    • Vérifiez le nombre de lignes dans les tables cibles pour confirmer que les nouveaux inserts sont répliqués :

      
target=> SELECT count(*) FROM testtab;
 count
-------
  2000
(1 row)
  8. Actualisation de l'abonnement après avoir ajouté des tables

    • Lorsque vous ajoutez de nouveaux tableaux à une publication existante, il est obligatoire d'actualiser l'abonnement pour que les modifications prennent effet :

      
ALTER SUBSCRIPTION <subscription_name> REFRESH PUBLICATION;

    • Cette commande récupère les informations de table manquantes auprès de l'éditeur et lance la réplication des tables qui ont été ajoutées aux publications abonnées depuis la création de l'abonnement ou la dernière actualisation de l'abonnement.