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.
# Einrichten der Aktiv-Aktiv-Replikation für die DB-Instances 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, wobei `pgactive` verfügbar ist. Um das Beispiel für hohe Verfügbarkeit in mehreren Regionen auszuführen, müssen Sie Instances von Amazon RDS für PostgreSQL in zwei verschiedenen Regionen bereitstellen und VPC-Peering einrichten. Weitere Informationen finden Sie unter [VPC-Peering](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html).
**Anmerkung**
Beim Senden von Datenverkehr zwischen mehreren Regionen können zusätzliche Kosten anfallen.
Bei diesen Schritten wird vorausgesetzt, dass die DB-Instance von RDS für PostgreSQL mit der `pgactive`-Erweiterung eingerichtet wurde. Weitere Informationen finden Sie unter [Initialisierung der „pgactive“-Erweiterungsfunktion](Appendix.PostgreSQL.CommonDBATasks.pgactive.basic-setup.md).
**So konfigurieren Sie die erste DB-Instance von RDS für PostgreSQL mit der „`pgactive`“-Erweiterung**
Das folgende Beispiel zeigt, wie die „`pgactive`“-Gruppe erstellt wird, sowie weitere Schritte, die erforderlich sind, um die „`pgactive`“-Erweiterung auf der RDS-für-PostgreSQL-DB-Instance zu erstellen.
1. Verwenden Sie `psql` oder ein anderes Client-Tool, um eine Verbindung zu Ihrer ersten DB-Instance von RDS für PostgreSQL herzustellen.
```
psql --host=firstinstance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password=PASSWORD --dbname=postgres
```
1. Erstellen Sie mit dem folgenden Befehl eine Datenbank auf der RDS-für-PostgreSQL-Instance:
```
postgres=> CREATE DATABASE app;
```
1. Wechseln Sie mit dem folgenden Befehl die Verbindung zur neuen Datenbank:
```
\c app
```
1. Erstellen Sie mit den folgenden SQL-Anweisungen eine Beispieltabelle.
1. Erstellen Sie mit der folgenden SQL-Anweisung eine Beispieltabelle.
```
app=> CREATE SCHEMA inventory;
CREATE TABLE inventory.products (
id int PRIMARY KEY, product_name text NOT NULL,
created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP);
```
1. Füllen Sie die Tabelle mit der folgenden SQL-Anweisung mit Beispieldaten auf.
```
app=> INSERT INTO inventory.products (id, product_name)
VALUES (1, 'soap'), (2, 'shampoo'), (3, 'conditioner');
```
1. Stellen Sie sicher, dass Daten in der Tabelle vorhanden sind, indem Sie die folgende SQL-Anweisung verwenden.
```
app=>SELECT count(*) FROM inventory.products;
count
-------
3
```
1. Erstellen Sie eine „`pgactive`“-Erweiterung für die bestehende Datenbank.
```
app=> CREATE EXTENSION pgactive;
```
1. Erstellen und initialisieren Sie die Gruppe „pgactive“ mit den folgenden Befehlen:
```
app=>
-- connection info for endpoint1
CREATE SERVER pgactive_server_endpoint1
FOREIGN DATA WRAPPER pgactive_fdw
OPTIONS (host '', dbname 'app');
CREATE USER MAPPING FOR postgres
SERVER pgactive_server_endpoint1
OPTIONS (user 'postgres', password '');
-- connection info for endpoint2
CREATE SERVER pgactive_server_endpoint2
FOREIGN DATA WRAPPER pgactive_fdw
OPTIONS (host '', dbname 'app');
CREATE USER MAPPING FOR postgres
SERVER pgactive_server_endpoint2
OPTIONS (user 'postgres', password '');
```
Jetzt können Sie die Replikationsgruppe initialisieren und diese erste Instance hinzufügen:
```
SELECT pgactive.pgactive_create_group(
node_name := 'endpoint1-app',
node_dsn := 'user_mapping=postgres pgactive_foreign_server=pgactive_server_endpoint1'
);
```
Verwenden Sie die folgenden Befehle als alternative, aber weniger sichere Methode, um die pgactive-Gruppe zu erstellen und zu initialisieren:
```
app=> SELECT pgactive.pgactive_create_group(
node_name := 'node1-app',
node_dsn := 'dbname=app host=firstinstance.111122223333.aws-region.rds.amazonaws.com user=postgres password=PASSWORD');
```
node1-app ist der Name, den Sie vergeben, um einen Knoten in der „`pgactive`“-Gruppe eindeutig zu identifizieren.
**Anmerkung**
Um diesen Schritt erfolgreich auf einer DB-Instance durchzuführen, auf die öffentlich zugegriffen werden kann, müssen Sie den Parameter „`rds.custom_dns_resolution`“ aktivieren, indem Sie ihn auf `1` setzen.
1. Verwenden Sie den folgenden Befehl, um zu überprüfen, ob die DB-Instance bereit ist:
```
app=> SELECT pgactive.pgactive_wait_for_node_ready();
```
Wird der Befehl erfolgreich ausgeführt, wird Ihnen die folgende Ausgabe angezeigt:
```
pgactive_wait_for_node_ready
------------------------------
(1 row)
```
**So konfigurieren Sie die zweite RDS-für-PostgreSQL-Instance und fügen sie der „`pgactive`“-Gruppe hinzu**
Das folgende Beispiel zeigt, wie Sie eine RDS-für-PostgreSQL-DB-Instance mit der „`pgactive`“-Gruppe verbinden können, sowie weitere Schritte, die zum Erstellen der „`pgactive`“-Erweiterung auf der DB-Instance erforderlich sind.
Bei diesen Schritten wird vorausgesetzt, dass andere DB-Instances von RDS für PostgreSQL mit der „`pgactive`“-Erweiterung eingerichtet wurde(n). Weitere Informationen finden Sie unter [Initialisierung der „pgactive“-Erweiterungsfunktion](Appendix.PostgreSQL.CommonDBATasks.pgactive.basic-setup.md).
1. Verwenden Sie `psql`, um sich mit der Instance zu verbinden, die Updates vom Herausgeber erhalten soll.
```
psql --host=secondinstance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password=PASSWORD --dbname=postgres
```
1. Erstellen Sie mit dem folgenden Befehl eine Datenbank auf der zweiten RDS-für-PostgreSQL-Instance:
```
postgres=> CREATE DATABASE app;
```
1. Wechseln Sie mit dem folgenden Befehl die Verbindung zur neuen Datenbank:
```
\c app
```
1. Erstellen Sie die „`pgactive`“-Erweiterung für die bestehende Datenbank.
```
app=> CREATE EXTENSION pgactive;
```
1. Fügen Sie der „`pgactive`“-Gruppe die zweite DB-Instance von RDS für PostgreSQL mit den folgenden Befehlen hinzu:
```
-- connection info for endpoint1
CREATE SERVER pgactive_server_endpoint1
FOREIGN DATA WRAPPER pgactive_fdw
OPTIONS (host '', dbname 'app');
CREATE USER MAPPING FOR postgres
SERVER pgactive_server_endpoint1
OPTIONS (user 'postgres', password '');
-- connection info for endpoint2
CREATE SERVER pgactive_server_endpoint2
FOREIGN DATA WRAPPER pgactive_fdw
OPTIONS (host '', dbname 'app');
CREATE USER MAPPING FOR postgres
SERVER pgactive_server_endpoint2
OPTIONS (user 'postgres', password '');
```
```
SELECT pgactive.pgactive_join_group(
node_name := 'endpoint2-app',
node_dsn := 'user_mapping=postgres pgactive_foreign_server=pgactive_server_endpoint2',
join_using_dsn := 'user_mapping=postgres pgactive_foreign_server=pgactive_server_endpoint1'
);
```
Verwenden Sie die folgenden Befehle als alternative, aber weniger sichere Methode, um der `pgactive`-Gruppe den die zweite DB-Instance von RDS für PostgreSQL hinzuzufügen.
```
app=> SELECT pgactive.pgactive_join_group(
node_name := 'node2-app',
node_dsn := 'dbname=app host=secondinstance.111122223333.aws-region.rds.amazonaws.com user=postgres password=PASSWORD',
join_using_dsn := 'dbname=app host=firstinstance.111122223333.aws-region.rds.amazonaws.com user=postgres password=PASSWORD');
```
node2-app ist der Name, den Sie vergeben, um einen Knoten in der „`pgactive`“-Gruppe eindeutig zu identifizieren.
1. Verwenden Sie den folgenden Befehl, um zu überprüfen, ob die DB-Instance bereit ist:
```
app=> SELECT pgactive.pgactive_wait_for_node_ready();
```
Wird der Befehl erfolgreich ausgeführt, wird Ihnen die folgende Ausgabe angezeigt:
```
pgactive_wait_for_node_ready
------------------------------
(1 row)
```
Wenn die erste RDS-für-PostgreSQL-Datenbank relativ groß ist, können Sie sehen, dass `pgactive.pgactive_wait_for_node_ready()` den Fortschrittsbericht des Wiederherstellungsvorgangs ausgibt. Die Ausgabe sieht folgendermaßen oder ähnlich aus:
```
NOTICE: restoring database 'app', 6% of 7483 MB complete
NOTICE: restoring database 'app', 42% of 7483 MB complete
NOTICE: restoring database 'app', 77% of 7483 MB complete
NOTICE: restoring database 'app', 98% of 7483 MB complete
NOTICE: successfully restored database 'app' from node node1-app in 00:04:12.274956
pgactive_wait_for_node_ready
------------------------------
(1 row)
```
Ab diesem Zeitpunkt werden die Daten zwischen den beiden DB-Instances durch „`pgactive`“ synchronisiert.
1. Sie können den folgenden Befehl verwenden, um zu überprüfen, ob die Datenbank der zweiten DB-Instance die Daten enthält:
```
app=> SELECT count(*) FROM inventory.products;
```
Wenn die Daten erfolgreich synchronisiert wurden, sehen Sie die folgende Ausgabe:
```
count
-------
3
```
1. Führen Sie den folgenden Befehl aus, um neue Werte einzufügen:
```
app=> INSERT INTO inventory.products (id, product_name) VALUES (4, 'lotion');
```
1. Stellen Sie eine Verbindung zur Datenbank der ersten DB-Instance her und führen Sie die folgende Abfrage aus:
```
app=> SELECT count(*) FROM inventory.products;
```
Wenn die Aktiv-Aktiv-Replikation initialisiert ist, sieht die Ausgabe ungefähr wie folgt aus:
```
count
-------
4
```
**So trennen Sie eine DB-Instance von der „`pgactive`“-Gruppe und entfernen Sie daraus**
Sie können eine DB-Instance mit den folgenden Schritten von der „`pgactive`“-Gruppe trennen und daraus entfernen:
1. Sie können die zweite DB-Instance mit dem folgenden Befehl von der ersten DB-Instance trennen:
```
app=> SELECT * FROM pgactive.pgactive_detach_nodes(ARRAY[‘node2-app']);
```
1. Entfernen Sie die „`pgactive`“-Erweiterung mit dem folgenden Befehl aus der zweiten DB-Instance:
```
app=> SELECT * FROM pgactive.pgactive_remove();
```
So erzwingen Sie die Entfernung der Erweiterung:
```
app=> SELECT * FROM pgactive.pgactive_remove(true);
```
1. Löschen Sie die Erweiterung mit dem folgenden Befehl:
```
app=> DROP EXTENSION pgactive;
```