Utilizzo dei wrapper di dati esterni supportati per Amazon RDS for PostgreSQL - Amazon Relational Database Service
Utilizzo dell'estensione log_fdwUtilizzo di postgres_fdw per accedere a dati esterniInterazione con un database MySQLInterazione con un database OracleUtilizzo di un database SQL Server

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Utilizzo dei wrapper di dati esterni supportati per Amazon RDS for PostgreSQL

Un wrapper di dati esterni (FDW) è uno specifico tipo di estensione che consente l'accesso a dati esterni. Ad esempio, l'estensione oracle_fdw consente al cluster di database RDS for PostgreSQL di interagire con i database Oracle. Come ulteriore esempio, utilizzando l'estensione postgres_fdw nativa di PostgreSQL è possibile accedere ai dati memorizzati in istanze database di PostgreSQL esterne ad Amazon RDS for PostgreSQL.

Di seguito sono disponibili le informazioni sui diversi wrapper di dati esterni di PostgreSQL supportati.

Utilizzo dell'estensione log_fdw per accedere al registro di database utilizzando SQL

L'istanza database RDS per PostgreSQL supporta l'estensione log_fdw che consente di accedere al log del motore del database utilizzando un'interfaccia SQL. L'estensione log_fdw offre due nuove funzioni che semplificano la creazione di tabelle esterne per i registri di database:

  • list_postgres_log_files – Elenca i file nella directory dei registri di database e le dimensioni dei file in byte.

  • create_foreign_table_for_log_file(table_name text, server_name text, log_file_name text) – Crea una tabella esterna per il file specificato nel database corrente.

Tutte le funzioni create da log_fdw sono di proprietà di rds_superuser. I membri del ruolo rds_superuser possono concedere l'accesso a queste funzioni ad altri utenti del database.

Per impostazione predefinita, i file di log vengono generati da Amazon RDS nel formato stderr (errore standard), come specificato nel parametro log_destination. Esistono solo due opzioni per questo parametro, stderr e csvlog (valori separati da virgola, CSV). Se aggiungi l'opzione csvlog al parametro, Amazon RDS genera entrambi i log stderr e csvlog. Ciò può influire sulla capacità di archiviazione del cluster di database, quindi è necessario tenere conto degli altri parametri che influiscono sulla gestione dei log. Per ulteriori informazioni, consulta Impostazione della destinazione del registro (stderr, csvlog).

Un vantaggio della generazione dei registri csvlog è che l'estensione log_fdw consente di costruire le tabelle esterne con i dati suddivisi in diverse colonne. Per eseguire questa operazione, l'istanza deve essere associata a un gruppo parametri del database personalizzato in modo da poter modificare l'impostazione per log_destination. Per ulteriori informazioni su come fare, consulta Utilizzo dei parametri sull'istanza database RDS for PostgreSQL.

L'esempio seguente presuppone che il parametro log_destination includa cvslog.

Per utilizzare l'estensione log_fdw

  1. Installa l'estensione log_fdw.

    postgres=> CREATE EXTENSION log_fdw;
CREATE EXTENSION

  2. Creare un server log come wrapper di dati esterno.

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

  3. Selezionare tutti gli elementi da un elenco di file di registro.

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

    Di seguito è riportata una risposta di esempio.

              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. Creare una tabella con una singola colonna "log_entry" per i file selezionato.

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

    La risposta non fornisce dettagli diversi da quello che la tabella ora esiste.

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

  5. Selezionare un campione del file di registro. Il seguente codice recupera l'ora del log e la descrizione del messaggio di errore.

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

    Di seguito è riportata una risposta di esempio.

                 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)

Utilizzo dell'estensione postgres_fdw per accedere a dati esterni

È possibile accedere ai dati in una tabella su un server di database remoto con l'estensione postgres_fdw. Se si imposta una connessione remota dall'istanza database di PostgreSQL, l'accesso è disponibile anche alla replica di lettura.

Usare postgres_fdw per accedere al server remoto del database

  1. Installare l'estensione postgres_fdw.

    CREATE EXTENSION postgres_fdw;

  2. Creare un server di dati esterni utilizzando CREATE SERVER.

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

  3. Creare una mappatura dell'utente per identificare il ruolo da utilizzare sul server remoto.

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

  4. Creare una tabella che esegua la mappatura della tabella sul server remoto.

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

Interazione con i database MySQL utilizzando l'estensione mysql_fdw

