Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# 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);
```