Einrichten der PostgreSQL-Replikation unter Debian 11

PostgreSQL ist ein freies und quelloffenes Datenbankmanagementsystem, das sich auf Erweiterbarkeit und SQL-Konformität konzentriert. PostgreSQL ist ein fortschrittliches RDBMS (Relational Database Management System) der Unternehmensklasse, das sowohl SQL- (relationale) als auch JSON-Abfragen (nicht-relationale) unterstützt.

Es ist ein hochstabiles und unternehmenstaugliches Datenbankmanagementsystem, das verschiedene Lösungen für Hochverfügbarkeit und Failover bietet. PostgreSQL wird als primäre Datenbank für Webanwendungen, mobile Anwendungen und analytische Anwendungen eingesetzt. Es ist bekannt für seine Zuverlässigkeit, Flexibilität, Robustheit und Leistung.

In diesem Lernprogramm werde ich die logische Replikation des PostgreSQL-Datenbank-Servers über pglogical2 auf zwei Debian 11-Servern installieren und einrichten. Du installierst den PostgreSQL-Server mit dem Erweiterungspaket pglogical und richtest dann die Replikation zwischen zwei oder mehr PostgreSQL-Servern ein.

pglogical ist eine Erweiterung von PostgreSQL, mit der du eine logische Streaming-Replikation auf Datenbankebene einrichten kannst. Sie verwendet das Publish/Subscribe-Modell für die Replikation. Mit der pglogical-Erweiterung replizierst du nicht die verfügbaren Daten auf PostgreSQL, sondern du replizierst und synchronisierst bestimmte Tabellen auf deiner verfügbaren Datenbank auf andere PostgreSQL-Server.

Voraussetzungen

Um diese Anleitung auszuführen, musst du die folgenden Voraussetzungen erfüllen:

• Zwei oder mehr Debian 11 Server.
• Einen Nicht-Root-Benutzer mit sudo/root-Administrator-Rechten.

In diesem Beispiel werden zwei Debian-Server mit den folgenden Details verwendet:

Hostname    IP Address      Used as
------------------------------------------
pgdg01      192.168.5.25    Publisher Node
pgdg02      192.168.5.26    Subscriber Node

Wenn die Server bereit sind, kannst du nun die Installation und Konfiguration von PostgreSQL Replication über pglogical starten.

Einrichten von /etc/hosts und PostgreSQL Repository

In diesem Beispiel wird davon ausgegangen, dass du frische Debian 11 Server verwendest. Daher musst du als erstes das PostgreSQL Repository einrichten und PostgreSQL auf allen deinen Debian Systemen installieren.

Du musst die folgenden Schritte auf allen deinen Debian-Servern ausführen.

Öffne zunächst die Konfigurationsdatei „/etc/hosts“ mit dem folgenden nano-Editor-Befehl.

sudo nano /etc/hosts

Füge die folgenden Zeilen in die Datei ein und achte darauf, dass du die Details der IP-Adressen und Hostnamen änderst.

192.168.5.25    pgdg01
192.168.5.26    pgdg02

Speichere und schließe die Datei „/etc/hosts“, wenn du fertig bist.

Als Nächstes gibst du den folgenden apt-Befehl ein, um einige grundlegende Abhängigkeiten zu installieren. Gib y ein, wenn du dazu aufgefordert wirst und drücke ENTER, um fortzufahren.

sudo apt install wget gnupg2 lsb-release curl apt-transport-https ca-certificates

Führe nun den folgenden Befehl aus, um den PostgreSQL GPG-Schlüssel und das Repository für Debian-Server hinzuzufügen.

curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/pgdg.gpg > /dev/null 2>&1
sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/pgdg.gpg] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'

Aktualisiere dann deinen Paketindex, um die Änderungen zu übernehmen.

sudo apt update

Nach dem Hinzufügen solltest du das PostgreSQL-Repository in der Liste sehen.

Nachdem du das PostgreSQL-Repository hinzugefügt hast, installierst du als Nächstes den PostgreSQL-Server und die pglogical-Erweiterung.

Installation von PostgreSQL und der pglogical-Erweiterung

Das offizielle PostgreSQL-Repository bietet standardmäßig mehrere Versionen von PostgreSQL an, z. B. PostgreSQL 13, 14 und 15. In diesem Beispiel wirst du die PostgreSQL-Replikation mit der neuesten Version von PostgreSQL 15 installieren und einrichten.

