Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan pglogical untuk menyinkronkan data di seluruh instans
Semua versi Aurora PostgreSQL yang tersedia saat ini mendukung ekstensi `pglogical`. Ekstensi pglogical mendahului fitur replikasi logis yang mirip secara fungsional yang diperkenalkan oleh PostgreSQL di versi 10. Untuk informasi selengkapnya, lihat [Ikhtisar replikasi logis PostgreSQL dengan Aurora](AuroraPostgreSQL.Replication.Logical.md).
Ekstensi `pglogical` ini mendukung replikasi logis antara dua klaster DB Aurora PostgreSQL atau lebih. Ini juga mendukung replikasi antara versi PostgreSQL yang berbeda, dan antara basis data yang berjalan pada instans DB RDS for PostgreSQL dan klaster DB Aurora PostgreSQL. Ekstensi `pglogical` menggunakan model terbitkan-dan-langganan untuk mereplikasi perubahan pada tabel dan objek lain, seperti urutan, dari penerbit ke pelanggan. Itu bergantung pada slot replikasi untuk memastikan bahwa perubahan disinkronkan dari simpul penerbit ke simpul pelanggan, didefinisikan sebagai berikut.
+ *Simpul penerbit* adalah klaster DB Aurora PostgreSQL yang merupakan sumber data yang akan direplikasi ke simpul lain. Simpul penerbit mendefinisikan tabel yang akan direplikasi dalam set publikasi.
+ *Simpul pelanggan* adalah klaster DB Aurora PostgreSQL yang menerima pembaruan WAL dari penerbit. Pelanggan membuat langganan untuk menghubungkan ke penerbit dan mendapatkan data WAL yang dikodekan. Saat pelanggan membuat langganan, slot replikasi dibuat pada simpul penerbit.
Berikut ini, Anda dapat menemukan informasi tentang cara mengatur ekstensi `pglogical`.
**Topics**
+ [Persyaratan dan batasan untuk ekstensi pglogical](#Appendix.PostgreSQL.CommonDBATasks.pglogical.requirements-limitations)
+ [Menyiapkan ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md)
+ [Menyiapkan replikasi logis untuk klaster DB Aurora PostgreSQL](Appendix.PostgreSQL.CommonDBATasks.pglogical.setup-replication.md)
+ [Membangun kembali replikasi logis setelah peningkatan besar](Appendix.PostgreSQL.CommonDBATasks.pglogical.recover-replication-after-upgrade.md)
+ [Mengelola slot replikasi logis untuk Aurora PostgreSQL RDS](Appendix.PostgreSQL.CommonDBATasks.pglogical.handle-slots.md)
+ [Referensi parameter untuk ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.reference.md)
## Persyaratan dan batasan untuk ekstensi pglogical
Semua rilis Aurora PostgreSQL yang tersedia saat ini mendukung ekstensi `pglogical`.
Baik simpul penerbit maupun simpul pelanggan harus disiapkan untuk replikasi logis.
Tabel yang ingin Anda replikasi dari penerbit ke pelanggan harus memiliki nama dan skema yang sama. Tabel ini juga harus berisi kolom yang sama, dan kolom harus menggunakan jenis data yang sama. Tabel penerbit dan pelanggan harus memiliki kunci primer yang sama. Sebaiknya Anda hanya menggunakan PRIMARY KEY sebagai batasan unik.
Tabel pada simpul pelanggan dapat memiliki batasan yang lebih permisif dibandingkan yang ada di simpul penerbit untuk batasan CHECK dan NOT NULL.
Ekstensi `pglogical` ini menyediakan fitur seperti replikasi dua arah yang tidak didukung oleh fitur replikasi logis default PostgreSQL (versi 10 dan lebih tinggi). Untuk informasi selengkapnya, lihat [replikasi bi-direksional PostgreSQL menggunakan pglogical](https://aws.amazon.com/blogs/database/postgresql-bi-directional-replication-using-pglogical/).
# Menyiapkan ekstensi pglogical
Untuk menyiapkan ekstensi `pglogical` pada klaster DB Aurora PostgreSQL, tambahkan `pglogical` ke pustaka bersama pada grup parameter klaster DB kustom untuk klaster DB Aurora PostgreSQL. Anda juga perlu mengatur nilai parameter `rds.logical_replication` ke `1`, untuk mengaktifkan penguraian kode logis. Terakhir, Anda membuat ekstensi di basis data. Anda dapat menggunakan Konsol Manajemen AWS atau AWS CLI untuk tugas-tugas ini.
Anda harus memiliki izin sebagai peran `rds_superuser` untuk melakukan semua tugas ini.
Langkah-langkah berikut mengasumsikan bahwa klaster DB Aurora PostgreSQL Anda terhubung dengan grup parameter DB . Untuk informasi cara membuat Grup parameter klaster DB, lihat [](USER_WorkingWithParamGroups.md).
## Konsol
**Menyiapkan ekstensi pglogical**
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Di panel navigasi, pilih Instans penulis klaster DB Aurora PostgreSQL .
1. Buka tab **Konfigurasi** untuk instans penulis klaster DB Aurora PostgreSQL. Di antara detail Instans, temukan tautan **Grup parameter**.
1. Pilih tautan untuk membuka parameter kustom yang terkait dengan klaster DB Aurora PostgreSQL Anda.
1. Di kolom pencarian **Parameter**, ketik `shared_pre` untuk menemukan parameter `shared_preload_libraries`.
1. Pilih **Edit parameter** untuk mengakses nilai properti.
1. Tambahkan `pglogical` ke daftar di kolom **Nilai**. Gunakan koma untuk memisahkan item dalam daftar nilai.
![\[Gambar parameter shared_preload_libraries dengan pglogical yang ditambahkan.\]](http://docs.aws.amazon.com/id_id/AmazonRDS/latest/AuroraUserGuide/images/apg_rpg_shared_preload_pglogical.png)
1. Temukan parameter `rds.logical_replication` dan atur ke `1`, untuk mengaktifkan replikasi logis.
1. Boot ulang instans penulis klaster DB Aurora PostgreSQL agar perubahan Anda diterapkan.
1. Saat instans tersedia, Anda dapat menggunakan `psql` (atau pgAdmin) untuk terhubung ke instans penulis klaster DB Aurora PostgreSQL
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
1. Untuk memverifikasi bahwa pglogical telah diinisialisasi, jalankan perintah berikut.
```
SHOW shared_preload_libraries;
shared_preload_libraries
--------------------------
rdsutils,pglogical
(1 row)
```
1. Verifikasikan pengaturan yang memungkinkan penguraian kode logis, sebagai berikut.
```
SHOW wal_level;
wal_level
-----------
logical
(1 row)
```
1. Buat ekstensi, sebagai berikut.
```
CREATE EXTENSION pglogical;
EXTENSION CREATED
```
1. Pilih **Simpan perubahan**.
1. Buka konsol Amazon RDS di [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Pilih instans penulis klaster DB Aurora PostgreSQL dari daftar Basis Data untuk memilihnya, lalu pilih **Boot ulang** dari menu Tindakan.
## AWS CLI
**Menyiapkan ekstensi pglogical**
Untuk mengatur pglogical menggunakan AWS CLI, Anda memanggil [modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html)operasi untuk memodifikasi parameter tertentu dalam grup parameter kustom Anda seperti yang ditunjukkan dalam prosedur berikut.
1. Gunakan AWS CLI perintah berikut `pglogical` untuk menambah `shared_preload_libraries` parameter.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name custom-param-group-name \
--parameters "ParameterName=shared_preload_libraries,ParameterValue=pglogical,ApplyMethod=pending-reboot" \
--region aws-region
```
1. Gunakan AWS CLI perintah berikut untuk mengatur `rds.logical_replication` `1` untuk mengaktifkan kemampuan decoding logis untuk instance penulis dari cluster DB PostgreSQL Aurora.
```
aws rds modify-db-parameter-group \
--db-parameter-group-name custom-param-group-name \
--parameters "ParameterName=rds.logical_replication,ParameterValue=1,ApplyMethod=pending-reboot" \
--region aws-region
```
1. Gunakan AWS CLI perintah berikut untuk me-reboot instance penulis Aurora PostgreSQL DB cluster RDS untuk instance PostgreSQL DB pglogical diinisialisasi.
```
aws rds reboot-db-instance \
--db-instance-identifier writer-instance \
--region aws-region
```
1. Saat instans tersedia, gunakan `psql` untuk terhubung ke instans penulis klaster DB Aurora PostgreSQL
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
1. Buat ekstensi, sebagai berikut.
```
CREATE EXTENSION pglogical;
EXTENSION CREATED
```
1. Reboot instance penulis Aurora PostgreSQL DB cluster instance PostgreSQL DB menggunakan perintah berikut. AWS CLI
```
aws rds reboot-db-instance \
--db-instance-identifier writer-instance \
--region aws-region
```
# Menyiapkan replikasi logis untuk klaster DB Aurora PostgreSQL
Prosedur berikut menunjukkan cara memulai replikasi logis di antara dua klaster DB Aurora PostgreSQL Langkah-langkah mengasumsikan bahwa sumber (penerbit) dan target (pelanggan) memiliki ekstensi `pglogical` yang disiapkan seperti yang dijelaskan dalam [Menyiapkan ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md).
**catatan**
`node_name`Node pelanggan tidak dapat memulai dengan`rds`.
**Untuk membuat simpul penerbit dan menentukan tabel untuk direplikasi**
Langkah-langkah ini mengasumsikan bahwa klaster DB Aurora PostgreSQL memiliki instans penulis dengan basis data yang memiliki satu atau beberapa tabel yang ingin direplikasi ke simpul lain. Anda perlu membuat ulang struktur tabel dari penerbit pada pelanggan, jadi pertama-tama, dapatkan struktur tabel jika perlu. Anda dapat melakukannya dengan menggunakan `psql` metacommand `\d tablename`, lalu membuat tabel yang sama pada instans pelanggan. Prosedur berikut membuat tabel contoh pada penerbit (sumber) untuk tujuan demonstrasi.
1. Gunakan `psql` untuk terhubung ke instans yang memiliki tabel yang ingin Anda gunakan sebagai sumber untuk pelanggan.
```
psql --host=source-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
Jika tidak memiliki tabel yang ingin ditiru, Anda dapat membuat tabel contoh sebagai berikut.
1. Buat contoh tabel menggunakan pernyataan SQL berikut.
```
CREATE TABLE docs_lab_table (a int PRIMARY KEY);
```
1. Mengisi tabel dengan data yang dihasilkan menggunakan pernyataan SQL berikut.
```
INSERT INTO docs_lab_table VALUES (generate_series(1,5000));
INSERT 0 5000
```
1. Verifikasikan bahwa data ada dalam tabel menggunakan pernyataan SQL berikut.
```
SELECT count(*) FROM docs_lab_table;
```
1. Identifikasi klaster DB Aurora PostgreSQL ini sebagai simpul penerbit, sebagai berikut.
```
SELECT pglogical.create_node(
node_name := 'docs_lab_provider',
dsn := 'host=source-instance.aws-region.rds.amazonaws.com port=5432 dbname=labdb');
create_node
-------------
3410995529
(1 row)
```
1. Tambahkan tabel yang ingin Anda replikasi ke set replikasi default. Untuk informasi set replikasi selengkapnya, lihat [Replication sets](https://github.com/2ndQuadrant/pglogical/tree/REL2_x_STABLE/docs#replication-sets) dalam dokumentasi pglogical.
```
SELECT pglogical.replication_set_add_table('default', 'docs_lab_table', 'true', NULL, NULL);
replication_set_add_table
---------------------------
t
(1 row)
```
Penyiapan simpul penerbit selesai. Anda sekarang dapat menyiapkan simpul pelanggan untuk menerima informasi terkini dari penerbit.
**Untuk menyiapkan simpul pelanggan dan membuat langganan untuk menerima informasi terkini**
Langkah-langkah ini mengasumsikan bahwa klaster DB Aurora PostgreSQL telah disiapkan dengan ekstensi `pglogical`. Untuk informasi selengkapnya, lihat [Menyiapkan ekstensi pglogical](Appendix.PostgreSQL.CommonDBATasks.pglogical.basic-setup.md).
1. Gunakan `psql` untuk terhubung ke instans yang ingin Anda terima informasi terkini dari penerbit.
```
psql --host=target-instance.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
1. Pada pelanggan klaster DB Aurora PostgreSQL, , buat tabel yang sama yang ada pada penerbit. Untuk contoh ini, tabelnya adalah `docs_lab_table`. Anda dapat membuat tabel sebagai berikut.
```
CREATE TABLE docs_lab_table (a int PRIMARY KEY);
```
1. Verifikasi bahwa tabel ini kosong.
```
SELECT count(*) FROM docs_lab_table;
count
-------
0
(1 row)
```
1. Identifikasi klaster DB Aurora PostgreSQL ini sebagai simpul pelanggan, sebagai berikut.
```
SELECT pglogical.create_node(
node_name := 'docs_lab_target',
dsn := 'host=target-instance.aws-region.rds.amazonaws.com port=5432 sslmode=require dbname=labdb user=postgres password=********');
create_node
-------------
2182738256
(1 row)
```
1. Buat langganan.
```
SELECT pglogical.create_subscription(
subscription_name := 'docs_lab_subscription',
provider_dsn := 'host=source-instance.aws-region.rds.amazonaws.com port=5432 sslmode=require dbname=labdb user=postgres password=*******',
replication_sets := ARRAY['default'],
synchronize_data := true,
forward_origins := '{}' );
create_subscription
---------------------
1038357190
(1 row)
```
Saat Anda menyelesaikan langkah ini, data dari tabel pada penerbit akan dibuat dalam tabel pada pelanggan. Anda dapat memverifikasi bahwa tabel telah dibuat menggunakan query SQL berikut.
```
SELECT count(*) FROM docs_lab_table;
count
-------
5000
(1 row)
```
Mulai dari titik ini, perubahan yang dilakukan pada tabel pada penerbit direplikasi ke tabel pada pelanggan.
# Membangun kembali replikasi logis setelah peningkatan besar
Sebelum Anda dapat melakukan upgrade versi utama dari cluster Aurora Postgre SQL DB RDS yang diatur sebagai node penerbit untuk replikasi logis, Anda harus menghapus semua slot replikasi, bahkan yang tidak aktif. Kami menyarankan Anda mengalihkan sementara transaksi database dari node penerbit, menjatuhkan slot replikasi, meningkatkan cluster Aurora Postgre SQL DB, meningkatkan instance Postgre DB RDS untuk SQL Postgre, kembali dan memulai ulang replikasi.
Slot replikasi hanya di-hosting di simpul penerbit. Node SQL pelanggan Aurora Postgre dalam skenario replikasi logis tidak memiliki slot untuk dijatuhkan. Proses upgrade versi SQL utama Aurora Postgre mendukung peningkatan pelanggan ke versi utama baru SQL Postgre independen dari node penerbit. Namun, proses upgrade memang mengganggu proses replikasi dan mengganggu sinkronisasi WAL data antara node penerbit dan node pelanggan. Anda perlu membangun kembali replikasi logis antara penerbit dan pelanggan setelah peningkatan penerbit, pelanggan, atau keduanya. Prosedur berikut menunjukkan kepada Anda cara menentukan bahwa replikasi telah terganggu dan cara mengatasi masalah tersebut.
## Menentukan bahwa replikasi logis telah terganggu
Anda dapat menentukan bahwa proses replikasi telah terganggu dengan menanyakan simpul penerbit atau simpul pelanggan, sebagai berikut.
**Untuk memeriksa simpul penerbit**
+ Gunakan `psql` untuk terhubung ke simpul penerbit, lalu buat kueri fungsi `pg_replication_slots`. Perhatikan nilai di kolom aktif. Biasanya, ini akan kembali `t` (benar), menunjukkan bahwa replikasi aktif. Jika kueri kembali `f` (salah), ini merupakan indikasi bahwa replikasi ke pelanggan telah berhenti.
```
SELECT slot_name,plugin,slot_type,active FROM pg_replication_slots;
slot_name | plugin | slot_type | active
-------------------------------------------+------------------+-----------+--------
pgl_labdb_docs_labcb4fa94_docs_lab3de412c | pglogical_output | logical | f
(1 row)
```
**Untuk memeriksa simpul pelanggan**
Pada simpul pelanggan, Anda dapat memeriksa status replikasi dengan tiga cara berbeda.
+ Lihat melalui SQL log Postgre pada node pelanggan untuk menemukan pesan kegagalan. Log dapat mengidentifikasi kegagalan dengan pesan yang menyertakan kode keluar 1, sebagaimana ditunjukkan berikut.
```
2022-07-06 16:17:03 UTC::@:[7361]:LOG: background worker "pglogical apply 16404:2880255011" (PID 14610) exited with exit code 1
2022-07-06 16:19:44 UTC::@:[7361]:LOG: background worker "pglogical apply 16404:2880255011" (PID 21783) exited with exit code 1
```
+ Buat kueri fungsi `pg_replication_origin`. Hubungkan ke basis data pada simpul pelanggan menggunakan `psql` dan buat kueri fungsi `pg_replication_origin`, sebagai berikut.
```
SELECT * FROM pg_replication_origin;
roident | roname
---------+--------
(0 rows)
```
Set hasil kosong berarti replikasi telah terganggu. Biasanya, Anda akan melihat output seperti berikut.
```
roident | roname
---------+----------------------------------------------------
1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c
(1 row)
```
+ Buat kueri fungsi `pglogical.show_subscription_status` sebagaimana ditunjukkan pada contoh berikut.
```
SELECT subscription_name,status,slot_name FROM pglogical.show_subscription_status();
subscription_name | status | slot_name
---====----------------+--------+-------------------------------------
docs_lab_subscription | down | pgl_labdb_docs_labcb4fa94_docs_lab3de412c
(1 row)
```
Output ini menunjukkan bahwa replikasi telah terganggu. Statusnya adalah `down`. Biasanya, output menunjukkan status sebagai `replicating`.
Jika proses replikasi logis terganggu, Anda dapat membangun kembali replikasi dengan mengikuti langkah-langkah berikut.
**Untuk membangun kembali replikasi logis antara simpul penerbit dan pelanggan**
Untuk membangun kembali replikasi, pertama-tama Anda memutuskan sambungan pelanggan dari simpul penerbit, lalu membangun kembali langganan, seperti yang diuraikan dalam langkah-langkah ini.
1. Hubungkan ke simpul pelanggan menggunakan `psql`, sebagai berikut.
```
psql --host=222222222222.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=labdb
```
1. Nonaktifkan langganan menggunakan fungsi `pglogical.alter_subscription_disable`.
```
SELECT pglogical.alter_subscription_disable('docs_lab_subscription',true);
alter_subscription_disable
----------------------------
t
(1 row)
```
1. Dapatkan identifier simpul penerbit dengan menanyakan `pg_replication_origin`, sebagai berikut.
```
SELECT * FROM pg_replication_origin;
roident | roname
---------+-------------------------------------
1 | pgl_labdb_docs_labcb4fa94_docs_lab3de412c
(1 row)
```
1. Gunakan respons dari langkah sebelumnya dengan perintah `pg_replication_origin_create` untuk menetapkan pengenal yang dapat digunakan oleh langganan saat dibuat kembali.
```
SELECT pg_replication_origin_create('pgl_labdb_docs_labcb4fa94_docs_lab3de412c');
pg_replication_origin_create
------------------------------
1
(1 row)
```
1. Aktifkan langganan dengan meneruskan namanya menggunakan status `true`, sebagaimana ditunjukkan dalam contoh berikut.
```
SELECT pglogical.alter_subscription_enable('docs_lab_subscription',true);
alter_subscription_enable
---------------------------
t
(1 row)
```
Periksa status simpul. Statusnya harus `replicating` sebagaimana ditunjukkan dalam contoh ini.
```
SELECT subscription_name,status,slot_name
FROM pglogical.show_subscription_status();
subscription_name | status | slot_name
-------------------------------+-------------+-------------------------------------
docs_lab_subscription | replicating | pgl_labdb_docs_lab98f517b_docs_lab3de412c
(1 row)
```
Periksa status slot replikasi pelanggan pada simpul penerbit. Kolom `active` slot harus kembali `t` (benar), menunjukkan bahwa replikasi telah dibuat kembali.
```
SELECT slot_name,plugin,slot_type,active
FROM pg_replication_slots;
slot_name | plugin | slot_type | active
-------------------------------------------+------------------+-----------+--------
pgl_labdb_docs_lab98f517b_docs_lab3de412c | pglogical_output | logical | t
(1 row)
```
# Mengelola slot replikasi logis untuk Aurora PostgreSQL RDS
Sebelum dapat melakukan peningkatan versi utama dari instans penulis klaster DB Aurora PostgreSQL yang disiapkan sebagai simpul penerbit untuk replikasi logis, Anda harus menghapus semua slot replikasi, bahkan yang tidak aktif. Proses pra-pemeriksaan peningkatan versi utama akan memberi tahu Anda bahwa peningkatan tidak dapat dilanjutkan sampai slot dihapuskan sementara.
Untuk mengidentifikasi slot replikasi yang dibuat menggunakan ekstensi `pglogical`, masuk ke setiap basis data dan dapatkan nama simpul. Bila membuat kueri simpul pelanggan, Anda akan mendapatkan simpul penerbit dan pelanggan dalam output, sebagaimana ditunjukkan dalam contoh ini.
```
SELECT * FROM pglogical.node;
node_id | node_name
------------+-------------------
2182738256 | docs_lab_target
3410995529 | docs_lab_provider
(2 rows)
```
Anda dapat memperoleh detail tentang langganan dengan kueri berikut.
```
SELECT sub_name,sub_slot_name,sub_target
FROM pglogical.subscription;
sub_name | sub_slot_name | sub_target
----------+--------------------------------+------------
docs_lab_subscription | pgl_labdb_docs_labcb4fa94_docs_lab3de412c | 2182738256
(1 row)
```
Anda sekarang dapat menghapus sementara langganan, sebagai berikut.
```
SELECT pglogical.drop_subscription(subscription_name := 'docs_lab_subscription');
drop_subscription
-------------------
1
(1 row)
```
Setelah menghapus sementara langganan, Anda dapat menghapus simpul.
```
SELECT pglogical.drop_node(node_name := 'docs-lab-subscriber');
drop_node
-----------
t
(1 row)
```
Anda dapat memverifikasi bahwa simpul tidak ada lagi, sebagai berikut.
```
SELECT * FROM pglogical.node;
node_id | node_name
---------+-----------
(0 rows)
```
# Referensi parameter untuk ekstensi pglogical
Dalam tabel, Anda dapat menemukan parameter yang terkait dengan ekstensi `pglogical`. Parameter seperti `pglogical.conflict_log_level` dan `pglogical.conflict_resolution` digunakan untuk menangani konflik pembaruan. Konflik dapat muncul saat perubahan dilakukan secara lokal ke tabel yang sama yang berlangganan terhadap perubahan dari penerbit. Konflik juga dapat terjadi selama berbagai skenario, seperti replikasi dua arah atau saat beberapa pelanggan mereplikasi dari penerbit yang sama. Untuk informasi selengkapnya, lihat [replikasi bi-direksional PostgreSQL menggunakan pglogical](https://aws.amazon.com/blogs/database/postgresql-bi-directional-replication-using-pglogical/).
| Parameter | Deskripsi |
| --- | --- |
| pglogical.batch\$1inserts | Melakukan penyisipan batch jika memungkinkan. Tidak diatur secara default. Ubah ke '1' untuk mengaktifkan, '0' untuk menonaktifkan. |
| pglogical.conflict\$1log\$1level | Menetapkan tingkat log yang digunakan untuk mencatat log konflik yang diselesaikan. Nilai string yang didukung adalah debug5, debug4, debug3, debug2, debug1, info, notice, warning, error, log, fatal, panic. |
| pglogical.conflict\$1resolution | Menetapkan metode yang digunakan untuk menyelesaikan konflik saat konflik dapat diselesaikan. Nilai string yang didukung adalah kesalahan, apply\$1remote, keep\$1local, last\$1update\$1wins, first\$1update\$1wins. |
| pglogical.extra\$1connection\$1options | Opsi koneksi untuk ditambahkan ke semua koneksi simpul peer. |
| pglogical.synchronous\$1commit | nilai komit sinkron spesifik pglogical |
| pglogical.use\$1spi | Gunakan SPI (antarmuka pemrograman server) alih-alih API tingkat rendah untuk menerapkan perubahan. Atur ke '1' untuk mengaktifkan, '0' untuk menonaktifkan. Untuk informasi SPI selengkapnya, lihat [Server Programming Interface](https://www.postgresql.org/docs/current/spi.html) dalam dokumentasi PostgreSQL. |