Usar a extensão log_fdw Usar postgres_fdw para acessar dados externos Trabalhar com um banco de dados MySQL Trabalhar com um banco de dados Oracle Trabalhar com um banco de dados do SQL Server

Trabalhar com os invólucros de dados externos compatíveis do Amazon Aurora 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 a instância de banco de dados do Aurora PostgreSQL funcione com bancos de dados Oracle.

A seguir, você encontrará informações sobre vários invólucros de dados externos do PostgreSQL compatíveis.

Tópicos

Usar a extensão log_fdw para acessar o log de banco de dados usando SQL
Usar a extensão postgres_fdw para acessar dados externos
Trabalhar com bancos de dados MySQL usando a extensão mysql_fdw
Trabalhar com um banco de dados Oracle usando a extensão oracle_fdw
Trabalhar com bancos de dados do SQL Server usando a extensão tds_fdw

Usar a extensão log_fdw para acessar o log de banco de dados usando SQL

O cluster de banco de dados do Aurora PostgreSQL compatível com a extensãolog_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 Aurora 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 Aurora gerará os dois 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).

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 grupos de parâmetros.

O exemplo a seguir pressupõe que o parâmetro log_destination inclua cvslog.

Para usar a extensão log_fdw

Instale a extensão log_fdw.


postgres=> CREATE EXTENSION log_fdw;
CREATE EXTENSION

Crie o servidor de log como um wrapper externo de dados.


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

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)

Crie uma tabela com uma única coluna "log_entry" 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)

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_fdw para acessar dados externos

Você pode acessar dados em uma tabela em um servidor de banco de dados remoto com a extensão postgres_fdw. 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_fdw para acessar um servidor de banco de dados remoto

Instale a extensão postgres_fdw.
```
CREATE EXTENSION postgres_fdw;
```

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');

Crie um mapeamento de usuário para identificar a função a ser usada no servidor remoto.


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

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_fdw

Para acessar um banco de dados compatível com MySQL pelo cluster de banco de dados do Aurora 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 do cluster de banco de dados do Aurora PostgreSQL DB com o banco de dados do 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.

A extensão mysql_fdw é compatível com o Amazon Aurora PostgreSQL versões 15.4, 14.9, 13.12, 12.16, 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.

Tópicos

Configurar o banco de dados do Aurora PostgreSQL para usar a extensão mysql_fdw
Exemplo: trabalhar com um banco de dados do Aurora MySQL pelo Aurora PostgreSQL
Usar criptografia em trânsito com a extensão

Configurar o banco de dados do Aurora PostgreSQL para usar a extensão mysql_fdw

Para configurar a extensão mysql_fdw no cluster de banco de dados do Aurora PostgreSQL, é necessário carregar a extensão no cluster 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 um cluster de banco de dados do Aurora MySQL, 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 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 banco de dados do Aurora PostgreSQL como o cluster de banco de dados do Aurora . 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_fdw a fim de acessar um servidor de banco de dados MySQL

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 o cluster de banco de dados do Aurora 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
```

Instale a extensão mysql_fdw da seguinte forma:


postgres=> CREATE EXTENSION mysql_fdw;
CREATE EXTENSION

Depois que a extensão é instalada no cluster de banco de dados do Aurora PostgreSQL, você configurará o servidor externo que fornece a conexão com um banco de dados do MySQL.

Para criar o servidor externo

Execute essas tarefas no cluster de banco de dados do Aurora PostgreSQL. As etapas presumem que você esteja conectado como usuário com privilégios rds_superuser, como postgres.

Crie um servidor externo no cluster de banco de dados do 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

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 Aurora MySQL pelo Aurora PostgreSQL

Suponha que você tenha uma tabela simples em uma instância de banco de dados do Aurora PostgreSQL. Os usuários do Aurora 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.

Crie um servidor externo na instância de banco de dados do Aurora PostgreSQL:


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

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
```

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

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

Execute uma consulta simples na tabela externa:


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

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 Aurora 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 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_fdw.

Trabalhar com um banco de dados Oracle usando a extensão oracle_fdw

Para acessar um banco de dados Oracle pelo cluster de banco de dados do Aurora 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_fdw.

A extensão oracle_fdw é compatível com o Aurora PostgreSQL 12.7 (Amazon Aurora versão 4.2) e versões posteriores.

Tópicos

Ativação da extensão oracle_fdw
Exemplo: usar um servidor externo vinculado a um banco de dados Amazon RDS for Oracle
Como trabalhar com criptografia em trânsito
Noções básicas da visualização e das permissões de pg_user_mappings

Ativação da extensão oracle_fdw

Para usar a extensão oracle_fdw, realize o procedimento a seguir.

Para ativar a extensão oracle_fdw

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

Na instância de banco de dados do RDS for Oracle, observe:
- Endpoint
- Port
- Database name

Crie um servidor externo.


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

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
```

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

Crie uma tabela estrangeira vinculada a uma tabela Oracle.


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

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 (Sobre os valores para negociar criptografia e integridade) na documentação do Oracle. O cliente usado para oracle_fdw no Amazon RDS é configurado com ACCEPTED, portanto a criptografia depende da configuração do servidor de banco de dados do Oracle.

Se o banco de dados estiver no RDS for Oracle, consulte Criptografia de rede nativa do Oracle para configurar a criptografia.

Noções básicas da visualização e das permissões de pg_user_mappings

O catálogo PostgreSQL pg_user_mapping armazena o mapeamento de um usuário do Aurora 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 rdssu1rds_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_fdw

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 pelo cluster de banco de dados do Aurora 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_fdw no GitHub.

A extensão tds_fdw é compatível com o Amazon Aurora PostgreSQL versão 13.6 e posterior.

Configurar o banco de dados do Aurora PostgreSQL para usar a extensão tds_fdw

Nos procedimentos a seguir, você pode encontrar um exemplo de configuração e uso de tds_fdw com um cluster de banco de dados do Aurora 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 o cluster de banco de dados do Aurora 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_fdw a fim de se conectar a um banco de dados do SQL Server

Conecte-se à instância primária do cluster de banco de dados do Aurora PostgreSQL usando uma conta que tenha a função rds_superuser:
```
psql --host=your-cluster-name-instance-1.aws-region.rds.amazonaws.com --port=5432 --username=test –-password
```

Instale a extensão tds_fdw:


test=> CREATE EXTENSION tds_fdw;
CREATE EXTENSION

Depois que a extensão for instalada no cluster de banco de dados do Aurora PostgreSQL , configure o servidor externo.

Para criar o servidor externo

Execute essas tarefas no cluster de banco de dados do Aurora PostgreSQL usando uma conta com privilégios rds_superuser.

Crie um servidor externo no cluster de banco de dados do 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

Para acessar dados não ASCII do lado do SQLServer, crie um link de servidor com a opção character_set no cluster de banco de dados do 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

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;
```

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

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

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 Aurora 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. 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.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Usar pglogical para sincronizar dados

Trabalhar com Trusted Language Extensions para PostgreSQL