Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menangani ekstensi dan pembungkus data asing
Untuk memperluas fungsionalitas ke klaster Aurora Edisi Kompatibel PostgreSQL, Anda dapat menginstal dan menggunakan berbagai *ekstensi* PostgreSQL. Misalnya, jika kasus penggunaan Anda memerlukan entri data intensif di seluruh tabel yang sangat besar, Anda dapat menginstal ekstensi `[pg\$1partman](https://pgxn.org/dist/pg_partman/doc/pg_partman.html)` untuk mempartisi data dan dengan demikian menyebarkan beban kerja.
**catatan**
Mulai versi Aurora PostgreSQL 14.5, Aurora PostgreSQL mendukung Ekstensi Bahasa Tepercaya untuk PostgreSQL. Fitur ini diimplementasikan sebagai ekstensi `pg_tle`, yang dapat Anda tambahkan ke Aurora PostgreSQL Anda. Dengan ekstensi ini, developer dapat membuat ekstensi PostgreSQL mereka sendiri di lingkungan yang aman yang menyederhanakan persyaratan penyiapan dan konfigurasi, serta sebagian besar pengujian awal untuk ekstensi baru. Untuk informasi selengkapnya, lihat [Bekerja dengan Ekstensi Bahasa Tepercaya untuk PostgreSQL](PostgreSQL_trusted_language_extension.md).
Dalam beberapa kasus, daripada menginstal ekstensi, Anda dapat menambahkan *modul* tertentu ke daftar `shared_preload_libraries` dalam grup parameter klaster DB kustom klaster DB Aurora PostgreSQL. Biasanya, grup parameter klaster DB default hanya memuat `pg_stat_statements`, tetapi beberapa modul lain tersedia untuk ditambahkan ke daftar. Misalnya, Anda dapat menambahkan kemampuan penjadwalan dengan menambahkan modul `pg_cron`, seperti yang dijelaskan dalam [Menjadwalkan pemeliharaan dengan ekstensi pg\$1cron PostgreSQL](PostgreSQL_pg_cron.md). Sebagai contoh lain, Anda dapat membuat log rencana eksekusi kueri dengan memuat modul `auto_explain`. Untuk mempelajari selengkapnya, [lihat Mencatat rencana eksekusi kueri](https://aws.amazon.com/premiumsupport/knowledge-center/rds-postgresql-tune-query-performance/#) di pusat AWS pengetahuan.
Ekstensi yang memberikan akses ke data eksternal lebih khusus dikenal sebagai *pembungkus data asing* (FDW). Sebagai contoh, ekstensi `oracle_fdw` memungkinkan klaster DB Aurora PostgreSQL bekerja dengan basis data Oracle.
Anda juga dapat menentukan dengan tepat ekstensi yang dapat diinstal pada instans DB Aurora PostgreSQL, dengan mencantumkannya dalam parameter `rds.allowed_extensions`. Untuk informasi selengkapnya, lihat [Membatasi instalasi ekstensi PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.FeatureSupport.Extensions.Restriction.html).
Berikut ini, Anda dapat menemukan informasi tentang pengaturan dan menggunakan beberapa ekstensi, modul, dan FDWs tersedia untuk Aurora PostgreSQL. Untuk menyederhanakan, ini semua akan disebut sebagai "ekstensi". Anda dapat menemukan daftar ekstensi yang dapat digunakan dengan versi Aurora PostgreSQL yang tersedia saat ini, lihat [Versi ekstensi untuk Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html) dalam *Catatan Rilis untuk Aurora PostgreSQL*.
+ [Mengelola objek besar dengan modul lo](PostgreSQL_large_objects_lo_extension.md)
+ [Mengelola data spasial dengan ekstensi PostGIS](Appendix.PostgreSQL.CommonDBATasks.PostGIS.md)
+ [Mengelola partisi PostgreSQL dengan ekstensi pg\$1partman](PostgreSQL_Partitions.md)
+ [Menjadwalkan pemeliharaan dengan ekstensi pg\$1cron PostgreSQL](PostgreSQL_pg_cron.md)
+ [Menggunakan pgAudit untuk mencatat aktivitas database](Appendix.PostgreSQL.CommonDBATasks.pgaudit.md)
+ [Menggunakan pglogical untuk menyinkronkan data di seluruh instans](Appendix.PostgreSQL.CommonDBATasks.pglogical.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 dukungan ekstensi yang didelegasikan Amazon Aurora untuk PostgreSQL
Menggunakan dukungan ekstensi yang didelegasikan Amazon Aurora untuk PostgreSQL, Anda dapat mendelegasikan manajemen ekstensi kepada pengguna yang tidak perlu menjadi file. `rds_superuser` Dengan dukungan ekstensi yang didelegasikan ini, peran baru yang `rds_extension` disebut dibuat dan Anda harus menetapkan ini kepada pengguna untuk mengelola ekstensi lainnya. Peran ini dapat membuat, memperbarui, dan menjatuhkan ekstensi.
Anda dapat menentukan ekstensi yang dapat diinstal pada instance Aurora PostgreSQL DB Anda, dengan mencantumkannya di parameter. `rds.allowed_extensions` Untuk informasi selengkapnya, lihat [Menggunakan ekstensi PostgreSQL dengan Amazon RDS for PostgreSQL.](https://docs.aws.amazon.com//AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.Extensions.html)
Anda dapat membatasi daftar ekstensi yang tersedia yang dapat dikelola oleh pengguna dengan `rds_extension` peran menggunakan `rds.allowed_delegated_extensions` parameter.
Dukungan ekstensi yang didelegasikan tersedia dalam versi berikut:
+ Semua versi yang lebih tinggi
+ 15.5 dan versi 15 yang lebih tinggi
+ 14.10 dan versi 14 yang lebih tinggi
+ 13.13 dan 13 versi yang lebih tinggi
+ 12.17 dan versi 12 yang lebih tinggi
**Topics**
+ [Mengaktifkan dukungan ekstensi delegasi ke pengguna](#AuroraPostgreSQL.delegated_ext_mgmt)
+ [Konfigurasi yang digunakan dalam dukungan ekstensi yang didelegasikan Aurora untuk PostgreSQL](#AuroraPostgreSQL.delegated_ext_config)
+ [Mematikan dukungan untuk ekstensi yang didelegasikan](#AuroraPostgreSQL.delegated_ext_disable)
+ [Manfaat menggunakan dukungan ekstensi yang didelegasikan Amazon Aurora](#AuroraPostgreSQL.delegated_ext_benefits)
+ [Batasan dukungan ekstensi yang didelegasikan Aurora untuk PostgreSQL](#AuroraPostgreSQL.delegated_ext_limit)
+ [Izin diperlukan untuk ekstensi tertentu](#AuroraPostgreSQL.delegated_ext_perm)
+ [Pertimbangan Keamanan](#AuroraPostgreSQL.delegated_ext_sec)
+ [Jatuhkan kaskade ekstensi dinonaktifkan](#AuroraPostgreSQL.delegated_ext_drop)
+ [Contoh ekstensi yang dapat ditambahkan menggunakan dukungan ekstensi yang didelegasikan](#AuroraPostgreSQL.delegated_ext_support)
## Mengaktifkan dukungan ekstensi delegasi ke pengguna
Anda harus melakukan hal berikut untuk mengaktifkan dukungan ekstensi delegasi kepada pengguna:
1. **Berikan `rds_extension` peran kepada pengguna** - Connect ke database sebagai `rds_superuser` dan jalankan perintah berikut:
```
Postgres => grant rds_extension to user_name;
```
1. **Mengatur daftar ekstensi yang tersedia bagi pengguna yang didelegasikan untuk dikelola** — `rds.allowed_delegated_extensions` Memungkinkan Anda menentukan subset ekstensi yang tersedia menggunakan parameter `rds.allowed_extensions` cluster DB. Anda dapat melakukan ini di salah satu level berikut:
+ Di cluster atau grup parameter instance, melalui Konsol Manajemen AWS atau API. Untuk informasi selengkapnya, lihat [](USER_WorkingWithParamGroups.md).
+ Gunakan perintah berikut di tingkat database:
```
alter database database_name set rds.allowed_delegated_extensions = 'extension_name_1,
extension_name_2,...extension_name_n';
```
+ Gunakan perintah berikut di tingkat pengguna:
```
alter user user_name set rds.allowed_delegated_extensions = 'extension_name_1,
extension_name_2,...extension_name_n';
```
**catatan**
Anda tidak perlu me-restart database setelah mengubah parameter `rds.allowed_delegated_extensions` dinamis.
1. **Izinkan akses ke pengguna yang didelegasikan ke objek yang dibuat selama proses pembuatan ekstensi** - Ekstensi tertentu membuat objek yang memerlukan izin tambahan untuk diberikan sebelum pengguna dengan `rds_extension` peran dapat mengaksesnya. `rds_superuser`Harus memberikan akses pengguna yang didelegasikan ke objek tersebut. Salah satu opsi adalah menggunakan pemicu peristiwa untuk secara otomatis memberikan izin kepada pengguna yang didelegasikan.
**Contoh pemicu peristiwa**
Jika Anda ingin mengizinkan pengguna yang didelegasikan `rds_extension` untuk menggunakan ekstensi yang memerlukan izin pengaturan pada objek mereka yang dibuat oleh pembuatan ekstensi, Anda dapat menyesuaikan contoh pemicu peristiwa di bawah ini dan hanya menambahkan ekstensi yang Anda inginkan agar pengguna yang didelegasikan memiliki akses ke fungsionalitas penuh. Pemicu peristiwa ini dapat dibuat pada template1 (template default), oleh karena itu semua database yang dibuat dari template1 akan memiliki pemicu peristiwa itu. Ketika pengguna yang didelegasikan menginstal ekstensi, pemicu ini akan secara otomatis memberikan kepemilikan pada objek yang dibuat oleh ekstensi.
```
CREATE OR REPLACE FUNCTION create_ext()
RETURNS event_trigger AS $$
DECLARE
schemaname TEXT;
databaseowner TEXT;
r RECORD;
BEGIN
IF tg_tag = 'CREATE EXTENSION' and current_user != 'rds_superuser' THEN
RAISE NOTICE 'SECURITY INVOKER';
RAISE NOTICE 'user: %', current_user;
FOR r IN SELECT * FROM pg_catalog.pg_event_trigger_ddl_commands()
LOOP
CONTINUE WHEN r.command_tag != 'CREATE EXTENSION' OR r.object_type != 'extension';
schemaname = (
SELECT n.nspname
FROM pg_catalog.pg_extension AS e
INNER JOIN pg_catalog.pg_namespace AS n
ON e.extnamespace = n.oid
WHERE e.oid = r.objid
);
databaseowner = (
SELECT pg_catalog.pg_get_userbyid(d.datdba)
FROM pg_catalog.pg_database d
WHERE d.datname = current_database()
);
RAISE NOTICE 'Record for event trigger %, objid: %,tag: %, current_user: %, schema: %, database_owenr: %', r.object_identity, r.objid, tg_tag, current_user, schemaname, databaseowner;
IF r.object_identity = 'address_standardizer_data_us' THEN
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.us_gaz TO %I WITH GRANT OPTION;', schemaname, databaseowner);
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.us_lex TO %I WITH GRANT OPTION;', schemaname, databaseowner);
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.us_rules TO %I WITH GRANT OPTION;', schemaname, databaseowner);
ELSIF r.object_identity = 'dict_int' THEN
EXECUTE pg_catalog.format('ALTER TEXT SEARCH DICTIONARY %I.intdict OWNER TO %I;', schemaname, databaseowner);
ELSIF r.object_identity = 'pg_partman' THEN
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.part_config TO %I WITH GRANT OPTION;', schemaname, databaseowner);
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.part_config_sub TO %I WITH GRANT OPTION;', schemaname, databaseowner);
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON TABLE %I.custom_time_partitions TO %I WITH GRANT OPTION;', schemaname, databaseowner);
ELSIF r.object_identity = 'postgis_topology' THEN
EXECUTE pg_catalog.format('GRANT SELECT, UPDATE, INSERT, DELETE ON ALL TABLES IN SCHEMA topology TO %I WITH GRANT OPTION;', databaseowner);
EXECUTE pg_catalog.format('GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA topology TO %I WITH GRANT OPTION;', databaseowner);
EXECUTE pg_catalog.format('GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA topology TO %I WITH GRANT OPTION;', databaseowner);
EXECUTE pg_catalog.format('GRANT USAGE ON SCHEMA topology TO %I WITH GRANT OPTION;', databaseowner);
END IF;
END LOOP;
END IF;
END;
$$ LANGUAGE plpgsql SECURITY DEFINER;
CREATE EVENT TRIGGER log_create_ext ON ddl_command_end EXECUTE PROCEDURE create_ext();
```
## Konfigurasi yang digunakan dalam dukungan ekstensi yang didelegasikan Aurora untuk PostgreSQL
| Nama Konfigurasi | Deskripsi | nilai default | Catatan | Siapa yang dapat memodifikasi atau memberikan izin |
| --- | --- | --- | --- | --- |
| `rds.allowed_delegated_extensions` | Parameter ini membatasi ekstensi yang dapat dikelola peran rds\$1extension dalam database. Itu harus merupakan bagian dari rds.allowed\$1extensions. | string kosong | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/Aurora_delegated_ext.html) Untuk mempelajari lebih lanjut tentang pengaturan parameter ini, lihat[Mengaktifkan dukungan ekstensi delegasi ke pengguna](#AuroraPostgreSQL.delegated_ext_mgmt). | rds\$1superuser |
| `rds.allowed_extensions` | Parameter ini memungkinkan pelanggan membatasi ekstensi yang dapat diinstal di instance Aurora PostgreSQL DB. Untuk informasi selengkapnya, lihat [Membatasi pemasangan ekstensi PostgreSQL](https://docs.aws.amazon.com//AmazonRDS/latest/UserGuide/CHAP_PostgreSQL.html#PostgreSQL.Concepts.General.FeatureSupport.Extensions.Restriction) | "\$1" | Secara default, parameter ini diatur ke “\$1”, yang berarti bahwa semua ekstensi yang didukung pada RDS untuk PostgreSQL dan Aurora PostgreSQL diizinkan untuk dibuat oleh pengguna dengan hak istimewa yang diperlukan. Kosong berarti tidak ada ekstensi yang dapat diinstal di instance Aurora PostgreSQL DB. | administrator |
| `rds-delegated_extension_allow_drop_cascade` | Parameter ini mengontrol kemampuan pengguna `rds_extension` untuk menjatuhkan ekstensi menggunakan opsi kaskade. | off | Secara default, `rds-delegated_extension_allow_drop_cascade` diatur ke `off`. Ini berarti bahwa pengguna dengan tidak `rds_extension` diizinkan untuk menjatuhkan ekstensi menggunakan opsi kaskade. Untuk memberikan kemampuan itu, `rds.delegated_extension_allow_drop_cascade` parameter harus diatur ke`on`. | rds\$1superuser |
## Mematikan dukungan untuk ekstensi yang didelegasikan
**Mematikan sebagian**
Pengguna yang didelegasikan tidak dapat membuat ekstensi baru tetapi masih dapat memperbarui ekstensi yang ada.
+ Atur ulang `rds.allowed_delegated_extensions` ke nilai default di grup parameter cluster DB.
+ Gunakan perintah berikut di tingkat database:
```
alter database database_name reset rds.allowed_delegated_extensions;
```
+ Gunakan perintah berikut di tingkat pengguna:
```
alter user user_name reset rds.allowed_delegated_extensions;
```
**Mematikan sepenuhnya**
Mencabut `rds_extension` peran dari pengguna akan mengembalikan pengguna ke izin standar. Pengguna tidak dapat lagi membuat, memperbarui, atau menjatuhkan ekstensi.
```
postgres => revoke rds_extension from user_name;
```
## Manfaat menggunakan dukungan ekstensi yang didelegasikan Amazon Aurora
Dengan menggunakan dukungan ekstensi yang didelegasikan Amazon Aurora untuk PostgreSQL, Anda mendelegasikan manajemen ekstensi dengan aman kepada pengguna yang tidak memiliki peran tersebut. `rds_superuser` Fitur ini memberikan manfaat sebagai berikut:
+ Anda dapat dengan mudah mendelegasikan manajemen ekstensi kepada pengguna pilihan Anda.
+ Ini tidak membutuhkan `rds_superuser` peran.
+ Menyediakan kemampuan untuk mendukung kumpulan ekstensi yang berbeda untuk database yang berbeda di cluster DB yang sama.
## Batasan dukungan ekstensi yang didelegasikan Aurora untuk PostgreSQL
+ Objek yang dibuat selama proses pembuatan ekstensi mungkin memerlukan hak istimewa tambahan agar ekstensi berfungsi dengan baik.
## Izin diperlukan untuk ekstensi tertentu
Untuk membuat, menggunakan, atau memperbarui ekstensi berikut, pengguna yang didelegasikan harus memiliki hak istimewa yang diperlukan pada fungsi, tabel, dan skema berikut.
| Ekstensi yang membutuhkan kepemilikan atau izin | Fungsi | Tabel | Skema | Kamus Pencarian Teks | Komentar |
| --- | --- | --- | --- | --- | --- |
| address\$1standardizer\$1data\$1us | | us\$1gaz, us\$1lex, us\$1lex, i.us\$1rules | | | |
| amcheck | bt\$1index\$1check, bt\$1index\$1parent\$1check | | | | |
| dict\$1int | | | | intdict | |
| pg\$1partman | | custom\$1time\$1partisi, part\$1config, part\$1config\$1sub | | | |
| pg\$1stat\$1statements | | | | | |
| PostGIS | st\$1tileamplop | spatial\$1ref\$1sys | | | |
| postgis\$1raster | | | | | |
| postgis\$1topology | | topologi, lapisan | topologi | | pengguna yang didelegasikan Harus menjadi pemilik database |
| log\$1fdw | create\$1foreign\$1table\$1for\$1log\$1file | | | | |
| rds\$1tools | role\$1password\$1encryption\$1type | | | | |
| postgis\$1tiger\$1geocoder | | geocode\$1settings\$1default, geocode\$1settings | harimau | | |
| pg\$1freespacemap | pg\$1freespace | | | | |
| pg\$1visibility | pg\$1visibility | | | | |
## Pertimbangan Keamanan
Perlu diingat bahwa pengguna dengan `rds_extension` peran akan dapat mengelola ekstensi di semua database tempat mereka memiliki hak istimewa terhubung. Jika tujuannya adalah agar pengguna yang didelegasikan mengelola ekstensi pada satu database, praktik yang baik adalah mencabut semua hak istimewa dari publik di setiap database, kemudian secara eksplisit memberikan hak istimewa koneksi untuk database spesifik tersebut kepada pengguna delegasi.
Ada beberapa ekstensi yang dapat memungkinkan pengguna untuk mengakses informasi dari beberapa database. Pastikan pengguna yang Anda berikan `rds_extension` memiliki kemampuan lintas basis data sebelum menambahkan ekstensi ini`rds.allowed_delegated_extensions`. Misalnya, `postgres_fdw` dan `dblink` menyediakan fungsionalitas untuk kueri di seluruh database pada instance yang sama atau instance jarak jauh. `log_fdw`membaca file log mesin postgres, yang untuk semua database dalam instance, berpotensi berisi kueri lambat atau pesan kesalahan dari beberapa database. `pg_cron`memungkinkan menjalankan pekerjaan latar belakang terjadwal pada instans DB dan dapat mengonfigurasi pekerjaan untuk dijalankan di database yang berbeda.
## Jatuhkan kaskade ekstensi dinonaktifkan
Kemampuan untuk menjatuhkan ekstensi dengan opsi kaskade oleh pengguna dengan `rds_extension` peran dikendalikan oleh `rds.delegated_extension_allow_drop_cascade` parameter. Secara default, `rds-delegated_extension_allow_drop_cascade` diatur ke `off`. Ini berarti bahwa pengguna dengan `rds_extension` peran tidak diizinkan untuk menjatuhkan ekstensi menggunakan opsi kaskade seperti yang ditunjukkan pada kueri di bawah ini.
```
DROP EXTENSION CASCADE;
```
Karena ini akan secara otomatis menjatuhkan objek yang bergantung pada ekstensi, dan pada gilirannya semua objek yang bergantung pada objek tersebut. Mencoba menggunakan opsi kaskade akan menghasilkan kesalahan.
Untuk memberikan kemampuan itu, `rds.delegated_extension_allow_drop_cascade` parameter harus diatur ke`on`.
Mengubah parameter `rds.delegated_extension_allow_drop_cascade` dinamis tidak memerlukan restart database. Anda dapat melakukan ini di salah satu level berikut:
+ Di cluster atau grup parameter instance, melalui Konsol Manajemen AWS atau API.
+ Menggunakan perintah berikut di tingkat database:
```
alter database database_name set rds.delegated_extension_allow_drop_cascade = 'on';
```
+ Menggunakan perintah berikut di tingkat pengguna:
```
alter role tenant_user set rds.delegated_extension_allow_drop_cascade = 'on';
```
## Contoh ekstensi yang dapat ditambahkan menggunakan dukungan ekstensi yang didelegasikan
+ `rds_tools`
```
extension_test_db=> create extension rds_tools;
CREATE EXTENSION
extension_test_db=> SELECT * from rds_tools.role_password_encryption_type() where rolname = 'pg_read_server_files';
ERROR: permission denied for function role_password_encryption_type
```
+ `amcheck`
```
extension_test_db=> CREATE TABLE amcheck_test (id int);
CREATE TABLE
extension_test_db=> INSERT INTO amcheck_test VALUES (generate_series(1,100000));
INSERT 0 100000
extension_test_db=> CREATE INDEX amcheck_test_btree_idx ON amcheck_test USING btree (id);
CREATE INDEX
extension_test_db=> create extension amcheck;
CREATE EXTENSION
extension_test_db=> SELECT bt_index_check('amcheck_test_btree_idx'::regclass);
ERROR: permission denied for function bt_index_check
extension_test_db=> SELECT bt_index_parent_check('amcheck_test_btree_idx'::regclass);
ERROR: permission denied for function bt_index_parent_check
```
+ `pg_freespacemap`
```
extension_test_db=> create extension pg_freespacemap;
CREATE EXTENSION
extension_test_db=> SELECT * FROM pg_freespace('pg_authid');
ERROR: permission denied for function pg_freespace
extension_test_db=> SELECT * FROM pg_freespace('pg_authid',0);
ERROR: permission denied for function pg_freespace
```
+ `pg_visibility`
```
extension_test_db=> create extension pg_visibility;
CREATE EXTENSION
extension_test_db=> select * from pg_visibility('pg_database'::regclass);
ERROR: permission denied for function pg_visibility
```
+ `postgres_fdw`
```
extension_test_db=> create extension postgres_fdw;
CREATE EXTENSION
extension_test_db=> create server myserver foreign data wrapper postgres_fdw options (host 'foo', dbname 'foodb', port '5432');
ERROR: permission denied for foreign-data wrapper postgres_fdw
```
# Mengelola objek besar dengan modul lo
Modul (ekstensi) lo ditujukan bagi pengguna dan developer basis data yang bekerja dengan basis data PostgreSQL melalui driver JDBC atau ODBC. Baik JDBC maupun ODBC mengharapkan basis data menangani penghapusan objek besar ketika referensi ke objek tersebut berubah. Namun, cara kerja PostgreSQL bukan seperti itu. PostgreSQL tidak berasumsi bahwa suatu objek harus dihapus ketika referensinya berubah. Hasilnya adalah bahwa objek tetap berada di disk, tidak direferensikan. Ekstensi lo mencakup fungsi yang Anda gunakan untuk memicu perubahan referensi untuk menghapus objek jika diperlukan.
**Tip**
Untuk menentukan apakah database Anda dapat memperoleh manfaat dari ekstensi lo, gunakan `vacuumlo` utilitas untuk memeriksa objek besar yatim piatu. Untuk mendapatkan hitungan objek tak berinduk tanpa mengambil tindakan apa pun, jalankan utilitas dengan opsi `-n` (no-op). Untuk mempelajari caranya, lihat [vacuumlo utility](#vacuumlo-utility) berikut.
Modul lo tersedia untuk Aurora PostgreSQL 13.7, 12.11, 11.16, 10.21, dan versi minor yang lebih tinggi.
Untuk menginstal modul (ekstensi), Anda memerlukan hak istimewa `rds_superuser`. Menginstal ekstensi lo akan menambahkan berikut ke basis data Anda:
+ `lo`— Ini adalah tipe data objek besar (lo) yang dapat Anda gunakan untuk objek besar biner (BLOBs) dan objek besar lainnya. Tipe data `lo` adalah domain dari jenis data `oid`. Dengan kata lain, ini adalah ID objek dengan batasan opsional. Untuk informasi selengkapnya, lihat [Object identifiers](https://www.postgresql.org/docs/14/datatype-oid.html) dalam dokumentasi PostgreSQL. Secara sederhana, Anda dapat menggunakan tipe `lo` data untuk membedakan kolom database Anda yang menyimpan referensi objek besar dari pengidentifikasi objek lain (OIDs).
+ `lo_manage` – Ini adalah fungsi yang dapat digunakan dalam pemicu pada kolom tabel yang berisi referensi objek besar. Setiap kali Anda menghapus atau mengubah nilai yang mereferensikan objek besar, pemicu akan memutuskan tautan objek (`lo_unlink`) dari referensinya. Gunakan pemicu pada kolom hanya jika kolom tersebut adalah referensi basis data tunggal ke objek besar.
Untuk informasi selengkapnya tentang modul objek besar, lihat [lo](https://www.postgresql.org/docs/current/lo.html) dalam dokumentasi PostgreSQL.
## Menginstal ekstensi lo
Sebelum menginstal ekstensi lo, pastikan bahwa Anda memiliki hak istimewa `rds_superuser`.
**Untuk menginstal ekstensi lo.**
1. Gunakan `psql` untuk terhubung ke instans DB primer dari klaster DB Aurora PostgreSQL Anda.
```
psql --host=your-cluster-instance-1.666666666666.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
Jika diminta, masukkan kata sandi Anda. Klien `psql` menghubungkan dan menampilkan basis data koneksi administratif default, `postgres=>`, sebagai perintah.
1. Instal ekstensi seperti berikut.
```
postgres=> CREATE EXTENSION lo;
CREATE EXTENSION
```
Anda kini dapat menggunakan jenis data `lo` untuk menentukan kolom dalam tabel Anda. Misalnya, Anda dapat membuat tabel (`images`) yang berisi data citra raster. Anda dapat menggunakan jenis data `lo` untuk kolom `raster`, seperti yang ditunjukkan pada contoh berikut, yang membuat tabel.
```
postgres=> CREATE TABLE images (image_name text, raster lo);
```
## Menggunakan fungsi pemicu lo\$1manage untuk menghapus objek
Anda dapat menggunakan fungsi `lo_manage` dalam pemicu pada `lo` atau kolom objek besar lainnya untuk membersihkan (dan mencegah objek tak berinduk) ketika `lo` diperbarui atau dihapus.
**Untuk menyiapkan pemicu pada kolom yang mereferensikan objek besar**
+ Lakukan salah satu langkah berikut:
+ Buat pemicu BEFORE UPDATE OR DELETE pada setiap kolom agar berisi referensi unik ke objek besar, menggunakan nama kolom untuk argumen.
```
postgres=> CREATE TRIGGER t_raster BEFORE UPDATE OR DELETE ON images
FOR EACH ROW EXECUTE FUNCTION lo_manage(raster);
```
+ Terapkan pemicu hanya ketika kolom sedang diperbarui.
```
postgres=> CREATE TRIGGER t_raster BEFORE UPDATE OF images
FOR EACH ROW EXECUTE FUNCTION lo_manage(raster);
```
Fungsi `lo_manage` pemicu hanya berfungsi saat memasukkan atau menghapus data kolom, bergantung pada bagaimana Anda mendefinisikan pemicu. Ini tidak berpengaruh ketika Anda melakukan operasi `DROP` atau `TRUNCATE` pada basis data. Berarti Anda harus menghapus kolom objek dari tabel apa pun sebelum hilang, untuk mencegah pembuatan objek tak berinduk.
Misalnya, anggaplah Anda ingin menghilangkan basis data yang berisi tabel `images`. Anda menghapus kolom sebagai berikut.
```
postgres=> DELETE FROM images COLUMN raster
```
Dengan asumsi bahwa fungsi `lo_manage` didefinisikan pada kolom itu untuk menangani penghapusan, Anda sekarang dapat dengan aman menghilangkan tabel.
## Menghapus benda-benda besar yatim piatu menggunakan `vacuumlo`
`vacuumlo`Utilitas mengidentifikasi dan menghapus objek besar yatim piatu dari database. Utilitas ini telah tersedia sejak PostgreSQL 9.1.24. Jika pengguna database Anda secara rutin bekerja dengan objek besar, kami sarankan Anda menjalankan `vacuumlo` sesekali untuk membersihkan objek besar yatim piatu.
Sebelum menginstal ekstensi lo, Anda dapat menggunakan `vacuumlo` untuk menilai apakah cluster Aurora PostgreSQL DB Anda dapat memperoleh manfaat. Untuk melakukannya, jalankan `vacuumlo` dengan opsi `-n` (no-op) untuk menunjukkan apa yang akan dihapus, seperti yang ditunjukkan berikut:
```
$ vacuumlo -v -n -h your-cluster-instance-1.666666666666.aws-region.rds.amazonaws.com -p 5433 -U postgres docs-lab-spatial-db
Password:*****
Connected to database "docs-lab-spatial-db"
Test run: no large objects will be removed!
Would remove 0 large objects from database "docs-lab-spatial-db".
```
Seperti yang ditunjukkan output, objek besar tak berinduk tidak menjadi masalah untuk basis data khusus ini.
Untuk informasi lebih lanjut tentang utilitas ini, lihat [https://www.postgresql.org/docs/current/vacuumlo.html](https://www.postgresql.org/docs/current/vacuumlo.html)di dokumentasi PostgreSQL.
## Memahami cara kerja `vacuumlo`
`vacuumlo`Perintah menghapus objek besar yatim piatu (LOs) dari database PostgreSQL Anda tanpa mempengaruhi atau bertentangan dengan tabel pengguna Anda.
Perintah berfungsi sebagai berikut:
1. `vacuumlo`dimulai dengan membuat tabel sementara yang berisi semua Object IDs (OIDs) dari objek besar dalam database Anda.
1. `vacuumlo`kemudian memindai melalui setiap kolom dalam database yang menggunakan tipe data `oid` atau`lo`. Jika `vacuumlo` menemukan OID yang cocok di kolom ini, ia menghapus OID dari tabel sementara. `vacuumlo`memeriksa hanya kolom yang diberi nama khusus `oid` atau`lo`, bukan domain berdasarkan jenis ini.
1. Entri yang tersisa dalam tabel sementara mewakili yatim piatu LOs, yang `vacuumlo` kemudian dihapus dengan aman.
## Meningkatkan `vacuumlo` kinerja
Anda berpotensi dapat meningkatkan kinerja `vacuumlo` dengan meningkatkan ukuran batch menggunakan `-l` opsi. Ini memungkinkan `vacuumlo` untuk memproses lebih banyak LOs sekaligus.
Jika sistem Anda memiliki memori yang cukup dan Anda dapat mengakomodasi tabel sementara sepenuhnya dalam memori, meningkatkan `temp_buffers` pengaturan di tingkat database dapat meningkatkan kinerja. Hal ini memungkinkan tabel untuk berada sepenuhnya dalam memori, yang dapat meningkatkan kinerja secara keseluruhan.
Berikut query memperkirakan ukuran tabel sementara:
```
SELECT
pg_size_pretty(SUM(pg_column_size(oid))) estimated_lo_temp_table_size
FROM
pg_largeobject_metadata;
```
## Pertimbangan untuk benda besar
Berikut ini Anda dapat menemukan beberapa pertimbangan penting untuk dicatat ketika bekerja dengan objek besar:
+ `Vacuumlo`adalah satu-satunya solusi karena saat ini tidak ada metode lain untuk menghapus yatim piatu LOs.
+ Alat seperti pglogis, replikasi logis asli, dan AWS DMS yang menggunakan teknologi replikasi tidak mendukung replikasi objek besar.
+ Saat merancang skema database Anda, hindari menggunakan objek besar bila memungkinkan dan pertimbangkan untuk menggunakan tipe data alternatif seperti `bytea` sebagai gantinya.
+ Jalankan `vacuumlo` secara teratur, setidaknya setiap minggu, untuk mencegah masalah dengan yatim piatu LOs.
+ Gunakan pemicu dengan `lo_manage` fungsi pada tabel yang menyimpan objek besar untuk membantu mencegah anak yatim piatu dibuat LOs .
# Mengelola data spasial dengan ekstensi PostGIS
PostGIS adalah ekstensi dari PostgreSQL untuk menyimpan dan mengelola informasi spasial. Untuk mempelajari selengkapnya tentang PostGIS, lihat [PostGIS.net](https://postgis.net/).
Mulai dari versi 10.5, PostgreSQL mendukung pustaka libprotobuf 1.3.0 yang digunakan oleh PostGIS agar berfungsi dengan data petak vektor map box.
Menyiapkan ekstensi PostGIS membutuhkan hak akses `rds_superuser`. Sebaiknya Anda membuat (peran) pengguna untuk mengelola ekstensi PostGIS dan data spasial. Ekstensi PostGIS dan komponen terkaitnya menambahkan ribuan fungsi ke PostgreSQL. Anda juga dapat membuat ekstensi PostGIS dalam skema tersendiri jika sesuai untuk kasus penggunaan Anda. Contoh berikut menunjukkan cara menginstal ekstensi dalam basis data tersendiri, tetapi ini tidak wajib dilakukan.
**Topics**
+ [Langkah 1: Membuat (peran) pengguna untuk mengelola ekstensi PostGIS](#Appendix.PostgreSQL.CommonDBATasks.PostGIS.Connect)
+ [Langkah 2: Memuat ekstensi PostGIS](#Appendix.PostgreSQL.CommonDBATasks.PostGIS.LoadExtensions)
+ [Langkah 3: Transfer kepemilikan skema ekstensi](#Appendix.PostgreSQL.CommonDBATasks.PostGIS.TransferOwnership)
+ [Langkah 4: Transfer kepemilikan tabel PostGIS](#Appendix.PostgreSQL.CommonDBATasks.PostGIS.TransferObjects)
+ [Langkah 5: Menguji ekstensi](#Appendix.PostgreSQL.CommonDBATasks.PostGIS.Test)
+ [Langkah 6: Meningkatkan ekstensi PostGIS](#Appendix.PostgreSQL.CommonDBATasks.PostGIS.Update)
+ [Versi ekstensi PostGIS](#CHAP_PostgreSQL.Extensions.PostGIS)
+ [Meningkatkan PostGIS 2 ke PostGIS 3](#PostgreSQL.Extensions.PostGIS.versions.upgrading.2-to-3)
## Langkah 1: Membuat (peran) pengguna untuk mengelola ekstensi PostGIS
Pertama, hubungkan ke instans DB RDS for PostgreSQL sebagai pengguna yang memiliki hak akses `rds_superuser`. Jika tidak mengubah nama default saat menyiapkan instans, Anda akan terhubung sebagai `postgres`.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
Buat peran (pengguna) terpisah untuk mengelola ekstensi PostGIS.
```
postgres=> CREATE ROLE gis_admin LOGIN PASSWORD 'change_me';
CREATE ROLE
```
Berikan hak akses `rds_superuser` kepada peran ini agar dapat menginstal ekstensi.
```
postgres=> GRANT rds_superuser TO gis_admin;
GRANT
```
Buat basis data agar dapat digunakan untuk artefak PostGIS. Langkah ini bersifat opsional. Atau, Anda dapat membuat skema di basis data pengguna untuk ekstensi PostGIS, tetapi ini juga tidak wajib dilakukan.
```
postgres=> CREATE DATABASE lab_gis;
CREATE DATABASE
```
Berikan semua hak akses `gis_admin` pada basis data `lab_gis`.
```
postgres=> GRANT ALL PRIVILEGES ON DATABASE lab_gis TO gis_admin;
GRANT
```
Keluar dari sesi, lalu sambungkan kembali ke instans DB RDS for PostgreSQL Anda sebagai `gis_admin`.
```
postgres=> psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=gis_admin --password --dbname=lab_gis
Password for user gis_admin:...
lab_gis=>
```
Lanjutkan menyiapkan ekstensi seperti yang dijelaskan pada langkah berikutnya.
## Langkah 2: Memuat ekstensi PostGIS
Ekstensi PostGIS mencakup beberapa ekstensi terkait yang berfungsi bersama untuk menyediakan fungsionalitas geospasial. Tergantung pada kasus penggunaannya, Anda mungkin tidak memerlukan semua ekstensi yang dibuat pada langkah ini.
Gunakan pernyataan `CREATE EXTENSION` untuk memuat ekstensi PostGIS.
```
CREATE EXTENSION postgis;
CREATE EXTENSION
CREATE EXTENSION postgis_raster;
CREATE EXTENSION
CREATE EXTENSION fuzzystrmatch;
CREATE EXTENSION
CREATE EXTENSION postgis_tiger_geocoder;
CREATE EXTENSION
CREATE EXTENSION postgis_topology;
CREATE EXTENSION
CREATE EXTENSION address_standardizer_data_us;
CREATE EXTENSION
```
Anda dapat memverifikasi hasilnya dengan menjalankan kueri SQL yang ditunjukkan dalam contoh berikut, yang mencantumkan ekstensi dan pemiliknya.
```
SELECT n.nspname AS "Name",
pg_catalog.pg_get_userbyid(n.nspowner) AS "Owner"
FROM pg_catalog.pg_namespace n
WHERE n.nspname !~ '^pg_' AND n.nspname <> 'information_schema'
ORDER BY 1;
List of schemas
Name | Owner
--------------+-----------
public | postgres
tiger | rdsadmin
tiger_data | rdsadmin
topology | rdsadmin
(4 rows)
```
## Langkah 3: Transfer kepemilikan skema ekstensi
Gunakan pernyataan ALTER SCHEMA untuk mentransfer kepemilikan skema ke peran `gis_admin`.
```
ALTER SCHEMA tiger OWNER TO gis_admin;
ALTER SCHEMA
ALTER SCHEMA tiger_data OWNER TO gis_admin;
ALTER SCHEMA
ALTER SCHEMA topology OWNER TO gis_admin;
ALTER SCHEMA
```
Anda dapat mengonfirmasi perubahan kepemilikan dengan menjalankan kueri SQL berikut. Bisa juga dengan menggunakan metacommand `\dn` dari baris perintah psql.
```
SELECT n.nspname AS "Name",
pg_catalog.pg_get_userbyid(n.nspowner) AS "Owner"
FROM pg_catalog.pg_namespace n
WHERE n.nspname !~ '^pg_' AND n.nspname <> 'information_schema'
ORDER BY 1;
List of schemas
Name | Owner
--------------+---------------
public | postgres
tiger | gis_admin
tiger_data | gis_admin
topology | gis_admin
(4 rows)
```
## Langkah 4: Transfer kepemilikan tabel PostGIS
**catatan**
Jangan mengubah kepemilikan fungsi PostGIS. Operasi yang tepat dan peningkatan PostGIS di masa mendatang memerlukan fungsi-fungsi ini untuk mempertahankan kepemilikan asli. [Untuk informasi selengkapnya tentang izin PostGIS, lihat PostgreSQL Security.](https://postgis.net/workshops/postgis-intro/security.html)
Gunakan fungsi berikut untuk mentransfer kepemilikan tabel PostGIS ke peran. `gis_admin` Jalankan pernyataan berikut dari perintah psql untuk membuat fungsinya.
```
CREATE FUNCTION exec(text) returns text language plpgsql volatile AS $f$ BEGIN EXECUTE $1; RETURN $1; END; $f$;
CREATE FUNCTION
```
Selanjutnya, jalankan kueri berikut untuk menjalankan fungsi `exec` yang nantinya akan menjalankan pernyataan dan mengubah izin.
```
SELECT exec('ALTER TABLE ' || quote_ident(s.nspname) || '.' || quote_ident(s.relname) || ' OWNER TO gis_admin;')
FROM (
SELECT nspname, relname
FROM pg_class c JOIN pg_namespace n ON (c.relnamespace = n.oid)
WHERE nspname in ('tiger','topology') AND
relkind IN ('r','S','v') ORDER BY relkind = 'S')
s;
```
## Langkah 5: Menguji ekstensi
Agar Anda tidak harus menentukan nama skema, tambahkan skema `tiger` ke jalur pencarian menggunakan perintah berikut.
```
SET search_path=public,tiger;
SET
```
Uji skema `tiger` menggunakan pernyataan SELECT berikut.
```
SELECT address, streetname, streettypeabbrev, zip
FROM normalize_address('1 Devonshire Place, Boston, MA 02109') AS na;
address | streetname | streettypeabbrev | zip
---------+------------+------------------+-------
1 | Devonshire | Pl | 02109
(1 row)
```
Untuk mempelajari selengkapnya tentang ekstensi ini, lihat [Tiger Geocoder](https://postgis.net/docs/Extras.html#Tiger_Geocoder) dalam dokumentasi PostGIS.
Uji akses ke skema `topology` menggunakan pernyataan `SELECT` berikut. Tindakan ini akan memanggil fungsi `createtopology` untuk mendaftarkan objek topologi baru (my\$1new\$1topo) dengan pengidentifikasi referensi spasial (26986) dan toleransi default (0,5) yang ditentukan. Untuk mempelajari lebih lanjut, lihat [CreateTopology](https://postgis.net/docs/CreateTopology.html)di dokumentasi PostGIS.
```
SELECT topology.createtopology('my_new_topo',26986,0.5);
createtopology
----------------
1
(1 row)
```
## Langkah 6: Meningkatkan ekstensi PostGIS
Setiap rilis baru PostgreSQL mendukung satu atau beberapa versi ekstensi PostGIS yang kompatibel dengan rilis tersebut. Meningkatkan mesin PostgreSQL ke versi baru tidak secara otomatis meningkatkan ekstensi PostGIS. Sebelum meningkatkan mesin PostgreSQL, Anda biasanya meningkatkan PostGIS ke versi terbaru yang tersedia untuk versi PostgreSQL saat ini. Untuk mengetahui detailnya, lihat [Versi ekstensi PostGIS](#CHAP_PostgreSQL.Extensions.PostGIS).
Setelah peningkatan mesin PostgreSQL, selanjutnya tingkatkan ekstensi PostGIS lagi, ke versi yang didukung untuk versi mesin PostgreSQL yang baru ditingkatkan. Untuk informasi selengkapnya tentang cara meningkatkan mesin PostgreSQL, lihat [Menguji peningkatan klaster DB produksi ke versi mayor baru](USER_UpgradeDBInstance.PostgreSQL.MajorVersion.md#USER_UpgradeDBInstance.PostgreSQL.MajorVersion.Upgrade.preliminary).
Anda dapat memeriksa pembaruan versi ekstensi PostGIS yang tersedia di klaster DB Aurora PostgreSQL kapan saja. Untuk melakukannya, jalankan perintah berikut. Fungsi ini tersedia untuk PostGIS 2.5.0 dan versi yang lebih baru.
```
SELECT postGIS_extensions_upgrade();
```
Jika aplikasi Anda tidak mendukung versi PostGIS terbaru, Anda dapat menginstal versi PostGIS lama yang tersedia di versi utama Anda sebagai berikut.
```
CREATE EXTENSION postgis VERSION "2.5.5";
```
Jika ingin meningkatkan ke versi PostGIS tertentu dari versi lama, Anda juga dapat menggunakan perintah berikut.
```
ALTER EXTENSION postgis UPDATE TO "2.5.5";
```
Tergantung pada versi sebelum peningkatan, Anda mungkin perlu menggunakan fungsi ini lagi. Hasil dari menjalankan fungsi pertama akan menentukan perlu atau tidaknya fungsi peningkatan lain. Misalnya, ini adalah kasus peningkatan dari PostGIS 2 ke PostGIS 3. Untuk informasi selengkapnya, lihat [Meningkatkan PostGIS 2 ke PostGIS 3](#PostgreSQL.Extensions.PostGIS.versions.upgrading.2-to-3).
Jika meningkatkan ekstensi ini untuk mempersiapkan peningkatan versi utama mesin PostgreSQL, Anda dapat melanjutkan tugas awal lainnya. Untuk informasi selengkapnya, lihat [Menguji peningkatan klaster DB produksi ke versi mayor baru](USER_UpgradeDBInstance.PostgreSQL.MajorVersion.md#USER_UpgradeDBInstance.PostgreSQL.MajorVersion.Upgrade.preliminary).
## Versi ekstensi PostGIS
Sebaiknya, Anda menginstal versi semua ekstensi seperti PostGIS sebagaimana tercantum di [Versi ekstensi untuk Aurora Edisi Kompatibel PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html) dalam *Catatan Rilis Aurora PostgreSQL*. Untuk mendapatkan daftar versi yang tersedia dalam rilis Anda, gunakan perintah berikut.
```
SELECT * FROM pg_available_extension_versions WHERE name='postgis';
```
Anda dapat menemukan informasi versi di bagian berikut dalam *Catatan Rilis Aurora PostgreSQL*:
+ [Versi ekstensi untuk Aurora PostgreSQL 14](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html#AuroraPostgreSQL.Extensions.14)
+ [Versi ekstensi untuk Aurora Edisi Kompatibel PostgreSQL 13](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html#AuroraPostgreSQL.Extensions.13)
+ [Versi ekstensi untuk Aurora Edisi Kompatibel PostgreSQL 12](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html#AuroraPostgreSQL.Extensions.12)
+ [Versi ekstensi untuk Aurora Edisi Kompatibel PostgreSQL 11](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html#AuroraPostgreSQL.Extensions.11)
+ [Versi ekstensi untuk Aurora Edisi Kompatibel PostgreSQL 10](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html#AuroraPostgreSQL.Extensions.10)
+ [Versi ekstensi untuk Aurora Edisi Kompatibel PostgreSQL 9.6](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html#AuroraPostgreSQL.Extensions.96)
## Meningkatkan PostGIS 2 ke PostGIS 3
Mulai dari versi 3.0, fungsi raster PostGIS kini menjadi ekstensi terpisah, `postgis_raster`. Ekstensi ini memiliki jalur instalasi dan peningkatan tersendiri. Ekstensi ini menghapus berbagai fungsi, tipe data, dan artefak lain yang diperlukan untuk pemrosesan gambar raster dari ekstensi `postgis` inti. Artinya, jika kasus penggunaan Anda tidak memerlukan pemrosesan raster, Anda tidak perlu menginstal ekstensi `postgis_raster`.
Dalam contoh peningkatan berikut, perintah peningkatan pertama mengekstrak fungsionalitas raster ke dalam ekstensi `postgis_raster`. Selanjutnya, perintah peningkatan kedua diperlukan untuk meningkatkan `postgis_raster` ke versi baru.
**Untuk meningkatkan dari PostGIS 2 ke PostGIS 3**
1. Identifikasi versi default PostGIS yang tersedia untuk versi PostgreSQL di klaster DB Aurora PostgreSQL. Untuk melakukannya, jalankan kueri berikut.
```
SELECT * FROM pg_available_extensions
WHERE default_version > installed_version;
name | default_version | installed_version | comment
---------+-----------------+-------------------+------------------------------------------------------------
postgis | 3.1.4 | 2.3.7 | PostGIS geometry and geography spatial types and functions
(1 row)
```
1. Identifikasi versi PostGIS yang diinstal di setiap basis data pada instans penulis klaster DB Aurora PostgreSQL. Dengan kata lain, buat kueri setiap basis data pengguna sebagai berikut.
```
SELECT
e.extname AS "Name",
e.extversion AS "Version",
n.nspname AS "Schema",
c.description AS "Description"
FROM
pg_catalog.pg_extension e
LEFT JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace
LEFT JOIN pg_catalog.pg_description c ON c.objoid = e.oid
AND c.classoid = 'pg_catalog.pg_extension'::pg_catalog.regclass
WHERE
e.extname LIKE '%postgis%'
ORDER BY
1;
Name | Version | Schema | Description
---------+---------+--------+---------------------------------------------------------------------
postgis | 2.3.7 | public | PostGIS geometry, geography, and raster spatial types and functions
(1 row)
```
Ketidakcocokan antara versi default (PostGIS 3.1.4) dan versi yang diinstal (PostGIS 2.3.7) ini mengindikasikan bahwa Anda perlu meningkatkan ekstensi PostGIS.
```
ALTER EXTENSION postgis UPDATE;
ALTER EXTENSION
WARNING: unpackaging raster
WARNING: PostGIS Raster functionality has been unpackaged
```
1. Jalankan kueri berikut untuk memverifikasi bahwa fungsi raster kini telah berada dalam paketnya tersendiri.
```
SELECT
probin,
count(*)
FROM
pg_proc
WHERE
probin LIKE '%postgis%'
GROUP BY
probin;
probin | count
--------------------------+-------
$libdir/rtpostgis-2.3 | 107
$libdir/postgis-3 | 487
(2 rows)
```
Output-nya menunjukkan bahwa masih ada perbedaan antarversi. Fungsi PostGIS adalah versi 3 (postgis-3), sedangkan fungsi raster (rtpostgis) adalah versi 2 (rtpostgis-2.3). Untuk menyelesaikan peningkatan, Anda dapat menjalankan perintah peningkatan lagi sebagai berikut.
```
postgres=> SELECT postgis_extensions_upgrade();
```
Anda dapat dengan aman mengabaikan pesan peringatan. Jalankan lagi kueri berikut untuk memverifikasi bahwa peningkatan telah selesai. Peningkatan selesai saat PostGIS dan semua ekstensi terkait tidak ditandai sebagai perlu peningkatan.
```
SELECT postgis_full_version();
```
1. Gunakan kueri berikut untuk melihat proses peningkatan yang telah selesai dan ekstensi yang dikemas secara terpisah, lalu verifikasi bahwa versinya telah sesuai.
```
SELECT
e.extname AS "Name",
e.extversion AS "Version",
n.nspname AS "Schema",
c.description AS "Description"
FROM
pg_catalog.pg_extension e
LEFT JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace
LEFT JOIN pg_catalog.pg_description c ON c.objoid = e.oid
AND c.classoid = 'pg_catalog.pg_extension'::pg_catalog.regclass
WHERE
e.extname LIKE '%postgis%'
ORDER BY
1;
Name | Version | Schema | Description
----------------+---------+--------+---------------------------------------------------------------------
postgis | 3.1.5 | public | PostGIS geometry, geography, and raster spatial types and functions
postgis_raster | 3.1.5 | public | PostGIS raster types and functions
(2 rows)
```
Output menunjukkan bahwa ekstensi PostGIS 2 telah ditingkatkan ke PostGIS 3, serta ekstensi `postgis` dan ekstensi `postgis_raster` yang sekarang terpisah adalah versi 3.1.5.
Setelah peningkatan ini selesai, Anda dapat menghapus ekstensi seperti berikut jika tidak berencana menggunakan fungsionalitas raster.
```
DROP EXTENSION postgis_raster;
```
# Mengelola partisi PostgreSQL dengan ekstensi pg\$1partman
Partisi tabel PostgreSQL menyediakan kerangka kerja untuk penanganan input data dan laporan performa tinggi. Gunakan partisi untuk basis data yang memerlukan input data dalam jumlah besar dengan cepat. Partisi juga menyediakan kueri tabel besar yang lebih cepat. Partisi membantu memelihara data tanpa memengaruhi instans basis data karena sumber daya I/O yang diperlukan lebih sedikit.
Dengan partisi, Anda dapat membagi data menjadi beberapa bagian berukuran kustom untuk diproses. Misalnya, Anda dapat membagi data deret waktu ke dalam berbagai rentang seperti per jam, harian, mingguan, bulanan, triwulanan, tahunan, kustom, atau kombinasinya. Untuk contoh data deret waktu, jika Anda membagi tabel berdasarkan jam, setiap partisi akan berisi data per satu jam. Jika Anda membagi tabel deret waktu berdasarkan hari, partisi akan berisi data per hari, dan seterusnya. Kunci partisi mengontrol ukuran partisi.
Saat Anda menggunakan perintah SQL `INSERT` atau `UPDATE` pada tabel yang dipartisi, mesin basis data merutekan data ke partisi yang sesuai. Partisi tabel PostgreSQL yang menyimpan data adalah tabel turunan dari tabel utama.
Selama pembacaan kueri basis data, pengoptimal PostgreSQL memeriksa klausul `WHERE` pada kueri dan, jika memungkinkan, mengarahkan pemindaian basis data hanya untuk partisi yang relevan.
Mulai versi 10, PostgreSQL menggunakan partisi deklaratif untuk mengimplementasikan partisi tabel. Ini juga dikenal sebagai partisi PostgreSQL asli. Sebelum PostgreSQL versi 10, Anda menggunakan pemicu untuk mengimplementasikan partisi.
Partisi tabel PostgreSQL menyediakan fitur berikut:
+ Pembuatan partisi baru setiap saat.
+ Rentang partisi bervariasi.
+ Partisi yang dapat dilepas dan dapat dipasang kembali menggunakan pernyataan bahasa definisi data (DDL).
Sebagai contoh, partisi yang dapat dilepas berguna untuk menghapus data historis dari partisi utama, tetapi menyimpan data historis untuk analisis.
+ Partisi baru mewarisi properti tabel basis data induk, termasuk yang berikut ini:
+ Indeks
+ Kunci primer, yang harus berisi kolom kunci partisi
+ Kunci asing
+ Batasan pemeriksaan
+ Referensi
+ Membuat indeks untuk seluruh tabel atau partisi tertentu.
Anda tidak dapat mengubah skema partisi individual. Namun, Anda dapat mengubah tabel induk (seperti menambahkan kolom baru), yang disebarkan ke partisi.
**Topics**
+ [Ikhtisar ekstensi pg\$1partman PostgreSQL](#PostgreSQL_Partitions.pg_partman)
+ [Mengaktifkan ekstensi pg\$1partman](#PostgreSQL_Partitions.enable)
+ [Mengonfigurasi partisi menggunakan fungsi create\$1parent](#PostgreSQL_Partitions.create_parent)
+ [Mengonfigurasi pemeliharaan partisi menggunakan fungsi run\$1maintenance\$1proc](#PostgreSQL_Partitions.run_maintenance_proc)
## Ikhtisar ekstensi pg\$1partman PostgreSQL
Anda dapat menggunakan ekstensi `pg_partman` PostgreSQL untuk mengotomatiskan pembuatan dan pemeliharaan partisi tabel. Untuk informasi umum selengkapnya, lihat [PG Partition Manager](https://github.com/pgpartman/pg_partman) dalam dokumentasi `pg_partman`.
**catatan**
Ekstensi `pg_partman` didukung di Aurora for PostgreSQL versi 12.6 dan yang lebih tinggi.
Alih-alih membuat setiap partisi secara manual, Anda dapat mengonfigurasi `pg_partman` dengan pengaturan berikut:
+ Tabel yang akan dipartisi
+ Jenis partisi
+ Kunci partisi
+ Granularitas partisi
+ Opsi pra-pembuatan dan manajemen partisi
Setelah membuat tabel yang dipartisi PostgreSQL, daftarkan dengan `pg_partman` dengan memanggil fungsi `create_parent`. Tindakan ini akan membuat partisi yang diperlukan berdasarkan parameter yang Anda teruskan ke fungsi.
Ekstensi `pg_partman` juga menyediakan fungsi `run_maintenance_proc`, yang dapat Anda panggil sesuai jadwal untuk secara otomatis mengelola partisi. Untuk memastikan bahwa partisi yang tepat dibuat sesuai kebutuhan, jadwalkan fungsi ini untuk berjalan secara berkala (seperti per jam). Anda juga dapat memastikan bahwa partisi secara otomatis dibatalkan.
## Mengaktifkan ekstensi pg\$1partman
Jika Anda memiliki beberapa basis data di dalam instans DB PostgreSQL yang partisinya ingin Anda kelola, aktifkan ekstensi `pg_partman` secara terpisah untuk setiap basis data. Untuk mengaktifkan ekstensi `pg_partman` untuk basis data tertentu, buat skema pemeliharaan partisi, kemudian buat ekstensi `pg_partman` seperti berikut.
```
CREATE SCHEMA partman;
CREATE EXTENSION pg_partman WITH SCHEMA partman;
```
**catatan**
Untuk membuat ekstensi `pg_partman`, pastikan Anda memiliki hak istimewa `rds_superuser`.
Jika Anda menerima kesalahan seperti berikut, berikan hak istimewa `rds_superuser` untuk akun tersebut atau gunakan akun pengguna super Anda.
```
ERROR: permission denied to create extension "pg_partman"
HINT: Must be superuser to create this extension.
```
Untuk memberikan hak istimewa `rds_superuser`, hubungkan dengan akun pengguna super Anda dan jalankan perintah berikut.
```
GRANT rds_superuser TO user-or-role;
```
Untuk contoh yang menunjukkan penggunaan ekstensi pg\$1partman, kita gunakan contoh tabel dan partisi basis data berikut. Basis data ini menggunakan tabel yang dipartisi berdasarkan stempel waktu. Skema `data_mart` berisi tabel bernama `events` dengan kolom bernama `created_at`. Pengaturan berikut disertakan dalam tabel `events`:
+ Kunci primer `event_id` dan `created_at`, yang harus memiliki kolom yang digunakan untuk memandu partisi.
+ Batasan pemeriksaan `ck_valid_operation` guna menerapkan nilai untuk kolom tabel `operation`.
+ Dua kunci asing, yang salah satunya (`fk_orga_membership)` menunjuk ke tabel eksternal `organization` dan kunci lainnya (`fk_parent_event_id`) adalah kunci asing referensi mandiri.
+ Dua indeks, yang salah satunya (`idx_org_id`) untuk kunci asing dan indeks lainnya (`idx_event_type`) untuk jenis peristiwa.
Pernyataan DDL berikut membuat objek ini, yang secara otomatis disertakan pada setiap partisi.
```
CREATE SCHEMA data_mart;
CREATE TABLE data_mart.organization ( org_id BIGSERIAL,
org_name TEXT,
CONSTRAINT pk_organization PRIMARY KEY (org_id)
);
CREATE TABLE data_mart.events(
event_id BIGSERIAL,
operation CHAR(1),
value FLOAT(24),
parent_event_id BIGINT,
event_type VARCHAR(25),
org_id BIGSERIAL,
created_at timestamp,
CONSTRAINT pk_data_mart_event PRIMARY KEY (event_id, created_at),
CONSTRAINT ck_valid_operation CHECK (operation = 'C' OR operation = 'D'),
CONSTRAINT fk_orga_membership
FOREIGN KEY(org_id)
REFERENCES data_mart.organization (org_id),
CONSTRAINT fk_parent_event_id
FOREIGN KEY(parent_event_id, created_at)
REFERENCES data_mart.events (event_id,created_at)
) PARTITION BY RANGE (created_at);
CREATE INDEX idx_org_id ON data_mart.events(org_id);
CREATE INDEX idx_event_type ON data_mart.events(event_type);
```
## Mengonfigurasi partisi menggunakan fungsi create\$1parent
Setelah mengaktifkan ekstensi `pg_partman`, gunakan fungsi `create_parent` untuk mengonfigurasi partisi di dalam skema pemeliharaan partisi. Contoh berikut menggunakan contoh tabel `events` yang dibuat di [Mengaktifkan ekstensi pg\$1partmanMengonfigurasi pemeliharaan partisi menggunakan fungsi run\$1maintenance\$1proc](#PostgreSQL_Partitions.enable). Panggil fungsi `create_parent` seperti berikut.
```
SELECT partman.create_parent(
p_parent_table => 'data_mart.events',
p_control => 'created_at',
p_type => 'range',
p_interval => '1 day',
p_premake => 30);
```
Parameternya adalah sebagai berikut:
+ `p_parent_table` – Tabel induk yang dipartisi. Tabel ini harus sudah ada dan sepenuhnya memenuhi syarat, termasuk skemanya.
+ `p_control` – Kolom yang menjadi dasar pembuatan partisi. Jenis data harus bilangan bulat atau berbasis waktu.
+ `p_type` – Jenisnya adalah `'range'` atau `'list'`.
+ `p_interval` – Interval waktu atau rentang bilangan bulat untuk setiap partisi. Contoh nilai meliputi `1 day``1 hour`,, dan sebagainya.
+ `p_premake` – Jumlah partisi yang akan dibuat terlebih dahulu untuk mendukung sisipan baru.
Untuk keterangan lengkap tentang fungsi `create_parent`, lihat [Creation Functions](https://github.com/pgpartman/pg_partman/blob/master/doc/pg_partman.md#user-content-creation-functions) dalam dokumentasi `pg_partman`.
## Mengonfigurasi pemeliharaan partisi menggunakan fungsi run\$1maintenance\$1proc
Anda dapat menjalankan operasi pemeliharaan partisi untuk secara otomatis membuat partisi baru, melepaskan partisi, atau menghapus partisi lama. Pemeliharaan partisi bergantung pada fungsi `run_maintenance_proc` pada ekstensi `pg_partman` dan `pg_cron`, yang memulai penjadwal internal. Penjadwal `pg_cron` secara otomatis mengeksekusi pernyataan, fungsi, dan prosedur SQL yang ditetapkan dalam basis data Anda.
Contoh berikut menggunakan contoh tabel `events` yang dibuat di [Mengaktifkan ekstensi pg\$1partmanMengonfigurasi pemeliharaan partisi menggunakan fungsi run\$1maintenance\$1proc](#PostgreSQL_Partitions.enable) untuk mengatur operasi pemeliharaan partisi agar berjalan secara otomatis. Sebagai prasyarat, tambahkan `pg_cron` ke parameter `shared_preload_libraries` dalam grup parameter instans DB.
```
CREATE EXTENSION pg_cron;
UPDATE partman.part_config
SET infinite_time_partitions = true,
retention = '3 months',
retention_keep_table=true
WHERE parent_table = 'data_mart.events';
SELECT cron.schedule('@hourly', $$CALL partman.run_maintenance_proc()$$);
```
Berikut ini, Anda dapat menemukan step-by-step penjelasan dari contoh sebelumnya:
1. Modifikasi grup parameter yang terkait dengan instans DB Anda dan tambahkan `pg_cron` ke nilai parameter `shared_preload_libraries`. Untuk menerapkan perubahan, instans DB harus dimulai ulang. Untuk informasi selengkapnya, lihat [Memodifikasi parameter dalam grup parameter DB di ](USER_WorkingWithParamGroups.Modifying.md).
1. Jalankan perintah `CREATE EXTENSION pg_cron;` menggunakan akun yang memiliki izin `rds_superuser`. Tindakan ini akan mengaktifkan ekstensi `pg_cron`. Untuk informasi selengkapnya, lihat [Menjadwalkan pemeliharaan dengan ekstensi pg\$1cron PostgreSQL](PostgreSQL_pg_cron.md).
1. Jalankan perintah `UPDATE partman.part_config` guna menyesuaikan pengaturan `pg_partman` untuk tabel `data_mart.events`.
1. Jalankan perintah `SET` . . . untuk mengonfigurasi tabel `data_mart.events` dengan klausul berikut:
1. `infinite_time_partitions = true,` – Mengonfigurasi tabel untuk dapat secara otomatis membuat partisi baru tanpa batas.
1. `retention = '3 months',` – Mengonfigurasi tabel agar memiliki retensi maksimum tiga bulan.
1. `retention_keep_table=true `– Mengonfigurasi tabel agar ketika periode retensi sudah habis, tabel tidak akan dihapus secara otomatis. Sebaliknya, partisi yang lebih lama dari periode retensi hanya dilepaskan dari tabel induk.
1. Jalankan perintah `SELECT cron.schedule` . . . untuk membuat panggilan fungsi `pg_cron`. Panggilan ini menetapkan frekuensi penjadwal menjalankan prosedur pemeliharaan `pg_partman`, `partman.run_maintenance_proc`. Untuk contoh ini, prosedur berjalan setiap jam.
Untuk keterangan lengkap tentang fungsi `run_maintenance_proc`, lihat [Maintenance Functions](https://github.com/pgpartman/pg_partman/blob/master/doc/pg_partman.md#maintenance-functions) dalam dokumentasi `pg_partman`.
# Menjadwalkan pemeliharaan dengan ekstensi pg\$1cron PostgreSQL
Anda dapat menggunakan ekstensi `pg_cron` PostgreSQL untuk menjadwalkan perintah pemeliharaan dalam basis data PostgreSQL. Untuk informasi selengkapnya tentang ekstensi ini, lihat [What is pg\$1cron?](https://github.com/citusdata/pg_cron) dalam dokumentasi pg\$1cron.
Ekstensi `pg_cron` didukung pada mesin Aurora PostgreSQL versi 12.6 dan yang lebih tinggi
Untuk mempelajari selengkapnya tentang penggunaan `pg_cron`, lihat [Menjadwalkan pekerjaan dengan pg\$1cron di RDS for PostgreSQL atau basis data Aurora Edisi Kompatibel PostgreSQL](https://aws.amazon.com/blogs/database/schedule-jobs-with-pg_cron-on-your-amazon-rds-for-postgresql-or-amazon-aurora-for-postgresql-databases/).
**catatan**
Versi `pg_cron` ekstensi ditampilkan sebagai versi dua digit, misalnya, 1.6, dalam tampilan pg\$1available\$1extensions. Meskipun Anda mungkin melihat versi tiga digit, misalnya, 1.6.4 atau 1.6.5, tercantum dalam beberapa konteks, Anda harus menentukan versi dua digit saat melakukan peningkatan ekstensi.
**Topics**
+ [Menyiapkan ekstensi pg\$1cron](#PostgreSQL_pg_cron.enable)
+ [Mengizinkan pengguna basis data untuk menggunakan pg\$1cron](#PostgreSQL_pg_cron.permissions)
+ [Menjadwalkan pekerjaan pg\$1cron](#PostgreSQL_pg_cron.examples)
+ [Referensi untuk ekstensi pg\$1cron](#PostgreSQL_pg_cron.reference)
## Menyiapkan ekstensi pg\$1cron
Siapkan ekstensi `pg_cron` sebagai berikut:
1. Modifikasi grup parameter kustom yang terkait dengan instans DB PostgreSQL Anda dengan menambahkan `pg_cron` ke nilai parameter `shared_preload_libraries`.
Mulai ulang instans DB PostgreSQL untuk menerapkan perubahan pada grup parameter. Untuk mempelajari selengkapnya tentang penggunaan grup parameter, lihat [Parameter Amazon Aurora PostgreSQL](AuroraPostgreSQL.Reference.ParameterGroups.md).
1. Setelah instans DB PostgreSQL dimulai ulang, jalankan perintah berikut menggunakan akun yang memiliki izin `rds_superuser`. Misalnya, jika Anda menggunakan pengaturan default saat membuat klaster DB Aurora PostgreSQL, hubungkan sebagai pengguna `postgres` dan buat ekstensi.
```
CREATE EXTENSION pg_cron;
```
Penjadwal `pg_cron` diatur dalam basis data PostgreSQL default bernama `postgres`. Objek `pg_cron` dibuat dalam basis data `postgres` ini dan semua tindakan penjadwalan berjalan dalam basis data ini.
1. Anda dapat menggunakan pengaturan default, atau Anda dapat menjadwalkan pekerjaan untuk berjalan di basis data lain dalam instans DB PostgreSQL Anda. Untuk menjadwalkan pekerjaan basis data lain dalam instans DB PostgreSQL Anda, lihat contoh di [Menjadwalkan pekerjaan cron untuk basis data selain basis data default](#PostgreSQL_pg_cron.otherDB).
## Mengizinkan pengguna basis data untuk menggunakan pg\$1cron
Menginstal ekstensi `pg_cron` membutuhkan hak istimewa `rds_superuser`. Namun, izin untuk menggunakan `pg_cron` dapat diberikan (oleh anggota grup/peran `rds_superuser`) kepada pengguna basis data lain, sehingga mereka dapat menjadwalkan pekerjaannya sendiri. Sebaiknya hanya berikan izin yang diperlukan ke skema `cron` sesuai kebutuhan ketika skema ini dapat meningkatkan operasi di lingkungan produksi Anda.
Untuk memberikan izin pengguna basis data dalam skema `cron`, jalankan perintah berikut:
```
postgres=> GRANT USAGE ON SCHEMA cron TO db-user;
```
Ini memberikan *db-user* izin untuk mengakses `cron` skema untuk menjadwalkan pekerjaan cron untuk objek yang mereka memiliki izin untuk mengakses. Jika pengguna basis data tidak memiliki izin, tugas akan gagal setelah memposting pesan kesalahan ke file `postgresql.log`, seperti yang ditunjukkan berikut:
```
2020-12-08 16:41:00 UTC::@:[30647]:ERROR: permission denied for table table-name
2020-12-08 16:41:00 UTC::@:[27071]:LOG: background worker "pg_cron" (PID 30647) exited with exit code 1
```
Dengan kata lain, pastikan bahwa pengguna database yang diberikan izin pada `cron` skema juga memiliki izin pada objek (tabel, skema, dan sebagainya) yang mereka rencanakan untuk dijadwalkan.
Detail pekerjaan cron dan keberhasilan atau kegagalannya juga ditangkap dalam `cron.job_run_details` tabel. Untuk informasi selengkapnya, lihat [Tabel untuk menjadwalkan pekerjaan dan menangkap status](#PostgreSQL_pg_cron.tables).
## Menjadwalkan pekerjaan pg\$1cron
Bagian berikut menunjukkan bagaimana Anda dapat menjadwalkan berbagai tugas manajemen menggunakan pekerjaan `pg_cron`.
**catatan**
Saat membuat pekerjaan `pg_cron`, periksa apakah pengaturan jumlah `max_worker_processes` lebih besar dari `cron.max_running_jobs`. Pekerjaan `pg_cron` akan gagal jika kehabisan proses pekerja latar belakang. Jumlah default pekerjaan `pg_cron` adalah `5`. Untuk informasi selengkapnya, lihat [Parameter untuk mengelola ekstensi pg\$1cron](#PostgreSQL_pg_cron.parameters).
**Topics**
+ [Mengosongkan tabel](#PostgreSQL_pg_cron.vacuum)
+ [Membersihkan tabel riwayat pg\$1cron](#PostgreSQL_pg_cron.job_run_details)
+ [Mencatat log kesalahan ke file postgresql.log saja](#PostgreSQL_pg_cron.log_run)
+ [Menjadwalkan pekerjaan cron untuk basis data selain basis data default](#PostgreSQL_pg_cron.otherDB)
### Mengosongkan tabel
Pengosongan otomatis menangani pemeliharaan vakum untuk kebanyakan kasus. Namun, Anda mungkin ingin menjadwalkan pengosongan tabel pada waktu yang Anda pilih.
Berikut adalah contoh penggunaan fungsi `cron.schedule` guna menyiapkan pekerjaan untuk menggunakan `VACUUM FREEZE` pada tabel tertentu setiap hari pada pukul 22.00 (GMT).
```
SELECT cron.schedule('manual vacuum', '0 22 * * *', 'VACUUM FREEZE pgbench_accounts');
schedule
----------
1
(1 row)
```
Setelah contoh sebelumnya berjalan, Anda dapat memeriksa riwayatnya di tabel `cron.job_run_details` seperti berikut.
```
postgres=> SELECT * FROM cron.job_run_details;
jobid | runid | job_pid | database | username | command | status | return_message | start_time | end_time
-------+-------+---------+----------+----------+--------------------------------+-----------+----------------+-------------------------------+-------------------------------
1 | 1 | 3395 | postgres | adminuser| vacuum freeze pgbench_accounts | succeeded | VACUUM | 2020-12-04 21:10:00.050386+00 | 2020-12-04 21:10:00.072028+00
(1 row)
```
Berikut ini adalah query dari `cron.job_run_details` tabel untuk melihat pekerjaan gagal.
```
postgres=> SELECT * FROM cron.job_run_details WHERE status = 'failed';
jobid | runid | job_pid | database | username | command | status | return_message | start_time | end_time
------+-------+---------+----------+----------+-------------------------------+--------+--------------------------------------------------+-------------------------------+------------------------------
5 | 4 | 30339 | postgres | adminuser| vacuum freeze pgbench_account | failed | ERROR: relation "pgbench_account" does not exist | 2020-12-04 21:48:00.015145+00 | 2020-12-04 21:48:00.029567+00
(1 row)
```
Untuk informasi selengkapnya, lihat [Tabel untuk menjadwalkan pekerjaan dan menangkap status](#PostgreSQL_pg_cron.tables).
### Membersihkan tabel riwayat pg\$1cron
Tabel `cron.job_run_details` berisi riwayat pekerjaan cron yang ukurannya bisa menjadi sangat besar dari waktu ke waktu. Sebaiknya jadwalkan pekerjaan untuk membersihkan tabel ini. Sebagai contoh, menyimpan entri selama seminggu mungkin sudah cukup untuk tujuan pemecahan masalah.
Contoh berikut ini menggunakan fungsi [cron.schedule](#PostgreSQL_pg_cron.schedule) untuk menjadwalkan pekerjaan yang berjalan setiap hari pada tengah malam untuk membersihkan tabel `cron.job_run_details`. Pekerjaan ini hanya menyimpan tujuh hari terakhir. Gunakan akun `rds_superuser` untuk menjadwalkan pekerjaan seperti berikut.
```
SELECT cron.schedule('0 0 * * *', $$DELETE
FROM cron.job_run_details
WHERE end_time < now() - interval '7 days'$$);
```
Untuk informasi selengkapnya, lihat [Tabel untuk menjadwalkan pekerjaan dan menangkap status](#PostgreSQL_pg_cron.tables).
### Mencatat log kesalahan ke file postgresql.log saja
Untuk mencegah penulisan ke tabel `cron.job_run_details`, modifikasi grup parameter yang terkait dengan instans DB PostgreSQL dan nonaktifkan parameter `cron.log_run`. Ekstensi `pg_cron` tidak lagi menulis ke tabel dan menangkap kesalahan ke file `postgresql.log` saja. Untuk informasi selengkapnya, lihat [Memodifikasi parameter dalam grup parameter DB di ](USER_WorkingWithParamGroups.Modifying.md).
Gunakan perintah berikut untuk memeriksa nilai parameter `cron.log_run`.
```
postgres=> SHOW cron.log_run;
```
Untuk informasi selengkapnya, lihat [Parameter untuk mengelola ekstensi pg\$1cron](#PostgreSQL_pg_cron.parameters).
### Menjadwalkan pekerjaan cron untuk basis data selain basis data default
Semua metadata untuk `pg_cron` disimpan dalam basis data default PostgreSQL bernama `postgres`. Karena pekerja latar belakang digunakan untuk menjalankan pekerjaan pemeliharaan cron, Anda dapat menjadwalkan pekerjaan di salah satu basis data Anda dalam instans DB PostgreSQL:
**catatan**
Hanya pengguna dengan `rds_superuser` peran atau `rds_superuser` hak istimewa yang dapat mencantumkan semua pekerjaan cron dalam database. Pengguna lain hanya dapat melihat pekerjaan mereka sendiri di `cron.job` tabel.
1. Dalam basis data cron, jadwalkan pekerjaan seperti yang biasa Anda lakukan menggunakan [cron.schedule](#PostgreSQL_pg_cron.schedule).
```
postgres=> SELECT cron.schedule('database1 manual vacuum', '29 03 * * *', 'vacuum freeze test_table');
```
1. Sebagai pengguna dengan peran `rds_superuser`, perbarui kolom basis data untuk pekerjaan yang baru saja Anda buat agar berjalan di basis data lain dalam instans DB PostgreSQL Anda.
```
postgres=> UPDATE cron.job SET database = 'database1' WHERE jobid = 106;
```
1. Verifikasi dengan membuat kueri tabel `cron.job`.
```
postgres=> SELECT * FROM cron.job;
jobid | schedule | command | nodename | nodeport | database | username | active | jobname
------+-------------+--------------------------------+-----------+----------+----------+-----------+--------+-------------------------
106 | 29 03 * * * | vacuum freeze test_table | localhost | 8192 | database1| adminuser | t | database1 manual vacuum
1 | 59 23 * * * | vacuum freeze pgbench_accounts | localhost | 8192 | postgres | adminuser | t | manual vacuum
(2 rows)
```
**catatan**
Dalam beberapa situasi, Anda mungkin menambahkan pekerjaan cron yang ingin Anda jalankan di basis data yang berbeda. Dalam kasus tersebut, pekerjaan mungkin mencoba untuk dijalankan dalam basis data default (`postgres`) sebelum kolom basis data ditentukan dengan benar. Jika nama pengguna memiliki izin, berarti pekerjaan berhasil dijalankan di basis data default.
## Referensi untuk ekstensi pg\$1cron
Anda dapat menggunakan parameter, fungsi, dan tabel berikut dengan ekstensi `pg_cron`. Untuk informasi selengkapnya, lihat [What is pg\$1cron?](https://github.com/citusdata/pg_cron) dalam dokumentasi pg\$1cron.
**Topics**
+ [Parameter untuk mengelola ekstensi pg\$1cron](#PostgreSQL_pg_cron.parameters)
+ [Referensi fungsi: cron.schedule](#PostgreSQL_pg_cron.schedule)
+ [Referensi fungsi: cron.unschedule](#PostgreSQL_pg_cron.unschedule)
+ [Tabel untuk menjadwalkan pekerjaan dan menangkap status](#PostgreSQL_pg_cron.tables)
### Parameter untuk mengelola ekstensi pg\$1cron
Berikut adalah daftar parameter yang mengontrol perilaku ekstensi `pg_cron`.
| Parameter | Deskripsi |
| --- | --- |
| cron.database\$1name | Basis data penyimpanan metadata `pg_cron`. |
| cron.host | Nama host untuk menghubungkan ke PostgreSQL. Anda tidak dapat mengubah nilai ini. |
| cron.log\$1run | Catat log setiap pekerjaan yang berjalan di tabel `job_run_details`. Nilainya adalah `on` atau `off`. Untuk informasi selengkapnya, lihat [Tabel untuk menjadwalkan pekerjaan dan menangkap status](#PostgreSQL_pg_cron.tables). |
| cron.log\$1statement | Catat log semua pernyataan cron sebelum menjalankannya. Nilainya adalah `on` atau `off`. |
| cron.max\$1running\$1jobs | Jumlah maksimum pekerjaan yang dapat dijalankan secara bersamaan. |
| cron.use\$1background\$1workers | Gunakan pekerja latar belakang, bukan sesi klien. Anda tidak dapat mengubah nilai ini. |
Gunakan perintah SQL berikut untuk menampilkan parameter ini dan nilainya.
```
postgres=> SELECT name, setting, short_desc FROM pg_settings WHERE name LIKE 'cron.%' ORDER BY name;
```
### Referensi fungsi: cron.schedule
Fungsi ini menjadwalkan pekerjaan cron. Pada mulanya, pekerjaan dijadwalkan di basis data `postgres` default. Fungsi tersebut mengembalikan nilai `bigint` yang mewakili pengidentifikasi pekerjaan. Untuk menjadwalkan pekerjaan agar berjalan di basis data lain dalam instans DB PostgreSQL Anda, lihat contoh di [Menjadwalkan pekerjaan cron untuk basis data selain basis data default](#PostgreSQL_pg_cron.otherDB).
Fungsi ini memiliki dua format sintaks.
**Sintaks**
```
cron.schedule (job_name,
schedule,
command
);
cron.schedule (schedule,
command
);
```
**Parameter**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/PostgreSQL_pg_cron.html)
**Contoh**
```
postgres=> SELECT cron.schedule ('test','0 10 * * *', 'VACUUM pgbench_history');
schedule
----------
145
(1 row)
postgres=> SELECT cron.schedule ('0 15 * * *', 'VACUUM pgbench_accounts');
schedule
----------
146
(1 row)
```
### Referensi fungsi: cron.unschedule
Fungsi ini menghapus pekerjaan cron. Anda dapat menentukan `job_name` atau `job_id`. Suatu kebijakan memastikan bahwa Anda adalah pemilik guna menghapus jadwal pekerjaan. Fungsi akan mengembalikan Boolean yang menunjukkan keberhasilan atau kegagalan.
Fungsi memiliki format sintaks berikut.
**Sintaks**
```
cron.unschedule (job_id);
cron.unschedule (job_name);
```
**Parameter**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/PostgreSQL_pg_cron.html)
**Contoh**
```
postgres=> SELECT cron.unschedule(108);
unschedule
------------
t
(1 row)
postgres=> SELECT cron.unschedule('test');
unschedule
------------
t
(1 row)
```
### Tabel untuk menjadwalkan pekerjaan dan menangkap status
Tabel berikut digunakan untuk menjadwalkan pekerjaan cron dan mencatat bagaimana pekerjaan tersebut diselesaikan.
| Tabel | Deskripsi |
| --- | --- |
| cron.job | Berisi metadata tentang setiap pekerjaan yang dijadwalkan. Sebagian besar interaksi dengan tabel ini harus dilakukan menggunakan fungsi `cron.schedule` dan `cron.unschedule`. Sebaiknya jangan memberikan pembaruan atau memasukkan hak istimewa secara langsung ke tabel ini. Hal tersebut akan memungkinkan pengguna untuk memperbarui kolom `username` agar berjalan sebagai `rds-superuser`. |
| cron.job\$1run\$1details | Berisi informasi historis tentang pekerjaan terjadwal yang telah dijalankan sebelumnya. Hal ini berguna untuk menyelidiki status, pesan kembali, dan waktu mulai dan akhir dari pekerjaan yang berjalan. Agar ukuran tabel ini tidak bertambah besar, bersihkan secara rutin. Sebagai contoh, lihat [Membersihkan tabel riwayat pg\$1cron](#PostgreSQL_pg_cron.job_run_details). |
# Menggunakan pgAudit untuk mencatat aktivitas database
Lembaga keuangan, lembaga pemerintah, dan banyak industri perlu menyimpan *log audit* untuk memenuhi persyaratan regulasi. Dengan menggunakan ekstensi Postgre SQL Audit (pgAudit) dengan klaster SQL DB Aurora Postgre Anda , Anda dapat menangkap catatan terperinci yang biasanya dibutuhkan oleh auditor atau untuk memenuhi persyaratan peraturan. Misalnya, Anda dapat mengatur pgAudit ekstensi untuk melacak perubahan yang dibuat pada database dan tabel tertentu, untuk merekam pengguna yang membuat perubahan, dan banyak detail lainnya.
pgAudit Ekstensi dibangun di atas fungsionalitas infrastruktur SQL logging Postgre asli dengan memperluas pesan log dengan lebih detail. Dengan kata lain, Anda menggunakan pendekatan yang sama untuk melihat log audit seperti untuk melihat pesan log lain. Untuk informasi lebih lanjut tentang SQL pencatatan Postgre, lihat. [](USER_LogAccess.Concepts.PostgreSQL.md)
pgAudit Ekstensi menyunting data sensitif seperti kata sandi cleartext dari log. Jika cluster Aurora Postgre SQL DB Anda dikonfigurasi untuk mencatat pernyataan bahasa manipulasi data (DML) seperti yang dijelaskan dalam[](USER_LogAccess.Concepts.PostgreSQL.Query_Logging.md), Anda dapat menghindari masalah kata sandi cleartext dengan menggunakan ekstensi Postgre Audit. SQL
Anda dapat mengonfigurasi audit pada basis data instans dengan tingkat kekhususan yang tinggi. Anda dapat mengaudit semua basis data dan semua pengguna. Atau, Anda dapat memilih untuk mengaudit hanya basis data, pengguna, dan objek tertentu lainnya. Anda juga dapat secara eksplisit mengecualikan pengguna dan basis data tertentu agar tidak diaudit. Untuk informasi selengkapnya, lihat [Mengecualikan pengguna atau basis data dari pencatatan log audit](Appendix.PostgreSQL.CommonDBATasks.pgaudit.exclude-user-db.md).
Mengingat jumlah detail yang dapat ditangkap, kami menyarankan jika Anda menggunakannyapgAudit, Anda memantau konsumsi penyimpanan Anda.
pgAudit Ekstensi ini didukung pada semua versi Aurora SQL Postgre yang tersedia. *Untuk daftar versi yang didukung oleh pgAudit versi Aurora Postgre, lihat SQL Versi [ekstensi untuk Amazon Aurora Postgre SQL di Catatan Rilis untuk Aurora Postgre](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html). SQL*
**Topics**
+ [Menyiapkan pgAudit ekstensi](Appendix.PostgreSQL.CommonDBATasks.pgaudit.basic-setup.md)
+ [Mengaudit objek basis data](Appendix.PostgreSQL.CommonDBATasks.pgaudit.auditing.md)
+ [Mengecualikan pengguna atau basis data dari pencatatan log audit](Appendix.PostgreSQL.CommonDBATasks.pgaudit.exclude-user-db.md)
+ [Referensi untuk ekstensi pgAudit](Appendix.PostgreSQL.CommonDBATasks.pgaudit.reference.md)
# Menyiapkan pgAudit ekstensi
Untuk menyiapkan pgAudit ekstensi pada cluster DB instans Postgre SQL DB, Anda terlebih dahulu menambahkan pgAudit ke pustaka bersama pada Anda. RDS RDS SQL grup parameter cluster DB kustom untuk cluster Aurora SQL Postgre DB Anda. Untuk informasi cara membuat Grup parameter klaster DB, lihat [](USER_WorkingWithParamGroups.md). Selanjutnya, Anda menginstal pgAudit ekstensi. Terakhir, Anda menentukan basis data dan objek yang ingin diaudit. Prosedur di bagian ini menunjukkan caranya kepada Anda. Anda dapat menggunakan Konsol Manajemen AWS atau AWS CLI.
Anda harus memiliki izin sebagai peran `rds_superuser` untuk melakukan semua tugas ini.
## Konsol
**Untuk mengatur pgAudit ekstensi**
1. Masuk ke Konsol Manajemen AWS dan buka RDS konsol Amazon di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih instance Writer cluster Aurora SQL Postgre DB Anda untuk Postgre DB. SQL
1. Buka tab **Konfigurasi** untuk instance penulis cluster Aurora Postgre SQL DB Anda. Di antara detail Instans, temukan tautan **Grup parameter**.
1. Pilih tautan untuk membuka parameter khusus yang terkait dengan cluster Aurora SQL Postgre DB Anda.
1. Di kolom pencarian **Parameter**, ketik `shared_pre` untuk menemukan parameter `shared_preload_libraries`.
1. Pilih **Edit parameter** untuk mengakses nilai properti.
1. Tambahkan `pgaudit` ke daftar di kolom **Nilai**. Gunakan koma untuk memisahkan item dalam daftar nilai.
![\[Gambar shared_preload_libaries parameter dengan pgAudit ditambahkan.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/apg_rpg_shared_preload_pgaudit.png)
1. Reboot instance penulis cluster Aurora Postgre SQL DB Anda RDS sehingga perubahan Anda pada parameter berlaku. `shared_preload_libraries`
1. Ketika instance tersedia, verifikasi yang pgAudit telah diinisialisasi. Gunakan `psql` untuk terhubung ke instance penulis cluster Aurora Postgre SQL DB Anda, dan kemudian jalankan perintah berikut.
```
SHOW shared_preload_libraries;
shared_preload_libraries
--------------------------
rdsutils,pgaudit
(1 row)
```
1. Dengan pgAudit diinisialisasi, Anda sekarang dapat membuat ekstensi. Anda perlu membuat ekstensi setelah menginisialisasi pustaka karena `pgaudit` ekstensi menginstal pemicu peristiwa untuk mengaudit pernyataan bahasa definisi data (). DDL
```
CREATE EXTENSION pgaudit;
```
1. Tutup sesi `psql`.
```
labdb=> \q
```
1. Masuk ke Konsol Manajemen AWS dan buka RDS konsol Amazon di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Temukan parameter `pgaudit.log` dalam daftar lalu atur ke nilai yang sesuai untuk kasus penggunaan Anda. Misalnya, menyetel parameter `pgaudit.log` ke `write` seperti yang ditunjukkan pada gambar berikut menangkap sisipan, pembaruan, penghapusan, dan beberapa jenis lainnya yang berubah pada log.
![\[Gambar parameter pgaudit.log dengan pengaturan.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/rpg_set_pgaudit-log-level.png)
Anda juga dapat memilih salah satu nilai berikut untuk parameter `pgaudit.log`.
+ none – Ini adalah default. Tidak ada perubahan basis data yang dibuat log.
+ semua – Semua dibuat log (baca, tulis, fungsi, peran, ddl, misc).
+ ddl — Mencatat semua pernyataan bahasa definisi data (DDL) yang tidak termasuk dalam `ROLE` kelas.
+ fungsi – Membuat log panggilan fungsi dan blok `DO`.
+ misc – Membuat log berbagai perintah, seperti `DISCARD`, `FETCH`, `CHECKPOINT`, `VACUUM`, dan `SET`.
+ baca – Membuat log `SELECT` dan `COPY` saat sumbernya adalah relasi (seperti tabel) atau kueri.
+ peran – Membuat log pernyataan yang terkait dengan peran dan hak akses, seperti `GRANT`, `REVOKE`, `CREATE ROLE`, `ALTER ROLE`, dan `DROP ROLE`.
+ write – Membuat log `INSERT`, `UPDATE`, `DELETE`, `TRUNCATE`, dan `COPY` saat tujuannya adalah relasi (tabel).
1. Pilih **Simpan perubahan**.
1. Buka RDS konsol Amazon di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Pilih instance penulis cluster Aurora Postgre SQL DB Anda RDS untuk instance dari daftar Database.
## AWS CLI
**Untuk pengaturan pgAudit**
Untuk pengaturan pgAudit menggunakan AWS CLI, Anda memanggil [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html)operasi untuk memodifikasi parameter log audit di grup parameter kustom Anda, seperti yang ditunjukkan dalam prosedur berikut.
1. Gunakan yang berikut ini AWS CLI perintah untuk `pgaudit` menambah `shared_preload_libraries` parameter.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name custom-param-group-name \
--parameters "ParameterName=shared_preload_libraries,ParameterValue=pgaudit,ApplyMethod=pending-reboot" \
--region aws-region
```
1. Gunakan yang berikut ini AWS CLI perintah untuk me-reboot instance penulis cluster Aurora Postgre SQL DB Anda RDS untuk instance Postgre DB diinisialisasi.
```
aws rds reboot-db-instance \
--db-instance-identifier writer-instance \
--region aws-region
```
1. Saat instans tersedia, verifikasikan bahwa `pgaudit` telah diinisialisasi. Gunakan `psql` untuk terhubung ke instance penulis cluster Aurora Postgre SQL DB Anda, dan kemudian jalankan perintah berikut.
```
SHOW shared_preload_libraries;
shared_preload_libraries
--------------------------
rdsutils,pgaudit
(1 row)
```
Dengan pgAudit diinisialisasi, Anda sekarang dapat membuat ekstensi.
```
CREATE EXTENSION pgaudit;
```
1. Tutup `psql` sesi sehingga Anda dapat menggunakan AWS CLI.
```
labdb=> \q
```
1. Gunakan yang berikut ini AWS CLI perintah untuk menentukan kelas pernyataan yang ingin dicatat oleh sesi audit logging. Contoh ini menetapkan parameter `pgaudit.log` ke `write`, yang menangkap sisipan, pembaruan, dan penghapusan ke log.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name custom-param-group-name \
--parameters "ParameterName=pgaudit.log,ParameterValue=write,ApplyMethod=pending-reboot" \
--region aws-region
```
Anda juga dapat memilih salah satu nilai berikut untuk parameter `pgaudit.log`.
+ none – Ini adalah default. Tidak ada perubahan basis data yang dibuat log.
+ semua – Semua dibuat log (baca, tulis, fungsi, peran, ddl, misc).
+ ddl — Mencatat semua pernyataan bahasa definisi data (DDL) yang tidak termasuk dalam `ROLE` kelas.
+ fungsi – Membuat log panggilan fungsi dan blok `DO`.
+ misc – Membuat log berbagai perintah, seperti `DISCARD`, `FETCH`, `CHECKPOINT`, `VACUUM`, dan `SET`.
+ baca – Membuat log `SELECT` dan `COPY` saat sumbernya adalah relasi (seperti tabel) atau kueri.
+ peran – Membuat log pernyataan yang terkait dengan peran dan hak akses, seperti `GRANT`, `REVOKE`, `CREATE ROLE`, `ALTER ROLE`, dan `DROP ROLE`.
+ write – Membuat log `INSERT`, `UPDATE`, `DELETE`, `TRUNCATE`, dan `COPY` saat tujuannya adalah relasi (tabel).
Nyalakan ulang instance penulis cluster Aurora Postgre SQL DB Anda RDS untuk instance Postgre DB ini AWS CLI perintah.
```
aws rds reboot-db-instance \
--db-instance-identifier writer-instance \
--region aws-region
```
# Mengaudit objek basis data
Dengan pgAudit pengaturan pada cluster Aurora Postgre SQL DB Anda dan dikonfigurasi untuk kebutuhan Anda, informasi yang lebih rinci ditangkap dalam log Postgre. SQL Misalnya, sementara konfigurasi SQL logging Postgre default mengidentifikasi tanggal dan waktu perubahan dibuat dalam tabel database, dengan pgAudit ekstensi entri log dapat mencakup skema, pengguna yang membuat perubahan, dan detail lainnya tergantung pada bagaimana parameter ekstensi dikonfigurasi. Anda dapat menyiapkan audit untuk melacak perubahan dengan cara berikut.
+ Untuk setiap sesi, oleh pengguna. Untuk tingkat sesi, Anda dapat menangkap teks perintah yang sepenuhnya memenuhi syarat.
+ Untuk setiap objek, oleh pengguna dan basis data.
Kemampuan audit objek diaktifkan saat Anda membuat peran `rds_pgaudit` pada sistem, lalu menambahkan peran ini ke parameter `pgaudit.role` dalam grup parameter kustom Anda. Secara default, parameter `pgaudit.role` tidak ditetapkan dan satu-satunya nilai yang diizinkan adalah `rds_pgaudit`. Langkah-langkah berikut mengasumsikan bahwa `pgaudit` telah diinisialisasi dan bahwa Anda telah membuat ekstensi `pgaudit` dengan mengikuti prosedur di [Menyiapkan pgAudit ekstensi](Appendix.PostgreSQL.CommonDBATasks.pgaudit.basic-setup.md).
![\[Gambar file SQL log Postgre setelah pengaturan. pgAudit\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/pgaudit-log-example.png)
Seperti yang ditunjukkan dalam contoh ini, baris "LOGAUDIT::SESSION" memberikan informasi tentang tabel dan skemanya, di antara detail lainnya.
**Menyiapkan audit objek**
1. Gunakan `psql` untuk terhubung ke instance penulis cluster Aurora SQL Postgre DB Anda.
```
psql --host=your-instance-name.aws-region.rds.amazonaws.com --port=5432 --username=postgrespostgres --password --dbname=labdb
```
1. Buat peran basis data yang dinamai `rds_pgaudit` menggunakan perintah berikut.
```
labdb=> CREATE ROLE rds_pgaudit;
CREATE ROLE
labdb=>
```
1. Tutup sesi `psql`.
```
labdb=> \q
```
Dalam beberapa langkah berikutnya, gunakan AWS CLI untuk memodifikasi parameter log audit di grup parameter kustom Anda.
1. Gunakan yang berikut AWS CLI perintah untuk mengatur `pgaudit.role` parameter ke`rds_pgaudit`. Secara default, parameter ini kosong, dan `rds_pgaudit` merupakan satu-satunya nilai yang diizinkan.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name custom-param-group-name \
--parameters "ParameterName=pgaudit.role,ParameterValue=rds_pgaudit,ApplyMethod=pending-reboot" \
--region aws-region
```
1. Gunakan yang berikut AWS CLI perintah untuk me-reboot instance penulis cluster Aurora Postgre SQL DB Anda RDS sehingga perubahan Anda pada parameter berlaku.
```
aws rds reboot-db-instance \
--db-instance-identifier writer-instance \
--region aws-region
```
1. Jalankan perintah berikut untuk mengonfirmasi bahwa `pgaudit.role` diatur ke `rds_pgaudit`.
```
SHOW pgaudit.role;
pgaudit.role
------------------
rds_pgaudit
```
Untuk menguji pgAudit logging, Anda dapat menjalankan beberapa contoh perintah yang ingin Anda audit. Misalnya, Anda dapat menjalankan perintah berikut.
```
CREATE TABLE t1 (id int);
GRANT SELECT ON t1 TO rds_pgaudit;
SELECT * FROM t1;
id
----
(0 rows)
```
Log basis data harus berisi entri yang serupa dengan entri berikut.
```
...
2017-06-12 19:09:49 UTC:...:rds_test@postgres:[11701]:LOG: AUDIT:
OBJECT,1,1,READ,SELECT,TABLE,public.t1,select * from t1;
...
```
Untuk informasi tentang menampilkan log, lihat [Memantau log Amazon Aurora Amazon](USER_LogAccess.md).
Untuk mempelajari lebih lanjut tentang pgAudit ekstensi, lihat [pgAudit](https://github.com/pgaudit/pgaudit/blob/master/README.md)di GitHub.
# Mengecualikan pengguna atau basis data dari pencatatan log audit
Seperti dibahas dalam[](USER_LogAccess.Concepts.PostgreSQL.md), SQL log Postgre mengkonsumsi ruang penyimpanan. Menggunakan pgAudit ekstensi menambah volume data yang dikumpulkan di log Anda ke berbagai tingkat, tergantung pada perubahan yang Anda lacak. Anda mungkin tidak perlu mengaudit setiap pengguna atau database di cluster Aurora SQL Postgre DB Anda.
Untuk meminimalkan dampak pada penyimpanan dan untuk menghindari pengambilan catatan audit yang tidak perlu, Anda dapat mengecualikan pengguna dan basis data agar tidak diaudit. Anda juga dapat mengubah pencatatan log dalam sesi tertentu. Contoh berikut menunjukkan caranya kepada Anda.
**catatan**
Pengaturan parameter pada tingkat sesi lebih diutamakan daripada pengaturan dalam grup parameter cluster DB kustom untuk grup parameter DB khusus instance penulis Aurora Postgre SQL DB cluster untuk instance . RDS SQL Jika Anda tidak ingin pengguna basis data melewati pengaturan konfigurasi pencatatan audit, pastikan untuk mengubah izin mereka.
Misalkan cluster Aurora Postgre SQL DB Anda dikonfigurasi untuk mengaudit tingkat aktivitas yang sama untuk semua pengguna dan database. Anda kemudian memutuskan bahwa Anda tidak ingin mengaudit pengguna `myuser`. Anda dapat menonaktifkan audit `myuser` dengan SQL perintah berikut.
```
ALTER USER myuser SET pgaudit.log TO 'NONE';
```
Kemudian, Anda dapat menggunakan kueri berikut untuk memeriksa kolom `user_specific_settings` untuk `pgaudit.log` guna mengonfirmasi bahwa parameter ditetapkan ke `NONE`.
```
SELECT
usename AS user_name,
useconfig AS user_specific_settings
FROM
pg_user
WHERE
usename = 'myuser';
```
Anda akan melihat output seperti berikut ini.
```
user_name | user_specific_settings
-----------+------------------------
myuser | {pgaudit.log=NONE}
(1 row)
```
Anda dapat menonaktifkan pencatatan log untuk pengguna tertentu di tengah-tengah sesi mereka menggunakan basis data dengan perintah berikut.
```
ALTER USER myuser IN DATABASE mydatabase SET pgaudit.log TO 'none';
```
Gunakan kueri berikut untuk memeriksa kolom pengaturan pgaudit.log untuk kombinasi pengguna dan basis data tertentu.
```
SELECT
usename AS "user_name",
datname AS "database_name",
pg_catalog.array_to_string(setconfig, E'\n') AS "settings"
FROM
pg_catalog.pg_db_role_setting s
LEFT JOIN pg_catalog.pg_database d ON d.oid = setdatabase
LEFT JOIN pg_catalog.pg_user r ON r.usesysid = setrole
WHERE
usename = 'myuser'
AND datname = 'mydatabase'
ORDER BY
1,
2;
```
Anda akan melihat output yang mirip dengan berikut ini.
```
user_name | database_name | settings
-----------+---------------+------------------
myuser | mydatabase | pgaudit.log=none
(1 row)
```
Setelah menonaktifkan audit `myuser`, Anda memutuskan bahwa Anda tidak ingin melacak perubahan ke `mydatabase`. Anda menonaktifkan audit untuk basis data spesifik tersebut menggunakan perintah berikut.
```
ALTER DATABASE mydatabase SET pgaudit.log to 'NONE';
```
Kemudian, gunakan kueri berikut untuk memeriksa kolom database\$1specific\$1settings untuk mengonfirmasi bahwa pgaudit.log disetel ke. NONE
```
SELECT
a.datname AS database_name,
b.setconfig AS database_specific_settings
FROM
pg_database a
FULL JOIN pg_db_role_setting b ON a.oid = b.setdatabase
WHERE
a.datname = 'mydatabase';
```
Anda akan melihat output seperti berikut ini.
```
database_name | database_specific_settings
---------------+----------------------------
mydatabase | {pgaudit.log=NONE}
(1 row)
```
Untuk mengembalikan pengaturan ke pengaturan default untuk myuser, gunakan perintah berikut:
```
ALTER USER myuser RESET pgaudit.log;
```
Untuk mengembalikan pengaturan ke pengaturan default untuk basis data, gunakan perintah berikut ini.
```
ALTER DATABASE mydatabase RESET pgaudit.log;
```
Untuk mengatur ulang pengguna dan basis data ke pengaturan default, gunakan perintah berikut.
```
ALTER USER myuser IN DATABASE mydatabase RESET pgaudit.log;
```
Anda juga dapat menangkap peristiwa tertentu ke log dengan menyetel `pgaudit.log` ke salah satu nilai lain yang diizinkan untuk parameter `pgaudit.log`. Untuk informasi selengkapnya, lihat [Daftar pengaturan yang diizinkan untuk parameter `pgaudit.log`](Appendix.PostgreSQL.CommonDBATasks.pgaudit.reference.md#Appendix.PostgreSQL.CommonDBATasks.pgaudit.reference.pgaudit-log-settings).
```
ALTER USER myuser SET pgaudit.log TO 'read';
ALTER DATABASE mydatabase SET pgaudit.log TO 'function';
ALTER USER myuser IN DATABASE mydatabase SET pgaudit.log TO 'read,function'
```
# Referensi untuk ekstensi pgAudit
Anda dapat menentukan tingkat detail yang diinginkan untuk log audit Anda dengan mengubah satu atau beberapa parameter yang tercantum di bagian ini.
## Mengatur perilaku pgAudit
Anda dapat mengontrol pencatatan log audit dengan mengubah satu atau beberapa parameter yang tercantum pada tabel berikut.
| Parameter | Deskripsi |
| --- | --- |
| `pgaudit.log` | Menentukan kelas pernyataan yang akan di-log oleh sesi audit pencatatan log. Nilai yang diizinkan termasuk ddl, fungsi, misc, baca, peran, tulis, tidak ada, semua. Untuk informasi selengkapnya, lihat [Daftar pengaturan yang diizinkan untuk parameter `pgaudit.log`](#Appendix.PostgreSQL.CommonDBATasks.pgaudit.reference.pgaudit-log-settings). |
| `pgaudit.log_catalog` | Saat diaktifkan (diatur ke 1), tambahkan pernyataan ke jejak audit jika semua relasi dalam pernyataan ada di pg\$1catalog. |
| `pgaudit.log_level` | Menentukan tingkat log untuk digunakan dalam entri log. Nilai yang diizinkan: debug5, debug4, debug3, debug2, debug1, info, notifikasi, peringatan, log |
| `pgaudit.log_parameter` | Saat diaktifkan (diatur ke 1), parameter yang diteruskan dengan pernyataan ditangkap dalam log audit. |
| `pgaudit.log_relation` | Saat diaktifkan (diatur ke 1), log audit untuk sesi akan membuat entri log terpisah untuk setiap relasi (TABLE, VIEW, dan sebagainya) yang direferensikan dalam pernyataan SELECT atau DML. |
| `pgaudit.log_statement_once` | Menentukan apakah logging akan mencakup teks pernyataan dan parameter dengan entri log pertama untuk statement/substatement kombinasi atau dengan setiap entri. |
| `pgaudit.role` | Menentukan peran utama yang akan digunakan untuk pencatatan log audit objek. Satu-satunya entri yang diizinkan adalah `rds_pgaudit`. |
## Daftar pengaturan yang diizinkan untuk parameter `pgaudit.log`
| Nilai | Deskripsi |
| --- | --- |
| Tidak ada | Ini adalah opsi default. Tidak ada perubahan basis data yang dibuat log. |
| semua | Membuat log untuk semua (baca, tulis, fungsi, peran, ddl, misc). |
| ddl | Membuat log semua pernyataan bahasa definisi data (DDL) yang tidak disertakan dalam kelas `ROLE`. |
| Fungsi | Membuat log panggilan fungsi dan blok `DO`. |
| misc | Membuat log berbagai perintah, seperti `DISCARD`, `FETCH`, `CHECKPOINT`, `VACUUM` dan `SET`. |
| baca | Membuat log `SELECT` dan `COPY` saat sumbernya adalah relasi (seperti tabel) atau kueri. |
| peran | Membuat log pernyataan terkait peran dan hak akses, seperti `GRANT`, `REVOKE`, `CREATE ROLE`, `ALTER ROLE`, dan `DROP ROLE`. |
| tulis | Membuat log `INSERT`, `UPDATE`, `DELETE`, `TRUNCATE`, dan `COPY` saat tujuannya adalah relasi (tabel). |
Untuk mencatat beberapa jenis peristiwa dengan audit sesi, gunakan daftar yang dipisahkan koma. Untuk membuat log semua jenis peristiwa, atur `pgaudit.log` ke `ALL`. Boot ulang instans DB Anda untuk menerapkan perubahan.
Dengan objek audit, Anda dapat memperbaiki pencatatan log audit agar berfungsi dengan relasi tertentu. Misalnya, Anda dapat menentukan bahwa Anda ingin pencatatan log audit untuk operasi `READ` di satu tabel atau lebih.
# Menggunakan pglogical untuk menyinkronkan data di seluruh instans
Semua versi Aurora PostgreSQL yang tersedia saat ini mendukung ekstensi `pglogical`. Ekstensi pglogical mendahului fitur replikasi logis yang mirip secara fungsional yang diperkenalkan oleh PostgreSQL di versi 10. Untuk informasi selengkapnya, lihat [Ikhtisar replikasi logis PostgreSQL dengan Aurora](AuroraPostgreSQL.Replication.Logical.md).
Ekstensi `pglogical` ini mendukung replikasi logis antara dua klaster DB Aurora PostgreSQL atau lebih. Ini juga mendukung replikasi antara versi PostgreSQL yang berbeda, dan antara basis data yang berjalan pada instans DB RDS for PostgreSQL dan klaster DB Aurora PostgreSQL. Ekstensi `pglogical` menggunakan model terbitkan-dan-langganan untuk mereplikasi perubahan pada tabel dan objek lain, seperti urutan, dari penerbit ke pelanggan. Itu bergantung pada slot replikasi untuk memastikan bahwa perubahan disinkronkan dari simpul penerbit ke simpul pelanggan, didefinisikan sebagai berikut.
+ *Simpul penerbit* adalah klaster DB Aurora PostgreSQL yang merupakan sumber data yang akan direplikasi ke simpul lain. Simpul penerbit mendefinisikan tabel yang akan direplikasi dalam set publikasi.
+ *Simpul pelanggan* adalah klaster DB Aurora PostgreSQL yang menerima pembaruan WAL dari penerbit. Pelanggan membuat langganan untuk menghubungkan ke penerbit dan mendapatkan data WAL yang dikodekan. Saat pelanggan membuat langganan, slot replikasi dibuat pada simpul penerbit.
Berikut ini, Anda dapat menemukan informasi tentang cara mengatur ekstensi `pglogical`.
**Topics**
+ [Persyaratan dan batasan untuk ekstensi pglogical](#Appendix.PostgreSQL.CommonDBATasks.pglogical.requirements-limitations)
+ [Menyiapkan ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md)
+ [Menyiapkan replikasi logis untuk klaster DB Aurora PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.pglogical.setup-replication.md)
+ [Membangun kembali replikasi logis setelah peningkatan besar](Appendix.PostgreSQL.CommonDBATasks.pglogical.recover-replication-after-upgrade.md)
+ [Mengelola slot replikasi logis untuk Aurora PostgreSQL RDS](Appendix.PostgreSQL.CommonDBATasks.pglogical.handle-slots.md)
+ [Referensi parameter untuk ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.reference.md)
## Persyaratan dan batasan untuk ekstensi pglogical
Semua rilis Aurora PostgreSQL yang tersedia saat ini mendukung ekstensi `pglogical`.
Baik simpul penerbit maupun simpul pelanggan harus disiapkan untuk replikasi logis.
Tabel yang ingin Anda replikasi dari penerbit ke pelanggan harus memiliki nama dan skema yang sama. Tabel ini juga harus berisi kolom yang sama, dan kolom harus menggunakan jenis data yang sama. Tabel penerbit dan pelanggan harus memiliki kunci primer yang sama. Sebaiknya Anda hanya menggunakan PRIMARY KEY sebagai batasan unik.
Tabel pada simpul pelanggan dapat memiliki batasan yang lebih permisif dibandingkan yang ada di simpul penerbit untuk batasan CHECK dan NOT NULL.
Ekstensi `pglogical` ini menyediakan fitur seperti replikasi dua arah yang tidak didukung oleh fitur replikasi logis default PostgreSQL (versi 10 dan lebih tinggi). Untuk informasi selengkapnya, lihat [replikasi bi-direksional PostgreSQL menggunakan pglogical](https://aws.amazon.com/blogs/database/postgresql-bi-directional-replication-using-pglogical/).
# Menyiapkan ekstensi pglogical
Untuk menyiapkan ekstensi `pglogical` pada klaster DB Aurora PostgreSQL, tambahkan `pglogical` ke pustaka bersama pada grup parameter klaster DB kustom untuk klaster DB Aurora PostgreSQL. Anda juga perlu mengatur nilai parameter `rds.logical_replication` ke `1`, untuk mengaktifkan penguraian kode logis. Terakhir, Anda membuat ekstensi di basis data. Anda dapat menggunakan Konsol Manajemen AWS atau AWS CLI untuk tugas-tugas ini.
Anda harus memiliki izin sebagai peran `rds_superuser` untuk melakukan semua tugas ini.
Langkah-langkah berikut mengasumsikan bahwa klaster DB Aurora PostgreSQL Anda terhubung dengan grup parameter DB . Untuk informasi cara membuat Grup parameter klaster DB, lihat [](USER_WorkingWithParamGroups.md).
## Konsol
**Menyiapkan ekstensi pglogical**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih Instans penulis klaster DB Aurora PostgreSQL .
1. Buka tab **Konfigurasi** untuk instans penulis klaster DB Aurora PostgreSQL. Di antara detail Instans, temukan tautan **Grup parameter**.
1. Pilih tautan untuk membuka parameter kustom yang terkait dengan klaster DB Aurora PostgreSQL Anda.
1. Di kolom pencarian **Parameter**, ketik `shared_pre` untuk menemukan parameter `shared_preload_libraries`.
1. Pilih **Edit parameter** untuk mengakses nilai properti.
1. Tambahkan `pglogical` ke daftar di kolom **Nilai**. Gunakan koma untuk memisahkan item dalam daftar nilai.
![\[Gambar parameter shared_preload_libraries dengan pglogical yang ditambahkan.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/apg_rpg_shared_preload_pglogical.png)
1. Temukan parameter `rds.logical_replication` dan atur ke `1`, untuk mengaktifkan replikasi logis.
1. Boot ulang instans penulis klaster DB Aurora PostgreSQL agar perubahan Anda diterapkan.
1. Saat instans tersedia, Anda dapat menggunakan `psql` (atau pgAdmin) untuk terhubung ke instans penulis klaster DB Aurora PostgreSQL
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
1. Untuk memverifikasi bahwa pglogical telah diinisialisasi, jalankan perintah berikut.
```
SHOW shared_preload_libraries;
shared_preload_libraries
--------------------------
rdsutils,pglogical
(1 row)
```
1. Verifikasikan pengaturan yang memungkinkan penguraian kode logis, sebagai berikut.
```
SHOW wal_level;
wal_level
-----------
logical
(1 row)
```
1. Buat ekstensi, sebagai berikut.
```
CREATE EXTENSION pglogical;
EXTENSION CREATED
```
1. Pilih **Simpan perubahan**.
1. Buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Pilih instans penulis klaster DB Aurora PostgreSQL dari daftar Basis Data untuk memilihnya, lalu pilih **Boot ulang** dari menu Tindakan.
## AWS CLI
**Menyiapkan ekstensi pglogical**
Untuk mengatur pglogical menggunakan AWS CLI, Anda memanggil [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html)operasi untuk memodifikasi parameter tertentu dalam grup parameter kustom Anda seperti yang ditunjukkan dalam prosedur berikut.
1. Gunakan AWS CLI perintah berikut `pglogical` untuk menambah `shared_preload_libraries` parameter.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name custom-param-group-name \
--parameters "ParameterName=shared_preload_libraries,ParameterValue=pglogical,ApplyMethod=pending-reboot" \
--region aws-region
```
1. Gunakan AWS CLI perintah berikut untuk mengatur `rds.logical_replication` `1` untuk mengaktifkan kemampuan decoding logis untuk instance penulis dari cluster DB PostgreSQL Aurora.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name custom-param-group-name \
--parameters "ParameterName=rds.logical_replication,ParameterValue=1,ApplyMethod=pending-reboot" \
--region aws-region
```
1. Gunakan AWS CLI perintah berikut untuk me-reboot instance penulis Aurora PostgreSQL DB cluster RDS untuk instance PostgreSQL DB pglogical diinisialisasi.
```
aws rds reboot-db-instance \
--db-instance-identifier writer-instance \
--region aws-region
```
1. Saat instans tersedia, gunakan `psql` untuk terhubung ke instans penulis klaster DB Aurora PostgreSQL
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
1. Buat ekstensi, sebagai berikut.
```
CREATE EXTENSION pglogical;
EXTENSION CREATED
```
1. Reboot instance penulis Aurora PostgreSQL DB cluster instance PostgreSQL DB menggunakan perintah berikut. AWS CLI
```
aws rds reboot-db-instance \
--db-instance-identifier writer-instance \
--region aws-region
```
# Menyiapkan replikasi logis untuk klaster DB Aurora PostgreSQL
Prosedur berikut menunjukkan cara memulai replikasi logis di antara dua klaster DB Aurora PostgreSQL Langkah-langkah mengasumsikan bahwa sumber (penerbit) dan target (pelanggan) memiliki ekstensi `pglogical` yang disiapkan seperti yang dijelaskan dalam [Menyiapkan ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md).
**catatan**
`node_name`Node pelanggan tidak dapat memulai dengan`rds`.
**Untuk membuat simpul penerbit dan menentukan tabel untuk direplikasi**
Langkah-langkah ini mengasumsikan bahwa klaster DB Aurora PostgreSQL memiliki instans penulis dengan basis data yang memiliki satu atau beberapa tabel yang ingin direplikasi ke simpul lain. Anda perlu membuat ulang struktur tabel dari penerbit pada pelanggan, jadi pertama-tama, dapatkan struktur tabel jika perlu. Anda dapat melakukannya dengan menggunakan `psql` metacommand `\d tablename`, lalu membuat tabel yang sama pada instans pelanggan. Prosedur berikut membuat tabel contoh pada penerbit (sumber) untuk tujuan demonstrasi.
1. Gunakan `psql` untuk terhubung ke instans yang memiliki tabel yang ingin Anda gunakan sebagai sumber untuk pelanggan.
```
psql --host=source-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
Jika tidak memiliki tabel yang ingin ditiru, Anda dapat membuat tabel contoh sebagai berikut.
1. Buat contoh tabel menggunakan pernyataan SQL berikut.
```
CREATE TABLE docs_lab_table (a int PRIMARY KEY);
```
1. Mengisi tabel dengan data yang dihasilkan menggunakan pernyataan SQL berikut.
```
INSERT INTO docs_lab_table VALUES (generate_series(1,5000));
INSERT 0 5000
```
1. Verifikasikan bahwa data ada dalam tabel menggunakan pernyataan SQL berikut.
```
SELECT count(*) FROM docs_lab_table;
```
1. Identifikasi klaster DB Aurora PostgreSQL ini sebagai simpul penerbit, sebagai berikut.
```
SELECT pglogical.create_node(
node_name := 'docs_lab_provider',
dsn := 'host=source-instance.aws-region.rds.amazonaws.com port=5432 dbname=labdb');
create_node
-------------
3410995529
(1 row)
```
1. Tambahkan tabel yang ingin Anda replikasi ke set replikasi default. Untuk informasi set replikasi selengkapnya, lihat [Replication sets](https://github.com/2ndQuadrant/pglogical/tree/REL2_x_STABLE/docs#replication-sets) dalam dokumentasi pglogical.
```
SELECT pglogical.replication_set_add_table('default', 'docs_lab_table', 'true', NULL, NULL);
replication_set_add_table
---------------------------
t
(1 row)
```
Penyiapan simpul penerbit selesai. Anda sekarang dapat menyiapkan simpul pelanggan untuk menerima informasi terkini dari penerbit.
**Untuk menyiapkan simpul pelanggan dan membuat langganan untuk menerima informasi terkini**
Langkah-langkah ini mengasumsikan bahwa klaster DB Aurora PostgreSQL telah disiapkan dengan ekstensi `pglogical`. Untuk informasi selengkapnya, lihat [Menyiapkan ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md).
1. Gunakan `psql` untuk terhubung ke instans yang ingin Anda terima informasi terkini dari penerbit.
```
psql --host=target-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
1. Pada pelanggan klaster DB Aurora PostgreSQL, , buat tabel yang sama yang ada pada penerbit. Untuk contoh ini, tabelnya adalah `docs_lab_table`. Anda dapat membuat tabel sebagai berikut.
```
CREATE TABLE docs_lab_table (a int PRIMARY KEY);
```
1. Verifikasi bahwa tabel ini kosong.
```
SELECT count(*) FROM docs_lab_table;
count
-------
0
(1 row)
```
1. Identifikasi klaster DB Aurora PostgreSQL ini sebagai simpul pelanggan, sebagai berikut.
```
SELECT pglogical.create_node(
node_name := 'docs_lab_target',
dsn := 'host=target-instance.aws-region.rds.amazonaws.com port=5432 sslmode=require dbname=labdb user=postgres password=********');
create_node
-------------
2182738256
(1 row)
```
1. Buat langganan.
```
SELECT pglogical.create_subscription(
subscription_name := 'docs_lab_subscription',
provider_dsn := 'host=source-instance.aws-region.rds.amazonaws.com port=5432 sslmode=require dbname=labdb user=postgres password=*******',
replication_sets := ARRAY['default'],
synchronize_data := true,
forward_origins := '{}' );
create_subscription
---------------------
1038357190
(1 row)
```
Saat Anda menyelesaikan langkah ini, data dari tabel pada penerbit akan dibuat dalam tabel pada pelanggan. Anda dapat memverifikasi bahwa tabel telah dibuat menggunakan query SQL berikut.
```
SELECT count(*) FROM docs_lab_table;
count
-------
5000
(1 row)
```
Mulai dari titik ini, perubahan yang dilakukan pada tabel pada penerbit direplikasi ke tabel pada pelanggan.
# Membangun kembali replikasi logis setelah peningkatan besar
Sebelum Anda dapat melakukan upgrade versi utama dari cluster Aurora Postgre SQL DB RDS yang diatur sebagai node penerbit untuk replikasi logis, Anda harus menghapus semua slot replikasi, bahkan yang tidak aktif. Kami menyarankan Anda mengalihkan sementara transaksi database dari node penerbit, menjatuhkan slot replikasi, meningkatkan cluster Aurora Postgre SQL DB, meningkatkan instance Postgre DB RDS untuk SQL Postgre, kembali dan memulai ulang replikasi.
Slot replikasi hanya di-hosting di simpul penerbit. Node SQL pelanggan Aurora Postgre dalam skenario replikasi logis tidak memiliki slot untuk dijatuhkan. Proses upgrade versi SQL utama Aurora Postgre mendukung peningkatan pelanggan ke versi utama baru SQL Postgre independen dari node penerbit. Namun, proses upgrade memang mengganggu proses replikasi dan mengganggu sinkronisasi WAL data antara node penerbit dan node pelanggan. Anda perlu membangun kembali replikasi logis antara penerbit dan pelanggan setelah peningkatan penerbit, pelanggan, atau keduanya. Prosedur berikut menunjukkan kepada Anda cara menentukan bahwa replikasi telah terganggu dan cara mengatasi masalah tersebut.
## Menentukan bahwa replikasi logis telah terganggu
Anda dapat menentukan bahwa proses replikasi telah terganggu dengan menanyakan simpul penerbit atau simpul pelanggan, sebagai berikut.
**Untuk memeriksa simpul penerbit**
+ Gunakan `psql` untuk terhubung ke simpul penerbit, lalu buat kueri fungsi `pg_replication_slots`. Perhatikan nilai di kolom aktif. Biasanya, ini akan kembali `t` (benar), menunjukkan bahwa replikasi aktif. Jika kueri kembali `f` (salah), ini merupakan indikasi bahwa replikasi ke pelanggan telah berhenti.
```
SELECT slot_name,plugin,slot_type,active FROM pg_replication_slots;
slot_name | plugin | slot_type | active
-------------------------------------------+------------------+-----------+--------
pgl_labdb_docs_labcb4fa94_docs_lab3de412c | pglogical_output | logical | f
(1 row)
```
**Untuk memeriksa simpul pelanggan**
Pada simpul pelanggan, Anda dapat memeriksa status replikasi dengan tiga cara berbeda.
+ Lihat melalui SQL log Postgre pada node pelanggan untuk menemukan pesan kegagalan. Log dapat mengidentifikasi kegagalan dengan pesan yang menyertakan kode keluar 1, sebagaimana ditunjukkan berikut.
```
2022-07-06 16:17:03 UTC::@:[7361]:LOG: background worker "pglogical apply 16404:2880255011" (PID 14610) exited with exit code 1
2022-07-06 16:19:44 UTC::@:[7361]:LOG: background worker "pglogical apply 16404:2880255011" (PID 21783) exited with exit code 1
```
+ Buat kueri fungsi `pg_replication_origin`. Hubungkan ke basis data pada simpul pelanggan menggunakan `psql` dan buat kueri fungsi `pg_replication_origin`, sebagai berikut.
```
SELECT * FROM pg_replication_origin;
roident | roname
---------+--------
(0 rows)
```
Set hasil kosong berarti replikasi telah terganggu. Biasanya, Anda akan melihat output seperti berikut.
```
roident | roname
---------+----------------------------------------------------
1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c
(1 row)
```
+ Buat kueri fungsi `pglogical.show_subscription_status` sebagaimana ditunjukkan pada contoh berikut.
```
SELECT subscription_name,status,slot_name FROM pglogical.show_subscription_status();
subscription_name | status | slot_name
---====----------------+--------+-------------------------------------
docs_lab_subscription | down | pgl_labdb_docs_labcb4fa94_docs_lab3de412c
(1 row)
```
Output ini menunjukkan bahwa replikasi telah terganggu. Statusnya adalah `down`. Biasanya, output menunjukkan status sebagai `replicating`.
Jika proses replikasi logis terganggu, Anda dapat membangun kembali replikasi dengan mengikuti langkah-langkah berikut.
**Untuk membangun kembali replikasi logis antara simpul penerbit dan pelanggan**
Untuk membangun kembali replikasi, pertama-tama Anda memutuskan sambungan pelanggan dari simpul penerbit, lalu membangun kembali langganan, seperti yang diuraikan dalam langkah-langkah ini.
1. Hubungkan ke simpul pelanggan menggunakan `psql`, sebagai berikut.
```
psql --host=222222222222.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
1. Nonaktifkan langganan menggunakan fungsi `pglogical.alter_subscription_disable`.
```
SELECT pglogical.alter_subscription_disable('docs_lab_subscription',true);
alter_subscription_disable
----------------------------
t
(1 row)
```
1. Dapatkan identifier simpul penerbit dengan menanyakan `pg_replication_origin`, sebagai berikut.
```
SELECT * FROM pg_replication_origin;
roident | roname
---------+-------------------------------------
1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c
(1 row)
```
1. Gunakan respons dari langkah sebelumnya dengan perintah `pg_replication_origin_create` untuk menetapkan pengenal yang dapat digunakan oleh langganan saat dibuat kembali.
```
SELECT pg_replication_origin_create('pgl_labdb_docs_labcb4fa94_docs_lab3de412c');
pg_replication_origin_create
------------------------------
1
(1 row)
```
1. Aktifkan langganan dengan meneruskan namanya menggunakan status `true`, sebagaimana ditunjukkan dalam contoh berikut.
```
SELECT pglogical.alter_subscription_enable('docs_lab_subscription',true);
alter_subscription_enable
---------------------------
t
(1 row)
```
Periksa status simpul. Statusnya harus `replicating` sebagaimana ditunjukkan dalam contoh ini.
```
SELECT subscription_name,status,slot_name
FROM pglogical.show_subscription_status();
subscription_name | status | slot_name
-------------------------------+-------------+-------------------------------------
docs_lab_subscription | replicating | pgl_labdb_docs_lab98f517b_docs_lab3de412c
(1 row)
```
Periksa status slot replikasi pelanggan pada simpul penerbit. Kolom `active` slot harus kembali `t` (benar), menunjukkan bahwa replikasi telah dibuat kembali.
```
SELECT slot_name,plugin,slot_type,active
FROM pg_replication_slots;
slot_name | plugin | slot_type | active
-------------------------------------------+------------------+-----------+--------
pgl_labdb_docs_lab98f517b_docs_lab3de412c | pglogical_output | logical | t
(1 row)
```
# Mengelola slot replikasi logis untuk Aurora PostgreSQL RDS
Sebelum dapat melakukan peningkatan versi utama dari instans penulis klaster DB Aurora PostgreSQL yang disiapkan sebagai simpul penerbit untuk replikasi logis, Anda harus menghapus semua slot replikasi, bahkan yang tidak aktif. Proses pra-pemeriksaan peningkatan versi utama akan memberi tahu Anda bahwa peningkatan tidak dapat dilanjutkan sampai slot dihapuskan sementara.
Untuk mengidentifikasi slot replikasi yang dibuat menggunakan ekstensi `pglogical`, masuk ke setiap basis data dan dapatkan nama simpul. Bila membuat kueri simpul pelanggan, Anda akan mendapatkan simpul penerbit dan pelanggan dalam output, sebagaimana ditunjukkan dalam contoh ini.
```
SELECT * FROM pglogical.node;
node_id | node_name
------------+-------------------
2182738256 | docs_lab_target
3410995529 | docs_lab_provider
(2 rows)
```
Anda dapat memperoleh detail tentang langganan dengan kueri berikut.
```
SELECT sub_name,sub_slot_name,sub_target
FROM pglogical.subscription;
sub_name | sub_slot_name | sub_target
----------+--------------------------------+------------
docs_lab_subscription | pgl_labdb_docs_labcb4fa94_docs_lab3de412c | 2182738256
(1 row)
```
Anda sekarang dapat menghapus sementara langganan, sebagai berikut.
```
SELECT pglogical.drop_subscription(subscription_name := 'docs_lab_subscription');
drop_subscription
-------------------
1
(1 row)
```
Setelah menghapus sementara langganan, Anda dapat menghapus simpul.
```
SELECT pglogical.drop_node(node_name := 'docs-lab-subscriber');
drop_node
-----------
t
(1 row)
```
Anda dapat memverifikasi bahwa simpul tidak ada lagi, sebagai berikut.
```
SELECT * FROM pglogical.node;
node_id | node_name
---------+-----------
(0 rows)
```
# Referensi parameter untuk ekstensi pglogical
Dalam tabel, Anda dapat menemukan parameter yang terkait dengan ekstensi `pglogical`. Parameter seperti `pglogical.conflict_log_level` dan `pglogical.conflict_resolution` digunakan untuk menangani konflik pembaruan. Konflik dapat muncul saat perubahan dilakukan secara lokal ke tabel yang sama yang berlangganan terhadap perubahan dari penerbit. Konflik juga dapat terjadi selama berbagai skenario, seperti replikasi dua arah atau saat beberapa pelanggan mereplikasi dari penerbit yang sama. Untuk informasi selengkapnya, lihat [replikasi bi-direksional PostgreSQL menggunakan pglogical](https://aws.amazon.com/blogs/database/postgresql-bi-directional-replication-using-pglogical/).
| Parameter | Deskripsi |
| --- | --- |
| pglogical.batch\$1inserts | Melakukan penyisipan batch jika memungkinkan. Tidak diatur secara default. Ubah ke '1' untuk mengaktifkan, '0' untuk menonaktifkan. |
| pglogical.conflict\$1log\$1level | Menetapkan tingkat log yang digunakan untuk mencatat log konflik yang diselesaikan. Nilai string yang didukung adalah debug5, debug4, debug3, debug2, debug1, info, notice, warning, error, log, fatal, panic. |
| pglogical.conflict\$1resolution | Menetapkan metode yang digunakan untuk menyelesaikan konflik saat konflik dapat diselesaikan. Nilai string yang didukung adalah kesalahan, apply\$1remote, keep\$1local, last\$1update\$1wins, first\$1update\$1wins. |
| pglogical.extra\$1connection\$1options | Opsi koneksi untuk ditambahkan ke semua koneksi simpul peer. |
| pglogical.synchronous\$1commit | nilai komit sinkron spesifik pglogical |
| pglogical.use\$1spi | Gunakan SPI (antarmuka pemrograman server) alih-alih API tingkat rendah untuk menerapkan perubahan. Atur ke '1' untuk mengaktifkan, '0' untuk menonaktifkan. Untuk informasi SPI selengkapnya, lihat [Server Programming Interface](https://www.postgresql.org/docs/current/spi.html) dalam dokumentasi PostgreSQL. |
# 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).