Anforderungen und Einschränkungen Einrichten der pglogical-Erweiterung Einrichten der logischen Replikation Wiederherstellung der logischen Replikation nach einem Upgrade Verwalten von logischen Replikationsslots Parameterreferenz für pglogical-Erweiterungsparameter

Verwenden von pglogical, um Daten zwischen Instances zu synchronisieren

Alle derzeit verfügbaren Aurora SQL Postgre-Versionen RDS unterstützen die pglogical Erweiterung. Die Erweiterung pglogical ist älter als die funktional ähnliche logische Replikationsfunktion, die von Postgre in Version 10 eingeführt wurde. SQL Weitere Informationen finden Sie unter Überblick über die SQL logische Postgre-Replikation mit Aurora.

Die pglogical Erweiterung unterstützt die logische Replikation zwischen zwei oder mehr Aurora SQL Postgre-DB-Clustern. Es unterstützt auch die Replikation zwischen verschiedenen SQL Postgre-Versionen und zwischen Datenbanken, die auf RDS SQL Postgre-DB-Instances und Aurora Postgre-DB-Clustern laufen. SQL 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 Publisher-Knoten ist der Aurora SQL Postgre-DB-Cluster RDS , der 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 der Aurora SQL Postgre-DB-Cluster RDS , der WAL Updates vom Herausgeber erhält. Der Abonnent erstellt ein Abonnement, um eine Verbindung zum Herausgeber herzustellen und die WAL dekodierten 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.

Themen

Anforderungen und Einschränkungen für die pglogical-Erweiterung
Einrichten der pglogical-Erweiterung
Einrichtung der logischen Replikation für den Aurora SQL Postgre-DB-Cluster
Wiederherstellung der logischen Replikation nach einem Hauptversions-Upgrade
Verwaltung logischer Replikationssteckplätze für Aurora Postgre SQL RDS Postgre SQL
Parameterreferenz für die pglogical-Erweiterung

Anforderungen und Einschränkungen für die pglogical-Erweiterung

Alle derzeit verfügbaren Versionen von Aurora Postgre SQL RDS 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 von einem Herausgeber auf einen Abonnenten 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. Es wird empfohlen, nur die PRIMARY KEY als eindeutige Einschränkung zu verwenden.

Die Tabellen auf dem Abonnentenknoten können für Einschränkungen und NOT NULL Einschränkungen mehr Zulässigkeit aufweisen als für CHECK die Tabellen auf dem Herausgeberknoten.

Die pglogical Erweiterung bietet Funktionen wie die bidirektionale Replikation, die von der in Postgre SQL (Version 10 und höher) integrierten Funktion für logische Replikation nicht unterstützt werden. Weitere Informationen finden Sie unter SQLBidirektionale Postgre-Replikation mit pglogical.

Einrichten der pglogical-Erweiterung

Um die pglogical Erweiterung auf Ihrem Aurora Postgre-DB-Cluster einzurichten, fügen Sie sie pglogical zu den Shared Libraries in der benutzerdefinierte DB-Cluster-Parametergruppe für Ihren Aurora SQL Postgre-DB-Cluster. 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 Management Console oder die AWS CLI für diese Aufgaben.

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 Ihr Aurora SQL Postgre-DB-Cluster RDS einer benutzerdefinierten zugeordnet ist. Weitere Informationen über das Erstellen einer benutzerdefinierten DB-Cluster-Parametergruppe finden Sie unter Parametergruppen für Amazon Aurora.

So richten Sie die pglogical-Erweiterung ein

