Ongoing service disruptions

For the most recent update on ongoing service disruptions affecting the AWS Middle East (UAE) Region (ME-CENTRAL-1), refer to the AWS Health Dashboard. For information on AWS Service migration, see How do I migrate my services to another region?

Wie verwende ich logische Replikation, um Tabellen zwischen meinen Amazon RDS for PostgreSQL-DB-Instances zu replizieren?

Lesedauer: 7 Minute

Ich möchte die logische Replikation verwenden, um Tabellen zwischen Datenbanken in meiner Amazon Relational Database Service (Amazon RDS) für PostgreSQL DB-Instance zu replizieren. Ich möchte keine Erweiterungen verwenden.

Lösung

Amazon RDS für PostgreSQL unterstützt logische Replikation mit PostgreSQL 10.4 und höher. Amazon Aurora PostgreSQL-Compatible Edition Version 2.2.0 und höher unterstützt die logische Replikation mit PostgreSQL 10.6 und höher.

Weitere Informationen findest du unter Logische Replikation für Amazon RDSD für PostgreSQL durchführen.

Mit der folgenden Auflösung werden zwei Quelltabellen auf zwei Zieltabellen repliziert.

Logische Replikation aktivieren

Führe die folgenden Schritte aus:

Erstelle eine benutzerdefinierte Parametergruppe und setze den Parameter rds.logical_replication auf 1.
Hinweis: Da der Parameter rds.logical_replication ein statischer Parameter ist, musst du die DB-Instance neu starten. Nachdem du die DB-Instance neu gestartet hast, ändert sich der Parameter wal_level in logical.
Verknüpfe die Parametergruppe mit der DB-Instance.

Führe die folgende Abfrage aus, um zu überprüfen, ob wal_level logical ist und rds.logical_replication aktiviert ist:

SELECT name,setting FROM pg_settings WHERE name IN ('wal_level','rds.logical_replication');

Erwartetes Ergebnis:

          name           | setting
-------------------------+---------
 rds.logical_replication | on
 wal_level               | logical
(2 rows)

Quelltabellen erstellen und Daten einfügen

Stelle eine Verbindung zur PostgreSQL-DB-Instance her und führe dann die folgenden Schritte in der Quelldatenbank aus:

Führe die folgenden Befehle aus, um die Quelltabellen zu erstellen:

CREATE TABLE reptab1 (slno int primary key);  
CREATE TABLE reptab2 (name varchar(20));

Führe die folgenden Befehle aus, um Daten zu den Quelltabellen hinzuzufügen:

INSERT INTO reptab1 VALUES (generate_series(1,1000));  
INSERT INTO reptab2 SELECT SUBSTR ('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',((random()*(36-1)+1)::integer),1) FROM generate_series(1,50);

Veröffentlichung für die Quelltabellen erstellen

Führe in der Quelldatenbank die folgenden Schritte aus:

Führe den folgenden Befehl aus, um eine Veröffentlichung der beiden Tabellen zu erstellen:

CREATE PUBLICATION testpub FOR TABLE reptab1, reptab2;

Führe die folgende Abfrage aus, um zu überprüfen, ob die Details der Veröffentlichung korrekt sind:

SELECT * FROM pg_publication;

Erwartetes Ergebnis:

  oid   | pubname | pubowner | puballtables | pubinsert | pubupdate | pubdelete | pubtruncate | pubviaroot  
--------+---------+----------+--------------+-----------+-----------+-----------+-------------+------------  
 115069 | testpub |    16395 | f            | t         | t         | t         | t           | f  
(1 row)

Führe die folgende Abfrage aus, um zu überprüfen, ob die Quelltabellen in der Veröffentlichung enthalten sind:

SELECT * FROM pg_publication;

Erwartetes Ergebnis:

 pubname | schemaname | tablename  

---------+------------+-----------  

 testpub | public | reptab1  

 testpub | public | reptab2  

(2 rows)

Verbindung zur Zieldatenbank herstellen und Zieltabellen erstellen

Führe in der Zieldatenbank die folgenden Schritte aus:

Führe die folgenden Befehle aus, um die Zieltabellen zu erstellen:

CREATE TABLE reptab1 (slno int primary key);  
CREATE TABLE reptab2 (name varchar(20));

Hinweis: Verwende dieselben Namen wie die Quelltabellen.

Führe die folgenden Abfragen aus, um sicherzustellen, dass sich keine Daten in den Zieltabellen befinden.
Tabelle eins:

