Arbeiten mit den unterstützten Fremddaten-Wrapper für Amazon RDS for PostgreSQL - Amazon Relational Database Service
Verwenden der Erweiterung log_fdwVerwenden von postgres_fdw für den Zugriff auf externe DatenArbeiten mit einer MySQL-DatenbankArbeiten mit einer Oracle-DatenbankArbeiten mit einer SQL-Server-Datenbank

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.

Arbeiten mit den unterstützten Fremddaten-Wrapper für Amazon RDS for PostgreSQL

Ein Fremddaten-Wrapper (FDW) ist eine bestimmte Art von Erweiterung, die Zugriff auf externe Daten ermöglicht. Zum Beispiel ermöglicht die Erweiterung oracle_fdw Ihrem RDS-für-PostgreSQL-DB-Cluster die Zusammenarbeit mit Oracle-Datenbanken. Mithilfe der nativen PostgreSQL-Erweiterung postgres_fdw können Sie beispielsweise auf Daten zugreifen, die in PostgreSQL-DB-Instances außerhalb Ihrer RDS-für-PostgreSQL-DB-Instance gespeichert sind.

Im Folgenden finden Sie Informationen zu mehreren unterstützten PostgreSQL-Fremddaten-Wrappern.

Verwenden der Erweiterung log_fdw für den Zugriff auf das DB-Protokoll mithilfe von SQL

Die DB-Instance von RDS für PostgreSQL unterstützt die Erweiterung log_fdw, mit der Sie über eine SQL-Schnittstelle auf Ihr Datenbank-Engine-Protokoll zugreifen können. Die log_fdw-Erweiterung umfasst zwei neue Funktionen, die das Erstellen von Fremdtabellen für Datenbankprotokolle erleichtern:

  • list_postgres_log_files führt die Dateien im Datenbankprotokollverzeichnis und die Dateigröße in Bytes auf.

  • create_foreign_table_for_log_file(table_name text, server_name text, log_file_name text) erstellt eine Fremdtabelle für die angegebene Datei in der aktuellen Datenbank.

Alle durch log_fdw erstellten Funktionen gehören rds_superuser. Mitglieder der rds_superuser-Rolle können anderen Datenbankbenutzern Zugriff auf diese Funktionen gewähren.

Standardmäßig werden die Protokolldateien von Amazon RDS im Format stderr (Standardfehler) generiert, wie im Parameter log_destination angegeben. Es gibt nur zwei Optionen für diesen Parameter: stderr und csvlog (Comma Separated Values, CSV). Wenn Sie dem Parameter die Option csvlog hinzufügen, generiert Amazon RDS sowohl stderr- als auch csvlog-Protokolle. Dies kann die Speicherkapazität Ihres DB-Clusters beeinträchtigen. Daher müssen Sie sich der anderen Parameter bewusst sein, die sich auf die Protokollbehandlung auswirken. Weitere Informationen finden Sie unter Festlegen des Protokollziels (stderr, csvlog).

Ein Vorteil der Generierung von csvlog-Protokollen ist, dass Sie mit der log_fdw-Erweiterung Fremdtabellen erstellen können, bei denen die Daten ordentlich in verschiedene Spalten aufgeteilt sind. Dazu muss Ihre Instance einer benutzerdefinierten DB-Parametergruppe zugeordnet sein, damit Sie die Einstellung für log_destination ändern können. Weitere Informationen zur Vorgehensweise finden Sie unter Arbeiten mit Parametern auf der DB-Instance von RDS for PostgreSQL.

Im folgenden Beispiel wird angenommen, dass der log_destination-Parameter cvslog enthält.

So verwenden Sie die Erweiterung log_fdw:

  1. Installieren Sie die log_fdw-Erweiterung.

    postgres=> CREATE EXTENSION log_fdw;
CREATE EXTENSION

  2. Erstellen Sie den Protokollserver als Fremddaten-Wrapper.

    postgres=> CREATE SERVER log_server FOREIGN DATA WRAPPER log_fdw;
