Datenbanken für PostgreSQL als Ziel für die logische Replikation

IBM Cloud® Databases for PostgreSQL unterstützt die logische Replikation, bei der Sie einen Abonnenten oder einen Verleger erstellen können. Sie können auch Ihre externe PostgreSQL als Herausgeber und Ihre Databases for PostgreSQL-Bereitstellung als Abonnent einrichten und Ihre Daten aus einer externen Datenbank in Ihre Bereitstellung replizieren.

Logische Replikation ist nur für Bereitstellungen verfügbar, in denen PostgreSQL 10 oder höher ausgeführt wird. Links zur PostgreSQL-Dokumentation führen Sie zur aktuellen Version von PostgreSQL. Wenn Sie Dokumentation für eine bestimmte Version benötigen, finden Sie auf der Dokumentationsseite PostgreSQL Links zu verschiedenen PostgreSQL-Versionen.

Veröffentlichungsberechtigten konfigurieren

Die externe PostgreSQL-Instanz ist der Veröffentlichungsberechtigte und muss so konfiguriert werden, dass Ihre Databases for PostgreSQL-Bereitstellung Verbindungen herstellen und die Daten ordnungsgemäß extrahieren kann.

Verlagsfunktionen

create_publisher

In jeder Datenbank können Sie mehrere Publikationen erstellen, um die Änderungen für einen anderen Abonnenten zu veröffentlichen.

Arguments:

    publisher_name               The Unique name of publisher.
    for table                    To publish single/list of tables
    for all table                To publish all tables, along with future tables.
    for all tables in schema     To publish all tables in schema, along wth future tables.

Usage:
    exampledb=> create publication my_publication for all tables ;
    CREATE PUBLICATION

list_publisher

Listen Sie die Anzahl der Veröffentlichungen in jeder Datenbank auf.

Usage:
   exampledb=# select * from pg_publication;
   oid  |    pubname     | pubowner | puballtables | pubinsert | pubupdate | pubdelete | pubtruncate
   -------+----------------+----------+--------------+-----------+-----------+-----------+-------------
   16401 | my_publication |       10 | t            | t         | t         | t         | t

alter_publisher

Ändern Sie die Definition der Publikation.

Syntax:
ALTER PUBLICATION name ADD publication_object [, ...]
ALTER PUBLICATION name SET publication_object [, ...]
ALTER PUBLICATION name DROP publication_object [, ...]
ALTER PUBLICATION name SET ( publication_parameter [= value] [, ... ] )
ALTER PUBLICATION name OWNER TO { new_owner | CURRENT_ROLE | CURRENT_USER | SESSION_USER }
ALTER PUBLICATION name RENAME TO new_name


 Usage:
    exampledb=# ALTER PUBLICATION my_publication RENAME TO my_publication_new;
    ALTER PUBLICATION

drop_publisher

Legen Sie die nicht verwendete Publikation ab/entfernen Sie sie.

Usage:
    exampledb=# drop publication my_publication_new;
    DROP PUBLICATION

Betrachten Sie Folgendes als Voraussetzungen:

Konfigurieren Sie die externe (Herausgeber-) PostgreSQL wal_level=logical.
Jeder für die Replikation ausgewählte Tisch muss einen Primärschlüssel enthalten oder über einen REPLICA IDENTITY festgelegt.
Ihr externer (Publisher) PostgreSQL muss über einen Replikationsbenutzer verfügen, der über die Berechtigung PostgreSQL REPLICATION verfügt. Dieser Benutzer muss über SELECT- und USAGE-Berechtigungen für die Datenbanken sowie über REPLICATION-Berechtigungen verfügen.
Für die PostgreSQL, die Sie replizieren, muss TLS/SSL aktiviert sein.
Externen (Publisher-)Replikationsbenutzern PostgreSQL BYPASSRLS-Berechtigungen erteilen, wenn die Sicherheit auf Zeilenebene aktiviert ist.

Es gibt inhärente Einschränkungen und einige Beschränkungen für die logische Replikation, die in der PostgreSQL-Dokumentation beschrieben sind. Sehen Sie sich diese an, bevor Sie entscheiden, ob eine logische Replikation für Ihren Anwendungsfall geeignet ist.

Abonnenten konfigurieren

Um Ihren Databases for PostgreSQL Einsatz zu konfigurieren und sicherzustellen, dass Ihre Daten korrekt repliziert werden, müssen Sie Folgendes beachten.

Sie müssen eine Datenbank in Ihrer Bereitstellung mit demselben Namen wie die Datenbank erstellen, die Sie replizieren möchten.
Logische Replikation funktioniert auf Tabellenebene, sodass jede Tabelle, die Sie zum Veröffentlichen auswählen, im Abonnenten erstellt werden muss, bevor der Prozess der logischen Replikation gestartet wird. (Sie können pg_dump als Hilfe verwenden.) Die Tabelle für den Abonnenten muss nicht mit dem entsprechenden Veröffentlichungsberechtigten-Pendant identisch sein. Die Tabelle für den Abonnenten muss jedoch mindestens jede Spalte enthalten, die auch in der Tabelle für den Veröffentlichungsberechtigten enthalten ist. Zusätzliche Spalten, die im Abonnenten vorhanden sind, dürfen nicht NOT NULL oder andere Integritätsbedingungen enthalten. Tun sie es doch, schlägt die Replikation fehl.