Melden Sie sich an bei AWS Management Console und öffnen Sie die RDS Amazon-Konsole unter https://console.aws.amazon.com/rds/.
Wählen Sie im Navigationsbereich die Writer-Instance Ihres Aurora SQL Postgre-DB-Clusters aus.
Öffnen Sie die Registerkarte Konfiguration für Ihre Aurora SQL Postgre-DB-Cluster-Writer-Instance. Suchen Sie in den Instance-Details den Link Parameter group (Parametergruppe).
Wählen Sie den Link, um die benutzerdefinierten Parameter zu öffnen, die mit Ihrem Aurora SQL Postgre-DB-Cluster verknüpft sind.
Geben Sie in das Suchfeld Parameters (Parameter) shared_pre ein, um den shared_preload_libraries-Parameter zu finden.
Wählen Sie Edit parameters (Parameter bearbeiten) aus, um auf die Eigenschaftswerte zuzugreifen.
Fügen Sie pglogical der Liste im Feld Values (Werte) hinzu. Verwenden Sie ein Komma, um Elemente in der Werteliste zu trennen.
Suchen Sie den rds.logical_replication-Parameter und legen Sie ihn auf 1 fest, um die logische Replikation zu aktivieren.
Starten Sie die Writer-Instance Ihres Aurora SQL Postgre-DB-Clusters RDS neu, damit Ihre Änderungen wirksam werden.
Wenn die Instance verfügbar ist, können Sie psql (oderpgAdmin) verwenden, um eine Verbindung zur Writer-Instance Ihres Aurora SQL Postgre-DB-Clusters herzustellen.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```

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)

Überprüfen Sie die Einstellung, die die logische Dekodierung ermöglicht, wie folgt.
```
SHOW wal_level;
wal_level
-----------
 logical
(1 row)
```

Erstellen Sie die Erweiterung wie folgt.


CREATE EXTENSION pglogical;
EXTENSION CREATED

Wählen Sie Änderungen speichern.
Öffnen Sie die RDS Amazon-Konsole unter https://console.aws.amazon.com/rds/.
Wählen Sie die Writer-Instance Ihres Aurora SQL Postgre-DB-Clusters RDS aus der Datenbankliste aus, um sie auszuwählen, und wählen Sie dann im Menü Aktionen die Option Reboot aus.

So richten Sie die pglogical-Erweiterung ein

Um pglogical einzurichten, verwenden Sie den AWS CLI, rufen Sie die modify-db-parameter-groupOperation auf, um bestimmte Parameter in Ihrer benutzerdefinierten Parametergruppe zu ändern, wie im folgenden Verfahren gezeigt.

Verwenden Sie Folgendes AWS CLI Befehl zum Hinzufügen pglogical zum shared_preload_libraries Parameter.


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

Verwenden Sie Folgendes AWS CLI Befehl, auf den gesetzt werden 1 soll, rds.logical_replication um die logische Dekodierungsfunktion für die Writer-Instance des Aurora SQL Postgre-DB-Clusters einzuschalten.


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

Verwenden Sie Folgendes AWS CLI Befehl zum Neustarten der Writer-Instance Ihres Aurora SQL Postgre-DB-Clusters RDS , sodass die pglogische Bibliothek initialisiert wird.
```
aws rds reboot-db-instance \
    --db-instance-identifier writer-instance \
    --region aws-region
```
Wenn die Instance verfügbar ist, verwenden Sie psql sie, um eine Verbindung zur Writer-Instance Ihres Aurora SQL Postgre-DB-Clusters herzustellen.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```

Erstellen Sie die Erweiterung wie folgt.


CREATE EXTENSION pglogical;
EXTENSION CREATED

Starten Sie die Writer-Instance Ihres Aurora SQL Postgre-DB-Clusters RDS neu: AWS CLI Befehl.


aws rds reboot-db-instance \
    --db-instance-identifier writer-instance \
    --region aws-region

Einrichtung der logischen Replikation für den Aurora SQL Postgre-DB-Cluster

Das folgende Verfahren zeigt Ihnen, wie Sie die logische Replikation zwischen zwei Aurora SQL Postgre-DB-Clustern 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 beschrieben.

So erstellen Sie den Herausgeberknoten und die zu replizierenden Tabellen

Bei diesen Schritten wird davon ausgegangen, dass Ihr Aurora SQL Postgre-DB-Cluster über eine Writer-Instance mit einer Datenbank RDS 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 psq1-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.

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 Anweisung eine Beispieltabelle. SQL
```
CREATE TABLE docs_lab_table (a int PRIMARY KEY);
```
2. Füllen Sie die Tabelle mit generierten Daten auf, indem Sie die folgende SQL Anweisung verwenden.
```
INSERT INTO docs_lab_table VALUES (generate_series(1,5000));
INSERT 0 5000
```
3. Stellen Sie mithilfe der folgenden SQL Anweisung sicher, dass Daten in der Tabelle vorhanden sind.
```
SELECT count(*) FROM docs_lab_table;
```