CREATE SERVER

  3. Wählen Sie aus einer Liste an Protokolldateien "alle" aus.

    postgres=> SELECT * FROM list_postgres_log_files() ORDER BY 1;

    Beispiel-Antwort.

              file_name           | file_size_bytes
------------------------------+-----------------
 postgresql.log.2023-08-09-22.csv |            1111
 postgresql.log.2023-08-09-23.csv |            1172
 postgresql.log.2023-08-10-00.csv |            1744
 postgresql.log.2023-08-10-01.csv |            1102
(4 rows)

  4. Erstellen Sie eine Tabelle mit einer einzigen 'log_entry'-Spalte für die ausgewählte Datei.

    postgres=> SELECT create_foreign_table_for_log_file('my_postgres_error_log',
     'log_server', 'postgresql.log.2023-08-09-22.csv');

    Die Antwort liefert keine weiteren Details außer, dass die Tabelle jetzt existiert.

    -----------------------------------
(1 row)

  5. Wählen Sie ein Beispiel der Protokolldatei aus. Mit dem folgenden Code werden die Protokollzeit und die Fehlermeldungsbeschreibung abgerufen.

    postgres=> SELECT log_time, message FROM my_postgres_error_log ORDER BY 1;

    Beispiel-Antwort.

                 log_time             |                                  message
----------------------------------+---------------------------------------------------------------------------
Tue Aug 09 15:45:18.172 2023 PDT | ending log output to stderr
Tue Aug 09 15:45:18.175 2023 PDT | database system was interrupted; last known up at 2023-08-09 22:43:34 UTC
Tue Aug 09 15:45:18.223 2023 PDT | checkpoint record is at 0/90002E0
Tue Aug 09 15:45:18.223 2023 PDT | redo record is at 0/90002A8; shutdown FALSE
Tue Aug 09 15:45:18.223 2023 PDT | next transaction ID: 0/1879; next OID: 24578
Tue Aug 09 15:45:18.223 2023 PDT | next MultiXactId: 1; next MultiXactOffset: 0
Tue Aug 09 15:45:18.223 2023 PDT | oldest unfrozen transaction ID: 1822, in database 1
(7 rows)

Verwenden der postgres_fdw-Erweiterung für den Zugriff auf externe Daten

Auf die Daten in einer Tabelle auf einem Remote-Datenbank-Server können Sie mit der Erweiterung postgres_fdw zugreifen. Wenn Sie eine Remote-Verbindung ausgehend von einer PostgreSQL-DB-Instance einrichten, ist der Zugriff auch für das Lesereplikat verfügbar.

Verwenden Sie postgres_fdw wie folgt für den Zugriff auf einen Remote-Datenbank-Server:

  1. Installieren Sie die Erweiterung postgres_fdw.

    CREATE EXTENSION postgres_fdw;

  2. Erstellen Sie einen Fremddaten-Server mit CREATE SERVER.

    CREATE SERVER foreign_server
FOREIGN DATA WRAPPER postgres_fdw
OPTIONS (host 'xxx.xx.xxx.xx', port '5432', dbname 'foreign_db');

  3. Erstellen Sie ein Benutzer-Mapping, um die Rolle zu identifizieren, die auf dem Remote-Server verwendet werden soll.

    CREATE USER MAPPING FOR local_user
SERVER foreign_server
OPTIONS (user 'foreign_user', password 'password');

  4. Erstellen Sie eine Tabelle, die der Tabelle auf dem Remote-Server zugewiesen ist.

    CREATE FOREIGN TABLE foreign_table (
        id integer NOT NULL,
        data text)
SERVER foreign_server
OPTIONS (schema_name 'some_schema', table_name 'some_table');

Arbeiten mit MySQL-Datenbanken mithilfe der Erweiterung mysql_fdw