Gib den folgenden„apt install„-Befehl ein, um den PostgreSQL-Server zu installieren. Gib y ein, um die Installation zu bestätigen und drücke ENTER, um fortzufahren.

sudo apt install postgresql

Wenn die Installation abgeschlossen ist, gib den folgenden systemctl-Befehl ein, um den PostgreSQL-Server zu überprüfen und sicherzustellen, dass der Dienst aktiviert ist und läuft.

sudo systemctl is-enabled postgresql
sudo systemctl status postgresql

Die Ausgabe„enabled“ bestätigt, dass der PostgreSQL-Dienst aktiviert ist und beim Start des Systems automatisch gestartet wird. Und die Ausgabe„active (running)“ bestätigt, dass der aktuelle PostgreSQL-Dienst läuft.

Als Nächstes gibst du den folgenden apt-Befehl ein, um das Erweiterungspaket pglogical zu installieren. Wenn du eine andere Version von PostgreSQL verwendest, solltest du die Paketnummer ersetzen, z. B.„postgresql-version-pglogical“.

sudo apt install postgresql-15-pglogical

Gib y ein, wenn du dazu aufgefordert wirst, und drücke ENTER, um fortzufahren.

Wenn PostgreSQL läuft und die pglogical-Erweiterung installiert ist. Jetzt kannst du mit der Konfiguration der logischen Streaming-Replikation mit pglogical beginnen.

Einrichten der UFW-Firewall

Bevor du die PostgreSQL-Server konfigurierst, musst du nun die ufw-Firewall einrichten, die die Verbindung zu deinem PostgreSQL-Server sichert und begrenzt. Damit hast du nur noch eine Verbindung aus deinen vertrauenswürdigen Netzwerken, die durch deinen PostgreSQL-Einsatz gesichert ist.

Um ufw zu installieren, gibst du den folgenden apt-Befehl ein. Wenn du dazu aufgefordert wirst, gib y zur Bestätigung ein und drücke ENTER, um fortzufahren.

sudo apt install ufw

Als nächstes gibst du den folgenden ufw-Befehl ein, um den OpenSSH-Dienst zu öffnen. Die Ausgabe „Rule added“ bestätigt, dass die neue Regel zu ufw hinzugefügt wurde.

sudo ufw allow OpenSSH

Gib nun den folgenden ufw-Befehl ein, um deinen vertrauenswürdigen Netzwerken den Zugriff auf den PostgreSQL-Server 5432 zu erlauben. Achte darauf, dass du die IP-Adresse in dem folgenden Befehl änderst.

sudo ufw allow from 192.168.5.0/24 to any port 5432

Als Nächstes gibst du den folgenden Befehl ein, um die ufw-Firewall zu starten und zu aktivieren. Wenn du zur Bestätigung aufgefordert wirst, gib y ein und drücke ENTER, um fortzufahren.

sudo ufw enable

Die Ausgabe„Firewall läuft und ist aktiviert“ bestätigt, dass die ufw läuft und auch aktiviert ist, was bedeutet, dass die ufw Firewall beim Systemstart automatisch startet.

Du kannst nun den Status und die Liste der aktivierten Ports der ufw überprüfen, indem du den folgenden Befehl eingibst.

sudo ufw status

Du solltest sehen, dass die ufw-Firewall „Status: Active‘ mit dem OpenSSH-Dienst und dem PostgreSQL-Server-Port‚5432‚, die in der ufw-Firewall verfügbar sind.

Konfigurieren von PostgreSQL zur Aktivierung der Replikation

WAL oder Write-Ahead Logging ist eine Methode, die die Datenintegrität auf dem PostgreSQL-Server sicherstellt. Alle Änderungen an Tabellen und Indizes müssen erst geschrieben werden, nachdem diese Änderungen protokolliert wurden.

In PostgreSQL gibt es drei WAL-Methoden, die du verwenden kannst, um die Replikation zu aktivieren.

• Die Standard-WAL-Einstellung ist„Replica„, mit der du die Archivierung und Replikation einrichten und schreibgeschützte Abfragen auf dem Standby-Server ausführen kannst.
• Mit derminimalen Methode kannst du die gesamte Protokollierung entfernen, mit Ausnahme einiger wichtiger Informationen, die bei einem Absturz oder einem sofortigen Herunterfahren wiederhergestellt werden müssen.
• Die logische Methode ermöglicht es dir, einige Informationen zur WAL hinzuzufügen, die eine logische Dekodierung unterstützen.

