Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Ausführen der logischen Replikation für Amazon RDS für PostgreSQL Ab Version 10.4 unterstützt RDS für PostgreSQL die Veröffentlichung und das Abonnement von SQL-Syntax, die erstmals in PostgreSQL 10 eingeführt wurde. Weitere Informationen finden Sie unter [Logische Replikation](https://www.postgresql.org/docs/current/logical-replication.html) in der PostgreSQL-Dokumentation. **Anmerkung** Zusätzlich zu der in PostgreSQL 10 eingeführten nativen logischen Replikationsfunktion von PostgreSQL unterstützt RDS für PostgreSQL auch die `pglogical`-Erweiterung. Weitere Informationen finden Sie unter [Verwenden von pglogical, um Daten zwischen Instances zu synchronisieren](Appendix.PostgreSQL.CommonDBATasks.pglogical.md). Im Folgenden erfahren Sie, wie Sie die logische Replikation für eine DB-Instance von RDS für PostgreSQL einrichten. **Topics** + [Verständnis der logischen Replikation und logischen Decodierung](#PostgreSQL.Concepts.General.FeatureSupport.LogicalDecoding) + [Arbeiten mit logischen Replikations-Slots](#PostgreSQL.Concepts.General.FeatureSupport.LogicalReplicationSlots) + [Replizieren von Daten auf Tabellenebene mithilfe logischer Replikation](#PostgreSQL.Concepts.LogicalReplication.Tables) ## Verständnis der logischen Replikation und logischen Decodierung RDS für PostgreSQL unterstützt das Streaming von Write-Ahead-Log(WAL)-Änderungen mithilfe der Slots für logische Replikation von PostgreSQL. Es unterstützt auch die Verwendung logischer Decodierung. Sie können logische Replikations-Slots in Ihrer Instance einrichten und über diese Slots Datenbankänderungen auf einen Client wie z. B. streame `pg_recvlogical`. Sie erstellen logische Replikationsslots auf Datenbankebene, die Replikationsverbindungen zu einer einzelnen Datenbank unterstützen. Die gängigsten Clients für die logische PostgreSQL-Replikation sind AWS Database Migration Service oder ein individuell verwalteter Host auf einer Amazon EC2 EC2-Instance. Der logische Replikations-Slot enthält keine Informationen über den Empfänger des Streams. Es gibt auch keine Anforderung, dass das Ziel eine Replikatdatenbank sein muss. Wenn beim Einrichten eines Slots für die logische Replikation nicht vom Slot gelesen wird, können Daten in den Speicher Ihrer DB-Instance geschrieben werden und diesen schnell füllen. Sie aktivieren die logische Replikation und die logische Decodierung PostgreSQL für Amazon RDS durch einen Parameter, einen neuen Replikationsverbindungstyp sowie eine Sicherheitsrolle. Beim Client für die logische Decodierung kann es sich um jeden beliebigen Client handeln, der eine Replikationsverbindung zu einer Datenbank in einer PostgreSQL-DB-Instance herstellen kann. **Logische Decodierung für eine DB-Instance von RDS für PostgreSQL aktivieren** 1. Stellen Sie sicher, dass das Benutzerkonto, das Sie verwenden, folgende Rollen hat: + Die `rds_superuser`-Rolle, damit Sie die logische Replikation aktivieren können + Die `rds_replication`-Rolle erteilt Berechtigungen zur Verwaltung von logischen Slots und zum Streamen von Daten mithilfe von logischen Slots 1. Setzen Sie den statischen Parameter `rds.logical_replication` auf 1. Setzen Sie bei der Anwendung dieses Parameters auch die Parameter `wal_level`, `max_wal_senders`, `max_replication_slots` und `max_connections` fest. Diese Änderungen an den Parametern können die WAL-Generierung steigern, legen Sie daher den Parameter `rds.logical_replication` nur dann fest, wenn Sie logische Slots verwenden. 1. Starten Sie die DB-Instance neu, damit der statische Parameter `rds.logical_replication` in Kraft tritt. 1. Erstellen Sie einen logischen Replikationsslot wie im nächsten Abschnitt erläutert. Für diesen Prozess ist es erforderlich, dass Sie ein Decodier-Plugin angeben. Derzeit unterstützt RDS für PostgreSQL die test\$1decoding- und wal2json-Ausgabe-Plugins, die mit PostgreSQL geliefert werden. Weitere Informationen zur logischen Decodierung mit PostgreSQL finden Sie in der [ PostgreSQL-Dokumentation](https://www.postgresql.org/docs/current/static/logicaldecoding-explanation.html). ## Arbeiten mit logischen Replikations-Slots Sie können SQL-Befehle verwenden, um mit logischen Slots zu arbeiten. Beispiel: Der folgende Befehl erstellt einen logischen Slot mit dem Namen `test_slot` unter Verwendung des standardmäßigen Ausgangs-Plugin `test_decoding` von PostgreSQL. ``` SELECT * FROM pg_create_logical_replication_slot('test_slot', 'test_decoding'); slot_name | xlog_position -----------------+--------------- regression_slot | 0/16B1970 (1 row) ``` Mit dem folgenden Befehl können Sie die logischen Slots auflisten. ``` SELECT * FROM pg_replication_slots; ``` Mit dem folgenden Befehl können Sie einen logischen Slot entfernen. ``` SELECT pg_drop_replication_slot('test_slot'); pg_drop_replication_slot ----------------------- (1 row) ``` Weitere Beispiele zum Arbeiten mit logischen Replikations-Slots finden Sie unter [ Logical Decoding Examples](https://www.postgresql.org/docs/9.5/static/logicaldecoding-example.html) in der PostgreSQL-Dokumentation. Sobald Sie den logischen Replikationsslot erstellt haben, können Sie mit dem Streaming beginnen. Das folgende Beispiel zeigt, wie die logische Decodierung über das Streaming-Replikationsprotokoll gesteuert wird. Dieses Beispiel verwendet das Programm pg\$1recvlogical, das in der PostgreSQL-Distribution enthalten ist. Dazu muss die Client-Authentifizierung so eingerichtet sein, dass Replikationsverbindungen zugelassen werden. ``` pg_recvlogical -d postgres --slot test_slot -U postgres --host -instance-name.111122223333.aws-region.rds.amazonaws.com -f - --start ``` Fragen Sie die Funktion `pg_replication_origin_status` ab, um den Inhalt der `pg_show_replication_origin_status` Ansicht anzuzeigen. ``` SELECT * FROM pg_show_replication_origin_status(); local_id | external_id | remote_lsn | local_lsn ----------+-------------+------------+----------- (0 rows) ``` ## Replizieren von Daten auf Tabellenebene mithilfe logischer Replikation Sie können die logische Replikation verwenden, um Daten aus Quelltabellen in Zieltabellen von RDS für PostgreSQL zu replizieren. Bei der logischen Replikation werden zunächst vorhandene Daten aus den Quelltabellen geladen und anschließend die laufenden Änderungen weiterhin repliziert. 1. **Erstellen der Quelltabellen** Stellen Sie eine Verbindung mit Ihrer Quelldatenbank in der DB-Instance von RDS für PostgreSQL her. ``` source=> CREATE TABLE testtab (slno int primary key); CREATE TABLE ``` 1. **Einfügen der Daten in die Quelltabellen** ``` source=> INSERT INTO testtab VALUES (generate_series(1,1000)); INSERT 0 1000 ``` 1. **Erstellen einer Publikation für Quelltabellen** + Erstellen Sie eine Publikation für die Quelltabellen: ``` source=> CREATE PUBLICATION testpub FOR TABLE testtab; CREATE PUBLICATION ``` + Verwenden Sie eine SELECT-Abfrage, um die Details der erstellten Publikation zu überprüfen: ``` 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) ``` + Vergewissern Sie sich, dass die Quelltabellen zur Publikation hinzugefügt wurden: ``` source=> SELECT * FROM pg_publication_tables; pubname | schemaname | tablename ---------+------------+----------- testpub | public | testtab (1 rows) ``` + Um alle Tabellen in einer Datenbank zu replizieren, verwenden Sie Folgendes: ``` CREATE PUBLICATION testpub FOR ALL TABLES; ``` + Wenn die Publikation bereits für eine einzelne Tabelle erstellt wurde und Sie eine neue Tabelle hinzufügen müssen, können Sie die folgende Abfrage ausführen, um der vorhandenen Publikation beliebige neue Tabellen hinzuzufügen: ``` ALTER PUBLICATION add table ; ``` 1. **Herstellen einer Verbindung mit der Zieldatenbank und Erstellen von Zieltabellen** + Stellen Sie eine Verbindung mit der Zieldatenbank in der Ziel-DB-Instance her. Erstellen Sie die Zieltabellen mit denselben Namen wie die Quelltabellen: ``` target=> CREATE TABLE testtab (slno int primary key); CREATE TABLE ``` + Vergewissern Sie sich, dass in den Zieltabellen keine Daten vorhanden sind, indem Sie eine SELECT-Abfrage für die Zieltabellen ausführen: ``` target=> SELECT count(*) FROM testtab; count ------- 0 (1 row) ``` 1. **Erstellen und Überprüfen des Abonnements in der Zieldatenbank** + Erstellen Sie das Abonnement in der Zieldatenbank: ``` target=> CREATE SUBSCRIPTION testsub CONNECTION 'host= port=5432 dbname= user= password=' PUBLICATION testpub; NOTICE: Created replication slot "testsub" on publisher CREATE SUBSCRIPTION ``` + Verwenden Sie eine SELECT-Abfrage, um zu überprüfen, ob das Abonnement aktiviert ist: ``` target=> SELECT oid, subname, subenabled, subslotname, subpublications FROM pg_subscription; oid | subname | subenabled | subslotname | subpublications -------+---------+------------+-------------+----------------- 16434 | testsub | t | testsub | {testpub} (1 row) ``` + Wenn das Abonnement erstellt wird, werden alle Daten von den Quelltabellen in die Zieltabellen geladen. Führen Sie eine SELECT-Abfrage für die Zieltabellen aus, um zu überprüfen, ob die ursprünglichen Daten geladen werden: ``` target=> SELECT count(*) FROM testtab; count ------- 1000 (1 row) ``` 1. **Überprüfen des Replikations-Slots in der Quelldatenbank** Durch die Erstellung eines Abonnements in der Zieldatenbank wird ein Replikations-Slot in der Quelldatenbank erstellt. Überprüfen Sie die Details des Replikations-Slots, indem Sie die folgende SELECT-Abfrage für die Quelldatenbank ausführen: ``` 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) ``` 1. **Testen der Replikation** + Testen Sie, ob Datenänderungen in den Quelltabellen in die Zieltabellen repliziert werden, indem Sie folgende Zeilen in die Quelltabellen einfügen: ``` source=> INSERT INTO testtab VALUES(generate_series(1001,2000)); INSERT 0 1000 source=> SELECT count(*) FROM testtab; count ------- 2000 (1 row) ``` + Überprüfen Sie die Anzahl der Zeilen in den Zieltabellen, um sicherzustellen, dass neu eingefügte Daten repliziert werden: ``` target=> SELECT count(*) FROM testtab; count ------- 2000 (1 row) ``` 1. **Aktualisieren des Abonnements nach dem Hinzufügen von Tabellen** + Wenn Sie einer vorhandenen Publikation neue Tabellen hinzufügen, muss das Abonnement unbedingt aktualisiert werden, damit die Änderungen wirksam werden: ``` ALTER SUBSCRIPTION REFRESH PUBLICATION; ``` + Mit diesem Befehl werden fehlende Tabelleninformationen vom Publisher abgerufen und die Replikation für Tabellen gestartet, die seit der Erstellung oder letzten Aktualisierung des Abonnements zu den abonnierten Publikationen hinzugefügt wurden.