Um von Ihrer DB-Instance von Aurora PostgreSQL aus auf eine mit MySQL kompatible Datenbank zugreifen zu können, können Sie die Erweiterung mysql_fdw installieren und verwenden. Mit diesem Fremddaten-Wrapper können Sie mit RDS für MySQL, Aurora MySQL, MariaDB und anderen MySQL-kompatiblen Datenbanken arbeiten. Die Verbindung zwischen der DB-Instance von Aurora PostgreSQL und der MySQL-Datenbank wird je nach Client- und Serverkonfigurationen auf Best-Effort-Basis verschlüsselt. Sie können die Verschlüsselung jedoch erzwingen, wenn Sie möchten. Weitere Informationen finden Sie unter Verwenden der Verschlüsselung während der Übertragung mit der Erweiterung.

Die Erweiterung mysql_fdw wird auf Amazon RDS für PostgreSQL Version 14.2, 13.6 und neueren Versionen unterstützt. Es werden Auswahlen, Einfügungen, Updates und Löschungen einer RDS-für-PostgreSQL-DB in Tabellen einer MySQL-kompatiblen Datenbank-Instance unterstützt.

Einrichten Ihrer DB von RDS für PostgreSQL zur Verwendung der Erweiterung mysql_fdw

Das Einrichten der Erweiterung mysql_fdw für Ihre DB-Instance von Aurora PostgreSQL umfasst das Laden der Erweiterung in Ihre DB-Instance und das anschließende Erstellen des Verbindungspunkts mit der MySQL-DB-Instance. Für diese Aufgabe benötigen Sie folgende Details zur MySQL-DB-Instance:

  • Hostname oder Endpunkt. Sie können den Endpunkt für eine DB-Instance von RDS für MySQL mithilfe der Konsole ermitteln. Wählen Sie die Registerkarte „Connectivity & security“ (Konnektivität und Sicherheit) aus und sehen Sie im Abschnitt „Endpoint and port“ (Endpunkt und Port) nach.

  • Port-Nummer. Die Standardport-Nummer für MySQL ist 3306.

  • Name der Datenbank. Die DB-ID.

Sie müssen auch Zugriff auf die Sicherheitsgruppe oder die Zugriffssteuerungsliste (ACL) für den MySQL-Port 3306 gewähren. Die DB-Instance von RDS für PostgreSQL und die DB-Instance von RDS für MySQL benötigen Zugriff auf Port 3306. Wenn der Zugriff nicht korrekt konfiguriert ist, wird beim Versuch, eine Verbindung mit einer MySQL-kompatiblen Tabelle herzustellen, eine Fehlermeldung ähnlich wie die folgende angezeigt:

ERROR: failed to connect to MySQL: Can't connect to MySQL server on 'hostname.aws-region.rds.amazonaws.com:3306' (110)

Im folgenden Verfahren erstellen Sie (als rds_superuser-Konto) den fremden Server. Anschließend gewähren Sie bestimmten Benutzern Zugriff auf den fremden Server. Diese Benutzer erstellen dann ihre eigenen Zuordnungen zu den entsprechenden MySQL-Benutzerkonten zur Zusammenarbeit mit der MySQL-DB-Instance.

So greifen Sie mit mysql_fdw auf einen MySQL-Datenbankserver zu

  1. Stellen Sie über ein Konto, das die rds_superuser-Rolle enthält, eine Verbindung mit Ihrer PostgreSQL-DB-Instance her. Wenn Sie die Standardwerte beim Erstellen Ihrer DB-Instance von RDS für PostgreSQL akzeptiert haben, lautet der Benutzername postgres und Sie können sich mit dem psql-Befehlszeilen-Tool wie folgt verbinden:

    psql --host=your-DB-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres –-password

  2. Installieren Sie die mysql_fdw-Erweiterung wie folgt:

    postgres=> CREATE EXTENSION mysql_fdw;
CREATE EXTENSION

Nachdem die Erweiterung für Ihre DB-Instance von RDS für PostgreSQL installiert wurde, richten Sie den fremden Server ein, der die Verbindung mit einer MySQL-Datenbank bereitstellt.