In diesem Abschnitt richtest du PostgreSQL so ein, dass es auf der lokalen Netzwerk-IP-Adresse läuft, richtest die„logische“ WAL-Ebene über die Erweiterung„pglogical“ ein und aktivierst dann die Replikationsbenutzer über die Datei pg_hba.conf.

Melde dich in der PostgreSQL-Shell an, indem du den folgenden Befehl eingibst.

sudo -u postgres psql

Überprüfe dann die Standardkonfiguration „wal_level“ auf dem PostgreSQL-Server.

select name,setting,unit from pg_settings where name in ('wal_level','max_worker_processes','max_replication_slots','max_wal_senders','shared_preload_libraries','track_commit_timestamp');

Die folgende Ausgabe bestätigt, dass das Standard-Wal-Level auf dem PostgreSQL-Server„replica“ ist, was bei den heutigen PostgreSQL-Versionen Standard ist.

Gib nun „\q“ ein, um die PostgreSQL-Shell zu verlassen.

Als Nächstes öffnest du die standardmäßige PostgreSQL-Konfigurationsdatei„/etc/postgresql/15/main/postgresql.conf“ mit dem folgenden nano-Editor-Befehl.

sudo nano /etc/postgresql/15/main/postgresql.conf

Entferne die Markierung des Parameters „listen_addresses“ und füge die IP-Adresse deines internen Servers hinzu.

Nachfolgend siehst du die Konfiguration, die auf dem Server„pgdg01“ verwendet werden soll.

listen_addresses = 'localhost, 192.168.5.25'

Und unten ist die Konfiguration, die auf dem Server„pgdg02“ verwendet werden soll.

listen_addresses = 'localhost, 192.168.5.26'

Füge nun die folgenden Parameter hinzu, um die„logische“ Wal-Ebene über die Erweiterung „pglogical“ zu aktivieren. Beide Server haben eine ähnliche Konfiguration für die Einstellungen der Wal-Ebene. Der Parameter„shared_preload_libraries = ‚pglogical‚“ aktiviert die logische Wal-Ebene über die„pglogical„-Erweiterung.

max_worker_processes = 10
shared_preload_libraries = 'pglogical'
track_commit_timestamp = 'on'
wal_level = 'logical'

Speichere und schließe die Datei„/etc/postgresql/15/main/postgresql.conf„, wenn du fertig bist.

Als Nächstes öffnest du die PostgreSQL-Authentifizierungsdatei „/etc/postgresql/15/main/pg_hba.conf“ mit dem folgenden nano-Editor-Befehl.

sudo nano /etc/postgresql/15/main/pg_hba.conf

Füge die folgenden Zeilen am Ende der Zeile hinzu. Dadurch wird die Authentifizierung für alle Benutzer vom Host‚192.168.5.1/24‚ sowohl für normale PostgreSQL-Benutzer als auch für Replikationsbenutzer zugelassen.

# IPv4 local connections:
host    all             all             192.168.5.1/24          scram-sha-256
# replication privilege.
host    replication     all             192.168.5.1/24          scram-sha-256

Speichere und schließe die Datei „/etc/postgresql/15/main/pg_hba.conf„, wenn du fertig bist.

Wenn die Konfiguration von ‚/etc/postgresql/15/main/postgresql.conf‚ und‚/etc/postgresql/15/main/pg_hba.conf‚ abgeschlossen ist, gib den folgenden systemctl-Befehl ein, um den PostgreSQL-Dienst neu zu starten und die Änderungen zu übernehmen.

sudo systemctl restart postgresql

Gib nun den folgenden ss-Befehl ein, um sicherzustellen, dass PostgreSQL auf deiner lokalen IP-Adresse läuft.

ss -tulpn | grep 5432

Du solltest eine Ausgabe wie diese erhalten – Auf dem Server pgdg01 sollte der PostgreSQL-Server unter der Adresse„192.168.5.25:5432“ laufen. Auf dem pgdg02-Server sollte der PostgreSQL-Server unter der Adresse„192.168.5.26:5432“ laufen.

Gib abschließend den folgenden Befehl ein, um dich in der PostgreSQL-Shell anzumelden und die aktivierte Wal-Ebene auf deinem PostgreSQL-Server zu überprüfen.

sudo -u postgres psql

Gib die folgende PostgreSQL-Abfrage ein, um den aktivierten Wal-Level auf deinem PostgreSQL-Server zu überprüfen.

select name,setting,unit from pg_settings where name in ('wal_level','max_worker_processes','max_replication_slots','max_wal_senders','shared_preload_libraries','track_commit_timestamp');

