Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Bekerja dengan pembungkus data asing yang didukung untuk Amazon Aurora PostgreSQL Pembungkus data asing (FDW) adalah jenis ekstensi tertentu yang memberikan akses ke data eksternal. Misalnya, ekstensi `oracle_fdw` memungkinkan instans DB Aurora PostgreSQL bekerja dengan basis data Oracle. Selanjutnya, Anda dapat menemukan informasi tentang beberapa pembungkus data asing PostgreSQL yang didukung. **Topics** + [ # Menggunakan ekstensi log\$1fdw untuk mengakses log DB dengan SQL ](CHAP_PostgreSQL.Extensions.log_fdw.md) + [ # Menggunakan ekstensi postgres\$1fdw untuk mengakses data eksternal ](postgresql-commondbatasks-fdw.md) + [ # Bekerja dengan basis data MySQL menggunakan ekstensi mysql\$1fdw ](postgresql-mysql-fdw.md) + [ # Bekerja dengan basis data Oracle menggunakan ekstensi oracle\$1fdw ](postgresql-oracle-fdw.md) + [ # Bekerja dengan database SQL Server dengan menggunakan ekstensi tds\$1fdw ](postgresql-tds-fdw.md) # Menggunakan ekstensi log\$1fdw untuk mengakses log DB dengan SQL Klaster DB Aurora PostgreSQL mendukung ekstensi `log_fdw` yang dapat Anda gunakan untuk mengakses log mesin basis data menggunakan antarmuka SQL.​ Ekstensi `log_fdw` ini memberikan dua fungsi yang memudahkan pembuatan tabel asing untuk log basis data: + `list_postgres_log_files` – Mencantumkan file di direktori log basis data dan ukuran file dalam byte. + `create_foreign_table_for_log_file(table_name text, server_name text, log_file_name text)` – Membangun tabel asing untuk file yang ditentukan dalam basis data saat ini. Semua fungsi yang dibuat oleh `log_fdw` dimiliki oleh `rds_superuser`. Anggota dengan peran `rds_superuser` dapat memberikan akses ke fungsi ini kepada pengguna basis data lain. Secara default, file log dibuat oleh Amazon Aurora dalam format `stderr` (kesalahan standar), seperti yang ditentukan pada parameter `log_destination`. Hanya ada dua opsi untuk parameter ini, yaitu `stderr` dan `csvlog` (nilai yang dipisahkan koma, CSV). Jika Anda menambahkan opsi `csvlog` ke parameter, Amazon Aurora akan membuat log `stderr` dan `csvlog`. Hal ini dapat memengaruhi kapasitas penyimpanan pada klaster DB sehingga Anda perlu mengetahui parameter lain yang memengaruhi penanganan log. Untuk informasi selengkapnya, lihat [Mengatur tujuan log (`stderr`, `csvlog`)](USER_LogAccess.Concepts.PostgreSQL.overview.parameter-groups.md#USER_LogAccess.Concepts.PostgreSQL.Log_Format). Salah satu manfaat pembuatan log `csvlog` adalah ekstensi `log_fdw` memungkinkan Anda membangun tabel asing dengan data yang terbagi dengan rapi menjadi beberapa kolom. Untuk melakukannya, instans Anda harus terkait dengan grup parameter DB kustom sehingga Anda dapat mengubah pengaturan `log_destination`. Untuk informasi selengkapnya tentang cara melakukannya, lihat [](USER_WorkingWithParamGroups.md). Contoh berikut mengasumsikan bahwa parameter `log_destination` mencakup `cvslog`. **Untuk menggunakan ekstensi log\$1fdw** 1. Instal ekstensi `log_fdw`. ``` postgres=> CREATE EXTENSION log_fdw; CREATE EXTENSION ``` 1. Buat server log sebagai pembungkus data asing. ``` postgres=> CREATE SERVER log_server FOREIGN DATA WRAPPER log_fdw; CREATE SERVER ``` 1. Pilih semua dari daftar file log. ``` postgres=> SELECT * FROM list_postgres_log_files() ORDER BY 1; ``` Respons sampel sebagai berikut. ``` 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. Membuat tabel dengan satu kolom 'log\$1entry' untuk file yang dipilih. ``` postgres=> SELECT create_foreign_table_for_log_file('my_postgres_error_log', 'log_server', 'postgresql.log.2023-08-09-22.csv'); ``` Respons tersebut tidak memberikan detail selain memberitahukan bahwa tabel telah ada. ``` ----------------------------------- (1 row) ``` 1. Pilih sampel file log. Kode berikut mengambil waktu log dan deskripsi pesan kesalahan. ``` postgres=> SELECT log_time, message FROM my_postgres_error_log ORDER BY 1; ``` Respons sampel sebagai berikut. ``` 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) ``` # Menggunakan ekstensi postgres\$1fdw untuk mengakses data eksternal Anda dapat mengakses data dalam tabel di server basis data jarak jauh dengan ekstensi [postgres\$1fdw](https://www.postgresql.org/docs/current/static/postgres-fdw.html). Jika Anda mengatur koneksi jarak jauh dari instans DB PostgreSQL, akses juga tersedia untuk replika baca Anda. **Untuk menggunakan postgres\$1fdw agar dapat mengakses server basis data jarak jauh** 1. Instal ekstensi postgres\$1fdw. ``` CREATE EXTENSION postgres_fdw; ``` 1. Buat server data asing menggunakan CREATE SERVER. ``` CREATE SERVER foreign_server FOREIGN DATA WRAPPER postgres_fdw OPTIONS (host 'xxx.xx.xxx.xx', port '5432', dbname 'foreign_db'); ``` 1. Buat pemetaan pengguna untuk mengidentifikasi peran yang akan digunakan pada server jarak jauh. **penting** Untuk menyunting kata sandi sehingga tidak muncul di log, atur `log_statement=none` pada tingkat sesi. Pengaturan pada tingkat parameter tidak menyunting kata sandi. ``` CREATE USER MAPPING FOR local_user SERVER foreign_server OPTIONS (user 'foreign_user', password 'password'); ``` 1. Buat tabel yang memetakan ke tabel pada server jarak jauh. ``` CREATE FOREIGN TABLE foreign_table ( id integer NOT NULL, data text) SERVER foreign_server OPTIONS (schema_name 'some_schema', table_name 'some_table'); ``` # Bekerja dengan basis data MySQL menggunakan ekstensi mysql\$1fdw Untuk mengakses basis data yang kompatibel dengan MySQL dari klaster DB Aurora PostgreSQL , Anda dapat menginstal dan menggunakan ekstensi `mysql_fdw`. Pembungkus data asing ini memungkinkan Anda bekerja dengan basis data RDS for MySQL, Aurora MySQL, MariaDB, dan basis data MySQL lainnya yang kompatibel. Koneksi dari klaster DB Aurora PostgreSQL ke basis data MySQL dienkripsi secara optimal, tergantung pada konfigurasi klien dan server. Namun, Anda dapat menerapkan enkripsi jika diinginkan. Untuk informasi selengkapnya, lihat [Menggunakan enkripsi bergerak dengan ekstensi](#postgresql-mysql-fdw.encryption-in-transit). Ekstensi `mysql_fdw` didukung di Amazon Aurora PostgreSQL versi 15.4, 14.9, 13.12, 12.16, dan rilis yang lebih baru. Ekstensi ini mendukung untuk memilih, menyisipkan, memperbarui, dan menghapus dari DB RDS for PostgreSQL ke tabel pada instans basis data yang kompatibel dengan MySQL. **Topics** + [ ## Mengatur basis data Aurora PostgreSQL untuk menggunakan ekstensi mysql\$1fdw ](#postgresql-mysql-fdw.setting-up) + [ ## Contoh: Bekerja dengan basis data Aurora MySQL dari Aurora PostgreSQL ](#postgresql-mysql-fdw.using-mysql_fdw) + [ ## Menggunakan enkripsi bergerak dengan ekstensi ](#postgresql-mysql-fdw.encryption-in-transit) ## Mengatur basis data Aurora PostgreSQL untuk menggunakan ekstensi mysql\$1fdw Mengatur ekstensi `mysql_fdw` pada klaster DB Aurora PostgreSQL melibatkan pemuatan ekstensi pada klaster DB , lalu membuat koneksi yang mengarah ke instans DB MySQL. Untuk tugas tersebut, Anda harus memiliki detail instans DB MySQL berikut: + Nama host atau titik akhir. Untuk klaster DB Aurora MySQL , Anda dapat menemukan titik akhir menggunakan Konsol. Pilih tab Konektivitas & keamanan, lalu lihat di bagian "Titik akhir dan port". + Nomor port. Nomor port default untuk MySQL adalah 3306. + Nama basis data. Pengidentifikasi DB. Anda juga perlu memberikan akses di grup keamanan atau daftar kontrol akses (ACL) untuk port MySQL, 3306. Baik klaster DB Aurora PostgreSQL dan klaster DB Aurora MySQL memerlukan akses ke port 3306. Jika akses tidak dikonfigurasi dengan benar, Anda akan melihat pesan kesalahan yang serupa dengan berikut ini saat mencoba menghubungkan ke tabel yang kompatibel dengan MySQL: ``` ERROR: failed to connect to MySQL: Can't connect to MySQL server on 'hostname.aws-region.rds.amazonaws.com:3306' (110) ``` Dalam prosedur berikut, Anda (sebagai akun `rds_superuser`) akan membuat server asing. Kemudian, Anda akan memberikan akses ke server asing untuk pengguna tertentu. Pengguna ini akan membuat pemetaan mereka sendiri ke akun pengguna MySQL yang sesuai untuk bekerja dengan instans DB MySQL. **Untuk menggunakan mysql\$1fdw agar dapat mengakses server basis data MySQL** 1. Hubungkan ke instans DB PostgreSQL Anda menggunakan akun yang memiliki peran `rds_superuser`. Jika Anda menerima default saat membuat klaster DB Aurora PostgreSQL , nama pengguna adalah `postgres`, dan Anda dapat terhubung menggunakan alat baris perintah `psql` sebagai berikut: ``` psql --host=your-DB-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres –-password ``` 1. Instal ekstensi `mysql_fdw` sebagai berikut: ``` postgres=> CREATE EXTENSION mysql_fdw; CREATE EXTENSION ``` Setelah ekstensi diinstal pada klaster DB Aurora PostgreSQL , Anda dapat mengatur server asing yang memberikan koneksi ke basis data MySQL. **Untuk membuat server asing** Lakukan tugas-tugas ini pada klaster DB Aurora PostgreSQL . Langkah-langkah ini mengasumsikan bahwa Anda terhubung sebagai pengguna dengan hak istimewa `rds_superuser`, seperti `postgres`. 1. Membuat server asing pada klaster DB 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. Berikan akses pengguna yang sesuai ke server asing. Pengguna yang diberi akses harus pengguna non-administrator, yaitu pengguna tanpa peran `rds_superuser`. ``` postgres=> GRANT USAGE ON FOREIGN SERVER mysql-db to user1; GRANT ``` Pengguna PostgreSQL membuat dan mengelola koneksi mereka ke basis data MySQL melalui server asing. ## Contoh: Bekerja dengan basis data Aurora MySQL dari Aurora PostgreSQL Misalnya, Anda memiliki tabel sederhana pada instans DB Aurora PostgreSQL . Pengguna Aurora PostgreSQL Anda ingin membuat kueri item (`SELECT`), `INSERT`, `UPDATE`, dan `DELETE` pada tabel tersebut. Asumsikan bahwa ekstensi `mysql_fdw` dibuat di instans DB RDS for PostgreSQL, seperti yang dijelaskan dalam prosedur sebelumnya. Setelah terhubung ke instans DB RDS for PostgreSQL sebagai pengguna yang memiliki hak istimewa `rds_superuser`, Anda dapat melanjutkan langkah-langkah berikut. 1. Pada instans DB Aurora PostgreSQL , buat server asing: ``` test=> CREATE SERVER mysqldb FOREIGN DATA WRAPPER mysql_fdw OPTIONS (host 'your-DB.aws-region.rds.amazonaws.com', port '3306'); CREATE SERVER ``` 1. Izinkan penggunaan kepada pengguna yang tidak memiliki izin `rds_superuser`, misalnya `user1`: ``` test=> GRANT USAGE ON FOREIGN SERVER mysqldb TO user1; GRANT ``` 1. Connect as*user1*, lalu buat pemetaan ke pengguna MySQL: ``` test=> CREATE USER MAPPING FOR user1 SERVER mysqldb OPTIONS (username 'myuser', password 'mypassword'); CREATE USER MAPPING ``` 1. Buat tabel asing yang dihubungkan ke tabel MySQL: ``` test=> CREATE FOREIGN TABLE mytab (a int, b text) SERVER mysqldb OPTIONS (dbname 'test', table_name ''); CREATE FOREIGN TABLE ``` 1. Jalankan kueri sederhana pada tabel asing: ``` test=> SELECT * FROM mytab; a | b ---+------- 1 | apple (1 row) ``` 1. Anda dapat menambahkan, mengubah, dan menghapus data dari tabel MySQL. Sebagai contoh: ``` test=> INSERT INTO mytab values (2, 'mango'); INSERT 0 1 ``` Jalankan lagi kueri `SELECT` untuk melihat hasilnya: ``` test=> SELECT * FROM mytab ORDER BY 1; a | b ---+------- 1 | apple 2 | mango (2 rows) ``` ## Menggunakan enkripsi bergerak dengan ekstensi Koneksi ke MySQL dari Aurora PostgreSQL menggunakan enkripsi bergerak (TLS/SSL) secara default. Namun, koneksi akan kembali ke non-enkripsi saat konfigurasi klien dan server berbeda. Anda dapat menerapkan enkripsi untuk semua koneksi yang keluar dengan menentukan opsi `REQUIRE SSL` pada akun pengguna RDS for MySQL. Pendekatan yang sama juga bekerja untuk akun pengguna MariaDB dan Aurora MySQL. Untuk akun pengguna MySQL yang dikonfigurasi ke `REQUIRE SSL`, upaya koneksi akan gagal jika koneksi tidak aman. Untuk menerapkan enkripsi akun pengguna basis data MySQL yang ada, Anda dapat menggunakan perintah `ALTER USER`. Sintaksis dapat berbeda-beda, bergantung pada versi MySQL, seperti yang ditunjukkan pada tabel berikut. Untuk informasi selengkapnya, lihat [ALTER USER](https://dev.mysql.com/doc/refman/8.0/en/alter-user.html) pada *Panduan Referensi MySQL*. | MySQL 5.7, MySQL 8.0 | MySQL 5.6 | | --- | --- | | `ALTER USER 'user'@'%' REQUIRE SSL;` | `GRANT USAGE ON *.* to 'user'@'%' REQUIRE SSL;` | Untuk informasi selengkapnya tentang ekstensi `mysql_fdw`, lihat dokumentasi [mysql\$1fdw](https://github.com/EnterpriseDB/mysql_fdw). # Bekerja dengan basis data Oracle menggunakan ekstensi oracle\$1fdw Untuk mengakses basis data Oracle dari klaster DB Aurora PostgreSQL , Anda dapat menginstal dan menggunakan ekstensi `oracle_fdw`. Ekstensi ini adalah pembungkus data asing untuk basis data Oracle. Untuk mempelajari selengkapnya tentang ekstensi ini, lihat dokumentasi [oracle\$1fdw](https://github.com/laurenz/oracle_fdw). Ekstensi `oracle_fdw` didukung pada Aurora PostgreSQL 12.7 (Amazon Aurora rilis 4.2) dan versi yang lebih baru. **Topics** + [ ## Mengaktifkan ekstensi oracle\$1fdw ](#postgresql-oracle-fdw.enabling) + [ ## Contoh: Menggunakan server asing yang terhubung ke basis data Amazon RDS for Oracle ](#postgresql-oracle-fdw.example) + [ ## Bekerja dengan enkripsi bergerak ](#postgresql-oracle-fdw.encryption) + [ ## Memahami tampilan dan izin pg\$1user\$1mappings ](#postgresql-oracle-fdw.permissions) ## Mengaktifkan ekstensi oracle\$1fdw Untuk menggunakan ekstensi oracle\$1fdw, lakukan prosedur berikut. **Untuk mengaktifkan ekstensi oracle\$1fdw** + Jalankan perintah berikut menggunakan akun yang memiliki izin `rds_superuser`. ``` CREATE EXTENSION oracle_fdw; ``` ## Contoh: Menggunakan server asing yang terhubung ke basis data Amazon RDS for Oracle Contoh berikut ini menunjukkan penggunaan server asing yang terhubung ke basis data Amazon RDS for Oracle. **Untuk membuat server asing yang terhubung ke basis data RDS for Oracle** 1. Perhatikan hal-hal berikut ini pada instans DB RDS for Oracle: + Titik Akhir + Port + Nama basis data 1. Membuat server asing. ``` test=> CREATE SERVER oradb FOREIGN DATA WRAPPER oracle_fdw OPTIONS (dbserver '//endpoint:port/DB_name'); CREATE SERVER ``` 1. Izinkan penggunaan kepada pengguna yang tidak memiliki hak istimewa `rds_superuser`, misalnya `user1`. ``` test=> GRANT USAGE ON FOREIGN SERVER oradb TO user1; GRANT ``` 1. Hubungkan sebagai `user1`, lalu buat pemetaan kepada pengguna Oracle. ``` test=> CREATE USER MAPPING FOR user1 SERVER oradb OPTIONS (user 'oracleuser', password 'mypassword'); CREATE USER MAPPING ``` 1. Buat tabel asing yang dihubungkan ke tabel Oracle. ``` test=> CREATE FOREIGN TABLE mytab (a int) SERVER oradb OPTIONS (table 'MYTABLE'); CREATE FOREIGN TABLE ``` 1. Buat kueri tabel asing. ``` test=> SELECT * FROM mytab; a --- 1 (1 row) ``` Jika kueri melaporkan kesalahan berikut, periksa grup keamanan dan daftar kontrol akses (ACL) untuk memastikan bahwa kedua instans dapat berkomunikasi. ``` ERROR: connection for foreign table "mytab" cannot be established DETAIL: ORA-12170: TNS:Connect timeout occurred ``` ## Bekerja dengan enkripsi bergerak PostgreSQL-to-Oracle enkripsi dalam perjalanan didasarkan pada kombinasi parameter konfigurasi klien dan server. Untuk contoh menggunakan Oracle 21c, lihat [Tentang Nilai untuk Melakukan Negosiasi Enkripsi dan Integritas](https://docs.oracle.com/en/database/oracle/oracle-database/21/dbseg/configuring-network-data-encryption-and-integrity.html#GUID-3A2AF4AA-AE3E-446B-8F64-31C48F27A2B5) pada dokumentasi Oracle. Klien yang digunakan untuk oracle\$1fdw di Amazon RDS dikonfigurasi `ACCEPTED` dengan, artinya enkripsi bergantung pada konfigurasi server database Oracle dan menggunakan Oracle Security Library (libnnz) untuk enkripsi. Jika basis data Anda menggunakan RDS for Oracle, lihat [Enkripsi jaringan asli Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.Options.NetworkEncryption.html) untuk mengonfigurasi enkripsi. ## Memahami tampilan dan izin pg\$1user\$1mappings Katalog PostgreSQL `pg_user_mapping` menyimpan pemetaan dari pengguna Aurora PostgreSQL ke pengguna di server data asing (jarak jauh). Akses ke katalog dibatasi, tetapi Anda menggunakan tampilan `pg_user_mappings` untuk melihat pemetaan. Berikut ini Anda dapat menemukan contoh yang menunjukkan bagaimana izin berlaku dengan contoh basis data Oracle, tetapi informasi ini biasanya berlaku untuk pembungkus data asing apa pun. Pada output berikut, Anda dapat menemukan peran dan izin yang dipetakan kepada tiga pengguna contoh yang berbeda. Pengguna `rdssu1` dan `rdssu2` adalah anggota dengan peran `rds_superuser`, sedangkan `user1` tidak. Contoh menggunakan metacommand `psql` `\du` untuk daftar peran yang ada. ``` test=> \du List of roles Role name | Attributes | Member of -----------------+------------------------------------------------------------+------------------------------------------------------------- rdssu1 | | {rds_superuser} rdssu2 | | {rds_superuser} user1 | | {} ``` Semua pengguna, termasuk pengguna yang memiliki hak istimewa `rds_superuser`, diizinkan untuk melihat pemetaan pengguna (`umoptions`) mereka sendiri di tabel `pg_user_mappings`. Seperti yang ditunjukkan pada contoh berikut, saat `rdssu1` mencoba untuk mendapatkan semua pemetaan pengguna, kesalahan ditampilkan meskipun hak istimewa `rdssu1` `rds_superuser`: ``` test=> SELECT * FROM pg_user_mapping; ERROR: permission denied for table pg_user_mapping ``` Berikut adalah beberapa contoh. ``` 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) ``` Karena perbedaan implementasi antara `information_schema._pg_user_mappings` dan `pg_catalog.pg_user_mappings`, maka `rds_superuser` yang dibuat secara manual memerlukan izin tambahan untuk dapat melihat kata sandi di `pg_catalog.pg_user_mappings`. `rds_superuser` tidak memerlukan izin tambahan untuk dapat melihat kata sandi di `information_schema._pg_user_mappings`. Pengguna yang tidak memiliki peran `rds_superuser` dapat melihat kata sandi `pg_user_mappings` hanya dalam kondisi berikut: + Pengguna saat ini adalah pengguna yang dipetakan dan memiliki server atau memegang hak istimewa `USAGE` atas server tersebut. + Pengguna saat ini adalah pemilik server dan pemetaannya untuk `PUBLIC`. # Bekerja dengan database SQL Server dengan menggunakan ekstensi tds\$1fdw Anda dapat menggunakan SQL `tds_fdw` ekstensi Postgre untuk mengakses database yang mendukung protokol aliran data tabular (TDS), seperti database Sybase dan Microsoft Server. SQL Pembungkus data asing ini memungkinkan Anda terhubung dari cluster SQL DB Postgre DB ke database yang menggunakan protokol, TDS termasuk Amazon untuk Microsoft Server. RDS RDS SQL Untuk informasi selengkapnya, lihat dokumentasi [tds-fdw/tds\$1fdw](https://github.com/tds-fdw/tds_fdw) di. GitHub `tds_fdw`Ekstensi ini didukung pada Amazon Aurora Postgre SQL versi 13.6 dan rilis yang lebih tinggi. ## Menyiapkan Aurora Postgre SQL DB Anda untuk menggunakan ekstensi tds\$1fdw Dalam prosedur berikut, Anda dapat menemukan contoh pengaturan dan penggunaan `tds_fdw` dengan cluster. SQL Sebelum Anda dapat terhubung ke database SQL Server menggunakan`tds_fdw`, Anda perlu mendapatkan rincian berikut untuk contoh: + Nama host atau titik akhir. Untuk instans RDS for SQL Server DB, Anda dapat menemukan titik akhir dengan menggunakan Console. Pilih tab Konektivitas & keamanan, lalu lihat di bagian "Titik akhir dan port". + Nomor port. Nomor port default untuk Microsoft SQL Server adalah 1433. + Nama basis data. Pengidentifikasi DB. Anda juga perlu menyediakan akses pada grup keamanan atau daftar kontrol akses (ACL) untuk port SQL Server, 1433. Baik cluster Aurora Postgre SQL DB RDS RDS untuk SQL Server DB memerlukan akses ke port 1433. Jika akses tidak dikonfigurasi dengan benar, ketika Anda mencoba untuk query Microsoft SQL Server Anda melihat pesan galat berikut: ``` 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 ``` **Untuk menggunakan tds\$1fdw untuk terhubung ke database Server SQL** 1. Connect ke instans Postgre SQL DB cluster utama menggunakan akun yang memiliki peran: `rds_superuser` ``` psql --host=your-cluster-name-instance-1.aws-region.rds.amazonaws.com --port=5432 --username=test –-password ``` 1. Instal ekstensi `tds_fdw`: ``` test=> CREATE EXTENSION tds_fdw; CREATE EXTENSION ``` Setelah ekstensi diinstal pada cluster Aurora Postgre SQL DB Anda , Anda mengatur server asing. **Untuk membuat server asing** Lakukan tugas-tugas ini di cluster Aurora Postgre SQL DB RDS menggunakan akun yang memiliki hak istimewa. `rds_superuser` 1. Buat server asing di cluster Aurora Postgre SQL DB instance Postgre DB: SQL ``` 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 ``` ``` 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. Berikan izin kepada pengguna yang tidak memiliki hak istimewa peran `rds_superuser`, misalnya `user1`: ``` test=> GRANT USAGE ON FOREIGN SERVER sqlserverdb TO user1; ``` 1. Connect as user1 dan buat pemetaan ke pengguna SQL Server: ``` test=> CREATE USER MAPPING FOR user1 SERVER sqlserverdb OPTIONS (username 'sqlserveruser', password 'password'); CREATE USER MAPPING ``` 1. Buat tabel asing yang ditautkan ke tabel SQL Server: ``` test=> CREATE FOREIGN TABLE mytab (a int) SERVER sqlserverdb OPTIONS (table 'MYTABLE'); CREATE FOREIGN TABLE ``` 1. Buat kueri tabel asing: ``` test=> SELECT * FROM mytab; a --- 1 (1 row) ``` ### Gunakan enkripsi bergerak untuk koneksi Koneksi dari Aurora Postgre SQL RDS ke SQL Server menggunakan enkripsi dalam transit (TLS/SSL) tergantung pada konfigurasi database Server. SQL Jika SQL Server tidak dikonfigurasi untuk enkripsi, SQL klien Postgre RDS untuk membuat permintaan ke database SQL Server akan kembali ke tidak terenkripsi. Anda dapat menerapkan enkripsi untuk koneksi ke RDS instans SQL Server DB dengan menyetel parameter. `rds.force_ssl` Untuk mempelajari caranya, lihat [Memaksa koneksi ke instans DB Anda untuk digunakan SSL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.Concepts.General.SSL.Using.html#SQLServer.Concepts.General.SSL.Forcing). Untuk informasi selengkapnya tentangSSL/TLSkonfigurasi RDS untuk SQL Server, lihat [Menggunakan SSL dengan instans Microsoft SQL Server DB](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/SQLServer.Concepts.General.SSL.Using.html).