So erstellen Sie den fremden Server

Führen Sie diese Aufgaben auf der DB-Instance von RDS für PostgreSQL aus. Die Schritte setzen voraus, dass Sie als Benutzer mit rds_superuser-Berechtigungen wie postgres verbunden sind.

  1. Erstellen Sie einen fremden Server auf der RDS-for-PostgreSQL-DB-Instance:

    postgres=> CREATE SERVER mysql-db FOREIGN DATA WRAPPER mysql_fdw OPTIONS (host 'db-name.111122223333.aws-region.rds.amazonaws.com', port '3306');
CREATE SERVER

  2. Gewähren Sie den entsprechenden Benutzern Zugriff auf den fremden Server. Dies sollten keine Administratorbenutzer sein, d. h. Benutzer ohne rds_superuser-Rolle.

    postgres=> GRANT USAGE ON FOREIGN SERVER mysql-db to user1;
GRANT

PostgreSQL-Benutzer erstellen und verwalten ihre eigenen Verbindungen mit der MySQL-Datenbank über den fremden Server.

Beispiel: Arbeiten mit einer RDS-für-MySQL-Datenbank von RDS für PostgreSQL

Angenommen, Sie haben eine einfache Tabelle auf einer DB-Instance von RDS für PostgreSQL. Ihre RDS-für-PostgreSQL-Benutzer möchten (SELECT)-, INSERT-, UPDATE- und DELETE-Elemente in dieser Tabelle abfragen. Nehmen wir an, dass die mysql_fdw-Erweiterung auf Ihrer RDS-für-PostgreSQL-DB-Instance erstellt wurde, wie im vorherigen Verfahren beschrieben. Nachdem Sie eine Verbindung mit der RDS-für-PostgreSQL-DB-Instance als Benutzer mit rds_superuser-Berechtigungen hergestellt haben, können Sie mit den folgenden Schritten fortfahren.

  1. Erstellen Sie einen fremden Server auf der DB-Instance von RDS für PostgreSQL: 

    test=> CREATE SERVER mysqldb FOREIGN DATA WRAPPER mysql_fdw OPTIONS (host 'your-DB.aws-region.rds.amazonaws.com', port '3306');
CREATE SERVER

  2. Gewähren Sie einem Benutzer, der keine rds_superuser-Berechtigungen hat, die Nutzung, zum Beispiel user1:

    test=> GRANT USAGE ON FOREIGN SERVER mysqldb TO user1;
GRANT

  3. Stellen Sie eine Verbindung als user1 (Benutzer 1) her und erstellen Sie dann eine Zuordnung zum MySQL-Benutzer: 

    test=> CREATE USER MAPPING FOR user1 SERVER mysqldb OPTIONS (username 'myuser', password 'mypassword');
CREATE USER MAPPING

  4. Erstellen Sie eine fremde Tabelle, die mit der MySQL-Tabelle verknüpft ist:

    test=> CREATE FOREIGN TABLE mytab (a int, b text) SERVER mysqldb OPTIONS (dbname 'test', table_name '');
CREATE FOREIGN TABLE

  5. Führen Sie eine einfache Abfrage mit der fremden Tabelle aus:

    test=> SELECT * FROM mytab;
a |   b
---+-------
1 | apple
(1 row)

  6. Sie können der MySQL-Tabelle Daten hinzufügen, ändern und daraus entfernen. Beispiel:

    test=> INSERT INTO mytab values (2, 'mango');
INSERT 0 1

    Führen Sie die SELECT-Abfrage noch einmal aus, um die Ergebnisse zu sehen:

    test=> SELECT * FROM mytab ORDER BY 1;
 a |   b
---+-------
1 | apple
2 | mango
(2 rows)

Verwenden der Verschlüsselung während der Übertragung mit der Erweiterung

