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. **Topics** + [ # Utilizzo dell'estensione log\$1fdw per accedere al registro di database utilizzando SQL ](CHAP_PostgreSQL.Extensions.log_fdw.md) + [ # Utilizzo dell'estensione postgres\$1fdw per accedere a dati esterni ](postgresql-commondbatasks-fdw.md) + [ # Interazione con i database MySQL utilizzando l'estensione mysql\$1fdw ](postgresql-mysql-fdw.md) + [ # Interazione con un database Oracle utilizzando l'estensione oracle\$1fdw ](postgresql-oracle-fdw.md) + [ # Interazione con i database MySQL utilizzando l'estensione mysql\$1fdw ](postgresql-tds-fdw.md) # Utilizzo dell'estensione log\$1fdw 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`)](USER_LogAccess.Concepts.PostgreSQL.overview.parameter-groups.md#USER_LogAccess.Concepts.PostgreSQL.Log_Format). 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 [Gruppi di parametri per Amazon Aurora](USER_WorkingWithParamGroups.md). L'esempio seguente presuppone che il parametro `log_destination` includa `cvslog`. **Per utilizzare l'estensione log\$1fdw** 1. Installa l’estensione `log_fdw`. ``` postgres=> CREATE EXTENSION log_fdw; CREATE EXTENSION ``` 1. Creare un server log come wrapper di dati esterno. ``` postgres=> CREATE SERVER log_server FOREIGN DATA WRAPPER log_fdw; CREATE SERVER ``` 1. 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) ``` 1. Creare una tabella con una singola colonna "log\$1entry" 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) ``` 1. 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\$1fdw per accedere a dati esterni È possibile accedere ai dati in una tabella su un server di database remoto con l'estensione [postgres\$1fdw](https://www.postgresql.org/docs/current/static/postgres-fdw.html). Se si imposta una connessione remota dall'istanza database di PostgreSQL, l'accesso è disponibile anche alla replica di lettura. **Usare postgres\$1fdw per accedere al server remoto del database** 1. Installare l'estensione postgres\$1fdw. ``` CREATE EXTENSION postgres_fdw; ``` 1. 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'); ``` 1. Creare una mappatura dell'utente per identificare il ruolo da utilizzare sul server remoto. **Importante** Per oscurare la password in modo che non compaia nei log, impostare `log_statement=none` a livello di sessione. L’impostazione a livello di parametro non comporta l’oscuramento della password. ``` CREATE USER MAPPING FOR local_user SERVER foreign_server OPTIONS (user 'foreign_user', password 'password'); ``` 1. 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\$1fdw 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](#postgresql-mysql-fdw.encryption-in-transit). 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. **Topics** + [ ## Configurazione del database Aurora PostgreSQL per l'utilizzo dell'estensione mysql\$1fdw ](#postgresql-mysql-fdw.setting-up) + [ ## Esempio: utilizzo di un database Aurora MySQL da Aurora PostgreSQL ](#postgresql-mysql-fdw.using-mysql_fdw) + [ ## Utilizzo della crittografia in transito con l'estensione ](#postgresql-mysql-fdw.encryption-in-transit) ## Configurazione del database Aurora PostgreSQL per l'utilizzo dell'estensione mysql\$1fdw 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\$1fdw 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 ``` 1. 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 ``` 1. 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 ``` 1. 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 ``` 1. Connect as*user1*, quindi crea una mappatura per l'utente MySQL: ``` test=> CREATE USER MAPPING FOR user1 SERVER mysqldb OPTIONS (username 'myuser', password 'mypassword'); CREATE USER MAPPING ``` 1. 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 ``` 1. Eseguire una semplice query sulla tabella esterna: ``` test=> SELECT * FROM mytab; a | b ---+------- 1 | apple (1 row) ``` 1. È 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](https://dev.mysql.com/doc/refman/8.0/en/alter-user.html) 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\$1fdw](https://github.com/EnterpriseDB/mysql_fdw). # Interazione con un database Oracle utilizzando l'estensione oracle\$1fdw 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\$1fdw](https://github.com/laurenz/oracle_fdw). L'estensione `oracle_fdw` è supportata su Aurora PostgreSQL 12.7 (Amazon Aurora versione 4.2) e versioni successive. **Topics** + [ ## Attivazione dell'estensione oracle\$1fdw ](#postgresql-oracle-fdw.enabling) + [ ## Esempio: utilizzo di un server esterno collegato a un database Amazon RDS for Oracle ](#postgresql-oracle-fdw.example) + [ ## Utilizzo della crittografia in transito ](#postgresql-oracle-fdw.encryption) + [ ## Informazioni sulla visualizzazione pg\$1user\$1mappings e sulle autorizzazioni ](#postgresql-oracle-fdw.permissions) ## Attivazione dell'estensione oracle\$1fdw Per utilizzare l'estensione oracle\$1fdw, eseguire la procedura riportata di seguito. **Come attivare l'estensione oracle\$1fdw** + 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 1. Creare un server esterno. ``` test=> CREATE SERVER oradb FOREIGN DATA WRAPPER oracle_fdw OPTIONS (dbserver '//endpoint:port/DB_name'); CREATE SERVER ``` 1. Concedere l'utilizzo a un utente che non dispone dei privilegi `rds_superuser`, ad esempio`user1`. ``` test=> GRANT USAGE ON FOREIGN SERVER oradb TO user1; GRANT ``` 1. 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 ``` 1. Creare una tabella esterna collegata a una tabella Oracle. ``` test=> CREATE FOREIGN TABLE mytab (a int) SERVER oradb OPTIONS (table 'MYTABLE'); CREATE FOREIGN TABLE ``` 1. 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à](https://docs.oracle.com/en/database/oracle/oracle-database/21/dbseg/configuring-network-data-encryption-and-integrity.html#GUID-3A2AF4AA-AE3E-446B-8F64-31C48F27A2B5) nella documentazione Oracle. Il client utilizzato per oracle\$1fdw su Amazon RDS è configurato con `ACCEPTED`, il che significa che la crittografia dipende dalla configurazione del server di database Oracle e utilizza Oracle Security Library (libnnz) per la crittografia. Se il database si trova su RDS for Oracle, consultare [Crittografia di rete nativa Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.Options.NetworkEncryption.html) per configurare la crittografia. ## Informazioni sulla visualizzazione pg\$1user\$1mappings 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 `rdssu1``rds_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\$1fdw È 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\$1fdw](https://github.com/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\$1fdw 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\$1fdw 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 ``` 1. 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\$1set 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 ``` 1. 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; ``` 1. 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 ``` 1. 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 ``` 1. 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](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.Concepts.General.SSL.Using.html#SQLServer.Concepts.General.SSL.Forcing). Per ulteriori informazioni sulla configurazione di SSL/TLS per RDS for SQL Server, consultare [Utilizzo di SSL con un'istanza database Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.Concepts.General.SSL.Using.html).