PostgreSQL 17: Mehr Zuverlässigkeit durch Logical Replication Failover

Bevor es losgeht, sollten Sie Folgendes parat haben:

1. AWS CLI mit Access- und Secret-Keys konfiguriert.
2. Konnektivität zu den RDS-Instanzen.
3. Eine bestehende VPC Security Group (SG), die Ihre IP auf Port 5432 freigibt.

1. Parameter Groups erstellen und konfigurieren – mit den nötigen Parametern.
2. RDS-Instanzen bereitstellen: RDS-PostgreSQL-Instanzen anlegen.
3. Logische Replikation einrichten: Slots, Publications und Subscriptions konfigurieren.
4. Failover simulieren und Subscription anpassen: Read Replica promoten und die Subscription auf die neue Primary umlenken.
5. Replikationsfluss testen, um die Datenkonsistenz zu prüfen.
6. Ressourcen aufräumen.

1. Parameter Groups konfigurieren

• Legen Sie zunächst eigene Parameter Groups für Primary, Read Replica und Logical Replica an. Aktivieren Sie folgende Parameter:

| Parameter                    | Wert      | Beschreibung                                                                   |
|------------------------------|-----------|--------------------------------------------------------------------------------|
| rds.logical_replication      | 1         | Aktiviert die logische Replikation auf der Primary-Instanz.                    |
| hot_standby_feedback         | 1         | Verhindert Query-Konflikte durch Feedback vom Standby an die Primary.          |
| rds.logical_slot_sync_dbname | Valid DB  | Gibt die Datenbank für die Slot-Synchronisierung an (Standard: `postgres`).    |
| synchronized_standby_slots   | Slot-Name | Name des physischen Replication Slots des Standby, der synchron bleiben soll.  |
| sync_replication_slots       | 1         | Aktiviert die automatische Synchronisierung der Replication Slots.             |

Erstellen Sie die Parameter Group. Wiederholen Sie das Vorgehen analog für Read Replica und Logical Replica.

aws rds create-db-parameter-group \
    --db-parameter-group-name pg-primary-group \
    --db-parameter-group-family postgres17 \
    --description "Logical replication setup with sync_replication_slots"

• Passen Sie die Parameter an. synchronized_standby_slots wird erst gesetzt, sobald die Read Replica existiert:

aws rds modify-db-parameter-group \
    --db-parameter-group-name pg-primary-group \
    --parameters "ParameterName='rds.logical_replication',ParameterValue=logical,ApplyMethod=pending-reboot" \
                 "ParameterName='sync_replication_slots',ParameterValue=1,ApplyMethod=pending-reboot"

aws rds modify-db-parameter-group \
    --db-parameter-group-name pg-read-replica-group \
    --parameters "ParameterName='rds.logical_replication',ParameterValue=1,ApplyMethod=pending-reboot" \
                 "ParameterName='hot_standby_feedback',ParameterValue='1',ApplyMethod=pending-reboot" \
                 "ParameterName='rds.logical_slot_sync_dbname',ParameterValue='postgres',ApplyMethod=pending-reboot" \
                 "ParameterName='sync_replication_slots',ParameterValue=1,ApplyMethod=pending-reboot"

2. RDS-Instanzen bereitstellen

• Legen Sie über die AWS CLI Primary-Instanz, Logical Replica und Read Replica an. Für Testzwecke sind diese Instanzen öffentlich erreichbar:

aws rds create-db-instance \
    --db-instance-identifier primary-instance \
    --engine postgres \
    --engine-version 17.1 \
    --allocated-storage 20 \
    --master-username postgres \
    --master-user-password ChangeM3 \
    --db-instance-class db.t3.medium \
    --vpc-security-group-ids sg-xxxxxx

Für die Logical Replica gehen Sie genauso vor.

• Für die Read Replica:

aws rds create-db-instance-read-replica \
    --db-instance-identifier read-replica \
    --source-db-instance-identifier primary-instance

• Sobald die Read Replica bereitsteht, lesen Sie den Namen des physischen Slots auf der Primary-Instanz aus und tragen ihn in die Parameter Group pg-primary-group ein:

psql -h $DB_PRI -U postgres -t -c "SELECT slot_name FROM pg_replication_slots where slot_type='physical'"

aws rds modify-db-parameter-group \
    --db-parameter-group-name pg-primary-group \
    --parameters "ParameterName='synchronized_standby_slots',ParameterValue='rds_us_east_1_db_dn2uyr2436rexq3u7gcdfzw4hy',ApplyMethod=pending-reboot"