Die Verbindung mit MySQL über RDS für PostgreSQL verwendet standardmäßig die Verschlüsselung während der Übertragung (TLS/SSL). Die Verbindung wird jedoch nicht verschlüsselt, wenn sich die Client- und Serverkonfiguration unterscheiden. Sie können die Verschlüsselung für alle ausgehenden Verbindungen erzwingen, indem Sie die Option REQUIRE SSL in den RDS-für-MySQL-Benutzerkonten angeben. Derselbe Ansatz funktioniert auch für MariaDB- und Aurora-MySQL-Benutzerkonten.

Für MySQL-Benutzerkonten, die für REQUIRE SSL konfiguriert sind, schlägt der Verbindungsversuch fehl, wenn keine sichere Verbindung hergestellt werden kann.

Um die Verschlüsselung für vorhandene MySQL-Datenbankbenutzerkonten durchzusetzen, können Sie den Befehl ALTER USER verwenden. Die Syntax variiert je nach MySQL-Version, wie in der folgenden Tabelle gezeigt. Weitere Informationen finden Sie unter ALTER USER im MySQL-Referenzhandbuch.

MySQL 5.7, MySQL 8.0 MySQL 5.6

ALTER USER 'user'@'%' REQUIRE SSL;

GRANT USAGE ON *.* to 'user'@'%' REQUIRE SSL;

Weitere Informationen zur Erweiterung mysql_fdw finden Sie in der mysql_fdw-Dokumentation.

Arbeiten mit Oracle-Datenbanken unter Verwendung der Erweiterung oracle_fdw

Um von Ihrer RDS-für-PostgreSQL-DB-Instance auf eine Oracle-Datenbank zuzugreifen, können Sie die Erweiterung oracle_fdw installieren und verwenden. Diese Erweiterung ist ein Fremddaten-Wrapper für Oracle-Datenbanken. Weitere Informationen zu dieser Erweiterung finden Sie in der oracle_fdw-Dokumentation.

Die Erweiterung oracle_fdw wird von den RDS-für-PostgreSQL-Versionen 12.7, 13.3 und höher unterstützt.

Aktivieren der Erweiterung oracle_fdw

So verwenden Sie die Erweiterung oracle_fdw:

Aktivieren der Erweiterung oracle_fdw

  • Führen Sie den folgenden Befehl mit einem Konto aus, das die rds_superuser-Berechtigungen besitzt.

    CREATE EXTENSION oracle_fdw;

Beispiel: Verwendung eines fremden Servers, der mit einer Amazon RDS for Oracle Database verknüpft ist

Das folgende Beispiel zeigt die Verwendung eines fremden Servers, der mit einer Amazon-RDS-für-Oracle-Datenbank verknüpft ist.

So erstellen Sie einen fremden Server, der mit einer RDS-for-Oracle-Datenbank verknüpft ist:

  1. Beachten Sie Folgendes auf der RDS-for-Oracle-DB-Instance:

    • Endpunkt

    • Port

    • Datenbankname

  2. Erstellen Sie einen fremden Server.

    test=> CREATE SERVER oradb FOREIGN DATA WRAPPER oracle_fdw OPTIONS (dbserver '//endpoint:port/DB_name');
CREATE SERVER

  3. Gewähren Sie einem Benutzer, der keine rds_superuser-Berechtigungen hat, die Nutzung, zum Beispiel user1.

    test=> GRANT USAGE ON FOREIGN SERVER oradb TO user1;
GRANT

  4. Verbinden Sie sich als user1 und erstellen Sie ein Mapping zu einem Oracle-Benutzer.

    test=> CREATE USER MAPPING FOR user1 SERVER oradb OPTIONS (user 'oracleuser', password 'mypassword');
CREATE USER MAPPING

  5. Erstellen einer fremden Tabelle, die mit einer Oracle-Tabelle verknüpft ist.

    test=> CREATE FOREIGN TABLE mytab (a int) SERVER oradb OPTIONS (table 'MYTABLE');
CREATE FOREIGN TABLE

  6. Fragen Sie die fremde Tabelle ab.

    test=>  SELECT * FROM mytab;
