# Trabalhar com os invólucros de dados externos compatíveis do Amazon RDS for PostgreSQL Um Foreign Data Wraper (FDW – Empacotador de dados externos) é um tipo específico de extensão que fornece acesso a dados externos. Por exemplo, a extensão `oracle_fdw` permite que o cluster de banco de dados do RDS for PostgreSQL funcione com bancos de dados Oracle. Citando outro exemplo, se você usar a extensão `postgres_fdw` nativa do PostgreSQL, poderá acessar dados armazenados em instâncias de banco de dados do PostgreSQL externas à instância de banco de dados do RDS for PostgreSQL. A seguir, você encontrará informações sobre vários invólucros de dados externos do PostgreSQL compatíveis. **Topics** + [Usar a extensão log\$1fdw para acessar o log de banco de dados usando SQL](CHAP_PostgreSQL.Extensions.log_fdw.md) + [Usar a extensão postgres\$1fdw para acessar dados externos](postgresql-commondbatasks-fdw.md) + [Trabalhar com bancos de dados MySQL usando a extensão mysql\$1fdw](postgresql-mysql-fdw.md) + [Trabalhar com um banco de dados Oracle usando a extensão oracle\$1fdw](postgresql-oracle-fdw.md) + [Trabalhar com bancos de dados do SQL Server usando a extensão tds\$1fdw](postgresql-tds-fdw.md) # Usar a extensão log\$1fdw para acessar o log de banco de dados usando SQL A instância de banco de dados do RDS para PostgreSQL é compatível com a extensão `log_fdw`, que permite acessar o log do mecanismo de banco de dados usando uma interface SQL. A extensão `log_fdw` apresenta duas novas funções que facilitam a criação de tabelas externas para logs de banco de dados: + `list_postgres_log_files` – lista os arquivos no diretório do log do banco de dados e o tamanho do arquivo em bytes. + `create_foreign_table_for_log_file(table_name text, server_name text, log_file_name text)` – cria uma tabela externa para o arquivo especificado no banco de dados atual. Todas as funções criadas por `log_fdw` são de propriedade do `rds_superuser`. Os membros da função `rds_superuser` podem conceder acesso a essas funções para outros usuários do banco de dados. Por padrão, os arquivos de log são gerados pelo Amazon RDS no formato (erro padrão) `stderr`, conforme especificado no parâmetro `log_destination`. Existem apenas duas opções para esse parâmetro, `stderr` e `csvlog` (valores separados por vírgula, CSV). Se você adicionar a opção `csvlog` ao parâmetro, o Amazon RDS gerará os logs `stderr` e `csvlog`. Isso pode afetar a capacidade de armazenamento em seu cluster de banco de dados. Portanto, você precisa estar ciente dos outros parâmetros que afetam o processamento de logs. Para obter mais informações, consulte [Definir o destino dos logs (`stderr`, `csvlog`)](USER_LogAccess.Concepts.PostgreSQL.overview.parameter-groups.md#USER_LogAccess.Concepts.PostgreSQL.Log_Format). Um benefício de gerar logs do `csvlog` é que a extensão `log_fdw` permite criar tabelas externas com dados divididos ordenadamente em várias colunas. Para fazer isso, sua instância precisa estar associada a um grupo de parâmetros de banco de dados personalizado para que você possa alterar a configuração para `log_destination`. Para obter mais informações sobre como fazer isso, consulte [Trabalhar com parâmetros na instância de banco de dados do RDS para PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Parameters.md). O exemplo a seguir pressupõe que o parâmetro `log_destination` inclua `cvslog`. **Para usar a extensão log\$1fdw** 1. Instale a extensão `log_fdw`. ``` postgres=> CREATE EXTENSION log_fdw; CREATE EXTENSION ``` 1. Crie o servidor de log como um wrapper externo de dados. ``` postgres=> CREATE SERVER log_server FOREIGN DATA WRAPPER log_fdw; CREATE SERVER ``` 1. Selecione todos os arquivos de log na lista. ``` postgres=> SELECT * FROM list_postgres_log_files() ORDER BY 1; ``` A seguir você encontra um exemplo de resposta. ``` 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. Crie uma tabela com uma única coluna "log\$1entry" para o arquivo selecionado. ``` postgres=> SELECT create_foreign_table_for_log_file('my_postgres_error_log', 'log_server', 'postgresql.log.2023-08-09-22.csv'); ``` A resposta não fornece nenhum detalhe além de que a tabela agora existe. ``` ----------------------------------- (1 row) ``` 1. Selecione um exemplo de arquivo de log. O código a seguir recupera o horário do log e a descrição da mensagem de erro. ``` postgres=> SELECT log_time, message FROM my_postgres_error_log ORDER BY 1; ``` A seguir você encontra um exemplo de resposta. ``` 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) ``` # Usar a extensão postgres\$1fdw para acessar dados externos Você pode acessar dados em uma tabela em um servidor de banco de dados remoto com a extensão [postgres\$1fdw](https://www.postgresql.org/docs/current/static/postgres-fdw.html). Se você configurar uma conexão remota usando a instância de banco de dados do PostgreSQL, o acesso também estará disponível para a réplica de leitura. **Para usar postgres\$1fdw para acessar um servidor de banco de dados remoto** 1. Instale a extensão postgres\$1fdw. ``` CREATE EXTENSION postgres_fdw; ``` 1. Crie um servidor de dados externo usando CREATE SERVER. ``` CREATE SERVER foreign_server FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host 'xxx.xx.xxx.xx', port '5432', dbname 'foreign_db'); ``` 1. Crie um mapeamento de usuário para identificar a função a ser usada no servidor remoto. **Importante** Para ocultar a senha a fim de que ela não apareça nos logs, defina `log_statement=none` no nível da sessão. A configuração no nível do parâmetro não oculta a senha. ``` CREATE USER MAPPING FOR local_user SERVER foreign_server OPTIONS (user 'foreign_user', password 'password'); ``` 1. Crie uma tabela que mapeia para a tabela no servidor remoto. ``` CREATE FOREIGN TABLE foreign_table ( id integer NOT NULL, data text) SERVER foreign_server OPTIONS (schema_name 'some_schema', table_name 'some_table'); ``` # Trabalhar com bancos de dados MySQL usando a extensão mysql\$1fdw Para acessar um banco de dados compatível com MySQL pela instância de banco de dados RDS para PostgreSQL, você pode instalar e usar a extensão `mysql_fdw`. Esse invólucro de dados externos permite que você trabalhe com o RDS for MySQL, o Aurora MySQL, o MariaDB e outros bancos de dados compatíveis com MySQL. A conexão da instância de bancos de dados do RDS para PostgreSQL ao banco de dados MySQL é criptografada com base no melhor esforço, dependendo das configurações do cliente e do servidor. No entanto, você pode impor a criptografia, se quiser. Para obter mais informações, consulte [Usar criptografia em trânsito com a extensão](#postgresql-mysql-fdw.encryption-in-transit). A extensão `mysql_fdw` é compatível com o Amazon RDS para PostgreSQL versão 14.2, 13.6 e posteriores. Ela é compatível com seleções, inserções, atualizações e exclusões de um banco de dados do RDS for PostgreSQL para tabelas em uma instância de banco de dados compatível com MySQL. **Topics** + [Configurar um banco de dados RDS para PostgreSQL para usar a extensão mysql\$1fdw](#postgresql-mysql-fdw.setting-up) + [Exemplo: trabalhar com um banco de dados do RDS para MySQL pelo RDS para PostgreSQL](#postgresql-mysql-fdw.using-mysql_fdw) + [Usar criptografia em trânsito com a extensão](#postgresql-mysql-fdw.encryption-in-transit) ## Configurar um banco de dados RDS para PostgreSQL para usar a extensão mysql\$1fdw Para configurar a extensão `mysql_fdw` na instância de banco de dados do RDS para PostgreSQL, é necessário carregar a extensão na instância de banco de dados e, em seguida, criar o ponto de conexão com a instância de banco de dados do MySQL. Para essa tarefa, você precisa ter os seguintes detalhes sobre a instância de banco de dados do MySQL: + Nome de host ou endpoint. Para uma instância de banco de dados do RDS para MySQL, é possível encontrar o endpoint usando o console. Escolha a guia “Connectivity & security” (Conectividade e segurança) e procure na seção “Endpoint and port” (Endpoint e porta). + Número da porta. O número da porta padrão do MySQL é 3306. + O nome do banco de dados. O identificador do banco de dados. Você também precisa fornecer acesso no grupo de segurança ou na lista de controle de acesso (ACL) para a porta 3306 do MySQL. Tanto o cluster de MySQL precisam acessar a porta 3306. Se o acesso não estiver configurado corretamente, ao tentar se conectar à tabela compatível com o MySQL, será exibida uma mensagem de erro semelhante à seguinte: ``` ERROR: failed to connect to MySQL: Can't connect to MySQL server on 'hostname.aws-region.rds.amazonaws.com:3306' (110) ``` No procedimento a seguir, você (como a conta `rds_superuser`) cria o servidor externo. Depois, você concede acesso ao servidor externo a usuários específicos. Em seguida, esses usuários criam seus próprios mapeamentos para as contas de usuário apropriadas do MySQL para trabalhar com a instância de banco de dados do MySQL. **Para usar mysql\$1fdw a fim de acessar um servidor de banco de dados MySQL** 1. Conecte-se à instância de banco de dados do PostgreSQL usando uma conta que tenha a função `rds_superuser`. Se tiver aceitado os padrões ao criar a instância de banco de dados do RDS para PostgreSQL, o nome de usuário será `postgres` e você poderá se conectar usando a ferramenta da linha de comando `psql` da seguinte forma: ``` psql --host=your-DB-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres –-password ``` 1. Instale a extensão `mysql_fdw` da seguinte forma: ``` postgres=> CREATE EXTENSION mysql_fdw; CREATE EXTENSION ``` Depois que a extensão é instalada na instância de banco de dados do RDS para PostgreSQL, é possível configurar o servidor externo que fornece a conexão com um banco de dados MySQL. **Para criar o servidor externo** Execute essas tarefas na instância de banco de dados do RDS para PostgreSQL. As etapas presumem que você esteja conectado como usuário com privilégios `rds_superuser`, como `postgres`. 1. Crie um servidor externo na instância de banco de dados do RDS para 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. Conceda aos usuários apropriados acesso ao servidor externo. Eles devem ser usuários não administradores, ou seja, usuários sem a função `rds_superuser`. ``` postgres=> GRANT USAGE ON FOREIGN SERVER mysql-db to user1; GRANT ``` Os usuários do PostgreSQL criam e gerenciam suas próprias conexões com o banco de dados do MySQL por meio do servidor externo. ## Exemplo: trabalhar com um banco de dados do RDS para MySQL pelo RDS para PostgreSQL Suponha que você tenha uma tabela simples em uma instância de banco de dados do RDS para PostgreSQL. Os usuários do RDS para PostgreSQL querem consultar os itens `SELECT`, `INSERT`, `UPDATE` e `DELETE` nessa tabela. Suponha que a extensão `mysql_fdw` foi criada na instância de banco de dados do RDS for PostgreSQL, conforme detalhado no procedimento anterior. Depois de se conectar à instância de banco de dados do RDS for PostgreSQL como um usuário com privilégios `rds_superuser`, é possível prosseguir com as etapas abaixo. 1. Crie um servidor externo na instância de banco de dados do RDS para PostgreSQL: ``` test=> CREATE SERVER mysqldb FOREIGN DATA WRAPPER mysql_fdw OPTIONS (host 'your-DB.aws-region.rds.amazonaws.com', port '3306'); CREATE SERVER ``` 1. Conceda uso a um usuário que não tenha permissões `rds_superuser`; por exemplo, `user1`: ``` test=> GRANT USAGE ON FOREIGN SERVER mysqldb TO user1; GRANT ``` 1. Conecte-se como *user1* e, em seguida, crie um mapeamento para o usuário do MySQL: ``` test=> CREATE USER MAPPING FOR user1 SERVER mysqldb OPTIONS (username 'myuser', password 'mypassword'); CREATE USER MAPPING ``` 1. Crie uma tabela externa vinculada a uma tabela do MySQL: ``` test=> CREATE FOREIGN TABLE mytab (a int, b text) SERVER mysqldb OPTIONS (dbname 'test', table_name ''); CREATE FOREIGN TABLE ``` 1. Execute uma consulta simples na tabela externa: ``` test=> SELECT * FROM mytab; a | b ---+------- 1 | apple (1 row) ``` 1. Você pode adicionar, alterar e remover dados da tabela do MySQL. Por exemplo: ``` test=> INSERT INTO mytab values (2, 'mango'); INSERT 0 1 ``` Execute a consulta `SELECT` novamente para ver os resultados: ``` test=> SELECT * FROM mytab ORDER BY 1; a | b ---+------- 1 | apple 2 | mango (2 rows) ``` ## Usar criptografia em trânsito com a extensão A conexão com o MySQL pelo RDS para PostgreSQL usa criptografia em trânsito (TLS/SSL) por padrão. No entanto, a conexão volta para não criptografada quando a configuração do cliente e do servidor é diferente. Você pode impor a criptografia para todas as conexões de saída especificando a opção `REQUIRE SSL` nas contas de usuário do RDS for MySQL. Essa mesma abordagem também funciona para contas de usuário do MariaDB e do Aurora MySQL. Para contas de usuário do MySQL configuradas como `REQUIRE SSL`, a tentativa de conexão falhará se não for possível estabelecer uma conexão segura. Para aplicar criptografia a contas de usuário do banco de dados do MySQL existentes, você pode usar o comando `ALTER USER`. A sintaxe varia, dependendo da versão do MySQL, conforme mostrado na tabela a seguir. Para obter mais informações, consulte [ALTER USER](https://dev.mysql.com/doc/refman/8.0/en/alter-user.html) no *Manual de referência do MySQL*. | MySQL 5.7, MySQL 8.0 | MySQL 5.6 | | --- | --- | | `ALTER USER 'user'@'%' REQUIRE SSL;` | `GRANT USAGE ON *.* to 'user'@'%' REQUIRE SSL;` | Para obter mais informações sobre a extensão `mysql_fdw`, consulte a documentação do [mysql\$1fdw](https://github.com/EnterpriseDB/mysql_fdw). # Trabalhar com um banco de dados Oracle usando a extensão oracle\$1fdw Para acessar um banco de dados Oracle pela instância de banco de dados do RDS for PostgreSQL, você pode instalar e usar a extensão `oracle_fdw`. Essa extensão é um invólucro de dados externos para bancos de dados Oracle. Para saber mais sobre a extensão, consulte a documentação do [oracle\$1fdw](https://github.com/laurenz/oracle_fdw). A extensão `oracle_fdw` é compatível com o RDS for PostgreSQL 12.7, 13.3 e versões posteriores. **Topics** + [Ativação da extensão oracle\$1fdw](#postgresql-oracle-fdw.enabling) + [Exemplo: usar um servidor externo vinculado a um banco de dados Amazon RDS for Oracle](#postgresql-oracle-fdw.example) + [Como trabalhar com criptografia em trânsito](#postgresql-oracle-fdw.encryption) + [Noções básicas da visualização e das permissões de pg\$1user\$1mappings](#postgresql-oracle-fdw.permissions) ## Ativação da extensão oracle\$1fdw Para usar a extensão oracle\$1fdw, realize o procedimento a seguir. **Para ativar a extensão oracle\$1fdw** + Execute o comando a seguir usando uma conta que tenha as permissões de `rds_superuser`. ``` CREATE EXTENSION oracle_fdw; ``` ## Exemplo: usar um servidor externo vinculado a um banco de dados Amazon RDS for Oracle O exemplo a seguir mostra o uso de um servidor externo vinculado a um banco de dados Amazon RDS for Oracle. **Para criar um servidor externo vinculado a um banco de dados do RDS for Oracle** 1. Na instância de banco de dados do RDS for Oracle, observe: + Endpoint + Port + Database name 1. Crie um servidor externo. ``` test=> CREATE SERVER oradb FOREIGN DATA WRAPPER oracle_fdw OPTIONS (dbserver '//endpoint:port/DB_name'); CREATE SERVER ``` 1. Conceda uso a um usuário que não tenha privilégios `rds_superuser`, por exemplo `user1`. ``` test=> GRANT USAGE ON FOREIGN SERVER oradb TO user1; GRANT ``` 1. Conecte-se como `user1` e crie um mapeamento para um usuário Oracle. ``` test=> CREATE USER MAPPING FOR user1 SERVER oradb OPTIONS (user 'oracleuser', password 'mypassword'); CREATE USER MAPPING ``` 1. Crie uma tabela estrangeira vinculada a uma tabela Oracle. ``` test=> CREATE FOREIGN TABLE mytab (a int) SERVER oradb OPTIONS (table 'MYTABLE'); CREATE FOREIGN TABLE ``` 1. Consulte a tabela externa. ``` test=> SELECT * FROM mytab; a --- 1 (1 row) ``` Se a consulta relatar o seguinte erro, verifique seu grupo de segurança e a lista de controle de acesso (ACL) para verificar se as duas instâncias podem se comunicar. ``` ERROR: connection for foreign table "mytab" cannot be established DETAIL: ORA-12170: TNS:Connect timeout occurred ``` ## Como trabalhar com criptografia em trânsito A criptografia PostgreSQL-to-Oracle em trânsito é baseada em uma combinação de parâmetros de configuração de cliente e servidor. Para obter um exemplo usando o Oracle 21c, consulte [About the Values for Negotiating Encryption and Integrity](https://docs.oracle.com/en/database/oracle/oracle-database/21/dbseg/configuring-network-data-encryption-and-integrity.html#GUID-3A2AF4AA-AE3E-446B-8F64-31C48F27A2B5) (Sobre os valores para negociar criptografia e integridade) na documentação do Oracle. Como o cliente usado para oracle\$1fdw no Amazon RDS está configurado com `ACCEPTED`, a criptografia depende da configuração do servidor de banco de dados do Oracle e utiliza a Oracle Security Library (libnnz) para isso. Se o banco de dados estiver no RDS for Oracle, consulte [Criptografia de rede nativa do Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.Options.NetworkEncryption.html) para configurar a criptografia. ## Noções básicas da visualização e das permissões de pg\$1user\$1mappings O catálogo PostgreSQL `pg_user_mapping` armazena o mapeamento de um usuário do RDS for PostgreSQL para o usuário em um servidor de dados externo (remoto). O acesso ao catálogo é restrito, mas você usa a visualização `pg_user_mappings` para ver os mapeamentos. Veja a seguir um exemplo que mostra como as permissões se aplicam a um banco de dados Oracle de exemplo, mas essas informações se aplicam de forma mais geral a qualquer wrapper de dados externo. Na saída a seguir, você pode encontrar funções e permissões mapeadas para três usuários de exemplo diferentes. Usuários eo `rdssu1` e `rdssu2` são membros da função `rds_superuser`, e `user1` não é. O exemplo usa o metacomando `\du` do `psql` para listar as funções existentes. ``` test=> \du List of roles Role name | Attributes | Member of -----------------+------------------------------------------------------------+------------------------------------------------------------- rdssu1 | | {rds_superuser} rdssu2 | | {rds_superuser} user1 | | {} ``` Todos os usuários, incluindo aqueles com privilégios `rds_superuser`, têm permissão para visualizar seus próprios mapeamentos de usuário (`umoptions`) na tabela `pg_user_mappings`. Como mostrado no exemplo a seguir, quando `rdssu1` tenta obter todos os mapeamentos do usuário, é gerado um erro, mesmo com privilégios `rdssu1``rds_superuser`: ``` test=> SELECT * FROM pg_user_mapping; ERROR: permission denied for table pg_user_mapping ``` Veja a seguir alguns exemplos: ``` 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) ``` Devido às diferenças na implementação de `information_schema._pg_user_mappings` e `pg_catalog.pg_user_mappings`, um `rds_superuser` criado manualmente requer outras permissões para visualizar senhas no `pg_catalog.pg_user_mappings`. Nenhuma permissão adicional é necessária para um `rds_superuser` visualizar senhas no `information_schema._pg_user_mappings`. Usuários que não tenham a função `rds_superuser` poderão visualizar senhas em `pg_user_mappings` somente nas seguintes condições: + O usuário atual é o usuário que está sendo mapeado e é proprietário do servidor ou mantém o privilégio `USAGE` sobre ele. + O usuário atual é o proprietário do servidor, e o mapeamento é para `PUBLIC`. # Trabalhar com bancos de dados do SQL Server usando a extensão tds\$1fdw Você pode usar a extensão `tds_fdw` do PostgreSQL para acessar bancos de dados compatíveis com o protocolo de fluxo de dados tabular (TDS), como bancos de dados do Sybase e do Microsoft SQL Server. Esse invólucro de dados externos permite que você se conecte pela instância de banco de dados do RDS for PostgreSQL a bancos de dados que usam o protocolo TDS, incluindo o Amazon RDS for Microsoft SQL Server. Para obter mais informações, consulte a documentação do [tds-fdw/tds\$1fdw](https://github.com/tds-fdw/tds_fdw) no GitHub. A extensão `tds_fdw` é compatível com o Amazon RDS for PostgreSQL versões 14.2, 13.6 e posteriores. ## Configurar o banco de dados do RDS for PostgreSQL para usar a extensão tds\$1fdw Nos procedimentos a seguir, você pode encontrar um exemplo de configuração e uso de `tds_fdw` com uma instância de banco de dados do RDS for PostgreSQL. Antes de se conectar a um banco de dados do SQL Server usando `tds_fdw`, é necessário obter os seguintes detalhes da instância: + Nome de host ou endpoint. Para uma instância de banco de dados do RDS for SQL Server, você pode encontrar o endpoint usando o console. Escolha a guia “Connectivity & security” (Conectividade e segurança) e procure na seção “Endpoint and port” (Endpoint e porta). + Número da porta. O número da porta padrão para o Microsoft SQL Server é 1433. + O nome do banco de dados. O identificador do banco de dados. Você também precisa fornecer acesso no grupo de segurança ou na lista de controle de acesso (ACL) para a porta 1433 do SQL Server. Tanto a instância de banco de dados do RDS for PostgreSQL como a instância de banco de dados do RDS for SQL Server precisam de acesso à porta 1433. Se o acesso não estiver configurado corretamente, ao tentar consultar o Microsoft SQL Server, será exibida a seguinte mensagem de erro: ``` 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 ``` **Para usar tds\$1fdw a fim de se conectar a um banco de dados do SQL Server** 1. Conecte-se à instância de banco de dados do PostgreSQL usando uma conta que tenha a função `rds_superuser`: ``` psql --host=your-DB-instance.aws-region.rds.amazonaws.com --port=5432 --username=test –-password ``` 1. Instale a extensão `tds_fdw`: ``` test=> CREATE EXTENSION tds_fdw; CREATE EXTENSION ``` Depois que a extensão for instalada na instância de banco de dados do RDS for PostgreSQL, configure o servidor externo. **Para criar o servidor externo** Execute essas tarefas na instância de banco de dados do RDS for PostgreSQL usando uma conta com privilégios `rds_superuser`. 1. Crie um servidor externo na instância de banco de dados do RDS para 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 ``` Para acessar dados não ASCII do lado do SQLServer, crie um link de servidor com a opção character\$1set na instância de banco de dados do RDS para 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. Conceda uso a um usuário que não tenha permissões da função `rds_superuser`; por exemplo, `user1`: ``` test=> GRANT USAGE ON FOREIGN SERVER sqlserverdb TO user1; ``` 1. Conecte-se como user1 e, em seguida, crie um mapeamento para um usuário do SQL Server: ``` test=> CREATE USER MAPPING FOR user1 SERVER sqlserverdb OPTIONS (username 'sqlserveruser', password 'password'); CREATE USER MAPPING ``` 1. Crie uma tabela externa vinculada a uma tabela do SQL Server: ``` test=> CREATE FOREIGN TABLE mytab (a int) SERVER sqlserverdb OPTIONS (table 'MYTABLE'); CREATE FOREIGN TABLE ``` 1. Consulte a tabela externa: ``` test=> SELECT * FROM mytab; a --- 1 (1 row) ``` ### Usar criptografia em trânsito para a conexão A conexão do RDS for PostgreSQL com o SQL Server usa criptografia em trânsito (TLS/SSL), dependendo da configuração do banco de dados do SQL Server. Se o SQL Server não estiver configurado para criptografia, o cliente do RDS for PostgreSQL que faz a solicitação ao banco de dados do SQL Server retornará ao estado de não criptografado. Você pode aplicar a criptografia para a conexão com instâncias de banco de dados do RDS for SQL Server definindo o parâmetro `rds.force_ssl`. Para saber como, consulte [Forçar conexões com a instância de banco de dados para usar SSL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.Concepts.General.SSL.Using.html#SQLServer.Concepts.General.SSL.Forcing). Para obter mais informações sobre a configuração de SSL/TLS para o RDS for SQL Server, consulte [Usar SSL com uma instância de banco de dados do Microsoft SQL Server](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.Concepts.General.SSL.Using.html).