Die Ausgabe„wal_level – logical“ bestätigt, dass die Wal-Ebene„logical“ aktiviert ist, und zwar über„shared_preload_library – pglogical„.

An diesem Punkt hast du die PostgreSQL-Server mit dem wal level‚logical‚ für die logische Streaming-Replikation über‚pglogical‚ konfiguriert. Außerdem laufen beide PostgreSQL-Server auf internen Netzwerk-IP-Adressen. Im nächsten Schritt erstellst du einen neuen PostgreSQL-Benutzer und eine Datenbank und aktivierst die Erweiterung„pglogical„.

Benutzer und Datenbank einrichten

pglogical ist eine PostgreSQL-Erweiterung, die auf der Datenbankebene arbeitet. Damit replizierst du nicht das gesamte PostgreSQL-System, sondern nur bestimmte Tabellen oder Datenbanken, die in PostgreSQL verfügbar sind.

Um pglogical einzurichten, musst du das PostgreSQL-Recht mit der Rolle SUPERUSER haben. Außerdem musst du die Erweiterung„pglogical“ für die Zieldatenbank, die du replizieren möchtest, aktivieren.

Melde dich in der PostgreSQL-Shell an, indem du den folgenden Befehl eingibst.

sudo -u postgres psql

Erstelle einen neuen Benutzer und eine neue Datenbank mit Hilfe der folgenden PostgreSQL-Abfragen.

In diesem Beispiel erstellst du einen neuen Benutzer„appuser“ mit der Berechtigung „SUPERUSER“. Zum Zeitpunkt der Erstellung dieses Artikels benötigte pglogical das SUPER-Benutzerrecht, damit es funktioniert. Außerdem erstellst du eine neue Datenbank„appdb„, die Zieldatenbank, auf der du die Replikation aktivieren willst.

CREATE ROLE appuser WITH LOGIN SUPERUSER ENCRYPTED PASSWORD 'Str0ngP4ssw0rd';
CREATE DATABASE appdb WITH OWNER appuser;

Überprüfe die Liste der Benutzer und Datenbanken auf deinem PostgreSQL-Server mit den folgenden Abfragen. Du solltest den neuen Benutzer„appuser“ mit SUPERUSER-Rechten und die neue Datenbank„appdb“ erhalten.

\du
\l

Als Nächstes verbindest du dich mit der neuen Datenbank ‚appdb‘, indem du die Abfrage ‚\c‘ oder ‚\connect‘ verwendest. Wenn du verbunden bist, wird dein PostgreSQL-Shellprompt wie folgt aussehen:‚appdb=#‘

\c appdb

Gib die folgende Abfrage ein, um die Erweiterung„pglogical“ für die Datenbank„appdb“ zu aktivieren.

CREATE EXTENSION pglogical;

Überprüfe dann die Liste der aktivierten Erweiterungen in der aktuellen„appdb„-Datenbank mit der folgenden Abfrage. Du solltest sehen, dass die„pglogical„-Erweiterung in der„appdb„-Datenbank aktiviert ist.

\dx

Nachdem du den Benutzer und die Datenbank angelegt und pglogical aktiviert hast, kannst du als Nächstes pglogical konfigurieren, um die Datenbankreplikation zwischen zwei PostgreSQL-Servern zu ermöglichen.

Aktivieren der Tabellenreplikation über pglogical

In diesem Abschnitt aktivierst du die logische Replikation für eine bestimmte Tabelle, die du in der Datenbank „appdb“ anlegen wirst

### pgdg01 als Publisher-Knoten einrichten

Gib die folgenden PostgreSQL-Abfragen auf dem‚publisher node‚ –‚pgdg01 server‘ ein, um eine neue Tabelle namens‚teachers‚ zu erstellen.

CREATE TABLE teachers (
  id INT PRIMARY KEY,
  first_name VARCHAR,
  last_name VARCHAR,
  subject VARCHAR
);

Füge neue Daten in die Tabelle „teachers“ ein, indem du die folgenden Abfragen eingibst.

INSERT INTO teachers(id, first_name, last_name, subject)
VALUES 
(1, 'Alice', 'Wonderland', 'Math'),
(2, 'Bob', 'Rista', 'Physics'),
(3, 'John', 'Bonas', 'English');

Rufe dann deine neuen Daten ab, um sicherzustellen, dass sie auf dem Publisher Node pgdg01 Server verfügbar sind.