SELECT count(*) FROM reptab1;

Erwartetes Ergebnis:

 count  
-------  
     0  
(1 row)

Tabelle zwei:

SELECT count(*) FROM reptab2;

Erwartetes Ergebnis:

 count  
-------  
     0  
(1 row)

Abonnement in der Zieldatenbank erstellen

Bevor du das Abonnement erstellst, führe die folgenden Befehle aus, um zu bestätigen, dass du keine Klartext-Version deines Benutzernamens und Passworts in den Datenbankprotokollen gespeichert hast:

SET log_min_messages to 'PANIC';  
SET log_statement to NONE;

Gehe wie folgt vor, um das Abonnement in der Zieldatenbank zu erstellen:

Führe den folgenden Befehl aus, um das Abonnement zu erstellen:

CREATE SUBSCRIPTION testsub CONNECTION 'host=source RDS/host endpoint port=5432 dbname=source_db_name user=user password=password' PUBLICATION testpub;

Hinweis: Ersetze source RDS/host endpoint durch den Endpunkt deiner Quell-DB-Instance und source_db_name durch den Namen deiner DB-Instance. Ersetze user durch deinen Benutzernamen und password durch dein Passwort.

Führe die folgende Abfrage aus, um zu überprüfen, ob das Abonnement aktiv ist:

SELECT oid,subname,subenabled,subslotname,subpublications FROM pg_subscription;

Erwartetes Ergebnis:

  oid  | subname | subenabled | subslotname | subpublications  
-------+---------+------------+-------------+-----------------  
 16434 | testsub | t          | testsub     | {testpub}  
(1 row)

Führe die folgenden Abfragen aus, um zu überprüfen, ob sich die Daten in den Zieltabellen befinden.
Tabelle eins:

SELECT count(*) FROM reptab1;

Erwartetes Ergebnis:

 count  
-------  
  1000  
(1 row)

Tabelle zwei:

SELECT count(*) FROM reptab2;

Erwartetes Ergebnis:

 count  
-------  
    50  
(1 row)

Replikations-Slot-Details in der Quelldatenbank überprüfen

Wenn du ein Abonnement in der Zieldatenbank erstellst, erstellt die Zieldatenbank einen Replikations-Slot in der Quelldatenbank.

Um die Details des Replikations-Slots zu überprüfen, führe die folgende Abfrage in der Quelldatenbank aus:

SELECT * FROM pg_replication_slots;

Erwartetes Ergebnis:

 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)

Replikation aus den Quelltabellen testen

Führe in der Quelldatenbank die folgenden Schritte aus:

Führe die folgenden Befehle aus, um Zeilen zu den Quelltabellen hinzuzufügen:

INSERT INTO reptab1 VALUES(generate_series(1001,2000));  
INSERT INTO reptab2 SELECT SUBSTR('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',((random()*(36-1)+1)::integer),1) FROM generate_series(1,50);

Führe die folgenden Abfragen aus, um zu überprüfen, ob sich die Daten in den Quelltabellen geändert haben.
Tabelle eins:

SELECT count(*) FROM reptab1;

Erwartetes Ergebnis:

 count  
-------  
   2000  
(1 row)

Tabelle zwei:

SELECT count(*) FROM reptab2;

Erwartetes Ergebnis:

 count  
-------  
   100  
(1 row)

Sicherstellen, dass die Daten in den Quelltabellen in die Zieltabellen repliziert wurden

Führe in der Zieldatenbank die folgenden Abfragen aus, um zu bestätigen, dass die Daten aus den Quelltabellen in die Zieltabellen repliziert wurden.

Tabelle eins:

SELECT count(*) FROM reptab1;

Erwartetes Ergebnis:

count  
-------  
   2000  
(1 row)

Tabelle zwei:

SELECT count(*) FROM reptab2;

Erwartetes Ergebnis:

 count  
-------  
   100  
(1 row)

Replikations-Slots löschen und logische Replikation deaktivieren

Wenn du die Replikation abgeschlossen hast und sie nicht mehr benötigst, lösche die Slots und deaktiviere die logische Replikation. Inaktive Replikations-Slots führen dazu, dass sich Write-Ahead Logging (WAL)-Dateien auf der Quell-DB-Instance ansammeln. WAL-Dateien können den Speicher füllen und zu Ausfallzeiten führen.

Führe die folgenden Schritte aus:

Führe in der Zieldatenbank den folgenden Befehl aus, um das Abonnement zu entfernen:
```
DROP SUBSCRIPTION testsub;
```

