Utilisation des encapsuleurs de données externes pris en charge pour Amazon RDS for PostgreSQL - Amazon Relational Database Service

Utilisation des encapsuleurs de données externes pris en charge pour Amazon RDS for PostgreSQL

Un wrapper de données externes (FDW) est un type d'extension spécifique qui permet d'accéder à des données externes. Par exemple, l'extension oracle_fdw permet à votre cluster de base de données RDS for PostgreSQL de fonctionner avec des bases de données Oracle. Autre exemple, en utilisant l'extension postgres_fdw native PostgreSQL, vous pouvez accéder aux données stockées dans des instances de base de données PostgreSQL externes à votre instance de base de données RDS for PostgreSQL.

Vous trouverez ci-dessous des informations sur plusieurs wrappers de données externes PostgreSQL pris en charge.

Utilisation de l'extension log_fdw pour accéder au journal de base de données à l'aide de SQL

RDS for PostgreSQL prend en charge l'extension log_fdw qui vous permet d'accéder au journal de votre moteur de base de données à l'aide d'une interface SQL. L'extension log_fdw fournit deux fonctions qui facilitent la création de tables source pour les journaux de base de données :

  • list_postgres_log_files – Répertorie les fichiers dans le répertoire du journal de base de données et indique la taille des fichiers en octets.

  • create_foreign_table_for_log_file(table_name text, server_name text, log_file_name text) – Crée un tableau source pour le fichier spécifié dans la base de données actuelle.

Toutes les fonctions créées par log_fdw appartiennent à rds_superuser. Les membres du rôle rds_superuser peuvent accorder l'accès à ces fonctions à d'autres utilisateurs de base de données.

Par défaut, les fichiers journaux sont générés par Amazon RDS au format stderr (erreur standard), comme spécifié dans le paramètre log_destination. Il n'y a que deux options pour ce paramètre, stderr et csvlog (valeurs séparées par des virgules, CSV). Si vous ajoutez l'option csvlog au paramètre, Amazon RDS génère les journaux stderr et csvlog. Cela peut affecter la capacité de stockage de votre instance, vous devez donc être conscient des autres paramètres qui affectent la gestion des journaux. Pour plus d'informations, consultez Définition de la destination du journal.

L'un des avantages de la génération de journaux csvlog est que l'extension log_fdw vous permet de créer des tables externes dont les données sont soigneusement réparties en plusieurs colonnes. Pour ce faire, votre instance doit être associée à un groupe de paramètres de base de données personnalisé afin que vous puissiez modifier le paramètre de log_destination. Pour plus d'informations sur la manière de procéder, consultez Utilisation de paramètres sur votre instance de base de données RDS for PostgreSQL.

L'exemple suivant suppose que le paramètre log_destination comprend le champ cvslog.

Pour utiliser l'extension log_fdw

  1. Procurez-vous l'extension log_fdw.

    postgres=> CREATE EXTENSION log_fdw; CREATE EXTENSION
  2. Créez le serveur de journal en tant que wrapper de données externes.

    postgres=> CREATE SERVER log_server FOREIGN DATA WRAPPER log_fdw; CREATE SERVER
  3. Sélectionnez l'ensemble des fichiers journaux d'une liste.

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

    Voici un exemple de réponse.

    file_name | file_size_bytes ------------------------------+----------------- postgresql.log.2016-08-09-22.csv | 1111 postgresql.log.2016-08-09-23.csv | 1172 postgresql.log.2016-08-10-00.csv | 1744 postgresql.log.2016-08-10-01.csv | 1102 (4 rows)
  4. Créez une table avec une seule colonne « log_entry » pour le fichier sélectionné.

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

    La réponse ne fournit aucun détail autre que l'existence de la table.

    ----------------------------------- (1 row)
  5. Sélectionnez un exemple de fichier journal. Le code suivant récupère l'heure du journal et la description du message d'erreur.

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

    Voici un exemple de réponse.

    log_time | message ----------------------------------+--------------------------------------------------------------------------- Tue Aug 09 15:45:18.172 2016 PDT | ending log output to stderr Tue Aug 09 15:45:18.175 2016 PDT | database system was interrupted; last known up at 2016-08-09 22:43:34 UTC Tue Aug 09 15:45:18.223 2016 PDT | checkpoint record is at 0/90002E0 Tue Aug 09 15:45:18.223 2016 PDT | redo record is at 0/90002A8; shutdown FALSE Tue Aug 09 15:45:18.223 2016 PDT | next transaction ID: 0/1879; next OID: 24578 Tue Aug 09 15:45:18.223 2016 PDT | next MultiXactId: 1; next MultiXactOffset: 0 Tue Aug 09 15:45:18.223 2016 PDT | oldest unfrozen transaction ID: 1822, in database 1 (7 rows)

