Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# RDSuntuk referensi prosedur SQL tersimpan saya
Topik ini menjelaskan prosedur tersimpan sistem yang tersedia untuk RDS instans Amazon yang menjalankan mesin My SQL DB. Pengguna utama harus menjalankan prosedur ini.
**Topics**
+ [
# Mengumpulkan dan memelihara Sejarah Status Global
](mysql-stored-proc-gsh.md)
+ [
# Mengkonfigurasi, memulai, dan menghentikan replikasi log biner (binlog)
](mysql-stored-proc-replicating.md)
+ [
# Mengakhiri sesi atau kueri
](mysql-stored-proc-ending.md)
+ [
# Mengelola klaster aktif-aktif
](mysql-stored-proc-active-active-clusters.md)
+ [
# Mengelola replikasi multi-sumber
](mysql-stored-proc-multi-source-replication.md)
+ [
# Mereplikasi transaksi menggunakan GTIDs
](mysql-stored-proc-gtid.md)
+ [
# Memutar log kueri
](mysql-stored-proc-logging.md)
+ [
# Mengatur dan menampilkan konfigurasi log biner
](mysql-stored-proc-configuring.md)
+ [
# Pemanasan cache InnoDB
](mysql-stored-proc-warming.md)
# Mengumpulkan dan memelihara Sejarah Status Global
Amazon RDS menyediakan serangkaian prosedur yang mengambil snapshot dari nilai variabel status dari waktu ke waktu dan menuliskannya ke tabel, bersama dengan perubahan apa pun sejak snapshot terakhir. Infrastruktur ini disebut Global Status History. Untuk informasi selengkapnya, lihat [Mengelola Riwayat Status Global untuk RDS untuk MySQL](Appendix.MySQL.CommonDBATasks.GoSH.md).
Prosedur tersimpan berikut mengelola bagaimana Global Status History dikumpulkan dan dipelihara.
**Topics**
+ [
## mysql.rds\$1collect\$1global\$1status\$1history
](#mysql_rds_collect_global_status_history)
+ [
## mysql.rds\$1disable\$1gsh\$1collector
](#mysql_rds_disable_gsh_collector)
+ [
## mysql.rds\$1disable\$1gsh\$1rotation
](#mysql_rds_disable_gsh_rotation)
+ [
## mysql.rds\$1enable\$1gsh\$1collector
](#mysql_rds_enable_gsh_collector)
+ [
## mysql.rds\$1enable\$1gsh\$1rotation
](#mysql_rds_enable_gsh_rotation)
+ [
## mysql.rds\$1rotate\$1global\$1status\$1history
](#mysql_rds_rotate_global_status_history)
+ [
## mysql.rds\$1set\$1gsh\$1collector
](#mysql_rds_set_gsh_collector)
+ [
## mysql.rds\$1set\$1gsh\$1rotation
](#mysql_rds_set_gsh_rotation)
## mysql.rds\$1collect\$1global\$1status\$1history
Mengambil snapshot sesuai permintaan untuk Global Status History.
### Sintaks
```
CALL mysql.rds_collect_global_status_history;
```
## mysql.rds\$1disable\$1gsh\$1collector
Menonaktifkan snapshot yang diambil oleh Global Status History.
### Sintaks
```
CALL mysql.rds_disable_gsh_collector;
```
## mysql.rds\$1disable\$1gsh\$1rotation
Menonaktifkan rotasi tabel `mysql.global_status_history`.
### Sintaks
```
CALL mysql.rds_disable_gsh_rotation;
```
## mysql.rds\$1enable\$1gsh\$1collector
Mengaktifkan Global Status History untuk mengambil snapshot default pada interval yang ditentukan oleh `rds_set_gsh_collector`.
### Sintaks
```
CALL mysql.rds_enable_gsh_collector;
```
## mysql.rds\$1enable\$1gsh\$1rotation
Mengaktifkan rotasi konten tabel `mysql.global_status_history` ke `mysql.global_status_history_old` pada interval yang ditentukan oleh `rds_set_gsh_rotation`.
### Sintaks
```
CALL mysql.rds_enable_gsh_rotation;
```
## mysql.rds\$1rotate\$1global\$1status\$1history
Merotasi konten tabel `mysql.global_status_history` ke `mysql.global_status_history_old` sesuai permintaan.
### Sintaks
```
CALL mysql.rds_rotate_global_status_history;
```
## mysql.rds\$1set\$1gsh\$1collector
Menentukan interval, dalam menit, di antara snapshot yang diambil oleh Global Status History.
### Sintaks
```
CALL mysql.rds_set_gsh_collector(intervalPeriod);
```
### Parameter
*intervalPeriod*
Interval, dalam menit, di antara snapshot. Nilai default-nya adalah `5`.
## mysql.rds\$1set\$1gsh\$1rotation
Menentukan interval, dalam hari, antara rotasi tabel `mysql.global_status_history`.
### Sintaks
```
CALL mysql.rds_set_gsh_rotation(intervalPeriod);
```
### Parameter
*intervalPeriod*
Interval, dalam hari, di antara rotasi tabel. Nilai default-nya adalah `7`.
# Mengkonfigurasi, memulai, dan menghentikan replikasi log biner (binlog)
Prosedur tersimpan berikut mengontrol bagaimana transaksi direplikasi dari basis data eksternal ke dalam RDS for MySQL, atau dari RDS for MySQL ke basis data eksternal.
Saat menggunakan prosedur tersimpan ini untuk mengelola replikasi dengan pengguna replikasi yang dikonfigurasi`caching_sha2_password`, Anda harus mengonfigurasi TLS dengan menentukan. `SOURCE_SSL=1` `caching_sha2_password`adalah plugin otentikasi default untuk RDS untuk MySQL 8.4 Untuk informasi lebih lanjut, lihat. [Mengenkripsi dengan SSL/TLS](mysql-ssl-connections.md)
Untuk informasi tentang mengonfigurasi, menggunakan, dan mengelola replika baca, lihat. [Menggunakan replika baca MySQL](USER_MySQL.Replication.ReadReplicas.md)
**Topics**
+ [
##
](#mysql_rds_next_master_log)
+ [
##
](#mysql_rds_next_source_log)
+ [
##
](#mysql_rds_reset_external_master)
+ [
##
](#mysql_rds_reset_external_source)
+ [
##
](#mysql_rds_set_external_master)
+ [
##
](#mysql_rds_set_external_source)
+ [
## mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS untuk MySQL versi utama 8.0 dan lebih rendah)
](#mysql_rds_set_external_master_with_auto_position)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS untuk MySQL mayor versi 8.4 dan lebih tinggi)
](#mysql_rds_set_external_source_with_auto_position)
+ [
## mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS untuk MariaDB dan RDS untuk MySQL mayor versi 8.0 dan lebih rendah)
](#mysql_rds_set_external_master_with_delay)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS untuk MySQL mayor versi 8.4 dan lebih tinggi)
](#mysql_rds_set_external_source_with_delay)
+ [
## mysql.rds\$1set\$1external\$1source\$1gtid\$1purged
](#mysql_rds_set_external_source_gtid_purged)
+ [
##
](#mysql_rds_set_master_auto_position)
+ [
##
](#mysql_rds_set_source_auto_position)
+ [
## mysql.rds\$1set\$1source\$1delay
](#mysql_rds_set_source_delay)
+ [
## mysql.rds\$1skip\$1repl\$1error
](#mysql_rds_skip_repl_error)
+ [
## mysql.rds\$1start\$1replication
](#mysql_rds_start_replication)
+ [
##
](#mysql_rds_start_replication_until)
+ [
## mysql.rds\$1stop\$1replication
](#mysql_rds_stop_replication)
##
Mengubah posisi log instans basis data sumber menjadi awal log biner berikutnya pada instans basis data sumber. Gunakan prosedur ini hanya jika Anda menerima I/O kesalahan replikasi 1236 pada replika baca.
### Sintaks
```
CALL mysql.rds_next_master_log(
curr_master_log
);
```
### Parameter
*curr\$1master\$1log*
Indeks file log master saat ini. Misalnya, jika file saat ini bernama `mysql-bin-changelog.012345`, maka indeksnya adalah 12345. Untuk menentukan nama file log master saat ini, jalankan perintah `SHOW REPLICA STATUS` dan lihat kolom `Master_Log_File`.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_next_master_log`.
**Awas**
Panggil `mysql.rds_next_master_log` hanya jika replikasi gagal setelah failover instans DB multi-AZ yang merupakan sumber replikasi, dan `Last_IO_Errno` bidang laporan kesalahan 1236. `SHOW REPLICA STATUS` I/O
Memanggil `mysql.rds_next_master_log` dapat mengakibatkan hilangnya data di replika baca jika transaksi dalam instans sumber tidak ditulis ke log biner di disk sebelum peristiwa failover terjadi. Anda dapat mengurangi kemungkinan hal ini terjadi dengan menyetel parameter instance sumber `sync_binlog` dan `innodb_support_xa` ke`1`, meskipun ini dapat mengurangi kinerja. Untuk informasi selengkapnya, lihat [Memecahkan masalah replika SQL baca saya](USER_ReadRepl.Troubleshooting.md).
### Contoh
Asumsikan replikasi gagal pada replika baca RDS for MySQL. Menjalankan `SHOW REPLICA STATUS\G` pada replika baca akan menampilkan hasil berikut:
```
*************************** 1. row ***************************
Replica_IO_State:
Source_Host: myhost.XXXXXXXXXXXXXXX.rr-rrrr-1.rds.amazonaws.com
Source_User: MasterUser
Source_Port: 3306
Connect_Retry: 10
Source_Log_File: mysql-bin-changelog.012345
Read_Source_Log_Pos: 1219393
Relay_Log_File: relaylog.012340
Relay_Log_Pos: 30223388
Relay_Source_Log_File: mysql-bin-changelog.012345
Replica_IO_Running: No
Replica_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Source_Log_Pos: 30223232
Relay_Log_Space: 5248928866
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Source_SSL_Allowed: No
Source_SSL_CA_File:
Source_SSL_CA_Path:
Source_SSL_Cert:
Source_SSL_Cipher:
Source_SSL_Key:
Seconds_Behind_Master: NULL
Source_SSL_Verify_Server_Cert: No
Last_IO_Errno: 1236
Last_IO_Error: Got fatal error 1236 from master when reading data from binary log: 'Client requested master to start replication from impossible position; the first event 'mysql-bin-changelog.013406' at 1219393, the last event read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4, the last byte read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4.'
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Source_Server_Id: 67285976
```
Kolom `Last_IO_Errno` menunjukkan bahwa instans menerima kesalahan I/O 1236. Kolom `Master_Log_File` menunjukkan bahwa nama file adalah `mysql-bin-changelog.012345`, yang berarti indeks file log adalah `12345`. Untuk mengatasi kesalahan, Anda dapat memanggil `mysql.rds_next_master_log` dengan parameter berikut:
```
CALL mysql.rds_next_master_log(12345);
```
##
Mengubah posisi log instans basis data sumber menjadi awal log biner berikutnya pada instans basis data sumber. Gunakan prosedur ini hanya jika Anda menerima I/O kesalahan replikasi 1236 pada replika baca.
### Sintaks
```
CALL mysql.rds_next_source_log(
curr_source_log
);
```
### Parameter
*curr\$1source\$1log*
Indeks file log sumber saat ini. Misalnya, jika file saat ini bernama `mysql-bin-changelog.012345`, maka indeksnya adalah 12345. Untuk menentukan nama file log sumber saat ini, jalankan perintah `SHOW REPLICA STATUS` dan lihat kolom `Source_Log_File`.
### Catatan penggunaan
Pengguna administratif harus menjalankan prosedur `mysql.rds_next_source_log`.
**Awas**
Panggil `mysql.rds_next_source_log` hanya jika replikasi gagal setelah failover instans DB multi-AZ yang merupakan sumber replikasi, dan `Last_IO_Errno` bidang laporan kesalahan 1236. `SHOW REPLICA STATUS` I/O
Memanggil `mysql.rds_next_source_log` dapat mengakibatkan hilangnya data di replika baca jika transaksi dalam instans sumber tidak ditulis ke log biner di disk sebelum peristiwa failover terjadi. Anda dapat mengurangi kemungkinan hal ini terjadi dengan menyetel parameter instance sumber `sync_binlog` dan `innodb_support_xa` ke`1`, meskipun ini dapat mengurangi kinerja. Untuk informasi selengkapnya, lihat [Memecahkan masalah replika SQL baca saya](USER_ReadRepl.Troubleshooting.md).
### Contoh
Asumsikan replikasi gagal pada replika baca RDS for MySQL. Menjalankan `SHOW REPLICA STATUS\G` pada replika baca akan menampilkan hasil berikut:
```
*************************** 1. row ***************************
Replica_IO_State:
Source_Host: myhost.XXXXXXXXXXXXXXX.rr-rrrr-1.rds.amazonaws.com
Source_User: MasterUser
Source_Port: 3306
Connect_Retry: 10
Source_Log_File: mysql-bin-changelog.012345
Read_Source_Log_Pos: 1219393
Relay_Log_File: relaylog.012340
Relay_Log_Pos: 30223388
Relay_Source_Log_File: mysql-bin-changelog.012345
Replica_IO_Running: No
Replica_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table:
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Source_Log_Pos: 30223232
Relay_Log_Space: 5248928866
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Source_SSL_Allowed: No
Source_SSL_CA_File:
Source_SSL_CA_Path:
Source_SSL_Cert:
Source_SSL_Cipher:
Source_SSL_Key:
Seconds_Behind_Source: NULL
Source_SSL_Verify_Server_Cert: No
Last_IO_Errno: 1236
Last_IO_Error: Got fatal error 1236 from source when reading data from binary log: 'Client requested source to start replication from impossible position; the first event 'mysql-bin-changelog.013406' at 1219393, the last event read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4, the last byte read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4.'
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Source_Server_Id: 67285976
```
Kolom `Last_IO_Errno` menunjukkan bahwa instans menerima kesalahan I/O 1236. Kolom `Source_Log_File` menunjukkan bahwa nama file adalah `mysql-bin-changelog.012345`, yang berarti indeks file log adalah `12345`. Untuk mengatasi kesalahan, Anda dapat memanggil `mysql.rds_next_source_log` dengan parameter berikut:
```
CALL mysql.rds_next_source_log(12345);
```
##
Mengonfigurasi ulang instans DB RDS for MySQL agar tidak lagi menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaks
```
CALL mysql.rds_reset_external_master;
```
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_reset_external_master`. Prosedur ini harus dijalankan pada instans DB MySQL agar dihapus sebagai replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
**catatan**
Kami menyarankan Anda menggunakan replikasi baca untuk mengelola replikasi antara dua instans DB Amazon RDS jika memungkinkan. Saat Anda melakukannya, sebaiknya hanya gunakan replika baca ini dan prosedur tersimpan terkait replikasi lainnya. Praktik ini memungkinkan topologi replikasi yang lebih kompleks antara instans DB Amazon RDS. Kami menawarkan prosedur tersimpan ini terutama untuk mengaktifkan replikasi dengan instans MySQL yang berjalan di luar Amazon RDS. Untuk informasi tentang mengelola replikasi di antara instans DB Amazon RDS, lihat [Menggunakan replika baca instans DB](USER_ReadRepl.md).
Untuk informasi selengkapnya tentang cara menggunakan replikasi untuk mengimpor data dari instans MySQL yang berjalan di luar Amazon RDS, lihat [Mengonfigurasi replikasi posisi file log biner dengan instans sumber eksternal](MySQL.Procedural.Importing.External.Repl.md).
##
Mengonfigurasi ulang instans DB RDS for MySQL agar tidak lagi menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaks
```
CALL mysql.rds_reset_external_source;
```
### Catatan penggunaan
Pengguna administratif harus menjalankan prosedur `mysql.rds_reset_external_source`. Prosedur ini harus dijalankan pada instans DB MySQL agar dihapus sebagai replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
**catatan**
Kami menyarankan Anda menggunakan replikasi baca untuk mengelola replikasi antara dua instans DB Amazon RDS jika memungkinkan. Saat Anda melakukannya, sebaiknya hanya gunakan replika baca ini dan prosedur tersimpan terkait replikasi lainnya. Praktik ini memungkinkan topologi replikasi yang lebih kompleks antara instans DB Amazon RDS. Kami menawarkan prosedur tersimpan ini terutama untuk mengaktifkan replikasi dengan instans MySQL yang berjalan di luar Amazon RDS.
Untuk informasi tentang mengelola replikasi di antara instans DB Amazon RDS, lihat [Menggunakan replika baca instans DB](USER_ReadRepl.md). Untuk informasi selengkapnya tentang menggunakan replikasi untuk mengimpor data dari instans MySQL yang berjalan di luar Amazon RDS, lihat [Mengonfigurasi replikasi posisi file log biner dengan instans sumber eksternal](MySQL.Procedural.Importing.External.Repl.md).
##
Mengonfigurasi instans DB RDS for MySQL agar tidak lagi menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
**catatan**
Anda bisa menggunakan prosedur tersimpan [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS untuk MariaDB dan RDS untuk MySQL mayor versi 8.0 dan lebih rendah)](#mysql_rds_set_external_master_with_delay) untuk mengonfigurasi instans basis data sumber eksternal dan replikasi tertunda.
### Sintaks
```
CALL mysql.rds_set_external_master (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
);
```
### Parameter
*host\$1name*
Nama host atau alamat IP instans MySQL yang berjalan di luar Amazon RDS untuk menjadi instans basis data sumber.
*host\$1port*
Port yang digunakan oleh instans MySQL yang berjalan di luar Amazon RDS untuk dikonfigurasi sebagai instans basis data sumber. Jika konfigurasi jaringan Anda mencakup replikasi port Secure Shell (SSH) yang mengubah nomor port, tentukan nomor port yang diekspos oleh SSH.
*replication\$1user\$1name*
ID pengguna dengan izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans MySQL yang berjalan di luar Amazon RDS. Kami menyarankan Anda memberikan akun yang digunakan sepenuhnya untuk replikasi dengan instans eksternal.
*replication\$1user\$1password*
Kata sandi ID pengguna yang ditentukan dalam `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nama log biner pada instans basis data sumber yang berisi informasi replikasi.
*mysql\$1binary\$1log\$1file\$1location*
Lokasi di log biner `mysql_binary_log_file_name` tempat replikasi mulai membaca informasi replikasi.
Anda dapat menentukan nama dan lokasi file binlog dengan menjalankan `SHOW MASTER STATUS` pada instans basis data sumber.
*ssl\$1encryption*
Nilai yang menentukan apakah enkripsi Lapisan Soket Aman (SSL) digunakan pada sambungan replikasi. 1 menentukan untuk menggunakan enkripsi SSL, 0 menentukan untuk tidak menggunakan enkripsi. Default-nya adalah 0.
Opsi `MASTER_SSL_VERIFY_SERVER_CERT` tidak didukung. Opsi ini diatur ke 0, yang berarti koneksi dienkripsi, tetapi sertifikat tidak diverifikasi.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_set_external_master`. Prosedur ini harus dijalankan pada instans DB MySQL untuk dikonfigurasi sebagai replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
Sebelum menjalankan `mysql.rds_set_external_master`, Anda harus mengonfigurasi instans MySQL yang berjalan di luar Amazon RDS menjadi instans basis data sumber. Untuk terhubung ke instans MySQL yang berjalan di luar Amazon RDS, Anda harus menentukan nilai `replication_user_name` dan `replication_user_password` yang menunjukkan pengguna replikasi yang memiliki izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans eksternal MySQL.
**Untuk mengonfigurasi instans eksternal MySQL sebagai instans basis data sumber**
1. Dengan menggunakan klien MySQL pilihan Anda, hubungkan ke instans eksternal MySQL dan buat akun pengguna yang akan digunakan untuk replikasi. Berikut adalah contohnya.
**MySQL 5.7**
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**MySQL 8.0**
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED WITH mysql_native_password BY 'password';
```
**catatan**
Tetapkan kata sandi selain penggugah (prompt) yang ditampilkan di sini sebagai praktik terbaik keamanan.
1. Pada instans eksternal MySQL, berikan hak istimewa `REPLICATION CLIENT` dan `REPLICATION SLAVE` kepada pengguna replikasi Anda. Contoh berikut memberikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada semua basis data untuk pengguna ‘repl\$1user’ domain Anda.
**MySQL 5.7**
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**MySQL 8.0**
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
Untuk menggunakan replikasi terenkripsi, konfigurasikan instans basis data sumber untuk menggunakan koneksi SSL.
**catatan**
Kami menyarankan Anda menggunakan replikasi baca untuk mengelola replikasi antara dua instans DB Amazon RDS jika memungkinkan. Saat Anda melakukannya, sebaiknya hanya gunakan replika baca ini dan prosedur tersimpan terkait replikasi lainnya. Praktik ini memungkinkan topologi replikasi yang lebih kompleks antara instans DB Amazon RDS. Kami menawarkan prosedur tersimpan ini terutama untuk mengaktifkan replikasi dengan instans MySQL yang berjalan di luar Amazon RDS. Untuk informasi tentang mengelola replikasi di antara instans DB Amazon RDS, lihat [Menggunakan replika baca instans DB](USER_ReadRepl.md).
Setelah memanggil `mysql.rds_set_external_master` untuk mengonfigurasi instans DB Amazon RDS sebagai replika baca, Anda dapat memanggil [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) pada replika baca untuk memulai proses replikasi. Anda dapat memanggil [](#mysql_rds_reset_external_master) untuk menghapus konfigurasi replika baca.
Saat `mysql.rds_set_external_master` dipanggil, Amazon RDS mencatat waktu, pengguna, dan tindakan `set master` di tabel `mysql.rds_history` dan `mysql.rds_replication_status`.
### Contoh
Ketika dijalankan pada instans DB MySQL, contoh berikut mengonfigurasi instans DB menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
```
call mysql.rds_set_external_master(
'Externaldb.some.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.0777',
120,
1);
```
##
Mengonfigurasi instans DB RDS for MySQL agar tidak lagi menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaks
```
CALL mysql.rds_set_external_source (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
);
```
### Parameter
*host\$1name*
Nama host atau alamat IP instans MySQL yang berjalan di luar Amazon RDS untuk menjadi instans basis data sumber.
*host\$1port*
Port yang digunakan oleh instans MySQL yang berjalan di luar Amazon RDS untuk dikonfigurasi sebagai instans basis data sumber. Jika konfigurasi jaringan Anda mencakup replikasi port Secure Shell (SSH) yang mengubah nomor port, tentukan nomor port yang diekspos oleh SSH.
*replication\$1user\$1name*
ID pengguna dengan izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans MySQL yang berjalan di luar Amazon RDS. Kami menyarankan Anda memberikan akun yang digunakan sepenuhnya untuk replikasi dengan instans eksternal.
*replication\$1user\$1password*
Kata sandi ID pengguna yang ditentukan dalam `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nama log biner pada instans basis data sumber yang berisi informasi replikasi.
*mysql\$1binary\$1log\$1file\$1location*
Lokasi di log biner `mysql_binary_log_file_name` tempat replikasi mulai membaca informasi replikasi.
Anda dapat menentukan nama dan lokasi file binlog dengan menjalankan `SHOW MASTER STATUS` pada instans basis data sumber.
*ssl\$1encryption*
Nilai yang menentukan apakah enkripsi Lapisan Soket Aman (SSL) digunakan pada sambungan replikasi. 1 menentukan untuk menggunakan enkripsi SSL, 0 menentukan untuk tidak menggunakan enkripsi. Standarnya adalah 0.
Opsi `SOURCE_SSL_VERIFY_SERVER_CERT` tidak didukung. Opsi ini diatur ke 0, yang berarti koneksi dienkripsi, tetapi sertifikat tidak diverifikasi.
### Catatan penggunaan
Pengguna administratif harus menjalankan prosedur `mysql.rds_set_external_source`. Prosedur ini harus dijalankan pada DB dikonfigurasi sebagai replika baca instance MySQL yang berjalan di luar Amazon RDS.
Sebelum menjalankan `mysql.rds_set_external_source`, Anda harus mengonfigurasi instans MySQL yang berjalan di luar Amazon RDS menjadi instans basis data sumber. Untuk terhubung ke instans MySQL yang berjalan di luar Amazon RDS, Anda harus menentukan nilai `replication_user_name` dan `replication_user_password` yang menunjukkan pengguna replikasi yang memiliki izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans eksternal MySQL.
**Untuk mengonfigurasi instans eksternal MySQL sebagai instans basis data sumber**
1. Dengan menggunakan klien MySQL pilihan Anda, hubungkan ke instans eksternal MySQL dan buat akun pengguna yang akan digunakan untuk replikasi. Berikut sebuah contoh.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**catatan**
Tetapkan kata sandi selain penggugah (prompt) yang ditampilkan di sini sebagai praktik terbaik keamanan.
1. Pada instans eksternal MySQL, berikan hak istimewa `REPLICATION CLIENT` dan `REPLICATION SLAVE` kepada pengguna replikasi Anda. Contoh berikut memberikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada semua basis data untuk pengguna ‘repl\$1user’ domain Anda.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
Untuk menggunakan replikasi terenkripsi, konfigurasikan instans basis data sumber untuk menggunakan koneksi SSL. Selain itu, impor sertifikat otoritas sertifikat, sertifikat klien, dan kunci klien ke dalam instans DB atau klaster DB menggunakan prosedur [mysql.rds\$1import\$1binlog\$1ssl\$1material](url-rds-user;mysql_rds_import_binlog_ssl_material.html).
**catatan**
Kami menyarankan Anda menggunakan replikasi baca untuk mengelola replikasi antara dua instans DB Amazon RDS jika memungkinkan. Saat Anda melakukannya, sebaiknya hanya gunakan replika baca ini dan prosedur tersimpan terkait replikasi lainnya. Praktik ini memungkinkan topologi replikasi yang lebih kompleks antara instans DB Amazon RDS. Kami menawarkan prosedur tersimpan ini terutama untuk mengaktifkan replikasi dengan instans MySQL yang berjalan di luar Amazon RDS. Untuk informasi tentang mengelola replikasi di antara instans DB Amazon RDS, lihat [Menggunakan replika baca instans DB](USER_ReadRepl.md).
Setelah memanggil `mysql.rds_set_external_source` untuk mengkonfigurasi DB instance sebagai replika baca, Anda dapat memanggil replika baca untuk memulai proses replikasi. [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) Anda dapat memanggil [](#mysql_rds_reset_external_source) untuk menghapus konfigurasi replika baca.
Saat `mysql.rds_set_external_source` dipanggil, Amazon RDS mencatat waktu, pengguna, dan tindakan `set master` di tabel `mysql.rds_history` dan `mysql.rds_replication_status`.
### Contoh
Ketika dijalankan pada DB, contoh berikut mengonfigurasi instans DB menjadi replika baca dari instance MySQL yang berjalan eksternal ke Amazon RDS.
```
call mysql.rds_set_external_source(
'Externaldb.some.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.0777',
120,
1);
```
## mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS untuk MySQL versi utama 8.0 dan lebih rendah)
Mengonfigurasi instans DB RDS for MySQL menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS. Prosedur ini juga mengonfigurasi replikasi dan replikasi yang tertunda berdasarkan pengidentifikasi transaksi global (). GTIDs
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaks
```
CALL mysql.rds_set_external_master_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
);
```
### Parameter
*host\$1name*
Nama host atau alamat IP instans MySQL yang berjalan di luar Amazon RDS untuk menjadi instans basis data sumber.
*host\$1port*
Port yang digunakan oleh instans MySQL yang berjalan di luar Amazon RDS untuk dikonfigurasi sebagai instans basis data sumber. Jika konfigurasi jaringan Anda mencakup replikasi port Secure Shell (SSH) yang mengubah nomor port, tentukan nomor port yang diekspos oleh SSH.
*replication\$1user\$1name*
ID pengguna dengan izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans MySQL yang berjalan di luar Amazon RDS. Kami menyarankan Anda memberikan akun yang digunakan sepenuhnya untuk replikasi dengan instans eksternal.
*replication\$1user\$1password*
Kata sandi ID pengguna yang ditentukan dalam `replication_user_name`.
*ssl\$1encryption*
Nilai yang menentukan apakah enkripsi Lapisan Soket Aman (SSL) digunakan pada sambungan replikasi. 1 menentukan untuk menggunakan enkripsi SSL, 0 menentukan untuk tidak menggunakan enkripsi. Default-nya adalah 0.
Opsi `MASTER_SSL_VERIFY_SERVER_CERT` tidak didukung. Opsi ini diatur ke 0, yang berarti koneksi dienkripsi, tetapi sertifikat tidak diverifikasi.
*delay*
Jumlah detik minimum untuk menunda replikasi dari instans basis data sumber.
Batas untuk parameter ini adalah satu hari (86.400 detik).
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_set_external_master_with_auto_position`. Prosedur ini harus dijalankan pada instans DB MySQL untuk dikonfigurasi sebagai replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
Prosedur ini didukung untuk semua versi RDS for MySQL 5.7, dan RDS for MySQL 8.0.26, dan versi 8.0 yang lebih tinggi.
Sebelum menjalankan `mysql.rds_set_external_master_with_auto_position`, Anda harus mengonfigurasi instans MySQL yang berjalan di luar Amazon RDS menjadi instans basis data sumber. Untuk terhubung ke instans MySQL yang berjalan di luar Amazon RDS, Anda harus menentukan nilai untuk `replication_user_name` dan `replication_user_password`. Nilai-nilai ini harus menunjukkan pengguna replikasi yang memiliki izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans external MySQL.
**Untuk mengonfigurasi instans eksternal MySQL sebagai instans basis data sumber**
1. Dengan menggunakan klien MySQL pilihan Anda, hubungkan ke instans eksternal MySQL dan buat akun pengguna yang akan digunakan untuk replikasi. Berikut adalah contohnya.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Pada instans eksternal MySQL, berikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` kepada pengguna replikasi Anda. Contoh berikut memberikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada semua basis data untuk pengguna `'repl_user'` domain Anda.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Untuk informasi selengkapnya, lihat [Mengonfigurasi replikasi posisi file log biner dengan instans sumber eksternal](MySQL.Procedural.Importing.External.Repl.md).
**catatan**
Kami menyarankan Anda menggunakan replikasi baca untuk mengelola replikasi antara dua instans DB Amazon RDS jika memungkinkan. Saat Anda melakukannya, sebaiknya hanya gunakan replika baca ini dan prosedur tersimpan terkait replikasi lainnya. Praktik ini memungkinkan topologi replikasi yang lebih kompleks antara instans DB Amazon RDS. Kami menawarkan prosedur tersimpan ini terutama untuk mengaktifkan replikasi dengan instans MySQL yang berjalan di luar Amazon RDS. Untuk informasi tentang mengelola replikasi di antara instans DB Amazon RDS, lihat [Menggunakan replika baca instans DB](USER_ReadRepl.md).
Sebelum Anda menelepon`mysql.rds_set_external_master_with_auto_position`, pastikan untuk memanggil [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged) untuk mengatur variabel `gtid_purged` sistem dengan rentang GTID tertentu dari sumber eksternal.
Setelah memanggil `mysql.rds_set_external_master_with_auto_position` untuk mengonfigurasi instans DB Amazon RDS sebagai replika baca, Anda dapat memanggil [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) pada replika baca untuk memulai proses replikasi. Anda dapat memanggil [](#mysql_rds_reset_external_master) untuk menghapus konfigurasi replika baca.
Saat Anda memanggil `mysql.rds_set_external_master_with_auto_position`, Amazon RDS mencatat waktu, pengguna, dan tindakan `set master` di tabel `mysql.rds_history` dan `mysql.rds_replication_status`.
Untuk pemulihan bencana, Anda dapat menggunakan prosedur ini dengan prosedur tersimpan [](#mysql_rds_start_replication_until) atau [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Untuk meneruskan perubahan ke replika baca yang tertunda ke waktu sebelum bencana, Anda dapat menjalankan prosedur `mysql.rds_set_external_master_with_auto_position`. Setelah prosedur `mysql.rds_start_replication_until_gtid` menghentikan replikasi, Anda dapat mempromosikan replika baca menjadi instans DB primer baru dengan menggunakan petunjuk di [Mempromosikan replika baca menjadi instans DB mandiri](USER_ReadRepl.Promote.md).
Untuk menggunakan prosedur `mysql.rds_rds_start_replication_until_gtid`, replikasi berbasis GTID harus diaktifkan. Untuk melewati transaksi berbasis GTID tertentu yang diketahui menyebabkan bencana, Anda dapat menggunakan prosedur tersimpan [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Untuk informasi selengkapnya tentang cara menggunakan replikasi berbasis GTID, lihat [Menggunakan replikasi GTID berbasis](mysql-replication-gtid.md).
### Contoh
Ketika dijalankan pada instans DB MySQL, contoh berikut mengonfigurasi instans DB menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS. Ini menetapkan penundaan replikasi minimum menjadi satu jam (3.600 detik) pada instans DB MySQL. Perubahan dari instans basis data sumber MySQL yang berjalan di luar Amazon RDS tidak diterapkan pada replika baca instans DB MySQL selama setidaknya satu jam.
```
call mysql.rds_set_external_master_with_auto_position(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
1,
3600);
```
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS untuk MySQL mayor versi 8.4 dan lebih tinggi)
Mengonfigurasi instans DB RDS for MySQL menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS. Prosedur ini juga mengonfigurasi replikasi dan replikasi yang tertunda berdasarkan pengidentifikasi transaksi global (). GTIDs
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaks
```
CALL mysql.rds_set_external_source_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
);
```
### Parameter
*host\$1name*
Nama host atau alamat IP instans MySQL yang berjalan di luar Amazon RDS untuk menjadi instans basis data sumber.
*host\$1port*
Port yang digunakan oleh instans MySQL yang berjalan di luar Amazon RDS untuk dikonfigurasi sebagai instans basis data sumber. Jika konfigurasi jaringan Anda mencakup replikasi port Secure Shell (SSH) yang mengubah nomor port, tentukan nomor port yang diekspos oleh SSH.
*replication\$1user\$1name*
ID pengguna dengan izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans MySQL yang berjalan di luar Amazon RDS. Kami menyarankan Anda memberikan akun yang digunakan sepenuhnya untuk replikasi dengan instans eksternal.
*replication\$1user\$1password*
Kata sandi ID pengguna yang ditentukan dalam `replication_user_name`.
*ssl\$1encryption*
Nilai yang menentukan apakah enkripsi Lapisan Soket Aman (SSL) digunakan pada sambungan replikasi. 1 menentukan untuk menggunakan enkripsi SSL, 0 menentukan untuk tidak menggunakan enkripsi. Default-nya adalah 0.
Opsi `SOURCE_SSL_VERIFY_SERVER_CERT` tidak didukung. Opsi ini diatur ke 0, yang berarti koneksi dienkripsi, tetapi sertifikat tidak diverifikasi.
*delay*
Jumlah detik minimum untuk menunda replikasi dari instans basis data sumber.
Batas untuk parameter ini adalah satu hari (86.400 detik).
### Catatan penggunaan
Pengguna administratif harus menjalankan prosedur `mysql.rds_set_external_source_with_auto_position`. Prosedur ini harus dijalankan pada instans DB MySQL untuk dikonfigurasi sebagai replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
Sebelum menjalankan `mysql.rds_set_external_source_with_auto_position`, Anda harus mengonfigurasi instans MySQL yang berjalan di luar Amazon RDS menjadi instans basis data sumber. Untuk terhubung ke instans MySQL yang berjalan di luar Amazon RDS, Anda harus menentukan nilai untuk `replication_user_name` dan `replication_user_password`. Nilai-nilai ini harus menunjukkan pengguna replikasi yang memiliki izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans external MySQL.
**Untuk mengonfigurasi instans eksternal MySQL sebagai instans basis data sumber**
1. Dengan menggunakan klien MySQL pilihan Anda, hubungkan ke instans eksternal MySQL dan buat akun pengguna yang akan digunakan untuk replikasi. Berikut adalah contohnya.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Pada instans eksternal MySQL, berikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` kepada pengguna replikasi Anda. Contoh berikut memberikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada semua basis data untuk pengguna `'repl_user'` domain Anda.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Untuk informasi selengkapnya, lihat [Mengonfigurasi replikasi posisi file log biner dengan instans sumber eksternal](MySQL.Procedural.Importing.External.Repl.md).
**catatan**
Kami menyarankan Anda menggunakan replikasi baca untuk mengelola replikasi antara dua instans DB Amazon RDS jika memungkinkan. Saat Anda melakukannya, sebaiknya hanya gunakan replika baca ini dan prosedur tersimpan terkait replikasi lainnya. Praktik ini memungkinkan topologi replikasi yang lebih kompleks antara instans DB Amazon RDS. Kami menawarkan prosedur tersimpan ini terutama untuk mengaktifkan replikasi dengan instans MySQL yang berjalan di luar Amazon RDS. Untuk informasi tentang mengelola replikasi di antara instans DB Amazon RDS, lihat [Menggunakan replika baca instans DB](USER_ReadRepl.md).
Sebelum Anda menelepon`mysql.rds_set_external_source_with_auto_position`, pastikan untuk memanggil [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#mysql_rds_set_external_source_gtid_purged) untuk mengatur variabel `gtid_purged` sistem dengan rentang GTID tertentu dari sumber eksternal.
Setelah memanggil `mysql.rds_set_external_source_with_auto_position` untuk mengonfigurasi instans DB Amazon RDS sebagai replika baca, Anda dapat memanggil [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) pada replika baca untuk memulai proses replikasi. Anda dapat memanggil [](#mysql_rds_reset_external_source) untuk menghapus konfigurasi replika baca.
Saat Anda memanggil `mysql.rds_set_external_source_with_auto_position`, Amazon RDS mencatat waktu, pengguna, dan tindakan `set master` di tabel `mysql.rds_history` dan `mysql.rds_replication_status`.
Untuk pemulihan bencana, Anda dapat menggunakan prosedur ini dengan prosedur tersimpan [](#mysql_rds_start_replication_until) atau [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Untuk meneruskan perubahan ke replika baca yang tertunda ke waktu sebelum bencana, Anda dapat menjalankan prosedur `mysql.rds_set_external_source_with_auto_position`. Setelah prosedur `mysql.rds_start_replication_until_gtid` menghentikan replikasi, Anda dapat mempromosikan replika baca menjadi instans DB primer baru dengan menggunakan petunjuk di [Mempromosikan replika baca menjadi instans DB mandiri](USER_ReadRepl.Promote.md).
Untuk menggunakan prosedur `mysql.rds_rds_start_replication_until_gtid`, replikasi berbasis GTID harus diaktifkan. Untuk melewati transaksi berbasis GTID tertentu yang diketahui menyebabkan bencana, Anda dapat menggunakan prosedur tersimpan [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Untuk informasi selengkapnya tentang cara menggunakan replikasi berbasis GTID, lihat [Menggunakan replikasi GTID berbasis](mysql-replication-gtid.md).
### Contoh
Ketika dijalankan pada instans DB MySQL, contoh berikut mengonfigurasi instans DB menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS. Ini menetapkan penundaan replikasi minimum menjadi satu jam (3.600 detik) pada instans DB MySQL. Perubahan dari instans basis data sumber MySQL yang berjalan di luar Amazon RDS tidak diterapkan pada replika baca instans DB MySQL selama setidaknya satu jam.
```
call mysql.rds_set_external_source_with_auto_position(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
1,
3600);
```
## mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS untuk MariaDB dan RDS untuk MySQL mayor versi 8.0 dan lebih rendah)
Mengonfigurasi instans DB RDS for MySQL menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS dan mengonfigurasi replikasi tertunda.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaks
```
CALL mysql.rds_set_external_master_with_delay(
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, delay
);
```
### Parameter
*host\$1name*
Nama host atau alamat IP dari instans MySQL yang berjalan di luar Amazon RDS yang akan menjadi instans basis data sumber.
*host\$1port*
Port yang digunakan oleh instans MySQL yang berjalan di luar Amazon RDS untuk dikonfigurasi sebagai instans basis data sumber. Jika konfigurasi jaringan Anda mencakup replikasi port SSH yang mengubah nomor port, tentukan nomor port yang diekspos oleh SSH.
*replication\$1user\$1name*
ID pengguna dengan izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans MySQL yang berjalan di luar Amazon RDS. Kami menyarankan Anda memberikan akun yang digunakan sepenuhnya untuk replikasi dengan instans eksternal.
*replication\$1user\$1password*
Kata sandi ID pengguna yang ditentukan dalam `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nama log biner pada Instans basis data sumber berisi informasi replikasi.
*mysql\$1binary\$1log\$1file\$1location*
Lokasi di log biner `mysql_binary_log_file_name` tempat replikasi akan mulai membaca informasi replikasi.
Anda dapat menentukan nama dan lokasi file binlog dengan menjalankan `SHOW MASTER STATUS` pada instans basis data sumber.
*ssl\$1encryption*
Nilai yang menentukan apakah enkripsi Lapisan Soket Aman (SSL) digunakan pada sambungan replikasi. 1 menentukan untuk menggunakan enkripsi SSL, 0 menentukan untuk tidak menggunakan enkripsi. Default-nya adalah 0.
Opsi `MASTER_SSL_VERIFY_SERVER_CERT` tidak didukung. Opsi ini diatur ke 0, yang berarti koneksi dienkripsi, tetapi sertifikat tidak diverifikasi.
*delay*
Jumlah detik minimum untuk menunda replikasi dari instans basis data sumber.
Batas untuk parameter ini adalah satu hari (86.400 detik).
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_set_external_master_with_delay`. Prosedur ini harus dijalankan pada instans DB MySQL untuk dikonfigurasi sebagai replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
Sebelum menjalankan `mysql.rds_set_external_master_with_delay`, Anda harus mengonfigurasi instans MySQL yang berjalan di luar Amazon RDS menjadi instans basis data sumber. Untuk terhubung ke instans MySQL yang berjalan di luar Amazon RDS, Anda harus menentukan nilai untuk `replication_user_name` dan `replication_user_password`. Nilai-nilai ini harus menunjukkan pengguna replikasi yang memiliki izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans external MySQL.
**Untuk mengonfigurasi instans eksternal MySQL sebagai instans basis data sumber**
1. Dengan menggunakan klien MySQL pilihan Anda, hubungkan ke instans eksternal MySQL dan buat akun pengguna yang akan digunakan untuk replikasi. Berikut adalah contohnya.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Pada instans eksternal MySQL, berikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` kepada pengguna replikasi Anda. Contoh berikut memberikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada semua basis data untuk pengguna `'repl_user'` domain Anda.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Untuk informasi selengkapnya, lihat [Mengonfigurasi replikasi posisi file log biner dengan instans sumber eksternal](MySQL.Procedural.Importing.External.Repl.md).
**catatan**
Kami menyarankan Anda menggunakan replikasi baca untuk mengelola replikasi antara dua instans DB Amazon RDS jika memungkinkan. Saat Anda melakukannya, sebaiknya hanya gunakan replika baca ini dan prosedur tersimpan terkait replikasi lainnya. Praktik ini memungkinkan topologi replikasi yang lebih kompleks antara instans DB Amazon RDS. Kami menawarkan prosedur tersimpan ini terutama untuk mengaktifkan replikasi dengan instans MySQL yang berjalan di luar Amazon RDS. Untuk informasi tentang mengelola replikasi di antara instans DB Amazon RDS, lihat [Menggunakan replika baca instans DB](USER_ReadRepl.md).
Setelah memanggil `mysql.rds_set_external_master_with_delay` untuk mengonfigurasi instans DB Amazon RDS sebagai replika baca, Anda dapat memanggil [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) pada replika baca untuk memulai proses replikasi. Anda dapat memanggil [](#mysql_rds_reset_external_master) untuk menghapus konfigurasi replika baca.
Saat Anda memanggil `mysql.rds_set_external_master_with_delay`, Amazon RDS mencatat waktu, pengguna, dan tindakan `set master` di tabel `mysql.rds_history` dan `mysql.rds_replication_status`.
Untuk pemulihan bencana, Anda dapat menggunakan prosedur ini dengan prosedur tersimpan [](#mysql_rds_start_replication_until) atau [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Untuk meneruskan perubahan ke replika baca yang tertunda ke waktu sebelum bencana, Anda dapat menjalankan prosedur `mysql.rds_set_external_master_with_delay`. Setelah prosedur `mysql.rds_start_replication_until` menghentikan replikasi, Anda dapat mempromosikan replika baca menjadi instans DB primer baru dengan menggunakan petunjuk di [Mempromosikan replika baca menjadi instans DB mandiri](USER_ReadRepl.Promote.md).
Untuk menggunakan prosedur `mysql.rds_rds_start_replication_until_gtid`, replikasi berbasis GTID harus diaktifkan. Untuk melewati transaksi berbasis GTID tertentu yang diketahui menyebabkan bencana, Anda dapat menggunakan prosedur tersimpan [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Untuk informasi selengkapnya tentang cara menggunakan replikasi berbasis GTID, lihat [Menggunakan replikasi GTID berbasis](mysql-replication-gtid.md).
Prosedur `mysql.rds_set_external_master_with_delay` tersedia dalam versi RDS for MySQL ini:
+ MySQL 8.0.26 dan versi 8.0 yang lebih tinggi
+ Semua versi 5.7
### Contoh
Ketika dijalankan pada instans DB MySQL, contoh berikut mengonfigurasi instans DB menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS. Ini menetapkan penundaan replikasi minimum menjadi satu jam (3.600 detik) pada instans DB MySQL. Perubahan dari instans basis data sumber MySQL yang berjalan di luar Amazon RDS tidak diterapkan pada replika baca instans DB MySQL selama setidaknya satu jam.
```
call mysql.rds_set_external_master_with_delay(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
'mysql-bin-changelog.000777',
120,
1,
3600);
```
## mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS untuk MySQL mayor versi 8.4 dan lebih tinggi)
Mengonfigurasi instans DB RDS for MySQL menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS dan mengonfigurasi replikasi tertunda.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaks
```
CALL mysql.rds_set_external_source_with_delay (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, delay
);
```
### Parameter
*host\$1name*
Nama host atau alamat IP dari instans MySQL yang berjalan di luar Amazon RDS yang akan menjadi instans basis data sumber.
*host\$1port*
Port yang digunakan oleh instans MySQL yang berjalan di luar Amazon RDS untuk dikonfigurasi sebagai instans basis data sumber. Jika konfigurasi jaringan Anda mencakup replikasi port SSH yang mengubah nomor port, tentukan nomor port yang diekspos oleh SSH.
*replication\$1user\$1name*
ID pengguna dengan izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans MySQL yang berjalan di luar Amazon RDS. Kami menyarankan Anda memberikan akun yang digunakan sepenuhnya untuk replikasi dengan instans eksternal.
*replication\$1user\$1password*
Kata sandi ID pengguna yang ditentukan dalam `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nama log biner pada Instans basis data sumber berisi informasi replikasi.
*mysql\$1binary\$1log\$1file\$1location*
Lokasi di log biner `mysql_binary_log_file_name` tempat replikasi akan mulai membaca informasi replikasi.
Anda dapat menentukan nama dan lokasi file binlog dengan menjalankan `SHOW MASTER STATUS` pada instans basis data sumber.
*ssl\$1encryption*
Nilai yang menentukan apakah enkripsi Lapisan Soket Aman (SSL) digunakan pada sambungan replikasi. 1 menentukan untuk menggunakan enkripsi SSL, 0 menentukan untuk tidak menggunakan enkripsi. Default-nya adalah 0.
Opsi `SOURCE_SSL_VERIFY_SERVER_CERT` tidak didukung. Opsi ini diatur ke 0, yang berarti koneksi dienkripsi, tetapi sertifikat tidak diverifikasi.
*delay*
Jumlah detik minimum untuk menunda replikasi dari instans basis data sumber.
Batas untuk parameter ini adalah satu hari (86.400 detik).
### Catatan penggunaan
Pengguna administratif harus menjalankan prosedur `mysql.rds_set_external_source_with_delay`. Prosedur ini harus dijalankan pada instans DB MySQL untuk dikonfigurasi sebagai replika baca dari instans MySQL yang berjalan di luar Amazon RDS.
Sebelum menjalankan `mysql.rds_set_external_source_with_delay`, Anda harus mengonfigurasi instans MySQL yang berjalan di luar Amazon RDS menjadi instans basis data sumber. Untuk terhubung ke instans MySQL yang berjalan di luar Amazon RDS, Anda harus menentukan nilai untuk `replication_user_name` dan `replication_user_password`. Nilai-nilai ini harus menunjukkan pengguna replikasi yang memiliki izin `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada instans external MySQL.
**Untuk mengonfigurasi instans eksternal MySQL sebagai instans basis data sumber**
1. Dengan menggunakan klien MySQL pilihan Anda, hubungkan ke instans eksternal MySQL dan buat akun pengguna yang akan digunakan untuk replikasi. Berikut adalah contohnya.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Pada instans eksternal MySQL, berikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` kepada pengguna replikasi Anda. Contoh berikut memberikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada semua basis data untuk pengguna `'repl_user'` domain Anda.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Untuk informasi selengkapnya, lihat [Mengonfigurasi replikasi posisi file log biner dengan instans sumber eksternal](MySQL.Procedural.Importing.External.Repl.md).
**catatan**
Kami menyarankan Anda menggunakan replikasi baca untuk mengelola replikasi antara dua instans DB Amazon RDS jika memungkinkan. Saat Anda melakukannya, sebaiknya hanya gunakan replika baca ini dan prosedur tersimpan terkait replikasi lainnya. Praktik ini memungkinkan topologi replikasi yang lebih kompleks antara instans DB Amazon RDS. Kami menawarkan prosedur tersimpan ini terutama untuk mengaktifkan replikasi dengan instans MySQL yang berjalan di luar Amazon RDS. Untuk informasi tentang mengelola replikasi di antara instans DB Amazon RDS, lihat [Menggunakan replika baca instans DB](USER_ReadRepl.md).
Setelah memanggil `mysql.rds_set_external_source_with_delay` untuk mengonfigurasi instans DB Amazon RDS sebagai replika baca, Anda dapat memanggil [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) pada replika baca untuk memulai proses replikasi. Anda dapat memanggil [](#mysql_rds_reset_external_source) untuk menghapus konfigurasi replika baca.
Saat Anda memanggil `mysql.rds_set_external_source_with_delay`, Amazon RDS mencatat waktu, pengguna, dan tindakan `set master` di tabel `mysql.rds_history` dan `mysql.rds_replication_status`.
Untuk pemulihan bencana, Anda dapat menggunakan prosedur ini dengan prosedur tersimpan [](#mysql_rds_start_replication_until) atau [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Untuk meneruskan perubahan ke replika baca yang tertunda ke waktu sebelum bencana, Anda dapat menjalankan prosedur `mysql.rds_set_external_source_with_delay`. Setelah prosedur `mysql.rds_start_replication_until` menghentikan replikasi, Anda dapat mempromosikan replika baca menjadi instans DB primer baru dengan menggunakan petunjuk di [Mempromosikan replika baca menjadi instans DB mandiri](USER_ReadRepl.Promote.md).
Untuk menggunakan prosedur `mysql.rds_rds_start_replication_until_gtid`, replikasi berbasis GTID harus diaktifkan. Untuk melewati transaksi berbasis GTID tertentu yang diketahui menyebabkan bencana, Anda dapat menggunakan prosedur tersimpan [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Untuk informasi selengkapnya tentang cara menggunakan replikasi berbasis GTID, lihat [Menggunakan replikasi GTID berbasis](mysql-replication-gtid.md).
### Contoh
Ketika dijalankan pada instans DB MySQL, contoh berikut mengonfigurasi instans DB menjadi replika baca dari instans MySQL yang berjalan di luar Amazon RDS. Ini menetapkan penundaan replikasi minimum menjadi satu jam (3.600 detik) pada instans DB MySQL. Perubahan dari instans basis data sumber MySQL yang berjalan di luar Amazon RDS tidak diterapkan pada replika baca instans DB MySQL selama setidaknya satu jam.
```
call mysql.rds_set_external_source_with_delay(
'Externaldb.some.com',
3306,
'repl_user',
'SomePassW0rd',
'mysql-bin-changelog.000777',
120,
1,
3600);
```
## mysql.rds\$1set\$1external\$1source\$1gtid\$1purged
Menetapkan variabel sistem [gtid\$1purged](https://dev.mysql.com/doc/refman/8.0/en/replication-options-gtids.html#sysvar_gtid_purged) dengan rentang GTID tertentu dari sumber eksternal. `gtid_purged`Nilai diperlukan untuk mengonfigurasi replikasi berbasis GTID untuk melanjutkan replikasi menggunakan penentuan posisi otomatis.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaks
```
CALL mysql.rds_set_external_source_gtid_purged(
server_uuid
, start_pos
, end_pos
);
```
### Parameter
*server\$1uuid*
Pengidentifikasi unik universal (UUID) dari server eksternal tempat rentang GTID diimpor.
*start\$1pos*
Posisi awal rentang GTID yang akan ditetapkan.
*end\$1pos*
Posisi akhir dari rentang GTID yang akan ditetapkan.
### Catatan penggunaan
`mysql.rds_set_external_source_gtid_purged`Prosedur ini hanya tersedia dengan MySQL 8.0.37 dan versi 8.0 yang lebih tinggi.
Hubungi `mysql.rds_set_external_source_gtid_purged` sebelum Anda menelepon[mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS untuk MySQL versi utama 8.0 dan lebih rendah)](#mysql_rds_set_external_master_with_auto_position),[mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS untuk MySQL mayor versi 8.4 dan lebih tinggi)](#mysql_rds_set_external_source_with_auto_position), atau[mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position\$1for\$1channel](mysql-stored-proc-multi-source-replication.md#mysql_rds_set_external_source_with_auto_position_for_channel).
Sebelum Anda menelepon`mysql.rds_set_external_source_gtid_purged`, pastikan untuk menghentikan semua saluran replikasi aktif untuk database. Untuk memeriksa status saluran, gunakan pernyataan `SHOW REPLICA STATUS` MySQL. Untuk menghentikan replikasi pada saluran, hubungi[mysql.rds\$1stop\$1replication\$1for\$1channel](mysql-stored-proc-multi-source-replication.md#mysql_rds_stop_replication_for_channel).
Rentang GTID yang Anda tentukan harus merupakan superset dari nilai yang ada. `GTID_PURGED` Prosedur tersimpan ini memeriksa nilai-nilai berikut sebelum menetapkan `GTID_PURGED` nilai:
+ `server_uuid`Itu valid.
+ Nilai `start_pos` lebih besar dari `0` dan kurang dari nilai`end_pos`.
+ Nilai `end_pos` lebih besar dari atau sama dengan nilai`start_pos`.
Jika set GTID di server eksternal Anda berisi beberapa rentang nilai, pertimbangkan untuk memanggil prosedur beberapa kali dengan nilai set GTID yang berbeda.
Saat Anda menelepon`mysql.rds_set_external_source_gtid_purged`, Amazon RDS mencatat waktu, pengguna, dan tindakan `set gtid_purged` dalam `mysql.rds_history` tabel.
Jika Anda tidak menetapkan `gtid_purged` nilai dengan tepat untuk cadangan yang Anda gunakan untuk replikasi, ini dapat mengakibatkan transaksi hilang atau diduplikasi selama proses replikasi. Lakukan langkah-langkah berikut untuk menetapkan `gtid_purged` nilai yang benar.
**Untuk mengatur nilai gtid\$1purged pada replika**
1. Tentukan titik waktu atau file cadangan spesifik yang akan digunakan sebagai titik awal replikasi. Ini bisa berupa cadangan logis (file mysqldump) atau cadangan fisik (snapshot Amazon RDS).
1. Tentukan `gtid_executed` nilainya. Nilai ini mewakili himpunan semua GTIDs yang dilakukan di server. Untuk mengambil nilai ini, pada instance sumber, lakukan salah satu hal berikut:
+ Jalankan pernyataan SQL `SELECT @@GLOBAL.GTID_EXECUTED;` pada saat cadangan diambil.
+ Jika ada opsi terkait yang disertakan dalam utilitas cadangan masing-masing, ekstrak nilai dari file cadangan. Untuk informasi selengkapnya, lihat [set-gtid-purged](https://dev.mysql.com/doc/refman/8.4/en/mysqldump.html#option_mysqldump_set-gtid-purged)opsi dalam dokumentasi MySQL.
1. Tentukan `gtid_purged` nilai yang akan digunakan untuk panggilan ke`mysql.rds_set_external_source_gtid_purged`. `gtid_purged`Nilai harus mencakup semua GTIDs yang dieksekusi pada instance sumber dan tidak lagi diperlukan untuk replikasi. Oleh karena itu, `gtid_purged` nilai harus menjadi bagian dari `gtid_executed` nilai yang Anda ambil pada langkah sebelumnya.
Untuk menentukan `gtid_purged` nilainya, identifikasi GTIDs yang tidak disertakan dalam cadangan dan tidak lagi diperlukan untuk replikasi. Anda dapat melakukannya dengan menganalisis log biner atau dengan menggunakan alat seperti mysqlbinlog untuk menemukan GTIDs yang dibersihkan dari log biner.
Atau, jika Anda memiliki cadangan konsisten yang mencakup semua log biner hingga titik cadangan, Anda dapat mengatur `gtid_purged` nilainya agar sama dengan `gtid_executed` nilai pada titik cadangan.
1. Setelah Anda menentukan `gtid_purged` nilai yang sesuai yang konsisten dengan cadangan Anda, panggil prosedur `mysql.rds_set_external_source_gtid_purged` tersimpan pada instans RDS untuk MySQL DB Anda untuk menetapkan nilainya.
### Contoh
Ketika dijalankan pada instance MySQL DB, contoh berikut menetapkan rentang GTID dari server MySQL eksternal dengan `12345678-abcd-1234-efgh-123456789abc` UUID, posisi awal, dan posisi akhir. `1` `100` Nilai GTID yang dihasilkan diatur ke. `+12345678-abcd-1234-efgh-123456789abc:1-100`
```
CALL mysql.rds_set_external_source_gtid_purged('12345678-abcd-1234-efgh-123456789abc', 1, 100);
```
##
Menetapkan mode replikasi untuk didasarkan pada posisi file log biner atau pada pengidentifikasi transaksi global ()GTIDs.
### Sintaks
```
CALL mysql.rds_set_master_auto_position (
auto_position_mode
);
```
### Parameter
*auto\$1position\$1mode*
Nilai yang menunjukkan apakah akan menggunakan replikasi posisi file log atau replikasi berbasis GTID:
+ `0` – Gunakan metode replikasi berdasarkan posisi file log biner. Nilai default-nya `0`.
+ `1` – Gunakan metode replikasi berbasis GTID.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_set_master_auto_position`.
Prosedur ini didukung untuk semua RDS untuk MySQL 5.7 versi dan RDS untuk MySQL 8.0.26 dan versi 8.0 yang lebih tinggi.
##
Menetapkan mode replikasi untuk didasarkan pada posisi file log biner atau pada pengidentifikasi transaksi global ()GTIDs.
### Sintaks
```
CALL mysql.rds_set_source_auto_position (auto_position_mode);
```
### Parameter
*auto\$1position\$1mode*
Nilai yang menunjukkan apakah akan menggunakan replikasi posisi file log atau replikasi berbasis GTID:
+ `0` – Gunakan metode replikasi berdasarkan posisi file log biner. Nilai default-nya `0`.
+ `1` – Gunakan metode replikasi berbasis GTID.
### Catatan penggunaan
Pengguna administratif harus menjalankan prosedur `mysql.rds_set_source_auto_position`.
## mysql.rds\$1set\$1source\$1delay
Mengatur jumlah detik minimum untuk menunda replikasi dari instans basis data sumber ke replika baca saat ini. Gunakan prosedur ini saat Anda tersambung ke replika baca untuk menunda replikasi dari instans basis data sumbernya.
### Sintaks
```
CALL mysql.rds_set_source_delay(
delay
);
```
### Parameter
*delay*
Jumlah detik minimum untuk menunda replikasi dari instans basis data sumber.
Batas untuk parameter ini adalah satu hari (86.400 detik).
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_set_source_delay`.
Untuk pemulihan bencana, Anda dapat menggunakan prosedur ini dengan prosedur tersimpan [](#mysql_rds_start_replication_until) atau [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Untuk meneruskan perubahan ke replika baca yang tertunda ke waktu sebelum bencana, Anda dapat menjalankan prosedur `mysql.rds_set_source_delay`. Setelah prosedur `mysql.rds_start_replication_until` atau `mysql.rds_start_replication_until_gtid` menghentikan replikasi, Anda dapat mempromosikan replika baca menjadi instans DB primer baru dengan menggunakan petunjuk di [Mempromosikan replika baca menjadi instans DB mandiri](USER_ReadRepl.Promote.md).
Untuk menggunakan prosedur `mysql.rds_rds_start_replication_until_gtid`, replikasi berbasis GTID harus diaktifkan. Untuk melewati transaksi berbasis GTID tertentu yang diketahui menyebabkan bencana, Anda dapat menggunakan prosedur tersimpan [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Untuk informasi selengkapnya tentang replikasi berbasis GTID, lihat [Menggunakan replikasi GTID berbasis](mysql-replication-gtid.md).
Prosedur `mysql.rds_set_source_delay` tersedia dalam versi RDS for MySQL ini:
+ Semua RDS untuk MySQL 8.4 versi
+ MySQL 8.0.26 dan versi 8.0 yang lebih tinggi
+ Semua versi 5.7
### Contoh
Untuk menunda replikasi dari instans basis data sumber ke replika baca saat ini setidaknya selama satu jam (3.600 detik), Anda dapat memanggil `mysql.rds_set_source_delay` dengan parameter berikut:
```
CALL mysql.rds_set_source_delay(3600);
```
## mysql.rds\$1skip\$1repl\$1error
Melewati dan menghapus kesalahan replikasi pada replika baca DB MySQL.
### Sintaksis
```
CALL mysql.rds_skip_repl_error;
```
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_skip_repl_error` pada replika baca. Untuk informasi selengkapnya tentang prosedur ini, lihat [Memanggil prosedur mysql.rds\$1skip\$1repl\$1error](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure).
Untuk menentukan apakah ada kesalahan, jalankan perintah `SHOW REPLICA STATUS\G` MySQL. Jika kesalahan replikasi tidak parah, Anda dapat menjalankan `mysql.rds_skip_repl_error` untuk melewati kesalahan tersebut. Jika ada beberapa kesalahan, `mysql.rds_skip_repl_error` akan menghapus kesalahan pertama, lalu memberi peringatan bahwa ada kesalahan lain. Anda kemudian dapat menggunakan `SHOW REPLICA STATUS\G` untuk menentukan tindakan yang benar untuk kesalahan berikutnya. Untuk informasi tentang nilai yang ditampilkan, lihat [SHOW REPLICA STATUS statement](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) dalam dokumentasi MySQL.
Untuk informasi selengkapnya tentang cara mengatasi kesalahan replikasi dengan Amazon RDS, lihat [Memecahkan masalah replika SQL baca saya](USER_ReadRepl.Troubleshooting.md).
#### Kesalahan replikasi terhenti
Ketika memanggil prosedur `mysql.rds_skip_repl_error`, Anda mungkin menerima pesan kesalahan yang menyatakan bahwa replika tidak berfungsi atau dinonaktifkan.
Pesan kesalahan ini muncul jika Anda menjalankan prosedur pada instans primer, bukan replika baca. Anda harus menjalankan prosedur ini pada replika baca agar prosedur berfungsi.
Pesan kesalahan ini mungkin juga muncul jika Anda menjalankan prosedur pada replika baca, tetapi replikasi tidak berhasil dimulai ulang.
Jika Anda perlu melewati sejumlah besar kesalahan, lag replikasi dapat meningkat hingga melampaui periode retensi default untuk file log biner (binlog). Dalam hal ini, Anda mungkin mengalami kesalahan fatal karena file binlog dibersihkan sebelum diputar ulang pada replika baca. Penghapusan ini menyebabkan replikasi berhenti, dan Anda tidak dapat lagi memanggil perintah `mysql.rds_skip_repl_error` untuk melewati kesalahan replikasi.
Anda dapat memitigasi masalah ini dengan meningkatkan jumlah jam retensi file binlog tersebut pada instans basis data sumber Anda. Setelah meningkatkan waktu retensi binlog, Anda dapat memulai ulang replikasi dan memanggil perintah `mysql.rds_skip_repl_error` sesuai kebutuhan.
Untuk mengatur waktu retensi binlog, gunakan prosedur [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) dan tentukan parameter konfigurasi `'binlog retention hours'` bersama dengan jumlah jam untuk mempertahankan file binlog di klaster DB. Contoh berikut menetapkan periode penyimpanan file binlog menjadi 48 jam.
```
CALL mysql.rds_set_configuration('binlog retention hours', 48);
```
## mysql.rds\$1start\$1replication
Memulai replikasi dari instans DB RDS for MySQL.
**catatan**
Anda dapat menggunakan prosedur tersimpan [](#mysql_rds_start_replication_until) atau [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) untuk memulai replikasi dari instans DB RDS for MySQL dan menghentikan replikasi di lokasi file log biner yang telah ditentukan.
### Sintaksis
```
CALL mysql.rds_start_replication;
```
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_start_replication`.
Untuk mengimpor data dari instance MySQL eksternal ke Amazon RDS, `mysql.rds_start_replication` panggil replika baca untuk memulai proses replikasi setelah Anda [](#mysql_rds_set_external_master) memanggil [](#mysql_rds_set_external_source) atau membangun konfigurasi replikasi. Untuk informasi selengkapnya, lihat [Memulihkan cadangan ke instans Amazon RDS for MySQL DB](MySQL.Procedural.Importing.md).
Untuk mengekspor data ke instans MySQL yang berjalan di luar Amazon RDS, panggil `mysql.rds_start_replication` dan `mysql.rds_stop_replication` pada replika baca untuk mengontrol beberapa tindakan replikasi, seperti membersihkan log biner. Untuk informasi selengkapnya, lihat [Mengekspor data dari instans DB MySQL dengan menggunakan replikasi](MySQL.Procedural.Exporting.NonRDSRepl.md).
Anda juga dapat memanggil `mysql.rds_start_replication` pada replika baca untuk memulai kembali proses replikasi apa pun yang sebelumnya Anda hentikan dengan memanggil `mysql.rds_stop_replication`. Untuk informasi selengkapnya, lihat [Menggunakan replika baca instans DB](USER_ReadRepl.md).
##
Memulai replikasi dari instans DB RDS for MySQL dan menghentikan replikasi di lokasi file log biner yang telah ditentukan.
### Sintaks
```
CALL mysql.rds_start_replication_until (
replication_log_file
, replication_stop_point
);
```
### Parameter
*replication\$1log\$1file*
Nama log biner pada instans basis data sumber yang berisi informasi replikasi.
*replication\$1stop\$1point *
Lokasi di log biner `replication_log_file` tempat replikasi akan berhenti.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_start_replication_until`.
Prosedur `mysql.rds_start_replication_until` tersedia dalam versi RDS for MySQL ini:
+ Semua RDS untuk MySQL 8.4 versi
+ MySQL 8.0.26 dan versi 8.0 yang lebih tinggi
+ Semua versi 5.7
Anda dapat menggunakan prosedur ini dengan replikasi tertunda untuk pemulihan bencana. Jika Anda telah mengonfigurasi replikasi tertunda, Anda dapat menggunakan prosedur ini untuk meneruskan perubahan ke replika baca tertunda ke waktu sebelum bencana terjadi. Setelah prosedur ini menghentikan replikasi, Anda dapat mempromosikan replika baca menjadi instans DB primer baru dengan menggunakan petunjuk di [Mempromosikan replika baca menjadi instans DB mandiri](USER_ReadRepl.Promote.md).
Anda dapat mengonfigurasi replikasi tertunda menggunakan prosedur tersimpan berikut ini:
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS untuk MariaDB dan RDS untuk MySQL mayor versi 8.0 dan lebih rendah)](#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS untuk MySQL mayor versi 8.4 dan lebih tinggi)](#mysql_rds_set_external_source_with_delay)
+ [mysql.rds\$1set\$1source\$1delay](#mysql_rds_set_source_delay)
Nama file yang ditentukan untuk parameter `replication_log_file` harus cocok dengan nama file binlog instans basis data sumber.
Jika parameter `replication_stop_point` menentukan lokasi perhentian di masa lalu, replikasi akan segera dihentikan.
### Contoh
Contoh berikut memulai replikasi dan mereplikasi perubahan hingga mencapai lokasi `120` di file log biner `mysql-bin-changelog.000777`.
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
## mysql.rds\$1stop\$1replication
Menghentikan replikasi dari instans DB MySQL.
### Sintaks
```
CALL mysql.rds_stop_replication;
```
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_stop_replication`.
Jika Anda mengonfigurasi replikasi untuk mengimpor data dari instans MySQL yang berjalan di luar Amazon RDS, Anda memanggil `mysql.rds_stop_replication` pada replika baca untuk menghentikan proses replikasi setelah impor selesai. Untuk informasi selengkapnya, lihat [Memulihkan cadangan ke instans Amazon RDS for MySQL DB](MySQL.Procedural.Importing.md).
Jika Anda mengonfigurasi replikasi untuk mengekspor data ke instans MySQL yang berjalan di luar Amazon RDS, Anda memanggil `mysql.rds_start_replication` dan `mysql.rds_stop_replication` pada replika baca untuk mengontrol beberapa tindakan replikasi, seperti membersihkan log biner. Untuk informasi selengkapnya, lihat [Mengekspor data dari instans DB MySQL dengan menggunakan replikasi](MySQL.Procedural.Exporting.NonRDSRepl.md).
Anda juga dapat menggunakan `mysql.rds_stop_replication` untuk menghentikan replikasi antara dua instans DB Amazon RDS. Anda biasanya menghentikan replikasi untuk menjalankan operasi berjangka panjang pada replika baca, seperti membuat indeks besar pada replika baca. Anda dapat memulai kembali proses replikasi apa pun yang sebelumnya Anda hentikan dengan memanggil [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) pada replika baca. Untuk informasi selengkapnya, lihat [Menggunakan replika baca instans DB](USER_ReadRepl.md).
# Mengakhiri sesi atau kueri
Prosedur tersimpan berikut mengakhiri sesi atau kueri.
**Topics**
+ [
## mysql.rds\$1kill
](#mysql_rds_kill)
+ [
## mysql.rds\$1kill\$1query
](#mysql_rds_kill_query)
## mysql.rds\$1kill
Mengakhiri koneksi ke server MySQL.
### Sintaksis
```
CALL mysql.rds_kill(processID);
```
### Parameter
*processID*
Identitas utas koneksi akan diakhiri.
### Catatan penggunaan
Setiap koneksi ke server MySQL berjalan di utas terpisah. Untuk mengakhiri koneksi, gunakan prosedur `mysql.rds_kill` dan teruskan ID utas koneksi tersebut. Untuk mendapatkan ID utas, gunakan perintah [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html) MySQL.
Untuk informasi tentang batasan, lihat [Batasan prosedur tersimpan MySQL](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures).
### Contoh
Contoh berikut mengakhiri koneksi dengan ID utas 4243:
```
CALL mysql.rds_kill(4243);
```
## mysql.rds\$1kill\$1query
Mengakhiri kueri yang berjalan pada server MySQL.
### Sintaksis
```
CALL mysql.rds_kill_query(processID);
```
### Parameter
*processID*
Identitas proses atau utas yang menjalankan kueri yang akan diakhiri.
### Catatan penggunaan
Untuk mengakhiri kueri yang berjalan pada server MySQL, gunakan prosedur `mysql_rds_kill_query` dan teruskan ID koneksi utas yang menjalankan kueri. Lalu, prosedur akan mengakhiri koneksi.
Untuk mendapatkan ID, lakukan kueri pada [tabel INFORMATION\$1SCHEMA PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/information-schema-processlist-table.html) MySQL atau gunakan perintah [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html) MySQL. Nilai dalam kolom ID dari `SHOW PROCESSLIST` atau `SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST` adalah *processID*.
Untuk informasi tentang batasan, lihat [Batasan prosedur tersimpan MySQL](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures).
### Contoh
Contoh berikut mengakhiri kueri dengan ID utas kueri 230040:
```
CALL mysql.rds_kill_query(230040);
```
# Mengelola klaster aktif-aktif
Prosedur tersimpan berikut ini disiapkan dan dikelola RDS untuk klaster SQL aktif-aktif Saya. Untuk informasi selengkapnya, lihat [Mengonfigurasikan klaster aktif-aktif untuk RDS for MySQL](mysql-active-active-clusters.md).
Prosedur tersimpan ini hanya tersedia RDS untuk instans My SQL DB yang menjalankan versi berikut:
+ Semua versi My SQL 8.4
+ SQL8.0.35 saya dan versi minor yang lebih tinggi
**Topics**
+ [
## mysql.rds\$1group\$1replication\$1advance\$1gtid
](#mysql_rds_group_replication_advance_gtid)
+ [
## mysql.rds\$1group\$1replication\$1create\$1user
](#mysql_rds_group_replication_create_user)
+ [
## mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel
](#mysql_rds_group_replication_set_recovery_channel)
+ [
## mysql.rds\$1group\$1replication\$1start
](#mysql_rds_group_replication_start)
+ [
## mysql.rds\$1group\$1replication\$1stop
](#mysql_rds_group_replication_stop)
## mysql.rds\$1group\$1replication\$1advance\$1gtid
Menciptakan placeholder GTIDs pada instance DB saat ini.
### Sintaks
```
CALL mysql.rds_group_replication_advance_gtid(
begin_id
, end_id
, server_uuid
);
```
### Parameter
*begin\$1id*
ID transaksi awal yang akan dibuat.
*end\$1id*
ID transaksi akhir yang akan dibuat.
*begin\$1id*
`group_replication_group_name` untuk transaksi yang akan dibuat. `group_replication_group_name`Ini ditentukan sebagai UUID dalam kelompok parameter DB yang terkait dengan instans DB.
### Catatan penggunaan
Dalam cluster aktif-aktif, untuk instans DB untuk bergabung dengan grup, semua GTID transaksi yang dijalankan pada instans DB baru harus ada pada anggota lain di cluster. Dalam kasus tertentu, instans DB baru mungkin memiliki lebih banyak transaksi ketika transaksi dieksekusi sebelum menggabungkan instans ke grup. Dalam hal ini, Anda tidak dapat menghapus transaksi yang ada, tetapi Anda dapat menggunakan prosedur ini untuk membuat placeholder yang sesuai GTIDs pada instans DB lain di grup. Sebelum itu, pastikan transaksi *tidak memengaruhi data yang direplikasi*.
Ketika Anda memanggil prosedur ini, GTID transaksi `server_uuid:begin_id-end_id` dibuat dengan konten kosong. Untuk menghindari masalah replikasi, jangan gunakan prosedur ini dalam kondisi lain.
**penting**
Jangan panggil prosedur ini ketika klaster aktif-aktif berfungsi normal. Jangan panggil prosedur ini kecuali Anda memahami kemungkinan konsekuensi dari transaksi yang Anda buat. Memanggil prosedur ini dapat menyebabkan inkonsistensi data.
### Contoh
Contoh berikut menciptakan placeholder GTIDs pada instance DB saat ini. :
```
CALL mysql.rds_group_replication_advance_gtid(5, 6, '11111111-2222-3333-4444-555555555555');
```
## mysql.rds\$1group\$1replication\$1create\$1user
Membuat pengguna replikasi `rdsgrprepladmin` untuk replikasi grup pada instans DB.
### Sintaks
```
CALL mysql.rds_group_replication_create_user(
replication_user_password
);
```
### Parameter
*replication\$1user\$1password*
Kata sandi pengguna replikasi `rdsgrprepladmin`.
### Catatan penggunaan
+ Kata sandi pengguna replikasi `rdsgrprepladmin` harus sama di semua instans DB dalam klaster aktif-aktif.
+ Nama pengguna `rdsgrprepladmin` dipesan untuk koneksi replikasi grup. Tidak ada pengguna lain, termasuk pengguna master, yang dapat memiliki nama pengguna ini.
### Contoh
Contoh berikut membuat pengguna replikasi `rdsgrprepladmin` untuk replikasi grup pada instans DB:
```
CALL mysql.rds_group_replication_create_user('password');
```
## mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel
Menetapkan saluran `group_replication_recovery` untuk klaster aktif-aktif. Prosedur ini menggunakan pengguna `rdsgrprepladmin` terpesan untuk mengonfigurasi saluran.
### Sintaks
```
CALL mysql.rds_group_replication_set_recovery_channel(
replication_user_password);
```
### Parameter
*replication\$1user\$1password*
Kata sandi pengguna replikasi `rdsgrprepladmin`.
### Catatan penggunaan
Kata sandi pengguna replikasi `rdsgrprepladmin` harus sama di semua instans DB dalam klaster aktif-aktif. Panggilan ke `mysql.rds_group_replication_create_user` menentukan kata sandi.
### Contoh
Contoh berikut menetapkan saluran `group_replication_recovery` untuk klaster aktif-aktif:
```
CALL mysql.rds_group_replication_set_recovery_channel('password');
```
## mysql.rds\$1group\$1replication\$1start
Memulai replikasi grup pada instans DB saat ini.
### Sintaks
```
CALL mysql.rds_group_replication_start(
bootstrap
);
```
### Parameter
*bootstrap*
Nilai yang menentukan apakah akan menginisialisasi grup baru atau bergabung dengan grup yang sudah ada. `1` menginisialisasi grup baru dengan instans DB saat ini. `0` menggabungkan instans DB saat ini ke grup yang sudah ada dengan menghubungkan ke titik akhir yang ditentukan dalam parameter `group_replication_group_seeds` dalam grup parameter DB yang terkait dengan instans DB.
### Contoh
Contoh berikut menginisialisasi grup baru dengan instans DB saat ini:
```
CALL mysql.rds_group_replication_start(1);
```
## mysql.rds\$1group\$1replication\$1stop
Menghentikan replikasi grup pada instans DB saat ini.
### Sintaks
```
CALL mysql.rds_group_replication_stop();
```
### Catatan penggunaan
Saat Anda menghentikan replikasi pada instans DB, tindakan tersebut tidak memengaruhi instans DB lain dalam klaster aktif-aktif.
# Mengelola replikasi multi-sumber
Prosedur tersimpan berikut menyiapkan dan mengelola saluran replikasi pada replika SQL multi-sumber RDS untuk Saya. Untuk informasi selengkapnya, lihat [Mengkonfigurasi multi-source-replication untuk Amazon RDS for MySQL](mysql-multi-source-replication.md).
Prosedur tersimpan ini hanya tersedia RDS untuk instans My SQL DB yang menjalankan versi mesin berikut:
+ Semua versi 8.4
+ 8.0.35 dan versi minor yang lebih tinggi
+ 5.7.44 dan versi minor yang lebih tinggi
Saat menggunakan prosedur tersimpan untuk mengelola replikasi dengan pengguna replikasi yang dikonfigurasi`caching_sha2_passwword`, Anda harus mengonfigurasi TLS dengan menentukan. `SOURCE_SSL=1` `caching_sha2_password`adalah plugin otentikasi default RDS untuk My SQL 8.4.
**catatan**
Meskipun dokumentasi ini mengacu pada instans DB sumber seperti RDS untuk instans SQL DB Saya, prosedur ini juga berfungsi untuk SQL instans Saya yang berjalan di luar Amazon. RDS
**Topics**
+ [
## mysql.rds\$1next\$1source\$1log\$1for\$1channel
](#mysql_rds_next_source_log_for_channel)
+ [
## mysql.rds\$1reset\$1external\$1source\$1for\$1channel
](#mysql_rds_reset_external_source_for_channel)
+ [
## mysql.rds\$1set\$1external\$1source\$1for\$1channel
](#mysql_rds_set_external_source_for_channel)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position\$1for\$1channel
](#mysql_rds_set_external_source_with_auto_position_for_channel)
+ [
## mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel
](#mysql_rds_set_external_source_with_delay_for_channel)
+ [
## mysql.rds\$1set\$1source\$1auto\$1position\$1for\$1channel
](#mysql_rds_set_source_auto_position_for_channel)
+ [
## mysql.rds\$1set\$1source\$1delay\$1for\$1channel
](#mysql_rds_set_source_delay_for_channel)
+ [
## mysql.rds\$1skip\$1repl\$1error\$1for\$1channel
](#mysql_rds_skip_repl_error_for_channel)
+ [
## mysql.rds\$1start\$1replication\$1for\$1channel
](#mysql_rds_start_replication_for_channel)
+ [
## mysql.rds\$1start\$1replication\$1until\$1for\$1channel
](#mysql_rds_start_replication_until_for_channel)
+ [
## mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel
](#mysql_rds_start_replication_until_gtid_for_channel)
+ [
## mysql.rds\$1stop\$1replication\$1for\$1channel
](#mysql_rds_stop_replication_for_channel)
## mysql.rds\$1next\$1source\$1log\$1for\$1channel
Mengubah posisi log instans DB sumber ke awal log biner berikutnya pada instans DB sumber untuk saluran. Gunakan prosedur ini hanya jika Anda menerima replikasi I/O kesalahan 1236 pada replika multi-sumber.
### Sintaks
```
CALL mysql.rds_next_source_log_for_channel(
curr_master_log,
channel_name
);
```
### Parameter
*curr\$1master\$1log*
Indeks file log sumber saat ini. Misalnya, jika file saat ini bernama `mysql-bin-changelog.012345`, maka indeksnya adalah 12345. Untuk menentukan nama file log sumber saat ini, jalankan perintah `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'` dan lihat kolom `Source_Log_File`.
*channel\$1name*
Nama saluran replikasi pada replika multi-sumber. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_next_source_log_for_channel`. Jika ada kesalahan IO\$1thread, misalnya, Anda dapat menggunakan prosedur ini untuk melewati semua peristiwa dalam file log biner saat ini dan melanjutkan replikasi dari file log biner berikutnya untuk saluran yang ditentukan dalam. `channel_name`
### Contoh
Asumsikan replikasi gagal pada saluran pada replika multi-sumber. Berjalan `SHOW REPLICA STATUS FOR CHANNEL 'channel_1'\G` pada replika multi-sumber mengembalikan hasil berikut:
```
mysql> SHOW REPLICA STATUS FOR CHANNEL 'channel_1'\G
*************************** 1. row ***************************
Replica_IO_State: Waiting for source to send event
Source_Host: myhost.XXXXXXXXXXXXXXX.rr-rrrr-1.rds.amazonaws.com
Source_User: ReplicationUser
Source_Port: 3306
Connect_Retry: 60
Source_Log_File: mysql-bin-changelog.012345
Read_Source_Log_Pos: 1219393
Relay_Log_File: replica-relay-bin.000003
Relay_Log_Pos: 30223388
Relay_Source_Log_File: mysql-bin-changelog.012345
Replica_IO_Running: No
Replica_SQL_Running: Yes
Replicate_Do_DB:.
.
.
Last_IO_Errno: 1236
Last_IO_Error: Got fatal error 1236 from master when reading data from binary log: 'Client requested master to start replication from impossible position; the first event 'mysql-bin-changelog.013406' at 1219393, the last event read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4, the last byte read from '/rdsdbdata/log/binlog/mysql-bin-changelog.012345' at 4.'
Last_SQL_Errno: 0
Last_SQL_Error:
.
.
Channel_name: channel_1
.
.
-- Some fields are omitted in this example output
```
Kolom `Last_IO_Errno` menunjukkan bahwa instans menerima kesalahan I/O 1236. Kolom `Source_Log_File` menunjukkan bahwa nama file adalah `mysql-bin-changelog.012345`, yang berarti indeks file log adalah `12345`. Untuk mengatasi kesalahan, Anda dapat menelepon `mysql.rds_next_source_log_for_channel` dengan parameter berikut:
```
CALL mysql.rds_next_source_log_for_channel(12345,'channel_1');
```
## mysql.rds\$1reset\$1external\$1source\$1for\$1channel
Menghentikan proses replikasi pada saluran yang ditentukan, dan menghapus saluran dan konfigurasi terkait dari replika multi-sumber.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaksis
```
CALL mysql.rds_reset_external_source_for_channel (channel_name);
```
### Parameter
*channel\$1name*
Nama saluran replikasi pada replika multi-sumber. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_reset_external_source_for_channel`. Prosedur ini menghapus semua log relai milik saluran yang dihapus.
## mysql.rds\$1set\$1external\$1source\$1for\$1channel
Mengkonfigurasi saluran replikasi pada instans RDS for My SQL DB untuk mereplikasi data dari yang lain RDS untuk instance My SQL DB.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
**catatan**
Anda dapat menggunakan prosedur [mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel](#mysql_rds_set_external_source_with_delay_for_channel) tersimpan sebagai gantinya untuk mengonfigurasi saluran ini dengan replikasi tertunda.
### Sintaks
```
CALL mysql.rds_set_external_source_for_channel (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, channel_name
);
```
### Parameter
*host\$1name*
Nama host atau alamat IP RDS untuk instans DB SQL sumber saya.
*host\$1port*
Port yang digunakan oleh instans RDS for My SQL source DB. Jika konfigurasi jaringan Anda menyertakan replikasi port Secure Shell (SSH) yang mengonversi nomor port, tentukan nomor port yang diekspos oleh. SSH
*replication\$1user\$1name*
ID pengguna dengan `REPLICATION CLIENT` dan `REPLICATION SLAVE` izin pada instance RDS for My SQL source DB. Kami menyarankan Anda memberikan akun yang hanya digunakan untuk replikasi dengan instans DB sumber.
*replication\$1user\$1password*
Kata sandi ID pengguna yang ditentukan dalam `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nama log biner pada instance DB sumber yang berisi informasi replikasi.
*mysql\$1binary\$1log\$1file\$1location*
Lokasi di log biner `mysql_binary_log_file_name` tempat replikasi mulai membaca informasi replikasi.
Anda dapat menentukan nama dan lokasi file binlog dengan menjalankan `SHOW BINARY LOG STATUS` instans DB sumber.
Versi sebelumnya dari My SQL digunakan `SHOW MASTER STATUS` sebagai pengganti`SHOW BINARY LOG STATUS`. Jika Anda menggunakan SQL versi Saya sebelum 8.4, maka gunakan`SHOW MASTER STATUS`.
*ssl\$1encryption*
Nilai yang menentukan apakah enkripsi Secure Socket Layer (SSL) digunakan pada koneksi replikasi. 1 menentukan untuk menggunakan SSL enkripsi, 0 menentukan untuk tidak menggunakan enkripsi. Default-nya adalah 0.
Opsi `SOURCE_SSL_VERIFY_SERVER_CERT` tidak didukung. Opsi ini diatur ke 0, yang berarti koneksi dienkripsi, tetapi sertifikat tidak diverifikasi.
*channel\$1name*
Nama saluran replikasi. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_set_external_source_for_channel`. Prosedur ini harus dijalankan pada target RDS untuk instans My SQL DB tempat Anda membuat saluran replikasi.
Sebelum Anda menjalankan`mysql.rds_set_external_source_for_channel`, konfigurasikan pengguna replikasi pada instans DB sumber dengan hak istimewa yang diperlukan untuk replika multi-sumber. Untuk menghubungkan replika multi-sumber ke instans DB sumber, Anda harus menentukan `replication_user_name` dan `replication_user_password` nilai pengguna replikasi yang memiliki `REPLICATION CLIENT` dan `REPLICATION SLAVE` izin pada instans DB sumber.
**Untuk mengkonfigurasi pengguna replikasi pada instans DB sumber**
1. Menggunakan SQL klien Saya pilihan Anda, sambungkan ke instans DB sumber dan buat akun pengguna yang akan digunakan untuk replikasi. Berikut adalah contohnya.
**penting**
Sebagai praktik keamanan terbaik, tentukan kata sandi selain nilai placeholder yang ditunjukkan dalam contoh berikut.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Pada instans DB sumber, berikan `REPLICATION CLIENT` dan `REPLICATION SLAVE` hak istimewa kepada pengguna replikasi Anda. Contoh berikut memberikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada semua basis data untuk pengguna ‘repl\$1user’ domain Anda.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Untuk menggunakan replikasi terenkripsi, konfigurasikan instans DB sumber untuk menggunakan koneksi. SSL
Setelah menelepon `mysql.rds_set_external_source_for_channel` untuk mengonfigurasi saluran replikasi ini, Anda dapat memanggil [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) replika untuk memulai proses replikasi di saluran. Anda dapat menelepon [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) untuk menghentikan replikasi pada saluran dan menghapus konfigurasi saluran dari replika.
Saat Anda menelepon`mysql.rds_set_external_source_for_channel`, Amazon RDS mencatat waktu, pengguna, dan tindakan `set channel source` dalam `mysql.rds_history` tabel tanpa detail khusus saluran, dan dalam `mysql.rds_replication_status` tabel, dengan nama saluran. Informasi ini dicatat hanya untuk tujuan penggunaan dan pemantauan internal. Untuk mencatat panggilan prosedur lengkap untuk tujuan audit, pertimbangkan untuk mengaktifkan log audit atau log umum, berdasarkan persyaratan spesifik aplikasi Anda.
### Contoh
Ketika dijalankan pada instance RDS for My SQL DB, contoh berikut mengkonfigurasi saluran replikasi bernama `channel_1` pada instance DB ini untuk mereplikasi data dari sumber yang ditentukan oleh host `sourcedb.example.com` dan port. `3306`
```
call mysql.rds_set_external_source_for_channel(
'sourcedb.example.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.0777',
120,
0,
'channel_1');
```
## mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position\$1for\$1channel
Mengkonfigurasi saluran replikasi pada instans RDS for My SQL DB dengan penundaan replikasi opsional. Replikasi didasarkan pada pengidentifikasi transaksi global ()GTIDs.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaksis
```
CALL mysql.rds_set_external_source_with_auto_position_for_channel (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
, channel_name
);
```
### Parameter
*host\$1name*
Nama host atau alamat IP RDS untuk instans DB SQL sumber saya.
*host\$1port*
Port yang digunakan oleh instans RDS for My SQL source DB. Jika konfigurasi jaringan Anda menyertakan replikasi port Secure Shell (SSH) yang mengonversi nomor port, tentukan nomor port yang diekspos oleh. SSH
*replication\$1user\$1name*
ID pengguna dengan `REPLICATION CLIENT` dan `REPLICATION SLAVE` izin pada instance RDS for My SQL source DB. Kami menyarankan Anda memberikan akun yang hanya digunakan untuk replikasi dengan instans DB sumber.
*replication\$1user\$1password*
Kata sandi ID pengguna yang ditentukan dalam `replication_user_name`.
*ssl\$1encryption*
Nilai yang menentukan apakah enkripsi Secure Socket Layer (SSL) digunakan pada koneksi replikasi. 1 menentukan untuk menggunakan SSL enkripsi, 0 menentukan untuk tidak menggunakan enkripsi. Default-nya adalah 0.
Opsi `SOURCE_SSL_VERIFY_SERVER_CERT` tidak didukung. Opsi ini diatur ke 0, yang berarti koneksi dienkripsi, tetapi sertifikat tidak diverifikasi.
*delay*
Jumlah minimum detik untuk menunda replikasi dari instans DB sumber.
Batas untuk parameter ini adalah satu hari (86.400 detik).
*channel\$1name*
Nama saluran replikasi. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_set_external_source_with_auto_position_for_channel`. Prosedur ini harus dijalankan pada target RDS untuk instans My SQL DB tempat Anda membuat saluran replikasi.
Sebelum Anda menjalankan`rds_set_external_source_with_auto_position_for_channel`, konfigurasikan pengguna replikasi pada instans DB sumber dengan hak istimewa yang diperlukan untuk replika multi-sumber. Untuk menghubungkan replika multi-sumber ke instans DB sumber, Anda harus menentukan `replication_user_name` dan `replication_user_password` nilai pengguna replikasi yang memiliki `REPLICATION CLIENT` dan `REPLICATION SLAVE` izin pada instans DB sumber.
**Untuk mengkonfigurasi pengguna replikasi pada instans DB sumber**
1. Menggunakan SQL klien Saya pilihan Anda, sambungkan ke instans DB sumber dan buat akun pengguna yang akan digunakan untuk replikasi. Berikut adalah contohnya.
**penting**
Sebagai praktik keamanan terbaik, tentukan kata sandi selain nilai placeholder yang ditunjukkan dalam contoh berikut.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Pada instans DB sumber, berikan `REPLICATION CLIENT` dan `REPLICATION SLAVE` hak istimewa kepada pengguna replikasi Anda. Contoh berikut memberikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada semua basis data untuk pengguna ‘repl\$1user’ domain Anda.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Untuk menggunakan replikasi terenkripsi, konfigurasikan instans DB sumber untuk menggunakan koneksi. SSL
Sebelum Anda menelepon`mysql.rds_set_external_source_with_auto_position_for_channel`, pastikan [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_gtid_purged) untuk memanggil untuk mengatur variabel `gtid_purged` sistem dengan GTID rentang tertentu dari sumber eksternal.
Setelah menelepon `mysql.rds_set_external_source_with_auto_position_for_channel` untuk mengonfigurasi instans Amazon RDS DB sebagai replika baca pada saluran tertentu, Anda dapat memanggil [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) replika baca untuk memulai proses replikasi pada saluran tersebut.
Setelah menelepon `mysql.rds_set_external_source_with_auto_position_for_channel` untuk mengonfigurasi saluran replikasi ini, Anda dapat memanggil [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) replika untuk memulai proses replikasi di saluran. Anda dapat menelepon [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) untuk menghentikan replikasi pada saluran dan menghapus konfigurasi saluran dari replika.
### Contoh
Ketika dijalankan pada instance RDS for My SQL DB, contoh berikut mengkonfigurasi saluran replikasi bernama `channel_1` pada instance DB ini untuk mereplikasi data dari sumber yang ditentukan oleh host `sourcedb.example.com` dan port `3306` Ini menetapkan penundaan replikasi minimum menjadi satu jam (3.600 detik). Ini berarti bahwa perubahan dari sumber RDS untuk instans SQL DB Saya tidak diterapkan pada replika multi-sumber setidaknya selama satu jam.
```
call mysql.rds_set_external_source_with_auto_position_for_channel(
'sourcedb.example.com',
3306,
'repl_user',
'password',
1,
3600,
'channel_1');
```
## mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel
Mengkonfigurasi saluran replikasi pada instans RDS for My SQL DB dengan penundaan replikasi tertentu.
**penting**
Untuk menjalankan prosedur ini, `autocommit` harus diaktifkan. Untuk mengaktifkannya, atur parameter `autocommit` ke `1`. Lihat informasi tentang cara mengubah parameter di [](USER_WorkingWithParamGroups.Modifying.md).
### Sintaksis
```
CALL mysql.rds_set_external_source_with_delay_for_channel (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, delay
, channel_name
);
```
### Parameter
*host\$1name*
Nama host atau alamat IP RDS untuk instans DB SQL sumber saya.
*host\$1port*
Port yang digunakan oleh instans RDS for My SQL source DB. Jika konfigurasi jaringan Anda menyertakan replikasi port Secure Shell (SSH) yang mengonversi nomor port, tentukan nomor port yang diekspos oleh. SSH
*replication\$1user\$1name*
ID pengguna dengan `REPLICATION CLIENT` dan `REPLICATION SLAVE` izin pada instance RDS for My SQL source DB. Kami menyarankan Anda memberikan akun yang hanya digunakan untuk replikasi dengan instans DB sumber.
*replication\$1user\$1password*
Kata sandi ID pengguna yang ditentukan dalam `replication_user_name`.
*mysql\$1binary\$1log\$1file\$1name*
Nama log biner pada instance DB sumber berisi informasi replikasi.
*mysql\$1binary\$1log\$1file\$1location*
Lokasi di log biner `mysql_binary_log_file_name` tempat replikasi akan mulai membaca informasi replikasi.
Anda dapat menentukan nama dan lokasi file binlog dengan menjalankan `SHOW BINARY LOG STATUS` pada instans basis data sumber.
Versi sebelumnya dari My SQL digunakan `SHOW MASTER STATUS` sebagai pengganti`SHOW BINARY LOG STATUS`. Jika Anda menggunakan SQL versi Saya sebelum 8.4, maka gunakan`SHOW MASTER STATUS`.
*ssl\$1encryption*
Nilai yang menentukan apakah enkripsi Secure Socket Layer (SSL) digunakan pada koneksi replikasi. 1 menentukan untuk menggunakan SSL enkripsi, 0 menentukan untuk tidak menggunakan enkripsi. Default-nya adalah 0.
Opsi `SOURCE_SSL_VERIFY_SERVER_CERT` tidak didukung. Opsi ini diatur ke 0, yang berarti koneksi dienkripsi, tetapi sertifikat tidak diverifikasi.
*delay*
Jumlah minimum detik untuk menunda replikasi dari instans DB sumber.
Batas untuk parameter ini adalah satu hari (86.400 detik).
*channel\$1name*
Nama saluran replikasi. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_set_external_source_with_delay_for_channel`. Prosedur ini harus dijalankan pada target RDS untuk instans My SQL DB tempat Anda membuat saluran replikasi.
Sebelum Anda menjalankan`mysql.rds_set_external_source_with_delay_for_channel`, konfigurasikan pengguna replikasi pada instans DB sumber dengan hak istimewa yang diperlukan untuk replika multi-sumber. Untuk menghubungkan replika multi-sumber ke instans DB sumber, Anda harus menentukan `replication_user_name` dan `replication_user_password` nilai pengguna replikasi yang memiliki `REPLICATION CLIENT` dan `REPLICATION SLAVE` izin pada instans DB sumber.
**Untuk mengkonfigurasi pengguna replikasi pada instans DB sumber**
1. Menggunakan SQL klien Saya pilihan Anda, sambungkan ke instans DB sumber dan buat akun pengguna yang akan digunakan untuk replikasi. Berikut adalah contohnya.
**penting**
Sebagai praktik keamanan terbaik, tentukan kata sandi selain nilai placeholder yang ditunjukkan dalam contoh berikut.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Pada instans DB sumber, berikan `REPLICATION CLIENT` dan `REPLICATION SLAVE` hak istimewa kepada pengguna replikasi Anda. Contoh berikut memberikan hak akses `REPLICATION CLIENT` dan `REPLICATION SLAVE` pada semua basis data untuk pengguna ‘repl\$1user’ domain Anda.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Untuk menggunakan replikasi terenkripsi, konfigurasikan instans DB sumber untuk menggunakan koneksi. SSL
Setelah menelepon `mysql.rds_set_external_source_with_delay_for_channel` untuk mengonfigurasi saluran replikasi ini, Anda dapat memanggil [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) replika untuk memulai proses replikasi di saluran. Anda dapat menelepon [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) untuk menghentikan replikasi pada saluran dan menghapus konfigurasi saluran dari replika.
Saat Anda menelepon`mysql.rds_set_external_source_with_delay_for_channel`, Amazon RDS mencatat waktu, pengguna, dan tindakan `set channel source` dalam `mysql.rds_history` tabel tanpa detail khusus saluran, dan dalam `mysql.rds_replication_status` tabel, dengan nama saluran. Informasi ini dicatat hanya untuk tujuan penggunaan dan pemantauan internal. Untuk mencatat panggilan prosedur lengkap untuk tujuan audit, pertimbangkan untuk mengaktifkan log audit atau log umum, berdasarkan persyaratan spesifik aplikasi Anda.
### Contoh
Ketika dijalankan pada instance RDS for My SQL DB, contoh berikut mengkonfigurasi saluran replikasi bernama `channel_1` pada instance DB ini untuk mereplikasi data dari sumber yang ditentukan oleh host `sourcedb.example.com` dan port `3306` Ini menetapkan penundaan replikasi minimum menjadi satu jam (3.600 detik). Ini berarti bahwa perubahan dari sumber RDS untuk instans SQL DB Saya tidak diterapkan pada replika multi-sumber setidaknya selama satu jam.
```
call mysql.rds_set_external_source_with_delay_for_channel(
'sourcedb.example.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.000777',
120,
1,
3600,
'channel_1');
```
## mysql.rds\$1set\$1source\$1auto\$1position\$1for\$1channel
Menetapkan mode replikasi untuk saluran yang ditentukan untuk didasarkan pada posisi file log biner atau pada pengidentifikasi transaksi global ()GTIDs.
### Sintaks
```
CALL mysql.rds_set_source_auto_position_for_channel (
auto_position_mode
, channel_name
);
```
### Parameter
*auto\$1position\$1mode*
Nilai yang menunjukkan apakah akan menggunakan replikasi posisi file log atau replikasi GTID berbasis:
+ `0` – Gunakan metode replikasi berdasarkan posisi file log biner. Default-nya adalah `0`.
+ `1`— Gunakan metode replikasi GTID berbasis.
*channel\$1name*
Nama saluran replikasi pada replika multi-sumber. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_set_source_auto_position_for_channel`. Prosedur ini memulai ulang replikasi pada saluran yang ditentukan untuk menerapkan mode posisi auto yang ditentukan.
### Contoh
Contoh berikut menetapkan mode posisi auto untuk channel\$11 untuk menggunakan metode replikasi GTID berbasis.
```
call mysql.rds_set_source_auto_position_for_channel(1,'channel_1');
```
## mysql.rds\$1set\$1source\$1delay\$1for\$1channel
Menetapkan jumlah minimum detik untuk menunda replikasi dari instance database sumber ke replika multi-sumber untuk saluran yang ditentukan.
### Sintaks
```
CALL mysql.rds_set_source_delay_for_channel(delay, channel_name);
```
### Parameter
*delay*
Jumlah minimum detik untuk menunda replikasi dari instans DB sumber.
Batas untuk parameter ini adalah satu hari (86.400 detik).
*channel\$1name*
Nama saluran replikasi pada replika multi-sumber. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_set_source_delay_for_channel`. Untuk menggunakan prosedur ini, panggilan pertama `mysql.rds_stop_replication_for_channel` untuk menghentikan replikasi. Kemudian, panggil prosedur ini untuk mengatur nilai penundaan replikasi. Saat penundaan diatur, panggil `mysql.rds_start_replication_for_channel` untuk memulai ulang replikasi.
### Contoh
Contoh berikut menetapkan penundaan replikasi dari instance database sumber pada `channel_1` replika multi-sumber setidaknya selama satu jam (3.600 detik).
```
CALL mysql.rds_set_source_delay_for_channel(3600,'channel_1');
```
## mysql.rds\$1skip\$1repl\$1error\$1for\$1channel
Melewatkan peristiwa log biner dan menghapus kesalahan replikasi pada replika multi-sumber SQL DB Saya untuk saluran yang ditentukan.
### Sintaks
```
CALL mysql.rds_skip_repl_error_for_channel(channel_name);
```
### Parameter
*channel\$1name*
Nama saluran replikasi pada replika multi-sumber. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_skip_repl_error_for_channel` pada replika baca. Anda dapat menggunakan prosedur ini dengan cara yang sama `mysql.rds_skip_repl_error` digunakan untuk melewati kesalahan pada replika baca. Untuk informasi selengkapnya, lihat [Memanggil prosedur mysql.rds\$1skip\$1repl\$1error](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure).
**catatan**
Untuk melewati kesalahan dalam replikasi GTID berbasis, kami sarankan Anda menggunakan prosedur [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) sebagai gantinya.
Untuk menentukan apakah ada kesalahan, jalankan SQL `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G` perintah Saya. Jika kesalahan replikasi tidak parah, Anda dapat menjalankan `mysql.rds_skip_repl_error_for_channel` untuk melewati kesalahan tersebut. Jika ada beberapa kesalahan, `mysql.rds_skip_repl_error_for_channel` menghapus kesalahan pertama pada saluran replikasi yang ditentukan, kemudian memperingatkan bahwa orang lain hadir. Anda kemudian dapat menggunakan `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G` untuk menentukan tindakan yang benar untuk kesalahan berikutnya. Untuk informasi tentang nilai yang dikembalikan, lihat [SHOWREPLICASTATUSpernyataan](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) dalam SQL dokumentasi Saya.
## mysql.rds\$1start\$1replication\$1for\$1channel
Memulai replikasi dari instans RDS for My SQL DB ke replika multi-sumber pada saluran yang ditentukan.
**catatan**
Anda dapat menggunakan prosedur [mysql.rds\$1start\$1replication\$1until\$1for\$1channel](#mysql_rds_start_replication_until_for_channel) atau [mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel](#mysql_rds_start_replication_until_gtid_for_channel) tersimpan untuk memulai replikasi dari instance RDS for My SQL DB dan menghentikan replikasi di lokasi file log biner yang ditentukan.
### Sintaks
```
CALL mysql.rds_start_replication_for_channel(channel_name);
```
### Parameter
*channel\$1name*
Nama saluran replikasi pada replika multi-sumber. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_start_replication_for_channel`. Setelah Anda mengimpor data dari sumber RDS untuk instans My SQL DB, jalankan perintah ini pada replika multi-sumber untuk memulai replikasi pada saluran yang ditentukan.
### Contoh
Contoh berikut memulai replikasi pada `channel_1` replika multi-sumber.
```
CALL mysql.rds_start_replication_for_channel('channel_1');
```
## mysql.rds\$1start\$1replication\$1until\$1for\$1channel
Memulai replikasi dari instance RDS for My SQL DB pada saluran yang ditentukan dan menghentikan replikasi di lokasi file log biner yang ditentukan.
### Sintaks
```
CALL mysql.rds_start_replication_until_for_channel (
replication_log_file
, replication_stop_point
, channel_name
);
```
### Parameter
*replication\$1log\$1file*
Nama log biner pada instance DB sumber berisi informasi replikasi.
*replication\$1stop\$1point *
Lokasi di log biner `replication_log_file` tempat replikasi akan berhenti.
*channel\$1name*
Nama saluran replikasi pada replika multi-sumber. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_start_replication_until_for_channel`. Dengan prosedur ini, replikasi dimulai dan kemudian berhenti ketika posisi file binlog yang ditentukan tercapai. Prosedur ini menghentikan `SQL_THREAD` dan`IO_THREAD`.
Nama file yang ditentukan untuk `replication_log_file` parameter harus cocok dengan nama file binlog instance DB sumber.
Ketika `replication_stop_point` parameter menentukan lokasi berhenti yang di masa lalu, replikasi segera dihentikan.
### Contoh
Contoh berikut memulai replikasi`channel_1`, dan mereplikasi perubahan hingga mencapai lokasi `120` dalam file log `mysql-bin-changelog.000777` biner.
```
call mysql.rds_start_replication_until_for_channel(
'mysql-bin-changelog.000777',
120,
'channel_1'
);
```
## mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel
Memulai replikasi pada saluran tertentu dari instans RDS for My SQL DB dan menghentikan replikasi pada identifier transaksi global yang ditentukan (). GTID
### Sintaks
```
CALL mysql.rds_start_replication_until_gtid_for_channel(gtid,channel_name);
```
### Parameter
*gtid*
GTIDSetelah itu untuk menghentikan replikasi.
*channel\$1name*
Nama saluran replikasi pada replika multi-sumber. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_start_replication_until_gtid_for_channel`. Prosedur memulai replikasi pada saluran yang ditentukan dan menerapkan semua perubahan hingga GTID nilai yang ditentukan. Kemudian, ia menghentikan replikasi pada saluran.
Saat parameter `gtid` menentukan transaksi yang telah dijalankan oleh replika, replikasi akan segera dihentikan.
Sebelum Anda menjalankan prosedur ini, Anda harus menonaktifkan replikasi multi-threaded dengan menetapkan nilai dari atau ke. `replica_parallel_workers` `slave_parallel_workers` `0`
### Contoh
Contoh berikut memulai replikasi`channel_1`, dan mereplikasi perubahan hingga mencapai. GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`
```
call mysql.rds_start_replication_until_gtid_for_channel('3E11FA47-71CA-11E1-9E33-C80AA9429562:23','channel_1');
```
## mysql.rds\$1stop\$1replication\$1for\$1channel
Menghentikan replikasi dari instans My SQL DB pada saluran yang ditentukan.
### Sintaks
```
CALL mysql.rds_stop_replication_for_channel(channel_name);
```
### Parameter
*channel\$1name*
Nama saluran replikasi pada replika multi-sumber. Setiap saluran replikasi menerima peristiwa log biner dari satu sumber RDS untuk instans My SQL DB yang berjalan pada host dan port tertentu.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_stop_replication_for_channel`.
### Contoh
Contoh berikut menghentikan replikasi pada `channel_1` replika multi-sumber.
```
CALL mysql.rds_stop_replication_for_channel('channel_1');
```
# Mereplikasi transaksi menggunakan GTIDs
Prosedur tersimpan berikut mengontrol bagaimana transaksi direplikasi menggunakan pengidentifikasi transaksi global (GTIDs) dengan RDS untuk MySQL. Untuk informasi lebih lanjut tentang replikasi berdasarkan GTIDs dengan RDS untuk MySQL, lihat. [Menggunakan replikasi GTID berbasis](mysql-replication-gtid.md)
Saat menggunakan prosedur tersimpan untuk mengelola replikasi dengan pengguna replikasi yang dikonfigurasi`caching_sha2_password`, Anda harus mengonfigurasi TLS dengan menentukan. `SOURCE_SSL=1` `caching_sha2_password`adalah plugin otentikasi default untuk RDS untuk MySQL 8.4.
**Topics**
+ [
##
](#mysql_rds_skip_transaction_with_gtid)
+ [
##
](#mysql_rds_start_replication_until_gtid)
##
Melewati replikasi transaksi dengan pengenal transaksi global (GTID) yang ditentukan pada instans DB MySQL.
Anda dapat menggunakan prosedur ini untuk pemulihan bencana ketika transaksi GTID tertentu diketahui menyebabkan masalah. Gunakan prosedur tersimpan ini untuk melewati transaksi bermasalah. Contoh transaksi bermasalah mencakup transaksi yang menonaktifkan replikasi, menghapus data penting, atau menyebabkan instans DB menjadi tidak tersedia.
### Sintaksis
```
CALL mysql.rds_skip_transaction_with_gtid (
gtid_to_skip
);
```
### Parameter
*gtid\$1to\$1skip*
GTID dari transaksi replikasi yang akan dilewati.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_skip_transaction_with_gtid`.
Prosedur ini didukung untuk semua RDS untuk MySQL 5.7 versi, semua RDS untuk MySQL 8.0 versi, dan semua RDS untuk MySQL 8.4 versi.
### Contoh
Contoh berikut melewati replikasi transaksi dengan GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`.
```
CALL mysql.rds_skip_transaction_with_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
##
Memulai replikasi dari instans DB RDS for MySQL dan menghentikan replikasi segera setelah pengidentifikasi transaksi global (GTID) yang ditentukan.
### Sintaksis
```
CALL mysql.rds_start_replication_until_gtid(gtid);
```
### Parameter
*gtid*
GTID setelah replikasi dihentikan.
### Catatan penggunaan
Pengguna utama harus menjalankan prosedur `mysql.rds_start_replication_until_gtid`.
Prosedur ini didukung untuk semua RDS untuk MySQL 5.7 versi, semua RDS untuk MySQL 8.0 versi, dan semua RDS untuk MySQL 8.4 versi.
Anda dapat menggunakan prosedur ini dengan replikasi tertunda untuk pemulihan bencana. Jika Anda telah mengonfigurasi replikasi tertunda, Anda dapat menggunakan prosedur ini untuk meneruskan perubahan ke replika baca tertunda ke waktu sebelum bencana terjadi. Setelah prosedur ini menghentikan replikasi, Anda dapat mempromosikan replika baca menjadi instans DB primer baru dengan menggunakan petunjuk di [Mempromosikan replika baca menjadi instans DB mandiri](USER_ReadRepl.Promote.md).
Anda dapat mengonfigurasi replikasi tertunda menggunakan prosedur tersimpan berikut ini:
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS untuk MariaDB dan RDS untuk MySQL mayor versi 8.0 dan lebih rendah)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS untuk MySQL mayor versi 8.4 dan lebih tinggi)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_with_delay)
+ [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay)
Saat parameter `gtid` menentukan transaksi yang telah dijalankan oleh replika, replikasi akan segera dihentikan.
### Contoh
Contoh berikut memulai replikasi dan mereplikasi perubahan hingga mencapai GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`.
```
call mysql.rds_start_replication_until_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
# Memutar log kueri
Prosedur tersimpan berikut memutar SQL log Saya ke tabel cadangan. Untuk informasi selengkapnya, lihat [File log ](USER_LogAccess.Concepts.MySQL.md).
**Topics**
+ [
## mysql.rds\$1rotate\$1general\$1log
](#mysql_rds_rotate_general_log)
+ [
## mysql.rds\$1rotate\$1slow\$1log
](#mysql_rds_rotate_slow_log)
## mysql.rds\$1rotate\$1general\$1log
Merotasi tabel `mysql.general_log` ke tabel cadangan.
### Sintaks
```
CALL mysql.rds_rotate_general_log;
```
### Catatan penggunaan
Anda bisa merotasi tabel `mysql.general_log` ke tabel cadangan dengan memanggil prosedur `mysql.rds_rotate_general_log`. Saat tabel log dirotasi, tabel log saat ini disalin ke tabel log cadangan dan entri di tabel log saat ini dihapus. Jika sudah ada, tabel log cadangan akan dihapus sebelum tabel log saat ini disalin ke cadangan. Anda dapat meminta tabel log cadangan jika diperlukan. Tabel log cadangan untuk tabel `mysql.general_log` bernama `mysql.general_log_backup`.
Anda dapat menjalankan prosedur ini hanya ketika parameter `log_output` diatur ke `TABLE`.
## mysql.rds\$1rotate\$1slow\$1log
Merotasi tabel `mysql.slow_log` ke tabel cadangan.
### Sintaks
```
CALL mysql.rds_rotate_slow_log;
```
### Catatan penggunaan
Anda bisa merotasi tabel `mysql.slow_log` ke tabel cadangan dengan memanggil prosedur `mysql.rds_rotate_slow_log`. Saat tabel log dirotasi, tabel log saat ini disalin ke tabel log cadangan dan entri di tabel log saat ini dihapus. Jika sudah ada, tabel log cadangan akan dihapus sebelum tabel log saat ini disalin ke cadangan.
Anda dapat meminta tabel log cadangan jika diperlukan. Tabel log cadangan untuk tabel `mysql.slow_log` bernama `mysql.slow_log_backup`.
# Mengatur dan menampilkan konfigurasi log biner
Prosedur tersimpan berikut mengatur dan menampilkan parameter konfigurasi, seperti untuk retensi file log biner.
**Topics**
+ [
## mysql.rds\$1set\$1configuration
](#mysql_rds_set_configuration)
+ [
## mysql.rds\$1show\$1configuration
](#mysql_rds_show_configuration)
## mysql.rds\$1set\$1configuration
Menentukan jumlah jam untuk mempertahankan log biner atau jumlah detik untuk menunda replikasi.
### Sintaksis
```
CALL mysql.rds_set_configuration(name,value);
```
### Parameter
*name*
Nama parameter konfigurasi yang akan diatur.
*value*
Nilai parameter konfigurasi.
### Catatan penggunaan
Prosedur `mysql.rds_set_configuration` mendukung parameter konfigurasi berikut:
+ [binlog retention hours](#mysql_rds_set_configuration-usage-notes.binlog-retention-hours)
+ [source delay](#mysql_rds_set_configuration-usage-notes.source-delay)
+ [target delay](#mysql_rds_set_configuration-usage-notes.target-delay)
Parameter konfigurasi disimpan secara permanen dan bertahan dari boot ulang atau failover instans DB apa pun.
#### binlog retention hours
Parameter `binlog retention hours` digunakan untuk menentukan jumlah jam untuk mempertahankan file log biner. Amazon RDS biasanya membersihkan log biner sesegera mungkin, tetapi log biner mungkin masih diperlukan untuk replikasi dengan basis data MySQL di luar RDS.
Nilai default `binlog retention hours` adalah `NULL`. Untuk RDS for MySQL, `NULL` menandakan bahwa log biner tidak dipertahankan (0 jam).
Untuk menentukan jumlah jam guna mempertahankan log biner pada instans DB, gunakan prosedur tersimpan `mysql.rds_set_configuration` dan tentukan periode dengan waktu yang cukup untuk terjadinya proses replikasi, seperti yang diperlihatkan dalam contoh berikut.
`call mysql.rds_set_configuration('binlog retention hours', 24);`
**catatan**
Anda tidak dapat menggunakan nilai `0` untuk `binlog retention hours`.
Untuk instans DB MySQL, nilai `binlog retention hours` maksimumnya adalah 168 (7 hari).
Setelah Anda mengatur periode retensi, pantau penggunaan penyimpanan untuk instans DB guna memastikan bahwa log biner yang dipertahankan tidak memakan terlalu banyak ruang penyimpanan.
Untuk penerapan klaster DB multi-AZ, Anda hanya dapat mengonfigurasi retensi log biner dari instans DB penulis, dan pengaturan disebarkan ke semua instans DB pembaca secara asinkron. Jika log biner pada cluster DB melebihi setengah dari total ruang penyimpanan lokal, Amazon RDS secara otomatis memindahkan log basi ke volume EBS. Namun, log terbaru tetap berada di penyimpanan lokal, sehingga mereka dapat hilang jika ada kegagalan yang memerlukan penggantian host, atau jika Anda menskalakan database ke atas atau ke bawah.
#### source delay
Gunakan parameter `source delay` dalam replika baca untuk menentukan jumlah detik untuk menunda replikasi dari replika baca ke instans DB sumbernya. Amazon RDS biasanya mereplikasi perubahan sesegera mungkin, tetapi Anda mungkin ingin menunda replikasi di beberapa lingkungan. Misalnya, saat replikasi tertunda, Anda dapat menggulirkan replika baca tertunda ke waktu sebelum bencana terjadi. Jika tabel jatuh secara tidak sengaja, Anda dapat menggunakan replikasi tertunda untuk memulihkannya dengan cepat. Nilai default `target delay` adalah `0` (tidak menunda replikasi).
Saat digunakan, parameter ini menjalankan [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) dan menerapkan CHANGE primary TO MASTER\$1DELAY = nilai input. Jika berhasil, prosedur menyimpan parameter `source delay` ke tabel `mysql.rds_configuration`.
Untuk menentukan jumlah detik bagi Amazon RDS untuk menunda replikasi ke instans DB sumber, gunakan prosedur tersimpan `mysql.rds_set_configuration` dan tentukan jumlah detik untuk menunda replikasi. Dalam contoh berikut, replikasi tertunda setidaknya satu jam (3.600 detik).
`call mysql.rds_set_configuration('source delay', 3600);`
Lalu, prosedur menjalankan `mysql.rds_set_source_delay(3600)`.
Batas untuk parameter `source delay` adalah satu hari (86.400 detik).
#### target delay
Gunakan parameter `target delay` untuk menentukan jumlah detik guna menunda replikasi antara instans DB dan replika baca yang dikelola RDS mendatang yang dibuat dari instans ini. Parameter ini diabaikan untuk replika non-RDS-managed baca. Amazon RDS biasanya mereplikasi perubahan sesegera mungkin, tetapi Anda mungkin ingin menunda replikasi di beberapa lingkungan. Misalnya, saat replikasi tertunda, Anda dapat menggulirkan replika baca tertunda ke waktu sebelum bencana terjadi. Jika tabel jatuh secara tidak sengaja, Anda dapat menggunakan replikasi tertunda untuk memulihkannya dengan cepat. Nilai default `target delay` adalah `0` (tidak menunda replikasi).
Untuk pemulihan bencana, Anda dapat menggunakan parameter konfigurasi ini dengan prosedur tersimpan [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) atau [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid). Untuk meneruskan perubahan ke replika baca yang tertunda ke waktu sebelum bencana, Anda dapat menjalankan prosedur `mysql.rds_set_configuration` dengan pengaturan parameter ini. Setelah prosedur `mysql.rds_start_replication_until` atau `mysql.rds_start_replication_until_gtid` menghentikan replikasi, Anda dapat mempromosikan replika baca menjadi instans DB primer baru dengan mengikuti petunjuk di [Mempromosikan replika baca menjadi instans DB mandiri](USER_ReadRepl.Promote.md).
Untuk menggunakan prosedur `mysql.rds_rds_start_replication_until_gtid`, replikasi berbasis GTID harus diaktifkan. Untuk melewati transaksi berbasis GTID tertentu yang diketahui menyebabkan bencana, Anda dapat menggunakan prosedur tersimpan [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid). Untuk informasi selengkapnya tentang cara menggunakan replikasi berbasis GTID, lihat [Menggunakan replikasi GTID berbasis](mysql-replication-gtid.md).
Untuk menentukan jumlah detik bagi Amazon RDS untuk menunda replikasi ke replika baca, gunakan prosedur tersimpan `mysql.rds_set_configuration` dan tentukan jumlah detik untuk menunda replikasi. Contoh berikut menunjukkan bahwa replikasi tertunda setidaknya satu jam (3.600 detik).
`call mysql.rds_set_configuration('target delay', 3600);`
Batas untuk parameter `target delay` adalah satu hari (86.400 detik).
## mysql.rds\$1show\$1configuration
Jumlah jam untuk mempertahankan log biner.
### Sintaksis
```
CALL mysql.rds_show_configuration;
```
### Catatan penggunaan
Untuk memverifikasi jumlah jam Amazon RDS mempertahankan log biner, gunakan prosedur tersimpan `mysql.rds_show_configuration`.
### Contoh
Contoh berikut menampilkan periode retensi:
```
call mysql.rds_show_configuration;
name value description
binlog retention hours 24 binlog retention hours specifies the duration in hours before binary logs are automatically deleted.
```
# Pemanasan cache InnoDB
Prosedur tersimpan berikut menyimpan, memuat, atau membatalkan pemuatan kumpulan buffer InnoDB di instans DB RDS for MySQL. Untuk informasi selengkapnya, lihat [Pemanasan cache InnoDB untuk MySQL di Amazon RDS](MySQL.Concepts.FeatureSupport.md#MySQL.Concepts.InnoDBCacheWarming).
**Topics**
+ [
## mysql.rds\$1innodb\$1buffer\$1pool\$1dump\$1now
](#mysql_rds_innodb_buffer_pool_dump_now)
+ [
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort
](#mysql_rds_innodb_buffer_pool_load_abort)
+ [
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now
](#mysql_rds_innodb_buffer_pool_load_now)
## mysql.rds\$1innodb\$1buffer\$1pool\$1dump\$1now
Membuang status kumpulan buffer saat ini ke disk.
### Sintaksis
```
CALL mysql.rds_innodb_buffer_pool_dump_now();
```
### Catatan penggunaan
Pengguna master harus menjalankan prosedur `mysql.rds_innodb_buffer_pool_dump_now`.
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort
Membatalkan pemuatan status kumpulan buffer yang disimpan saat sedang berlangsung.
### Sintaksis
```
CALL mysql.rds_innodb_buffer_pool_load_abort();
```
### Catatan penggunaan
Pengguna master harus menjalankan prosedur `mysql.rds_innodb_buffer_pool_load_abort`.
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now
Memuat status kumpulan buffer yang disimpan dari disk.
### Sintaksis
```
CALL mysql.rds_innodb_buffer_pool_load_now();
```
### Catatan penggunaan
Pengguna master harus menjalankan prosedur `mysql.rds_innodb_buffer_pool_load_now`.