Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwalten der Multi-Source-Replikation
Mit den folgenden gespeicherten Prozeduren werden Replikationskanäle auf einem Multi-Source-Replikat von RDS für MySQL eingerichtet und verwaltet. Weitere Informationen finden Sie unter [Konfiguration multi-source-replication für Amazon RDS for MySQL](mysql-multi-source-replication.md).
Diese gespeicherten Prozeduren sind nur für DB-Instances von RDS für MySQL verfügbar, auf denen die folgenden Engine-Versionen ausgeführt werden:
+ Alle 8.4-Versionen
+ 8.0.35 und höhere Nebenversionen
+ 5.7.44 und höhere Nebenversionen
Wenn Sie gespeicherte Prozeduren verwenden, um die Replikation mit einem mit `caching_sha2_passwword` konfigurierten Replikationsbenutzer zu verwalten, müssen Sie TLS konfigurieren, indem Sie `SOURCE_SSL=1` festlegen. `caching_sha2_password` ist das Standard-Authentifizierungs-Plugin für RDS für MySQL 8.4.
**Anmerkung**
Obwohl in dieser Dokumentation Quell-DB-Instances als RDS-für-MySQL-DB-Instances bezeichnet werden, funktionieren diese Prozeduren auch für MySQL-Instances, die außerhalb von Amazon RDS ausgeführt werden.
**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
Ändert die Position des Protokolls für die Quell-DB-Instance in den Anfang des nächsten Binärprotokolls auf der Quell-DB-Instance für den Kanal. Verwenden Sie diese Prozedur nur dann, wenn Sie für ein Multi-Source-Replikat bei der Replikation einen I/O-Fehler mit der Fehlernummer 1236 erhalten.
### Syntax
```
CALL mysql.rds_next_source_log_for_channel(
curr_master_log,
channel_name
);
```
### Parameter
*curr\$1master\$1log*
Der Index der aktuellen Quell-Protokolldatei. Der Index ist im Dateinamen codiert. Eine aktuelle Datei mit dem Namen `mysql-bin-changelog.012345` hat beispielsweise den Index 12345. Um den Namen der aktuellen Quell-Protokolldatei zu ermitteln, führen Sie den Befehl `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'` aus. Sie finden den Namen anschließend im Feld `Source_Log_File`.
*channel\$1name*
Der Name des Replikationskanals auf dem Multi-Source-Replikat. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_next_source_log_for_channel` muss vom Hauptbenutzer ausgeführt werden. Wenn beispielsweise ein IO\$1Thread-Fehler auftritt, können Sie diese Prozedur verwenden, um alle Ereignisse in der aktuellen Binärprotokolldatei zu überspringen und die Replikation von der nächsten Binärprotokolldatei für den in `channel_name` angegebenen Kanal aus fortzusetzen.
### Beispiel
Angenommen, dass die Replikation auf einem Kanal für ein Multi-Source-Replikat fehlschlägt. Die Ausführung von `SHOW REPLICA STATUS FOR CHANNEL 'channel_1'\G` für das Multi-Source-Replikat gibt das folgende Ergebnis zurück:
```
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
```
Den Angeben im Feld `Last_IO_Errno` ist zu entnehmen, dass die Instance eine I/O-Fehlermeldung mit der Nummer 1236 erhalten hat. Dem Feld `Source_Log_File` ist zudem zu entnehmen, dass die betroffene Protokolldatei den Namen `mysql-bin-changelog.012345` aufweist und ihr Index folglich `12345` lautet. Zur Behebung des Fehlers können Sie `mysql.rds_next_source_log_for_channel` mit den folgenden Parametern aufrufen:
```
CALL mysql.rds_next_source_log_for_channel(12345,'channel_1');
```
## mysql.rds\$1reset\$1external\$1source\$1for\$1channel
Stoppt den Replikationsvorgang auf dem angegebenen Kanal und entfernt den Kanal und die zugehörigen Konfigurationen vom Multi-Source-Replikat.
**Wichtig**
Um diese Prozedur auszuführen, muss `autocommit` aktiviert sein. Um dies zu aktivieren, setzen Sie den `autocommit`-Parameter auf `1`. Weitere Informationen zum Ändern von Parametern finden Sie unter [Ändern von Parametern in einer DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntax
```
CALL mysql.rds_reset_external_source_for_channel (channel_name);
```
### Parameter
*channel\$1name*
Der Name des Replikationskanals auf dem Multi-Source-Replikat. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_reset_external_source_for_channel` muss vom Hauptbenutzer ausgeführt werden. Bei dieser Prozedur werden alle Relay-Protokolle gelöscht, die zu dem zu entfernenden Kanal gehören.
## mysql.rds\$1set\$1external\$1source\$1for\$1channel
Konfiguriert einen Replikationskanal in einer DB-Instance von RDS für MySQL, um die Daten aus einer anderen DB-Instance von RDS für MySQL zu replizieren.
**Wichtig**
Um diese Prozedur auszuführen, muss `autocommit` aktiviert sein. Um dies zu aktivieren, setzen Sie den `autocommit`-Parameter auf `1`. Weitere Informationen zum Ändern von Parametern finden Sie unter [Ändern von Parametern in einer DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
**Anmerkung**
Sie können stattdessen die gespeicherte Prozedur [mysql.rds\$1set\$1external\$1source\$1with\$1delay\$1for\$1channel](#mysql_rds_set_external_source_with_delay_for_channel) verwenden, um diesen Kanal mit verzögerter Replikation zu konfigurieren.
### Syntax
```
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*
Der Hostname bzw. die IP-Adresse der Quell-DB-Instance von RDS für MySQL.
*host\$1port*
Der von der Quell-DB-Instance von RDS für MySQL verwendete Port. Wenn Ihre Netzwerkkonfiguration die Replikation über Secure Shell (SSH)-Ports einschließt, welche die Portnummer konvertiert, geben Sie für diesen Parameter die von SSH offengelegte Portnummer an.
*replication\$1user\$1name*
Die ID eines Benutzers mit den Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` auf der Quell-DB-Instance von RDS für MySQL. Es wird empfohlen, ein Konto bereitzustellen, das ausschließlich für die Replikation mit der Quell-DB-Instance genutzt wird.
*replication\$1user\$1password*
Das zu dem in `replication_user_name` angegebenen User-ID gehörige Passwort.
*mysql\$1binary\$1log\$1file\$1name*
Der Name des Binärprotokolls auf der Quell-DB-Instance, die die Replikationsinformationen enthält.
*mysql\$1binary\$1log\$1file\$1location*
Die Position in der binären Protokolldatei `mysql_binary_log_file_name`, ab der bei der Replikation die Replikationsinformationen gelesen werden.
Sie können den Namen und den Speicherort der Binärprotokolldatei ermitteln, indem Sie `SHOW BINARY LOG STATUS` auf der Quell-DB-Instance ausführen.
Frühere Versionen von MySQL verwenden `SHOW MASTER STATUS` anstelle von `SHOW BINARY LOG STATUS`. Wenn Sie eine MySQL-Version vor 8.4 verwenden, nutzen Sie `SHOW MASTER STATUS`.
*ssl\$1encryption*
Ein Wert, der angibt, ob die SSL-Verschlüsselung (Secure Socket Layer) für die Replikationsverbindung verwendet wird. 1 = SSL-Verschlüsselung, 0 = keine Verschlüsselung. Der Standardwert ist 0.
Die Option `SOURCE_SSL_VERIFY_SERVER_CERT` wird nicht unterstützt. Diese Option ist auf 0 gesetzt, was bedeutet, dass die Verbindung verschlüsselt ist, aber die Zertifikate nicht überprüft werden.
*channel\$1name*
Der Name des Replikationskanals. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_set_external_source_for_channel` muss vom Hauptbenutzer ausgeführt werden. Diese Prozedur muss auf der Ziel-DB-Instance von RDS für MySQL ausgeführt werden, auf der Sie den Replikationskanal erstellen.
Konfigurieren Sie vor der Ausführung von `mysql.rds_set_external_source_for_channel` einen Replikationsbenutzer auf der Quell-DB-Instance mit den für das Multi-Source-Replikat erforderlichen Berechtigungen. Um eine Verbindung des Multi-Source-Replikats mit der Quell-DB-Instance herzustellen, müssen Sie die Werte `replication_user_name` und `replication_user_password` eines Replikationsbenutzers angeben, der über die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für die Quell-DB-Instance verfügt.
**So konfigurieren Sie einen Replikationsbenutzer auf der Quell-DB-Instance**
1. Stellen Sie mithilfe eines MySQL-Clients Ihrer Wahl eine Verbindung mit der Quell-DB-Instance her und erstellen Sie ein Benutzerkonto, das für die Replikation verwendet werden soll. Im Folgenden wird ein Beispiel gezeigt.
**Wichtig**
Geben Sie als bewährte Sicherheitsmethode ein anderes Passwort als im Platzhalterwert in den folgenden Beispielen angegeben an.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Erteilen Sie dem Replikationsbenutzer auf der Quell-DB-Instance die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE`. Im folgenden Beispiel werden dem Benutzer 'repl\$1user' für Ihre Domäne die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für alle Datenbanken erteilt.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Um die verschlüsselte Replikation zu verwenden, konfigurieren Sie die Quell-DB-Instance für die Verwendung von SSL-Verbindungen.
Nachdem Sie `mysql.rds_set_external_source_for_channel` aufgerufen haben, um diesen Replikationskanal zu konfigurieren, können Sie [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) auf dem Replikat aufrufen, um den Replikationsvorgang auf dem Kanal zu starten. Sie können [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) aufrufen, um die Replikation auf dem Kanal zu beenden und die Kanalkonfiguration vom Replikat zu entfernen.
Beim Aufrufen von `mysql.rds_set_external_source_for_channel` werden in Amazon RDS die Uhrzeit, der Benutzer und eine Aktion von `set channel source` in der Tabelle `mysql.rds_history` ohne kanalspezifische Details und in der Tabelle `mysql.rds_replication_status` mit dem Kanalnamen aufgezeichnet. Diese Informationen werden nur für die interne Verwendung und zu Überwachungszwecken aufgezeichnet. Um den gesamten Prozeduraufruf zu Audit-Zwecken aufzuzeichnen, sollten Sie je nach den spezifischen Anforderungen Ihrer Anwendung die Aktivierung von Audit-Protokollen oder allgemeinen Protokollen in Betracht ziehen.
### Beispiele
Bei der Ausführung auf einer DB-Instance von RDS für MySQL wird im folgenden Beispiel der Replikationskanal `channel_1` auf dieser DB-Instance konfiguriert, um Daten von der durch den Host `sourcedb.example.com` und Port `3306` angegebenen Quelle zu replizieren.
```
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
Konfiguriert einen Replikationskanal auf einer DB-Instance von RDS für MySQL mit einer optionalen Replikationsverzögerung. Dies Replikation basiert auf globalen Transaktionskennungen (GTIDs).
**Wichtig**
Um diese Prozedur auszuführen, muss `autocommit` aktiviert sein. Um dies zu aktivieren, setzen Sie den `autocommit`-Parameter auf `1`. Weitere Informationen zum Ändern von Parametern finden Sie unter [Ändern von Parametern in einer DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntax
```
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*
Der Hostname bzw. die IP-Adresse der Quell-DB-Instance von RDS für MySQL.
*host\$1port*
Der von der Quell-DB-Instance von RDS für MySQL verwendete Port. Wenn Ihre Netzwerkkonfiguration die Replikation über Secure Shell (SSH)-Ports einschließt, welche die Portnummer konvertiert, geben Sie für diesen Parameter die von SSH offengelegte Portnummer an.
*replication\$1user\$1name*
Die ID eines Benutzers mit den Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` auf der Quell-DB-Instance von RDS für MySQL. Es wird empfohlen, ein Konto bereitzustellen, das ausschließlich für die Replikation mit der Quell-DB-Instance genutzt wird.
*replication\$1user\$1password*
Das zu dem in `replication_user_name` angegebenen User-ID gehörige Passwort.
*ssl\$1encryption*
Ein Wert, der angibt, ob die SSL-Verschlüsselung (Secure Socket Layer) für die Replikationsverbindung verwendet wird. 1 = SSL-Verschlüsselung, 0 = keine Verschlüsselung. Der Standardwert ist 0.
Die Option `SOURCE_SSL_VERIFY_SERVER_CERT` wird nicht unterstützt. Diese Option ist auf 0 gesetzt, was bedeutet, dass die Verbindung verschlüsselt ist, aber die Zertifikate nicht überprüft werden.
*Verzögerung*
Die Mindestanzahl von Sekunden, um die die Replikation von der Quell-DB-Instance verzögert werden soll.
Die Obergrenze für diesen Parameter beträgt einen Tag (86 400 Sekunden).
*channel\$1name*
Der Name des Replikationskanals. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_set_external_source_with_auto_position_for_channel` muss vom Hauptbenutzer ausgeführt werden. Diese Prozedur muss auf der Ziel-DB-Instance von RDS für MySQL ausgeführt werden, auf der Sie den Replikationskanal erstellen.
Konfigurieren Sie vor der Ausführung von `rds_set_external_source_with_auto_position_for_channel` einen Replikationsbenutzer auf der Quell-DB-Instance mit den für das Multi-Source-Replikat erforderlichen Berechtigungen. Um eine Verbindung des Multi-Source-Replikats mit der Quell-DB-Instance herzustellen, müssen Sie die Werte `replication_user_name` und `replication_user_password` eines Replikationsbenutzers angeben, der über die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für die Quell-DB-Instance verfügt.
**So konfigurieren Sie einen Replikationsbenutzer auf der Quell-DB-Instance**
1. Stellen Sie mithilfe eines MySQL-Clients Ihrer Wahl eine Verbindung mit der Quell-DB-Instance her und erstellen Sie ein Benutzerkonto, das für die Replikation verwendet werden soll. Im Folgenden wird ein Beispiel gezeigt.
**Wichtig**
Geben Sie als bewährte Sicherheitsmethode ein anderes Passwort als im Platzhalterwert in den folgenden Beispielen angegeben an.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Erteilen Sie dem Replikationsbenutzer auf der Quell-DB-Instance die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE`. Im folgenden Beispiel werden dem Benutzer 'repl\$1user' für Ihre Domäne die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für alle Datenbanken erteilt.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Um die verschlüsselte Replikation zu verwenden, konfigurieren Sie die Quell-DB-Instance für die Verwendung von SSL-Verbindungen.
Stellen Sie vor dem Aufrufen von `mysql.rds_set_external_source_with_auto_position_for_channel` sicher, dass Sie [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_gtid_purged) aufrufen, um die Systemvariable `gtid_purged` mit einem bestimmten GTID-Bereich aus einer externen Quelle aufrufen.
Nachdem Sie `mysql.rds_set_external_source_with_auto_position_for_channel` aufgerufen haben, um eine Amazon-RDS-DB-Instance als Lesereplikat auf einem bestimmten Kanal zu konfigurieren, können Sie [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) für das Lesereplikat aufrufen, um die Replikation auf diesem Kanal zu starten.
Nachdem Sie `mysql.rds_set_external_source_with_auto_position_for_channel` aufgerufen haben, um diesen Replikationskanal zu konfigurieren, können Sie [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) auf dem Replikat aufrufen, um den Replikationsvorgang auf dem Kanal zu starten. Sie können [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) aufrufen, um die Replikation auf dem Kanal zu beenden und die Kanalkonfiguration vom Replikat zu entfernen.
### Beispiele
Bei der Ausführung auf einer DB-Instance von RDS für MySQL wird im folgenden Beispiel der Replikationskanal `channel_1` auf dieser DB-Instance konfiguriert, um Daten von der durch den Host `sourcedb.example.com` und Port `3306` angegebenen Quelle zu replizieren. Die minimale Replikationsverzögerung wird auf eine Stunde (3 600 Sekunden) festgelegt. Dies bedeutet, dass eine Änderung an der Quell-DB-Instance von RDS für MySQL frühestens nach einer Stunde auf das Multi-Source-Replikat angewendet wird.
```
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
Konfiguriert einen Replikationskanal auf einer DB-Instance von RDS für MySQL mit einer angegebenen Replikationsverzögerung.
**Wichtig**
Um diese Prozedur auszuführen, muss `autocommit` aktiviert sein. Um dies zu aktivieren, setzen Sie den `autocommit`-Parameter auf `1`. Weitere Informationen zum Ändern von Parametern finden Sie unter [Ändern von Parametern in einer DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Syntax
```
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*
Der Hostname bzw. die IP-Adresse der Quell-DB-Instance von RDS für MySQL.
*host\$1port*
Der von der Quell-DB-Instance von RDS für MySQL verwendete Port. Wenn Ihre Netzwerkkonfiguration die Replikation über Secure Shell (SSH)-Ports einschließt, welche die Portnummer konvertiert, geben Sie für diesen Parameter die von SSH offengelegte Portnummer an.
*replication\$1user\$1name*
Die ID eines Benutzers mit den Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` auf der Quell-DB-Instance von RDS für MySQL. Es wird empfohlen, ein Konto bereitzustellen, das ausschließlich für die Replikation mit der Quell-DB-Instance genutzt wird.
*replication\$1user\$1password*
Das zu dem in `replication_user_name` angegebenen User-ID gehörige Passwort.
*mysql\$1binary\$1log\$1file\$1name*
Der Name des Binärprotokolls auf der Quell-DB-Instance, die die Replikationsinformationen enthält.
*mysql\$1binary\$1log\$1file\$1location*
Die Position innerhalb der für `mysql_binary_log_file_name` angegebenen binären Protokolldatei, ab der bei der Replikation die Replikationsinformationen gelesen werden.
Sie können den Namen und den Speicherort der Binlog-Datei ermitteln, indem Sie `SHOW BINARY LOG STATUS` auf der Quelldatenbank-Instance starten.
Frühere Versionen von MySQL verwenden `SHOW MASTER STATUS` anstelle von `SHOW BINARY LOG STATUS`. Wenn Sie eine MySQL-Version vor 8.4 verwenden, nutzen Sie `SHOW MASTER STATUS`.
*ssl\$1encryption*
Ein Wert, der angibt, ob die SSL-Verschlüsselung (Secure Socket Layer) für die Replikationsverbindung verwendet wird. 1 = SSL-Verschlüsselung, 0 = keine Verschlüsselung. Der Standardwert ist 0.
Die Option `SOURCE_SSL_VERIFY_SERVER_CERT` wird nicht unterstützt. Diese Option ist auf 0 gesetzt, was bedeutet, dass die Verbindung verschlüsselt ist, aber die Zertifikate nicht überprüft werden.
*Verzögerung*
Die Mindestanzahl von Sekunden, um die die Replikation von der Quell-DB-Instance verzögert werden soll.
Die Obergrenze für diesen Parameter beträgt einen Tag (86 400 Sekunden).
*channel\$1name*
Der Name des Replikationskanals. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_set_external_source_with_delay_for_channel` muss vom Hauptbenutzer ausgeführt werden. Diese Prozedur muss auf der Ziel-DB-Instance von RDS für MySQL ausgeführt werden, auf der Sie den Replikationskanal erstellen.
Konfigurieren Sie vor der Ausführung von `mysql.rds_set_external_source_with_delay_for_channel` einen Replikationsbenutzer auf der Quell-DB-Instance mit den für das Multi-Source-Replikat erforderlichen Berechtigungen. Um eine Verbindung des Multi-Source-Replikats mit der Quell-DB-Instance herzustellen, müssen Sie die Werte `replication_user_name` und `replication_user_password` eines Replikationsbenutzers angeben, der über die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für die Quell-DB-Instance verfügt.
**So konfigurieren Sie einen Replikationsbenutzer auf der Quell-DB-Instance**
1. Stellen Sie mithilfe eines MySQL-Clients Ihrer Wahl eine Verbindung mit der Quell-DB-Instance her und erstellen Sie ein Benutzerkonto, das für die Replikation verwendet werden soll. Im Folgenden wird ein Beispiel gezeigt.
**Wichtig**
Geben Sie als bewährte Sicherheitsmethode ein anderes Passwort als im Platzhalterwert in den folgenden Beispielen angegeben an.
```
CREATE USER 'repl_user'@'example.com' IDENTIFIED BY 'password';
```
1. Erteilen Sie dem Replikationsbenutzer auf der Quell-DB-Instance die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE`. Im folgenden Beispiel werden dem Benutzer 'repl\$1user' für Ihre Domäne die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für alle Datenbanken erteilt.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'example.com';
```
Um die verschlüsselte Replikation zu verwenden, konfigurieren Sie die Quell-DB-Instance für die Verwendung von SSL-Verbindungen.
Nachdem Sie `mysql.rds_set_external_source_with_delay_for_channel` aufgerufen haben, um diesen Replikationskanal zu konfigurieren, können Sie [mysql.rds\$1start\$1replication\$1for\$1channel](#mysql_rds_start_replication_for_channel) auf dem Replikat aufrufen, um den Replikationsvorgang auf dem Kanal zu starten. Sie können [mysql.rds\$1reset\$1external\$1source\$1for\$1channel](#mysql_rds_reset_external_source_for_channel) aufrufen, um die Replikation auf dem Kanal zu beenden und die Kanalkonfiguration vom Replikat zu entfernen.
Beim Aufrufen von `mysql.rds_set_external_source_with_delay_for_channel` werden in Amazon RDS die Uhrzeit, der Benutzer und eine Aktion von `set channel source` in der Tabelle `mysql.rds_history` ohne kanalspezifische Details und in der Tabelle `mysql.rds_replication_status` mit dem Kanalnamen aufgezeichnet. Diese Informationen werden nur für die interne Verwendung und zu Überwachungszwecken aufgezeichnet. Um den gesamten Prozeduraufruf zu Audit-Zwecken aufzuzeichnen, sollten Sie je nach den spezifischen Anforderungen Ihrer Anwendung die Aktivierung von Audit-Protokollen oder allgemeinen Protokollen in Betracht ziehen.
### Beispiele
Bei der Ausführung auf einer DB-Instance von RDS für MySQL wird im folgenden Beispiel der Replikationskanal `channel_1` auf dieser DB-Instance konfiguriert, um Daten von der durch den Host `sourcedb.example.com` und Port `3306` angegebenen Quelle zu replizieren. Die minimale Replikationsverzögerung wird auf eine Stunde (3 600 Sekunden) festgelegt. Dies bedeutet, dass eine Änderung an der Quell-DB-Instance von RDS für MySQL frühestens nach einer Stunde auf das Multi-Source-Replikat angewendet wird.
```
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
Legt den Replikationsmodus für den angegebenen Kanal als auf Binärprotokolldateipositionen oder globalen Transaktionskennungen (GTIDs) basierend fest.
### Syntax
```
CALL mysql.rds_set_source_auto_position_for_channel (
auto_position_mode
, channel_name
);
```
### Parameter
*auto\$1position\$1mode*
Ein Wert, der angibt, ob die Replikation auf Basis der Protokolldateiposition oder der GTID verwendet werden soll:
+ `0` – Verwendung der auf der Binärprotokolldateiposition basierenden Replikationsmethode. Der Standardwert ist `0`.
+ `1` – Verwendung der auf GTID basierenden Replikationsmethode.
*channel\$1name*
Der Name des Replikationskanals auf dem Multi-Source-Replikat. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_set_source_auto_position_for_channel` muss vom Hauptbenutzer ausgeführt werden. Mit dieser Prozedur wird die Replikation auf dem festgelegten Kanal neu gestartet, um den angegebenen automatischen Positionierungsmodus anzuwenden.
### Beispiele
Im folgenden Beispiel wird der automatischen Positionierungsmodus für channel\$11 so eingestellt, dass er die GTID-basierte Replikationsmethode verwendet.
```
call mysql.rds_set_source_auto_position_for_channel(1,'channel_1');
```
## mysql.rds\$1set\$1source\$1delay\$1for\$1channel
Legt die Mindestanzahl von Sekunden fest, um die die Replikation von der Quelldatenbank-Instance auf das Multi-Source-Replikat für den angegebenen Kanal verzögert werden soll.
### Syntax
```
CALL mysql.rds_set_source_delay_for_channel(delay, channel_name);
```
### Parameter
*Verzögerung*
Die Mindestanzahl von Sekunden, um die die Replikation von der Quell-DB-Instance verzögert werden soll.
Die Obergrenze für diesen Parameter beträgt einen Tag (86 400 Sekunden).
*channel\$1name*
Der Name des Replikationskanals auf dem Multi-Source-Replikat. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_set_source_delay_for_channel` muss vom Hauptbenutzer ausgeführt werden. Um diese Prozedur zu verwenden, rufen Sie zuerst `mysql.rds_stop_replication_for_channel` auf, um die Replikation zu stoppen. Rufen Sie dann diese Prozedur auf, um den Wert für die Replikationsverzögerung festzulegen. Wenn die Verzögerung festgelegt wurde, rufen Sie `mysql.rds_start_replication_for_channel` auf, um die Replikation neu zu starten.
### Beispiele
Im folgenden Beispiel wird die Verzögerung für die Replikation von der Quelldatenbank-Instance auf `channel_1` des Multi-Source-Replikats auf mindestens eine Stunde (3 600 Sekunden) festgelegt.
```
CALL mysql.rds_set_source_delay_for_channel(3600,'channel_1');
```
## mysql.rds\$1skip\$1repl\$1error\$1for\$1channel
Überspringt ein Binärprotokollereignis und löscht einen Replikationsfehler auf einem MySQL-DB-Multi-Source-Replikat für den angegebenen Kanal.
### Syntax
```
CALL mysql.rds_skip_repl_error_for_channel(channel_name);
```
### Parameter
*channel\$1name*
Der Name des Replikationskanals auf dem Multi-Source-Replikat. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Der Hauptbenutzer muss die Prozedur `mysql.rds_skip_repl_error_for_channel` auf einem Lesereplikat ausführen. Sie können diese Prozedur in ähnlicher Weise verwenden, wie `mysql.rds_skip_repl_error` zum Überspringen eines Fehlers in einem Lesereplikat genutzt wird. Weitere Informationen finden Sie unter [Aufrufen der Prozedur mysql.rds\$1skip\$1repl\$1error](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure).
**Anmerkung**
Um Fehler bei der GTID-basierten Replikation zu überspringen, wird empfohlen, stattdessen die Prozedur [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) zu verwenden.
Führen Sie den MySQL-Befehl `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G` aus, um festzustellen, ob Fehler aufgetreten sind. Wenn ein Replikationsfehler nicht als kritisch eingestuft, ist, können Sie `mysql.rds_skip_repl_error_for_channel` ausführen, um den Fehler zu überspringen. Wenn mehrere Fehler aufgetreten sind, löscht `mysql.rds_skip_repl_error_for_channel` den ersten Fehler im angegebenen Replikationskanal und weist darauf hin, dass es weitere Fehlermeldungen gibt. In diesem Fall können Sie mithilfe von `SHOW REPLICA STATUS FOR CHANNEL 'channel_name'\G` die angemessene Vorgehensweise bei der Handhabung des nächsten Fehlers ermitteln. Informationen zu den zurückgegebenen Werten finden Sie unter [SHOW REPLICA STATUS-Anweisung](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) in der MySQL-Dokumentation.
## mysql.rds\$1start\$1replication\$1for\$1channel
Initiiert die Replikation von einer DB-Instance von RDS für MySQL zu einem Multi-Source-Replikat auf dem angegebenen Kanal.
**Anmerkung**
Sie können die gespeicherte Prozedur [mysql.rds\$1start\$1replication\$1until\$1for\$1channel](#mysql_rds_start_replication_until_for_channel) oder [mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel](#mysql_rds_start_replication_until_gtid_for_channel) verwenden, um die Replikation von einer RDS für MySQL-DB-Instance zu initiieren und die Replikation an der angegebenen Position der Binärprotokolldatei zu stoppen.
### Syntax
```
CALL mysql.rds_start_replication_for_channel(channel_name);
```
### Parameter
*channel\$1name*
Der Name des Replikationskanals auf dem Multi-Source-Replikat. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_start_replication_for_channel` muss vom Hauptbenutzer ausgeführt werden. Nachdem Sie die Daten aus der Quell-DB-Instance von RDS für MySQL importiert haben, führen Sie diesen Befehl für das Multi-Source-Replikat aus, um die Replikation auf dem angegebenen Kanal zu starten.
### Beispiele
Im folgenden Beispiel wird die Replikation auf `channel_1` des Multi-Source-Replikats gestartet.
```
CALL mysql.rds_start_replication_for_channel('channel_1');
```
## mysql.rds\$1start\$1replication\$1until\$1for\$1channel
Initiiert die Replikation von einer DB-Instance von RDS für MySQL auf dem festgelegten Kanal und stoppt die Replikation an der angegebenen Position in der Binärprotokolldatei.
### Syntax
```
CALL mysql.rds_start_replication_until_for_channel (
replication_log_file
, replication_stop_point
, channel_name
);
```
### Parameter
*replication\$1log\$1file*
Der Name des Binärprotokolls auf der Quell-DB-Instance, die die Replikationsinformationen enthält.
*replication\$1stop\$1point *
Die Position im `replication_log_file`-Binärprotokoll, an der die Replikation stoppt.
*channel\$1name*
Der Name des Replikationskanals auf dem Multi-Source-Replikat. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_start_replication_until_for_channel` muss vom Hauptbenutzer ausgeführt werden. Bei dieser Prozedur wird die Replikation gestartet und dann beendet, wenn die angegebene Position in der Binärprotokolldatei erreicht wurde. Mit dieser Prozedur wird sowohl der `SQL_THREAD` als auch der `IO_THREAD` beendet.
Der für den Parameter `replication_log_file` angegebene Dateiname muss mit dem Namen der Binärprotokolldatei der Quell-DB-Instance übereinstimmen.
Wenn der Parameter `replication_stop_point` eine Stoppposition angibt, die in der Vergangenheit liegt, wird die Replikation sofort gestoppt.
### Beispiele
Das folgende Beispiel initiiert die Replikation auf `channel_1` und repliziert die Änderungen, bis die Position `120` in der Binärprotokolldatei `mysql-bin-changelog.000777` erreicht wurde.
```
call mysql.rds_start_replication_until_for_channel(
'mysql-bin-changelog.000777',
120,
'channel_1'
);
```
## mysql.rds\$1start\$1replication\$1until\$1gtid\$1for\$1channel
Initiiert die Replikation auf dem angegebenen Kanal von einer DB-Instance von RDS für MySQL und stoppt die Replikation an der angegebenen globalen Transaktionskennung (GTID).
### Syntax
```
CALL mysql.rds_start_replication_until_gtid_for_channel(gtid,channel_name);
```
### Parameter
*gtid*
Die GTID, nach der die Replikation stoppen soll.
*channel\$1name*
Der Name des Replikationskanals auf dem Multi-Source-Replikat. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_start_replication_until_gtid_for_channel` muss vom Hauptbenutzer ausgeführt werden. Die Prozedur startet die Replikation auf dem festgelegten Kanal und wendet alle Änderungen bis zum angegebenen GTID-Wert an. Anschließend wird die Replikation auf dem Kanal beendet.
Wenn der Parameter `gtid` eine Transaktion angibt, die bereits von dem Replikat ausgeführt wurde, wird die Replikation sofort gestoppt.
Bevor Sie diese Prozedur ausführen, müssen Sie die Multi-Thread-Replikation deaktivieren, indem Sie den Wert `replica_parallel_workers` oder `slave_parallel_workers` auf `0` festlegen.
### Beispiele
Das folgende Beispiel initiiert die Replikation auf `channel_1` und repliziert die Änderungen, bis die GTID `3E11FA47-71CA-11E1-9E33-C80AA9429562:23` erreicht wurde.
```
call mysql.rds_start_replication_until_gtid_for_channel('3E11FA47-71CA-11E1-9E33-C80AA9429562:23','channel_1');
```
## mysql.rds\$1stop\$1replication\$1for\$1channel
Stoppt die Replikation von einer MySQL-DB-Instance auf dem angegebenen Kanal.
### Syntax
```
CALL mysql.rds_stop_replication_for_channel(channel_name);
```
### Parameter
*channel\$1name*
Der Name des Replikationskanals auf dem Multi-Source-Replikat. Jeder Replikationskanal empfängt die binären Protokollereignisse von einer einzigen DB-Instance von RDS für MySQL, die auf einem bestimmten Host und Port ausgeführt wird.
### Nutzungshinweise
Die Prozedur `mysql.rds_stop_replication_for_channel` muss vom Hauptbenutzer ausgeführt werden.
### Beispiele
Im folgenden Beispiel wird die Replikation auf `channel_1` des Multi-Source-Replikats beendet.
```
CALL mysql.rds_stop_replication_for_channel('channel_1');
```