Utilisation de l'extension postgres_fdw pour accéder à des données externes

Vous pouvez accéder aux données d'un tableau sur un serveur de bases de données distant à l'aide de l'extension postgres_fdw. Si vous configurez une connexion distante à partir de votre instance de base de données PostgreSQL, l'accès à votre réplica en lecture est également disponible.

Pour utiliser postgres_fdw pour accéder à un serveur de bases de données distant

  1. Installez l'extension postgres_fdw.

    CREATE EXTENSION postgres_fdw;
  2. Créez un serveur de données externes à l'aide de CREATE SERVER.

    CREATE SERVER foreign_server FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host 'xxx.xx.xxx.xx', port '5432', dbname 'foreign_db');
  3. Créez un mappage utilisateur pour identifier le rôle à utiliser sur le serveur distant.

    CREATE USER MAPPING FOR local_user SERVER foreign_server OPTIONS (user 'foreign_user', password 'password');
  4. Créez une table mappée à la table sur le serveur distant.

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

Travailler avec des bases de données MySQL en utilisant l'extension mysql_fdw

Pour accéder à une base de données compatible MySQL à partir de votre instance de base de données RDS for PostgreSQL, vous pouvez installer et utiliser l'extension mysql_fdw. Cet encapsuleur de données externes vous permet de travailler avec RDS for MySQL, Aurora MySQL, MariaDB et d'autres bases de données compatibles avec MySQL. La connexion de RDS for PostgreSQL à la base de données MySQL est chiffrée au mieux, en fonction des configurations du client et du serveur. Cependant, vous pouvez imposer le chiffrement si vous le souhaitez. Pour plus d'informations, consultez Utilisation du chiffrement en transit avec l'extension.

L'extension mysql_fdw est prise en charge sur Amazon RDS for PostgreSQL versions 14.2, 13.6 et ultérieures. Elle prend en charge la sélection, l'insertion, la mise à jour et la suppression d'une base de données RDS for PostgreSQL vers des tables sur une instance de base de données compatible MySQL.

Configuration de votre base de données RDS for PostgreSQL pour utiliser l'extension mysql_fdw

La configuration de l'extension mysql_fdw sur votre instance de base de données RDS for PostgreSQL implique le chargement de l'extension dans votre instance de base de données, puis la création du point de connexion à l'instance de base de données MySQL. Pour cette tâche, vous devez disposer des informations suivantes sur l'instance de base de données MySQL :

  • Nom d'hôte ou point de terminaison. Pour une instance de base de données RDS for MySQL, vous pouvez trouver le point de terminaison en utilisant la console. Sélectionnez l'onglet Connectivity & security (Connectivité et sécurité) et regardez dans la section « Endpoint and port » (Point de terminaison et port).

  • Numéro de port. Le numéro de port par défaut pour MySQL est 3306.

  • Nom du moteur de la base de données. L'identifiant de la base de données.