Per accedere a un database compatibile con MySQL dall'istanza database RDS per PostgreSQL è possibile installare e utilizzare l'estensione mysql_fdw. Questo wrapper di dati esterni consente di interagire con RDS per MySQL, Aurora MySQL, MariaDB e altri database compatibili con MySQL. La connessione dall'istanza database RDS per PostgreSQL al database MySQL è crittografata in base al miglior tentativo a seconda delle configurazioni di client e server. Tuttavia, se lo si desidera, è possibile imporre l'utilizzo della crittografia. Per ulteriori informazioni, consulta Utilizzo della crittografia in transito con l'estensione.

L'estensione mysql_fdw è supportata su Amazon RDS per PostgreSQL 14.2, 13.6 e versioni successive. Supporta le operazioni di select, insert, update e delete da un database RDS for PostgreSQL su tabelle contenuto in un'istanza database compatibile con MySQL.

Configurazione del database RDS per PostgreSQL per l'utilizzo dell'estensione mysql_fdw

La configurazione dell'estensione mysql_fdw sull'istanza database RDS per PostgreSQL comporta il caricamento dell'estensione nell'istanza database e quindi la creazione del punto di connessione all'istanza database MySQL. Per tale attività, è necessario disporre delle seguenti informazioni sull'istanza database MySQL:

  • Nome host o endpoint. Per trovare l'endpoint di un'istanza database RDS per MySQL è possibile utilizzare la console. Scegliere la scheda Connectivity & security (Connettività e sicurezza) e cercare nella sezione Endpoint and port (Endpoint e porta).

  • Numero della porta. La porta di default per MySQL è 3306.

  • Nome del database. L'identificatore del database.

È inoltre necessario fornire l'accesso al gruppo di sicurezza o alla lista di controllo degli accessi (ACL) per la porta MySQL 3306. L'istanza database RDS per PostgreSQL e l'istanza database RDS per MySQL necessitano dell'accesso alla porta 3306. Se l'accesso non è configurato correttamente, quando si cerca di connettersi alla tabella compatibile con MySQL comparirà un messaggio di errore simile al seguente:

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

Nella seguente procedura, l'utente (utilizzando l'account rds_superuser) crea il server esterno. Quindi concede l'accesso al server esterno a specifici utenti. Questi utenti creano quindi i propri mapping agli account utente MySQL appropriati per interagire con l'istanza database MySQL.

Per utilizzare mysql_fdw per accedere al server database MySQL

  1. Effettuare la connessione all'istanza database PostgreSQL utilizzando un account che dispone del ruolo rds_superuser. Se al momento della creazione dell'istanza database RDS per PostgreSQL sono stati accettati i valori predefiniti, il nome utente è postgres e lo strumento a riga di comando psql può essere usato per collegarsi come segue:

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

  2. Installare l'estensione mysql_fdw come segue:

    postgres=> CREATE EXTENSION mysql_fdw;
CREATE EXTENSION

Dopo aver installato l'estensione sull'istanza database RDS per PostgreSQL imposta il server esterno che fornisce la connessione a un database MySQL.

Per creare il server esterno

Esegui queste attività sull'istanza database RDS per PostgreSQL. La procedura presuppone che l'utente sia connesso come utente con i privilegi di rds_superuser, come postgres.

  1. Creazione di un server esterno nell'istanza database RDS for PostgreSQL:

    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. Concedere agli utenti appropriati l'accesso al server esterno. Questi dovrebbero essere utenti non amministratori, cioè utenti senza il ruolo rds_superuser.

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

Gli utenti PostgreSQL creano e gestiscono le proprie connessioni al database MySQL tramite il server esterno.

Esempio: utilizzo di un database RDS per MySQL da RDS per PostgreSQL

Supponi di disporre di una semplice tabella su un'istanza database RDS per PostgreSQL. Gli utenti di RDS per PostgreSQL desiderano eseguire query sugli elementi (SELECT), INSERT, UPDATE e DELETE contenute in tale tabella. Supponiamo che l'estensione mysql_fdw sia stata creata nell'istanza database RDS for PostgreSQL, come descritto nella procedura precedente. Dopo aver effettuato la connessione all'istanza database RDS for PostgreSQL come utente con i privilegi rds_superuser, è possibile procedere con i seguenti passaggi.

  1. Nell'istanza database RDS per PostgreSQL crea un server esterno: 

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

  2. Concedere l'utilizzo a un utente che non dispone delle autorizzazioni rds_superuser, ad esempio user1:

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

  3. Connettersi come user1 e quindi creare una mappatura per l'utente MySQL: 

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

  4. Creare di una tabella esterna collegata a una tabella MySQL:

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

  5. Eseguire una semplice query sulla tabella esterna:

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

  6. È possibile aggiungere, modificare e rimuovere i dati dalla tabella MySQL. Ad esempio:

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

    Eseguire nuovamente la query SELECT per visualizzare i risultati:

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

Utilizzo della crittografia in transito con l'estensione