a
---
1
(1 row)

Wenn die Abfrage den folgenden Fehler meldet, überprüfen Sie Ihre Sicherheitsgruppe und Zugriffssteuerungsliste (Access Control List, ACL), um sicherzustellen, dass beide Instances kommunizieren können.

ERROR: connection for foreign table "mytab" cannot be established
DETAIL: ORA-12170: TNS:Connect timeout occurred

Datenverschlüsselung während der Übertragung

Die PostgreSQL-zu-Oracle-Verschlüsselung bei der Übertragung basiert auf einer Kombination von Client- und Server-Konfigurationsparametern. Ein Beispiel für Oracle 21c finden Sie unter Informationen zu den Werten für Verschlüsselung und Integrität in der Oracle-Dokumentation. Der Client, der für oracle_fdw auf Amazon RDS verwendet wird, ist mit ACCEPTED konfiguriert, was bedeutet, dass die Verschlüsselung von der Konfiguration des Oracle-Datenbankservers abhängt.

Wenn sich Ihre Datenbank auf RDS for Oracle befindet, finden Sie weitere Informationen zum Konfigurieren der Verschlüsselung unter Oracle Native Network Encryption.

Informationen zur Ansicht pg_user_mappings und zu Berechtigungen

Der PostgreSQL-Katalog pg_user_mapping speichert das Mapping eines Benutzers von RDS for PostgreSQL für den Benutzer auf einem fremden Datenserver (Remote). Der Zugriff auf den Katalog ist eingeschränkt, aber Sie verwenden die Ansicht pg_user_mappings, um die Mappings zu sehen. Das folgende Beispiel zeigt, wie Berechtigungen für eine Oracle-Beispieldatenbank gelten. Diese Informationen gelten im Allgemeinen für jeden fremden Daten-Wrapper.

In der folgenden Ausgabe finden Sie Rollen und Berechtigungen, die drei verschiedenen Beispielbenutzern zugeordnet sind. Benutzer rdssu1 und rdssu2 sind Mitglieder der rds_superuser-Rolle und user1 nicht. In dem Beispiel wird der psql-Metabefehl \du verwendet, um vorhandene Rollen aufzulisten.

test=>  \du
                                                               List of roles
    Role name    |                         Attributes                         |                          Member of
-----------------+------------------------------------------------------------+-------------------------------------------------------------
 rdssu1          |                                                            | {rds_superuser}
 rdssu2          |                                                            | {rds_superuser}
 user1           |                                                            | {}

Alle Benutzer, einschließlich Benutzer mit rds_superuser-Berechtigungen, dürfen ihre eigenen Benutzerzuordnungen (umoptions) in der pg_user_mappings-Tabelle anzeigen. Wie im folgenden Beispiel gezeigt, wird trotz rdssu1rds_superuser-Berechtigungen ein Fehler gemeldet, wenn rdssu1 versucht, alle Benutzerzuordnungen abzurufen:

test=> SELECT * FROM pg_user_mapping;
ERROR: permission denied for table pg_user_mapping

Im Folgenden sind einige Beispiele aufgeführt.

test=> SET SESSION AUTHORIZATION rdssu1;
SET
test=> SELECT * FROM pg_user_mappings;
 umid  | srvid | srvname | umuser | usename    |            umoptions
-------+-------+---------+--------+------------+----------------------------------
 16414 | 16411 | oradb   |  16412 | user1      |
 16423 | 16411 | oradb   |  16421 | rdssu1     | {user=oracleuser,password=mypwd}
 16424 | 16411 | oradb   |  16422 | rdssu2     |
 (3 rows)

test=> SET SESSION AUTHORIZATION rdssu2;
SET
test=> SELECT * FROM pg_user_mappings;
 umid  | srvid | srvname | umuser | usename    |            umoptions