Vous devez également fournir un accès sur le groupe de sécurité ou la liste de contrôle d'accès (ACL) pour le port MySQL 3306. L'instance de base de données RDS for PostgreSQL et l'instance de base de données RDS for MySQL doivent toutes deux avoir accès au port 3306. Si l'accès n'est pas configuré correctement, lorsque vous essayez de vous connecter à une table compatible avec MySQL, vous voyez apparaître un message d'erreur similaire au suivant :

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

Dans la procédure suivante, vous (en tant que compte rds_superuser) créez le serveur externe. Vous accordez ensuite l'accès au serveur externe à des utilisateurs spécifiques. Ces utilisateurs créent ensuite leurs propres mappages vers les comptes utilisateurs MySQL appropriés pour travailler avec l'instance de base de données MySQL.

Pour utiliser mysql_fdw pour accéder à un serveur de base de données MySQL

  1. Connectez-vous à votre instance de base de données PostgreSQL en utilisant un compte qui a le rôle rds_superuser. Si vous avez accepté les valeurs par défaut lors de la création de votre instance de base de données RDS for PostgreSQL, le nom d'utilisateur est postgres et vous pouvez vous connecter à l'aide de l'outil de ligne de commande psql comme suit :

    psql --host=your-DB-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres –-password
  2. Installez l'extension mysql_fdw comme suit :

    postgres=> CREATE EXTENSION mysql_fdw; CREATE EXTENSION

Une fois l'extension installée sur votre instance de base de données RDS for PostgreSQL, vous devez configurer le serveur externe qui fournit la connexion à une base de données MySQL.

Pour créer le serveur externe

Effectuez ces tâches sur l'instance de base de données RDS for PostgreSQL. Les étapes supposent que vous êtes connecté en tant qu'utilisateur avec des privilèges rds_superuser, tels que postgres.

  1. Créez un serveur externe dans l'instance de base de données RDS for PostgreSQL :

    postgres=> CREATE SERVER mysql-db FOREIGN DATA WRAPPER mysql_fdw OPTIONS (host 'db-name.111122223333.aws-region.rds.amazonaws.com', port '3306'); CREATE SERVER
  2. Accordez aux utilisateurs appropriés l'accès au serveur externe. Il doit s'agir d'utilisateurs non administrateurs, c'est-à-dire d'utilisateurs sans rôle rds_superuser.

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

Les utilisateurs de PostgreSQL créent et gèrent leurs propres connexions à la base de données MySQL via le serveur externe.

Exemple : utilisation d'une base de données RDS for MySQL à partir de RDS for PostgreSQL

Supposons que vous ayez une table simple sur une instance de base de données RDS for MySQL. Vos utilisateurs RDS for PostgreSQL souhaitent interroger les éléments (SELECT), INSERT, UPDATE et DELETE sur cette table. Supposons que l'extension mysql_fdw a été créée sur votre instance de base de données RDS for PostgreSQL, comme indiqué dans la procédure précédente. Après vous être connecté à l'instance de base de données RDS for PostgreSQL en tant qu'utilisateur disposant de privilèges rds_superuser, vous pouvez procéder aux étapes suivantes.

  1. Sur l'instance de base de données RDS for PostgreSQL, créez un serveur externe :

    test=> CREATE SERVER mysqldb FOREIGN DATA WRAPPER mysql_fdw OPTIONS (host 'your-DB.aws-region.rds.amazonaws.com', port '3306'); CREATE SERVER
  2. Accordez l'utilisation à un utilisateur dépourvu d'autorisations rds_superuser, par exemple user1 :

    test=> GRANT USAGE ON FOREIGN SERVER mysqldb TO user1; GRANT
  3. Connectez-vous en tant que user1, puis créez un mappage vers l'utilisateur MySQL :

    test=> CREATE USER MAPPING FOR user1 SERVER mysqldb OPTIONS (username 'myuser', password 'mypassword'); CREATE USER MAPPING
  4. Créez une table externe liée à la table MySQL :

    test=> CREATE FOREIGN TABLE mytab (a int, b text) SERVER mysqldb OPTIONS (dbname 'test', table_name ''); CREATE FOREIGN TABLE
  5. Exécutez une requête simple dans la table externe :

    test=> SELECT * FROM mytab; a | b ---+------- 1 | apple (1 row)
  6. Vous pouvez ajouter, modifier et supprimer des données de la table MySQL. Par exemple :

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

    Exécutez à nouveau la requête SELECT pour voir les résultats :

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