La connessione a MySQL da RDS per PostgreSQL utilizza la crittografia in transito (TLS/SSL) per impostazione predefinita. Tuttavia, la connessione torna a essere non crittografata quando la configurazione di client e server differiscono. È possibile applicare la crittografia a tutte le connessioni in uscita specificando l'opzione REQUIRE SSL sugli account utente RDS for MySQL. Lo stesso approccio funziona anche per gli account utente MariaDB e Aurora MySQL.

Per gli account utente MySQL configurati su REQUIRE SSL, il tentativo di connessione non riesce se non è possibile stabilire una connessione sicura.

Per applicare la crittografia agli account utente esistenti del database MySQL è possibile utilizzare il comando ALTER USER. La sintassi varia a seconda della versione MySQL, come mostrato nella tabella seguente. Per ulteriori informazioni, consultare la voce ALTER USER nel Manuale di riferimento di MySQL.

MySQL 5.7, MySQL 8.0 MySQL 5.6

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

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

Per ulteriori informazioni sull'estensione mysql_fdw, consultare la documentazione di mysql_fdw.

Interazione con un database Oracle utilizzando l'estensione oracle_fdw

Per accedere a un database Oracle dall'istanza database RDS for PostgreSQL è possibile installare e utilizzare l'estensione oracle_fdw. Questa estensione è un wrapper di dati esterni per database Oracle. Per ulteriori informazioni sull'estensione, consultare la documentazione di oracle_fdw.

L'estensione oracle_fdw è supportata su RDS for PostgreSQL 12.7, 13.3 e versioni successive.

Attivazione dell'estensione oracle_fdw

Per utilizzare l'estensione oracle_fdw, eseguire la procedura riportata di seguito.

Come attivare l'estensione oracle_fdw

  • Eseguire il seguente comando utilizzando un account con le autorizzazioni rds_superuser.

    CREATE EXTENSION oracle_fdw;

Esempio: utilizzo di un server esterno collegato a un database Amazon RDS for Oracle

L'esempio seguente mostra l'utilizzo di un server esterno collegato a un database Amazon RDS for Oracle.

Come creare un server esterno collegato a un database RDS for Oracle

  1. Annotare le seguenti informazioni sull'istanza database RDS for Oracle:

    • Endpoint

    • Porta

    • Nome del database

  2. Creare un server esterno.

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

  3. Concedere l'utilizzo a un utente che non dispone dei privilegi rds_superuser, ad esempiouser1.

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

  4. Connettersi come user1 e creare una mappatura a un utente Oracle.

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

  5. Creare una tabella esterna collegata a una tabella Oracle.

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

  6. Eseguire una query sulla tabella esterna.

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

Se la query segnala il seguente errore, controllare il gruppo di sicurezza e la lista di controllo degli accessi (ACL) per assicurarsi che entrambe le istanze possano comunicare.

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

Utilizzo della crittografia in transito

La crittografia da PostgreSQL a Oracle in transito si basa su una combinazione di parametri di configurazione client e server. Per un esempio di utilizzo di Oracle 21c, consultare Informazioni sui valori per la negoziazione di crittografia e integrità nella documentazione Oracle. Il client utilizzato per oracle_fdw su Amazon RDS è configurato con ACCEPTED, il che significa che la crittografia dipende dalla configurazione del database server Oracle.

Se il database si trova su RDS for Oracle, consultare Crittografia di rete nativa Oracle per configurare la crittografia.

Informazioni sulla visualizzazione pg_user_mappings e sulle autorizzazioni

Il catalogo PostgreSQL pg_user_mapping archivia la mappatura da un utente RDS for PostgreSQL all'utente in un server remoto di dati esterni. L'accesso al catalogo è limitato, ma puoi usare la visualizzazione pg_user_mappings per vedere le mappature. Di seguito è possibile trovare un esempio che mostra come si applicano le autorizzazioni con un database Oracle, sebbene le stesse informazioni si applichino più in generale a qualsiasi wrapper di dati esterno.

Nel seguente output sono presenti ruoli e autorizzazioni mappati su tre diversi utenti di esempio. Gli utenti rdssu1 e rdssu2 sono membri del ruolo rds_superuser, mentre user1 non lo è. Nell'esempio viene utilizzato il metacomando psql \du per elencare i ruoli esistenti.

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

Tutti gli utenti, inclusi gli utenti che godono dei privilegi rds_superuser, sono autorizzati a visualizzare le proprie mappature utente (umoptions) nella tabella pg_user_mappings. Come mostrato nell'esempio seguente, quando rdssu1 cerca di ottenere tutte le mappature utente, viene generato un errore anche se gode dei privilegi rdssu1rds_superuser:

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

