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.
# Arbeiten mit MySQL-Lesereplikaten
Im Folgenden finden Sie spezifische Informationen zum Arbeiten mit Lesereplikaten unter RDS für MySQL. Allgemeine Informationen zu Lesereplikaten und Anleitungen zu ihrer Verwendung finden Sie in [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
Weitere Informationen zu MySQL-Lesereplikaten finden Sie in den folgenden Themen.
+ [Konfigurieren von Replikationsfiltern mit MySQL](USER_MySQL.Replication.ReadReplicas.ReplicationFilters.md)
+ [Konfigurieren der verzögerten Replikation mit MySQL](USER_MySQL.Replication.ReadReplicas.DelayReplication.md)
+ [Aktualisieren von Lesereplikaten mit MySQL](USER_MySQL.Replication.ReadReplicas.Updates.md)
+ [Arbeiten mit Bereitstellungen von Multi-AZ-Lesereplikaten mit MySQL](USER_MySQL.Replication.ReadReplicas.MultiAZ.md)
+ [Verwendung von kaskadierenden Lesereplikaten mit RDS für MySQL](USER_MySQL.Replication.ReadReplicas.Cascading.md)
+ [Überwachen der Replikationsverzögerung für MySQL-Lesereplikate](USER_MySQL.Replication.ReadReplicas.Monitor.md)
+ [Starten und Stoppen der Replikation mit MySQL Read Replicas](USER_MySQL.Replication.ReadReplicas.StartStop.md)
+ [Fehlerbehebung für ein Problem mit einer MySQL Read Replica](USER_ReadRepl.Troubleshooting.md)
## Konfigurieren von Lesereplikaten mit MySQL
Bevor eine MySQL-DB-Instance als Replikationsquelle dienen kann, stellen Sie sicher, dass automatische Sicherungen für die Quell-DB-Instance aktiviert werden. Hierzu legen Sie für den Aufbewahrungszeitraum für Sicherungen einen anderen Wert als 0 fest. Diese Erfordernis gilt auch für ein Lesereplikat, das die Quell-DB-Instance für ein anderes Lesereplikat ist. Automatische Sicherungen werden nur für Lesereplikate unterstützt, die mit einer beliebigen MySQL-Version ausgeführt werden. Sie können die Replikation basierend auf den Binärprotokollkoordinaten für eine MySQL-DB-Instance konfigurieren.
Sie können die Replikation mithilfe von globalen Transaktionskennungen (GTIDs) in den folgenden Versionen konfigurieren:
+ RDS für MySQL Version 5.7.44 und höhere 5.7-Versionen
+ RDS für MySQL Version 8.0.28 und höhere 8.0-Versionen
+ RDS für MySQL Version 8.4.3 und höhere 8.4-Versionen
Weitere Informationen finden Sie unter [Verwenden der GTID-basierten Replikation](mysql-replication-gtid.md).
Sie können bis zu 15 Lesereplikate von einer DB-Instance innerhalb derselben Region erstellen. Damit die Replikation effektiv durchgeführt werden kann, sollte jedes Lesereplikat über die selbe Menge an Rechen- und Speicherressourcen wie die Quell-DB-Instance verfügen. Wenn Sie die Quell-DB-Instance skalieren, skalieren Sie auch die Lesereplikate.
RDS für MySQL unterstützt kaskadierende Lesereplikate. Informationen zum Konfigurieren von kaskadierenden Lesereplikaten finden Sie unter [Verwendung von kaskadierenden Lesereplikaten mit RDS für MySQL](USER_MySQL.Replication.ReadReplicas.Cascading.md).
Sie können mehrere Erstellungs- und Löschaktionen für Lesereplikate gleichzeitig ausführen, die auf die gleiche Quell-DB-Instance verweisen. Halten Sie sich bei der Ausführung dieser Aktionen an die Grenze von 15 Lesereplikaten für jede Quell-Instance.
Eine Lesereplikat einer MySQL-DB-Instance kann keine niedrigere DB-Engine-Version als die Quell-DB-Instance verwenden.
### Vorbereiten von MySQL-DB-Instances, die MyISAM verwenden
Wenn Ihre MySQL-DB-Instance eine nicht-transaktionale Engine, wie MyISAM, verwendet, müssen Sie die folgenden Schritte erfolgreich ausführen, um Ihr Lesereplikat einzurichten. Diese Schritte sind unbedingt notwendig, damit das Lesereplikat eine konsistente Kopie Ihrer Daten enthält. Diese Schritte sind nicht erforderlich, wenn alle Ihre Tabellen eine transaktionale Engine wie InnoDB nutzen.
1. Halten Sie alle Data Manipulation Language (DML)- und Data Definition Language (DDL)-Operationen in nicht-transaktionalen Tabellen in der Quell-DB-Instance an und warten Sie bis diese abgeschlossen sind. SELECT-Anweisungen können weiter ausgeführt werden.
1. Bereinigen und sperren Sie die Tabellen in der Quell-DB-Instance.
1. Erstellen Sie das Lesereplikat mithilfe der Methoden in den folgenden Abschnitten.
1. Überprüfen Sie den Vorgang der Lesereplikat-Erstellung mithilfe von beispielsweise der API-Operation `DescribeDBInstances`. Sobald das Lesereplikat verfügbar ist, entsperren Sie die Tabellen in der Quell-DB-Instance und fahren Sie mit den normalen Datenbank-Operationen fort.
# Konfigurieren von Replikationsfiltern mit MySQL
Sie können Replikationsfilter verwenden, um anzugeben, welche Datenbanken und Tabellen mit einem Lesereplikat repliziert werden. Replikationsfilter können Datenbanken und Tabellen in die Replikation einbeziehen oder sie von der Replikation ausschließen.
Im Folgenden finden Sie einige Anwendungsfälle für Replikationsfilter:
+ Reduzieren der Größe eines Lesereplikats. Mit Replikationsfiltern können Sie die Datenbanken und Tabellen ausschließen, die für das Lesereplikat nicht benötigt werden.
+ Ausschließen von Datenbanken und Tabellen von Lesereplikaten aus Sicherheitsgründen.
+ Replizieren verschiedener Datenbanken und Tabellen für spezifische Anwendungsfälle bei verschiedenen Lesereplikaten. Beispielsweise könnten Sie bestimmte Lesereplikate für Analysen oder Sharding verwenden.
+ Für eine DB-Instance, die Read Replicas in verschiedenen hat AWS-Regionen, um verschiedene Datenbanken oder Tabellen in verschiedenen zu replizieren. AWS-Regionen
**Anmerkung**
Sie können Replikationsfilter auch verwenden, um anzugeben, welche Datenbanken und Tabellen mit einer primären MySQL -DB-Instance repliziert werden, die als Replikat in einer eingehenden Replikationstopologie konfiguriert ist. Weitere Informationen zu dieser Konfiguration finden Sie unter [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.Repl.md).
**Topics**
+ [
## Einrichten der Parameter der Replikationsfilter bei RDS für MySQL
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Configuring)
+ [
## Einschränkungen der Replikationsfilter bei RDS für MySQL
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Limitations)
+ [
## Beispiele für Replikationsfilter bei RDS für MySQL
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Examples)
+ [
## Anzeigen der Replikationsfilter für ein Lesereplikat
](#USER_MySQL.Replication.ReadReplicas.ReplicationFilters.Viewing)
## Einrichten der Parameter der Replikationsfilter bei RDS für MySQL
Um Replikationsfilter zu konfigurieren, legen Sie die folgenden Filterparameter für die Replikation fest:
+ `replicate-do-db` – Repliziert Änderungen der angegebenen Datenbanken. Wenn Sie diesen Parameter für ein Lesereplikat festlegen, werden nur die im Parameter angegebenen Datenbanken repliziert.
+ `replicate-ignore-db` – Repliziert keine Änderungen der angegebenen Datenbanken. Wenn der Parameter `replicate-do-db` für ein Lesereplikat festgelegt ist, wird dieser Parameter nicht ausgewertet.
+ `replicate-do-table` – Repliziert Änderungen der angegebenen Tabellen. Wenn Sie diesen Parameter für ein Lesereplikat festlegen, werden nur die im Parameter angegebenen Tabellen repliziert. Wenn der Parameter `replicate-do-db` oder `replicate-ignore-db` festgelegt ist, müssen Sie die Datenbank, welche die angegebenen Tabellen enthält, in die Replikation mit dem Lesereplikat einbeziehen.
+ `replicate-ignore-table` – Repliziert keine Änderungen der angegebenen Tabellen. Wenn der Parameter `replicate-do-table` für ein Lesereplikat festgelegt ist, wird dieser Parameter nicht ausgewertet.
+ `replicate-wild-do-table` – Repliziert Tabellen basierend auf den angegebenen Namensmustern für Datenbanken und Tabellen. Die Platzhalterzeichen `%` und `_` werden unterstützt. Wenn der Parameter `replicate-do-db` oder `replicate-ignore-db` festgelegt ist, müssen Sie die Datenbank, welche die angegebenen Tabellen enthält, in die Replikation mit dem Lesereplikat einbeziehen.
+ `replicate-wild-ignore-table` – Repliziert keine Tabellen basierend auf den angegebenen Namensmustern für Datenbanken und Tabellen. Die Platzhalterzeichen `%` und `_` werden unterstützt. Wenn die Parameter `replicate-do-table` oder `replicate-wild-do-table` für ein Lesereplikat festgelegt sind, wird dieser Parameter nicht ausgewertet.
Die Parameter werden in der angegebenen Reihenfolge ausgewertet. Weitere Informationen zur Funktionsweise dieser Parameter finden Sie in der MySQL-Dokumentation:
+ Allgemeine Informationen finden Sie unter [Optionen und Variablen für Replikatserver](https://dev.mysql.com/doc/refman/8.0/en/replication-options-replica.html).
+ Informationen darüber, wie Filterparameter für die Datenbankreplikation ausgewertet werden, finden Sie unter [Optionen zur Auswertung der Replikation auf Datenbankebene und für die binäre Protokollierung](https://dev.mysql.com/doc/refman/8.0/en/replication-rules-db-options.html).
+ Informationen darüber, wie Filterparameter für die Tabellenreplikation ausgewertet werden, finden Sie unter [Optionen zur Auswertung der Replikation auf Tabellenebene](https://dev.mysql.com/doc/refman/8.0/en/replication-rules-table-options.html).
Standardmäßig hat jeder dieser Parameter einen leeren Wert. Sie können diese Parameter auf jedem Lesereplikat verwenden, um Replikationsfilter festzulegen, zu ändern und zu löschen. Wenn Sie einen dieser Parameter festlegen, trennen Sie die einzelnen Filter durch ein Komma voneinander.
Sie können die Platzhalterzeichen `%` und `_` in den Parametern `replicate-wild-do-table` und `replicate-wild-ignore-table` verwenden. Der Platzhalter `%` entspricht einer beliebigen Anzahl von Zeichen, und der Platzhalter `_` entspricht nur einem Zeichen.
Das binäre Protokollierungsformat der Quell-DB-Instance ist wichtig für die Replikation, da es den Datensatz der Datenänderungen bestimmt. Die Einstellung des Parameters `binlog_format` bestimmt, ob die Replikation zeilenbasiert oder anweisungsbasiert ist. Weitere Informationen finden Sie unter [Konfiguration von RDS für MySQL-Binärprotokollierung für Single-AZ-Datenbanken](USER_LogAccess.MySQL.BinaryFormat.md).
**Anmerkung**
Alle DDL-Anweisungen (Data Definition Language) werden unabhängig von der Einstellung `binlog_format` für die Quell-DB-Instance als Anweisungen repliziert.
## Einschränkungen der Replikationsfilter bei RDS für MySQL
Folgende Einschränkungen gelten für Replikationsfilter bei RDS für MySQL:
+ Jeder Filterparameter für die Replikation hat ein Limit von 2 000 Zeichen.
+ Kommas werden in Replikationsfiltern für Parameterwerte nicht unterstützt. In einer Liste mit Parametern können Kommas nur als Werttrennzeichen verwendet werden. Beispiel: `ParameterValue='`a,b`'` wird unterstützt, `ParameterValue='a,b'` jedoch nicht.
+ Die Optionen `--binlog-do-db` und `--binlog-ignore-db` von MySQL für binäre Protokollfilter werden nicht unterstützt.
+ Die Replikationsfilterung unterstützt keine XA-Transaktionen.
Weitere Informationen finden Sie unter [Einschränkungen bei XA-Transaktionen](https://dev.mysql.com/doc/refman/8.0/en/xa-restrictions.html) in der MySQL-Dokumentation.
## Beispiele für Replikationsfilter bei RDS für MySQL
Um die Replikationsfilter für ein Lesereplikat zu konfigurieren, ändern Sie die Parameter der Replikationsfilter in der Parametergruppe, die dem Lesereplikat zugeordnet ist.
**Anmerkung**
Eine Standard-Parametergruppe kann nicht modifiziert werden. Erstellen Sie eine neue Parametergruppe und ordnen Sie diese der Lesereplika zu, wenn die Lesereplika eine Standardparametergruppe verwendet. Weitere Informationen zu DB-Parametergruppen finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md).
Sie können Parameter in einer Parametergruppe mithilfe der AWS-Managementkonsole AWS CLI, oder RDS-API festlegen. Weitere Informationen zum Festlegen von Parametern finden Sie unter [Ändern von Parametern in einer DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md). Wenn Sie Parameter in einer Parametergruppe festlegen, verwenden alle DB-Instances, die der Parametergruppe zugeordnet sind, diese Parametereinstellungen. Wenn Sie Parameter der Replikationsfilter in einer Parametergruppe festlegen, stellen Sie sicher, dass die Parametergruppe nur Lesereplikaten zugeordnet ist. Lassen Sie die Parameter der Replikationsfilter für Quell-DB-Instances leer.
In den folgenden Beispielen werden die Parameter mithilfe von festgeleg AWS CLI. Diese Beispiele legen `ApplyMethod` auf `immediate` fest, sodass die Parameteränderungen unmittelbar nach Abschluss des CLI-Befehls erfolgen. Wenn Sie möchten, dass eine ausstehende Änderung nach dem Neustart des Lesereplikats angewendet wird, legen Sie `ApplyMethod` auf `pending-reboot` fest.
In den folgenden Beispielen werden Replikationsfilter festgelegt:
+ [Including databases in replication](#rep-filter-in-dbs-mysql)
+ [Including tables in replication](#rep-filter-in-tables-mysql)
+ [Including tables in replication with wildcard characters](#rep-filter-in-tables-wildcards-mysql)
+ [Excluding databases from replication](#rep-filter-ex-dbs-mysql)
+ [Excluding tables from replication](#rep-filter-ex-tables-mysql)
+ [Excluding tables from replication using wildcard characters](#rep-filter-ex-tables-wildcards-mysql)
**Example Einschließen von Datenbanken in die Replikation**
Das folgende Beispiel schließt die Datenbanken `mydb1` und `mydb2` in die Replikation ein.
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-db,ParameterValue='mydb1,mydb2',ApplyMethod=immediate"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-do-db,ParameterValue='mydb1,mydb2',ApplyMethod=immediate"
```
**Example Einschließen von Tabellen in die Replikation**
Das folgende Beispiel schließt die Tabellen `table1` und `table2` in der Datenbank `mydb1` in die Replikation ein.
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-do-table,ParameterValue='mydb1.table1,mydb1.table2',ApplyMethod=immediate"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-do-table,ParameterValue='mydb1.table1,mydb1.table2',ApplyMethod=immediate"
```
**Example Einschließen von Tabellen in die Replikation mit Platzhalterzeichen**
Das folgende Beispiel schließt Tabellen mit Namen, die mit `order` und `return` beginnen, in Datenbank `mydb` in die Replikation ein.
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-wild-do-table,ParameterValue='mydb.order%,mydb.return%',ApplyMethod=immediate"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-wild-do-table,ParameterValue='mydb.order%,mydb.return%',ApplyMethod=immediate"
```
**Example Ausschließen von Datenbanken von der Replikation**
Das folgende Beispiel schließt die Datenbanken `mydb5` und `mydb6` von der Replikation aus.
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-db,ParameterValue='mydb5,mydb6',ApplyMethod=immediate"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-ignore-db,ParameterValue='mydb5,mydb6',ApplyMethod=immediate"
```
**Example Ausschließen von Tabellen von der Replikation**
Das folgende Beispiel schließt die Tabellen `table1` in Datenbank `mydb5` und `table2` in Datenbank `mydb6` von der Replikation aus.
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-ignore-table,ParameterValue='mydb5.table1,mydb6.table2',ApplyMethod=immediate"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-ignore-table,ParameterValue='mydb5.table1,mydb6.table2',ApplyMethod=immediate"
```
**Example Ausschließen von Tabellen von der Replikation mit Platzhalterzeichen**
Das folgende Beispiel schließt Tabellen mit Namen, die mit `order` und `return` beginnen, in Datenbank `mydb7` von der Replikation aus.
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "ParameterName=replicate-wild-ignore-table,ParameterValue='mydb7.order%,mydb7.return%',ApplyMethod=immediate"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "ParameterName=replicate-wild-ignore-table,ParameterValue='mydb7.order%,mydb7.return%',ApplyMethod=immediate"
```
## Anzeigen der Replikationsfilter für ein Lesereplikat
Sie können die Replikationsfilter für ein Lesereplikat wie folgt anzeigen:
+ Überprüfen Sie die Einstellungen der Parameter der Replikationsfilter in der dem Lesereplikat zugeordneten Parametergruppe.
Detaillierte Anweisungen finden Sie unter [Anzeigen von Parameterwerten für eine DB-Parametergruppe in Amazon RDS](USER_WorkingWithParamGroups.Viewing.md).
+ Stellen Sie in einem MySQL-Client eine Verbindung zum Read-Replikat her und führen Sie die`SHOW REPLICA STATUS` Anweisung aus.
In der Ausgabe werden in den folgenden Feldern die Replikationsfilter für das Lesereplikat angezeigt:
+ `Replicate_Do_DB`
+ `Replicate_Ignore_DB`
+ `Replicate_Do_Table`
+ `Replicate_Ignore_Table`
+ `Replicate_Wild_Do_Table`
+ `Replicate_Wild_Ignore_Table`
Weitere Informationen zu diesen Feldern finden Sie unter [Überprüfen des Replikationsstatus](https://dev.mysql.com/doc/refman/8.0/en/replication-administration-status.html) in der MySQL-Dokumentation.
# Konfigurieren der verzögerten Replikation mit MySQL
Sie können die verzögerte Replikation als Strategie für die Notfallwiederherstellung einsetzen. Für die verzögerte Replikation geben Sie die Mindestanzahl von Sekunden an, um welche die Replikation von der Quelle in das Lesereplikat verzögert werden soll. Wenn es zu einem Notfall kommt, weil beispielsweise eine Tabelle versehentlich gelöscht wurde, können Sie das Problem mit den folgenden Schritten schnell beheben:
+ Beenden Sie die Replikation im Lesereplikat, bevor die Änderung, die den Notfall verursacht hat, an das Lesereplikat gesendet wird.
Verwenden Sie die gespeicherte Prozedur [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication), um die Replikation zu stoppen.
+ Starten Sie die Replikation und geben Sie an, dass die Replikation automatisch an einer bestimmten Position in der Protokolldatei stoppen soll.
Mit der gespeicherten Prozedur [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) geben Sie eine Position unmittelbar vor Eintreten des Notfalls an.
+ Stufen Sie das Lesereplikat zur neuen Quell-DB-Instance hoch, indem Sie der Anleitung unter folge [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md).
**Anmerkung**
Unter RDS für MySQL 8.4 wird die verzögerte Replikation für MySQL ab 8.4.3 unterstützt. In RDS für MySQL 8.0 wird die verzögerte Replikation für MySQL ab 8.0.28 unterstützt. Unter RDS für MySQL 5.7 wird die verzögerte Replikation für MySQL ab 5.7.44 unterstützt.
Verwenden Sie gespeicherte Prozeduren, um die verzögerte Replikation zu konfigurieren. Sie können die verzögerte Replikation nicht mit der AWS-Managementkonsole AWS CLI, der oder der Amazon RDS-API konfigurieren.
Sie können die Replikation auf der Grundlage globaler Transaktions-Identifikatoren (GTIDs) in einer Konfiguration mit verzögerter Replikation für die folgenden Versionen verwenden:
RDS für MySQL Version 5.7.44 und höhere 5.7-Versionen
RDS für MySQL Version 8.0.28 und höhere 8.0-Versionen
RDS für MySQL Version 8.4.3 und höhere 8.4-Versionen
Wenn Sie die GTID-basierte Replikation verwenden, nutzen Sie die gespeicherte Prozedur [](mysql-stored-proc-gtid.md#mysql_rds_start_replication_until_gtid) anstelle der gespeicherten Prozedur [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until). Weitere Informationen zu GTID-basierten Replikationen finden Sie unter [Verwenden der GTID-basierten Replikation](mysql-replication-gtid.md).
**Topics**
+ [
## Konfigurieren der verzögerten Replikation während der Erstellung von Read Replicas
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.ReplicaCreation)
+ [
## Ändern der verzögerten Replikation einer vorhandenen Read Replica
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.ExistingReplica)
+ [
## Festlegen einer Position zum Stoppen der Replikation zu einer Read Replica
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.StartUntil)
+ [
## Hochstufen eines Lesereplikats
](#USER_MySQL.Replication.ReadReplicas.DelayReplication.Promote)
## Konfigurieren der verzögerten Replikation während der Erstellung von Read Replicas
Um die verzögerte Replikation für zukünftig aus einer DB-Instance erstellte Lesereplikate zu konfigurieren, führen Sie die gespeicherte Prozedur [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) mit dem Parameter `target delay` aus.
**Konfigurieren Sie die verzögerte Replikation während der Lesereplikat-Erstellung wie folgt:**
1. Stellen Sie als Master-Benutzer mit einem MySQL-Client eine Verbindung zu der MySQL-DB-Instance her, die als Quelle für Lesereplikate verwendet werden soll.
1. Führen Sie die gespeicherte Prozedur [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) mit dem Parameter `target delay` aus.
Führen Sie beispielsweise die folgende gespeicherte Prozedur aus, um anzugeben, dass die Replikation um mindestens eine Stunde (3.600 Sekunden) für jedes Lesereplikat verzögert werden soll, das aus der aktuellen DB-Instance erstellt wird.
```
call mysql.rds_set_configuration('target delay', 3600);
```
**Anmerkung**
Nachdem Sie diese gespeicherte Prozedur ausgeführt haben, wird jedes Lesereplikat, das Sie mit der AWS CLI oder der Amazon RDS-API erstellen, so konfiguriert, dass die Replikation um die angegebene Anzahl von Sekunden verzögert wird.
## Ändern der verzögerten Replikation einer vorhandenen Read Replica
Führen Sie die gespeicherte Prozedur [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) aus, um die verzögerte Replikation eines vorhandenen Lesereplikats zu ändern.
**Ändern Sie die verzögerte Replikation eines existierenden Lesereplikats wie folgt:**
1. Verwenden Sie einen MySQL-Client, um als Master-Benutzer eine Verbindung zum Lesereplikat herzustellen.
1. Verwenden Sie die gespeicherte Prozedur [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication), um die Replikation zu stoppen.
1. Führen Sie die gespeicherte Prozedur [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay) aus.
Führen Sie beispielsweise die folgende gespeicherte Prozedur aus, um anzugeben, dass die Replikation für das Lesereplikat um mindestens eine Stunde (3600 Sekunden) verzögert werden soll.
```
call mysql.rds_set_source_delay(3600);
```
1. Verwenden Sie die gespeicherte Prozedur [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication), um die Replikation zu starten.
## Festlegen einer Position zum Stoppen der Replikation zu einer Read Replica
Nachdem Sie die Replikation für ein Lesereplikat gestoppt haben, können Sie die Replikation mit der gespeicherten Prozedur [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) starten und dann an einer angegebenen Position in der Binärprotokolldatei stoppen lassen.
**Starten Sie die Replikation für ein Lesereplikat und stoppen Sie die Replikation an einer bestimmten Position wie folgt:**
1. Verwenden Sie einen MySQL-Client, um als Masterbenutzer eine Verbindung zur MySQL-DB-Instance herzustellen.
1. Führen Sie die gespeicherte Prozedur [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) aus.
Das folgende Beispiel initiiert die Replikation und repliziert die Änderungen, bis die Position `120` in der Binärprotokolldatei `mysql-bin-changelog.000777` erreicht wird. Beispiel: In einem Szenario der Notfallwiederherstellung liegt die Position `120` unmittelbar vor der Katastrophe.
```
call mysql.rds_start_replication_until(
'mysql-bin-changelog.000777',
120);
```
Die Replikation stoppt automatisch, sobald der Stopppunkt erreicht ist. Das folgende RDS-Ereignis wird generiert: `Replication has been stopped since the replica reached the stop point specified by the rds_start_replication_until stored procedure`.
## Hochstufen eines Lesereplikats
Nachdem die Replikation gestoppt wurde, können Sie in einem Szenario der Notfallwiederherstellung ein Lesereplikat zur neuen Quell-DB-Instance hochstufen. Weitere Informationen zum Hochstufen eines Lesereplikats finden Sie unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md).
# Aktualisieren von Lesereplikaten mit MySQL
Lesereplikate wurden zur Unterstützung von Leseabfragen entwickelt. Jedoch könnten gelegentliche Updates notwendig sein. Sie könnten beispielsweise einen Index hinzufügen, um die spezifischen Abfragetypen zu optimieren, die auf das Replica zugreifen.
Zwar können Sie Updates aktivieren, indem Sie den Parameter `read_only` in der DB-Parametergruppe für das Lesereplikat auf `0` setzen. Wir raten jedoch davon ab, da Probleme auftreten können, wenn das Lesereplikat nicht mehr mit der Quell-DB-Instance kompatibel ist. Für Wartungsarbeiten empfehlen wir, blue/green Bereitstellungen zu verwenden. Weitere Informationen finden Sie unter [Verwendung von Blue/Green Bereitstellungen für Datenbankaktualisierungen](blue-green-deployments.md).
Wenn Sie den Schreibschutz für ein Lesereplikat deaktivieren, ändern Sie den Wert des Parameters `read_only` sobald wie möglich wieder in `1`.
# Arbeiten mit Bereitstellungen von Multi-AZ-Lesereplikaten mit MySQL
Sie können ein Lesereplikat aus Single-AZ- oder Multi-AZ-DB-Instance-Bereitstellungen erstellen. Sie können Multi-AZ-Bereitstellungen verwenden, um die Haltbarkeit und Verfügbarkeit kritischer Daten zu verbessern, aber Sie können Multi-AZ nicht zweitranging noch für schreibgeschützte Abfragen verwenden. Stattdessen können Sie Lesereplikate aus Multi-AZ-DB-Instances mit hohem Datenverkehr erstellen, um schreibgeschützte Abfragen auslagern zu können. Wenn die Quell-Instance einer Multi-AZ-Bereitstellung ein Failover zur sekundären Instance durchführt, werden alle zugehörigen Lesereplikate automatisch auf die Verwendung der sekundären (jetzt primären) Instance als Replikationsquelle umgeschaltet. Weitere Informationen finden Sie unter [Konfigurieren und Verwalten einer Multi-AZ-Bereitstellung für Amazon RDS](Concepts.MultiAZ.md).
Sie können ein Lesereplikat als Multi-AZ-DB-Instance erstellen. Amazon RDS erstellt eine Standby-Version des Replikats in einer anderen Availability Zone, um ein Failover für das Replikat zu unterstützen. Das Erstellen Ihres Lesereplikats als Multi-AZ-DB-Instance ist unabhängig davon, ob die Quelldatenbank eine Multi-AZ-DB-Instance ist.
# Verwendung von kaskadierenden Lesereplikaten mit RDS für MySQL
RDS für MySQL unterstützt kaskadierende Lesereplikate. Mit *kaskadierenden Lesereplikaten* können Sie Lesereplikate skalieren, ohne dass Sie zusätzlichen Overhead für Ihre Quell-DB-Instance von RDS für MySQL verursachen.
Bei kaskadierenden Lesereplikaten sendet Ihre DB-Instance von RDS für MySQL Daten an das erste Lesereplikat in der Kette. Dieses Lesereplikat sendet dann Daten an das zweite Replikat in der Kette usw. Das Endergebnis ist, dass alle Lesereplikate in der Kette die Änderungen von der DB-Instance von RDS für MySQL aufweisen, jedoch ohne Overhead ausschließlich auf der Quell-DB-Instance zu verursachen.
Sie können eine Reihe von bis zu drei Lesereplikaten in einer Kette von einer Quell-DB-Instance von RDS für MySQL erstellen. Angenommen, Sie haben eine DB-Instance von RDS für MySQL, `mysql-main`. Sie haben die folgenden Möglichkeiten:
+ Beginnend mit `mysql-main` erstellen Sie das erste Lesereplikat in der Kette `read-replica-1`.
+ Als Nächstes erstellen Sie ab `read-replica-1` das nächste Lesereplikat in der Kette `read-replica-2`.
+ Schließlich erstellen Sie ab `read-replica-2` das nächste Lesereplikat in der Kette `read-replica-3`.
Sie können kein weiteres Lesereplikat über dieses dritte kaskadierende Lesereplikat hinaus in der Reihe für `mysql-main` erstellen. Eine vollständige Reihe von Instances aus einer Quell-DB-Instance von RDS für MySQL bis zum Ende einer Reihe kaskadierender Lesereplikate kann aus höchstens vier DB-Instances bestehen.
Damit die Kaskadierung von Lesereplikaten funktioniert, müssen automatische Backups für jede Quell-DB-Instance von RDS für MySQL aktiviert sein. Erstellen Sie zuerst das Lesereplikat und ändern Sie es dann, um automatische Backups für das Lesereplikat für zu aktivieren. Weitere Informationen finden Sie unter [Erstellen eines Lesereplikats](USER_ReadRepl.Create.md).
Wie bei jedem Lesereplikat können Sie ein Lesereplikat, das Teil einer Kaskade ist, hochstufen. Wenn Sie ein Lesereplikat aus einer Kette von Lesereplikaten hochstufen, wird dieses Replikat aus der Kette entfernt. Angenommen, Sie möchten einen Teil der Workload von Ihrer `mysql-main`-DB-Instance zu einer neuen Instance verschieben, die nur von der Buchhaltung verwendet wird. Ausgehend von der Kette von drei Lesereplikaten aus dem Beispiel entscheiden Sie sich, `read-replica-2` hochzustufen. Die Kette ist wie folgt betroffen:
+ Durch Hochstufen von `read-replica-2` wird es aus der Replikationskette entfernt.
+ Es ist jetzt eine vollständige DB-Instance mit Lese-/Schreibzugriff.
+ Die Replizierung auf `read-replica-3` wird fortgesetzt wie vor der Hochstufung.
+ Ihre `mysql-main` setzt die Replizierung auf `read-replica-1` fort.
Weitere Informationen über das Hochstufen von Lesereplikaten finden Sie unter [Hochstufen eines Lesereplikats zur eigenständigen DB-Instance](USER_ReadRepl.Promote.md).
# Überwachen der Replikationsverzögerung für MySQL-Lesereplikate
Für MySQL-Lesereplikat können Sie die Replikationsverzögerung in Amazon CloudWatch überwachen, indem Sie sich die Amazon-RDS-Metrik `ReplicaLag` ansehen. Die Kennzahl `ReplicaLag` meldet den Wert des Feldes `Seconds_Behind_Master` des Befehls `SHOW REPLICA STATUS`.
Häufige Ursachen für Replikationsverzögerungen in MySQL:
+ Ein Netzwerkausfall.
+ Schreiben in Tabellen, die verschiedene Indizes in einem Lesereplikat haben. Wenn der Parameter `read_only` in einem Lesereplikat auf `0` gesetzt ist, kann die Replikation fehlschlagen, wenn das Lesereplikat nicht mehr mit der Quell-DB-Instance kompatibel ist. Nachdem Sie Wartungsarbeiten für ein Lesereplikat durchgeführt haben, sollten Sie den Parameter `read_only` wieder zurück auf `1` setzen.
+ Die Verwendung einer nicht-transaktionalen Speicher-Engine wie MyISAM: Die Replikation wird nur für die InnoDB-Speicher-Engine für MySQL unterstützt.
Wenn die Metrik `ReplicaLag` 0 erreicht, hat das Replica den Stand der Quell-DB-Instance erreicht. Wenn die Metrik `ReplicaLag` -1 zurückgibt, ist die Replikation aktuell nicht aktiv. `ReplicaLag` = -1 ist gleich `Seconds_Behind_Master` = `NULL`.
# Starten und Stoppen der Replikation mit MySQL Read Replicas
Sie können den Replikationsvorgang für eine Amazon-RDS-DB-Instance anhalten oder neustarten, indem Sie die gespeicherten Systemprozeduren [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) und [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) aufrufen. Dies können Sie tun, wenn Sie eine Replikation zwischen Amazon-RDS-Instances für langandauernde Operationen, wie dem Erstellen von großen Indexen, durchführen. Sie müssen Replikation auch anhalten und starten, wenn Sie Datenbanken importieren oder exportieren. Weitere Informationen erhalten Sie unter [Importieren von Daten in eine Datenbank von Amazon RDS für MySQL mit reduzierter Ausfallzeit](mysql-importing-data-reduced-downtime.md) und [Exportieren von Daten aus einer MySQL DB-Instance mithilfe der Replikation](MySQL.Procedural.Exporting.NonRDSRepl.md).
Wenn eine Replikation für mehr als 30 aufeinanderfolgende Tage manuell oder aufgrund eines Replikationsfehlers gestoppt wird, beendet Amazon RDS die Replikation zwischen der Quell-DB-Instance und allen Lesereplikaten. um erhöhten Speicheranforderungen in der Quell-DB-Instance vorzubeugen und lange Failover-Zeiten zu vermeiden. Die Lesereplikat-DB-Instance ist weiterhin verfügbar. Die Replikation kann jedoch nicht fortgesetzt werden, da die vom Lesereplikat benötigten Binärprotokolle aus der Quell-DB-Instance nach Beendigung der Replikation gelöscht wurden. Sie können ein neues Lesereplikat für die Quell-DB-Instance erstellen, um die Replikation erneut aufzunehmen.
# Fehlerbehebung für ein Problem mit einer MySQL Read Replica
Im Fall von MySQL-DB-Instances zeigen Lesereplikate manchmal Replikationsfehler oder Dateninkonsistenzen (oder beides) zwischen dem Lesereplikat und seiner DB-Quell-Instance an. Dieses Problem tritt auf, wenn einige Binärprotokoll (Binlog)-Ereignisse oder InnoDB-Wiederholungsprotokolle während eines Fehlers des Lesereplikats oder der Quell-DB-Instance nicht bereinigt werden. In diesen Fällen müssen Sie die Lesereplikate manuell löschen und neu erstellen. Sie können das Risiko minimieren, indem Sie die folgenden Parameterwerte einstellen: `sync_binlog=1` und `innodb_flush_log_at_trx_commit=1`. Diese Einstellungen könnten die Leistung reduzieren, daher ist es ratsam, sie vor der Implementierung in einer Produktionsumgebung ausgiebig zu testen.
**Warnung**
In der Parametergruppe, die mit der Quell-DB-Instance verknüpft ist, sollten diese Parameterwerte beibehalten werden: `sync_binlog=1` und `innodb_flush_log_at_trx_commit=1`. Diese Parameter sind dynamisch. Wenn Sie diese Einstellungen nicht verwenden möchten, empfehlen wir Ihnen, diese Werte vorübergehend festzulegen, bevor Sie einen Vorgang für die Quell-DB-Instance ausführen, der einen Neustart verursachen könnte. Zu diesen Vorgängen gehören unter anderem Neustart, Neustart mit Failover, das Aktualisieren der Datenbankversion und das Ändern der DB-Instance-Klasse oder ihres Speichers. Die gleiche Empfehlung gilt für das Erstellen neuer Lesereplikate für die Quell-DB-Instance.
Die Nichteinhaltung dieser Anleitung erhöht das Risiko, dass Lesereplikate Replikationsfehler oder Dateninkonsistenzen (oder beides) zwischen dem Lesereplikat und seiner DB-Quell-Instance aufweisen.
Die Replikationstechnologien in MySQL funktionieren nach einem asynchronen Prinzip. Da sie asynchron sind, steigt gelegentlich `BinLogDiskUsage` in der Quell-DB-Instance an und `ReplicaLag` ist im Lesereplikat zu erwarten. Beispielsweise kann auf der Quell-DB-Instance eine große Anzahl von Schreibvorgängen gleichzeitig ausgeführt werden. Dagegen werden Schreibvorgänge zum Lesereplikat über einen einzigen I/O-Thread seriell abgearbeitet. Dies kann zu einer Verzögerung zwischen der Quell-DB-Instance und dem Lesereplikat führen. Weitere Informationen über schreibgeschützte Replikate in der MySQL-Dokumentation finden Sie unter [Details zur Implementierung der Replikation](https://dev.mysql.com/doc/refman/8.0/en/replication-implementation-details.html).
Sie können folgende Dinge tun, um die Verzögerungszeit zwischen Aktualisierungen einer Quell-DB-Instance und der nachfolgenden Aktualisierung des Lesereplikats zu reduzieren:
+ Passen Sie die Speichergröße und die DB-Instance-Klasse eines Lesereplikats an die der Quell-DB-Instance an.
+ Stellen Sie sicher, dass Parametereinstellungen in den DB-Parametergruppen, die von der Quell-DB-Instance und den Lesereplikaten verwendet werden, kompatibel sind. Weitere Informationen und ein Beispiel finden Sie in der Beschreibung des `max_allowed_packet`-Parameters weiter unten in diesem Abschnitt.
Amazon RDS überwacht den Replikationsstatus Ihrer Lesereplikate und setzt den `Replication State` der Lesereplikat-Instance auf `Error`, wenn die Replikation aus irgendeinem Grund beendet wird. Ein Beispiel wären auf Ihrem Lesereplikat ausgeführte DML-Abfragen, die mit den Aktualisierungen auf der Quell-DB-Instance in Konflikt treten.
Sie können die Details des von der MySQL-Engine zurückgegebenen Fehlers dem Feld `Replication Error` entnehmen. Ereignisse, die den Status des Lesereplikats angeben, werden ebenfalls generiert, einschließlich [RDS-EVENT-0045](USER_Events.Messages.md#RDS-EVENT-0045), [RDS-EVENT-0046](USER_Events.Messages.md#RDS-EVENT-0046) und [RDS-EVENT-0047](USER_Events.Messages.md#RDS-EVENT-0047). Weitere Informationen über Ereignisse und Abonnements zu Ereignissen finden Sie unter [Arbeiten mit Amazon-RDS-Ereignisbenachrichtigungen](USER_Events.md). Wenn eine MySQL-Fehlermeldung zurückgegeben wird, überprüfen Sie die Fehlernummer in der [MySQL-Fehlermeldungsdokumentation](https://dev.mysql.com/doc/mysql-errors/8.0/en/server-error-reference.html).
Ein häufiges Problem, das Replikationsfehler verursachen kann, besteht, wenn der Wert für den `max_allowed_packet`-Parameter eines Lesereplikats niedriger ist als der Wert für den `max_allowed_packet`-Parameter der Quell-DB-Instance. Der `max_allowed_packet`-Parameter ist ein benutzerdefinierter Parameter, den Sie in einer DB-Parametergruppe festlegen können. Sie verwenden `max_allowed_packet`, um die maximale Größe von DML-Code anzugeben, der in der Datenbank ausgeführt werden kann. In einigen Fällen ist der `max_allowed_packet`-Wert in der mit einer Quell-DB-Instance verknüpften DB-Parametergruppe kleiner als der `max_allowed_packet`-Wert in der mit dem Lesereplikat der Quelle verknüpften DB-Parametergruppe. In diesen Fällen kann der Replikationsprozess den Fehler `Packet bigger than 'max_allowed_packet' bytes` auslösen und die Replikation beenden. Um den Fehler zu beheben, lassen Sie die DB-Quell-Instance und das Lesereplikat DB-Parametergruppen mit denselben `max_allowed_packet`-Parameterwerten verwenden.
Weitere Situationen, bei denen Replikationsfehler auftreten können, sind die Folgenden:
+ Schreibvorgänge auf Tabellen in einem Lesereplikat. In einigen Fällen können Sie Indizes für ein Lesereplikat erstellen, die sich von den Indizes in der Quell-DB-Instance unterscheiden. Wenn Sie dies tun, setzen Sie den Parameter `read_only` auf `0`, um die Indizes zu erstellen. Wenn Sie in einem Lesereplikat in Tabellen schreiben, kann die Replikation unterbrochen werden, wenn das Lesereplikat nicht mehr mit der Quell-DB-Instance kompatibel ist. Nachdem Sie Wartungsarbeiten für ein Lesereplikat durchgeführt haben, sollten Sie den Parameter `read_only` wieder zurück auf `1` setzen.
+ Die Verwendung einer nicht-transaktionalen Speicher-Engine wie MyISAM: Read Replicas erfordern eine transaktionale Speicher-Engine. Die Replikation wird nur für die InnoDB-Speicher-Engine für MySQL unterstützt.
+ Verwenden von nicht-deterministischen Abfragen wie `SYSDATE()`. Weitere Informationen finden Sie unter [Erkennen sicherer und nicht sicherer Anweisungen in der binären Protokollierung](https://dev.mysql.com/doc/refman/8.0/en/replication-rbr-safe-unsafe.html).
Wenn Sie entscheiden, dass Sie einen Fehler problemlos überspringen können, folgen Sie den Schritten im Abschnitt [Überspringen des aktuellen Replikationsfehlers für RDS für MySQL](Appendix.MySQL.CommonDBATasks.SkipError.md). Andernfalls können Sie zuerst das Lesereplikat löschen. Anschließend erstellen Sie eine Instance mit derselben DB-Instance-Kennung, sodass der Endpunkt mit dem des alten Lesereplikats übereinstimmt. Wird ein Replikationsfehler behoben, ändert sich das Feld `Replication State` zu *Replicating*.