Utilisation du chiffrement en transit avec l'extension

La connexion à MySQL depuis RDS for PostgreSQL utilise le chiffrement en transit (TLS/SSL) par défaut. Toutefois, la connexion redevient non chiffrée lorsque la configuration du client et du serveur diffère. Vous pouvez imposer le chiffrement pour toutes les connexions sortantes en spécifiant l'option REQUIRE SSL sur les comptes d'utilisateur RDS for MySQL. Cette même approche fonctionne également pour les comptes utilisateurs MariaDB et Aurora MySQL.

Pour les comptes utilisateurs MySQL configurés pour REQUIRE SSL, la tentative de connexion échoue si une connexion sécurisée ne peut être établie.

Pour appliquer le chiffrement aux comptes d'utilisateurs de bases de données MySQL existants, vous pouvez utiliser la commande ALTER USER. La syntaxe varie en fonction de la version MySQL, comme indiqué dans le tableau suivant. Pour plus d'informations, consultez ALTER USER dans le Manuel de référence de MySQL.

MySQL 5.7 vers MySQL 8 MySQL 5.6

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

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

Pour plus d'informations sur l'extension mysql_fdw, consultez la documentation mysql_fdw.

Utilisation des bases de données Oracle avec l'extension oracle_fdw

Pour accéder à une base de données Oracle depuis votre instance de base de données RDS for PostgreSQL, vous pouvez installer et utiliser l'extension oracle_fdw. Cette extension est un wrapper de données externes pour les bases de données Oracle. Pour en savoir plus sur cette extension, veuillez consulter la documentation oracle_fdw.

L'extension oracle_fdw est prise en charge sur RDS pour PostgreSQL 12.7, 13.3 et les versions ultérieures.

Activation de l'extension oracle_fdw

Pour utiliser l'extension oracle_fdw, suivez la procédure suivante.

Pour activer l'extension oracle_fdw

  • Exécutez la commande suivante en utilisant un compte disposant d'autorisations rds_superuser.

    CREATE EXTENSION oracle_fdw;

Exemple : utilisation d'un serveur externe lié à une base de données Amazon RDS for Oracle Database

Les exemples suivants démontrent l'utilisation d'un serveur externe lié à une base de données Amazon RDS for Oracle.

Pour créer un serveur externe lié à une base de données RDS for Oracle

  1. Notez ce qui suit sur l'instance de base de données RDS for Oracle :

    • Point de terminaison

    • Port

    • Nom de base de données

  2. Créez un serveur externe.

    test=> CREATE SERVER oradb FOREIGN DATA WRAPPER oracle_fdw OPTIONS (dbserver '//endpoint:port/DB_name'); CREATE SERVER
  3. Accordez l'utilisation à un utilisateur dépourvu d'autorisations rds_superuser, par exemple user1.

    test=> GRANT USAGE ON FOREIGN SERVER oradb TO user1; GRANT
  4. Connectez-vous en tant que user1 et créez un mappage à un utilisateur Oracle.

    test=> CREATE USER MAPPING FOR user1 SERVER oradb OPTIONS (user 'oracleuser', password 'mypassword'); CREATE USER MAPPING
  5. Créez une table externe liée à une table Oracle.

    test=> CREATE FOREIGN TABLE mytab (a int) SERVER oradb OPTIONS (table 'MYTABLE'); CREATE FOREIGN TABLE
  6. Interrogez la table externe.

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