Di seguito vengono riportati alcuni esempi.

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)

A causa delle differenze nell'implementazione di information_schema._pg_user_mappings e pg_catalog.pg_user_mappings, un rds_superuser creato manualmente richiede autorizzazioni aggiuntive per visualizzare le password in pg_catalog.pg_user_mappings.

Non sono necessarie autorizzazioni aggiuntive per un rds_superuser che desideri visualizzare le password in information_schema._pg_user_mappings.

Gli utenti che non dispongono del ruolo rds_superuser possono visualizzare le password in pg_user_mappings solo nelle seguenti condizioni:

  • L'utente corrente è l'utente mappato e possiede il server oppure detiene il privilegio USAGE su di esso.

  • L'utente corrente è il proprietario del server e la mappatura è per PUBLIC.

Interazione con i database MySQL utilizzando l'estensione mysql_fdw

È possibile utilizzare l'estensione tds_fdw per PostgreSQL per accedere ai database che supportano il protocollo TDS (Tabular Data Stream), ad esempio i database Sybase e Microsoft SQL Server. Questo wrapper di dati esterni consente di connettersi dalla propria istanza database RDS for PostgreSQL ai database che utilizzano il protocollo TDS, incluso Amazon RDS for Microsoft SQL Server. Per ulteriori informazioni, consultare la documentazione di tds-fdw/tds_fdw su GitHub.

L'estensione tds_fdw è supportata su Amazon RDS for PostgreSQL versioni 14.2, 13.6 e successive.

Configurazione del database Aurora PostgreSQL per l'utilizzo dell'estensione tds_fdw

Nelle procedure seguenti, è possibile trovare un esempio di configurazione e utilizzo di tds_fdw con un'istanza database RDS for PostgreSQL. Prima di potersi connettere a un database di SQL Server utilizzando tds_fdw è necessario disporre delle seguenti informazioni sull'istanza:

  • Nome host o endpoint. Per trovare l'endpoint di un'istanza database RDS for SQL Server è possibile utilizzare la console. Scegliere la scheda Connectivity & security (Connettività e sicurezza) e cercare nella sezione Endpoint and port (Endpoint e porta).

  • Numero della porta. Il numero di porta predefinito per Microsoft SQL Server è 1433.

  • Nome del database. L'identificatore del database.

È inoltre necessario fornire l'accesso al gruppo di sicurezza o alla lista di controllo degli accessi (ACL) per la porta SQL Server 1433. Sia l'istanza database RDS for PostgreSQL che l'istanza database RDS for MySQL Server necessitano dell'accesso alla porta 1433. Se l'accesso non è configurato correttamente, quando si tenta di eseguire una query su Microsoft SQL Server viene visualizzato il seguente messaggio di errore:

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
Per utilizzare tds_fdw per connettersi a un database di SQL Server

  1. Collegarsi all'istanza database PostgreSQL utilizzando un account che dispone del ruolo rds_superuser:

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

  2. Installare l'estensione tds_fdw:

    test=> CREATE EXTENSION tds_fdw;
CREATE EXTENSION

Dopo che l'estensione è stata installata sull'istanza database RDS for PostgreSQL, è necessario configurare il server esterno.

Per creare il server esterno

Eseguire queste attività sull'istanza database RDS for PostgreSQL utilizzando un account che dispone dei privilegi rds_superuser.

  1. Creazione di un server esterno nell'istanza database RDS for PostgreSQL:

    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

    Per accedere ai dati non ASCII sul lato SQLServer, crea un collegamento server con l'opzione character_set nell'istanza database RDS per 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. Concedere le autorizzazioni a un utente che non dispone del ruolo rds_superuser, ad esempio user1:

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

  3. Collegarsi come user1 e quindi creare una mappatura per l'utente SQL Server:

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

  4. Creare una tabella esterna collegata a una tabella SQL Server:

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

  5. Eseguire una query sulla tabella esterna:

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

Utilizzo della crittografia in transito per la connessione

La connessione da RDS per PostgreSQL verso SQL Server utilizza la crittografia in transito (TLS/SSL) in base alla configurazione del database SQL Server. Se SQL Server non è configurato per la crittografia, il client RDS per PostgreSQL che effettua la richiesta al database di SQL Server torna a comunicare in modalità non crittografata.

È possibile imporre l'utilizzo della crittografia per la connessione alle istanze database RDS for SQL Server impostando il parametro rds.force_ssl. Per scoprire come fare, consultare Imposizione dell'utilizzo di SSL per le connessioni all'istanza database. Per ulteriori informazioni sulla configurazione di SSL/TLS per RDS for SQL Server, consultare Utilizzo di SSL con un'istanza database Microsoft SQL Server.