• Weisen Sie die Parameter Groups nun den jeweiligen Instanzen zu und starten Sie diese neu.
• Prüfen Sie, ob die Parameter korrekt gesetzt sind. Sie müssen aktiv sein, damit die logische Replikation nach einem Failover weiterläuft:

psql -h $DB_PRI -U postgres -c "SELECT name,setting FROM pg_settings WHERE name IN ('wal_level','rds.logical_replication','sync_replication_slots','synchronized_standby_slots')"
:' output
            name            |                   setting
----------------------------+---------------------------------------------
 rds.logical_replication    | on
 sync_replication_slots     | on
 synchronized_standby_slots | rds_us_east_1_db_dn2uyr2436rexq3u7gcdfzw4hy
 wal_level                  | logical
(4 rows)
'

# rds.logical_slot_sync_dbname is not available in pg_settings
# make sure to update it if your database is not "postgres."
psql -h $DB_RR -U postgres -c "SELECT name,setting FROM pg_settings WHERE name IN ('wal_level','rds.logical_replication','sync_replication_slots','hot_standby_feedback','rds.logical_slot_sync_dbname')"
:' output
          name           | setting
-------------------------+---------
 hot_standby_feedback    | on
 rds.logical_replication | on
 sync_replication_slots  | on
 wal_level               | logical
(4 rows)
'

3. Logische Replikation einrichten

Auf der Primary-Instanz:

• Quelltabelle anlegen, mit Beispieldaten füllen und Publication erstellen:

CREATE TABLE reptab1 (slno int primary key);
INSERT INTO reptab1 VALUES (generate_series(1,1000));
CREATE PUBLICATION testpub FOR TABLE reptab1;

• Erstellen Sie auf der Logical Replica eine identische Tabelle und eine Subscription mit failover = true. Damit entsteht auf der Primary-Instanz ein Logical Replication Slot.

CREATE TABLE reptab1 (slno int primary key);
CREATE SUBSCRIPTION testsub CONNECTION 'host=<primary-endpoint> port=5432 dbname=postgres user=postgres password=ChangeM3' PUBLICATION testpub WITH (failover = true);

• Prüfen Sie, ob die Subscription aktiv ist und die Daten übernommen wurden:

SELECT subname, subenabled FROM pg_subscription;
SELECT count(*) from reptab1;

• Auf der Read-Replica-Instanz sollte nun ein Logical Replication Slot zu sehen sein:

psql -h $DB_RR -U postgres -c "select slot_name, slot_type, active, failover, synced from pg_replication_slots;"
:'output
 slot_name | slot_type | active | failover | synced
-----------+-----------+--------+----------+--------
 testsub   | logical   | f      | t        | t
(1 row)
'

4. Failover simulieren und Subscription anpassen

So simulieren Sie einen Failover:

• Read Replica zur eigenständigen Instanz promoten:

aws rds promote-read-replica \
   --db-instance-identifier read-replica

• Die Subscription auf der Logical Replica auf die neue Primary umstellen:

ALTER SUBSCRIPTION testsub CONNECTION 'host=<read-replica-endpoint> port=5432 dbname=postgres user=postgres password=ChangeM3';

Mit aktiviertem sync_replication_slots bleibt der Logical Replication Slot beim Failover bestehen. Der Subscriber (Logical Replica) repliziert dadurch nahtlos weiter, ein Resync entfällt.

• Fügen Sie zur Validierung der Replikation neue Zeilen in die promotete Read Replica ein:

INSERT INTO reptab1 VALUES (generate_series(1001,2000));

• Prüfen Sie, ob die Logical Replica die neuen Zeilen enthält:

SELECT COUNT(*) FROM reptab1;  -- Should reflect the new data

Damit keine unnötigen Kosten anfallen, löschen Sie alle RDS-Instanzen und Parameter Groups:

aws rds delete-db-instance --db-instance-identifier primary-instance --skip-final-snapshot
aws rds delete-db-instance --db-instance-identifier read-replica --skip-final-snapshot
aws rds delete-db-instance --db-instance-identifier logical-replica --skip-final-snapshot

aws rds delete-db-parameter-group --db-parameter-group-name pg-primary-group
aws rds delete-db-parameter-group --db-parameter-group-name pg-read-replica-group
aws rds delete-db-parameter-group --db-parameter-group-name pg-logical-replica-group