Si la requête signale l'erreur suivante, vérifiez votre groupe de sécurité et votre liste de contrôle d'accès (ACL) pour vous assurer que les deux instances peuvent communiquer.

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

Utilisation du chiffrement en transit

Le chiffrement PostgreSQL vers Oracle en transit est basé sur une combinaison de paramètres de configuration client et serveur. Pour un exemple d'utilisation d'Oracle 21c, consultez A propos de la négociation du chiffrement et de l'intégrité dans la documentation Oracle. Le client utilisé pour oracle_fdw sur Amazon RDS est configuré avec ACCEPTED, ce qui signifie que le chiffrement dépend de la configuration du serveur de base de données Oracle.

Si votre base de données se trouve sur RDS for Oracle, consultez la section Oracle native network encryption (Chiffrement réseau natif Oracle) pour configurer le chiffrement.

Comprendre la vue et les autorisations pg_user_mappings

Le catalogue PostgreSQL pg_user_mapping stocke le mappage d'un utilisateur RDS for PostgreSQL vers l'utilisateur d'un serveur de données externe (distant). L'accès au catalogue est restreint, mais vous utilisez la vue pg_user_mappings pour visualiser les mappages. Dans ce qui suit, vous trouverez un exemple qui présente comment les autorisations s'appliquent avec un exemple de base de données Oracle, mais ces informations s'appliquent plus généralement à tout encapsuleur de données externes.

Dans la sortie suivante, vous pouvez trouver des rôles et des autorisations mappés à trois exemples d'utilisateurs différents. Les utilisateurs rdssu1 et rdssu2 sont membres du rôle rds_superuser, et user1 ne l'est pas. L'exemple utilise la métacommande psql \du pour lister les rôles existants.

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

Tous les utilisateurs, y compris ceux qui disposent de privilèges rds_superuser, sont autorisés à voir leurs propres mappages d'utilisateurs (umoptions) dans la table pg_user_mappings. Comme le montre l'exemple suivant, lorsque rdssu1 tente d'obtenir tous les mappages d'utilisateurs, une erreur s'affiche en dépit des privilèges rds_superuser de rdssu1 :

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

Voici quelques exemples.

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)

En raison des différences dans l'implémentation de information_schema._pg_user_mappings et de pg_catalog.pg_user_mappings, un rds_superuser créé manuellement nécessite des autorisations supplémentaires pour afficher les mots de passe dans pg_catalog.pg_user_mappings.

Un rds_superuser n'a besoin d'aucune autorisation supplémentaire pour afficher les mots de passe dans information_schema._pg_user_mappings.

Les utilisateurs qui n'ont pas le rôle rds_superuser peuvent afficher les mots de passe dans pg_user_mappings uniquement dans les conditions suivantes :

  • L'utilisateur actif est celui faisant l'objet du mappage. Il possède le serveur ou détient le privilège USAGE sur celui-ci.

  • L'utilisateur actuel est le propriétaire du serveur et le mappage est pour PUBLIC.

Utilisation de bases de données SQL Server avec l'extension tds_fdw

Vous pouvez utiliser l'extension PostgreSQL tds_fdw pour accéder aux bases de données qui prennent en charge le protocole TDS (tabular data stream), comme les bases de données Sybase et Microsoft SQL Server. Cet encapsuleur de données externes vous permet de vous connecter à partir de votre instance de base de données RDS for PostgreSQL ou de votre à des bases de données qui utilisent le protocole TDS, y compris Amazon RDS for Microsoft SQL Server. Pour plus d'informations, consultez la documentation de tds-fdw/tds_fdw sur GitHub.

L'extension tds_fdw est prise en charge sur Amazon RDS for PostgreSQL versions 14.2, 13.6 et ultérieures.

Configuration de votre base de données RDS pour PostgreSQL pour utiliser l'extension tds_fdw