select count(*) from teachers;
select * from teachers;

Die folgende Ausgabe bestätigt, dass die neuen Daten in die Tabelle„teachers“ eingefügt wurden.

Um die Replikation der PostgreSQL-Datenbank/Tabelle über pglogical einzurichten, musst du die folgenden Schritte ausführen:

• Erstelle einen Provider-Knoten auf dem Publisher-Server pgdg01.
• Erstelle ein Replikationsset, mit dem du steuern kannst, welche Tabellen in der Datenbank repliziert werden sollen.
• Füge dem Replikationsset Tabellen hinzu.

Gib den folgenden Befehl ein, um einen neuen Providerknoten mit dem Namen „provider1“ zu erstellen. Achte darauf, dass du die Details von PostgreSQL mit dem Server pgdg01 änderst.

select pglogical.create_node(node_name := 'provider1', dsn := 'host=pgdg01 port=5432 dbname=appdb user=appuser');

Gib als Nächstes die folgende Abfrage ein, um ein neues Replikatset mit dem Namen „replication_set“ zu erstellen.

select pglogical.create_replication_set('replication_set');

Dann fügst du die Tabelle „teachers“ zum Replikationsset „replication_set“ hinzu, indem du die folgende Abfrage eingibst.

select pglogical.replication_set_add_table(set_name := 'replication_set', relation := 'teachers', synchronize_data := true);

Jetzt hast du den Providerknoten mit dem PostgreSQL-Server pgdg01 erstellt, das Replikatset„replication_set“ erstellt und die Tabelle„teachers“ zum„replication_set“ hinzugefügt. Als Nächstes erstellst und richtest du einen Subscriber Node auf dem Server„pgdg02“ ein.

pgdg02 als Subsciber Node einrichten

Gehe zum Server „pgdg02“ und gib den folgenden Befehl im nano-Editor ein, um eine neue PostgreSQL-Passwortdatei„/var/lib/postgresql/.pgpass“ zu erstellen. Diese Passwortdatei wird für deine Anmeldung verwendet.

sudo -u postgres nano /var/lib/postgresql/.pgpass

Füge die folgenden Zeilen in die Datei ein und achte darauf, dass du den Benutzernamen und das Passwort mit deinen Daten änderst.

pgdg01:5432:appdb:appuser:Str0ngP4ssw0rd
pgdg01:5432:replication:appuser:Str0ngP4ssw0rd
pgdg02:5432:appdb:appuser:Str0ngP4ssw0rd
pgdg02:5432:replication:appuser:Str0ngP4ssw0rd

Speichere und schließe die Datei, wenn du fertig bist.

Gib nun den folgenden Befehl ein, um die Berechtigung der Datei„/var/lib/postgresql/.pgpass“ auf schreibgeschützt zu ändern.

sudo chmod 0600 /var/lib/postgresql/.pgpass

Als Nächstes loggst du dich mit dem folgenden Befehl bei PostgreSQL ein.

sudo -u postgres psql

Nach der Anmeldung gibst du die folgende Abfrage ein, um deine PostgreSQL-Serverkonfiguration neu zu laden, und beendest sie, um sicherzustellen, dass die Änderungen übernommen werden.

select pg_reload_conf();
\q

Melde dich nun erneut in der PostgreSQL-Shell auf dem Server pgdg02 an.

sudo -u postgres psql

Verbinde dich mit der Datenbank „appdb“, die du erstellt hast.

\c appdb

Gib dann die folgende PostgreSQL-Abfrage ein, um eine neue Tabelle„Lehrer“ zu erstellen, die mit der Tabelle auf dem Anbieterknoten„pgdg01“ abgeglichen werden muss.

CREATE TABLE teachers (
  id INT PRIMARY KEY,
  first_name VARCHAR,
  last_name VARCHAR,
  subject VARCHAR
);

Wenn du die verfügbaren Daten überprüfst, solltest du eine leere Tabelle erhalten.

select count(*) from teachers;
select * from teachers;

Nachdem du die PostgreSQL-Passwortdatei und die Tabelle „teachers“ erstellt hast, richtest du als Nächstes PostgreSQL auf dem Server„pgdg02“ als Subscriber mit den folgenden Schritten ein:

• Erstelle einen Subscriber-Knoten auf dem pgdg02-Server.
• Erstelle das Abonnement, das den Synchronisations- und Replikationsprozess im Hintergrund starten wird.
• Überprüfe den Replikationsprozess.

