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 der MariaDB-Replikation in Amazon RDS
Sie verwenden Lesereplikate üblicherweise, um die Replikation zwischen Amazon-RDS-DB-Instances zu konfigurieren. Allgemeine Informationen zu Lesereplikaten finden Sie unter [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md). Spezifische Informationen zum Arbeiten mit Lesereplikaten unter Amazon RDS für MariaDB finden Sie unter [Arbeiten mit MariaDB Read Replicas](USER_MariaDB.Replication.ReadReplicas.md).
Sie können die Replikation auch basierend auf den Binärprotokollkoordinaten für eine MariaDB-Instance konfigurieren. Für MariaDB-Instances können Sie die Replikation auch auf der Grundlage der globalen Transaktion IDs (GTIDs) konfigurieren, was eine bessere Absturzsicherheit bietet. Weitere Informationen finden Sie unter [Konfigurieren der GTID-basierten Replikation einer externen Quell-Instance](MariaDB.Procedural.Replication.GTID.md).
Nachfolgend finden Sie weitere Replikationsoptionen, die mit RDS für MariaDB verfügbar sind:
+ Sie können eine Replikation zwischen einer RDS-for-MariaDB-DB-Instance und einer MySQL- oder MariaDB-Instance, die außerhalb von Amazon RDS ausgeführt wird, einrichten. Informationen zum Konfigurieren der Replikation mit einer externen Quelle finden Sie unter [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.ReplMariaDB.md).
+ Sie können die Replikation zum Importieren von Datenbanken aus einer MySQL- oder MariaDB-Instance, die außerhalb von Amazon RDS ausgeführt wird, oder zum Exportieren von Datenbanken in solche Instances konfigurieren. Weitere Informationen erhalten Sie unter [Importieren von Daten in eine DB-Instance von Amazon RDS für MariaDB mit reduzierter Ausfallzeit](mariadb-importing-data-reduced-downtime.md) und [Exportieren von Daten aus einer MySQL DB-Instance mithilfe der Replikation](MySQL.Procedural.Exporting.NonRDSRepl.md).
Für jede dieser Replikationsoptionen können Sie die Replikation vom Typ „row-based“, „statement-based“ oder „mixed“ verwenden. Die Replikation vom Typ „row-based“ repliziert nur die geänderten Zeilen, die sich aus einer SQL-Anweisung ergeben. Die Replikation vom Typ „statement-based“ repliziert die gesamte SQL-Anweisung. Die Replikation vom Typ „mixed“ verwendet nach Möglichkeit Replikation vom Typ „statement-based“, wechselt aber auf Replikation vom Typ „row-based“, wenn SQL-Anweisungen ausgeführt werden, die bei der Replikation vom Typ „statement-based“ nicht sicher sind. In den meisten Fällen wird eine Replikation vom Typ „mixed“ empfohlen. Das binäre Protokollformat der DB-Instance bestimmt, ob die Replikation vom Typ „row-based“, „statement-based“ oder „mixed“ ist. Weitere Informationen zum Einrichten des binären Protokollformats finden Sie unter [Konfigurieren der Binärprotokollierung für MariaDB](USER_LogAccess.MariaDB.BinaryFormat.md).
Informationen zur Replikationskompatibilität zwischen MariaDB-Versionen finden Sie unter [Replication Compatibility](https://mariadb.com/kb/en/mariadb-vs-mysql-compatibility/#replication-compatibility) in der MariaDB-Dokumentation.
**Topics**
+ [Arbeiten mit MariaDB Read Replicas](USER_MariaDB.Replication.ReadReplicas.md)
+ [Konfigurieren der GTID-basierten Replikation einer externen Quell-Instance](MariaDB.Procedural.Replication.GTID.md)
+ [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](MySQL.Procedural.Importing.External.ReplMariaDB.md)
# Arbeiten mit MariaDB Read Replicas
Im Folgenden finden Sie spezifische Informationen zum Arbeiten mit Lesereplikaten in Amazon RDS für MariaDB. Allgemeine Informationen zu Lesereplikaten und Anleitungen zu ihrer Verwendung finden Sie in [Arbeiten mit DB-Instance-Lesereplikaten](USER_ReadRepl.md).
+ [Konfigurieren von Replikationsfiltern mit MariaDB](USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.md)
+ [Konfigurieren der verzögerten Replikation mit MariaDB](USER_MariaDB.Replication.ReadReplicas.DelayReplication.md)
+ [Löschen von Lesereplikaten bei MariaDB](USER_MariaDB.Replication.ReadReplicas.Updates.md)
+ [Arbeiten mit Bereitstellungen von Multi-AZ-Lesereplikaten mit MariaDB](USER_MariaDB.Replication.ReadReplicas.MultiAZ.md)
+ [Verwendung von kaskadierenden Lesereplikaten mit RDS für MariaDB](USER_MariaDB.Replication.ReadReplicas.Cascading.md)
+ [Überwachung von MariaDB Read Replicas](USER_MariaDB.Replication.ReadReplicas.Monitor.md)
+ [Starten und Stoppen der Replikation mit MariaDB Read Replicas](USER_MariaDB.Replication.ReadReplicas.StartStop.md)
+ [Fehlerbehebung bei Problemen mit einer MariaDB Read Replica](USER_ReadRepl.Troubleshooting.MariaDB.md)
## Konfigurieren von Lesereplikaten mit MariaDB
Bevor eine MariaDB-DB-Instance als Replikationsquelle eingesetzt werden kann, müssen Sie automatische Backups für die Quell-DB-Instance aktivieren, indem Sie den Aufbewahrungszeitraum für Backups auf einen anderen Wert als 0 festlegen. Diese Erfordernis gilt auch für ein Lesereplikat, das die Quell-DB-Instance für ein anderes Lesereplikat ist.
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 dieselbe 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 MariaDB unterstützt kaskadierende Lesereplikate. Informationen zum Konfigurieren von kaskadierenden Lesereplikaten finden Sie unter [Verwendung von kaskadierenden Lesereplikaten mit RDS für MariaDB](USER_MariaDB.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.
# Konfigurieren von Replikationsfiltern mit MariaDB
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 mit Read Replicas in verschiedenen AWS-Regionen, um unterschiedliche Datenbanken oder Tabellen in verschiedenen AWS-Regionen zu replizieren.
**Anmerkung**
Sie können Replikationsfilter verwenden, um anzugeben, welche Datenbanken und Tabellen mit einer primären MariaDB-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**
+ [Einstellen der Parameter der Replikationsfilter bei RDS für MariaDB](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Configuring)
+ [Einschränkungen der Replikationsfilter bei RDS für MariaDB](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Limitations)
+ [Beispiele für Replikationsfilter bei RDS für MariaDB](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Examples)
+ [Anzeigen der Replikationsfilter für ein Lesereplikat](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Viewing)
## Einstellen der Parameter der Replikationsfilter bei RDS für MariaDB
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, muss die Datenbank, die die angegebenen Tabellen enthält, in die Replikation mit dem Lesereplikat einbezogen werden.
+ `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 darüber, wie diese Parameter funktionieren, finden Sie in der [Dokumentation für MariaDB](https://mariadb.com/kb/en/replication-filters/#replication-filters-for-replication-slaves).
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 [Konfigurieren der Binärprotokollierung für MariaDB](USER_LogAccess.MariaDB.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 MariaDB
Folgende Einschränkungen gelten für Replikationsfilter bei RDS für MariaDB:
+ Jeder Filterparameter für die Replikation hat ein Limit von 2 000 Zeichen.
+ Kommas werden in Replikationsfiltern nicht unterstützt.
+ Die Optionen `binlog_do_db` und `binlog_ignore_db` von MariaDB 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.
+ Die Replikationsfilterung wird für RDS für MariaDB Version 10.2 nicht unterstützt.
## Beispiele für Replikationsfilter bei RDS für MariaDB
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 von AWS-Managementkonsole, AWS CLI oder der 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-mariadb)
+ [Including tables in replication](#rep-filter-in-tables-mariadb)
+ [Including tables in replication with wildcard characters](#rep-filter-in-tables-wildcards-mariadb)
+ [Escaping wildcard characters in names](#rep-filter-escape-wildcards-mariadb)
+ [Excluding databases from replication](#rep-filter-ex-dbs-mariadb)
+ [Excluding tables from replication](#rep-filter-ex-tables-mariadb)
+ [Excluding tables from replication using wildcard characters](#rep-filter-ex-tables-wildcards-mariadb)
**Example Einschließen von Datenbanken in die Replikation**
Das folgende Beispiel schließt die Datenbanken `mydb1` und `mydb2` in die Replikation ein. Wenn Sie `replicate-do-db` für ein Lesereplikat festlegen, werden nur die im Parameter angegebenen Datenbanken repliziert.
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 `orders` und `returns` 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.orders%,mydb.returns%", "ApplyMethod":"immediate"}]"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-wild-do-table", "ParameterValue": "mydb.orders%,mydb.returns%", "ApplyMethod":"immediate"}]"
```
**Example Escape-Platzhalterzeichen in Namen**
Das folgende Beispiel zeigt, wie Sie das Escapezeichen `\` verwenden, um ein Platzhalterzeichen zu umgehen, das Teil eines Namens ist.
Angenommen, Sie haben mehrere Tabellennamen in der Datenbank `mydb1`, die mit `my_table` beginnen, und Sie möchten diese Tabellen in die Replikation einschließen. Die Tabellennamen enthalten einen Unterstrich, der auch ein Platzhalterzeichen darstellt, sodass in dem Beispiel Unterstriche in den Tabellennamen mit Escapezeichen versehen sind.
Für Linux, macOS oder Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-wild-do-table", "ParameterValue": "my\_table%", "ApplyMethod":"immediate"}]"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-wild-do-table", "ParameterValue": "my\_table%", "ApplyMethod":"immediate"}]"
```
**Example Ausschließen von Datenbanken von der Replikation**
Das folgende Beispiel schließt die Datenbanken `mydb1` und `mydb2` 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": "mydb1,mydb2", "ApplyMethod":"immediate"}]"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-ignore-db", "ParameterValue": "mydb1,mydb2", "ApplyMethod":"immediate"}]"
```
**Example Ausschließen von Tabellen von der Replikation**
Das folgende Beispiel schließt die Tabellen `table1` und `table2` in der Datenbank `mydb1` 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": "mydb1.table1,mydb1.table2", "ApplyMethod":"immediate"}]"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-ignore-table", "ParameterValue": "mydb1.table1,mydb1.table2", "ApplyMethod":"immediate"}]"
```
**Example Ausschließen von Tabellen von der Replikation mit Platzhalterzeichen**
Das folgende Beispiel schließt Tabellen mit Namen, die mit `orders` und `returns` beginnen, in Datenbank `mydb` 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": "mydb.orders%,mydb.returns%", "ApplyMethod":"immediate"}]"
```
Für Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-wild-ignore-table", "ParameterValue": "mydb.orders%,mydb.returns%", "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 MariaDB-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.
**Anmerkung**
Frühere Versionen von MariaDB wurden`SHOW SLAVE STATUS` anstelle von verwendet`SHOW REPLICA STATUS`. Wenn Sie vor 10.5 eine MariaDB-Version verwenden, verwenden Si `SHOW SLAVE STATUS`.
# Konfigurieren der verzögerten Replikation mit MariaDB
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.
+ 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**
Die verzögerte Replikation wird für MariaDB 10.6 und höher 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, der AWS CLI oder der Amazon-RDS-API konfigurieren.
Sie können die Replikation basierend auf globalen Transaktionskennungen (GTIDs) in einer verzögerten Replikationskonfiguration verwenden.
**Topics**
+ [Konfigurieren der verzögerten Replikation während der Erstellung von Read Replicas](#USER_MariaDB.Replication.ReadReplicas.DelayReplication.ReplicaCreation)
+ [Ändern der verzögerten Replikation einer vorhandenen Read Replica](#USER_MariaDB.Replication.ReadReplicas.DelayReplication.ExistingReplica)
+ [Hochstufen eines Lesereplikats](#USER_MariaDB.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 MariaDB-Client eine Verbindung zu der MariaDB-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**
Nach dem Ausführen dieser gespeicherten Prozedur wird jedes Lesereplikat, das Sie mit der AWS CLI oder der Amazon-RDS-API erstellen, mit einer um die angegebene Anzahl Sekunden verzögerten Replikation konfiguriert.
## Ä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 MariaDB-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.
## 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).
# Löschen von Lesereplikaten bei MariaDB
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 beim Zugriff auf das Replica zu beschleunigen. Sie können Updates aktivieren, indem Sie den Parameter `read_only` in der DB-Parametergruppe für das Lesereplikat auf **0** setzen.
# Arbeiten mit Bereitstellungen von Multi-AZ-Lesereplikaten mit MariaDB
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 MariaDB
RDS für MariaDB unterstützt kaskadierende Lesereplikate. Mit *kaskadierenden Lesereplikaten* können Sie Lesevorgänge skalieren, ohne dass Sie zusätzlichen Overhead für Ihre Quell-DB-Instance von RDS für MariaDB verursachen.
Bei kaskadierenden Lesereplikaten sendet Ihre DB-Instance von RDS für MariaDB 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 MariaDB 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 MariaDB erstellen. Angenommen, Sie haben eine DB-Instance von RDS für MariaDB, `mariadb-main`. Sie haben die folgenden Möglichkeiten:
+ Beginnend mit `mariadb-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 `mariadb-main` erstellen. Eine vollständige Reihe von Instances aus einer Quell-DB-Instance von RDS für MariaDB 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 MariaDB 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 `mariadb-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 `mariadb-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).
# Überwachung von MariaDB Read Replicas
Für MariaDB-Lesereplikate können Sie die Replikationsverzögerung in Amazon CloudWatch überwachen, indem Sie die Amazon-RDS-Metrik `ReplicaLag` anzeigen. Die Kennzahl `ReplicaLag` meldet den Wert des Feldes `Seconds_Behind_Master` des Befehls `SHOW REPLICA STATUS`.
**Anmerkung**
Frühere Versionen von MariaDB wurden`SHOW SLAVE STATUS` anstelle von verwendet`SHOW REPLICA STATUS`. Wenn Sie vor 10.5 eine MariaDB-Version verwenden, verwenden Si `SHOW SLAVE STATUS`.
Häufige Ursachen für Replikationsverzögerung in MariaDB:
+ Ein Netzwerkausfall.
+ Schreibvorgänge auf Tabellen mit Indizes auf einem Lesereplikat. Wenn der Parameter `read_only` im Lesereplikat nicht auf 0 gesetzt ist, kann es die Replikation unterbrechen.
+ Die Verwendung einer nicht-transaktionalen Speicher-Engine wie MyISAM: Die Replikation wird nur für die InnoDB-Speicher-Engine für MariaDB 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 MariaDB 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 DB-Instance von Amazon RDS für MariaDB mit reduzierter Ausfallzeit](mariadb-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 bei Problemen mit einer MariaDB Read Replica
Die Replikationstechnologien für MariaDB arbeiten asynchron. 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 MariaDB-Dokumentation finden Sie unter [Replikation - Übersicht](http://mariadb.com/kb/en/mariadb/replication-overview/).
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 MariaDB-Engine zurückgegebenen Fehlers im Feld `Replication Error` überprüfen. 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 MariaDB-Fehlermeldung zurückgegeben wird, überprüfen Sie den Fehler in der [MariaDB error message documentation](http://mariadb.com/kb/en/mariadb/mariadb-error-codes/).
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, mit der die maximale Größe des auf der Datenbank ausführbaren DML-Codes angegeben wird. In einigen Fällen ist der Parameterwert `max_allowed_packet` in der mit einer Quell-DB-Instance verknüpften DB-Parametergruppe kleiner als der Parameterwert `max_allowed_packet` in der mit dem Lesereplikat der Quelle verknüpften DB-Parametergruppe. In diesen Fällen kann der Replikationsvorgang einen Fehler zurückgeben (Paket größer als "max\$1allowed\$1packet" Bytes) und die Replikation anhalten. Sie können den Fehler beheben, indem Sie die DB-Parametergruppe der Quelle und des Lesereplikats mit denselben Parameterwerten für `max_allowed_packet` verwenden.
Weitere Situationen, bei denen Replikationsfehler auftreten können, sind die Folgenden:
+ Schreibvorgänge auf Tabellen in einem Lesereplikat. Wenn Sie Indizes für ein Lesereplikat erstellen, müssen Sie den `read_only`-Parameter auf **0** setzen, um die Indizes zu erstellen. Wenn Sie in dem Lesereplikat in Tabellen schreiben, kann die Replikation unterbrochen werden.
+ Bei Verwendung einer nicht-transaktionalen Speicher-Engine wie MyISAM, erfordern Lesereplikate eine transaktionale Speicher-Engine. Die Replikation wird nur für die InnoDB-Speicher-Engine für MariaDB 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 in [Überspringen des aktuellen Replikationsfehlers für RDS für MySQL](Appendix.MySQL.CommonDBATasks.SkipError.md). Andernfalls können Sie das Lesereplikat löschen und eine Instance mit derselben DB-Instance-Kennung erstellen, sodass der Endpunkt mit dem alten Lesereplikat übereinstimmt. Wird ein Replikationsfehler behoben, ändert sich das Feld `Replication State` zu *Replicating*.
Bei MariaDB-DB-Instances kann in manchen Fällen nicht auf sekundäre Lesereplikate umgestellt werden, wenn während des Fehlers nicht alle Binärprotokollereignisse (binlog) bereinigt wurden. 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.
# Konfigurieren der GTID-basierten Replikation einer externen Quell-Instance
Sie können die Replikation basierend auf globalen Transaktions-Identifikatoren (GTIDs) von einer externen MariaDB-Instance der Version 10.0.24 oder höher in eine RDS for MariaDB-DB-Instance einrichten. Befolgen Sie diese Richtlinien, wenn Sie eine externe Quellinstance und ein Replikat auf Amazon RDS einrichten:
+ Überwachen Sie Failover-Ereignisse für die RDS-for-MariaDB-DB-Instance, die Ihr Replikat ist. Tritt ein Failover auf, kann die DB-Instance, die Ihr Replikat ist, auf einem neuen Host mit einer anderen Netzwerkadresse wiederhergestellt werden. Weitere Informationen zum Überwachen von Failover-Ereignissen finden Sie unter [Arbeiten mit Amazon-RDS-Ereignisbenachrichtigungen](USER_Events.md).
+ Behalten Sie die Binärprotokolle auf Ihrer Quell-Instance, bis sichergestellt ist, dass sie auf das Replikat angewendet wurden. Durch das Aufbewahren können Sie sicherstellen, dass Sie Ihre Quell-Instance im Fall eines Ausfalls wiederherstellen können.
+ Schalten Sie automatische Backups in Ihrer MariaDB-DB-Instance auf Amazon RDS ein. Das Einschalten automatischer Backups stellt sicher, dass Sie Ihr Replikat zu einem bestimmten Zeitpunkt wiederherstellen können, wenn Sie den Master und das Replikat neu synchronisieren müssen. Informationen zu Backups und Restore finden Sie unter. Point-In-Time [Sichern, Wiederherstellen und Exportieren von Daten](CHAP_CommonTasks.BackupRestore.md)
**Anmerkung**
Die erforderlichen Berechtigungen für das Starten einer Replikation in einer MariaDB-DB-instance sind beschränkt und für die Amazon-RDS-Hauptbenutzer nicht verfügbar. Aus diesem Grund müssen Sie die Amazon-RDS-Befehle [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md) und [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) verwenden, um eine Replikation zwischen der Live-Datenbank und der RDS-for-MariaDB-Datenbank einzurichten.
Um die Replikation zwischen einer externen Quell-Instance und einer MariaDB DB-Instance auf Amazon RDS zu starten, gehen Sie wie folgt vor.
**So starten Sie eine Replikation:**
1. Legen Sie die Quell-MariaDB-Instance als schreibgeschützt fest:
```
mysql> FLUSH TABLES WITH READ LOCK;
mysql> SET GLOBAL read_only = ON;
```
1. Rufen Sie die aktuelle GTID der externen MariaDB-Instance ab. Sie können dies mithilfe von `mysql` oder mithilfe des Query Editors Ihrer Wahl tun, um `SELECT @@gtid_current_pos;` auszuführen.
Das GTID-Format sieht folgendermaßen aus: `--`. Eine GTID sieht typischerweise so aus **0-1234510749-1728**. Weitere Informationen zu GTIDs und ihren Bestandteilen finden Sie unter [Global Transaction ID](http://mariadb.com/kb/en/mariadb/global-transaction-id/) in der MariaDB-Dokumentation.
1. Kopieren Sie die Datenbank mithilfe von von der externen MariaDB-Instance in die MariaDB-DB-Instanc `mysqldump`. Für große Datenbanken empfiehlt es sich, die Prozedur in zu verwende [Importieren von Daten in eine DB-Instance von Amazon RDS für MariaDB mit reduzierter Ausfallzeit](mariadb-importing-data-reduced-downtime.md).
Für Linux, macOS oder Unix:
```
mysqldump \
--databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u local_user \
-plocal_password | mysql \
--host=hostname \
--port=3306 \
-u RDS_user_name \
-pRDS_password
```
Für Windows:
```
mysqldump ^
--databases database_name ^
--single-transaction ^
--compress ^
--order-by-primary \
-u local_user \
-plocal_password | mysql ^
--host=hostname ^
--port=3306 ^
-u RDS_user_name ^
-pRDS_password
```
**Anmerkung**
Zwischen der Option `-p` und dem eingegebenen Passwort darf kein Leerzeichen vorhanden sein.
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
Verwenden Sie die Optionen `--host`, `--user (-u)`, `--port` und `-p` im Befehl `mysql`, um Hostnamen, Benutzernamen, Port und Passwort für die Verbindung mit Ihrer MariaDB-DB-Instance festzulegen. Der Hostname ist der DNS-Name aus dem Endpunkt der MariaDB-DB-Instance, z. B. `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Sie finden den Endpunktwert in den Instance-Details in der Amazon-RDS-Managementkonsole.
1. Legen Sie die Quell-MariaDB-Instance als wieder beschreibbar fest.
```
mysql> SET GLOBAL read_only = OFF;
mysql> UNLOCK TABLES;
```
1. Fügen Sie in der Amazon-RDS-Managementkonsole die IP-Adresse des Servers, der die externe MariaDB-Datenbank hostet, zu der VPC-Sicherheitsgruppe dieser MariaDB-DB-Instance hinzu. Weitere Informationen zum Modifizieren einer VPC-Sicherheitsgruppe finden Sie unter [Sicherheitsgruppen für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) im *Amazon Virtual Private Cloud-Benutzerhandbuch*.
Die IP-Adresse kann sich ändern, wenn die folgenden Bedingungen erfüllt sind:
+ Sie verwenden eine öffentliche IP-Adresse für die Kommunikation zwischen der externen Quell-Instance und der DB-Instance.
+ Die externe Quell-Instance wurde gestoppt und neu gestartet.
Wenn diese Bedingungen erfüllt sind, überprüfen Sie die IP-Adresse, bevor Sie sie hinzufügen.
Es könnte sein, dass Sie Ihr lokales Netzwerk so konfigurieren müssen, dass es Verbindungen von der IP-Adresse Ihrer MariaDB-DB-Instance zulässt, damit es mit Ihrer externen MariaDB-Instance kommunizieren kann. Verwenden Sie den Befehl `host`, um die IP-Adresse Ihrer MariaDB-DB-Instance zu herauszufinden.
```
host db_instance_endpoint
```
Der Host-Name ist der DNS-Name aus dem Endpunkt der MariaDB-DB-Instance.
1. Verbinden Sie sich mithilfe eines Clients Ihrer Wahl mit der externen MariaDB-Instance und erstellen Sie einen MariaDB-Benutzer, der für die Replikation verwendet werden soll. Dieses Konto wird ausschließlich für die Replikation verwendet und muss auf Ihre Domäne beschränkt sein, um die Sicherheit zu erhöhen. 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 für die externe MariaDB-Instance die Berechtigungen `REPLICATION CLIENT` und `REPLICATION SLAVE` für Ihren Replikationsbenutzer. Erteilen Sie beispielsweise die Sonderrechte `REPLICATION CLIENT` und `REPLICATION SLAVE` in allen Datenbank für den '`repl_user`'-Benutzer für Ihre Domäne, mit dem folgenden Befehl.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. Machen Sie die MariaDB-DB-Instance zum Replikat. Verbinden Sie sich als Masterbenutzer mit der MariaDB-DB-Instance und bestimmen Sie die externe MariaDB-Datenbank mithilfe des Befehls [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md) als Quell-Instance. Verwenden Sie die GTID, die Sie in Schritt 2 festgelegt haben. Im Folgenden wird ein -Beispiel gezeigt.
```
CALL mysql.rds_set_external_master_gtid ('mymasterserver.mydomain.com', 3306, 'repl_user', 'password', 'GTID', 1);
```
**Anmerkung**
Geben Sie aus Sicherheitsgründen ein anderes Passwort als hier angegeben an.
1. Verwenden Sie auf der MariaDB-DB-Instance den Befehl [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication), um die Replikation zu starten:
```
CALL mysql.rds_start_replication;
```
# Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance
Sie können eine Replikation zwischen einer RDS für MySQL- oder MariaDB-DB-Instance und einer MySQL- oder MariaDB-Instance, die außerhalb von Amazon RDS ausgeführt wird, mit der Binärprotokolldatei-Replikation einrichten.
**Topics**
+ [Bevor Sie beginnen](#MySQL.Procedural.Importing.External.Repl.BeforeYouBegin)
+ [Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance](#MySQL.Procedural.Importing.External.Repl.Procedure)
## Bevor Sie beginnen
Sie konfigurieren die Replikation mithilfe der Position der Binärprotokolldatei von replizierten Transaktionen.
Die erforderlichen Berechtigungen für das Starten einer Replikation in einer Amazon-RDS-DB-Instance sind beschränkt und für Ihre Amazon-RDS-Hauptbenutzer nicht verfügbar. Achten Sie daher darauf, dass Sie die Amazon-RDS-Befehle [mysql.rds\$1set\$1external\$1master (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master) oder [mysql.rds\$1set\$1external\$1source (RDS-für-MySQL-Hauptversionen 8.4 und höher)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) und [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) verwenden, um eine Replikation zwischen Ihrer Live-Datenbank und Ihrer Amazon-RDS-Datenbank einzurichten.
Aktualisieren Sie den Parameter `binlog_format`, um das binäre Protokollierungsformat für eine MySQL- oder MariaDB-Datenbank festzulegen. Wenn Ihre DB-Instance die standardmäßige DB-Instance-Parametergruppe verwendet, erstellen Sie eine neue DB-Parametergruppe, um den Parameter `binlog_format` zu ändern. In MariaDB sowie MySQL 8.0 und früheren Versionen ist `binlog_format` standardmäßig auf `MIXED` festgelegt. Sie können `binlog_format` jedoch auch auf `ROW` oder `STATEMENT` einstellen, wenn Sie ein spezifisches Format des Binärprotokolls (binlog) benötigen. Starten Sie Ihre DB-Instance neu, damit die Änderungen übernommen werden. In MySQL 8.4 und höheren Versionen ist `binlog_format` standardmäßig auf `ROW` festgelegt.
Informationen zum Einstellen des Parameters `binlog_format` erhalten Sie unter [Konfiguration von RDS für MySQL-Binärprotokollierung für Single-AZ-Datenbanken](USER_LogAccess.MySQL.BinaryFormat.md). Informationen über die Auswirkungen der Verwendung unterschiedlicher MySQL-Replikationstypen finden Sie unter [Vor- und Nachteile einer auf Anweisungen und einer auf Zeilen basierenden Replikation](https://dev.mysql.com/doc/refman/8.0/en/replication-sbr-rbr.html) in der MySQL-Dokumentation.
## Konfigurieren der Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance
Befolgen Sie diese Richtlinien, wenn Sie eine externe Quellinstance und ein Replikat auf Amazon RDS einrichten:
+ Überwachen Sie Failover-Ereignisse für die Amazon-RDS-DB-Instance, die Ihr Replica ist. Tritt ein Failover auf, kann die DB-Instance, die Ihr Replikat ist, auf einem neuen Host mit einer anderen Netzwerkadresse wiederhergestellt werden. Weitere Informationen zum Überwachen von Failover-Ereignissen finden Sie unter [Arbeiten mit Amazon-RDS-Ereignisbenachrichtigungen](USER_Events.md).
+ Bewahren Sie die Binärprotokolle auf Ihrer Quell-Instance auf, bis Sie sichergestellt haben, dass sie auf das Replikat angewendet wurden. Durch das Aufbewahren können Sie sicherstellen, dass Sie Ihre Quell-Instance im Fall eines Ausfalls wiederherstellen können.
+ Schalten Sie automatische Backups in Ihrer Amazon-RDS-DB-Instance ein. Das Einschalten automatischer Sicherungen stellt sicher, dass Sie Ihr Replikat zu einem bestimmten Zeitpunkt wiederherstellen können, wenn Sie die Quell-Instance und das Replikat neu synchronisieren müssen. Informationen zu Sicherungen und point-in-time Wiederherstellungen finden Sie unter[Sichern, Wiederherstellen und Exportieren von Daten](CHAP_CommonTasks.BackupRestore.md).
**Konfigurieren Sie die Replikation der Binärprotokolldateiposition mit einer externen Quell-Instance wie folgt:**
1. Legen Sie die Quell-MySQL- oder MariaDB-Instance als schreibgeschützt fest.
```
mysql> FLUSH TABLES WITH READ LOCK;
mysql> SET GLOBAL read_only = ON;
```
1. Führen Sie den Befehl `SHOW MASTER STATUS` in der MySQL- oder MariaDB-Quell-Instance aus, um die Position des Binärprotokolls zu ermitteln.
Sie erhalten eine Ausgabe, ähnlich der im folgenden Beispiel.
```
File Position
------------------------------------
mysql-bin-changelog.000031 107
------------------------------------
```
1. Kopieren Sie die Datenbank aus der externen Instance in die Amazon-RDS-DB-Instance mithilfe von `mysqldump`. Für große Datenbanken empfiehlt es sich, die Prozedur in zu verwende [Importieren von Daten in eine Datenbank von Amazon RDS für MySQL mit reduzierter Ausfallzeit](mysql-importing-data-reduced-downtime.md).
Für Linux, macOS oder Unix:
```
mysqldump --databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u local_user \
-plocal_password | mysql \
--host=hostname \
--port=3306 \
-u RDS_user_name \
-pRDS_password
```
Für Windows:
```
mysqldump --databases database_name ^
--single-transaction ^
--compress ^
--order-by-primary ^
-u local_user ^
-plocal_password | mysql ^
--host=hostname ^
--port=3306 ^
-u RDS_user_name ^
-pRDS_password
```
**Anmerkung**
Zwischen der Option `-p` und dem eingegebenen Passwort darf kein Leerzeichen vorhanden sein.
Zum Festlegen von Host-Name, Benutzername, Port und Passwort für die Verbindung mit Ihrer Amazon-RDS-DB-Instance verwenden Sie die Optionen `--host`, `--user (-u)`, `--port` und `-p` im Befehl `mysql`. Der Hostname ist der DNS-Name (Domain Name Service) aus dem Endpunkt der Amazon-RDS-DB-Instance, z. B `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Sie finden den Endpunktwert in den Instance-Details in der AWS-Managementkonsole.
1. Legen Sie die Quell-MySQL- oder MariaDB-Instance als wieder beschreibbar fest.
```
mysql> SET GLOBAL read_only = OFF;
mysql> UNLOCK TABLES;
```
Weitere Informationen zum Erstellen von Backups zur Verwendung mit der Replikation finden Sie unter [in der MySQL-Dokumentation](https://dev.mysql.com/doc/refman/8.0/en/replication-solutions-backups-read-only.html).
1. Fügen Sie im die IP-Adresse des Servers AWS-Managementkonsole, der die externe Datenbank hostet, der Sicherheitsgruppe Virtual Private Cloud (VPC) für die Amazon RDS-DB-Instance hinzu. Weitere Informationen zum Ändern einer VPC-Sicherheitsgruppe finden Sie unter [Sicherheitsgruppen für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) im *Amazon Virtual Private Cloud-Benutzerhandbuch*.
Die IP-Adresse kann sich ändern, wenn die folgenden Bedingungen erfüllt sind:
+ Sie verwenden eine öffentliche IP-Adresse für die Kommunikation zwischen der externen Quell-Instance und der DB-Instance.
+ Die externe Quell-Instance wurde gestoppt und neu gestartet.
Wenn diese Bedingungen erfüllt sind, überprüfen Sie die IP-Adresse, bevor Sie sie hinzufügen.
Es könnte sein, dass Sie Ihr lokales Netzwerk so konfigurieren müssen, dass es Verbindungen von der IP-Adresse Ihrer Amazon-RDS-DB-Instance zulässt. Sie tun dies, damit Ihr lokales Netzwerk mit Ihrer externen MySQL- oder MariaDB-Instance kommunizieren kann. Verwenden Sie den Befehl `host`, um die IP-Adresse Ihrer Amazon-RDS-DB-Instance herauszufinden.
```
host db_instance_endpoint
```
Der Hostname ist der DNS-Name aus dem Endpunkt der Amazon-RDS-DB-Instance.
1. Stellen Sie mit einem Client Ihrer Wahl eine Verbindung zur Quell-Instance her und erstellen Sie den für die Replikation zu verwendenden Benutzer. Verwenden Sie dieses Konto ausschließlich für die Replikation und beschränken Sie es auf Ihre Domäne, um die Sicherheit zu erhöhen. 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 für die externe Instance die Sonderrechte `REPLICATION CLIENT` und `REPLICATION SLAVE` für Ihren Replikationsbenutzer. Erteilen Sie beispielsweise die Sonderrechte `REPLICATION CLIENT` und `REPLICATION SLAVE` in allen Datenbank für den '`repl_user`'-Benutzer für Ihre Domäne, mit dem folgenden Befehl.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. Machen Sie die Amazon-RDS-DB-Instance zum Replica. Stellen Sie dazu zunächst als Master-Benutzer eine Verbindung zur Amazon-RDS-DB-Instance her. Identifizieren Sie dann die externe MySQL- oder MariaDB-Datenbank mithilfe des Befehls [mysql.rds\$1set\$1external\$1source (RDS-für-MySQL-Hauptversionen 8.4 und höher)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) oder [mysql.rds\$1set\$1external\$1master (RDS-für-MariaDB- und RDS-für-MySQL-Hauptversionen 8.0 und niedriger)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master) als Quell-Instance. Verwenden Sie den Namen und die Position der Protokolldatei, die Sie in Schritt 2 festgelegt haben. Die folgenden Befehle sind Beispiele.
**MySQL 8.4**
```
CALL mysql.rds_set_external_source ('mysourceserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**MariaDB und MySQL 8.0 und 5.7**
```
CALL mysql.rds_set_external_master ('mymasterserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**Anmerkung**
Unter RDS für MySQL können Sie stattdessen die verzögerte Replikation wählen, indem Sie die gespeicherte Prozedur [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) oder [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) ausführen. Unter RDS für MySQL besteht ein Grund für die Verwendung einer verzögerten Replikation darin, die Notfallwiederherstellung mit der gespeicherten Prozedur [](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until) zu aktivieren. Derzeit unterstützt RDS für MariaDB verzögerte Replikation, aber nicht die `mysql.rds_start_replication_until`-Prozedur.
1. Verwenden Sie für die Amazon-RDS-DB-Instance den Befehl [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication), um die Replikation zu starten.
```
CALL mysql.rds_start_replication;
```