Identifizieren Sie diesen Aurora SQL Postgre-DB-Cluster RDS wie folgt als Publisher-Knoten.


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)

Fügen Sie die Tabelle, die Sie replizieren möchten, zum Standardreplikationssatz hinzu. Weitere Informationen zu Replikationssätzen finden Sie unter Replikationssätze 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 davon ausgegangen, dass der Aurora SQL Postgre-DB-Cluster RDS mit der pglogical Erweiterung eingerichtet wurde. Weitere Informationen finden Sie unter Einrichten der pglogical-Erweiterung.

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

Erstellen Sie auf dem SQLAbonnenten-Aurora-Postgre-DB-Cluster RDS dieselbe Tabelle, die auf dem Publisher 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);
```

Stellen Sie sicher, dass diese Tabelle leer ist.


SELECT count(*) FROM docs_lab_table;
 count
-------
  0
(1 row)

Identifizieren Sie diesen Aurora SQL Postgre-DB-Cluster RDS 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)

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. Mithilfe 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 eines Aurora SQL Postgre-DB-Clusters durchführen können, der als Publisher-Knoten für die logische Replikation eingerichtet ist, müssen Sie alle Replikationssteckplätze löschen, auch die, die nicht aktiv sind. Es wird empfohlen, Datenbanktransaktionen vorübergehend vom Herausgeberknoten umzuleiten, die Replikationsslots zu löschen, den Aurora SQL Postgre-DB-Cluster zu aktualisieren, die RDS for SQL Postgre-DB-Instance Replikation erneut einzurichten und neu zu starten.

Die Replikationsslots werden nur auf dem Herausgeberknoten gehostet. Der Aurora SQL Postgre-Abonnentenknoten in einem logischen Replikationsszenario hat keine Steckplätze zum Löschen. Der Upgrade-Prozess für die SQL Hauptversion von Aurora Postgre unterstützt das Upgrade des Abonnenten auf eine neue Hauptversion von Postgre SQL unabhängig vom Herausgeberknoten. Der Upgrade-Prozess unterbricht jedoch den Replikationsprozess und beeinträchtigt die Synchronisation von WAL Daten zwischen Herausgeberknoten und Abonnentenknoten. Sie müssen die logische Replikation zwischen Herausgeber und Abonnent wiederherstellen, nachdem Sie den Herausgeber, den Abonnenten oder beide aktualisiert haben. Im folgenden Verfahren wird gezeigt, wie Sie feststellen, ob die Replikation unterbrochen wurde, und wie Sie das Problem beheben.

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 SQL Postgre-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.

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

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)

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)

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)
```

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 Replikationssteckplätze für Aurora Postgre SQL RDS Postgre SQL

Bevor Sie ein Hauptversions-Upgrade auf der Writer-Instance eines Aurora SQL Postgre-DB-Clusters RDS durchführen können, die in einem logischen Replikationsszenario als Publisher-Knoten dient, müssen Sie die 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 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 SQLBidirektionale Postgre-Replikation mit pglogical.

Parameter	Beschreibung
pglogical.batch_inserts	Batch-Inserts wenn möglich Standardmäßig nicht festgelegt. In '1' ändern zum Einschalten, in '0' zum Ausschalten.
pglogical.conflict_log_level	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_resolution	Legt die Methode fest, die verwendet werden soll, um Konflikte zu lösen, die lösbar sind. Unterstützte Zeichenfolgenwerte sind error, apply_remote, keep_local, last_update_wins, first_update_wins.
pglogical.extra_connection_options	Verbindungsoptionen zum Hinzufügen zu allen Peer-Knotenverbindungen
pglogical.synchronous_commit	Spezifischer synchroner Commit-Wert für pglogical
pglogical.use_spi	Verwenden Sie SPI (Server-Programmierschnittstelle) anstelle von Low-Level, um Änderungen vorzunehmen. API In '1' ändern zum Einschalten, in '0' zum Ausschalten. Weitere Informationen zu SPI finden Sie unter Server Programming Interface in der Postgre-Dokumentation. SQL

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Referenz für pgAudit Erweiterungsparameter

Weiter