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. # Verwenden von pglogical, um Daten zwischen Instances zu synchronisieren Alle derzeit verfügbaren Versionen von RDS für PostgreSQL unterstützen die `pglogical`-Erweiterung. Die Erweiterung pglogical ist älter als die funktionell ähnliche logische Replikationsfunktion, die von PostgreSQL in Version 10 eingeführt wurde. Weitere Informationen finden Sie unter [Ausführen der logischen Replikation für Amazon RDS für PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.LogicalReplication.md). Die `pglogical`-Erweiterung unterstützt die logische Replikation zwischen zwei oder mehr . DB-Instances von RDS für PostgreSQL Es unterstützt auch die Replikation zwischen verschiedenen PostgreSQL-Versionen und zwischen Datenbanken, die auf DB-Instances von RDS für PostgreSQL und DB-Clustern von Aurora PostgreSQL laufen. Die `pglogical`-Erweiterung verwendet ein Publish-Subscribe-Modell, um Änderungen an Tabellen und anderen Objekten, z. B. Sequenzen, von einem Herausgeber auf einen Abonnenten zu replizieren. Sie stützt sich auf einen Replikationsslot, um sicherzustellen, dass Änderungen von einem Herausgeberknoten zu einem Abonnentenknoten synchronisiert werden. Dies ist wie folgt definiert. + Der *Herausgeberknoten* ist die DB-Instance von RDS für PostgreSQL, die die Datenquelle ist, die auf andere Knoten repliziert werden soll. Der Herausgeberknoten definiert die Tabellen, die in einem Veröffentlichungssatz repliziert werden sollen. + Der *Abonnentenknoten* ist die DB-Instance von RDS für PostgreSQL, die WAL-Updates vom Herausgeber erhält. Der Abonnent erstellt ein Abonnement, um eine Verbindung zum Herausgeber herzustellen und die dekodierten WAL-Daten abzurufen. Wenn der Abonnent das Abonnement erstellt, wird der Replikationsslot auf dem Herausgeberknoten erstellt. Im Folgenden erfahren Sie, wie Sie die `pglogical`-Erweiterung einrichten. **Topics** + [Anforderungen und Einschränkungen für die pglogical-Erweiterung](#Appendix.PostgreSQL.CommonDBATasks.pglogical.requirements-limitations) + [Einrichten der pglogical-Erweiterung](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md) + [Einrichten der logischen Replikation für die DB-Instance von RDS für PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.pglogical.setup-replication.md) + [Wiederherstellung der logischen Replikation nach einem Hauptversions-Upgrade](Appendix.PostgreSQL.CommonDBATasks.pglogical.recover-replication-after-upgrade.md) + [Verwaltung logischer Replikationsslots für](Appendix.PostgreSQL.CommonDBATasks.pglogical.handle-slots.md) + [Parameterreferenz für die pglogical-Erweiterung](Appendix.PostgreSQL.CommonDBATasks.pglogical.reference.md) ## Anforderungen und Einschränkungen für die pglogical-Erweiterung Alle derzeit verfügbaren Versionen von RDS für PostgreSQL unterstützen die `pglogical`-Erweiterung. Sowohl der Herausgeberknoten als auch der Abonnentenknoten müssen für die logische Replikation eingerichtet sein. Die Tabellen, die Sie vom Publisher zum Subscriber replizieren möchten, müssen dieselben Namen und dasselbe Schema haben. Diese Tabellen müssen außerdem dieselben Spalten enthalten und diese müssen dieselben Datentypen verwenden. Sowohl die Herausgeber- als auch die Abonnententabelle müssen dieselben Primärschlüssel haben. Wir empfehlen, nur den PRIMARY KEY als eindeutige Einschränkung zu verwenden. Die Tabellen auf dem Abonnentenknoten können für CHECK-Einschränkungen und NOT NULL-Einschränkungen großzügigere Einschränkungen haben als die Tabellen auf dem Herausgeberknoten. Die `pglogical`-Erweiterung bietet Funktionen wie die bidirektionale Replikation, die von der logischen Replikationsfunktion, die in PostgreSQL (Version 10 und höher) integriert ist, nicht unterstützt werden. Weitere Informationen finden Sie unter [Die bidirektionale PostgreSQL-Replikation mit pglogical](https://aws.amazon.com/blogs/database/postgresql-bi-directional-replication-using-pglogical/). # Einrichten der pglogical-Erweiterung Wenn Sie die `pglogical`-Erweiterung auf Ihrer DB-Instance von RDS für PostgreSQL einrichten möchten, fügen Sie zunächst `pglogical` zu den gemeinsam genutzten Bibliotheken in der benutzerdefinierten DB-Parametergruppe für Ihre DB-Instance von RDS für PostgreSQL hinzu. Sie müssen außerdem den Wert des `rds.logical_replication`-Parameters auf `1` festlegen, um die logische Dekodierung zu aktivieren. Abschließend erstellen Sie die Erweiterung in der Datenbank. Sie können das AWS-Managementkonsole oder das AWS CLI für diese Aufgaben verwenden. Sie müssen über Berechtigungen als `rds_superuser`-Rolle verfügen, um diese Aufgaben ausführen zu können. Bei den folgenden Schritten wird davon ausgegangen, dass Ihre DB-Instance von RDS für PostgreSQL einer benutzerdefinierten DB-Parametergruppe zugeordnet ist. Weitere Informationen über das Erstellen einer benutzerdefinierten DB-Parametergruppe finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md). ## Konsole **So richten Sie die pglogical-Erweiterung ein** 1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. Wählen Sie im Navigationsbereich Ihre DB-Instance von RDS für PostgreSQL aus. 1. Öffnen Sie die Registerkarte **Configuration** (Konfiguration) für Ihre DB-Instance von RDS für PostgreSQL Suchen Sie in den Instance-Details den Link **Parameter group** (Parametergruppe). 1. Wählen Sie den Link aus, um die benutzerdefinierten Parameter zu öffnen, die Ihrem DB-Instance von RDS für PostgreSQL 1. Geben Sie in das Suchfeld **Parameters** (Parameter) `shared_pre` ein, um den `shared_preload_libraries`-Parameter zu finden. 1. Wählen Sie **Edit parameters** (Parameter bearbeiten) aus, um auf die Eigenschaftswerte zuzugreifen. 1. Fügen Sie `pglogical` der Liste im Feld **Values** (Werte) hinzu. Verwenden Sie ein Komma, um Elemente in der Werteliste zu trennen. ![\[Bild des shared_preload_libraries-Parameters mit hinzugefügter pglogical-Erweiterung.\]](http://docs.aws.amazon.com/de_de/AmazonRDS/latest/UserGuide/images/apg_rpg_shared_preload_pglogical.png) 1. Suchen Sie den `rds.logical_replication`-Parameter und legen Sie ihn auf `1` fest, um die logische Replikation zu aktivieren. 1. Starten Sie die DB-Instance von RDS für PostgreSQL neu, damit Ihre Änderungen wirksam werden. 1. Wenn die Instance verfügbar ist, können Sie über `psql` (oder pgAdmin) eine Verbindung mit der DB-Instance von RDS für PostgreSQL herstellen. ``` psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Führen Sie den folgenden Befehl aus, um zu überprüfen, dass pglogical initialisiert ist. ``` SHOW shared_preload_libraries; shared_preload_libraries -------------------------- rdsutils,pglogical (1 row) ``` 1. Überprüfen Sie die Einstellung, die die logische Dekodierung ermöglicht, wie folgt. ``` SHOW wal_level; wal_level ----------- logical (1 row) ``` 1. Erstellen Sie die Erweiterung wie folgt. ``` CREATE EXTENSION pglogical; EXTENSION CREATED ``` 1. Wählen Sie **Änderungen speichern ** aus. 1. Öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. Wählen Sie aus der Liste der Datenbanken Ihre DB-Instance von RDS für PostgreSQL und dann im Menü „Actions“ (Aktionen) die Option **Reboot** (Neustart) aus. ## AWS CLI **So richten Sie die pglogical-Erweiterung ein** Um pglogical mit dem einzurichten AWS CLI, rufen Sie den [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html)Vorgang auf, um bestimmte Parameter in Ihrer benutzerdefinierten Parametergruppe zu ändern, wie im folgenden Verfahren gezeigt. 1. Verwenden Sie den folgenden AWS CLI Befehl, um den Parameter `pglogical` zu erweitern. `shared_preload_libraries` ``` aws rds modify-db-parameter-group \ --db-parameter-group-name custom-param-group-name \ --parameters "ParameterName=shared_preload_libraries,ParameterValue=pglogical,ApplyMethod=pending-reboot" \ --region aws-region ``` 1. Verwenden Sie den folgenden AWS CLI Befehl, um auf zu setzen`rds.logical_replication`, `1` um die logische Dekodierungsfunktion für die zu aktivieren. DB-Instance von RDS für PostgreSQL ``` aws rds modify-db-parameter-group \ --db-parameter-group-name custom-param-group-name \ --parameters "ParameterName=rds.logical_replication,ParameterValue=1,ApplyMethod=pending-reboot" \ --region aws-region ``` 1. Verwenden Sie den folgenden AWS CLI Befehl, um die neu zu starten, sodass die pglogische Bibliothek initialisiert wird. ``` aws rds reboot-db-instance \ --db-instance-identifier your-instance \ --region aws-region ``` 1. Wenn die Instance verfügbar ist, stellen Sie über `psql` eine Verbindung mit der DB-Instance von RDS für PostgreSQL her. ``` psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Erstellen Sie die Erweiterung wie folgt. ``` CREATE EXTENSION pglogical; EXTENSION CREATED ``` 1. Starten Sie die for PostgreSQL-DB-Instance mit dem folgenden Befehl neu. AWS CLI ``` aws rds reboot-db-instance \ --db-instance-identifier your-instance \ --region aws-region ``` # Einrichten der logischen Replikation für die DB-Instance von RDS für PostgreSQL Das folgende Verfahren zeigt Ihnen, wie Sie die logische Replikation zwischen zwei DB-Instances von RDS für PostgreSQL starten. Bei den Schritten wird davon ausgegangen, dass sowohl für die Quelle (Herausgeber) als auch für das Ziel (Abonnent) die `pglogical`-Erweiterung eingerichtet wurde, wie unter [Einrichten der pglogical-Erweiterung](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md) beschrieben. **Anmerkung** Der `node_name` eines Subscriber-Knoten kann nicht mit `rds` beginnen. **So erstellen Sie den Herausgeberknoten und die zu replizierenden Tabellen** Bei diesen Schritten wird vorausgesetzt, dass Ihre DB-Instance von RDS für PostgreSQL über eine Datenbank mit einer oder mehreren Tabellen verfügt, die Sie auf einen anderen Knoten replizieren möchten. Sie müssen die Tabellenstruktur des Herausgebers für den Abonnenten neu erstellen. Rufen Sie daher bei Bedarf zunächst die Tabellenstruktur ab. Verwenden Sie dazu den `psql`-Metabefehl `\d tablename` und erstellen Sie dann dieselbe Tabelle auf der Abonnenten-Instance. Mit dem folgenden Verfahren wird zu Demonstrationszwecken eine Beispieltabelle für den Herausgeber (Quelle) erstellt. 1. Verwenden Sie `psql`, um eine Verbindung zu der Instance herzustellen, die die Tabelle enthält, die Sie als Quelle für Abonnenten verwenden möchten. ``` psql --host=source-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` Wenn Sie noch keine vorhandene Tabelle haben, die Sie replizieren möchten, können Sie wie folgt eine Beispieltabelle erstellen. 1. Erstellen Sie mit der folgenden SQL-Anweisung eine Beispieltabelle. ``` CREATE TABLE docs_lab_table (a int PRIMARY KEY); ``` 1. Füllen Sie die Tabelle mit der folgenden SQL-Anweisung mit generierten Daten auf. ``` INSERT INTO docs_lab_table VALUES (generate_series(1,5000)); INSERT 0 5000 ``` 1. Stellen Sie sicher, dass Daten in der Tabelle vorhanden sind, indem Sie die folgende SQL-Anweisung verwenden. ``` SELECT count(*) FROM docs_lab_table; ``` 1. Identifizieren Sie diese DB-Instance von RDS für PostgreSQL wie folgt als Herausgeberknoten. ``` SELECT pglogical.create_node( node_name := 'docs_lab_provider', dsn := 'host=source-instance.aws-region.rds.amazonaws.com port=5432 dbname=labdb'); create_node ------------- 3410995529 (1 row) ``` 1. Fügen Sie die Tabelle, die Sie replizieren möchten, zum Standardreplikationssatz hinzu. Weitere Informationen zu Replikationssätzen finden Sie unter [Replikationssätze](https://github.com/2ndQuadrant/pglogical/tree/REL2_x_STABLE/docs#replication-sets) in der Dokumentation zur pglogical-Erweiterung. ``` SELECT pglogical.replication_set_add_table('default', 'docs_lab_table', 'true', NULL, NULL); replication_set_add_table --------------------------- t (1 row) ``` Die Einrichtung des Herausgeberknotens ist abgeschlossen. Sie können jetzt den Abonnentenknoten einrichten, um die Updates vom Herausgeber zu erhalten. **So richten Sie den Abonnentenknoten ein und erstellen ein Abonnement für den Empfang von Updates** Bei diesen Schritten wird vorausgesetzt, dass die DB-Instance von RDS für PostgreSQL mit der `pglogical`-Erweiterung eingerichtet wurde. Weitere Informationen finden Sie unter [Einrichten der pglogical-Erweiterung](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md). 1. Verwenden Sie `psql`, um sich mit der Instance zu verbinden, die Updates vom Herausgeber erhalten soll. ``` psql --host=target-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Erstellen Sie auf der DB-Instance von RDS für PostgreSQL des Abonnenten dieselbe Tabelle, die auf dem Herausgeber vorhanden ist. In diesem Beispiel heißt die Tabelle `docs_lab_table`. Sie können die Tabelle wie folgt erstellen. ``` CREATE TABLE docs_lab_table (a int PRIMARY KEY); ``` 1. Stellen Sie sicher, dass diese Tabelle leer ist. ``` SELECT count(*) FROM docs_lab_table; count ------- 0 (1 row) ``` 1. Identifizieren Sie diese DB-Instance von RDS für PostgreSQL wie folgt als Abonnentenknoten. ``` SELECT pglogical.create_node( node_name := 'docs_lab_target', dsn := 'host=target-instance.aws-region.rds.amazonaws.com port=5432 sslmode=require dbname=labdb user=postgres password=********'); create_node ------------- 2182738256 (1 row) ``` 1. Erstellen Sie das Abonnement. ``` SELECT pglogical.create_subscription( subscription_name := 'docs_lab_subscription', provider_dsn := 'host=source-instance.aws-region.rds.amazonaws.com port=5432 sslmode=require dbname=labdb user=postgres password=*******', replication_sets := ARRAY['default'], synchronize_data := true, forward_origins := '{}' ); create_subscription --------------------- 1038357190 (1 row) ``` Wenn Sie diesen Schritt abschließen, werden die Daten aus der Tabelle des Herausgeberknotens in der Tabelle auf dem Abonnentenknoten erstellt. Mit der folgenden SQL-Abfrage können Sie überprüfen, ob dies der Fall ist. ``` SELECT count(*) FROM docs_lab_table; count ------- 5000 (1 row) ``` Ab diesem Zeitpunkt werden Änderungen, die an der Tabelle auf dem Herausgeberknoten vorgenommen wurden, auf die Tabelle auf dem Abonnentenknoten repliziert. # Wiederherstellung der logischen Replikation nach einem Hauptversions-Upgrade Bevor Sie ein Hauptversions-Upgrade einer DB-Instance von RDS für PostgreSQL durchführen können, die als Herausgeberknoten für die logische Replikation eingerichtet ist, müssen Sie alle Replikationsslots einschließlich der Slots löschen, die nicht aktiv sind. Wir empfehlen, Datenbanktransaktionen vorübergehend vom Herausgeberknoten umzuleiten, die Replikationsslots zu löschen, die DB-Instance von RDS für PostgreSQL zu aktualisieren und dann die Replikation erneut einzurichten und neu zu starten. Die Replikationsslots werden nur auf dem Herausgeberknoten gehostet. Der Abonnentenknoten von RDS für PostgreSQL hat in einem logischen Replikationsszenario keine Slots, die gelöscht werden könnten. Er kann jedoch nicht auf eine Hauptversion aktualisiert werden, solange er als Abonnentenknoten mit einem Abonnement beim Herausgeber vorgesehen ist. Bevor Sie den Abonnentenknoten von RDS für PostgreSQL aktualisieren, löschen Sie das Abonnement und den Knoten. Weitere Informationen finden Sie unter [Verwaltung logischer Replikationsslots für ](Appendix.PostgreSQL.CommonDBATasks.pglogical.handle-slots.md). ## Feststellen, dass die logische Replikation unterbrochen wurde Sie können feststellen, ob der Replikationsprozess unterbrochen wurde, indem Sie entweder den Herausgeberknoten oder den Abonnentenknoten wie folgt abfragen. **So überprüfen Sie den Herausgeberknoten** + Verwenden Sie `psql`, um eine Verbindung mit dem Herausgeberknoten herzustellen, und fragen Sie dann die `pg_replication_slots`-Funktion ab. Notieren Sie sich den Wert in der aktiven Spalte. Normalerweise wird `t` (true) zurückgegeben, was bedeutet, dass die Replikation aktiv ist. Wenn die Abfrage `f` (false) zurückgibt, ist dies ein Hinweis darauf, dass die Replikation an den Abonnenten gestoppt wurde. ``` SELECT slot_name,plugin,slot_type,active FROM pg_replication_slots; slot_name | plugin | slot_type | active -------------------------------------------+------------------+-----------+-------- pgl_labdb_docs_labcb4fa94_docs_lab3de412c | pglogical_output | logical | f (1 row) ``` **So überprüfen Sie den Abonnentenknoten** Auf dem Abonnentenknoten können Sie den Status der Replikation auf drei verschiedene Arten überprüfen. + Suchen Sie in den PostgreSQL-Protokollen auf dem Abonnentenknoten nach Fehlermeldungen. Das Protokoll identifiziert Fehler mit Meldungen, die den Exit-Code 1 enthalten, wie im Folgenden dargestellt. ``` 2022-07-06 16:17:03 UTC::@:[7361]:LOG: background worker "pglogical apply 16404:2880255011" (PID 14610) exited with exit code 1 2022-07-06 16:19:44 UTC::@:[7361]:LOG: background worker "pglogical apply 16404:2880255011" (PID 21783) exited with exit code 1 ``` + Fragen Sie die `pg_replication_origin`-Funktion ab. Stellen Sie mithilfe von `psql` eine Verbindung mit der Datenbank auf dem Abonnentenknoten her und fragen Sie die `pg_replication_origin`-Funktion wie folgt ab. ``` SELECT * FROM pg_replication_origin; roident | roname ---------+-------- (0 rows) ``` Die leere Ergebnismenge bedeutet, dass die Replikation unterbrochen wurde. Die Ausgabe sollte normalerweise folgendermaßen aussehen. ``` roident | roname ---------+---------------------------------------------------- 1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c (1 row) ``` + Fragen Sie die `pglogical.show_subscription_status`-Funktion wie im folgenden Beispiel veranschaulicht ab. ``` SELECT subscription_name,status,slot_name FROM pglogical.show_subscription_status(); subscription_name | status | slot_name ---====----------------+--------+------------------------------------- docs_lab_subscription | down | pgl_labdb_docs_labcb4fa94_docs_lab3de412c (1 row) ``` Diese Ausgabe zeigt, dass die Replikation unterbrochen wurde. Ihr Status lautet `down`. Normalerweise zeigt die Ausgabe den Status `replicating` an. Wenn Ihr logischer Replikationsprozess unterbrochen wurde, können Sie die Replikation wiederherstellen, indem Sie die folgenden Schritte ausführen. **So stellen Sie die logische Replikation zwischen Herausgeber- und Abonnentenknoten wieder her** Um die Replikation wiederherzustellen, trennen Sie zuerst den Abonnenten vom Herausgeberknoten und richten dann das Abonnement erneut ein, wie in diesen Schritten beschrieben. 1. Stellen Sie mit `psql` wie folgt eine Verbindung zum Abonnentenknoten her. ``` psql --host=222222222222.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb ``` 1. Deaktivieren Sie das Abonnement, indem Sie die `pglogical.alter_subscription_disable`-Funktion verwenden. ``` SELECT pglogical.alter_subscription_disable('docs_lab_subscription',true); alter_subscription_disable ---------------------------- t (1 row) ``` 1. Rufen Sie die ID des Herausgeberknotens ab, indem Sie `pg_replication_origin` wie folgt abfragen. ``` SELECT * FROM pg_replication_origin; roident | roname ---------+------------------------------------- 1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c (1 row) ``` 1. Verwenden Sie die Antwort aus dem vorherigen Schritt mit dem `pg_replication_origin_create`-Befehl, um die ID zuzuweisen, die vom Abonnement verwendet werden kann, wenn es erneut eingerichtet wurde. ``` SELECT pg_replication_origin_create('pgl_labdb_docs_labcb4fa94_docs_lab3de412c'); pg_replication_origin_create ------------------------------ 1 (1 row) ``` 1. Aktivieren Sie das Abonnement, indem Sie seinen Namen mit dem Status `true` übergeben, wie im folgenden Beispiel veranschaulicht. ``` SELECT pglogical.alter_subscription_enable('docs_lab_subscription',true); alter_subscription_enable --------------------------- t (1 row) ``` Prüfen Sie den Status des Knotens. Sein Status sollte `replicating` wie in diesem Beispiel gezeigt lauten. ``` SELECT subscription_name,status,slot_name FROM pglogical.show_subscription_status(); subscription_name | status | slot_name -------------------------------+-------------+------------------------------------- docs_lab_subscription | replicating | pgl_labdb_docs_lab98f517b_docs_lab3de412c (1 row) ``` Überprüfen Sie den Status des Replikationsslots des Abonnenten auf dem Herausgeberknoten. Die `active`-Spalte des Slots sollte den Wert `t` (true) zurückgeben, was darauf hinweist, dass die Replikation wiederhergestellt wurde. ``` SELECT slot_name,plugin,slot_type,active FROM pg_replication_slots; slot_name | plugin | slot_type | active -------------------------------------------+------------------+-----------+-------- pgl_labdb_docs_lab98f517b_docs_lab3de412c | pglogical_output | logical | t (1 row) ``` # Verwaltung logischer Replikationsslots für Bevor Sie ein Hauptversions-Upgrade einer DB-Instance von RDS für PostgreSQL durchführen können, die als Herausgeberknoten in einem logischen Replikationsszenario eingerichtet ist, müssen Sie alle Replikationsslots auf der Instance löschen. Bei der Vorabüberprüfung des Hauptversions-Upgrades werden Sie darüber informiert, dass das Upgrade erst fortgesetzt werden kann, wenn die Slots gelöscht wurden. Um Slots aus Ihrer DB-Instance von RDS für PostgreSQL zu entfernen, löschen Sie zuerst das Abonnement und dann den Slot. Um Replikationsslots zu identifizieren, die mit der `pglogical`-Erweiterung erstellt wurden, melden Sie sich bei jeder Datenbank an und rufen Sie die Namen der Knoten ab. Wenn Sie den Abonnentenknoten abfragen, erhalten Sie in der Ausgabe sowohl den Herausgeber- als auch den Abonnentenknoten, wie in diesem Beispiel gezeigt. ``` SELECT * FROM pglogical.node; node_id | node_name ------------+------------------- 2182738256 | docs_lab_target 3410995529 | docs_lab_provider (2 rows) ``` Die Details zum Abonnement erhalten Sie mit der folgenden Abfrage. ``` SELECT sub_name,sub_slot_name,sub_target FROM pglogical.subscription; sub_name | sub_slot_name | sub_target ----------+--------------------------------+------------ docs_lab_subscription | pgl_labdb_docs_labcb4fa94_docs_lab3de412c | 2182738256 (1 row) ``` Sie können das Abonnement jetzt wie folgt kündigen. ``` SELECT pglogical.drop_subscription(subscription_name := 'docs_lab_subscription'); drop_subscription ------------------- 1 (1 row) ``` Nachdem Sie das Abonnement gekündigt haben, können Sie den Knoten löschen. ``` SELECT pglogical.drop_node(node_name := 'docs-lab-subscriber'); drop_node ----------- t (1 row) ``` Sie können wie folgt überprüfen, dass der Knoten nicht mehr existiert. ``` SELECT * FROM pglogical.node; node_id | node_name ---------+----------- (0 rows) ``` # Parameterreferenz für die pglogical-Erweiterung In der Tabelle finden Sie Parameter, die der `pglogical`-Erweiterung zugeordnet sind. Parameter wie `pglogical.conflict_log_level` und `pglogical.conflict_resolution` werden verwendet, um Aktualisierungskonflikte zu beheben. Konflikte können auftreten, wenn Änderungen lokal an denselben Tabellen vorgenommen werden, die Änderungen vom Herausgeber abonniert haben. Konflikte können auch in verschiedenen Szenarien auftreten, z. B. bei der bidirektionalen Replikation oder wenn mehrere Abonnenten vom selben Herausgeber replizieren. Weitere Informationen finden Sie unter [Die bidirektionale PostgreSQL-Replikation mit pglogical](https://aws.amazon.com/blogs/database/postgresql-bi-directional-replication-using-pglogical/). | Parameter | Description | | --- | --- | | pglogical.batch\$1inserts | Batch-Inserts wenn möglich Standardmäßig nicht festgelegt. In '1' ändern zum Einschalten, in '0' zum Ausschalten. | | pglogical.conflict\$1log\$1level | Legt die Protokollstufe für die Protokollierung gelöster Konflikte fest. Unterstützte Zeichenfolgenwerte sind debug5, debug4, debug3, debug2, debug1, info, notice, warning, error, log, fatal, panic. | | pglogical.conflict\$1resolution | Legt die Methode fest, die verwendet werden soll, um Konflikte zu lösen, die lösbar sind. Unterstützte Zeichenfolgenwerte sind error, apply\$1remote, keep\$1local, last\$1update\$1wins, first\$1update\$1wins. | | pglogical.extra\$1connection\$1options | Verbindungsoptionen zum Hinzufügen zu allen Peer-Knotenverbindungen | | pglogical.synchronous\$1commit | Spezifischer synchroner Commit-Wert für pglogical | | pglogical.use\$1spi | Verwenden Sie zum Anwenden von Änderungen SPI (Server Programming Interface) anstelle der Low-Level-API. In '1' ändern zum Einschalten, in '0' zum Ausschalten. Weitere Informationen zu SPI finden Sie unter [Server Programming Interface](https://www.postgresql.org/docs/current/spi.html) in der PostgreSQL-Dokumentation. |