Dans les procédures suivantes, vous trouverez un exemple de configuration et d'utilisation de tds_fdw avec une instance de base de données RDS for PostgreSQL. Avant de pouvoir vous connecter à une base de données SQL Server à l'aide de tds_fdw, vous devez obtenir les détails suivants pour l'instance :

  • Nom d'hôte ou point de terminaison. Pour une instance de base de données RDS for SQL Server, vous pouvez trouver le point de terminaison en utilisant la console. Sélectionnez l'onglet Connectivity & security (Connectivité et sécurité) et regardez dans la section « Endpoint and port » (Point de terminaison et port).

  • Numéro de port. Le numéro de port par défaut de Microsoft SQL Server est 1433.

  • Nom du moteur de la base de données. L'identifiant de la base de données.

Vous devez également fournir un accès au groupe de sécurité ou à la liste de contrôle d'accès (ACL) pour le port du serveur SQL 1433. l'instance de base de données RDS for PostgreSQL et l'instance de base de données RDS for SQL Server ont tou(te)s deux besoin d'accéder au port 1433. Si l'accès n'est pas configuré correctement, lorsque vous essayez d'interroger le serveur Microsoft SQL, le message d'erreur suivant s'affiche :

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

Pour utiliser tds_fdw pour vous connecter à une base de données SQL Server

  1. Connectez-vous à votre instance de base de données PostgreSQL en utilisant un compte qui dispose du rôle rds_superuser :

    psql --host=your-DB-instance.aws-region.rds.amazonaws.com --port=5432 --username=test –-password
  2. Installez l'extension tds_fdw :

    test=> CREATE EXTENSION tds_fdw; CREATE EXTENSION

Une fois l'extension installée sur votre instance de base de données RDS for PostgreSQL, vous configurez le serveur externe.

Pour créer le serveur externe

Effectuez ces tâches sur l'instance de base de données RDS for PostgreSQL en utilisant un compte qui dispose de privilèges rds_superuser.

  1. Créer un serveur externe dans l'instance de base de données RDS for PostgreSQL :

    test=> CREATE SERVER sqlserverdb FOREIGN DATA WRAPPER tds_fdw OPTIONS (servername 'mssql2019.aws-region.rds.amazonaws.com, port '1433', database 'tds_fdw_testing'); CREATE SERVER
  2. Accordez des autorisations à un utilisateur qui n'a pas de privilèges de rôle rds_superuser, par exemple, user1 :

    test=> GRANT USAGE ON FOREIGN SERVER sqlserverdb TO user1;
  3. Connectez-vous en tant que user1 et créez un mappage vers un utilisateur SQL Server :

    test=> CREATE USER MAPPING FOR user1 SERVER sqlserverdb OPTIONS (username 'sqlserveruser', password 'password'); CREATE USER MAPPING
  4. Créez une table externe liée à une table SQL Server :

    test=> CREATE FOREIGN TABLE mytab (a int) SERVER sqlserverdb OPTIONS (table 'MYTABLE'); CREATE FOREIGN TABLE
  5. Interrogez la table externe :

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

Utilisation du chiffrement en transit pour la connexion

La connexion de RDS for PostgreSQL à SQL Server utilise le chiffrement en transit (TLS/SSL) selon la configuration de la base de données SQL Server. Si le serveur SQL n'est pas configuré pour le chiffrement, le client RDS for PostgreSQL qui émet la requête à la base de données du serveur SQL revient au mode non chiffré.

Vous pouvez renforcer le chiffrement de la connexion aux instances de base de données RDS for SQL Server en définissant le paramètre rds.force_ssl. Pour savoir comment procéder, consultez Forcing connections to your DB instance to use SSL (Forcer les connexions à votre instance de base de données à utiliser SSL). Pour plus d'informations sur la configuration SSL/TLS pour RDS for SQL Server, consultez Using SSL with a Microsoft SQL Server DB instance (Utiliser SSL avec une instance de base de données Microsoft SQL Server).