Für native PostgreSQL-Abonnementbefehle sind Superuser-Berechtigungen erforderlich, die bei Databases for PostgreSQL-Bereitstellungen nicht verfügbar sind. Stattdessen enthält Ihre Bereitstellung eine Reihe von Funktionen, die zum Festlegen und Verwalten der logischen Replikation für das Abonnement verwendet werden können.

Nur der Benutzer mit Administratorberechtigung, der von Databases for PostgreSQL bereitgestellt wird, verfügt über die Berechtigungen zum Ausführen der folgenden Replikationsbefehle, die es Ihnen ermöglichen, Inhalte von einem externen PostgreSQL-Veröffentlichungsberechtigten zu abonnieren und zu replizieren.

Abonnentenfunktionen

create_subscription

Arguments:
    subscription_name   Unique name to create the subscription channel with
    host_ip             Publisher hostname or public IP address
    port                Port number publisher is running on
    username            `admin` user created on the publisher
    password            Password of the `admin` user on the publisher
    db_name             The name of the database to be replicated
    publisher_name      The name of publisher channel on the publisher

Usage:
    exampledb=> SELECT create_subscription('subs1','130.215.223.184','5432','password','admin','exampledb','my_publication');

delete_subscription

Arguments:
    subscription_name   Name the subscription channel to delete
    db_name             The name of the replicated database

Usage:
exampledb=> SELECT delete_subscription('subs1', 'exampledb');

list_subscriptions

Arguments:
    None

Usage:
    exampledb=> SELECT * FROM list_subscriptions();

disable_subscription

Arguments:
    subscription_name   Name the subscription channel to disable
    db_name             The name of the replicated database

Usage:
    exampledb=> SELECT disable_subscription('subs1','exampledb');

enable_subscription

Arguments:
    subscription_name   Name the subscription channel to enable
    db_name             The name of the replicated database

Usage:
    exampledb=> SELECT enable_subscription('subs1','exampledb');

subscription_slot_none

Diese Funktion wird verwendet, um den Slotnamen eines Abonnements auf NONE zu setzen. Dies ist erforderlich, um ein Abonnement zu löschen, damit ein entfernter Replikationsslot nicht gelöscht werden kann oder nicht existiert bzw. nie existiert hat.

Arguments:
    subscription_name   Name the subscription channel to alter
    db_name             The name of the replicated database

Usage:
    exampledb=> SELECT subscription_slot_none('subs1','exampledb');

refresh_subscription

Diese Funktion wird verwendet, um ein Abonnement für den Abonnenten zu aktualisieren, nachdem Änderungen am Veröffentlichungsberechtigten vorgenommen wurden, wie z. B. das Hinzufügen oder Entfernen einer Tabelle.

Arguments:
    subscription_name   Name the subscription channel to refresh
    db_name             The name of the replicated database

Usage:
    exampledb=> SELECT refresh_subscription('subs1','exampledb');

Logische Replikation für den Veröffentlichungsberechtigten einrichten

Um Ihr externes PostgreSQL als Publisher zu konfigurieren, führen Sie die folgenden Schritte aus.

Bearbeiten Sie Ihre lokale pg_hba.conf und fügen Sie Folgendes hinzu.
```
hostssl    replication            replicator         0.0.0.0/0      md5
hostssl    all                    replicator         0.0.0.0/0      md5
```
Das "Replikator"-Feld ist der Benutzer, den Sie mit der Berechtigung PostgreSQL REPLICATION eingerichtet haben.
Bearbeiten Sie Ihre lokale postgresql.conf mit der erforderlichen logischen Replikationskonfiguration. Legen Sie wal_level auf 'logical' und listen_addresses='*' so fest, dass Verbindungen von einem beliebigen Host akzeptiert werden.
```
listen_addresses='*'
wal_level = logical
```
Starten Sie den PostgreSQL-Server erneut.

Jetzt können Sie einen Publisher für die Datenbank definieren und die Tabellen hinzufügen, die Sie auf den Subskribenten replizieren wollen.

Melden Sie sich bei der Datenbank, aus der Sie veröffentlichen möchten, mit Ihrem Replikationsbenutzer an.
```
psql -U replicator -d exampledb
```

Erstellen Sie den Veröffentlichungskanal.

exampledb=> CREATE PUBLICATION my_publication;

Fügen Sie dem Veröffentlichungsberechtigten Tabellen hinzu.
```
exampledb=> ALTER PUBLICATION my_publication ADD TABLE my_table;
```
Die Anzahl der Worker, die die Synchronisation unterstützen, die durch den Konfigurationsparameter max_logical_replication_workers definiert ist, ist begrenzt und kann nicht geändert werden. Verwenden Sie daher so wenig Veröffentlichungen wie möglich und fügen Sie so viele Tabellen wie möglich in eine Veröffentlichung ein.

Logische Replikation für den Abonnenten einrichten

Um Ihre Databases for PostgreSQL Bereitstellung als Abonnent zu konfigurieren, führen Sie die folgenden Schritte aus.

Melden Sie sich bei der Datenbank, die für die Replikation erstellt wurde, als admin-Benutzer an.
```
psql -U admin -d exampledb
```

Führen Sie die folgende Abfrage aus, um de Funktion create_subscription aufzurufen und den Abonnentenkanal zu erstellen.

exampledb=> SELECT create_subscription('subs1','130.215.223.184','5432','admin','password','exampledb','my_publication');

Replikation überwachen

Sie können den Status der logischen Replikation sowohl vom Veröffentlichungsberechtigten als auch vom Abonnenten aus überwachen, indem Sie die folgende Abfrage für einen der beiden ausführen.

exampledb=> SELECT * FROM pg_stat_replication;