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.
# Referenz für gespeicherte RDS-für-MySQL-Verfahren
Diese Themen beschreiben gespeicherte Prozeduren, die für Amazon RDS-Instances verfügbar sind, die die MySQL-DB-Engine ausführen. Diese Prozeduren müssen vom Hauptbenutzer ausgeführt werden.
**Topics**
+ [Erfassen und Verwalten des globalen Statusverlaufs](mysql-stored-proc-gsh.md)
+ [Konfigurieren, Starten und Beenden der Binärprotokollreplikation (binlog)](mysql-stored-proc-replicating.md)
+ [Beenden einer Sitzung oder Abfrage](mysql-stored-proc-ending.md)
+ [Verwalten von Aktiv/Aktiv-Clustern](mysql-stored-proc-active-active-clusters.md)
+ [Verwalten der Multi-Source-Replikation](mysql-stored-proc-multi-source-replication.md)
+ [Transaktionen replizieren mit GTIDs](mysql-stored-proc-gtid.md)
+ [Rotieren der Abfrageprotokolle](mysql-stored-proc-logging.md)
+ [Festlegen und Anzeigen der Konfiguration des Binärprotokolls](mysql-stored-proc-configuring.md)
+ [Wärmen des InnoDB-Caches](mysql-stored-proc-warming.md)
# Erfassen und Verwalten des globalen Statusverlaufs
Amazon RDS stellt einen Satz von Verfahren bereit, die Snapshots der Werte dieser Statusvariablen im Zeitverlauf erstellen und diese zusammen mit allen Änderungen seit dem letzten Snapshot in eine Tabelle schreiben. Diese Infrastruktur wird als Global Status History bezeichnet. Weitere Informationen finden Sie unter [Verwalten des globalen Statusverlaufs für RDS für MySQL](Appendix.MySQL.CommonDBATasks.GoSH.md).
Die folgenden gespeicherten Verfahren verwalten, wie die Global Status History erfasst und verwaltet wird.
**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
Generiert einen Snapshot auf Anforderung für den globalen Statusverlauf (Global Status History, GoSH).
### Syntax
```
CALL mysql.rds_collect_global_status_history;
```
## mysql.rds\$1disable\$1gsh\$1collector
Deaktiviert die periodische Generierung von Snapshots des globalen Statusverlaufs (Global Status History, GoSH).
### Syntax
```
CALL mysql.rds_disable_gsh_collector;
```
## mysql.rds\$1disable\$1gsh\$1rotation
Schaltet die Rotation der `mysql.global_status_history`-Tabelle aus.
### Syntax
```
CALL mysql.rds_disable_gsh_rotation;
```
## mysql.rds\$1enable\$1gsh\$1collector
Aktiviert den globalen Statusverlauf (Global Status History, GoSH), um Standard-Snapshots in zeitlichen Abständen, die mithilfe von `rds_set_gsh_collector` festgelegt wurden, zu generieren.
### Syntax
```
CALL mysql.rds_enable_gsh_collector;
```
## mysql.rds\$1enable\$1gsh\$1rotation
Aktiviert die Rotation der Inhalte der Tabelle `mysql.global_status_history` zu `mysql.global_status_history_old` in zeitlichen Abständen, die durch `rds_set_gsh_rotation` angegeben werden.
### Syntax
```
CALL mysql.rds_enable_gsh_rotation;
```
## mysql.rds\$1rotate\$1global\$1status\$1history
Rotiert die Inhalte der Tabelle `mysql.global_status_history` bei Anforderung zu `mysql.global_status_history_old`.
### Syntax
```
CALL mysql.rds_rotate_global_status_history;
```
## mysql.rds\$1set\$1gsh\$1collector
Gibt den zeitlichen Abstand für die Generierung von aufeinander folgenden Snapshots durch den globalen Statusverlauf (Global Status History, GoSH) an.
### Syntax
```
CALL mysql.rds_set_gsh_collector(intervalPeriod);
```
### Parameter
*intervalPeriod*
Der zeitliche Abstand in Minuten für die periodische Generierung von Snapshots. Der Standardwert ist `5`.
## mysql.rds\$1set\$1gsh\$1rotation
Gibt den zeitlichen Abstand in Tagen für die periodische Rotation der Tabelle `mysql.global_status_history` an.
### Syntax
```
CALL mysql.rds_set_gsh_rotation(intervalPeriod);
```
### Parameter
*intervalPeriod*
Der zeitliche Abstand in Tagen für die periodische Tabellenrotation. Der Standardwert ist `7`.
# Konfigurieren, Starten und Beenden der Binärprotokollreplikation (binlog)
Die folgenden gespeicherten Prozeduren steuern, wie Transaktionen aus einer externen Datenbank in RDS für MySQL oder aus Aurora für MySQL in eine externen Datenbank repliziert werden.
Wenn Sie gespeicherte Prozeduren verwenden, um die Replikation mit einem mit `caching_sha2_password` 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. Weitere Informationen finden Sie unter [Verschlüsseln mit SSL/TLS](mysql-ssl-connections.md).
Informationen zum Konfigurieren, Verwenden und Verwalten von Lesereplikaten finden Sie unter [Arbeiten mit MySQL-Lesereplikaten](USER_MySQL.Replication.ReadReplicas.md).
**Topics**
+ [](#mysql_rds_next_master_log)
+ [mysql.rds\$1next\$1source\$1log (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#mysql_rds_next_source_log)
+ [mysql.rds\$1next\$1master\$1log (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_reset_external_master)
+ [mysql.rds\$1next\$1source\$1log (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#mysql_rds_reset_external_source)
+ [mysql.rds\$1set\$1external\$1master (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_set_external_master)
+ [mysql.rds\$1set\$1external\$1source (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#mysql_rds_set_external_source)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_set_external_master_with_auto_position)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#mysql_rds_set_external_source_with_auto_position)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#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\$1set\$1source\$1auto\$1position (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#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)
##
Ändert die Protokollposition der Quelldatenbankinstance in den Anfang des nächsten Binärprotokolls auf der Quelldatenbankinstance. Verwenden Sie dieses Verfahren nur, wenn Sie bei einer Read Replica den Replikationsfehler 1236 erhalten. I/O
### Syntax
```
CALL mysql.rds_next_master_log(
curr_master_log
);
```
### Parameters
*curr\$1master\$1log*
Der Index der aktuellen Master-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 Master-Protokolldatei zu ermitteln, führen Sie den Befehl `SHOW REPLICA STATUS` aus. Sie finden den Namen anschließend im Feld `Master_Log_File`.
### Nutzungshinweise
Die Prozedur `mysql.rds_next_master_log` muss vom Hauptbenutzer ausgeführt werden.
**Warnung**
Rufen Sie `mysql.rds_next_master_log` nur auf, wenn die Replikation nach einem Failover einer Multi-AZ-DB-Instance, die die Replikationsquelle ist, fehlschlägt und das `Last_IO_Errno` Feld den Fehler 1236 meldet. `SHOW REPLICA STATUS` I/O
Ein Aufruf von `mysql.rds_next_master_log` kann zu Datenverlust im Lesereplikat führen, falls Transaktionen in der Quell-Instance nicht in das binäre Protokoll auf der Festplatte geschrieben wurden, bevor das Failover-Ereignis auftrat. Sie können durch Festlegung der Quell-Instance-Parameter `sync_binlog` und `innodb_support_xa` auf `1` das Risiko dafür verringern, obwohl dies zu einer Reduzierung der Leistung führen kann. Weitere Informationen finden Sie unter [Fehlerbehebung für ein Problem mit einer MySQL Read Replica](USER_ReadRepl.Troubleshooting.md).
### Beispiele
Angenommen, die Replikation schlägt auf einer RDS-für-MySQL- -Read Replica fehl. Die Ausführung von `SHOW REPLICA STATUS\G` für das Lesereplikat gibt das folgende Ergebnis zurück:
```
*************************** 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
```
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 `Master_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 dann `mysql.rds_next_master_log` mit dem folgenden Parameter aufrufen:
```
CALL mysql.rds_next_master_log(12345);
```
## mysql.rds\$1next\$1source\$1log (RDS-für-MySQL-Hauptversionen 8.4 und höher)
Ändert die Protokollposition der Quelldatenbankinstance in den Anfang des nächsten Binärprotokolls auf der Quelldatenbankinstance. Verwenden Sie dieses Verfahren nur, wenn Sie bei einer Read Replica den I/O Replikationsfehler 1236 erhalten.
### Syntax
```
CALL mysql.rds_next_source_log(
curr_source_log
);
```
### Parameters
*curr\$1source\$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` aus. Sie finden den Namen anschließend im Feld `Source_Log_File`.
### Nutzungshinweise
Der Administrator muss das `mysql.rds_next_source_log`-Verfahren ausführen.
**Warnung**
Rufen Sie `mysql.rds_next_source_log` nur auf, wenn die Replikation nach einem Failover einer Multi-AZ-DB-Instance, die die Replikationsquelle ist, fehlschlägt und das `Last_IO_Errno` Feld den Fehler 1236 meldet. `SHOW REPLICA STATUS` I/O
Ein Aufruf von `mysql.rds_next_source_log` kann zu Datenverlust im Lesereplikat führen, falls Transaktionen in der Quell-Instance nicht in das binäre Protokoll auf der Festplatte geschrieben wurden, bevor das Failover-Ereignis auftrat. Sie können durch Festlegung der Quell-Instance-Parameter `sync_binlog` und `innodb_support_xa` auf `1` das Risiko dafür verringern, obwohl dies zu einer Reduzierung der Leistung führen kann. Weitere Informationen finden Sie unter [Fehlerbehebung für ein Problem mit einer MySQL Read Replica](USER_ReadRepl.Troubleshooting.md).
### Beispiele
Angenommen, die Replikation schlägt auf einer RDS-für-MySQL- -Read Replica fehl. Die Ausführung von `SHOW REPLICA STATUS\G` für das Lesereplikat gibt das folgende Ergebnis zurück:
```
*************************** 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
```
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 dann `mysql.rds_next_source_log` mit dem folgenden Parameter aufrufen:
```
CALL mysql.rds_next_source_log(12345);
```
## mysql.rds\$1next\$1master\$1log (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)
Rekonfiguriert eine RDS-für-MySQL-DB-Instance, sodass sie keine Read Replica einer Instance von MySQL außerhalb von Amazon RDS ist.
**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_master;
```
### Nutzungshinweise
Die Prozedur `mysql.rds_reset_external_master` muss vom Hauptbenutzer ausgeführt werden. Diese Prozedur muss auf der MySQL-DB-Instance ausgeführt werden, die nicht mehr Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance sein soll.
**Anmerkung**
Wir empfehlen, Lesereplikate zur Verwaltung der Replikation zwischen zwei Amazon-RDS-DB-Instances zu verwenden, sofern dies möglich ist. In diesem Fall sollten Sie nur diese und andere replikationsbezogene gespeicherte Prozeduren verwenden. Bei dieser Vorgehensweise sind komplexere Replikationstopologien zwischen Amazon-RDS-DB-Instances möglich. Wir bieten diese gespeicherten Prozeduren hauptsächlich an, um die Replikation mit MySQL-Instances zu ermöglichen, die außerhalb von Amazon RDS ausgeführt werden. Informationen zur Verwaltung der Replikation zwischen Amazon-RDS-DB-Instances finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
Weitere Informationen zur Verwendung von Replikation für den Import von Daten aus einer außerhalb von Amazon RDS ausgeführten MySQL-Instance finden Sie unter [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.Repl.md).
## mysql.rds\$1next\$1source\$1log (RDS-für-MySQL-Hauptversionen 8.4 und höher)
Rekonfiguriert eine RDS-für-MySQL-DB-Instance, sodass sie keine Read Replica einer Instance von MySQL außerhalb von Amazon RDS ist.
**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;
```
### Nutzungshinweise
Der Administrator muss das `mysql.rds_reset_external_source`-Verfahren ausführen. Diese Prozedur muss auf der MySQL-DB-Instance ausgeführt werden, die nicht mehr Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance sein soll.
**Anmerkung**
Wir empfehlen, Lesereplikate zur Verwaltung der Replikation zwischen zwei Amazon-RDS-DB-Instances zu verwenden, sofern dies möglich ist. In diesem Fall sollten Sie nur diese und andere replikationsbezogene gespeicherte Prozeduren verwenden. Bei dieser Vorgehensweise sind komplexere Replikationstopologien zwischen Amazon-RDS-DB-Instances möglich. Wir bieten diese gespeicherten Prozeduren hauptsächlich an, um die Replikation mit MySQL-Instances zu ermöglichen, die außerhalb von Amazon RDS ausgeführt werden.
Informationen zur Verwaltung der Replikation zwischen Amazon-RDS-DB-Instances finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md). Weitere Informationen zur Verwendung von Replikation für den Import von Daten aus einer außerhalb von Amazon RDS ausgeführten MySQL-Instance finden Sie unter [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.Repl.md).
## mysql.rds\$1set\$1external\$1master (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)
Konfiguriert eine RDS-für-MySQL-Instance für die Verwendung als Read Replica einer außerhalb von Amazon RDS ausgeführten MySQL-Instance.
**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 die gespeicherte Prozedur [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_set_external_master_with_delay) zum Konfigurieren einer externer Quelldatenbank-Instance und einer verzögerten Replikation verwenden.
### Syntax
```
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
);
```
### Parameters
*host\$1name*
Der Hostname bzw. die IP-Adresse der außerhalb von Amazon RDS ausgeführten MySQL-Instance, die als Quelldatenbank-Instance festgelegt werden soll.
*host\$1port*
Der Port, der von der außerhalb von Amazon RDS ausgeführten MySQL-Instance verwendet wird, die als Quelldatenbank-Instance konfiguriert werden soll. 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 MySQL-Instance, die extern zu Amazon RDS ausgeführt wird. Es wird empfohlen, ein Benutzerkonto bereitzustellen, das ausschließlich für die Replikation mit der externen 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 Quelldatenbank-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 Binlog-Datei ermitteln, indem Sie `SHOW MASTER STATUS`auf der Quelldatenbank-Instance starten.
*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 `MASTER_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.
### Nutzungshinweise
Die Prozedur `mysql.rds_set_external_master` muss vom Hauptbenutzer ausgeführt werden. Diese Prozedur muss auf der MySQL-DB-Instance ausgeführt werden, die als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance konfiguriert werden soll.
Vor der Ausführung von `mysql.rds_set_external_master` müssen Sie zuerst die außerhalb von Amazon RDS ausgeführte MySQL-Instance für die Verwendung als Quelldatenbank-Instance konfigurieren. Um eine Verbindung zu der außerhalb von Amazon RDS ausgeführten MySQL-Instance herzustellen, müssen Sie Werte für `replication_user_name` und `replication_user_password` bereitstellen, die auf einen Replikationsbenutzer verweisen, der über die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für die externe MySQL-Instance verfügt.
**So konfigurieren Sie eine externe Instance von MySQL als Quelldatenbank-Instance**
1. Verbinden Sie sich mithilfe eines MySQL-Clients Ihrer Wahl mit der externen MySQL-Instance und erstellen Sie ein Benutzerkonto, das für die Replikation verwendet werden soll. Im Folgenden wird ein -Beispiel gezeigt.
**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';
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
1. Erteilen Sie innerhalb der externen MySQL-Instance Ihrem Replikationsbenutzer 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.
**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';
```
Um die verschlüsselte Replikation zu verwenden, konfigurieren Sie die Quelldatenbank-Instance für die Verwendung von SSL-Verbindungen.
**Anmerkung**
Wir empfehlen, Lesereplikate zur Verwaltung der Replikation zwischen zwei Amazon-RDS-DB-Instances zu verwenden, sofern dies möglich ist. In diesem Fall sollten Sie nur diese und andere replikationsbezogene gespeicherte Prozeduren verwenden. Bei dieser Vorgehensweise sind komplexere Replikationstopologien zwischen Amazon-RDS-DB-Instances möglich. Wir bieten diese gespeicherten Prozeduren hauptsächlich an, um die Replikation mit MySQL-Instances zu ermöglichen, die außerhalb von Amazon RDS ausgeführt werden. Informationen zur Verwaltung der Replikation zwischen Amazon-RDS-DB-Instances finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
Nachdem Sie `mysql.rds_set_external_master` aufgerufen haben, um eine Amazon-RDS-DB-Instance als Lesereplikat zu konfigurieren, können Sie [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) für das Lesereplikat aufrufen, um die Replikation zu starten Zudem haben Sie die Möglichkeit, mit einem Aufruf von [mysql.rds\$1next\$1master\$1log (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_reset_external_master) die Lesereplikat-Konfiguration zu entfernen.
Beim Aufrufen von `mysql.rds_set_external_master` werden von Amazon RDS Uhrzeit, Benutzer und eine Aktion von `set master` in den Tabellen `mysql.rds_history` und `mysql.rds_replication_status` protokolliert.
### Beispiele
Bei Ausführung innerhalb einer MySQL-DB-Instance konfiguriert das folgende Beispiel diese DB-Instance für die Verwendung als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance.
```
call mysql.rds_set_external_master(
'Externaldb.some.com',
3306,
'repl_user',
'password',
'mysql-bin-changelog.0777',
120,
1);
```
## mysql.rds\$1set\$1external\$1source (RDS-für-MySQL-Hauptversionen 8.4 und höher)
Konfiguriert eine RDS-für-MySQL-Instance für die Verwendung als Read Replica einer außerhalb von Amazon RDS ausgeführten MySQL-Instance.
**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 (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
);
```
### Parameters
*host\$1name*
Der Hostname bzw. die IP-Adresse der außerhalb von Amazon RDS ausgeführten MySQL-Instance, die als Quelldatenbank-Instance festgelegt werden soll.
*host\$1port*
Der Port, der von der außerhalb von Amazon RDS ausgeführten MySQL-Instance verwendet wird, die als Quelldatenbank-Instance konfiguriert werden soll. 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 MySQL-Instance, die extern zu Amazon RDS ausgeführt wird. Es wird empfohlen, ein Benutzerkonto bereitzustellen, das ausschließlich für die Replikation mit der externen 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 Quelldatenbank-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 Binlog-Datei ermitteln, indem Sie `SHOW MASTER STATUS`auf der Quelldatenbank-Instance starten.
*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.
### Nutzungshinweise
Der Administrator muss das `mysql.rds_set_external_source`-Verfahren ausführen. Dieses Verfahren muss auf der DB-Instance von RDS für MySQL ausgeführt werden, die als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance konfiguriert werden soll.
Vor der Ausführung von `mysql.rds_set_external_source` müssen Sie zuerst die außerhalb von Amazon RDS ausgeführte MySQL-Instance für die Verwendung als Quelldatenbank-Instance konfigurieren. Um eine Verbindung zu der außerhalb von Amazon RDS ausgeführten MySQL-Instance herzustellen, müssen Sie Werte für `replication_user_name` und `replication_user_password` bereitstellen, die auf einen Replikationsbenutzer verweisen, der über die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für die externe MySQL-Instance verfügt.
**So konfigurieren Sie eine externe Instance von MySQL als Quelldatenbank-Instance**
1. Verbinden Sie sich mithilfe eines MySQL-Clients Ihrer Wahl mit der externen MySQL-Instance und erstellen Sie ein Benutzerkonto, das für die Replikation verwendet werden soll. Im Folgenden wird ein -Beispiel gezeigt.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
1. Erteilen Sie innerhalb der externen MySQL-Instance Ihrem Replikationsbenutzer 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'@'mydomain.com';
```
Um die verschlüsselte Replikation zu verwenden, konfigurieren Sie die Quelldatenbank-Instance für die Verwendung von SSL-Verbindungen. Importieren Sie außerdem mit der Prozedur [mysql.rds\$1import\$1binlog\$1ssl\$1material](url-rds-user;mysql_rds_import_binlog_ssl_material.html) das Zertifizierungsstellenzertifikat, das Clientzertifikat und den Clientschlüssel in die DB-Instance bzw. den DB-Cluster.
**Anmerkung**
Wir empfehlen, Lesereplikate zur Verwaltung der Replikation zwischen zwei Amazon-RDS-DB-Instances zu verwenden, sofern dies möglich ist. In diesem Fall sollten Sie nur diese und andere replikationsbezogene gespeicherte Prozeduren verwenden. Bei dieser Vorgehensweise sind komplexere Replikationstopologien zwischen Amazon-RDS-DB-Instances möglich. Wir bieten diese gespeicherten Prozeduren hauptsächlich an, um die Replikation mit MySQL-Instances zu ermöglichen, die außerhalb von Amazon RDS ausgeführt werden. Informationen zur Verwaltung der Replikation zwischen Amazon-RDS-DB-Instances finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
Nachdem Sie `mysql.rds_set_external_source` aufgerufen haben, um eine DB-Instance von RDS für MySQL als Lesereplikat zu konfigurieren, können Sie [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) für das Lesereplikat aufrufen, um die Replikation zu starten Zudem haben Sie die Möglichkeit, mit einem Aufruf von [mysql.rds\$1next\$1source\$1log (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#mysql_rds_reset_external_source) die Lesereplikat-Konfiguration zu entfernen.
Beim Aufrufen von `mysql.rds_set_external_source` werden von Amazon RDS Uhrzeit, Benutzer und eine Aktion von `set master` in den Tabellen `mysql.rds_history` und `mysql.rds_replication_status` protokolliert.
### Beispiele
Bei Ausführung auf einer DB-Instance von RDS für MySQL konfiguriert das folgende Beispiel diese DB-Instance für die Verwendung als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance.
```
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-für-MySQL-Hauptversionen 8.0 und niedriger)
Konfiguriert eine RDS für MySQL-DB-Instance für die Verwendung als Read Replica einer außerhalb von Amazon RDS ausgeführten MySQL-Instance. Bei diesem Verfahren werden auch verzögerte Replikation und Replikation auf der Grundlage globaler Transaktions-Identifikatoren () konfiguriert. 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_master_with_auto_position (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
);
```
### Parameters
*host\$1name*
Der Hostname bzw. die IP-Adresse der außerhalb von Amazon RDS ausgeführten MySQL-Instance, die als Quelldatenbank-Instance festgelegt werden soll.
*host\$1port*
Der Port, der von der außerhalb von Amazon RDS ausgeführten MySQL-Instance verwendet wird, die als Quelldatenbank-Instance konfiguriert werden soll. 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 MySQL-Instance, die extern zu Amazon RDS ausgeführt wird. Es wird empfohlen, ein Benutzerkonto bereitzustellen, das ausschließlich für die Replikation mit der externen 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 `MASTER_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.
*delay*
Die Mindestanzahl von Sekunden, um die Replikation von der Quelldatenbank-Instance zu verzögern.
Die Obergrenze für diesen Parameter beträgt einen Tag (86 400 Sekunden).
### Nutzungshinweise
Die Prozedur `mysql.rds_set_external_master_with_auto_position` muss vom Hauptbenutzer ausgeführt werden. Diese Prozedur muss auf der MySQL-DB-Instance ausgeführt werden, die als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance konfiguriert werden soll.
Diese Prozedur wird für alle RDS für MySQL 5.7 und RDS für MySQL 8.0.26 und höhere 8.0-Versionen unterstützt.
Vor der Ausführung von `mysql.rds_set_external_master_with_auto_position` müssen Sie zuerst die außerhalb von Amazon RDS ausgeführte MySQL-Instance für die Verwendung als Quelldatenbank-Instance konfigurieren. Um eine Verbindung zu der außerhalb von Amazon RDS ausgeführten MySQL-Instance herzustellen, müssen Sie Werte für `replication_user_name` und `replication_user_password` angeben. Diese Werte müssen einen Replikationsbenutzer mit den Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für die externe MySQL-Instance angeben.
**So konfigurieren Sie eine externe Instance von MySQL als Quelldatenbank-Instance**
1. Verbinden Sie sich mithilfe eines MySQL-Clients Ihrer Wahl mit der externen MySQL-Instance und erstellen Sie ein Benutzerkonto, das für die Replikation verwendet werden soll. Im Folgenden wird ein Beispiel gezeigt.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Erteilen Sie innerhalb der externen MySQL-Instance Ihrem Replikationsbenutzer die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE`. Im folgenden Beispiel werden dem Benutzer `REPLICATION CLIENT` für Ihre Domäne die Berechtigungen `REPLICATION SLAVE` und `'repl_user'` für alle Datenbanken erteilt.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Weitere Informationen finden Sie unter [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.Repl.md).
**Anmerkung**
Wir empfehlen, Lesereplikate zur Verwaltung der Replikation zwischen zwei Amazon-RDS-DB-Instances zu verwenden, sofern dies möglich ist. In diesem Fall sollten Sie nur diese und andere replikationsbezogene gespeicherte Prozeduren verwenden. Bei dieser Vorgehensweise sind komplexere Replikationstopologien zwischen Amazon-RDS-DB-Instances möglich. Wir bieten diese gespeicherten Prozeduren hauptsächlich an, um die Replikation mit MySQL-Instances zu ermöglichen, die außerhalb von Amazon RDS ausgeführt werden. Informationen zur Verwaltung der Replikation zwischen Amazon-RDS-DB-Instances finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
Stellen Sie vor dem Aufrufen von `mysql.rds_set_external_master_with_auto_position` sicher, dass Sie [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#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_master_with_auto_position` aufgerufen haben, um eine Amazon-RDS-DB-Instance als Lesereplikat zu konfigurieren, können Sie [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) für das Lesereplikat aufrufen, um die Replikation zu starten Zudem haben Sie die Möglichkeit, mit einem Aufruf von [mysql.rds\$1next\$1master\$1log (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_reset_external_master) die Lesereplikat-Konfiguration zu entfernen.
Beim Aufruf von `mysql.rds_set_external_master_with_auto_position` zeichnet Amazon RDS die Uhrzeit, den Benutzer und eine `set master`-Aktion in den Tabellen `mysql.rds_history` und `mysql.rds_replication_status` auf.
Für die Notfallwiederherstellung können Sie diese Prozedur mit der gespeicherten Prozedur [](#mysql_rds_start_replication_until) oder [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) verwenden. Um alle Änderungen bis zu einem Zeitpunkt unmittelbar vor Eintreten des Notfalls in einem verzögerten Lesereplikat wiederherzustellen, können Sie die Prozedur `mysql.rds_set_external_master_with_auto_position` ausführen. Nachdem die Prozedur `mysql.rds_start_replication_until_gtid` die Replikation gestoppt hat, können Sie das Lesereplikat zur neuen primären DB-Instance hochstufen (siehe die Anleitung unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md)).
Um die Prozedur `mysql.rds_rds_start_replication_until_gtid` verwenden zu können, muss die GTID-basierte Replikation aktiviert sein. Wenn Sie eine bestimmte GTID-basierte Transaktion überspringen möchten, von der Sie wissen, dass sie einen Notfall verursacht, können Sie die gespeicherte Prozedur [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) verwenden. Weitere Informationen über das Arbeiten mit der GTID-basierten Replikation finden Sie unter [Verwenden der GTID-basierten Replikation](mysql-replication-gtid.md).
### Beispiele
Bei Ausführung innerhalb einer MySQL-DB-Instance konfiguriert das folgende Beispiel diese DB-Instance für die Verwendung als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance. Die minimale Replikationsverzögerung wird für die MySQL-DB-Instance auf eine Stunde (3600 Sekunden) gesetzt. Eine Änderung an der MySQL-Quelldatenbankinstance, die außerhalb von Amazon RDS ausgeführt wird, wird frühestens nach einer Stunde in das Lesereplikat der MySQL-DB-Instance übernommen.
```
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-für-MySQL-Hauptversionen 8.4 und höher)
Konfiguriert eine RDS für MySQL-DB-Instance für die Verwendung als Read Replica einer außerhalb von Amazon RDS ausgeführten MySQL-Instance. Bei diesem Verfahren werden auch verzögerte Replikation und Replikation auf der Grundlage globaler Transaktions-Identifikatoren () konfiguriert. 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 (
host_name
, host_port
, replication_user_name
, replication_user_password
, ssl_encryption
, delay
);
```
### Parameters
*host\$1name*
Der Hostname bzw. die IP-Adresse der außerhalb von Amazon RDS ausgeführten MySQL-Instance, die als Quelldatenbank-Instance festgelegt werden soll.
*host\$1port*
Der Port, der von der außerhalb von Amazon RDS ausgeführten MySQL-Instance verwendet wird, die als Quelldatenbank-Instance konfiguriert werden soll. 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 MySQL-Instance, die extern zu Amazon RDS ausgeführt wird. Es wird empfohlen, ein Benutzerkonto bereitzustellen, das ausschließlich für die Replikation mit der externen 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.
*delay*
Die Mindestanzahl von Sekunden, um die Replikation von der Quelldatenbank-Instance zu verzögern.
Die Obergrenze für diesen Parameter beträgt einen Tag (86 400 Sekunden).
### Nutzungshinweise
Der Administrator muss das `mysql.rds_set_external_source_with_auto_position`-Verfahren ausführen. Diese Prozedur muss auf der MySQL-DB-Instance ausgeführt werden, die als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance konfiguriert werden soll.
Vor der Ausführung von `mysql.rds_set_external_source_with_auto_position` müssen Sie zuerst die außerhalb von Amazon RDS ausgeführte MySQL-Instance für die Verwendung als Quelldatenbank-Instance konfigurieren. Um eine Verbindung zu der außerhalb von Amazon RDS ausgeführten MySQL-Instance herzustellen, müssen Sie Werte für `replication_user_name` und `replication_user_password` angeben. Diese Werte müssen einen Replikationsbenutzer mit den Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für die externe MySQL-Instance angeben.
**So konfigurieren Sie eine externe Instance von MySQL als Quelldatenbank-Instance**
1. Verbinden Sie sich mithilfe eines MySQL-Clients Ihrer Wahl mit der externen MySQL-Instance und erstellen Sie ein Benutzerkonto, das für die Replikation verwendet werden soll. Im Folgenden wird ein Beispiel gezeigt.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Erteilen Sie innerhalb der externen MySQL-Instance Ihrem Replikationsbenutzer die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE`. Im folgenden Beispiel werden dem Benutzer `REPLICATION CLIENT` für Ihre Domäne die Berechtigungen `REPLICATION SLAVE` und `'repl_user'` für alle Datenbanken erteilt.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Weitere Informationen finden Sie unter [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.Repl.md).
**Anmerkung**
Wir empfehlen, Lesereplikate zur Verwaltung der Replikation zwischen zwei Amazon-RDS-DB-Instances zu verwenden, sofern dies möglich ist. In diesem Fall sollten Sie nur diese und andere replikationsbezogene gespeicherte Prozeduren verwenden. Bei dieser Vorgehensweise sind komplexere Replikationstopologien zwischen Amazon-RDS-DB-Instances möglich. Wir bieten diese gespeicherten Prozeduren hauptsächlich an, um die Replikation mit MySQL-Instances zu ermöglichen, die außerhalb von Amazon RDS ausgeführt werden. Informationen zur Verwaltung der Replikation zwischen Amazon-RDS-DB-Instances finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
Stellen Sie vor dem Aufrufen von `mysql.rds_set_external_source_with_auto_position` sicher, dass Sie [mysql.rds\$1set\$1external\$1source\$1gtid\$1purged](#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` aufgerufen haben, um eine Amazon-RDS-DB-Instance als Lesereplikat zu konfigurieren, können Sie [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) für das Lesereplikat aufrufen, um die Replikation zu starten Zudem haben Sie die Möglichkeit, mit einem Aufruf von [mysql.rds\$1next\$1source\$1log (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#mysql_rds_reset_external_source) die Lesereplikat-Konfiguration zu entfernen.
Beim Aufruf von `mysql.rds_set_external_source_with_auto_position` zeichnet Amazon RDS die Uhrzeit, den Benutzer und eine `set master`-Aktion in den Tabellen `mysql.rds_history` und `mysql.rds_replication_status` auf.
Für die Notfallwiederherstellung können Sie diese Prozedur mit der gespeicherten Prozedur [](#mysql_rds_start_replication_until) oder [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) verwenden. Um alle Änderungen bis zu einem Zeitpunkt unmittelbar vor Eintreten des Notfalls in einem verzögerten Lesereplikat wiederherzustellen, können Sie die Prozedur `mysql.rds_set_external_source_with_auto_position` ausführen. Nachdem die Prozedur `mysql.rds_start_replication_until_gtid` die Replikation gestoppt hat, können Sie das Lesereplikat zur neuen primären DB-Instance hochstufen (siehe die Anleitung unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md)).
Um die Prozedur `mysql.rds_rds_start_replication_until_gtid` verwenden zu können, muss die GTID-basierte Replikation aktiviert sein. Wenn Sie eine bestimmte GTID-basierte Transaktion überspringen möchten, von der Sie wissen, dass sie einen Notfall verursacht, können Sie die gespeicherte Prozedur [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) verwenden. Weitere Informationen über das Arbeiten mit der GTID-basierten Replikation finden Sie unter [Verwenden der GTID-basierten Replikation](mysql-replication-gtid.md).
### Beispiele
Bei Ausführung innerhalb einer MySQL-DB-Instance konfiguriert das folgende Beispiel diese DB-Instance für die Verwendung als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance. Die minimale Replikationsverzögerung wird für die MySQL-DB-Instance auf eine Stunde (3600 Sekunden) gesetzt. Eine Änderung an der MySQL-Quelldatenbankinstance, die außerhalb von Amazon RDS ausgeführt wird, wird frühestens nach einer Stunde in das Lesereplikat der MySQL-DB-Instance übernommen.
```
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-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)
Konfiguriert eine RDS für MySQL-DB-Instance für die Verwendung als Read Replica einer außerhalb von Amazon RDS ausgeführten MySQL-Instance und konfiguriert die verzögerte Replikation.
**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_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
);
```
### Parameters
*host\$1name*
Der Hostname bzw. die IP-Adresse der außerhalb von Amazon RDS ausgeführten MySQL-Instance, die als Replikations-Master festgelegt werden soll
*host\$1port*
Der Port, der von der außerhalb von Amazon RDS ausgeführten MySQL-Instance verwendet wird, die als Quelldatenbank-Instance konfiguriert werden soll. Wenn Ihre Netzwerkkonfiguration die Replikation von 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 MySQL-Instance, die extern zu Amazon RDS ausgeführt wird. Es wird empfohlen, ein Benutzerkonto bereitzustellen, das ausschließlich für die Replikation mit der externen 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 Quelldatenbank-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 MASTER STATUS` auf der Quelldatenbank-Instance starten.
*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 `MASTER_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.
*delay*
Die Mindestanzahl von Sekunden, um die Replikation von der Quelldatenbank-Instance zu verzögern.
Die Obergrenze für diesen Parameter beträgt einen Tag (86 400 Sekunden).
### Nutzungshinweise
Die Prozedur `mysql.rds_set_external_master_with_delay` muss vom Hauptbenutzer ausgeführt werden. Diese Prozedur muss auf der MySQL-DB-Instance ausgeführt werden, die als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance konfiguriert werden soll.
Vor der Ausführung von `mysql.rds_set_external_master_with_delay` müssen Sie zuerst die außerhalb von Amazon RDS ausgeführte MySQL-Instance für die Verwendung als Quelldatenbank-Instance konfigurieren. Um eine Verbindung zu der außerhalb von Amazon RDS ausgeführten MySQL-Instance herzustellen, müssen Sie Werte für `replication_user_name` und `replication_user_password` angeben. Diese Werte müssen einen Replikationsbenutzer mit den Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für die externe MySQL-Instance angeben.
**So konfigurieren Sie eine externe Instance von MySQL als Quelldatenbank-Instance**
1. Verbinden Sie sich mithilfe eines MySQL-Clients Ihrer Wahl mit der externen MySQL-Instance und erstellen Sie ein Benutzerkonto, das für die Replikation verwendet werden soll. Im Folgenden wird ein Beispiel gezeigt.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Erteilen Sie innerhalb der externen MySQL-Instance Ihrem Replikationsbenutzer die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE`. Im folgenden Beispiel werden dem Benutzer `REPLICATION CLIENT` für Ihre Domäne die Berechtigungen `REPLICATION SLAVE` und `'repl_user'` für alle Datenbanken erteilt.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Weitere Informationen finden Sie unter [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.Repl.md).
**Anmerkung**
Wir empfehlen, Lesereplikate zur Verwaltung der Replikation zwischen zwei Amazon-RDS-DB-Instances zu verwenden, sofern dies möglich ist. In diesem Fall sollten Sie nur diese und andere replikationsbezogene gespeicherte Prozeduren verwenden. Bei dieser Vorgehensweise sind komplexere Replikationstopologien zwischen Amazon-RDS-DB-Instances möglich. Wir bieten diese gespeicherten Prozeduren hauptsächlich an, um die Replikation mit MySQL-Instances zu ermöglichen, die außerhalb von Amazon RDS ausgeführt werden. Informationen zur Verwaltung der Replikation zwischen Amazon-RDS-DB-Instances finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
Nachdem Sie `mysql.rds_set_external_master_with_delay` aufgerufen haben, um eine Amazon-RDS-DB-Instance als Lesereplikat zu konfigurieren, können Sie [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) für das Lesereplikat aufrufen, um die Replikation zu starten Zudem haben Sie die Möglichkeit, mit einem Aufruf von [mysql.rds\$1next\$1master\$1log (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_reset_external_master) die Lesereplikat-Konfiguration zu entfernen.
Beim Aufruf von `mysql.rds_set_external_master_with_delay` zeichnet Amazon RDS die Uhrzeit, den Benutzer und eine `set master`-Aktion in den Tabellen `mysql.rds_history` und `mysql.rds_replication_status` auf.
Für die Notfallwiederherstellung können Sie diese Prozedur mit der gespeicherten Prozedur [](#mysql_rds_start_replication_until) oder [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) verwenden. Um alle Änderungen bis zu einem Zeitpunkt unmittelbar vor Eintreten des Notfalls in einem verzögerten Lesereplikat wiederherzustellen, können Sie die Prozedur `mysql.rds_set_external_master_with_delay` ausführen. Nachdem die Prozedur `mysql.rds_start_replication_until` die Replikation gestoppt hat, können Sie das Lesereplikat zur neuen primären DB-Instance hochstufen (siehe die Anleitung unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md)).
Um die Prozedur `mysql.rds_rds_start_replication_until_gtid` verwenden zu können, muss die GTID-basierte Replikation aktiviert sein. Wenn Sie eine bestimmte GTID-basierte Transaktion überspringen möchten, von der Sie wissen, dass sie einen Notfall verursacht, können Sie die gespeicherte Prozedur [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) verwenden. Weitere Informationen über das Arbeiten mit der GTID-basierten Replikation finden Sie unter [Verwenden der GTID-basierten Replikation](mysql-replication-gtid.md).
Die gespeicherte Prozedur `mysql.rds_set_external_master_with_delay` ist für die folgenden Versionen von RDS für MySQL verfügbar:
+ MySQL 8.0.26 und höhere 8.0-Versionen
+ Alle 5.7-Versionen
### Beispiele
Bei Ausführung innerhalb einer MySQL-DB-Instance konfiguriert das folgende Beispiel diese DB-Instance für die Verwendung als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance. Die minimale Replikationsverzögerung wird für die MySQL-DB-Instance auf eine Stunde (3600 Sekunden) gesetzt. Eine Änderung an der MySQL-Quelldatenbankinstance, die außerhalb von Amazon RDS ausgeführt wird, wird frühestens nach einer Stunde in das Lesereplikat der MySQL-DB-Instance übernommen.
```
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-für-MySQL-Hauptversionen 8.4 und höher)
Konfiguriert eine RDS für MySQL-DB-Instance für die Verwendung als Read Replica einer außerhalb von Amazon RDS ausgeführten MySQL-Instance und konfiguriert die verzögerte Replikation.
**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 (
host_name
, host_port
, replication_user_name
, replication_user_password
, mysql_binary_log_file_name
, mysql_binary_log_file_location
, ssl_encryption
, delay
);
```
### Parameters
*host\$1name*
Der Hostname bzw. die IP-Adresse der außerhalb von Amazon RDS ausgeführten MySQL-Instance, die als Replikations-Master festgelegt werden soll
*host\$1port*
Der Port, der von der außerhalb von Amazon RDS ausgeführten MySQL-Instance verwendet wird, die als Quelldatenbank-Instance konfiguriert werden soll. Wenn Ihre Netzwerkkonfiguration die Replikation von 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 MySQL-Instance, die extern zu Amazon RDS ausgeführt wird. Es wird empfohlen, ein Benutzerkonto bereitzustellen, das ausschließlich für die Replikation mit der externen 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 Quelldatenbank-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 MASTER STATUS` auf der Quelldatenbank-Instance starten.
*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.
*delay*
Die Mindestanzahl von Sekunden, um die Replikation von der Quelldatenbank-Instance zu verzögern.
Die Obergrenze für diesen Parameter beträgt einen Tag (86 400 Sekunden).
### Nutzungshinweise
Der Administrator muss das `mysql.rds_set_external_source_with_delay`-Verfahren ausführen. Diese Prozedur muss auf der MySQL-DB-Instance ausgeführt werden, die als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance konfiguriert werden soll.
Vor der Ausführung von `mysql.rds_set_external_source_with_delay` müssen Sie zuerst die außerhalb von Amazon RDS ausgeführte MySQL-Instance für die Verwendung als Quelldatenbank-Instance konfigurieren. Um eine Verbindung zu der außerhalb von Amazon RDS ausgeführten MySQL-Instance herzustellen, müssen Sie Werte für `replication_user_name` und `replication_user_password` angeben. Diese Werte müssen einen Replikationsbenutzer mit den Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für die externe MySQL-Instance angeben.
**So konfigurieren Sie eine externe Instance von MySQL als Quelldatenbank-Instance**
1. Verbinden Sie sich mithilfe eines MySQL-Clients Ihrer Wahl mit der externen MySQL-Instance und erstellen Sie ein Benutzerkonto, das für die Replikation verwendet werden soll. Im Folgenden wird ein Beispiel gezeigt.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'SomePassW0rd'
```
1. Erteilen Sie innerhalb der externen MySQL-Instance Ihrem Replikationsbenutzer die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE`. Im folgenden Beispiel werden dem Benutzer `REPLICATION CLIENT` für Ihre Domäne die Berechtigungen `REPLICATION SLAVE` und `'repl_user'` für alle Datenbanken erteilt.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com'
IDENTIFIED BY 'SomePassW0rd'
```
Weitere Informationen finden Sie unter [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.Repl.md).
**Anmerkung**
Wir empfehlen, Lesereplikate zur Verwaltung der Replikation zwischen zwei Amazon-RDS-DB-Instances zu verwenden, sofern dies möglich ist. In diesem Fall sollten Sie nur diese und andere replikationsbezogene gespeicherte Prozeduren verwenden. Bei dieser Vorgehensweise sind komplexere Replikationstopologien zwischen Amazon-RDS-DB-Instances möglich. Wir bieten diese gespeicherten Prozeduren hauptsächlich an, um die Replikation mit MySQL-Instances zu ermöglichen, die außerhalb von Amazon RDS ausgeführt werden. Informationen zur Verwaltung der Replikation zwischen Amazon-RDS-DB-Instances finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
Nachdem Sie `mysql.rds_set_external_source_with_delay` aufgerufen haben, um eine Amazon-RDS-DB-Instance als Lesereplikat zu konfigurieren, können Sie [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) für das Lesereplikat aufrufen, um die Replikation zu starten Zudem haben Sie die Möglichkeit, mit einem Aufruf von [mysql.rds\$1next\$1source\$1log (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#mysql_rds_reset_external_source) die Lesereplikat-Konfiguration zu entfernen.
Beim Aufruf von `mysql.rds_set_external_source_with_delay` zeichnet Amazon RDS die Uhrzeit, den Benutzer und eine `set master`-Aktion in den Tabellen `mysql.rds_history` und `mysql.rds_replication_status` auf.
Für die Notfallwiederherstellung können Sie diese Prozedur mit der gespeicherten Prozedur [](#mysql_rds_start_replication_until) oder [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) verwenden. Um alle Änderungen bis zu einem Zeitpunkt unmittelbar vor Eintreten des Notfalls in einem verzögerten Lesereplikat wiederherzustellen, können Sie die Prozedur `mysql.rds_set_external_source_with_delay` ausführen. Nachdem die Prozedur `mysql.rds_start_replication_until` die Replikation gestoppt hat, können Sie das Lesereplikat zur neuen primären DB-Instance hochstufen (siehe die Anleitung unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md)).
Um die Prozedur `mysql.rds_rds_start_replication_until_gtid` verwenden zu können, muss die GTID-basierte Replikation aktiviert sein. Wenn Sie eine bestimmte GTID-basierte Transaktion überspringen möchten, von der Sie wissen, dass sie einen Notfall verursacht, können Sie die gespeicherte Prozedur [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) verwenden. Weitere Informationen über das Arbeiten mit der GTID-basierten Replikation finden Sie unter [Verwenden der GTID-basierten Replikation](mysql-replication-gtid.md).
### Beispiele
Bei Ausführung innerhalb einer MySQL-DB-Instance konfiguriert das folgende Beispiel diese DB-Instance für die Verwendung als Lesereplikat einer außerhalb von Amazon RDS ausgeführten MySQL-Instance. Die minimale Replikationsverzögerung wird für die MySQL-DB-Instance auf eine Stunde (3600 Sekunden) gesetzt. Eine Änderung an der MySQL-Quelldatenbankinstance, die außerhalb von Amazon RDS ausgeführt wird, wird frühestens nach einer Stunde in das Lesereplikat der MySQL-DB-Instance übernommen.
```
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
Legt die Systemvariable [gtid\$1purged](https://dev.mysql.com/doc/refman/8.0/en/replication-options-gtids.html#sysvar_gtid_purged) auf einen angegebenen GTID-Bereich aus einer externen Quelle fest. Der Wert `gtid_purged` ist für die Konfiguration der GTID-basierten Replikation erforderlich, um die Replikation mithilfe der automatischen Positionierung fortzusetzen.
**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_gtid_purged(
server_uuid
, start_pos
, end_pos
);
```
### Parameters
*server\$1uuid*
Der Universally Unique Identifier (UUID) des externen Servers, von dem der GTID-Bereich importiert wird.
*start\$1pos*
Die Startposition des festzulegenden GTID-Bereichs.
*end\$1pos*
Die Startposition des festzulegenden GTID-Bereichs.
### Nutzungshinweise
Das Verfahren `mysql.rds_set_external_source_gtid_purged` ist nur mit MySQL 8.0.37 und höheren 8.0-Versionen verfügbar.
Rufen Sie `mysql.rds_set_external_source_gtid_purged` vor [mysql.rds\$1set\$1external\$1master\$1with\$1auto\$1position (RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_set_external_master_with_auto_position), [mysql.rds\$1set\$1external\$1source\$1with\$1auto\$1position (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#mysql_rds_set_external_source_with_auto_position) oder [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) auf.
Stellen Sie vor dem Anruf von `mysql.rds_set_external_source_gtid_purged` sicher, dass alle aktiven Replikationskanäle für die Datenbank beendet wurden. Verwenden Sie die MySQL-Anweisung `SHOW REPLICA STATUS`, um den Status eines Kanals zu überprüfen. Um die Replikation auf einem Kanal zu beenden, rufen Sie [mysql.rds\$1stop\$1replication\$1for\$1channel](mysql-stored-proc-multi-source-replication.md#mysql_rds_stop_replication_for_channel) auf.
Der von Ihnen angegebene GTID-Bereich muss eine übergeordnete Menge des vorhandenen `GTID_PURGED`-Werts sein. Dieses gespeicherte Verfahren überprüft die folgenden Werte, bevor der Wert `GTID_PURGED` festlegt wird:
+ Die `server_uuid` ist gültig.
+ Der Wert von `start_pos` ist größer als `0` und kleiner als der Wert von `end_pos`.
+ Der Wert von `end_pos` ist größer oder gleich dem Wert von `start_pos`.
Wenn die auf Ihrem externen Server festgelegte GTID mehrere Wertebereiche enthält, sollten Sie erwägen, das Verfahren mehrmals mit unterschiedlichen GTID-Satzwerten aufzurufen.
Beim Aufruf von `mysql.rds_set_external_source_gtid_purged` zeichnet Amazon RDS die Uhrzeit, den Benutzer und eine `set gtid_purged`-Aktion in der Tabelle `mysql.rds_history` auf.
Wenn Sie den Wert `gtid_purged` für die Sicherung, die Sie für die Replikation verwenden, nicht angemessen festlegen, kann dies dazu führen, dass während des Replikationsvorgangs Transaktionen fehlen oder doppelt vorhanden sind. Führen Sie die folgenden Schritte aus, um den richtigen `gtid_purged`-Wert festzulegen.
**So legen Sie den Wert „gtid\$1purged“ für das Replikat fest**
1. Ermitteln Sie den Zeitpunkt oder die spezifische Sicherungsdatei, die als Ausgangspunkt für die Replikation verwendet werden soll. Dies kann eine logische Sicherung (eine mysqldump-Datei) oder eine physische Sicherung (ein Amazon-RDS-Snapshot) sein.
1. Ermitteln Sie den Wert `gtid_executed`. Dieser Wert stellt die Menge aller Daten dar GTIDs , die auf dem Server festgeschrieben wurden. Führen Sie auf der Quell-Instance einen der folgenden Schritte aus, um diesen Wert abzurufen:
+ Führen Sie die SQL-Anweisung `SELECT @@GLOBAL.GTID_EXECUTED;` zum Zeitpunkt der Sicherung aus.
+ Wenn das jeweilige Sicherungsdienstprogramm zugehörige Optionen enthält, extrahieren Sie den Wert aus der Sicherungsdatei. Weitere Informationen finden Sie in der MySQL-Dokumentation zu der [set-gtid-purged](https://dev.mysql.com/doc/refman/8.4/en/mysqldump.html#option_mysqldump_set-gtid-purged)Option.
1. Ermitteln Sie den Wert `gtid_purged`, der für den Aufruf von `mysql.rds_set_external_source_gtid_purged` verwendet werden soll. Der `gtid_purged` Wert sollte alle enthalten GTIDs , die auf der Quellinstanz ausgeführt wurden und nicht mehr für die Replikation benötigt werden. Daher sollte der Wert `gtid_purged` eine Teilmenge des im vorherigen Schritt abgerufenen `gtid_executed`-Werts sein.
Um den `gtid_purged` Wert zu ermitteln, identifizieren Sie GTIDs diejenigen, die nicht im Backup enthalten sind und nicht mehr für die Replikation benötigt werden. Sie können dies tun, indem Sie die Binärprotokolle analysieren oder ein Tool wie mysqlbinlog verwenden, um diejenigen zu finden GTIDs , die aus den Binärprotokollen gelöscht wurden.
Wenn Sie über eine konsistente Sicherung verfügen, die alle Binärprotokolle bis zum Sicherungspunkt umfasst, können Sie den Wert alternativ so festlegen, dass er dem `gtid_purged`-Wert am Sicherungspunkt entspricht. `gtid_executed`
1. Nachdem Sie den entsprechenden `gtid_purged`-Wert ermittelt haben, der mit Ihrer Sicherung konsistent ist, rufen Sie das gespeicherte `mysql.rds_set_external_source_gtid_purged`-Verfahren auf Ihrer DB-Instance von RDS für MySQL auf, um den Wert festzulegen.
### Beispiele
Bei der Ausführung auf einer MySQL-DB-Instance legt das folgende Beispiel den GTID-Bereich von einem externen MySQL-Server mit der UUID `12345678-abcd-1234-efgh-123456789abc`, einer Startposition von `1` und einer Endposition von `100` fest. Der resultierende GTID-Wert ist auf `+12345678-abcd-1234-efgh-123456789abc:1-100` festgelegt.
```
CALL mysql.rds_set_external_source_gtid_purged('12345678-abcd-1234-efgh-123456789abc', 1, 100);
```
##
Legt fest, dass der Replikationsmodus entweder auf binären Protokolldateipositionen oder auf globalen Transaktions-Identifikatoren (GTIDs) basiert.
### Syntax
```
CALL mysql.rds_set_master_auto_position (
auto_position_mode
);
```
### Parameters
*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.
### Nutzungshinweise
Die Prozedur `mysql.rds_set_master_auto_position` muss vom Hauptbenutzer ausgeführt werden.
Dieses Verfahren wird für RDS-für-MySQL-5.7-Versionen und RDS-für-MySQL 8.0.26 und höhere 8.0-Versionen unterstützt.
## mysql.rds\$1set\$1source\$1auto\$1position (RDS-für-MySQL-Hauptversionen 8.4 und höher)
Legt fest, dass der Replikationsmodus entweder auf binären Protokolldateipositionen oder auf globalen Transaktions-Identifikatoren () GTIDs basiert.
### Syntax
```
CALL mysql.rds_set_source_auto_position (auto_position_mode);
```
### Parameters
*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.
### Nutzungshinweise
Der Administrator muss das `mysql.rds_set_source_auto_position`-Verfahren ausführen.
## mysql.rds\$1set\$1source\$1delay
Legt die Mindestanzahl von Sekunden fest, in der die Replikation von der Quelldatenbankinstance auf das aktuelle Lesereplikat verzögert werden soll. Verwenden Sie diese Prozedur, wenn Sie mit einem Lesereplikat verbunden sind, um die Replikation von der zugehörigen Quelldatenbankinstance zu verzögern.
### Syntax
```
CALL mysql.rds_set_source_delay(
delay
);
```
### Parameters
*delay*
Die Mindestanzahl von Sekunden, um die Replikation von der Quelldatenbank-Instance zu verzögern.
Die Obergrenze für diesen Parameter beträgt einen Tag (86 400 Sekunden).
### Nutzungshinweise
Die Prozedur `mysql.rds_set_source_delay` muss vom Hauptbenutzer ausgeführt werden.
Für die Notfallwiederherstellung können Sie diese Prozedur mit der gespeicherten Prozedur [](#mysql_rds_start_replication_until) oder [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) verwenden. Um alle Änderungen bis zu einem Zeitpunkt unmittelbar vor Eintreten des Notfalls in einem verzögerten Lesereplikat wiederherzustellen, können Sie die Prozedur `mysql.rds_set_source_delay` ausführen. Nachdem die Prozedur `mysql.rds_start_replication_until` oder `mysql.rds_start_replication_until_gtid` die Replikation gestoppt hat, können Sie das Lesereplikat zur neuen primären DB-Instance hochstufen (siehe die Anleitung unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md)).
Um die Prozedur `mysql.rds_rds_start_replication_until_gtid` verwenden zu können, muss die GTID-basierte Replikation aktiviert sein. Wenn Sie eine bestimmte GTID-basierte Transaktion überspringen möchten, von der Sie wissen, dass sie einen Notfall verursacht, können Sie die gespeicherte Prozedur [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) verwenden. Weitere Informationen zur GTID-basierten Replikation finden Sie unter [Verwenden der GTID-basierten Replikation](mysql-replication-gtid.md).
Die gespeicherte Prozedur `mysql.rds_set_source_delay` ist für die folgenden Versionen von RDS für MySQL verfügbar:
+ RDS für MySQL 8.4 (alle Versionen)
+ MySQL 8.0.26 und höhere 8.0-Versionen
+ Alle 5.7-Versionen
### Beispiele
Um die Replikation von der Quelldatenbankinstance zum aktuellen Lesereplikat um mindestens eine Stunde (3.600 Sekunden) zu verzögern, können Sie `mysql.rds_set_source_delay` mit dem folgenden Parameter aufrufen:
```
CALL mysql.rds_set_source_delay(3600);
```
## mysql.rds\$1skip\$1repl\$1error
Ignoriert und löscht einen Replikationsfehler in einem MySQL-DB-Lesereplikat.
### Syntax
```
CALL mysql.rds_skip_repl_error;
```
### Nutzungshinweise
Der Hauptbenutzer muss die Prozedur `mysql.rds_skip_repl_error` auf einem Lesereplikat ausführen. Weitere Informationen zu dieser Prozedur finden Sie unter [Aufrufen der Prozedur mysql.rds\$1skip\$1repl\$1error](Appendix.MySQL.CommonDBATasks.SkipError.md#Appendix.MySQL.CommonDBATasks.SkipError.procedure).
Führen Sie den MySQL-Befehl `SHOW REPLICA STATUS\G` aus, um festzustellen, ob Fehler aufgetreten sind. Wenn ein Replikationsfehler nicht als kritisch eingestuft, ist, können Sie `mysql.rds_skip_repl_error` ausführen, um den Fehler zu überspringen. Wenn mehrere Fehler aufgetreten sind, löscht `mysql.rds_skip_repl_error` den ersten Fehler und weist darauf hin, dass weitere Fehlermeldungen anhängig sind. In diesem Fall können Sie mithilfe von `SHOW REPLICA STATUS\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.
Weitere Informationen zur Handhabung von Replikationsfehlern mit Amazon RDS finden Sie unter [Fehlerbehebung für ein Problem mit einer MySQL Read Replica](USER_ReadRepl.Troubleshooting.md).
#### Fehler „Replication stopped (Replikation gestoppt)“
Wenn Sie die Prozedur `mysql.rds_skip_repl_error` aufrufen, wird möglicherweise eine Fehlermeldung angezeigt, die besagt, dass das Replikat ausgefallen oder deaktiviert ist.
Diese Fehlermeldung wird angezeigt, wenn Sie die Prozedur auf der primären Instance statt auf dem Lesereplikat ausführen. Sie müssen diese Prozedur auf dem Lesereplikat ausführen, damit sie funktioniert.
Diese Fehlermeldung wird möglicherweise auch angezeigt, wenn Sie die Prozedur zwar auf dem Lesereplikat ausführen, die Replikation jedoch nicht neu gestartet werden kann.
Wenn Sie eine größere Anzahl von Fehlern überspringen müssen, kann die Dauer der Replikationsverzögerung den standardmäßigen Aufbewahrungszeitraum für binäre Protokolldateien (binlog) überschreiten. In diesem Fall kann es zu einem schwerwiegenden Fehler kommen, weil Binärprotokolldateien bereinigt werden, bevor ihr Inhalt in das Lesereplikat repliziert wurde. Diese Bereinigung führt zur Beendigung der Replikation, und Sie können den Befehl `mysql.rds_skip_repl_error` nicht mehr aufrufen, um Replikationsfehler zu überspringen und zu ignorieren.
Sie können dieses Problem verringern, indem Sie die Anzahl der Stunden erhöhen, die die Binärprotokolldateien auf Ihrer Quelldatenbankinstance aufbewahrt werden. Nachdem Sie die Aufbewahrungsdauer für binäre Protokolldateien verlängert haben, können Sie die Replikation neu starten und nach Bedarf den Befehl `mysql.rds_skip_repl_error` aufrufen.
Verwenden Sie zur Festlegung der Aufbewahrungszeit für Binärprotokolldateien die Prozedur [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) und legen Sie einen Konfigurationsparameter für `'binlog retention hours'` zusammen mit der Stundenanzahl für die Aufbewahrung der Binärprotokolldateien im DB-Cluster fest. Beim folgenden Beispiel wird die Aufbewahrungszeit für binäre Protokolle auf 48 Stunden festgelegt.
```
CALL mysql.rds_set_configuration('binlog retention hours', 48);
```
## mysql.rds\$1start\$1replication
Startet die Replikation von einer/einem RDS-für-MySQL-DB-Instance.
**Anmerkung**
Sie können die gespeicherte Prozedur [](#mysql_rds_start_replication_until) oder [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) 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;
```
### Nutzungshinweise
Die Prozedur `mysql.rds_start_replication` muss vom Hauptbenutzer ausgeführt werden.
Um Daten aus einer außerhalb von Amazon RDS ausgeführten MySQL-Instance zu importieren, rufen Sie `mysql.rds_start_replication` für das Lesereplikat auf, um den Replikationsvorgang zu starten, nachdem Sie [mysql.rds\$1set\$1external\$1master (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_set_external_master) oder [mysql.rds\$1set\$1external\$1source (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#mysql_rds_set_external_source) aufgerufen haben, um die Replikation zu konfigurieren. Weitere Informationen finden Sie unter [Wiederherstellen eines Backups in eine DB-Instance von Amazon RDS für MySQL](MySQL.Procedural.Importing.md).
Zum Export von Daten in eine außerhalb von Amazon RDS ausgeführte MySQL-Instance rufen Sie `mysql.rds_start_replication` und `mysql.rds_stop_replication` für das Lesereplikat auf, um Replikationsaktionen wie das Bereinigen von Binärprotokollen zu steuern. Weitere Informationen finden Sie unter [Exportieren von Daten aus einer MySQL DB-Instance mithilfe der Replikation](MySQL.Procedural.Exporting.NonRDSRepl.md).
Darüber hinaus können Sie `mysql.rds_start_replication` für das Lesereplikat aufrufen, um einen zuvor durch einen Aufruf von `mysql.rds_stop_replication` gestoppten Replikationsprozess wieder zu starten. Weitere Informationen finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
##
Initiiert die Replikation von einer RDS-für-MySQL-DB-Instance und stoppt die Replikation an der angegebenen Position in der Binärprotokolldatei.
### Syntax
```
CALL mysql.rds_start_replication_until (
replication_log_file
, replication_stop_point
);
```
### Parameters
*replication\$1log\$1file*
Der Name des Binärprotokolls auf der Quelldatenbank-Instance, die die Replikationsinformationen enthält.
*replication\$1stop\$1point *
Die Position im `replication_log_file`-Binärprotokoll, an der die Replikation stoppt.
### Nutzungshinweise
Die Prozedur `mysql.rds_start_replication_until` muss vom Hauptbenutzer ausgeführt werden.
Die gespeicherte Prozedur `mysql.rds_start_replication_until` ist für die folgenden Versionen von RDS für MySQL verfügbar:
+ RDS für MySQL 8.4 (alle Versionen)
+ MySQL 8.0.26 und höhere 8.0-Versionen
+ Alle 5.7-Versionen
Sie können diese Prozedur mit verzögerter Replikation für die Notfallwiederherstellung verwenden. Wenn Sie die verzögerte Replikation konfiguriert haben, können Sie diese Prozedur verwenden, um alle Änderungen bis zu einem Zeitpunkt unmittelbar vor Eintreten des Notfalls in einem verzögerten Lesereplikat wiederherzustellen. Nachdem diese Prozedur die Replikation gestoppt hat, können Sie das Lesereplikat zur neuen primären DB-Instance hochstufen (siehe die Anleitung unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md).
Sie können die verzögerte Replikation mit den folgenden gespeicherten Prozeduren konfigurieren:
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS-für-MySQL-Hauptversionen 8.4 und höher)](#mysql_rds_set_external_source_with_delay)
+ [mysql.rds\$1set\$1source\$1delay](#mysql_rds_set_source_delay)
Der für den Parameter `replication_log_file` angegebene Dateiname muss mit dem Binlogdateinamen der Quelldatenbankinstance ü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 und repliziert die Änderungen, bis die Position `120` in der Binärprotokolldatei `mysql-bin-changelog.000777` erreicht wird.
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
## mysql.rds\$1stop\$1replication
Stoppt die Replikation von einer MySQL-DB-Instance.
### Syntax
```
CALL mysql.rds_stop_replication;
```
### Nutzungshinweise
Die Prozedur `mysql.rds_stop_replication` muss vom Hauptbenutzer ausgeführt werden.
Wenn Sie die Replikation für den Import von Daten aus einer außerhalb von Amazon RDS ausgeführten MySQL-Instance konfigurieren, stoppen Sie mit einem Aufruf von `mysql.rds_stop_replication` für das Lesereplikat den Replikationsvorgang nach Abschluss des Imports. Weitere Informationen finden Sie unter [Wiederherstellen eines Backups in eine DB-Instance von Amazon RDS für MySQL](MySQL.Procedural.Importing.md).
Wenn Sie die Replikation für den Export von Daten in eine außerhalb von Amazon RDS ausgeführte MySQL-Instance konfigurieren, rufen Sie `mysql.rds_start_replication` und `mysql.rds_stop_replication` für das Lesereplikat auf, um Replikationsaktionen wie das Bereinigen von Binärprotokollen zu steuern. Weitere Informationen finden Sie unter [Exportieren von Daten aus einer MySQL DB-Instance mithilfe der Replikation](MySQL.Procedural.Exporting.NonRDSRepl.md).
Zudem können Sie `mysql.rds_stop_replication` auch dazu verwenden, die Replikation zwischen zwei Amazon-RDS-DB-Instances zu stoppen. In der Regel wird eine Replikation gestoppt, um eine länger dauernde Operation im Lesereplikat – zum Beispiel das Erstellen eines umfangreichen Indexes – durchzuführen. Ein gestoppter Replikationsvorgang kann durch Aufruf von [mysql.rds\$1start\$1replication](#mysql_rds_start_replication) für das Lesereplikat wieder gestartet werden. Weitere Informationen finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
# Beenden einer Sitzung oder Abfrage
Die folgenden gespeicherten Prozeduren beenden eine Sitzung oder Abfrage.
**Topics**
+ [mysql.rds\$1kill](#mysql_rds_kill)
+ [mysql.rds\$1kill\$1query](#mysql_rds_kill_query)
## mysql.rds\$1kill
Beendet eine Verbindung zum MySQL-Server.
### Syntax
```
CALL mysql.rds_kill(processID);
```
### Parameter
*processID*
Die ID des Verbindungs-Threads, der beendet werden soll.
### Nutzungshinweise
Jede Verbindung zum MySQL-Server wird in einem eigenen Thread ausgeführt. Um eine Verbindung zu beenden, verwenden Sie die Prozedur `mysql.rds_kill` und übergeben ihr als Parameter die Thread-ID der Verbindung. Die Thread-ID erhalten Sie mithilfe des MySQL-Befehls [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html).
Weitere Informationen zu Einschränkungen finden Sie unter [Einschränkungen bei gespeicherten MySQL-Prozeduren](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures).
### Beispiele
Im folgenden Beispiel wird eine Verbindung mit der Thread-ID 4243 beendet:
```
CALL mysql.rds_kill(4243);
```
## mysql.rds\$1kill\$1query
Beendet eine an den MySQL-Server übermittelte Abfrage.
### Syntax
```
CALL mysql.rds_kill_query(processID);
```
### Parameter
*processID*
Die Identität des Prozesses oder Threads, der die zu beendende Abfrage ausführt.
### Nutzungshinweise
Um eine an den MySQL-Server übermittelte Abfrage zu beenden, verwenden Sie die Prozedur `mysql_rds_kill_query` und übergeben die ID des Threads, der die Abfrage ausführt. Die Prozedur beendet dann die Verbindung.
Die Abfrage-ID erhalten Sie mithilfe der MySQL-Tabelle [INFORMATION\$1SCHEMA PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/information-schema-processlist-table.html) oder des MySQL-Befehls [SHOW PROCESSLIST](https://dev.mysql.com/doc/refman/8.0/en/show-processlist.html). Der Wert in der ID-Spalte von `SHOW PROCESSLIST` oder `SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST` ist die *processID*.
Weitere Informationen zu Einschränkungen finden Sie unter [Einschränkungen bei gespeicherten MySQL-Prozeduren](MySQL.KnownIssuesAndLimitations.md#MySQL.Concepts.KnownIssuesAndLimitations.KillProcedures).
### Beispiele
Im folgenden Beispiel wird eine Abfrage mit der Thread-ID 230040 beendet:
```
CALL mysql.rds_kill_query(230040);
```
# Verwalten von Aktiv/Aktiv-Clustern
Mit den folgenden gespeicherten Prozeduren werden Aktiv/Aktiv-Cluster von RDS für MySQL eingerichtet und verwaltet. Weitere Informationen finden Sie unter [Konfigurieren von Aktiv/Aktiv-Clustern von RDS für MySQL](mysql-active-active-clusters.md).
Diese gespeicherten Prozeduren sind nur für DB-Instances von RDS für MySQL verfügbar, auf denen die folgenden Versionen ausgeführt werden:
+ Alle MySQL 8.4-Versionen
+ MySQL 8.0.35 und höhere Unterversionen
**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
Erstellt Platzhalter-GTIDs für die aktuelle DB-Instance.
### Syntax
```
CALL mysql.rds_group_replication_advance_gtid(
begin_id
, end_id
, server_uuid
);
```
### Parameter
*begin\$1id*
Die zu erstellende Start-Transaktions-ID.
*end\$1id*
Die zu erstellende Ende-Transaktions-ID.
*begin\$1id*
Der Parameter `group_replication_group_name` für die zu erstellende Transaktion. Der Parameter `group_replication_group_name` ist als UUID in der DB-Parametergruppe angegeben, die der DB-Instance zugeordnet ist.
### Nutzungshinweise
In einem Aktiv/Aktiv-Cluster müssen alle GTID-Transaktionen, die auf der neuen DB-Instance ausgeführt werden, auf den anderen Mitgliedern des Clusters vorhanden sein, damit eine DB-Instance einer Gruppe hinzugefügt werden kann. In ungewöhnlichen Situationen kann eine neue DB-Instance mehr Transaktionen haben, wenn diese ausgeführt werden, bevor die Instance der Gruppe hinzugefügt wird. In diesem Fall können Sie keine vorhandenen Transaktionen entfernen. Sie können jedoch diese Prozedur anwenden, um die entsprechenden Platzhalter-GTIDs auf den anderen DB-Instances in der Gruppe zu erstellen. Vergewissern Sie sich vorher, dass sich die Transaktionen *nicht auf die replizierten Daten auswirken*.
Wenn Sie diese Prozedur aufrufen, werden GTID-Transaktionen von `server_uuid:begin_id-end_id` mit leerem Inhalt erstellt. Um Replikationsprobleme zu vermeiden, sollten Sie diese Prozedur unter keinen anderen Bedingungen anwenden.
**Wichtig**
Rufen Sie diese Prozedur nicht auf, wenn der Aktiv/Aktiv-Cluster einwandfrei funktioniert. Rufen Sie diese Prozedur nur auf, wenn Sie sich der möglichen Konsequenzen der von Ihnen erstellten Transaktionen bewusst sind. Der Aufruf dieser Prozedur kann zu inkonsistenten Daten führen.
### Beispiel
Im folgenden Beispiel werden Platzhalter-GTIDs für die aktuelle DB-Instance erstellt:
```
CALL mysql.rds_group_replication_advance_gtid(5, 6, '11111111-2222-3333-4444-555555555555');
```
## mysql.rds\$1group\$1replication\$1create\$1user
Erstellt den Replikationsbenutzer `rdsgrprepladmin` für die Gruppenreplikation auf der DB-Instance.
### Syntax
```
CALL mysql.rds_group_replication_create_user(
replication_user_password
);
```
### Parameter
*replication\$1user\$1password*
Das Passwort des Replikationsbenutzers `rdsgrprepladmin`.
### Nutzungshinweise
+ Das Passwort des Replikationsbenutzers `rdsgrprepladmin` muss auf allen DB-Instances in einem Aktiv/Aktiv-Cluster identisch sein.
+ Der Benutzername `rdsgrprepladmin` ist für Gruppenreplikationsverbindungen reserviert. Kein anderer Benutzer, einschließlich des Masterbenutzers, darf diesen Benutzernamen haben.
### Beispiel
Im folgenden Beispiel wird der Replikationsbenutzer `rdsgrprepladmin` für die Gruppenreplikation auf der DB-Instance erstellt:
```
CALL mysql.rds_group_replication_create_user('password');
```
## mysql.rds\$1group\$1replication\$1set\$1recovery\$1channel
Legt den Kanal `group_replication_recovery` für einen Aktiv/Aktiv-Cluster fest. Die Prozedur verwendet den reservierten Benutzer `rdsgrprepladmin`, um den Kanal zu konfigurieren.
### Syntax
```
CALL mysql.rds_group_replication_set_recovery_channel(
replication_user_password);
```
### Parameter
*replication\$1user\$1password*
Das Passwort des Replikationsbenutzers `rdsgrprepladmin`.
### Nutzungshinweise
Das Passwort des Replikationsbenutzers `rdsgrprepladmin` muss auf allen DB-Instances in einem Aktiv/Aktiv-Cluster identisch sein. Durch Aufrufen von `mysql.rds_group_replication_create_user` wird das Passwort festgelegt.
### Beispiel
Im folgenden Beispiel wird der Kanal `group_replication_recovery` für einen Aktiv/Aktiv-Cluster festgelegt:
```
CALL mysql.rds_group_replication_set_recovery_channel('password');
```
## mysql.rds\$1group\$1replication\$1start
Startet die Gruppenreplikation auf der aktuellen DB-Instance.
### Syntax
```
CALL mysql.rds_group_replication_start(
bootstrap
);
```
### Parameter
*bootstrap*
Dieser Wert gibt an, ob eine neue Gruppe initialisiert oder einer vorhandenen Gruppe hinzugefügt werden soll. `1` initialisiert eine neue Gruppe mit der aktuellen DB-Instance. `0` verbindet die aktuelle DB-Instance mit einer vorhandenen Gruppe, indem eine Verbindung mit den Endpunkten hergestellt wird, die im Parameter `group_replication_group_seeds` der DB-Parametergruppe definiert sind, die der DB-Instance zugeordnet ist.
### Beispiel
Im folgenden Beispiel wird eine neue Gruppe mit der aktuellen DB-Instance initialisiert:
```
CALL mysql.rds_group_replication_start(1);
```
## mysql.rds\$1group\$1replication\$1stop
Stoppt die Gruppenreplikation auf der aktuellen DB-Instance.
### Syntax
```
CALL mysql.rds_group_replication_stop();
```
### Nutzungshinweise
Wenn Sie die Replikation auf einer DB-Instance stoppen, hat dies keine Auswirkungen auf andere DB-Instances im Aktiv/Aktiv-Cluster.
# 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');
```
# Transaktionen replizieren mit GTIDs
Die folgenden gespeicherten Prozeduren steuern, wie Transaktionen mithilfe von globalen Transaktions-Identifikatoren (GTIDs) mit RDS for MySQL repliziert werden. Weitere Hinweise zur Replikation auf GTIDs Basis von RDS for MySQL finden Sie unter[Verwenden der GTID-basierten Replikation](mysql-replication-gtid.md).
Wenn Sie gespeicherte Verfahren verwenden, um die Replikation mit einem mit `caching_sha2_password` 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.
**Topics**
+ [](#mysql_rds_skip_transaction_with_gtid)
+ [](#mysql_rds_start_replication_until_gtid)
##
Überspringt die Replikation einer Transaktion mit der angegebenen globalen Transaktionskennung (GTID) in einer MySQL-DB-Instance.
Sie können dieses Verfahren für die Notfallwiederherstellung verwenden, wenn eine bestimmte GTID-Transaktion bekanntermaßen ein Problem verursacht. Verwenden Sie diese gespeicherte Prozedur, um die problematische Transaktion zu überspringen. Problematisch sind beispielsweise Transaktionen, die die Replikation deaktivieren, wichtige Daten löschen oder dafür sorgen, dass die DB-Instance nicht mehr verfügbar ist.
### Syntax
```
CALL mysql.rds_skip_transaction_with_gtid (
gtid_to_skip
);
```
### Parameters
*gtid\$1to\$1skip*
Die GTID der zu überspringenden Replikationstransaktion.
### Nutzungshinweise
Die Prozedur `mysql.rds_skip_transaction_with_gtid` muss vom Hauptbenutzer ausgeführt werden.
Dieses Verfahren wird für alle Versionen von RDS für MySQL 5.7, alle Versionen von RDS für MySQL 8.0 sowie alle Versionen von RDS für MySQL 8.4 unterstützt.
### Beispiele
Im folgenden Beispiel wird die Replikation der Transaktion mit der GTID übersprunge `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`.
```
CALL mysql.rds_skip_transaction_with_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
##
Initiiert die Replikation von einer/einem RDS-für-MySQL-DB-Instance und stoppt die Replikation unmittelbar nach der angegebenen globalen Transaktionskennung (GTID).
### Syntax
```
CALL mysql.rds_start_replication_until_gtid(gtid);
```
### Parameters
*gtid*
Die GTID, nach der die Replikation stoppen soll.
### Nutzungshinweise
Die Prozedur `mysql.rds_start_replication_until_gtid` muss vom Hauptbenutzer ausgeführt werden.
Dieses Verfahren wird für alle Versionen von RDS für MySQL 5.7, alle Versionen von RDS für MySQL 8.0 sowie alle Versionen von RDS für MySQL 8.4 unterstützt.
Sie können diese Prozedur mit verzögerter Replikation für die Notfallwiederherstellung verwenden. Wenn Sie die verzögerte Replikation konfiguriert haben, können Sie diese Prozedur verwenden, um alle Änderungen bis zu einem Zeitpunkt unmittelbar vor Eintreten des Notfalls in einem verzögerten Lesereplikat wiederherzustellen. Nachdem diese Prozedur die Replikation gestoppt hat, können Sie das Lesereplikat zur neuen primären DB-Instance hochstufen (siehe die Anleitung unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md).
Sie können die verzögerte Replikation mit den folgenden gespeicherten Prozeduren konfigurieren:
+ [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration)
+ [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master_with_delay)
+ [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS-für-MySQL-Hauptversionen 8.4 und höher)](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)
Wenn der Parameter `gtid` eine Transaktion angibt, die bereits von dem Replikat ausgeführt wurde, wird die Replikation sofort gestoppt.
### Beispiele
Das folgende Beispiel initiiert die Replikation und repliziert die Änderungen, bis die GTID erreicht wir `3E11FA47-71CA-11E1-9E33-C80AA9429562:23`.
```
call mysql.rds_start_replication_until_gtid('3E11FA47-71CA-11E1-9E33-C80AA9429562:23');
```
# Rotieren der Abfrageprotokolle
Die folgenden gespeicherten Prozeduren rotieren MySQL-Protokolle in Backup-Tabellen. Weitere Informationen finden Sie unter [ MySQL-Datenbank-Logdateien](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
Rotiert die Tabelle `mysql.general_log` in eine Sicherungstabelle.
### Syntax
```
CALL mysql.rds_rotate_general_log;
```
### Nutzungshinweise
Sie können die Tabelle `mysql.general_log` in eine Sicherungstabelle rotieren, indem Sie die Prozedur `mysql.rds_rotate_general_log` aufrufen. Beim Rotieren von Protokolldateien wird die aktuelle Protokolltabelle in eine Sicherungsprotokolltabelle kopiert, und die Einträge in der aktuellen Protokolltabelle werden entfernt. Sofern bereits eine Sicherungsprotokolltabelle vorhanden ist, wird diese gelöscht, bevor die aktuelle Protokolltabelle in die Sicherungsprotokolltabelle kopiert wird. Sie können die Sicherungsprotokolltabelle abfragen, wenn dies nötig ist. Die Backup-Protokolltabelle für die `mysql.general_log`-Tabelle ist als `mysql.general_log_backup` benannt.
Sie können dieses Verfahren nur ausführen, wenn der Parameter `log_output` auf `TABLE` eingestellt ist.
## mysql.rds\$1rotate\$1slow\$1log
Rotiert die Tabelle `mysql.slow_log` in eine Sicherungstabelle.
### Syntax
```
CALL mysql.rds_rotate_slow_log;
```
### Nutzungshinweise
Sie können die Tabelle `mysql.slow_log` in eine Sicherungstabelle rotieren, indem Sie die Prozedur `mysql.rds_rotate_slow_log` aufrufen. Beim Rotieren von Protokolldateien wird die aktuelle Protokolltabelle in eine Sicherungsprotokolltabelle kopiert, und die Einträge in der aktuellen Protokolltabelle werden entfernt. Sofern bereits eine Sicherungsprotokolltabelle vorhanden ist, wird diese gelöscht, bevor die aktuelle Protokolltabelle in die Sicherungsprotokolltabelle kopiert wird.
Sie können die Sicherungsprotokolltabelle abfragen, wenn dies nötig ist. Die Backup-Protokolltabelle für die `mysql.slow_log`-Tabelle ist als `mysql.slow_log_backup` benannt.
# Festlegen und Anzeigen der Konfiguration des Binärprotokolls
Die folgenden gespeicherten Prozeduren legen Konfigurationsparameter fest und zeigen sie an, z. B. für die Aufbewahrung binärer Protokolldateien.
**Topics**
+ [mysql.rds\$1set\$1configuration](#mysql_rds_set_configuration)
+ [mysql.rds\$1show\$1configuration](#mysql_rds_show_configuration)
## mysql.rds\$1set\$1configuration
Gibt die Anzahl an Stunden an, für die die Binärprotokolle aufbewahrt werden sollen, oder die Anzahl Sekunden, um die die Replikation verzögert werden soll.
### Syntax
```
CALL mysql.rds_set_configuration(name,value);
```
### Parameters
*name*
Der Name des festzulegenden Konfigurationsparameters
*value*
Der Wert des Konfigurationsparameters
### Nutzungshinweise
Die Prozedur `mysql.rds_set_configuration` unterstützt die folgenden Konfigurationsparameter:
+ [binlog retention hours](#mysql_rds_set_configuration-usage-notes.binlog-retention-hours)
+ [Quellenverzögerung](#mysql_rds_set_configuration-usage-notes.source-delay)
+ [target delay](#mysql_rds_set_configuration-usage-notes.target-delay)
Die Konfigurationsparameter werden dauerhaft gespeichert und überstehen jeden Neustart oder Failover der DB-Instance.
#### binlog retention hours
Der Parameter `binlog retention hours` wird verwendet, um die Anzahl der Stunden anzugeben, die Binärprotokolldateien aufbewahrt werden sollen. In der Regel werden binäre Protokolldateien von Amazon RDS so schnell wie möglich bereinigt. Eine binäre Protokolldatei ist möglicherweise für die Replikation mit einer außerhalb von RDS ausgeführten MySQL-Datenbank erforderlich.
Der Standardwert von `binlog retention hours` ist `NULL`. Für RDS für MySQL bedeutet `NULL`, dass binäre Protokolle nicht aufbewahrt werden (0 Stunden).
Um die Anzahl der Stunden zu bestimmen, für die Binärprotokolle auf einer/einem DB-Instance aufbewahrt werden sollen, verwenden Sie die gespeicherte Prozedur `mysql.rds_set_configuration` und geben Sie, wie in dem folgenden Beispiel gezeigt, einen ausreichend großen Zeitraum für die gewünschte Replikation an.
`call mysql.rds_set_configuration('binlog retention hours', 24);`
**Anmerkung**
Sie können den Wert `0` nicht für `binlog retention hours` verwenden.
Für MySQL-DB-Instances beträgt der maximal zulässige Wert für `binlog retention hours` 168 (entspricht 7 Tagen).
Nachdem Sie den Aufbewahrungszeitraum festgelegt haben, überwachen Sie die Speichernutzung für die DB-Instance, um sicherzustellen, dass die aufbewahrten binären Protokolle nicht zu viel Speicherplatz beanspruchen.
Bei Multi-AZ-DB-Cluster-Bereitstellungen können Sie die Aufbewahrung von Binärprotokollen nur über die Writer-DB-Instance konfigurieren und die Einstellung wird asynchron an alle Reader-DB-Instances weitergegeben. Wenn Binärprotokolle auf dem DB-Cluster die Hälfte des gesamten lokalen Speicherplatzes überschreiten, verschiebt Amazon RDS automatisch veraltete Protokolle auf das EBS-Volume. Die neuesten Protokolle verbleiben jedoch im lokalen Speicher, sodass sie verloren gehen können, wenn ein Fehler auftritt, der einen Host-Austausch erfordert, oder wenn Sie die Datenbank nach oben oder unten skalieren.
#### Quellenverzögerung
Verwenden Sie den Parameter `source delay` in einem Lesereplikat zur Angabe der Sekundenzahl, um die die Replikation vom Lesereplikat zur entsprechenden Quelldatenbank-Instance verzögert werden soll. Amazon RDS repliziert Änderungen normalerweise so schnell wie möglich, in einigen Umgebungen ist aber eine Verzögerung der Replikation sinnvoll. Wenn die Replikation verzögert wird, können Sie alle Änderungen bis zu einem Zeitpunkt unmittelbar vor Eintreten des Notfalls in einem verzögerten Lesereplikat wiederherstellen. Wenn eine Tabelle versehentlich entfernt wurde, können Sie sie aufgrund der verzögerten Replikation schnell wiederherstellen. Der Standardwert von `target delay` ist `0` (Replikation nicht verzögern).
Wenn Sie diesen Parameter verwenden, wird [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) ausgeführt und „CHANGE primary TO MASTER\$1DELAY = input value“ angewendet. Bei Erfolg speichert die Prozedur den Parameter `source delay` in der Tabelle `mysql.rds_configuration`.
Verwenden Sie zum Angeben der Anzahl der Sekunden für Amazon RDS, um die die Replikation in eine Quell-DB-Instance verzögert werden soll, die gespeicherte Prozedur `mysql.rds_set_configuration`. Im folgenden Beispiel wird die Replikation um mindestens eine Stunde (3 600 Sekunden) verzögert.
`call mysql.rds_set_configuration('source delay', 3600);`
Die Prozedur führt dann `mysql.rds_set_source_delay(3600)` aus.
Die Obergrenze für den Parameter `source delay` beträgt einen Tag (86 400 Sekunden).
#### target delay
Verwenden Sie den Parameter `target delay` zur Angabe der Sekundenzahl, um die die Replikation zwischen einer DB-Instance und künftigen von RDS verwalteten Lesereplikaten, die anhand dieser Instance erstellt werden, verzögert werden soll. Dieser Parameter wird für non-RDS-managed Read Replicas ignoriert. Amazon RDS repliziert Änderungen normalerweise so schnell wie möglich, in einigen Umgebungen ist aber eine Verzögerung der Replikation sinnvoll. Wenn die Replikation verzögert wird, können Sie alle Änderungen bis zu einem Zeitpunkt unmittelbar vor Eintreten des Notfalls in einem verzögerten Lesereplikat wiederherstellen. Wenn eine Tabelle versehentlich entfernt wurde, können Sie sie mithilfe der verzögerten Replikation schnell wiederherstellen. Der Standardwert von `target delay` ist `0` (Replikation nicht verzögern).
Für die Notfallwiederherstellung können Sie diesen Konfigurationsparameter mit der gespeicherten Prozedur [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) oder [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) verwenden. Um alle Änderungen bis zu einem Zeitpunkt unmittelbar vor Eintreten des Notfalls in einem verzögerten Lesereplikat wiederherzustellen, können Sie die Prozedur `mysql.rds_set_configuration` mit diesem Parametersatz ausführen. Nachdem die Prozedur `mysql.rds_start_replication_until` oder `mysql.rds_start_replication_until_gtid` die Replikation gestoppt hat, können Sie das Lesereplikat zur neuen primären DB-Instance hochstufen (siehe die Anleitung unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md)).
Um die Prozedur `mysql.rds_rds_start_replication_until_gtid` verwenden zu können, muss die GTID-basierte Replikation aktiviert sein. Wenn Sie eine bestimmte GTID-basierte Transaktion überspringen möchten, von der Sie wissen, dass sie einen Notfall verursacht, können Sie die gespeicherte Prozedur [](mysql-stored-proc-gtid.md#mysql_rds_skip_transaction_with_gtid) verwenden. Weitere Informationen über das Arbeiten mit der GTID-basierten Replikation finden Sie unter [Verwenden der GTID-basierten Replikation](mysql-replication-gtid.md).
Verwenden Sie zum Angeben der Anzahl der Sekunden für Amazon RDS, um die die Replikation in ein Lesereplikat verzögert werden soll, die gespeicherte Prozedur `mysql.rds_set_configuration`. Das folgende Beispiel gibt an, dass die Replikation um mindestens eine Stunde (3600 Sekunden) verzögert wird.
`call mysql.rds_set_configuration('target delay', 3600);`
Die Obergrenze für den Parameter `target delay` beträgt einen Tag (86 400 Sekunden).
## mysql.rds\$1show\$1configuration
Die Anzahl der Stunden, während der binäre Protokolldateien aufbewahrt werden sollen.
### Syntax
```
CALL mysql.rds_show_configuration;
```
### Nutzungshinweise
Mit der gespeicherten Prozedur `mysql.rds_show_configuration` überprüfen Sie, wie viele Stunden Amazon RDS die binären Protokolldateien aufbewahrt werden.
### Beispiele
Nachfolgend sehen Sie ein Beispiel für die Anzeige des Aufbewahrungszeitraums:
```
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.
```
# Wärmen des InnoDB-Caches
Die folgenden gespeicherten Prozeduren speichern, laden oder brechen das Laden des InnoDB-Pufferpools auf RDS-für-MySQL-DB-Instances ab. Weitere Informationen finden Sie unter [InnoDB-Cache-Warming für MySQL in 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
Speichert den aktuellen Zustand des Pufferpools auf der Festplatte.
### Syntax
```
CALL mysql.rds_innodb_buffer_pool_dump_now();
```
### Nutzungshinweise
Die Prozedur `mysql.rds_innodb_buffer_pool_dump_now` muss vom Hauptbenutzer ausgeführt werden.
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort
Bricht das Laden des gespeicherten Zustands des Pufferpools ab, während der Vorgang läuft.
### Syntax
```
CALL mysql.rds_innodb_buffer_pool_load_abort();
```
### Nutzungshinweise
Die Prozedur `mysql.rds_innodb_buffer_pool_load_abort` muss vom Hauptbenutzer ausgeführt werden.
## mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now
Lädt den gespeicherten Zustand des Pufferpools von der Festplatte.
### Syntax
```
CALL mysql.rds_innodb_buffer_pool_load_now();
```
### Nutzungshinweise
Die Prozedur `mysql.rds_innodb_buffer_pool_load_now` muss vom Hauptbenutzer ausgeführt werden.