Utilizzo dei wrapper di dati esterni supportati per Amazon Aurora PostgreSQL - Amazon Aurora
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 Aurora 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 all'istanza database Aurora PostgreSQL di interagire con i database Oracle.

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

Il cluster di database Aurora PostegreSQL 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 Aurora 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 Aurora 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 di gruppi di parametri.

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 dal cluster di database Aurora 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 dal cluster di database Aurora 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 Aurora PostgreSQL 15.4, 14.9, 13.12, 12.16 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 Aurora PostgreSQL per l'utilizzo dell'estensione mysql_fdw

La configurazione dell'estensione mysql_fdw sul cluster di database Aurora PostgreSQL comporta il caricamento dell'estensione nel cluster di 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 cluster di database Aurora 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. Il cluster di database Aurora PostegreSQL e il cluster di database Aurora 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 del cluster di database Aurora 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 sul cluster di database Aurora PostgreSQL, imposta il server esterno che fornisce la connessione a un database MySQL.

Per creare il server esterno

Esegui queste attività sul cluster di database Aurora 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 nel cluster di database Aurora 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 Aurora MySQL da Aurora PostgreSQL

Supponi di disporre di una semplice tabella su un'istanza database Aurora PostgreSQL. Gli utenti di Aurora 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. Nel cluster di database Aurora 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 Aurora 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 dal cluster di database Aurora 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 Aurora PostgreSQL 12.7 (Amazon Aurora versione 4.2) 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 Aurora 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 dal proprio cluster di database Aurora 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 Aurora PostgreSQL versioni 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 cluster di database Aurora 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 il cluster di database Aurora PostegreSQL 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 principale del cluster di database Aurora PostgreSQL utilizzando un account che dispone del ruolo rds_superuser:

    psql --host=your-cluster-name-instance-1.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 sul cluster di database Aurora PostgreSQL , è necessario configurare il server esterno.

Per creare il server esterno

Eseguire queste attività sul cluster di database Aurora PostgreSQL utilizzando un account che dispone dei privilegi rds_superuser.

  1. Creazione di un server esterno nel cluster di database Aurora 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 nel cluster database Aurora 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 Aurora 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.