Gib die folgende Abfrage ein, um einen neuen Subscriber-Knoten mit dem PostgreSQL-Server pgdg02 zu erstellen. Achte darauf, dass du die Details Hostname, Datenbankname und Benutzer änderst.

select pglogical.create_node(node_name := 'subscriber1', dsn := 'host=pgdg02 port=5432 dbname=appdb user=appuser');

Als nächstes erstellst du ein neues Abonnement mit dem Namen „subscription1“. Gib das Replikationsset mit dem Namen „replication_set“ ein und gib als Anbieter PostgreSQL auf dem Server pgdg01 an. Damit wird die Replikation der Tabelle„Lehrer“ gestartet und läuft im Hintergrund.

select pglogical.create_subscription(subscription_name := 'subscription1', replication_sets := array['replication_set'], provider_dsn := 'host=pgdg01 port=5432 dbname=appdb user=appuser' );

Gib die folgende Abfrage ein, um den Abonnementstatus zu überprüfen.

select *  FROM pglogical.show_subscription_status();

Du solltest eine Ausgabe wie diese erhalten – Der Status von‚abonnement1‚ repliziert zum Anbieter‚provider1‚ und dem Replikationsset‚replication_set‘.

Gib nun die folgende Abfrage ein, um darauf zu warten, dass das Abonnement mit der asynchronen Replikation beginnt und die Daten synchronisiert werden.

SELECT pglogical.wait_for_subscription_sync_complete('subscription1');

Abschließend kannst du die Daten in der Tabelle„teachers“ überprüfen, die auf dem PostgreSQL-Server pgdg2 verfügbar ist.

select count(*) from teachers;
select * from teachers;

Wenn die Replikation erfolgreich war, sollten deine Daten jetzt verfügbar sein und auf den PostgreSQL-Server pgdg02 repliziert werden.

Replikation testen

In diesem Abschnitt überprüfst du die Replikation auf dem PostgreSQL-Server, indem du neue Daten vom Publisher-Knoten pgdg01 einfügst. Anschließend überprüfst du die Daten vom Subscriber-Knoten, um sicherzustellen, dass die Daten repliziert werden.

Verbinde dich zunächst mit der Datenbank„appdb“ auf dem Server pgdg01, indem du den folgenden Befehl eingibst.

sudo -u postgres psql -U appuser -h pgdg01 -d appdb

Gib die folgenden Abfragen ein, um neue Daten in die Tabelle„teachers“ einzufügen.

INSERT INTO teachers(id, first_name, last_name, subject)
VALUES 
(4, 'Ian', 'Gibson', 'Geography'),
(5, 'Tom', 'Riddle', 'Biology'),
(6, 'Jared', 'Dunn', 'Chemistry');

Überprüfe die Tabelle„teachers„, um sicherzustellen, dass die neuen Daten hinzugefügt wurden.

select count(*) from teachers;
select * from teachers;

Wechsle dann zum Server pgdg02 und gib folgenden Befehl ein, um dich mit der Datenbank„appdb“ zu verbinden.

sudo -u postgres psql -U appuser -h pgdg02 -d appdb

Gib die folgende Abfrage ein, um die verfügbaren Daten in der Tabelle„teachers“ zu überprüfen. Wenn die Replikation erfolgreich war, solltest du die neu aktualisierten Daten auf dem Server pgdg02 sehen.

select count(*) from teachers;
select * from teachers;

Damit hast du die Konfiguration der logischen Stream-Replikation über pglogical auf PostgreSQL-Servern abgeschlossen.

Fazit

In diesem Lernprogramm hast du die logische Stream-Replikation über pglogical auf Debian 11-Servern installiert und konfiguriert. Außerdem hast du die grundlegende Verwendung der pglogical-Erweiterung für die Erstellung und Verwaltung der PostgreSQL-Replikation auf Datenbankebene gelernt.

Außerdem hast du die Installation des neuesten PostgreSQL 15 auf dem Debian-Server über das offizielle PostgreSQL-Repository abgeschlossen und den PostgreSQL-Server über die UFW-Firewall gesichert.

Damit kannst du nun einen weiteren PostgreSQL-Server hinzufügen und die pglogical-Erweiterung einrichten, um die Replikation auf mehrere Server zu ermöglichen. Du kannst auch einen Lastausgleich über HAPROXY einrichten oder eine Ausfallsicherung für PostgreSQL-Server einrichten. Weitere Informationen findest du in der offiziellen Dokumentation von PostgreSQL.