-------+-------+---------+--------+------------+----------------------------------
 16414 | 16411 | oradb   |  16412 | user1      |
 16423 | 16411 | oradb   |  16421 | rdssu1     |
 16424 | 16411 | oradb   |  16422 | rdssu2     | {user=oracleuser,password=mypwd}
 (3 rows)

test=> SET SESSION AUTHORIZATION user1;
SET
test=> SELECT * FROM pg_user_mappings;
 umid  | srvid | srvname | umuser | usename    |           umoptions
-------+-------+---------+--------+------------+--------------------------------
 16414 | 16411 | oradb   |  16412 | user1      | {user=oracleuser,password=mypwd}
 16423 | 16411 | oradb   |  16421 | rdssu1     |
 16424 | 16411 | oradb   |  16422 | rdssu2     |
 (3 rows)

Aufgrund von Unterschieden in der Implementierung von information_schema._pg_user_mappings und pg_catalog.pg_user_mappings erfordert ein manuell erstelltes rds_superuser zusätzliche Berechtigungen zum Anzeigen von Passwörtern in pg_catalog.pg_user_mappings.

Es sind keine zusätzlichen Berechtigungen für rds_superuser nötig, um Kennwörter in information_schema._pg_user_mappings anzuzeigen.

Benutzer, die nicht über die rds_superuser-Rolle verfügen können Passwörter in pg_user_mappings nur unter den folgenden Bedingungen anzeigen:

  • Der aktuelle Benutzer ist der zugeordnete Benutzer und besitzt den Server oder besitzt die USAGE-Berechtigung dafür.

  • Der aktuelle Benutzer ist der Serverbesitzer und das Mapping ist für PUBLIC.

Arbeiten mit SQL-Server-Datenbanken unter Verwendung der Erweiterung tds_fdw

Sie können die PostgreSQL-Erweiterung tds_fdw für den Zugriff auf Datenbanken verwenden, die das TDS-Protokoll (Tabular Data Stream) unterstützen, wie Sybase- und Microsoft-SQL-Server-Datenbanken. Mit diesem Fremddaten-Wrapper können Sie sich von Ihrer RDS-für-PostgreSQL-DB-Instance aus mit Datenbanken verbinden, die das TDS-Protokoll verwenden, einschließlich Amazon RDS for Microsoft SQL Server. Weitere Informationen finden Sie in der tds-fdw/tds_fdw-Dokumentation auf GitHub.

Die Erweiterung tds_fdw wird von den Amazon-RDS-für-PostgreSQL-Versionen 14.2, 13.6 und höher unterstützt.

Einrichten Ihrer Aurora-PostgreSQL-DB zur Verwendung der Erweiterung tds_fdw

In den folgenden Verfahren finden Sie ein Beispiel für die Einrichtung und Verwendung der Erweiterung tds_fdw mit einer RDS-für-PostgreSQL-DB-Instance. Bevor Sie eine Verbindung mit einer SQL-Server-Datenbank mithilfe von tds_fdw herstellen können, benötigen Sie die folgenden Details für die Instance:

  • Hostname oder Endpunkt. Sie können den Endpunkt für eine RDS-for-SQL-Server-DB-Instance mithilfe der Konsole ermitteln. Wählen Sie die Registerkarte „Connectivity & security“ (Konnektivität und Sicherheit) aus und sehen Sie im Abschnitt „Endpoint and port“ (Endpunkt und Port) nach.

  • Port-Nummer. Die Standardport-Nummer für Microsoft SQL Server ist 1433.

  • Name der Datenbank. Die DB-ID.

Sie müssen auch Zugriff auf die Sicherheitsgruppe oder die Zugriffssteuerungsliste (ACL) für den SQL-Server-Port 1433 gewähren. Sowohl die RDS-für-PostgreSQL-DB-Instance als auch die RDS-for-SQL-Server-DB-Instance benötigen Zugriff auf Port 1433. Wenn der Zugriff nicht richtig konfiguriert ist, wird beim Versuch, den Microsoft SQL Server abzufragen, die folgende Fehlermeldung angezeigt:

ERROR: DB-Library error: DB #: 20009, DB Msg: Unable to connect:
Adaptive Server is unavailable or does not exist (mssql2019.aws-region.rds.amazonaws.com), OS #: 0, OS Msg: Success, Level: 9
So verbinden Sie sich mit tds_fdw mit einer SQL-Server-Datenbank

  1. Verbinden Sie sich mit Ihrer PostgreSQL-DB-Instance über ein Konto mit der rds_superuser-Rolle:

    psql --host=your-DB-instance.aws-region.rds.amazonaws.com --port=5432 --username=test –-password

  2. Installieren Sie die tds_fdw-Erweiterung.

    test=> CREATE EXTENSION tds_fdw;
CREATE EXTENSION

Nachdem die Erweiterung auf Ihrer RDS-für-PostgreSQL-DB-Instance installiert wurde, richten Sie den fremden Server ein.

So erstellen Sie den fremden Server

Führen Sie diese Aufgaben auf der RDS-für-PostgreSQL-DB-Instance unter Verwendung eines Kontos mit rds_superuser-Berechtigungen aus.

  1. Erstellen Sie einen fremden Server auf der RDS-for-PostgreSQL-DB-Instance:

    test=> CREATE SERVER sqlserverdb FOREIGN DATA WRAPPER tds_fdw OPTIONS (servername 'mssql2019.aws-region.rds.amazonaws.com', port '1433', database 'tds_fdw_testing');
CREATE SERVER

    Um auf Nicht-ASCII-Daten auf der SQLServer-Seite zuzugreifen, erstellen Sie einen Serverlink mit der Option character_set auf der DB-Instance von RDS für PostgreSQL:

    test=> CREATE SERVER sqlserverdb FOREIGN DATA WRAPPER tds_fdw OPTIONS (servername 'mssql2019.aws-region.rds.amazonaws.com', port '1433', database 'tds_fdw_testing', character_set 'UTF-8');
CREATE SERVER

  2. Gewähren Sie einem Benutzer, der keine rds_superuser-Rollenberechtigungen hat, Berechtigungen, zum Beispiel user1:

    test=> GRANT USAGE ON FOREIGN SERVER sqlserverdb TO user1;

  3. Stellen Sie eine Verbindung als „user1“ (Benutzer 1) her und erstellen Sie dann eine Zuordnung zum SQL-Server-Benutzer:

    test=> CREATE USER MAPPING FOR user1 SERVER sqlserverdb OPTIONS (username 'sqlserveruser', password 'password');
CREATE USER MAPPING

  4. Erstellen Sie eine fremde Tabelle, die mit einer SQL-Server-Tabelle verknüpft ist:

    test=> CREATE FOREIGN TABLE mytab (a int) SERVER sqlserverdb OPTIONS (table 'MYTABLE');
CREATE FOREIGN TABLE

  5. Fragen Sie die fremde Tabelle ab:

    test=> SELECT * FROM mytab;
 a
---
 1
(1 row)

Verwenden der Verschlüsselung während der Übertragung für die Verbindung

Die Verbindung von RDS for PostgreSQL mit SQL Server verwendet je nach SQL-Server-Datenbankkonfiguration die Verschlüsselung während der Übertragung (TLS/SSL). Wenn der SQL Server nicht für die Verschlüsselung konfiguriert ist, bleibt der RDS-für-PostgreSQL-Client, der die Anforderung an die SQL-Server-Datenbank stellt, unverschlüsselt.

Sie können die Verschlüsselung für die Verbindung mit RDS-for-SQL-Server DB-Instances erzwingen, indem Sie den rds.force_ssl-Parameter festlegen. Weitere Informationen finden Sie unter Erzwingen von Verbindungen mit Ihrer DB-Instance, um SSL zu verwenden. Weitere Informationen zur SSL/TLS-Konfiguration für RDS for SQL Server finden Sie unter Verwenden von SSL mit einer Microsoft-SQL-Server-DB-Instance.