Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan ekstensi PostgreSQL dengan Amazon RDS for PostgreSQL
Anda dapat memperluas fungsionalitas PostgreSQL dengan menginstal berbagai ekstensi dan modul. Misalnya, untuk bekerja dengan data spasial Anda dapat menginstal dan menggunakan ekstensi PostGIS. Untuk informasi selengkapnya, lihat [Mengelola data spasial dengan ekstensi PostGIS](Appendix.PostgreSQL.CommonDBATasks.PostGIS.md). Sebagai contoh lain, jika Anda ingin meningkatkan entri data untuk tabel yang sangat besar, Anda dapat mempertimbangkan untuk mempartisi data Anda dengan menggunakan ekstensi `pg_partman`. Untuk mempelajari selengkapnya, lihat [Mengelola partisi PostgreSQL dengan ekstensi pg\$1partman](PostgreSQL_Partitions.md).
**catatan**
RDS untuk PostgreSQL mendukung Ekstensi Bahasa Tepercaya untuk PostgreSQL melalui ekstensi, yang dapat Anda tambahkan ke instans DB Anda. `pg_tle` Dengan menggunakan ekstensi ini, developer dapat membuat ekstensi PostgreSQL mereka sendiri di lingkungan yang aman yang menyederhanakan persyaratan penyiapan dan konfigurasi. Untuk mempelajari tentang RDS untuk versi PostgreSQL yang `pg_tle` mendukung ekstensi dan 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 DB kustom instans DB RDS For 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 lebih lanjut, [lihat Mencatat rencana eksekusi kueri](https://aws.amazon.com/premiumsupport/knowledge-center/rds-postgresql-tune-query-performance/#) di pusat AWS pengetahuan.
Bergantung pada versi RDS for PostgreSQL Anda, menginstal ekstensi mungkin memerlukan izin `rds_superuser`, sebagai berikut:
+ Untuk RDS for PostgreSQL versi 12 dan versi sebelumnya, menginstal ekstensi yang memerlukan hak istimewa `rds_superuser`.
+ Untuk RDS for PostgreSQL versi 13 dan versi yang lebih tinggi, pengguna (peran) dengan izin membuat pada instans basis data tertentu yang dapat menginstal dan menggunakan *ekstensi tepercaya apa pun*. Untuk daftar ekstensi tepercaya, lihat [Ekstensi terpercaya PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.Extensions.md#PostgreSQL.Concepts.General.Extensions.Trusted).
Anda juga dapat menentukan dengan tepat ekstensi mana yang dapat diinstal pada instans DB RDS for PostgreSQL, dengan mencantumkannya dalam parameter `rds.allowed_extensions`. Untuk informasi selengkapnya, lihat [Membatasi penginstalan ekstensi PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.Extensions.md#PostgreSQL.Concepts.General.FeatureSupport.Extensions.Restriction).
Untuk mempelajari lebih lanjut tentang peran `rds_superuser` tersebut, lihat [Memahami peran dan izin PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.Roles.md).
**Topics**
+ [
# Menggunakan fungsi dari ekstensi orafce
](Appendix.PostgreSQL.CommonDBATasks.orafce.md)
+ [
# Menggunakan dukungan ekstensi yang didelegasikan Amazon RDS untuk PostgreSQL
](RDS_delegated_ext.md)
+ [
# Mengelola partisi PostgreSQL dengan ekstensi pg\$1partman
](PostgreSQL_Partitions.md)
+ [
# Menggunakan pgAudit untuk mencatat aktivitas database
](Appendix.PostgreSQL.CommonDBATasks.pgaudit.md)
+ [
# Menjadwalkan pemeliharaan dengan ekstensi pg\$1cron PostgreSQL
](PostgreSQL_pg_cron.md)
+ [
# Menggunakan pglogical untuk menyinkronkan data di seluruh instans
](Appendix.PostgreSQL.CommonDBATasks.pglogical.md)
+ [
# Menggunakan pgactive untuk mendukung replikasi aktif-aktif
](Appendix.PostgreSQL.CommonDBATasks.pgactive.md)
+ [
# Mengurangi bloat dalam tabel dan indeks dengan ekstensi pg\$1repack
](Appendix.PostgreSQL.CommonDBATasks.pg_repack.md)
+ [
# Memutakhirkan dan menggunakan ekstensi PLV8
](PostgreSQL.Concepts.General.UpgradingPLv8.md)
+ [
# Menggunakan PL/Rust untuk menulis fungsi PostgreSQL dalam bahasa Rust
](PostgreSQL.Concepts.General.Using.PL_Rust.md)
+ [
# Mengelola data spasial dengan ekstensi PostGIS
](Appendix.PostgreSQL.CommonDBATasks.PostGIS.md)
# Menggunakan fungsi dari ekstensi orafce
Ekstensi Orafce menyediakan fungsi dan operator yang meniru subset fungsi dan paket dari basis data Oracle. Ekstensi orafce memudahkan Anda untuk mem-port aplikasi Oracle ke PostgreSQL. RDS for PostgreSQL versi 9.6.6 dan yang lebih tinggi mendukung ekstensi ini. Untuk informasi lebih lanjut tentang orafce, lihat [orafce](https://github.com/orafce/orafce) di. GitHub
**catatan**
RDS for PostgreSQL tidak mendukung paket `utl_file` yang merupakan bagian dari ekstensi orafce. Karena fungsi skema `utl_file` menyediakan operasi baca dan tulis pada file teks sistem operasi, yang membutuhkan akses superuser ke host yang mendasarinya. Sebagai layanan terkelola, RDS for PostgreSQL tidak menyediakan akses host.
**Menggunakan ekstensi orafce**
1. Hubungkan ke instans DB dengan nama pengguna utama yang Anda gunakan untuk membuat instans DB.
Jika Anda ingin mengaktifkan orafce untuk basis data yang berbeda dalam instans DB yang sama, gunakan perintah psql `/c dbname`. Dengan menggunakan perintah ini, Anda dapat mengubah dari basis data utama setelah memulai koneksi.
1. Nyalakan ekstensi orafce dengan pernyataan `CREATE EXTENSION`.
```
CREATE EXTENSION orafce;
```
1. Transfer kepemilikan skema oracle ke peran rds\$1superuser dengan pernyataan `ALTER SCHEMA`.
```
ALTER SCHEMA oracle OWNER TO rds_superuser;
```
Jika Anda ingin melihat daftar pemilik untuk skema oracle, gunakan perintah psql `\dn`.
# Menggunakan dukungan ekstensi yang didelegasikan Amazon RDS untuk PostgreSQL
Menggunakan dukungan ekstensi yang didelegasikan Amazon RDS untuk PostgreSQL, Anda dapat mendelegasikan manajemen ekstensi ke 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 instans RDS DB Anda, dengan mencantumkannya di `rds.allowed_extensions` parameter. 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
+ 16.4 dan versi 16 yang lebih tinggi
+ 15.8 dan versi 15 yang lebih tinggi
+ 14.13 dan versi 14 yang lebih tinggi
+ 13.16 dan 13 versi yang lebih tinggi
+ 12.20 dan versi 12 yang lebih tinggi
**Topics**
+ [
## Mengaktifkan dukungan ekstensi delegasi ke pengguna
](#RDSPostgreSQL.delegated_ext_mgmt)
+ [
## Konfigurasi yang digunakan dalam dukungan ekstensi yang didelegasikan RDS untuk PostgreSQL
](#RDSPostgreSQL.delegated_ext_config)
+ [
## Mematikan dukungan untuk ekstensi yang didelegasikan
](#RDSPostgreSQL.delegated_ext_disable)
+ [
## Manfaat menggunakan dukungan ekstensi yang didelegasikan Amazon RDS
](#RDSPostgreSQL.delegated_ext_benefits)
+ [
## Batasan dukungan ekstensi yang didelegasikan Amazon RDS untuk PostgreSQL
](#RDSPostgreSQL.delegated_ext_limit)
+ [
## Izin diperlukan untuk ekstensi tertentu
](#RDSPostgreSQL.delegated_ext_perm)
+ [
## Pertimbangan Keamanan
](#RDSPostgreSQL.delegated_ext_sec)
+ [
## Jatuhkan kaskade ekstensi dinonaktifkan
](#RDSPostgreSQL.delegated_ext_drop)
+ [
## Contoh ekstensi yang dapat ditambahkan menggunakan dukungan ekstensi yang didelegasikan
](#RDSPostgreSQL.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 [Grup parameter untuk RDS](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 RDS 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/UserGuide/RDS_delegated_ext.html) Untuk mempelajari lebih lanjut tentang pengaturan parameter ini, lihat[Mengaktifkan dukungan ekstensi delegasi ke pengguna](#RDSPostgreSQL.delegated_ext_mgmt). | rds\$1superuser |
| `rds.allowed_extensions` | Parameter ini memungkinkan pelanggan membatasi ekstensi yang dapat diinstal dalam instans RDS 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 instans RDS 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 RDS
Dengan menggunakan dukungan ekstensi yang didelegasikan Amazon RDS 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 Amazon RDS untuk PostgreSQL
+ Objek yang dibuat selama proses pembuatan ekstensi mungkin memerlukan hak istimewa tambahan agar ekstensi berfungsi dengan baik.
+ Beberapa ekstensi tidak dapat dikelola oleh pengguna ekstensi yang didelegasikan secara default, termasuk yang berikut:`log_fdw`,,`pg_cron`,`pg_tle`,`pgactive`,`pglogical`, `postgis_raster``postgis_tiger_geocoder`,`postgis_topology`.
## 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 | none | us\$1gaz, us\$1lex, us\$1lex, i.us\$1rules | none | none | none |
| amcheck | bt\$1index\$1check, bt\$1index\$1parent\$1check | none | none | none | none |
| dict\$1int | none | none | none | intdict | none |
| pg\$1partman | none | custom\$1time\$1partisi, part\$1config, part\$1config\$1sub | none | none | none |
| pg\$1stat\$1statements | none | none | none | none | none |
| PostGIS | st\$1tileamplop | spatial\$1ref\$1sys | none | none | none |
| postgis\$1raster | none | none | none | none | none |
| postgis\$1topology | none | topologi, lapisan | topologi | none | pengguna yang didelegasikan Harus menjadi pemilik database |
| log\$1fdw | create\$1foreign\$1table\$1for\$1log\$1file | none | none | none | none |
| rds\$1tools | role\$1password\$1encryption\$1type | none | none | none | none |
| postgis\$1tiger\$1geocoder | none | geocode\$1settings\$1default, geocode\$1settings | harimau | none | none |
| pg\$1freespacemap | pg\$1freespace | none | none | none | none |
| pg\$1visibility | pg\$1visibility | none | none | none | none |
## 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 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 pada RDS for PostgreSQL versi 12.5 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 [](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`.
# 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 Anda RDSuntuk instans Postgre SQL DB, 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 Anda RDSuntuk instans Postgre SQL DB dikonfigurasi untuk mencatat pernyataan bahasa manipulasi data (DML) seperti yang dijelaskan dalam[Mengaktifkan pencatatan kueri untuk ](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 RDSuntuk versi PostgreSQL. Untuk daftar versi yang didukung oleh tersedia RDS untuk pgAudit versi Postgre, lihat SQL [Versi ekstensi untuk Amazon untuk Postgre di Catatan Rilis *Amazon RDS RDS untuk SQL* Postgre](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-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 , Anda terlebih dahulu menambahkan pgAudit ke pustaka bersama pada grup parameter DB kustom untuk instans Postgre DB Anda. RDS RDS SQL Untuk informasi cara membuat grup parameter DB kustom, lihat [Grup parameter untuk RDS](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 . SQL
1. Buka tab **Konfigurasi** untuk instance penulis cluster Anda. RDSuntuk contoh Postgre SQL DB. Di antara detail Instans, temukan tautan **Grup parameter**.
1. Pilih tautan untuk membuka parameter khusus yang terkait dengan cluster DB Anda. RDSuntuk contoh Postgre SQL DB.
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/UserGuide/images/apg_rpg_shared_preload_pgaudit.png)
1. Reboot untuk instance Postgre SQL DB sehingga perubahan Anda pada parameter berlaku. `shared_preload_libraries`
1. Ketika instance tersedia, verifikasi yang pgAudit telah diinisialisasi. Gunakan `psql` untuk terhubung ke 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/UserGuide/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 Postgre SQL DB 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 sehingga pustaka SQL pgaudit diinisialisasi.
```
aws rds reboot-db-instance \
--db-instance-identifier your-instance \
--region aws-region
```
1. Saat instans tersedia, verifikasikan bahwa `pgaudit` telah diinisialisasi. Gunakan `psql` untuk terhubung ke 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 menggunakan yang berikut SQL ini AWS CLI perintah.
```
aws rds reboot-db-instance \
--db-instance-identifier your-instance \
--region aws-region
```
# Mengaudit objek basis data
Dengan pgAudit pengaturan pada Anda RDSuntuk instans Postgre SQL DB 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/UserGuide/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 . RDSuntuk contoh Postgre SQL DB.
```
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 untuk instance Postgre SQL DB sehingga perubahan Anda pada parameter berlaku.
```
aws rds reboot-db-instance \
--db-instance-identifier your-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 file RDS 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 DB Anda. RDSuntuk contoh Postgre SQL DB.
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 Postgre DB. RDS SQL Jika Anda tidak ingin pengguna basis data melewati pengaturan konfigurasi pencatatan audit, pastikan untuk mengubah izin mereka.
Misalkan Anda RDSuntuk instans Postgre SQL DB 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.
# 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 RDS for PostgreSQL versi 12.5 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`.
+ Jika instans DB RDS for PostgreSQL menggunakan parameter `rds.allowed_extensions` untuk secara eksplisit mencantumkan ekstensi yang dapat diinstal, Anda perlu menambahkan ekstensi `pg_cron` ke daftar. Hanya versi RDS for PostgreSQL tertentu yang mendukung parameter `rds.allowed_extensions`. Secara default, semua ekstensi yang tersedia diizinkan. Untuk informasi selengkapnya, lihat [Membatasi penginstalan ekstensi PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.Extensions.md#PostgreSQL.Concepts.General.FeatureSupport.Extensions.Restriction).
Mulai ulang instans DB PostgreSQL untuk menerapkan perubahan pada grup parameter. Untuk mempelajari selengkapnya tentang penggunaan grup parameter, lihat [](USER_WorkingWithParamGroups.Modifying.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 instans DB RDS for 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.
Lihat juga, [](Appendix.PostgreSQL.CommonDBATasks.Autovacuum.md).
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 [](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/UserGuide/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/UserGuide/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 pglogical untuk menyinkronkan data di seluruh instans
Semua versi RDS for 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 [Melakukan replikasi logis untuk Amazon RDS for PostgreSQL](PostgreSQL.Concepts.General.FeatureSupport.LogicalReplication.md).
Ekstensi `pglogical` ini mendukung replikasi logis antara dua atau lebih. Instans DB RDS for PostgreSQL. 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 instans DB RDS for PostgreSQL yang merupakan sumber data yang akan direplikasi ke simpul lain. Simpul penerbit mendefinisikan tabel yang akan direplikasi dalam set publikasi.
+ *Simpul pelanggan* adalah instans DB RDS for 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 instans DB RDS for 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 untuk PostgreSQL
](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 RDS for 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 instans DB RDS for PostgreSQL , tambahkan `pglogical` ke pustaka bersama pada grup parameter DB kustom untuk instans DB RDS for 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 instans DB RDS for PostgreSQL Anda terhubung dengan grup parameter klaster DB kustom. Untuk informasi cara membuat grup parameter DB kustom, lihat [Grup parameter untuk RDS](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 DB RDS for PostgreSQL.
1. Buka tab **Konfigurasi** untuk Instans DB RDS for PostgreSQL. Di antara detail Instans, temukan tautan **Grup parameter**.
1. Pilih tautan untuk membuka parameter kustom yang terkait dengan Anda. Instans DB RDS for PostgreSQL.
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/UserGuide/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 DB RDS for PostgreSQL DB Anda agar perubahan Anda diterapkan.
1. Saat instans tersedia, Anda dapat menggunakan `psql` (atau pgAdmin) untuk terhubung ke instans DB RDS for 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 DB RDS for 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 . Instans DB RDS for PostgreSQL.
```
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 sehingga pustaka pglogical diinisialisasi.
```
aws rds reboot-db-instance \
--db-instance-identifier your-instance \
--region aws-region
```
1. Saat instans tersedia, gunakan `psql` untuk terhubung ke instans DB RDS for 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 menggunakan perintah berikut. AWS CLI
```
aws rds reboot-db-instance \
--db-instance-identifier your-instance \
--region aws-region
```
# Menyiapkan replikasi logis untuk instans DB RDS for PostgreSQL
Prosedur berikut menunjukkan cara memulai replikasi logis di antara dua instans DB RDS for 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 instans DB RDS for PostgreSQL memiliki 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 instans DB RDS for 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 instans DB RDS for 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 instans DB RDS for 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 instans DB RDS for 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 untuk instance Postgre SQL DB 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 dan kemudian membangun kembali dan memulai ulang replikasi.
Slot replikasi hanya di-hosting di simpul penerbit. Node SQL pelanggan RDS untuk Postgre dalam skenario replikasi logis tidak memiliki slot untuk turun, tetapi tidak dapat ditingkatkan ke versi utama sementara itu ditetapkan sebagai simpul pelanggan dengan berlangganan ke penerbit. Sebelum memutakhirkan node SQL pelanggan RDS untuk Postgre, lepaskan langganan dan node. Untuk informasi selengkapnya, lihat [Mengelola slot replikasi logis untuk untuk PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.pglogical.handle-slots.md).
## 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 untuk PostgreSQL
Sebelum dapat melakukan peningkatan versi utama dari instans DB RDS for 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 menghapus sementara slot dari instans DB RDS for PostgreSQL Anda, pertama-tama hapus sementara langganan, lalu hapus sementara slotnya.
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. |
# Menggunakan pgactive untuk mendukung replikasi aktif-aktif
Ekstensi `pgactive` menggunakan replikasi aktif-aktif untuk mendukung dan mengoordinasikan operasi penulisan pada beberapa RDS untuk basis data PostgreSQL. Amazon RDS for `pgactive` PostgreSQL mendukung ekstensi pada versi berikut:
+ RDS untuk PostgreSQL 17.0 dan semua versi yang lebih tinggi
+ RDS untuk PostgreSQL 16.1 dan versi 16 yang lebih tinggi
+ RDS untuk PostgreSQL 15.4-R2 dan versi 15 yang lebih tinggi
+ RDS untuk PostgreSQL 14.10 dan versi 14 yang lebih tinggi
+ RDS untuk PostgreSQL 13.13 dan versi 13 yang lebih tinggi
+ RDS untuk PostgreSQL 12.17 dan versi 12 yang lebih tinggi
+ RDS untuk PostgreSQL 11.22
**catatan**
Ketika ada operasi tulis pada lebih dari satu basis data dalam konfigurasi replikasi, konflik mungkin terjadi. Untuk informasi selengkapnya, lihat [Menangani konflik dalam replikasi aktif-aktif](Appendix.PostgreSQL.CommonDBATasks.pgactive.handle-conflicts.md)
**Topics**
+ [
## Batasan untuk ekstensi pgactive
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.requirements-limitations)
+ [
# Menginisialisasi kemampuan ekstensi pgactive
](Appendix.PostgreSQL.CommonDBATasks.pgactive.basic-setup.md)
+ [
# Menyiapkan replikasi aktif-aktif untuk instans DB RDS for PostgreSQL
](Appendix.PostgreSQL.CommonDBATasks.pgactive.setup-replication.md)
+ [
# Mengukur lag replikasi di antara anggota pgactive
](Appendix.PostgreSQL.CommonDBATasks.pgactive.replicationlag.md)
+ [
# Mengkonfigurasi pengaturan parameter untuk ekstensi pgactive
](Appendix.PostgreSQL.CommonDBATasks.pgactive.parameters.md)
+ [
# Memahami konflik aktif-aktif
](Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.replication.md)
+ [
# Memahami skema pgactive
](Appendix.PostgreSQL.CommonDBATasks.pgactive.schema.md)
+ [
# referensi fungsi pgactive
](pgactive-functions-reference.md)
+ [
# Menangani konflik dalam replikasi aktif-aktif
](Appendix.PostgreSQL.CommonDBATasks.pgactive.handle-conflicts.md)
+ [
# Menangani urutan dalam replikasi aktif-aktif
](Appendix.PostgreSQL.CommonDBATasks.pgactive.handle-sequences.md)
## Batasan untuk ekstensi pgactive
+ Semua tabel memerlukan Kunci Primer, jika bukan Pembaruan dan Hapus tidak akan diperbolehkan. Nilai di kolom Kunci Primer tidak boleh diperbarui.
+ Urutan mungkin memiliki celah dan terkadang mungkin tidak mengikuti perintah. Urutan tidak direplikasi. Untuk informasi selengkapnya, lihat [Menangani urutan dalam replikasi aktif-aktif](Appendix.PostgreSQL.CommonDBATasks.pgactive.handle-sequences.md).
+ DDL dan objek besar tidak direplikasi.
+ Indeks unik sekunder dapat menyebabkan divergensi data.
+ Kolasi harus identik pada semua simpul dalam grup.
+ Penyeimbang beban di seluruh simpul adalah anti-pola.
+ Transaksi besar dapat menyebabkan kelambatan replikasi.
# Menginisialisasi kemampuan ekstensi pgactive
Untuk menginisialisasi kemampuan ekstensi `pgactive` pada instans DB RDS for PostgreSQL, tetapkan nilai parameter `rds.enable_pgactive` ke `1` dan kemudian buat ekstensi dalam basis data. Melakukannya secara otomatis menyalakan parameter `rds.logical_replication` dan `track_commit_timestamp` lalu menetapkan nilai `wal_level` ke `logical`.
Anda harus memiliki izin sebagai peran `rds_superuser` untuk melakukan tugas-tugas ini.
Anda dapat menggunakan Konsol Manajemen AWS atau AWS CLI untuk membuat RDS yang diperlukan untuk instance PostgreSQL DB. Langkah-langkah berikut mengasumsikan bahwa instans DB RDS for PostgreSQL Anda dikaitkan dengan grup parameter DB kustom. Untuk informasi tentang cara membuat grup parameter DB kustom, lihat [Grup parameter untuk RDS](USER_WorkingWithParamGroups.md).
## Konsol
**Untuk menginisialisasi kemampuan ekstensi pgactive**
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 DB RDS for PostgreSQL.
1. Buka tab **Konfigurasi** untuk instans DB RDS for PostgreSQL. Dalam detail instans, temukan tautan **grup parameter instans DB**.
1. Pilih tautan untuk membuka parameter kustom yang terkait dengan instans DB RDS for PostgreSQL.
1. Temukan parameter `rds.enable_pgactive`, lalu atur ke `1` untuk menginisialisasi kemampuan `pgactive`.
1. Pilih **Simpan perubahan**.
1. Dalam panel navigasi yang ada pada konsol Amazon RDS, pilih **Basis Data**.
1. Pilih instans DB RDS for PostgreSQL, kemudian pilih **Boot ulang** dari menu **Tindakan**.
1. Konfirmasikan boot ulang instans DB sehingga perubahan Anda berlaku.
1. Ketika instans tersedia, Anda dapat menggunakan `psql` klien PostgreSQL lainnya agar terhubung ke instans DB RDS for PostgreSQL.
Contoh berikut mengasumsikan bahwa RDS Anda untuk PostgreSQL DB instance memiliki database default bernama. *postgres*
```
psql --host=mydb.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password=PASSWORD --dbname=postgres
```
1. Untuk memverifikasi bahwa pgactive telah diinisialisasi, jalankan perintah berikut.
```
postgres=>SELECT setting ~ 'pgactive'
FROM pg_catalog.pg_settings
WHERE name = 'shared_preload_libraries';
```
Jika `pgactive` berada di `shared_preload_libraries`, perintah sebelumnya akan mengembalikan yang berikut:
```
?column?
----------
t
```
## AWS CLI
**Untuk menginisialisasi kemampuan ekstensi pgactive**
Untuk menginisialisasi `pgactive` penggunaan AWS CLI, panggil [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 untuk mengatur `rds.enable_pgactive` untuk menginisialisasi `pgactive` kemampuan `1` untuk RDS untuk PostgreSQL DB instance.
```
postgres=>aws rds modify-db-parameter-group \
--db-parameter-group-name custom-param-group-name \
--parameters "ParameterName=rds.enable_pgactive,ParameterValue=1,ApplyMethod=pending-reboot" \
--region aws-region
```
1. Gunakan AWS CLI perintah berikut untuk me-reboot RDS untuk PostgreSQL DB instance sehingga perpustakaan diinisialisasi. `pgactive`
```
aws rds reboot-db-instance \
--db-instance-identifier your-instance \
--region aws-region
```
1. Saat instans tersedia, gunakan `psql` untuk terhubung ke instans DB RDS for PostgreSQL.
```
psql --host=mydb.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=master user --password=PASSWORD --dbname=postgres
```
1. Untuk memverifikasi bahwa pgactive telah diinisialisasi, jalankan perintah berikut.
```
postgres=>SELECT setting ~ 'pgactive'
FROM pg_catalog.pg_settings
WHERE name = 'shared_preload_libraries';
```
Jika `pgactive` berada di `shared_preload_libraries`, perintah sebelumnya akan mengembalikan yang berikut:
```
?column?
----------
t
```
# Menyiapkan replikasi aktif-aktif untuk instans DB RDS for PostgreSQL
Prosedur berikut menunjukkan cara memulai replikasi aktif-aktif antara dua klaster jika tersedia. `pgactive` Untuk menjalankan contoh ketersediaan tinggi beberapa wilayah, Anda perlu menerapkan instans Amazon RDS for PostgreSQL di dua wilayah berbeda dan menyiapkan VPC Peering. Untuk informasi selengkapnya, lihat [VPC peering](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html).
**catatan**
Mengirim lalu lintas antar beberapa wilayah dapat menimbulkan biaya tambahan.
Langkah-langkah ini mengasumsikan bahwa RDS untuk instance PostgreSQL DB telah diaktifkan dengan ekstensi. `pgactive` Untuk informasi selengkapnya, lihat [Menginisialisasi kemampuan ekstensi pgactive](Appendix.PostgreSQL.CommonDBATasks.pgactive.basic-setup.md).
**Mengonfigurasi instans DB RDS for PostgreSQL dengan ekstensi `pgactive`**
Contoh berikut menggambarkan cara grup `pgactive` dibuat, bersama dengan langkah-langkah lain yang diperlukan untuk membuat ekstensi `pgactive` pada instans DB RDS for PostgreSQL.
1. Gunakan `psql` atau alat klien lain agar terhubung ke instans DB RDS for PostgreSQL.
```
psql --host=firstinstance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password=PASSWORD --dbname=postgres
```
1. Buat basis data pada instans RDS for PostgreSQL menggunakan perintah berikut:
```
postgres=> CREATE DATABASE app;
```
1. Alihkan koneksi ke basis data baru menggunakan perintah berikut:
```
\c app
```
1. Buat dan konten tabel menggunakan pernyataan SQL berikut:
1. Buat contoh tabel menggunakan pernyataan SQL berikut.
```
app=> CREATE SCHEMA inventory;
CREATE TABLE inventory.products (
id int PRIMARY KEY, product_name text NOT NULL,
created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP);
```
1. Mengisi tabel dengan beberapa contoh data yang dihasilkan dengan menggunakan pernyataan SQL berikut.
```
app=> INSERT INTO inventory.products (id, product_name)
VALUES (1, 'soap'), (2, 'shampoo'), (3, 'conditioner');
```
1. Verifikasi bahwa data ada dalam tabel dengan menggunakan pernyataan SQL berikut.
```
app=>SELECT count(*) FROM inventory.products;
count
-------
3
```
1. Buat ekstensi `pgactive` pada basis data yang ada.
```
app=> CREATE EXTENSION pgactive;
```
1. Untuk membuat dan menginisialisasi grup pgactive dengan aman, gunakan perintah berikut:
```
app=>
-- connection info for endpoint1
CREATE SERVER pgactive_server_endpoint1
FOREIGN DATA WRAPPER pgactive_fdw
OPTIONS (host '', dbname 'app');
CREATE USER MAPPING FOR postgres
SERVER pgactive_server_endpoint1
OPTIONS (user 'postgres', password '');
-- connection info for endpoint2
CREATE SERVER pgactive_server_endpoint2
FOREIGN DATA WRAPPER pgactive_fdw
OPTIONS (host '', dbname 'app');
CREATE USER MAPPING FOR postgres
SERVER pgactive_server_endpoint2
OPTIONS (user 'postgres', password '');
```
Sekarang Anda dapat menginisialisasi grup replikasi dan menambahkan contoh pertama ini:
```
SELECT pgactive.pgactive_create_group(
node_name := 'endpoint1-app',
node_dsn := 'user_mapping=postgres pgactive_foreign_server=pgactive_server_endpoint1'
);
```
Gunakan perintah berikut sebagai metode alternatif tetapi kurang aman untuk membuat dan menginisialisasi grup pgactive:
```
app=> SELECT pgactive.pgactive_create_group(
node_name := 'node1-app',
node_dsn := 'dbname=app host=firstinstance.111122223333.aws-region.rds.amazonaws.com user=postgres password=PASSWORD');
```
node1-app adalah nama yang Anda tetapkan untuk mengidentifikasi simpul secara unik dalam grup `pgactive`.
**catatan**
Untuk melakukan langkah ini dengan sukses pada instans DB yang dapat diakses publik, Anda harus mengaktifkan parameter `rds.custom_dns_resolution` dengan menyetelnya ke `1`.
1. Untuk memeriksa apakah instans DB sudah siap, gunakan perintah berikut ini:
```
app=> SELECT pgactive.pgactive_wait_for_node_ready();
```
Jika perintah berhasil, Anda dapat melihat output sebagai berikut:
```
pgactive_wait_for_node_ready
------------------------------
(1 row)
```
**Mengonfigurasi instans RDS for PostgreSQL kedua dan bergabung ke grup `pgactive`**
Contoh berikut menggambarkan cara instans DB RDS for PostgreSQL bergabung ke grup `pgactive`, bersama dengan langkah-langkah lain yang diperlukan untuk membuat ekstensi `pgactive` pada instans DB.
Langkah-langkah ini mengasumsikan bahwa instans DB RDS for PostgreSQL lainnya telah disiapkan dengan ekstensi `pgactive`. Untuk informasi selengkapnya, lihat [Menginisialisasi kemampuan ekstensi pgactive](Appendix.PostgreSQL.CommonDBATasks.pgactive.basic-setup.md).
1. Gunakan `psql` untuk terhubung ke instans yang ingin Anda terima pembaruan dari penerbit.
```
psql --host=secondinstance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password=PASSWORD --dbname=postgres
```
1. Buat basis data pada instans DB RDS for PostgreSQL kedua menggunakan perintah berikut:
```
postgres=> CREATE DATABASE app;
```
1. Alihkan koneksi ke basis data baru menggunakan perintah berikut:
```
\c app
```
1. Buat ekstensi `pgactive` pada basis data yang ada.
```
app=> CREATE EXTENSION pgactive;
```
1. Bergabunglah dengan kedua PostgreSQL ke grup dengan cara yang lebih aman menggunakan perintah berikut: `pgactive`
```
-- connection info for endpoint1
CREATE SERVER pgactive_server_endpoint1
FOREIGN DATA WRAPPER pgactive_fdw
OPTIONS (host '', dbname 'app');
CREATE USER MAPPING FOR postgres
SERVER pgactive_server_endpoint1
OPTIONS (user 'postgres', password '');
-- connection info for endpoint2
CREATE SERVER pgactive_server_endpoint2
FOREIGN DATA WRAPPER pgactive_fdw
OPTIONS (host '', dbname 'app');
CREATE USER MAPPING FOR postgres
SERVER pgactive_server_endpoint2
OPTIONS (user 'postgres', password '');
```
```
SELECT pgactive.pgactive_join_group(
node_name := 'endpoint2-app',
node_dsn := 'user_mapping=postgres pgactive_foreign_server=pgactive_server_endpoint2',
join_using_dsn := 'user_mapping=postgres pgactive_foreign_server=pgactive_server_endpoint1'
);
```
Gunakan perintah berikut sebagai metode alternatif tetapi kurang aman untuk bergabung dengan ke grup `pgactive`
```
app=> SELECT pgactive.pgactive_join_group(
node_name := 'node2-app',
node_dsn := 'dbname=app host=secondinstance.111122223333.aws-region.rds.amazonaws.com user=postgres password=PASSWORD',
join_using_dsn := 'dbname=app host=firstinstance.111122223333.aws-region.rds.amazonaws.com user=postgres password=PASSWORD');
```
node2-app adalah nama yang Anda tetapkan untuk mengidentifikasi simpul secara unik dalam grup `pgactive`.
1. Untuk memeriksa apakah instans DB sudah siap, gunakan perintah berikut ini:
```
app=> SELECT pgactive.pgactive_wait_for_node_ready();
```
Jika perintah berhasil, Anda dapat melihat output sebagai berikut:
```
pgactive_wait_for_node_ready
------------------------------
(1 row)
```
Jika basis data RDS for PostgreSQL pertama relatif besar, Anda dapat melihat `pgactive.pgactive_wait_for_node_ready()` yang merilis laporan kemajuan operasi pemulihan. Output akan terlihat serupa dengan yang berikut ini:
```
NOTICE: restoring database 'app', 6% of 7483 MB complete
NOTICE: restoring database 'app', 42% of 7483 MB complete
NOTICE: restoring database 'app', 77% of 7483 MB complete
NOTICE: restoring database 'app', 98% of 7483 MB complete
NOTICE: successfully restored database 'app' from node node1-app in 00:04:12.274956
pgactive_wait_for_node_ready
------------------------------
(1 row)
```
Dari titik ini ke depan, `pgactive` menyinkronkan data antara dua instans DB.
1. Anda dapat menggunakan perintah berikut untuk memverifikasi apakah basis data instans DB kedua memiliki data:
```
app=> SELECT count(*) FROM inventory.products;
```
Jika data berhasil disinkronkan, Anda akan melihat output sebagai berikut:
```
count
-------
3
```
1. Jalankan perintah berikut ini untuk memasukkan nilai baru:
```
app=> INSERT INTO inventory.products (id, product_name) VALUES (4, 'lotion');
```
1. Hubungkan ke basis data instans DB pertama dan jalankan kueri berikut:
```
app=> SELECT count(*) FROM inventory.products;
```
Jika replikasi aktif-aktif diinisialisasi, output serupa dengan berikut ini:
```
count
-------
4
```
**Melepas dan menghapus instans DB dari grup `pgactive`**
Anda dapat melepas dan menghapus instans DB dari grup `pgactive` menggunakan langkah-langkah berikut:
1. Anda dapat melepas instans DB kedua dari instans DB pertama menggunakan perintah berikut:
```
app=> SELECT * FROM pgactive.pgactive_detach_nodes(ARRAY[‘node2-app']);
```
1. Menghapus ekstensi `pgactive` dari instans DB kedua menggunakan perintah berikut:
```
app=> SELECT * FROM pgactive.pgactive_remove();
```
Untuk menghapus ekstensi secara paksa:
```
app=> SELECT * FROM pgactive.pgactive_remove(true);
```
1. Hapus sementara ekstensi menggunakan perintah berikut ini:
```
app=> DROP EXTENSION pgactive;
```
# Mengukur lag replikasi di antara anggota pgactive
Anda dapat menggunakan kueri berikut untuk melihat lag replikasi di antara `pgactive` anggota. Jalankan kueri ini di setiap `pgactive` node untuk mendapatkan gambaran lengkap.
```
app=> SELECT * FROM pgactive.pgactive_get_replication_lag_info();
│-[ RECORD 1 ]--------+---------------------------------------------
│node_name | node2-app
│node_sysid | 7481018224801653637
│application_name | pgactive:7481018224801653637:send
│slot_name | pgactive_16385_7481018224801653637_0_16385__
│active | t
│active_pid | 783486
│pending_wal_decoding | 0
│pending_wal_to_apply | 0
│restart_lsn | 0/2108150
│confirmed_flush_lsn | 0/2154690
│sent_lsn | 0/2154690
│write_lsn | 0/2154690
│flush_lsn | 0/2154690
│replay_lsn | 0/2154690
│-[ RECORD 2 ]--------+---------------------------------------------
│node_name | node1-app
│node_sysid | 7481018033434600853
│application_name | pgactive:7481018033434600853:send
│slot_name | pgactive_16385_7481018033434600853_0_16385__
│active | t
│active_pid | 783488
│pending_wal_decoding | 0
│pending_wal_to_apply | 0
│restart_lsn | 0/20F5AD0
│confirmed_flush_lsn | 0/214EF68
│sent_lsn | 0/214EF68
│write_lsn | 0/214EF68
│flush_lsn | 0/214EF68
│replay_lsn | 0/214EF68
```
Pantau diagnostik berikut minimal:
aktif
Siapkan peringatan saat aktif salah, yang menunjukkan bahwa slot saat ini tidak digunakan (instance pelanggan telah terputus dari penerbit).
pending\$1wal\$1decoding
Dalam replikasi logis PostgreSQL, file WAL disimpan dalam format biner. Penerbit harus memecahkan kode perubahan WAL ini dan mengubahnya menjadi perubahan logis (seperti menyisipkan, memperbarui, atau menghapus operasi).
Metrik pending\$1wal\$1decoding menunjukkan jumlah file WAL yang menunggu untuk didekodekan di sisi penerbit.
Jumlah ini dapat meningkat karena faktor-faktor ini:
+ Ketika pelanggan tidak terhubung, status aktif akan salah dan pending\$1wal\$1decoding akan meningkat
+ Slot aktif, tetapi penerbit tidak dapat mengikuti volume perubahan WAL
pending\$1wal\$1to\$1apply
Metrik pending\$1wal\$1apply menunjukkan jumlah file WAL yang menunggu untuk diterapkan di sisi pelanggan.
Beberapa faktor dapat mencegah pelanggan menerapkan perubahan dan berpotensi menyebabkan skenario penuh disk:
+ Perbedaan skema - misalnya, ketika Anda memiliki perubahan dalam aliran WAL untuk tabel bernama sampel, tetapi tabel itu tidak ada di sisi pelanggan
+ Nilai di kolom kunci primer diperbarui
+ Indeks unik sekunder dapat menyebabkan divergensi data
# Mengkonfigurasi pengaturan parameter untuk ekstensi pgactive
Anda dapat menggunakan kueri berikut untuk melihat semua parameter yang terkait dengan ekstensi `pgactive`.
```
app=> SELECT * FROM pg_settings WHERE name LIKE 'pgactive.%';
```
Anda dapat mengkonfigurasi `pgactive` ekstensi menggunakan berbagai parameter. Parameter ini dapat diatur melalui antarmuka Konsol Manajemen AWS atau AWS CLI.
## Parameter ekstensi pgactive utama
Tabel berikut memberikan referensi untuk parameter utama `pgactive` ekstensi:
| Parameter | Unit | Default | Deskripsi |
| --- | --- | --- | --- |
| pgactive.conflict\$1logging\$1include\$1tuples | `boolean` | – | Log informasi Tuple lengkap untuk `pgactive` ekstensi. Restart server diperlukan agar perubahan diterapkan. |
| pgactive.log\$1conflicts\$1to\$1table | `boolean` | – | Menentukan apakah `pgactive` ekstensi mencatat konflik yang terdeteksi ke `pgactive.pgactive_conflict_history` tabel. Untuk informasi selengkapnya, lihat Pencatatan konflik untuk detailnya. Restart server diperlukan agar perubahan diterapkan. |
| pgactive.log\$1conflicts\$1to\$1logfile | `boolean` | – | Menentukan apakah `pgactive` ekstensi mencatat konflik yang terdeteksi ke file log PostgreSQL. Untuk informasi selengkapnya, lihat Pencatatan konflik untuk detailnya. Restart server diperlukan agar perubahan diterapkan. |
| pgactive.synchronous\$1commit | `boolean` | off | Menentukan perilaku komit untuk pekerja terapan pgactive. Saat dinonaktifkan (tidak aktif), pekerja terapkan melakukan komit asinkron, yang meningkatkan throughput PostgreSQL selama operasi penerapan tetapi menunda konfirmasi pemutaran ulang ke hulu. Mengaturnya `off` selalu aman dan tidak akan menyebabkan kerugian transaksi atau lompatan. Pengaturan ini hanya memengaruhi waktu pembilasan disk pada node hilir dan saat konfirmasi dikirim ke hulu. Sistem menunda pengiriman konfirmasi pemutaran ulang hingga komit dibuang ke disk melalui operasi yang tidak terkait seperti pos pemeriksaan atau pekerjaan berkala. Namun, jika bagian hulu memiliki hilir yang terdaftar`synchronous_standby_names`, menyetelnya untuk `off` menyebabkan komit sinkron di hulu membutuhkan waktu lebih lama untuk melaporkan keberhasilan kepada klien. Dalam hal ini, atur parameter ke`on`. Bahkan ketika parameter ini disetel ke `on` dengan node yang terdaftar di`synchronous_standby_names`, konflik replikasi masih dapat terjadi dalam konfigurasi aktif-aktif. Ini karena sistem tidak memiliki penguncian antar simpul dan manajemen snapshot global, memungkinkan transaksi bersamaan pada node yang berbeda untuk memodifikasi tuple yang sama. Selain itu, transaksi hanya memulai replikasi setelah melakukan pada node hulu. Mengaktifkan komit sinkron tidak mengubah ekstensi pgactive menjadi sistem yang selalu konsisten. |
| pgactive.temp\$1dump\$1directory | `string` | – | Mendefinisikan jalur penyimpanan sementara yang diperlukan untuk operasi kloning database selama penyiapan awal. Direktori ini harus dapat ditulis oleh pengguna postgres dan memiliki ruang penyimpanan yang cukup untuk berisi dump database lengkap. Sistem menggunakan lokasi ini hanya selama pengaturan database awal dengan operasi salinan logis. Parameter ini tidak digunakan oleh file`pgactive_init_copy command`. |
| pgactive.max\$1ddl\$1lock\$1delay | `milliseconds` | `-1` | Menentukan waktu tunggu maksimum untuk kunci DDL sebelum secara paksa membatalkan transaksi tulis bersamaan. Nilai defaultnya adalah`-1`, yang mengadopsi nilai yang ditetapkan. `max_standby_streaming_delay` Parameter ini menerima satuan waktu. Misalnya, Anda dapat mengaturnya ke 10 detik selama 10 detik. Selama periode tunggu ini, sistem mencoba untuk memperoleh kunci DDL sambil menunggu transaksi tulis yang sedang berlangsung untuk melakukan atau memutar kembali. Untuk informasi lebih lanjut, lihat Penguncian DDL. |
| pgactive.ddl\$1lock\$1timeout | `milliseconds` | `-1` | Menentukan berapa lama upaya kunci DDL menunggu untuk mendapatkan kunci. Nilai default adalah`-1`, yang menggunakan nilai yang ditentukan dalam lock\$1timeout. Anda dapat mengatur parameter ini menggunakan satuan waktu seperti 10 detik selama 10 detik. Timer ini hanya mengontrol masa tunggu untuk mendapatkan kunci DDL. Setelah sistem mendapatkan kunci dan memulai operasi DDL, timer berhenti. Parameter ini tidak membatasi durasi total kunci DDL dapat ditahan atau waktu operasi DDL keseluruhan. Untuk mengontrol total durasi operasi, gunakan `statement_timeout` sebagai gantinya. Untuk informasi lebih lanjut, lihat Penguncian DDL. |
| pgactive.debug\$1trace\$1ddl\$1locks\$1level | `boolean` | – | Mengganti level log debug default untuk operasi penguncian DDL di ekstensi. `pgactive` Saat dikonfigurasi, pengaturan ini menyebabkan pesan terkait penguncian DDL dipancarkan pada tingkat debug LOG, bukan tingkat defaultnya. Gunakan parameter ini untuk memantau aktivitas penguncian DDL tanpa mengaktifkan tingkat verbose `DEBUG1` atau `DEBUG2` log di seluruh server Anda. Level log yang tersedia, dalam urutan verbositas yang meningkat: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.pgactive.parameters.html) Untuk informasi selengkapnya tentang opsi pemantauan, lihat Memantau kunci DDL global. Perubahan pada setelan ini berlaku saat Anda memuat ulang konfigurasi. Anda tidak perlu me-restart server. |
## Parameter ekstensi pgactive tambahan
Tabel berikut menyajikan opsi konfigurasi internal yang lebih jarang digunakan dan tersedia untuk `pgactive` ekstensi.
| Parameter | Unit | Default | Deskripsi |
| --- | --- | --- | --- |
| pgactive.debug\$1apply\$1delay | `integer` | – | Menetapkan penundaan penerapan (dalam milidetik) untuk koneksi yang dikonfigurasi yang tidak memiliki penundaan penerapan eksplisit dalam entri mereka`pgactive.pgactive_connections`. Penundaan ini diatur selama pembuatan node atau waktu bergabung, dan pgactive tidak akan memutar ulang transaksi pada node rekan sampai setidaknya jumlah milidetik yang ditentukan telah berlalu sejak dilakukan. Terutama digunakan untuk mensimulasikan jaringan latensi tinggi di lingkungan pengujian untuk membuatnya lebih mudah untuk menciptakan konflik. Misalnya, dengan penundaan 500 ms pada node A dan B, Anda memiliki setidaknya 500 ms untuk melakukan penyisipan yang bertentangan pada node B setelah memasukkan nilai pada node A. Memerlukan server memuat ulang atau memulai ulang pekerja terapan agar berlaku. |
| pgactive.connectability\$1check\$1duration | `integer` | – | Menentukan durasi (dalam detik) bahwa pekerja database mencoba untuk membuat koneksi selama upaya gagal. Pekerja membuat satu upaya koneksi per detik hingga berhasil atau mencapai nilai batas waktu ini. Pengaturan ini berguna ketika mesin database dimulai sebelum pekerja siap untuk membuat koneksi. |
| pgactive.skip\$1ddl\$1replication | `boolean` | `on` | Mengontrol bagaimana perubahan DDL direplikasi atau ditangani di Amazon RDS dengan diaktifkan. `pgactive` Ketika diatur ke`on`, node memproses perubahan DDL seperti node non-pgcctive. Persyaratan berikut berlaku saat bekerja dengan parameter ini: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.pgactive.parameters.html) Anda dapat memodifikasi parameter ini dengan dua cara dengan hak istimewa pengguna super: secara global, lokal (tingkat sesi). Mengubah parameter ini secara tidak benar dapat merusak pengaturan replikasi Anda. |
| pgactive.do\$1not\$1replicate | `boolean` | – | Parameter ini hanya untuk penggunaan internal. Ketika Anda mengatur parameter ini dalam transaksi, perubahan tidak direplikasi ke node lain di cluster DB Anda. Mengubah parameter ini secara tidak benar dapat merusak pengaturan replikasi Anda. |
| pgactive.discard\$1mismatched\$1row\$1attributes | `boolean` | – | Parameter ini ditujukan hanya untuk penggunaan spesialis. Sebaiknya gunakan parameter ini hanya saat memecahkan masalah replikasi tertentu. Gunakan parameter ini ketika: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.pgactive.parameters.html) Pengaturan ini mengesampingkan pesan kesalahan berikut dan memungkinkan divergensi data muncul agar replikasi berlanjut: `cannot right-pad mismatched attributes; attno %u is missing in local table and remote row has non-null, non-dropped value for this attribute` Mengubah parameter ini secara tidak benar dapat merusak pengaturan replikasi Anda. |
| pgactive.debug\$1trace\$1replay | `boolean` | – | Ketika diatur ke`on`, itu memancarkan pesan log untuk setiap tindakan jarak jauh yang menerapkan proses pekerja di hilir. Log meliputi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.pgactive.parameters.html) Log juga menangkap perintah DDL yang diantrian dan tetesan tabel.para> Secara default, log tidak menyertakan isi bidang baris. Untuk menyertakan nilai baris dalam log, Anda harus mengkompilasi ulang dengan flag berikut diaktifkan: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.pgactive.parameters.html) Mengaktifkan pengaturan logging ini dapat memengaruhi kinerja. Kami menyarankan untuk mengaktifkannya hanya bila diperlukan untuk pemecahan masalah. Perubahan pada pengaturan ini berlaku saat Anda memuat ulang konfigurasi. Anda tidak perlu me-restart server. |
| pgactive.extra\$1apply\$1connection\$1options | | – | Anda dapat mengonfigurasi parameter koneksi untuk semua koneksi node peer dengan node pgactive. Parameter ini mengontrol pengaturan seperti keepalives dan mode SSL. Secara default, pgactive menggunakan parameter koneksi berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.pgactive.parameters.html) Untuk mengganti parameter default, gunakan perintah serupa berikut: pgactive.extra\$1apply\$1connection\$1options = 'keepalives=0' String koneksi node individual lebih diutamakan daripada pengaturan ini dan opsi koneksi bawaan pgactive. Untuk informasi selengkapnya tentang format string koneksi, lihat string koneksi [libpq](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING). Sebaiknya tetap mengaktifkan pengaturan keepalive default. Hanya nonaktifkan keepalives jika Anda mengalami masalah dengan transaksi besar yang diselesaikan melalui jaringan yang tidak dapat diandalkan. Sebaiknya tetap mengaktifkan pengaturan keepalive default. Hanya nonaktifkan keepalives jika Anda mengalami masalah dengan transaksi besar yang diselesaikan melalui jaringan yang tidak dapat diandalkan. Perubahan pada pengaturan ini berlaku saat Anda memuat ulang konfigurasi. Anda tidak perlu me-restart server. |
| pgactive.init\$1node\$1parallel\$1jobs (int) | | – | Menentukan jumlah pekerjaan paralel yang `pg_dump` dan `pg_restore` dapat digunakan selama node logis bergabung dengan fungsi. `pgactive.pgactive_join_group` Perubahan pada pengaturan ini berlaku saat Anda memuat ulang konfigurasi. Anda tidak perlu me-restart server. |
| pgactive.max\$1nodes | `int` | 4 | Menentukan jumlah maksimum node yang diizinkan dalam grup ekstensi pgactive. Nilai defaultnya adalah 4 node. Anda harus mempertimbangkan hal berikut saat mengatur nilai parameter ini: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/UserGuide/Appendix.PostgreSQL.CommonDBATasks.pgactive.parameters.html) Anda dapat mengatur parameter ini dengan dua cara: dalam file konfigurasi, menggunakan `ALTER SYSTEM SET` perintah Nilai default untuk parameter ini adalah`4`, artinya, bisa ada maksimal 4 node yang diizinkan dalam grup `pgactive` ekstensi pada setiap titik waktu. Perubahan berlaku setelah Anda me-restart server. |
| pgactive.permit\$1node\$1identifier\$1getter\$1function\$1creation | `boolean` | – | Parameter ini ditujukan untuk penggunaan internal saja. Saat diaktifkan, `pgactive` ekstensi memungkinkan pembuatan fungsi pengenal node pgactive. |
# Memahami konflik aktif-aktif
Saat Anda menggunakan pgactive dalam mode aktif-aktif, menulis ke tabel yang sama dari beberapa node dapat membuat konflik data. Sementara beberapa sistem pengelompokan menggunakan kunci terdistribusi untuk mencegah akses bersamaan, pgactive mengambil pendekatan optimis yang lebih cocok untuk aplikasi yang didistribusikan secara geografis.
Beberapa sistem pengelompokan database mencegah akses data bersamaan dengan menggunakan kunci terdistribusi. Meskipun pendekatan ini bekerja ketika server berada dalam jarak dekat, itu tidak mendukung aplikasi yang didistribusikan secara geografis karena memerlukan latensi yang sangat rendah untuk kinerja yang baik. Alih-alih menggunakan kunci terdistribusi (pendekatan pesimis), ekstensi pgactive menggunakan pendekatan optimis. Ini berarti:
+ Membantu Anda menghindari konflik jika memungkinkan.
+ Memungkinkan jenis konflik tertentu terjadi.
+ Memberikan resolusi konflik ketika konflik terjadi.
Pendekatan ini memberi Anda lebih banyak fleksibilitas saat membangun aplikasi terdistribusi.
## Bagaimana konflik terjadi
Konflik antar node muncul dari urutan peristiwa yang tidak dapat terjadi jika semua transaksi yang terlibat terjadi secara bersamaan pada node yang sama. Karena node hanya bertukar perubahan setelah transaksi dilakukan, setiap transaksi valid secara individual pada node yang dilakukannya tetapi tidak akan valid jika dijalankan pada node lain yang telah melakukan pekerjaan lain sementara itu. Karena pgactive apply pada dasarnya memutar ulang transaksi pada node lain, operasi replay dapat gagal jika ada konflik antara transaksi yang diterapkan dan transaksi yang dilakukan pada node penerima.
Alasan sebagian besar konflik tidak dapat terjadi ketika semua transaksi berjalan pada satu node adalah karena PostgreSQL memiliki mekanisme komunikasi antar-transaksi untuk mencegahnya, termasuk:
+ Indeks UNIK
+ SEQUENCEs
+ Penguncian baris dan relasi
+ Pelacakan ketergantungan SERIALIZABLE
Semua mekanisme ini adalah cara untuk berkomunikasi antar transaksi untuk mencegah masalah konkurensi yang tidak diinginkan
pgactive mencapai latensi rendah dan menangani partisi jaringan dengan baik karena tidak menggunakan manajer transaksi terdistribusi atau pengelola kunci. Namun, ini berarti transaksi pada node yang berbeda berjalan dalam isolasi lengkap satu sama lain. Sementara isolasi biasanya meningkatkan konsistensi database, dalam hal ini, Anda perlu mengurangi isolasi untuk mencegah konflik.
## Jenis konflik
Konflik yang dapat terjadi meliputi:
**Topics**
+ [
### KUNCI PRIMER atau konflik UNIK
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict1)
+ [
### Konflik INSERT/INSERT
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict2)
+ [
### INSERTs yang melanggar beberapa kendala UNIK
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict3)
+ [
### Konflik PEMBARUIAN/PEMBARUAN
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict4)
+ [
### PERBARUI konflik pada KUNCI PRIMARY
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict5)
+ [
### UPDATEs yang melanggar beberapa kendala UNIK
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict6)
+ [
### PERBARUI/HAPUS konflik
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict7)
+ [
### Konflik INSERT/UPDATE
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict8)
+ [
### HAPUS/HAPUS konflik
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict9)
+ [
### Konflik Kendala Kunci Asing
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict10)
+ [
### Konflik kendala pengecualian
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict11)
+ [
### Konflik data global
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict12)
+ [
### Mengunci konflik dan kebuntuan dibatalkan
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict13)
+ [
### Konflik yang berbeda
](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict14)
### KUNCI PRIMER atau konflik UNIK
Konflik baris terjadi ketika beberapa operasi mencoba memodifikasi kunci baris yang sama dengan cara yang tidak mungkin dilakukan pada satu node. Konflik ini mewakili jenis konflik data yang paling umum.
pgactive menyelesaikan konflik yang terdeteksi melalui last-update-wins penanganan atau penangan konflik kustom Anda.
Konflik baris meliputi:
+ SISIPKAN vs SISIPKAN
+ SISIPKAN vs PEMBARUAN
+ PEMBARUAN vs HAPUS
+ SISIPKAN vs HAPUS
+ HAPUS vs HAPUS
+ SISIPKAN vs HAPUS
### Konflik INSERT/INSERT
Konflik yang paling umum ini terjadi ketika INSERTs pada dua node yang berbeda membuat tupel dengan nilai KUNCI PRIMARY yang sama (atau nilai kendala UNIK identik ketika tidak ada KUNCI PRIMARY).
pgactivelink menyelesaikan konflik INSERT dengan menggunakan stempel waktu dari host asal untuk mempertahankan tupel terbaru. Anda dapat mengganti perilaku default ini dengan penangan konflik kustom Anda. Meskipun proses ini tidak memerlukan tindakan administrator khusus, ketahuilah bahwa pgactivelink membuang salah satu operasi INSERT di semua node. Tidak ada penggabungan data otomatis yang terjadi kecuali handler kustom Anda mengimplementasikannya.
Pgactivelink hanya dapat menyelesaikan konflik yang melibatkan pelanggaran kendala tunggal. Jika INSERT melanggar beberapa kendala UNIK, Anda harus menerapkan strategi penyelesaian konflik tambahan.
### INSERTs yang melanggar beberapa kendala UNIK
INSERT/INSERT Konflik dapat melanggar beberapa kendala UNIK, termasuk KUNCI PRIMAR. pgactivelink hanya dapat menangani konflik yang melibatkan satu kendala UNIK. Ketika konflik melanggar beberapa kendala UNIK, pekerja penerapan gagal dan mengembalikan kesalahan berikut:
`multiple unique constraints violated by remotely INSERTed tuple.`
Dalam versi yang lebih lama, situasi ini menghasilkan kesalahan 'konflik keunikan yang menyimpang' sebagai gantinya.
Untuk mengatasi konflik ini, Anda harus mengambil tindakan manual. Baik HAPUS tupel lokal yang bertentangan atau PERBARUI untuk menghapus konflik dengan tupel jarak jauh yang baru. Ketahuilah bahwa Anda mungkin perlu mengatasi beberapa tupel yang saling bertentangan. Saat ini, pgactivelink tidak menyediakan fungsionalitas bawaan untuk mengabaikan, membuang, atau menggabungkan tupel yang melanggar beberapa kendala unik.
**catatan**
Untuk informasi selengkapnya, lihat UPDATEs bahwa melanggar beberapa kendala UNIK.
### Konflik PEMBARUIAN/PEMBARUAN
Konflik ini terjadi ketika dua node secara bersamaan memodifikasi Tuple yang sama tanpa mengubah KUNCI PRIMAR-nya. pgactivelink menyelesaikan konflik ini menggunakan last-update-wins logika atau penangan konflik kustom Anda, jika ditentukan. KUNCI UTAMA sangat penting untuk pencocokan tupel dan resolusi konflik. Untuk tabel tanpa KUNCI UTAMA, pgactivelink menolak operasi UPDATE dengan kesalahan berikut:
`Cannot run UPDATE or DELETE on table (tablename) because it does not have a primary key.`
### PERBARUI konflik pada KUNCI PRIMARY
pgactive memiliki batasan saat menangani pembaruan PRIMARY KEY. Meskipun Anda dapat melakukan operasi UPDATE pada KUNCI UTAMA, pgactive tidak dapat secara otomatis menyelesaikan konflik menggunakan last-update-wins logika untuk operasi ini. Anda harus memastikan bahwa pembaruan PRIMARY KEY Anda tidak bertentangan dengan nilai yang ada. Jika konflik terjadi selama pembaruan PRIMARY KEY, konflik tersebut menjadi konflik yang berbeda yang memerlukan intervensi manual Anda. Untuk informasi selengkapnya tentang penanganan situasi ini, lihat[Konflik yang berbeda](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict14).
### UPDATEs yang melanggar beberapa kendala UNIK
pgactivelink tidak dapat menerapkan resolusi last-update-wins konflik ketika UPDATE yang masuk melanggar beberapa batasan UNIK atau nilai KUNCI UTAMA. Perilaku ini mirip dengan operasi INSERT dengan beberapa pelanggaran kendala. Situasi ini menciptakan konflik yang berbeda yang memerlukan intervensi manual Anda. Untuk informasi selengkapnya, lihat [Konflik yang berbeda](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict14).
### PERBARUI/HAPUS konflik
Konflik ini terjadi ketika UPDATEs satu node baris sementara node lain DELETEs secara bersamaan. Dalam hal ini terjadi UPDATE/DELETE konflik pada pemutaran ulang. Resolusinya adalah membuang PEMBARUAN apa pun yang tiba setelah DELETE, kecuali penangan konflik kustom Anda menentukan sebaliknya.
pgactivelink membutuhkan KUNCI UTAMA untuk mencocokkan tupel dan menyelesaikan konflik. Untuk tabel tanpa KUNCI PRIMARY, ia menolak operasi DELETE dengan kesalahan berikut:
`Cannot run UPDATE or DELETE on table (tablename) because it does not have a primary key.`
**catatan**
pgactivelink tidak dapat membedakan antara dan konflik. UPDATE/DELETE INSERT/UPDATE Dalam kedua kasus, UPDATE mempengaruhi baris yang tidak ada. Karena replikasi asinkron dan kurangnya urutan pemutaran ulang antar node, pgactivelink tidak dapat menentukan apakah PEMBARUAN adalah untuk baris baru (INSERT belum diterima) atau baris yang dihapus. Dalam kedua skenario, pgactivelink membuang UPDATE.
### Konflik INSERT/UPDATE
Konflik ini dapat terjadi di lingkungan multi-node. Itu terjadi ketika INSERTs satu node baris, node kedua UPDATEs itu, dan node ketiga menerima UPDATE sebelum INSERT asli. Secara default, pgactivelink menyelesaikan konflik ini dengan membuang UPDATE, kecuali pemicu konflik kustom Anda menentukan sebaliknya. Ketahuilah bahwa metode resolusi ini dapat mengakibatkan inkonsistensi data di seluruh node. Untuk informasi selengkapnya tentang skenario serupa dan penanganannya, lihat[PERBARUI/HAPUS konflik](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict7).
### HAPUS/HAPUS konflik
Konflik ini terjadi ketika dua node berbeda secara bersamaan menghapus tuple yang sama. pgactivelink menganggap konflik ini tidak berbahaya karena kedua operasi DELETE memiliki hasil akhir yang sama. Dalam skenario ini, pgactivelink dengan aman mengabaikan salah satu operasi DELETE tanpa mempengaruhi konsistensi data.
### Konflik Kendala Kunci Asing
Kendala KUNCI ASING dapat menyebabkan konflik saat menerapkan transaksi jarak jauh ke data lokal yang ada. Konflik ini biasanya terjadi ketika transaksi diterapkan dalam urutan yang berbeda dari urutan logisnya pada node asal.
Secara default, pgactive menerapkan perubahan dengan session\$1replication\$1role as`replica`, yang melewati pemeriksaan kunci asing selama replikasi. Dalam konfigurasi aktif-aktif, ini dapat menyebabkan pelanggaran kunci asing. Sebagian besar pelanggaran bersifat sementara dan diselesaikan setelah replikasi menyusul. Namun, kunci asing yang menggantung dapat terjadi karena pgactive tidak mendukung penguncian baris lintas-simpul.
Perilaku ini melekat pada sistem aktif-aktif asinkron yang toleran partisi. Misalnya, node A mungkin menyisipkan baris anak baru sementara node B secara bersamaan menghapus baris induknya. Sistem tidak dapat mencegah jenis modifikasi bersamaan di seluruh node.
Untuk meminimalkan konflik kunci asing, kami merekomendasikan hal berikut:
+ Batasi hubungan kunci asing ke entitas yang terkait erat.
+ Ubah entitas terkait dari satu node bila memungkinkan.
+ Pilih entitas yang jarang membutuhkan modifikasi.
+ Menerapkan kontrol konkurensi tingkat aplikasi untuk modifikasi.
### Konflik kendala pengecualian
tautan pgactive tidak mendukung batasan pengecualian dan membatasi pembuatannya.
**catatan**
Jika Anda mengonversi database mandiri yang ada ke database pgactivelink, jatuhkan semua batasan pengecualian secara manual.
Dalam sistem asinkron terdistribusi, tidak mungkin untuk menjamin bahwa tidak ada kumpulan baris yang melanggar batasan. Ini karena semua transaksi pada node yang berbeda sepenuhnya terisolasi. Kendala pengecualian dapat menyebabkan kebuntuan pemutaran ulang, di mana pemutaran ulang tidak dapat berkembang dari node mana pun ke node lain karena pelanggaran batasan pengecualian.
Jika Anda memaksa pgactive Link untuk membuat batasan pengecualian, atau jika Anda tidak menghapus yang sudah ada saat mengonversi database mandiri menjadi pgactive Link, replikasi kemungkinan akan rusak. Untuk mengembalikan kemajuan replikasi, hapus atau ubah tupel lokal yang bertentangan dengan tupel jarak jauh yang masuk sehingga transaksi jarak jauh dapat diterapkan.
### Konflik data global
Saat menggunakan pgactivelink, konflik dapat terjadi ketika node memiliki data seluruh sistem PostgreSQL global yang berbeda, seperti peran. Konflik ini dapat menyebabkan operasi—terutama DDL—berhasil dan berkomitmen pada satu node tetapi gagal diterapkan ke node lain.
Jika pengguna ada di satu node tetapi tidak yang lain, masalah replikasi dapat terjadi:
+ Node1 memiliki nama pengguna`fred`, tetapi pengguna ini tidak ada di Node2
+ Saat `fred` membuat tabel di Node1, tabel direplikasi dengan `fred` sebagai pemilik
+ Ketika perintah DDL ini diterapkan ke Node2, itu gagal karena pengguna `fred` tidak ada
+ Kegagalan ini menghasilkan ERROR di log PostgreSQL di Node2 dan menambah penghitung `pgactive.pgactive_stats.nr_rollbacks`
**Resolusi:** Buat pengguna `fred` di Node2. Pengguna tidak memerlukan izin yang identik tetapi harus ada di kedua node.
Jika tabel ada pada satu node tetapi tidak yang lain, operasi modifikasi data akan gagal:
+ Node1 memiliki tabel bernama `foo` yang tidak ada di Node2
+ Setiap operasi DHTML pada `foo` tabel pada Node1 akan gagal ketika direplikasi ke Node2
**Resolusi:** Buat tabel `foo` di Node2 dengan struktur yang sama.
**catatan**
pgactivelink saat ini tidak mereplikasi perintah CREATE USER atau operasi DDL. Replikasi DDL direncanakan untuk rilis future.
### Mengunci konflik dan kebuntuan dibatalkan
Karena proses penerapan pgactive beroperasi seperti sesi pengguna normal, mereka mengikuti aturan penguncian baris dan tabel standar. Hal ini dapat mengakibatkan pgactivelink menerapkan proses menunggu pada kunci yang dipegang oleh transaksi pengguna atau oleh proses penerapan lainnya.
Jenis kunci berikut dapat memengaruhi proses penerapan:
+ Penguncian tingkat tabel eksplisit (LOCK TABLE...) oleh sesi pengguna
+ Penguncian tingkat baris eksplisit (PILIH... UNTUK UPDATE/FOR BERBAGI) oleh sesi pengguna
+ Mengunci dari kunci asing
+ Penguncian implisit karena baris UPDATEs, INSERTs, atau DELETEs, baik dari aktivitas lokal atau berlaku dari server lain
Kebuntuan dapat terjadi antara:
+ Proses penerapan pgactivelink dan transaksi pengguna
+ Dua menerapkan proses
Ketika kebuntuan terjadi, detektor kebuntuan PostgreSQL mengakhiri salah satu transaksi masalah. Jika proses pgactivelink apply worker dihentikan, proses tersebut secara otomatis mencoba ulang dan biasanya berhasil.
**catatan**
Masalah ini bersifat sementara dan umumnya tidak memerlukan intervensi administrator. Jika proses penerapan diblokir untuk jangka waktu yang lama dengan mengunci sesi pengguna yang tidak aktif, Anda dapat menghentikan sesi pengguna untuk melanjutkan replikasi. Situasi ini mirip dengan ketika pengguna memegang kunci panjang yang memengaruhi sesi pengguna lain.
Untuk mengidentifikasi penundaan pemutaran ulang terkait penguncian, aktifkan fasilitas `log_lock_waits` di PostgreSQL.
### Konflik yang berbeda
Konflik divergen terjadi ketika data yang seharusnya identik di seluruh node berbeda secara tak terduga. Meskipun konflik ini seharusnya tidak terjadi, tidak semua dapat dicegah dengan andal dalam implementasi saat ini.
**catatan**
Memodifikasi KUNCI UTAMA baris dapat menyebabkan konflik yang berbeda jika node lain mengubah kunci baris yang sama sebelum semua node memproses perubahan. Hindari mengubah kunci utama, atau membatasi perubahan pada satu node yang ditunjuk. Untuk informasi selengkapnya, lihat [PERBARUI konflik pada KUNCI PRIMARY](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflict5).
Konflik divergen yang melibatkan data baris biasanya memerlukan intervensi administrator. Untuk mengatasi konflik ini, Anda harus menyesuaikan data secara manual pada satu node agar sesuai dengan yang lain sambil menonaktifkan replikasi sementara menggunakan. `pgactive.pgactive_do_not_replicate` Konflik ini seharusnya tidak terjadi ketika Anda menggunakan pgactive seperti yang didokumentasikan dan menghindari pengaturan atau fungsi yang ditandai sebagai tidak aman.
Sebagai administrator, Anda harus menyelesaikan konflik ini secara manual. Bergantung pada jenis konflik, Anda harus menggunakan opsi lanjutan seperti`pgactive.pgactive_do_not_replicate`. Gunakan opsi ini dengan hati-hati, karena penggunaan yang tidak tepat dapat memperburuk situasi. Karena berbagai kemungkinan konflik, kami tidak dapat memberikan instruksi resolusi universal.
Konflik divergen terjadi ketika data yang seharusnya identik di seluruh node yang berbeda secara tak terduga berbeda. Meskipun konflik ini seharusnya tidak terjadi, tidak semua konflik semacam itu dapat dicegah dengan andal dalam implementasi saat ini.
## Menghindari atau mentolerir konflik
Dalam kebanyakan kasus, Anda dapat menggunakan desain aplikasi yang sesuai untuk menghindari konflik atau membuat aplikasi Anda toleran terhadap konflik.
Konflik hanya terjadi ketika operasi simultan terjadi pada beberapa node. Untuk menghindari konflik:
+ Menulis hanya ke satu simpul
+ Menulis ke subset database independen pada setiap node (misalnya, menetapkan setiap node skema terpisah)
Untuk konflik INSERT vs INSERT, gunakan urutan Global untuk mencegah konflik sepenuhnya.
Jika konflik tidak dapat diterima untuk kasus penggunaan Anda, pertimbangkan untuk menerapkan penguncian terdistribusi di tingkat aplikasi. Seringkali, pendekatan terbaik adalah merancang aplikasi Anda untuk bekerja dengan mekanisme resolusi konflik pgactive daripada mencoba mencegah semua konflik. Untuk informasi selengkapnya, lihat [Jenis konflik](#Appendix.PostgreSQL.CommonDBATasks.pgactive.actact.conflicttypes).
## Penebangan konflik
pgactivelink mencatat insiden konflik dalam `pgactive.pgactive_conflict_history` tabel untuk membantu Anda mendiagnosis dan menangani konflik aktif-aktif. Pencatatan konflik ke tabel ini hanya terjadi ketika Anda menyetel `pgactive.log_conflicts_to_table` ke true. Ekstensi pgactive juga mencatat konflik ke file log PostgreSQL saat log\$1min\$1messages disetel ke atau, terlepas dari pengaturannya. `LOG` `lower` `pgactive.log_conflicts_to_table`
Gunakan tabel riwayat konflik untuk:
+ Ukur seberapa sering aplikasi Anda membuat konflik
+ Identifikasi di mana konflik terjadi
+ Tingkatkan aplikasi Anda untuk mengurangi tingkat konflik
+ Mendeteksi kasus di mana resolusi konflik tidak menghasilkan hasil yang diinginkan
+ Tentukan di mana Anda memerlukan pemicu konflik yang ditentukan pengguna atau perubahan desain aplikasi
Untuk konflik baris, Anda dapat mencatat nilai baris secara opsional. Ini dikendalikan oleh `pgactive.log_conflicts_to_table` pengaturan. Perhatikan bahwa:
+ Ini adalah opsi seluruh basis data global
+ Tidak ada kontrol per tabel atas pencatatan nilai baris
+ Tidak ada batasan yang diterapkan pada nomor bidang, elemen array, atau panjang bidang
+ Mengaktifkan fitur ini mungkin tidak disarankan jika Anda bekerja dengan baris multi-megabyte yang dapat memicu konflik
Karena tabel riwayat konflik berisi data dari setiap tabel dalam database (masing-masing dengan skema yang berpotensi berbeda), nilai baris yang dicatat disimpan sebagai bidang JSON. JSON dibuat menggunakan`row_to_json`, mirip dengan memanggilnya langsung dari SQL. PostgreSQL tidak menyediakan `json_to_row` fungsi, jadi Anda memerlukan kode khusus tabel (PL/pgSQL, PL/Python, PL/Perlin, dll.) untuk merekonstruksi tupel yang diketik komposit dari JSON yang dicatat.
**catatan**
Support untuk konflik yang ditentukan pengguna direncanakan sebagai fitur ekstensi future.
# Memahami skema pgactive
Skema pgactive mengelola replikasi aktif-aktif dalam RDS untuk PostgreSQL. Skema ini berisi tabel yang menyimpan konfigurasi replikasi dan informasi status.
**catatan**
Skema pgactive berkembang dan dapat berubah. Jangan memodifikasi data dalam tabel ini secara langsung.
Tabel kunci dalam skema pgactive meliputi:
+ `pgactive_nodes`— Menyimpan informasi tentang node dalam grup replikasi aktif-aktif.
+ `pgactive_connections`— Menyimpan detail koneksi untuk setiap node.
## pgactive\$1nodes
Pgactive\$1nodes menyimpan informasi tentang node yang berpartisipasi dalam grup replikasi aktif-aktif.
| Kolom | Tipe | Kolasi | Nullable | Default |
| --- | --- | --- | --- | --- |
| node\$1sysid | text | – | tidak null | – |
| node\$1timeline | oid | – | tidak null | – |
| node\$1dboid | oid | – | tidak null | – |
| node\$1status | char | – | tidak null | – |
| node\$1name | text | – | tidak null | – |
| node\$1dsn | text | – | tidak null | – |
| node\$1init\$1from\$1dsn | text | – | tidak null | – |
| node\$1read\$1only | boolean | – | – | false |
| node\$1seq\$1id | smallint | – | tidak null | – |
**node\$1sysid**
ID unik untuk node, dihasilkan selama `pgactive_create_group` atau `pgactive_join_group`
**node\$1status**
Kesiapan simpul:
+ **b** - pengaturan awal
+ **i** - menginisialisasi
+ **c** - menyusul
+ **o** - membuat slot keluar
+ **r** - siap
+ **k** - terbunuh
Kolom ini tidak menunjukkan apakah node terhubung atau terputus.
**node\$1name**
Nama simpul unik yang disediakan pengguna.
**node\$1dsn**
String koneksi atau nama pemetaan pengguna
**node\$1init\$1from\$1dsn**
DSN dari mana node ini dibuat.
## pgactive\$1connection
Pgactive\$1connections menyimpan detail koneksi untuk setiap node.
| Kolom | Tipe | Kolasi | Nullable | Default |
| --- | --- | --- | --- | --- |
| conn\$1sysid | text | none | tidak null | none |
| conn\$1timeline | oid | none | tidak null | none |
| conn\$1dboid | oid | none | tidak null | none |
| conn\$1dsn | text | none | tidak null | none |
| conn\$1apply\$1delay | integer | none | none | none |
| conn\$1replication\$1sets | text | none | none | none |
conn\$1sysid
Node identifier untuk node entri ini mengacu pada.
conn\$1dsn
Sama seperti `node_dsn` pgactive.pgactive\$1nodes.
conn\$1apply\$1delay
Jika diatur, milidetik menunggu sebelum menerapkan setiap transaksi dari node jarak jauh. Terutama untuk debugging. Jika null, default global berlaku.
## Bekerja dengan set replikasi
Set replikasi menentukan tabel mana yang akan disertakan atau dikecualikan dari operasi replikasi. Secara default, semua tabel direplikasi kecuali Anda menentukan sebaliknya menggunakan fungsi berikut:
+ `pgactive_exclude_table_replication_set()`- Tidak termasuk tabel tertentu dari replikasi
+ `pgactive_include_table_replication_set()`- Termasuk tabel tertentu dalam replikasi
**catatan**
Sebelum Anda mengonfigurasi set replikasi, pertimbangkan hal berikut:
Anda dapat mengonfigurasi penyertaan atau pengecualian tabel hanya setelah menjalankan `pgactive_create_group()` tetapi sebelumnya`pgactive_join_group()`.
Setelah Anda menggunakannya`pgactive_exclude_table_replication_set()`, Anda tidak dapat menggunakannya`pgactive_include_table_replication_set()`.
Setelah Anda menggunakannya`pgactive_include_table_replication_set()`, Anda tidak dapat menggunakannya`pgactive_exclude_table_replication_set()`.
Sistem menangani tabel yang baru dibuat secara berbeda berdasarkan konfigurasi awal Anda:
+ Jika Anda mengecualikan tabel: Setiap tabel baru yang dibuat setelah `pgactive_join_group()` secara otomatis disertakan dalam replikasi
+ Jika Anda menyertakan tabel: Setiap tabel baru yang dibuat setelahnya secara otomatis `pgactive_join_group()` dikecualikan dari replikasi.
Untuk melihat konfigurasi set replikasi untuk tabel tertentu, gunakan `pgactive.pgactive_get_table_replication_sets()` fungsi.
# referensi fungsi pgactive
Berikut ini, Anda dapat menemukan daftar fungsi pgactive dengan parameternya, nilai pengembalian, dan catatan penggunaan praktis untuk membantu Anda menggunakannya secara efektif:
## get\$1last\$1applied\$1xact\$1info
Mengambil informasi transaksi yang diterapkan terakhir untuk node tertentu.
**Argumen**
+ sysid (teks) - garis waktu OID
+ dboid (OID)
**Jenis pengembalian**
Ini mencatat yang berikut:
+ last\$1applied\$1xact\$1id (OID)
+ last\$1applied\$1xact\$1committs (stempel waktu dengan zona waktu)
+ last\$1applied\$1xact\$1at (stempel waktu dengan zona waktu)
**Catatan penggunaan**
Gunakan fungsi ini untuk mengambil informasi transaksi yang diterapkan terakhir untuk node tertentu.
## pgactive\$1apply\$1pause
Menjeda proses penerapan replikasi.
**Argumen**
Tidak ada
**Jenis pengembalian**
boolean
**Catatan penggunaan**
Panggil fungsi ini untuk menjeda proses penerapan replikasi.
## pgactive\$1apply\$1resume
Melanjutkan proses penerapan replikasi.
**Argumen**
Tidak ada
**Jenis pengembalian**
kosong
**Catatan penggunaan**
Panggil fungsi ini untuk melanjutkan proses penerapan replikasi.
## pgactive\$1is\$1apply\$1paused
Memeriksa apakah replikasi berlaku saat ini dijeda.
**Argumen**
Tidak ada
**Jenis pengembalian**
boolean
**Catatan penggunaan**
Gunakan fungsi ini untuk memeriksa apakah replikasi berlaku saat ini dijeda.
## pgactive\$1create\$1group
Membuat grup pgactive dengan mengubah database mandiri menjadi node awal.
**Argumen**
+ node\$1name (teks)
+ node\$1dsn (teks)
+ apply\$1delay integer DEFAULT NULL: :integer - replication\$1sets text [] DEFAULT ARRAY ['default': :text]
**Jenis pengembalian**
kosong
**Catatan penggunaan**
Membuat grup pgactive dengan mengubah database mandiri menjadi node awal. Fungsi melakukan pemeriksaan kewarasan sebelum mengubah node menjadi node pgactive. Sebelum menggunakan fungsi ini, pastikan klaster PostgreSQL Anda memiliki `max_worker_processes` cukup tersedia untuk mendukung pekerja latar belakang pgactive.
## pgactive\$1detach\$1nodes
Menghapus node tertentu dari grup pgactive.
**Argumen**
+ p\$1nodes (teks [])
**Jenis pengembalian**
kosong
**Catatan penggunaan**
Gunakan fungsi ini untuk menghapus node tertentu dari grup pgactive.
## pgactive\$1exclude\$1table\$1replication\$1set
Tidak termasuk tabel tertentu dari replikasi.
**Argumen**
+ p\$1relation (regclass)
**Jenis pengembalian**
kosong
**Catatan penggunaan**
Gunakan fungsi ini untuk mengecualikan tabel tertentu dari replikasi.
## pgactive\$1get\$1replication\$1lag\$1info
Mengambil informasi lag replikasi rinci, termasuk rincian node, status WAL, dan nilai LSN.
**Argumen**
Tidak ada
**Jenis pengembalian**
Rekaman SETOF - teks node\$1name - teks node\$1sysid - teks application\$1name - teks slot\$1name - boolean aktif - integer active\$1pid - pending\$1wal\$1decoding bigint - Perkiraan ukuran WAL dalam byte yang akan diterjemahkan pada node pengirim - pending\$1wal\$1to\$1apply bigint - Perkiraan ukuran WAL dalam byte yang akan diterapkan pada penerimaan simpul - restart\$1lsn pg\$1lsn - confirmed\$1flush\$1lsn pg\$1lsn - sent\$1lsn pg\$1lsn - write\$1lsn pg\$1lsn - flush\$1lsn pg\$1lsn - replay\$1lsn pg\$1lsn
**Catatan penggunaan**
Panggil fungsi ini untuk mengambil informasi lag replikasi, termasuk detail node, status WAL, dan nilai LSN.
## pgactive\$1get\$1stats
Mengambil statistik replikasi pgaktif.
**Argumen**
Tidak ada
**Jenis pengembalian**
Catatan SETOF - rep\$1node\$1id oid - rilocalid oid - teks riremoteid - nr\$1commit bigint - nr\$1rollback bigint - nr\$1insert bigint - nr\$1insert\$1conflict bigint - nr\$1delete\$1conflict bigint - nr\$1delete bigint - nr\$1deleteet \$1conflict bigint - nr\$1disconnect bigint
**Catatan penggunaan**
Gunakan fungsi ini untuk mengambil statistik replikasi pgactive.
## pgactive\$1get\$1table\$1replication\$1sets
Mendapat konfigurasi set replikasi untuk relasi tertentu.
**Argumen**
+ hubungan (regclass)
**Jenis pengembalian**
Catatan SETOF
**Catatan penggunaan**
Panggil fungsi ini untuk mendapatkan konfigurasi set replikasi untuk relasi tertentu.
## pgactive\$1include\$1table\$1replication\$1set
Termasuk tabel tertentu dalam replikasi.
**Argumen**
+ p\$1relation (regclass)
**Jenis pengembalian**
kosong
**Catatan penggunaan**
Gunakan fungsi ini untuk menyertakan tabel tertentu dalam replikasi.
## pgactive\$1join\$1group
Menambahkan node ke grup pgactive yang ada.
**Argumen**
+ node\$1name (teks)
+ node\$1dsn (teks)
+ join\$1using\$1dsn (teks)
+ apply\$1delay (bilangan bulat, opsional)
+ replication\$1sets (teks [], default: ['default'])
+ bypass\$1collation\$1check (boolean, default: false)
+ bypass\$1node\$1identifier\$1creation (boolean, default: false)
+ bypass\$1user\$1tables\$1check (boolean, default: false)
**Jenis pengembalian**
kosong
**Catatan penggunaan**
Panggil fungsi ini untuk menambahkan node ke grup pgactive yang ada. Pastikan klaster PostgreSQL Anda memiliki max\$1worker\$1processes yang cukup untuk pekerja latar belakang pgactive.
## pgactive\$1remove
Menghapus semua komponen pgactive dari node lokal.
**Argumen**
+ memaksa (boolean, default: false)
**Jenis pengembalian**
kosong
**Catatan penggunaan**
Panggil fungsi ini untuk menghapus semua komponen pgactive dari node lokal.
## pgactive\$1snowflake\$1id\$1nextval
Menghasilkan nilai urutan unik khusus simpul.
**Argumen**
+ regclass
**Jenis pengembalian**
bigint
**Catatan penggunaan**
Gunakan fungsi ini untuk menghasilkan nilai urutan unik khusus simpul.
## pgactive\$1update\$1node\$1conninfo
Memperbarui informasi koneksi untuk node pgactive.
**Argumen**
+ node\$1name\$1to\$1update (teks)
+ node\$1dsn\$1to\$1update (teks)
**Jenis pengembalian**
kosong
**Catatan penggunaan**
Gunakan fungsi ini untuk memperbarui informasi koneksi untuk node pgactive.
## pgactive\$1wait\$1for\$1node\$1ready
Memantau kemajuan pembuatan grup atau bergabung dengan operasi.
**Argumen**
+ batas waktu (bilangan bulat, default: 0)
+ progress\$1interval (bilangan bulat, default: 60)
**Jenis pengembalian**
kosong
**Catatan penggunaan**
Panggil fungsi ini untuk memantau kemajuan pembuatan grup atau bergabung dengan operasi.
# Menangani konflik dalam replikasi aktif-aktif
Ekstensi `pgactive` bekerja per basis data dan bukan per klaster. Setiap instans DB yang menggunakan `pgactive` adalah instans independen dan dapat menerima perubahan data dari sumber apa pun. Ketika perubahan dikirim ke instans DB, PostgreSQL meng-commit perubahan tersebut secara lokal dan kemudian menggunakan `pgactive` untuk mereplikasi perubahan tersebut secara asinkron ke instans DB lainnya. Ketika dua instans DB PostgreSQL memperbarui catatan yang sama pada waktu yang hampir bersamaan, konflik dapat terjadi.
Ekstensi `pgactive` menyediakan mekanisme untuk deteksi konflik dan resolusi otomatis. Ini akan melacak stempel waktu ketika transaksi dilakukan pada kedua instans DB dan secara otomatis menerapkan perubahan dengan stempel waktu terbaru. Ekstensi `pgactive` juga melakukan log ketika konflik terjadi dalam tabel `pgactive.pgactive_conflict_history`.
`pgactive.pgactive_conflict_history`Akan terus tumbuh. Anda mungkin ingin menentukan kebijakan pembersihan. Ini dapat dilakukan dengan menghapus beberapa catatan secara teratur atau mendefinisikan skema partisi untuk hubungan ini (dan kemudian melepaskan, menjatuhkan, memotong partisi yang menarik). Untuk menerapkan kebijakan pembersihan secara teratur, salah satu opsi adalah menggunakan `pg_cron` ekstensi. Lihat informasi berikut dari contoh untuk tabel `pg_cron` riwayat, [Penjadwalan pemeliharaan dengan ekstensi PostgreSQL pg\$1cron](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL_pg_cron.html).
# Menangani urutan dalam replikasi aktif-aktif
Sebuah instans DB RDS for PostgreSQL dengan ekstensi `pgactive` menggunakan dua mekanisme urutan yang berbeda untuk menghasilkan nilai unik.
**Urutan Global**
Untuk menggunakan urutan global, buat urutan lokal dengan pernyataan `CREATE SEQUENCE`. Gunakan `pgactive.pgactive_snowflake_id_nextval(seqname)` alih-alih `usingnextval(seqname)` untuk mendapatkan nilai unik berikutnya dari urutan.
Contoh berikut membuat urutan global:
```
app=> CREATE TABLE gstest (
id bigint primary key,
parrot text
);
```
```
app=>CREATE SEQUENCE gstest_id_seq OWNED BY gstest.id;
```
```
app=> ALTER TABLE gstest \
ALTER COLUMN id SET DEFAULT \
pgactive.pgactive_snowflake_id_nextval('gstest_id_seq');
```
**Urutan yang dipartisi**
Dalam urutan split-step atau partisi, urutan PostgreSQL normal digunakan pada setiap simpul. Setiap urutan bertambah dengan jumlah yang sama dan dimulai pada offset yang berbeda. Misalnya, dengan langkah 100, simpul 1 menghasilkan urutan sebagai 101, 201, 301, dan seterusnya dan simpul 2 menghasilkan urutan sebagai 102, 202, 302, dan seterusnya. Skema ini bekerja dengan baik bahkan jika simpul tidak dapat berkomunikasi untuk waktu yang lama, tetapi mengharuskan perancang menentukan jumlah simpul maksimum saat membuat skema dan memerlukan konfigurasi per-simpul. Kesalahan dapat dengan mudah menyebabkan urutan yang tumpang tindih.
Hal ini relatif mudah untuk mengonfigurasi pendekatan ini dengan `pgactive` dengan membuat urutan yang diinginkan pada simpul sebagai berikut:
```
CREATE TABLE some_table (generated_value bigint primary key);
```
```
app=> CREATE SEQUENCE some_seq INCREMENT 100 OWNED BY some_table.generated_value;
```
```
app=> ALTER TABLE some_table ALTER COLUMN generated_value SET DEFAULT nextval('some_seq');
```
Kemudian panggil `setval` setiap simpul untuk memberikan nilai awal offset yang berbeda sebagai berikut.
```
app=>
-- On node 1
SELECT setval('some_seq', 1);
-- On node 2
SELECT setval('some_seq', 2);
```
# Mengurangi bloat dalam tabel dan indeks dengan ekstensi pg\$1repack
Anda dapat menggunakan `pg_repack` ekstensi untuk menghapus bloat dari tabel dan indeks sebagai alternatif. `VACUUM FULL` Ekstensi didukung pada RDS for PostgreSQL versi 9.6.3 dan yang lebih tinggi. Untuk informasi selengkapnya tentang `pg_repack` ekstensi dan pengemasan ulang tabel lengkap, lihat [dokumentasi GitHub proyek](https://reorg.github.io/pg_repack/).
Tidak seperti`VACUUM FULL`, `pg_repack` ekstensi memerlukan kunci eksklusif (AccessExclusiveLock) hanya untuk waktu yang singkat selama operasi membangun kembali tabel dalam kasus berikut:
+ Pembuatan awal tabel log - Tabel log dibuat untuk merekam perubahan yang terjadi selama salinan awal data, seperti yang ditunjukkan pada contoh berikut:
```
postgres=>\dt+ repack.log_*
List of relations
-[ RECORD 1 ]-+----------
Schema | repack
Name | log_16490
Type | table
Owner | postgres
Persistence | permanent
Access method | heap
Size | 65 MB
Description |
```
+ swap-and-dropFase terakhir.
Untuk sisa operasi pembangunan kembali, hanya perlu `ACCESS SHARE` kunci pada tabel asli untuk menyalin baris dari itu ke tabel baru. Ini membantu operasi INSERT, UPDATE, dan DELETE untuk melanjutkan seperti biasa.
## Rekomendasi
Rekomendasi berikut berlaku saat Anda menghapus bloat dari tabel dan indeks menggunakan ekstensi: `pg_repack`
+ Lakukan pengemasan ulang selama jam non-bisnis atau melalui jendela pemeliharaan untuk meminimalkan dampaknya terhadap kinerja aktivitas database lainnya.
+ Pantau sesi pemblokiran selama aktivitas membangun kembali dan memastikan bahwa tidak ada aktivitas di tabel asli yang berpotensi memblokir`pg_repack`, khususnya selama swap-and-drop fase akhir ketika memerlukan kunci eksklusif pada tabel asli. Untuk informasi selengkapnya, lihat [Mengidentifikasi apa yang memblokir kueri](https://repost.aws/knowledge-center/rds-aurora-postgresql-query-blocked).
Ketika Anda melihat sesi pemblokiran, Anda dapat menghentikannya menggunakan perintah berikut setelah mempertimbangkan dengan cermat. Ini membantu dalam kelanjutan `pg_repack` untuk menyelesaikan pembangunan kembali:
```
SELECT pg_terminate_backend(pid);
```
+ Saat menerapkan perubahan yang masih harus dibayar dari tabel `pg_repack's` log pada sistem dengan tingkat transaksi yang sangat tinggi, proses penerapan mungkin tidak dapat mengikuti tingkat perubahan. Dalam kasus seperti itu, tidak `pg_repack` akan dapat menyelesaikan proses penerapan. Untuk informasi selengkapnya, lihat [Memantau tabel baru selama pengemasan ulang](#Appendix.PostgreSQL.CommonDBATasks.pg_repack.Monitoring). Jika indeks sangat membengkak, solusi alternatif adalah melakukan pengemasan ulang indeks saja. Ini juga membantu siklus pembersihan indeks VACUUM untuk menyelesaikan lebih cepat.
Anda dapat melewati fase pembersihan indeks menggunakan VACUUM manual dari PostgreSQL versi 12, dan dilewati secara otomatis selama autovacuum darurat dari PostgreSQL versi 14. Ini membantu VACUUM menyelesaikan lebih cepat tanpa menghilangkan kembung indeks dan hanya dimaksudkan untuk situasi darurat seperti mencegah VACUUM sampul. Untuk informasi selengkapnya, lihat [Menghindari kembung dalam indeks di Panduan](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.diag-table-ind-bloat.html#AuroraPostgreSQL.diag-table-ind-bloat.AvoidinginIndexes) Pengguna Amazon Aurora.
## Prasyarat
+ Tabel harus memiliki PRIMARY KEY atau not-null UNIQUE kendala.
+ Versi ekstensi harus sama untuk klien dan server.
+ Pastikan bahwa instance RDS memiliki `FreeStorageSpace` lebih dari ukuran total tabel tanpa kembung. Sebagai contoh, pertimbangkan ukuran total tabel termasuk TOAST dan indeks sebagai 2TB, dan total kembung dalam tabel sebagai 1TB. Yang dibutuhkan `FreeStorageSpace` harus lebih dari nilai yang dikembalikan oleh perhitungan berikut:
`2TB (Table size)` - `1TB (Table bloat)` = `1TB`
Anda dapat menggunakan kueri berikut untuk memeriksa ukuran total tabel dan gunakan `pgstattuple` untuk mendapatkan kembung. Untuk informasi selengkapnya, lihat [Mendiagnosis tabel dan indeks kembung di Panduan](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.diag-table-ind-bloat.html) Pengguna Amazon Aurora
```
SELECT pg_size_pretty(pg_total_relation_size('table_name')) AS total_table_size;
```
Ruang ini direklamasi setelah selesainya kegiatan.
+ Pastikan instans RDS memiliki kapasitas komputasi dan IO yang cukup untuk menangani operasi pengemasan ulang. Anda dapat mempertimbangkan untuk meningkatkan kelas instance untuk keseimbangan kinerja yang optimal.
**Untuk menggunakan `pg_repack` ekstensi**
1. Instal `pg_repack` ekstensi pada RDS Anda untuk PostgreSQL DB instance dengan menjalankan perintah berikut.
```
CREATE EXTENSION pg_repack;
```
1. Jalankan perintah berikut untuk memberikan akses tulis ke tabel log sementara yang dibuat oleh`pg_repack`.
```
ALTER DEFAULT PRIVILEGES IN SCHEMA repack GRANT INSERT ON TABLES TO PUBLIC;
ALTER DEFAULT PRIVILEGES IN SCHEMA repack GRANT USAGE, SELECT ON SEQUENCES TO PUBLIC;
```
1. Connect ke database menggunakan utilitas `pg_repack` klien. Gunakan akun yang memiliki hak istimewa `rds_superuser`. Sebagai contoh, asumsikan bahwa peran `rds_test` memiliki hak istimewa `rds_superuser`. Sintaks berikut melakukan `pg_repack` untuk tabel lengkap termasuk semua indeks tabel dalam database. `postgres`
```
pg_repack -h db-instance-name.111122223333.aws-region.rds.amazonaws.com -U rds_test -k postgres
```
**catatan**
Anda harus terhubung menggunakan opsi -k. Opsi -a tidak didukung.
Respons dari `pg_repack` klien memberikan informasi pada tabel pada instance DB yang dikemas ulang.
```
INFO: repacking table "pgbench_tellers"
INFO: repacking table "pgbench_accounts"
INFO: repacking table "pgbench_branches"
```
1. Sintaks berikut menampilkan ulang tabel tunggal `orders` termasuk indeks dalam database. `postgres`
```
pg_repack -h db-instance-name.111122223333.aws-region.rds.amazonaws.com -U rds_test --table orders -k postgres
```
Sintaks berikut hanya menampilkan indeks untuk `orders` tabel dalam database. `postgres`
```
pg_repack -h db-instance-name.111122223333.aws-region.rds.amazonaws.com -U rds_test --table orders --only-indexes -k postgres
```
## Memantau tabel baru selama pengemasan ulang
+ Ukuran database ditingkatkan dengan ukuran total tabel dikurangi kembung, hingga swap-and-drop fase repack. Anda dapat memantau laju pertumbuhan ukuran database, menghitung kecepatan pengemasan ulang, dan memperkirakan secara kasar waktu yang diperlukan untuk menyelesaikan transfer data awal.
Sebagai contoh, pertimbangkan ukuran total tabel sebagai 2TB, ukuran database sebagai 4TB, dan total kembung dalam tabel sebagai 1TB. Nilai ukuran total database yang dikembalikan oleh perhitungan pada akhir operasi repack adalah sebagai berikut:
`2TB (Table size)` \$1 `4 TB (Database size)` - `1TB (Table bloat)` = `5TB`
Anda dapat memperkirakan secara kasar kecepatan operasi pengemasan ulang dengan mengambil sampel laju pertumbuhan dalam byte antara dua titik waktu. Jika tingkat pertumbuhan 1GB per menit, dibutuhkan 1000 menit atau 16,6 jam kira-kira untuk menyelesaikan operasi pembuatan tabel awal. Selain pembuatan tabel awal, `pg_repack` juga perlu menerapkan perubahan yang masih harus dibayar. Waktu yang dibutuhkan tergantung pada tingkat penerapan perubahan yang sedang berlangsung ditambah perubahan yang masih harus dibayar.
**catatan**
Anda dapat menggunakan `pgstattuple` ekstensi untuk menghitung kembung dalam tabel. Untuk informasi selengkapnya, lihat [pgstattuple](https://www.postgresql.org/docs/current/pgstattuple.html).
+ Jumlah baris dalam tabel `pg_repack's` log, di bawah skema repack mewakili volume perubahan yang menunggu untuk diterapkan ke tabel baru setelah pemuatan awal.
Anda dapat memeriksa tabel `pg_repack's` log `pg_stat_all_tables` untuk memantau perubahan yang diterapkan pada tabel baru. `pg_stat_all_tables.n_live_tup`menunjukkan jumlah catatan yang tertunda untuk diterapkan ke tabel baru. Untuk informasi selengkapnya, lihat [pg\$1stat\$1all\$1tables](https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-PG-STAT-ALL-TABLES-VIEW).
```
postgres=>SELECT relname,n_live_tup FROM pg_stat_all_tables WHERE schemaname = 'repack' AND relname ILIKE '%log%';
-[ RECORD 1 ]---------
relname | log_16490
n_live_tup | 2000000
```
+ Anda dapat menggunakan `pg_stat_statements` ekstensi untuk mengetahui waktu yang dibutuhkan oleh setiap langkah dalam operasi pengemasan ulang. Ini sangat membantu dalam persiapan untuk menerapkan operasi pengemasan ulang yang sama di lingkungan produksi. Anda dapat menyesuaikan `LIMIT` klausa untuk memperluas output lebih lanjut.
```
postgres=>SELECT
SUBSTR(query, 1, 100) query,
round((round(total_exec_time::numeric, 6) / 1000 / 60),4) total_exec_time_in_minutes
FROM
pg_stat_statements
WHERE
query ILIKE '%repack%'
ORDER BY
total_exec_time DESC LIMIT 5;
query | total_exec_time_in_minutes
-----------------------------------------------------------------------+----------------------------
CREATE UNIQUE INDEX index_16493 ON repack.table_16490 USING btree (a) | 6.8627
INSERT INTO repack.table_16490 SELECT a FROM ONLY public.t1 | 6.4150
SELECT repack.repack_apply($1, $2, $3, $4, $5, $6) | 0.5395
SELECT repack.repack_drop($1, $2) | 0.0004
SELECT repack.repack_swap($1) | 0.0004
(5 rows)
```
Pengepakan ulang sepenuhnya merupakan out-of-place operasi sehingga tabel asli tidak terpengaruh dan kami tidak mengantisipasi tantangan tak terduga yang memerlukan pemulihan tabel asli. Jika repack gagal secara tak terduga, Anda harus memeriksa penyebab kesalahan dan menyelesaikannya.
Setelah masalah teratasi, jatuhkan dan buat ulang `pg_repack` ekstensi di database tempat tabel ada, dan coba lagi langkahnya. `pg_repack` Selain itu, ketersediaan sumber daya komputasi dan aksesibilitas tabel secara bersamaan memainkan peran penting dalam penyelesaian operasi pengemasan ulang secara tepat waktu.
# Memutakhirkan dan menggunakan ekstensi PLV8
PLV8 adalah ekstensi bahasa Javascript tepercaya untuk PostgreSQL. Anda dapat menggunakannya untuk prosedur tersimpan, pemicu, dan kode prosedural lainnya yang dapat dipanggil dari SQL. Ekstensi bahasa ini didukung oleh semua rilis PostgreSQL saat ini.
Jika Anda menggunakan [PLV8](https://plv8.github.io/)dan meningkatkan PostgreSQL ke versi PLV8 baru, Anda segera memanfaatkan ekstensi baru. Ambil langkah-langkah berikut untuk menyinkronkan metadata katalog Anda dengan versi baru. PLV8 Langkah-langkah ini opsional, tetapi kami sangat menyarankan Anda menyelesaikannya untuk menghindari peringatan ketidakcocokan metadata.
Proses pemutakhiran menjatuhkan semua PLV8 fungsi Anda yang ada. Oleh karena itu, kami menyarankan Anda membuat snapshot dari instans DB RDS for PostgreSQL Anda sebelum meningkatkan. Untuk informasi selengkapnya, lihat [Membuat snapshot DB untuk instans DB AZ tunggal untuk Amazon RDS](USER_CreateSnapshot.md).
**penting**
Dimulai dengan PostgreSQL versi 18, Amazon RDS for PostgreSQL akan menghentikan ekstensi dan PostgreSQL. `plcoffee` `plls` Kami menyarankan Anda berhenti menggunakan CoffeeScript dan LiveScript dalam aplikasi Anda untuk memastikan Anda memiliki jalur peningkatan untuk upgrade versi engine masa depan.
**Untuk menyinkronkan metadata katalog Anda dengan versi baru PLV8**
1. Verifikasi bahwa Anda perlu memperbarui. Untuk melakukannya, jalankan perintah berikut saat terhubung dengan instans Anda.
```
SELECT * FROM pg_available_extensions WHERE name IN ('plv8','plls','plcoffee');
```
Jika hasil Anda berisi nilai untuk versi terinstal yang lebih rendah dari versi default, lanjutkan dengan prosedur ini untuk memperbarui ekstensi Anda. Misalnya, kumpulan hasil berikut menunjukkan bahwa Anda harus memperbarui.
```
name | default_version | installed_version | comment
--------+-----------------+-------------------+--------------------------------------------------
plls | 2.1.0 | 1.5.3 | PL/LiveScript (v8) trusted procedural language
plcoffee| 2.1.0 | 1.5.3 | PL/CoffeeScript (v8) trusted procedural language
plv8 | 2.1.0 | 1.5.3 | PL/JavaScript (v8) trusted procedural language
(3 rows)
```
1. Buat snapshot instans DB RDS for PostgreSQL Anda jika Anda belum melakukannya. Anda dapat melanjutkan dengan langkah-langkah berikut saat snapshot sedang dibuat.
1. Dapatkan hitungan jumlah PLV8 fungsi dalam instans DB Anda sehingga Anda dapat memvalidasi bahwa semuanya ada setelah peningkatan. Misalnya, kueri SQL berikut mengembalikan jumlah fungsi yang ditulis dalam plv8, plcoffee, and plls.
```
SELECT proname, nspname, lanname
FROM pg_proc p, pg_language l, pg_namespace n
WHERE p.prolang = l.oid
AND n.oid = p.pronamespace
AND lanname IN ('plv8','plcoffee','plls');
```
1. Gunakan pg\$1dump untuk membuat file dump hanya untuk skema. Misalnya, buat file di mesin klien Anda di direktori `/tmp`.
```
./pg_dump -Fc --schema-only -U master postgres >/tmp/test.dmp
```
Contoh ini menggunakan hal berikut:
+ `-Fc` – Format kustom
+ --schema-only – Buang perintah yang diperlukan untuk membuat skema (fungsi dalam kasus ini)
+ `-U` – Nama pengguna utama RDS
+ `database` – Nama untuk basis data di instans DB Anda
Untuk informasi selengkapnya, lihat [pg\$1dump](https://www.postgresql.org/docs/current/static/app-pgdump.html ) dalam dokumentasi PostgreSQL.
1. Ekstrak pernyataan DDL "CREATE FUNCTION" yang ada di berkas dump. Contoh berikut menggunakan perintah `grep` untuk mengekstrak pernyataan DDL yang menciptakan fungsi dan menyimpannya ke file. Anda menggunakan ini dalam langkah-langkah berikutnya untuk membuat ulang fungsi.
```
./pg_restore -l /tmp/test.dmp | grep FUNCTION > /tmp/function_list
```
Untuk informasi selengkapnya pada pg\$1restore, lihat [pg\$1restore](https://www.postgresql.org/docs/current/static/app-pgrestore.html) dalam dokumentasi PostgreSQL.
1. Hapus sementara fungsi dan ekstensi. Contoh berikut menjatuhkan objek PLV8 berbasis apa pun. Opsi kaskade memastikan bahwa ketergantungan apa pun dapat dihapus sementara.
```
DROP EXTENSION plv8 CASCADE;
```
Jika instans PostgreSQL Anda berisi objek berdasarkan plcoffee atau plls, ulangi langkah ini untuk ekstensi tersebut.
1. Buat ekstensi. Contoh berikut untuk membuat ekstensi plv8, plcoffee, dan plls.
```
CREATE EXTENSION plv8;
CREATE EXTENSION plcoffee;
CREATE EXTENSION plls;
```
1. Buat fungsi menggunakan file dump dan file "driver".
Contoh berikut membuat ulang fungsi yang Anda ekstrak sebelumnya.
```
./pg_restore -U master -d postgres -Fc -L /tmp/function_list /tmp/test.dmp
```
1. Verifikasi bahwa semua fungsi Anda telah dibuat ulang dengan menggunakan kueri berikut.
```
SELECT * FROM pg_available_extensions WHERE name IN ('plv8','plls','plcoffee');
```
PLV8 Versi 2 menambahkan baris tambahan berikut ke set hasil Anda:
```
proname | nspname | lanname
---------------+------------+----------
plv8_version | pg_catalog | plv8
```
# Menggunakan PL/Rust untuk menulis fungsi PostgreSQL dalam bahasa Rust
PL/Rust is a trusted Rust language extension for PostgreSQL. You can use it for stored procedures, functions, and other procedural code that's callable from SQL. The PL/Rustekstensi bahasa tersedia dalam versi berikut:
+ RDS untuk PostgreSQL 17.1 dan versi 17 yang lebih tinggi
+ RDS untuk PostgreSQL 16.1 dan versi 16 yang lebih tinggi
+ RDS for PostgreSQL 15.2-R2 dan versi 15 yang lebih tinggi
+ RDS for PostgreSQL 14.9 dan versi 14 yang lebih tinggi
+ RDS for PostgreSQL 13.12 dan versi 13 yang lebih tinggi
Untuk informasi lebih lanjut, lihat [PL/Rust](https://github.com/tcdi/plrust#readme) on. GitHub
**Topics**
+ [
## Menyiapkan PL/Rust
](#PL_Rust-setting-up)
+ [
## Membuat fungsi dengan PL/Rust
](#PL_Rust-create-function)
+ [
## Menggunakan crate dengan PL/Rust
](#PL_Rust-crates)
+ [
## Batasan PL/Rust
](#PL_Rust-limitations)
## Menyiapkan PL/Rust
Untuk menginstal ekstensi plrust pada instans DB Anda, tambahkan plrust ke parameter `shared_preload_libraries` dalam grup parameter DB yang terkait dengan instans DB Anda. Dengan ekstensi plrust yang terinstal, Anda dapat membuat fungsi.
Untuk mengubah parameter `shared_preload_libraries`, instans DB Anda harus berkaitan dengan grup parameter kustom. Untuk informasi tentang cara membuat grup parameter DB kustom, lihat [Grup parameter untuk RDS](USER_WorkingWithParamGroups.md).
Anda dapat menginstal ekstensi plrust menggunakan Konsol Manajemen AWS atau. AWS CLI
Langkah-langkah berikut mengasumsikan bahwa instans Anda dikaitkan dengan grup parameter DB kustom.
### Konsol
**Instal ekstensi plrust di parameter `shared_preload_libraries`**
Lakukan langkah-langkah berikut menggunakan akun yang merupakan anggota grup `rds_superuser` (peran).
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 **Basis data**.
1. Pilih nama instans DB Anda untuk menampilkan detailnya.
1. Buka tab **Konfigurasi** untuk instans DB Anda dan temukan tautan grup parameter instans DB.
1. Pilih tautan untuk membuka parameter kustom yang terkait dengan instans DB.
1. Di bidang pencarian **Parameter**, ketik `shared_pre` untuk menemukan parameter **`shared_preload_libraries`**.
1. Pilih **Edit parameter** untuk mengakses nilai properti.
1. Tambahkan plrust ke daftar di bidang **Nilai**. Gunakan koma untuk memisahkan item dalam daftar nilai.
1. Boot ulang instans DB sehingga perubahan Anda pada parameter`shared_preload_libraries` akan berlaku. Boot ulang awal mungkin memerlukan waktu tambahan untuk menyelesaikannya.
1. Ketika instans tersedia, verifikasi bahwa plrust telah diinisialisasi. Gunakan `psql` untuk terhubung ke instans DB, kemudian jalankan perintah berikut.
```
SHOW shared_preload_libraries;
```
Output-nya semestinya mirip dengan yang berikut:
```
shared_preload_libraries
--------------------------
rdsutils,plrust
(1 row)
```
### AWS CLI
**Instal ekstensi plrust di parameter shared\$1preload\$1libraries**
Lakukan langkah-langkah berikut menggunakan akun yang merupakan anggota grup `rds_superuser` (peran).
1. Gunakan [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html) AWS CLI perintah untuk menambahkan plrust ke `shared_preload_libraries` parameter.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name custom-param-group-name \
--parameters "ParameterName=shared_preload_libraries,ParameterValue=plrust,ApplyMethod=pending-reboot" \
--region aws-region
```
1. Gunakan [reboot-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/reboot-db-instance) AWS CLI perintah untuk me-reboot instance DB dan menginisialisasi pustaka plrust. Boot ulang awal mungkin memerlukan waktu tambahan untuk menyelesaikannya.
```
aws rds reboot-db-instance \
--db-instance-identifier your-instance \
--region aws-region
```
1. Ketika instans tersedia, Anda dapat memverifikasi bahwa plrust telah diinisialisasi. Gunakan `psql` untuk terhubung ke instans DB, kemudian jalankan perintah berikut.
```
SHOW shared_preload_libraries;
```
Output-nya semestinya mirip dengan yang berikut:
```
shared_preload_libraries
--------------------------
rdsutils,plrust
(1 row)
```
## Membuat fungsi dengan PL/Rust
PL/Rust akan mengompilasi fungsi sebagai pustaka dinamis, memuatnya, dan menjalankannya.
Fungsi Rust berikut menyaring kelipatan dari array.
```
postgres=> CREATE LANGUAGE plrust;
CREATE EXTENSION
```
```
CREATE OR REPLACE FUNCTION filter_multiples(a BIGINT[], multiple BIGINT) RETURNS BIGINT[]
IMMUTABLE STRICT
LANGUAGE PLRUST AS
$$
Ok(Some(a.into_iter().filter(|x| x.unwrap() % multiple != 0).collect()))
$$;
WITH gen_values AS (
SELECT ARRAY(SELECT * FROM generate_series(1,100)) as arr)
SELECT filter_multiples(arr, 3)
from gen_values;
```
## Menggunakan crate dengan PL/Rust
Dalam RDS untuk PostgreSQL versi 16.3-R2 dan lebih tinggi, 15.7-R2 dan versi 15 yang lebih tinggi, 14.12-R2 dan versi 14 yang lebih tinggi, dan 13.15-R2 dan versi 13 yang lebih tinggi, mendukung peti tambahan: PL/Rust
+ `url`
+ `regex`
+ `serde`
+ `serde_json`
Dalam RDS untuk PostgreSQL versi 15.5-R2 dan lebih tinggi, 14.10-R2 dan versi 14 yang lebih tinggi, dan 13.13-R2 dan versi 13 yang lebih tinggi, mendukung dua peti tambahan: PL/Rust
+ `croaring-rs`
+ `num-bigint`
Dimulai dengan Amazon RDS untuk PostgreSQL versi 15.4, 14.9, dan 13.12, mendukung peti berikut: PL/Rust
+ `aes`
+ `ctr`
+ `rand`
Hanya fitur default yang didukung untuk crate ini. Versi RDS for PostgreSQL baru mungkin berisi versi crate terbaru, dan crate versi lama yang mungkin tidak lagi didukung lagi.
Ikuti praktik terbaik untuk melakukan peningkatan versi utama untuk menguji apakah PL/Rust fungsi Anda kompatibel dengan versi utama yang baru. Untuk informasi selengkapnya, lihat blog [Best practices for upgrading Amazon RDS to major and minor versions of PostgreSQL](https://aws.amazon.com/blogs/database/best-practices-for-upgrading-amazon-rds-to-major-and-minor-versions-of-postgresql/) serta [Upgrading the PostgreSQL DB engine for Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_UpgradeDBInstance.PostgreSQL.html) di Panduan Pengguna Amazon RDS.
Contoh penggunaan dependensi saat membuat PL/Rust fungsi tersedia di [Gunakan](https://tcdi.github.io/plrust/use-plrust.html#use-dependencies) dependensi.
## Batasan PL/Rust
Secara default, pengguna database tidak dapat menggunakanPL/Rust. To provide access to PL/Rust, terhubung sebagai pengguna dengan hak istimewa rds\$1superuser, dan menjalankan perintah berikut:
```
postgres=> GRANT USAGE ON LANGUAGE PLRUST TO user;
```
# 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 [Cara melakukan upgrade versi utama untuk RDS untuk PostgreSQL](USER_UpgradeDBInstance.PostgreSQL.MajorVersion.Process.md).
Anda dapat memeriksa pembaruan versi ekstensi PostGIS yang tersedia di instans DB RDS for 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 [Cara melakukan upgrade versi utama untuk RDS untuk PostgreSQL](USER_UpgradeDBInstance.PostgreSQL.MajorVersion.Process.md).
## Versi ekstensi PostGIS
Sebaiknya, Anda menginstal versi semua ekstensi seperti PostGIS sebagaimana tercantum di [Versi ekstensi untuk Amazon RDS for PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html) dalam *Catatan Rilis Amazon RDS for 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 Amazon RDS for PostgreSQL*:
+ [Ekstensi PostgreSQL versi 16 didukung di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html#postgresql-extensions-16x)
+ [Ekstensi PostgreSQL versi 15 didukung di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html#postgresql-extensions-15x)
+ [Ekstensi PostgreSQL versi 14 didukung di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html#postgresql-extensions-14x)
+ [Ekstensi PostgreSQL versi 13 didukung di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html#postgresql-extensions-13x)
+ [Ekstensi PostgreSQL versi 12 didukung di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html#postgresql-extensions-12x)
+ [Ekstensi PostgreSQL versi 11 didukung di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html#postgresql-extensions-11x)
+ [Ekstensi PostgreSQL versi 10 didukung di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html#postgresql-extensions-101x)
+ [Ekstensi PostgreSQL versi 9.6.x yang didukung di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-extensions.html#postgresql-extensions-96x)
## 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 instans DB RDS for 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 DB RDS for 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;
```