Führe in der Zieldatenbank die folgende Abfrage aus, um zu überprüfen, ob das Abonnement entfernt wurde:

SELECT * FROM pg_subscription;

Erwartetes Ergebnis:

oid | subdbid | subname | subowner | subenabled | subconninfo | subslotname | subsynccommit | subpublications  
----+---------+---------+----------+------------+-------------+-------------+---------------+-----------------  
(0 rows)

Hinweis: Wenn du das Abonnement in der Zieldatenbank entfernst, entfernt die Zieldatenbank auch die Replikations-Slots in der Quelldatenbank.

Führe in der Quelldatenbank die folgende Abfrage aus, um zu überprüfen, ob die Replikations-Slots aus der Quelldatenbank entfernt wurden:

SELECT * FROM pg_replication_slots;

Erwartetes Ergebnis:

slot_name | plugin | slot_type | datoid | database | temporary | active | active_pid | xmin | catalog_xmin | restart_lsn | confirmed_flush_lsn | wal_status | safe_wal_size  
----------+--------+-----------+--------+----------+-----------+--------+------------+------+--------------+-------------+---------------------+------------+--------------  
(0 rows)

Führe in der Quelldatenbank den folgenden Befehl aus, um die Veröffentlichung zu entfernen:
```
DROP PUBLICATION testpub;
```

Führe in der Quelldatenbank die folgenden Abfragen aus, um zu überprüfen, ob die Veröffentlichung entfernt wurde:

SELECT * FROM pg_publication;  
SELECT * FROM pg_publication_tables;

Erwartetes Ergebnis:

 oid | pubname | pubowner | puballtables | pubinsert | pubupdate | pubdelete | pubtruncate | pubviaroot  
-----+---------+----------+--------------+-----------+-----------+-----------+-------------+------------  
(0 rows)  
pubname | schemaname | tablename  
---------+------------+-----------  
(0 rows)

Setze in der benutzerdefinierten Parametergruppe deiner DB-Instance den Parameter „rds.logical_replication“ auf 0.
Hinweis: Starte die DB-Instance neu, damit die Änderungen übernommen werden.
Überprüfe je nach Nutzung die Parameter max_replication_slots, max_wal_senders, max_logical_replication_workers, max_worker_processes und max_sync_workers_per_subscription.

Führe die folgende Abfrage aus, um zu überprüfen, ob inaktive Replikations-Slots vorhanden sind und wie groß die Steckplätze sind:

SELECT slot_name, pg_size_pretty(pg_wal_lsn_diff(pg_current_wal_lsn(),restart_lsn)) AS replicationSlotLag, active FROM pg_replication_slots;

(Optional) Führe den folgenden Befehl aus, um die Replikations-Slots zu entfernen:

SELECT pg_drop_replication_slot('Your_slotname_name')

Relevanter Inhalt

Wie verwende ich Binärprotokolle aus einer aktiven Amazon RDS für MySQL-DB-Instance, um sie auf einen lokalen Standby-Server zu replizieren?
AWS OFFICIALAktualisiert vor 8 Monaten
Wie behebe ich logische Replikationsprobleme für einen Quell-DB-Cluster von Aurora PostgreSQL-Compatible?
AWS OFFICIALAktualisiert vor 4 Monaten
Wie verhindere ich DDL-Operationen in meinen Amazon RDS für PostgreSQL- oder Aurora PostgreSQL-kompatiblen Instances während Blau/Grün-Bereitstellungen?
AWS OFFICIALAktualisiert vor 9 Monaten
Wie migriere ich meine Amazon-RDS-for-MySQL-DB-Instance mithilfe einer benutzerdefinierten Startzeit?
AWS OFFICIALAktualisiert vor 4 Jahren

Wie verwende ich logische Replikation, um Tabellen zwischen meinen Amazon RDS for PostgreSQL-DB-Instances zu replizieren?

Lösung

Logische Replikation aktivieren

Quelltabellen erstellen und Daten einfügen

Veröffentlichung für die Quelltabellen erstellen

Verbindung zur Zieldatenbank herstellen und Zieltabellen erstellen

Abonnement in der Zieldatenbank erstellen

Replikations-Slot-Details in der Quelldatenbank überprüfen

Replikation aus den Quelltabellen testen

Sicherstellen, dass die Daten in den Quelltabellen in die Zieltabellen repliziert wurden

Replikations-Slots löschen und logische Replikation deaktivieren

Ähnliche Informationen

Relevanter Inhalt