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.
# MariaDB-Datenbank-Protokolldateien
Sie können das MariaDB-Fehlerprotokoll, das Slow-Query-Protokoll, das Fehlerprotokoll zur IAM-Datenbankauthentifizierung und das allgemeine Protokoll überwachen. Das MariaDB-Fehlerprotokoll wird standardmäßig generiert; Sie können die langsame Abfrage und allgemeine Protokolle generieren, indem Sie Parameter in Ihrer DB-Parametergruppe festlegen. Amazon RDS rotiert alle MariaDB-Protokolldateien; die Intervalle für jeden Typ sind im Folgenden angegeben.
Sie können die MariaDB-Protokolle direkt über die Amazon-RDS-Konsole, Amazon-RDS-API, Amazon-RDS-CLI oder AWS-SDKs überwachen. Sie können auf MariaDB-Protokolle auch direkt zugreifen, indem Sie die Protokolle in eine Datenbank-Tabelle in der Hauptdatenbank weiterleiten und diese Tabelle abfragen. Mit dem Dienstprogramm "mysqlbinlog" können Sie ein binäres Protokoll herunterladen.
Weitere Informationen zum Anzeigen und Herunterladen von dateibasierten Datenbankprotokollen finden Sie unter [Überwachen von Amazon RDS-Protokolldateien](USER_LogAccess.md).
**Topics**
+ [Zugriff auf MariaDB-Fehlerprotokolle](USER_LogAccess.MariaDB.Errorlog.md)
+ [Zugriff auf die MariaDB-Slow-Query- und allgemeinen Protokolle](USER_LogAccess.MariaDB.Generallog.md)
+ [MariaDB-Protokolle in Amazon Logs veröffentlichen CloudWatch](USER_LogAccess.MariaDB.PublishtoCloudWatchLogs.md)
+ [Protokollrotation und -aufbewahrung für MariaDB](USER_LogAccess.MariaDB.LogFileSize.md)
+ [Verwalten von tabellenbasierten MariaDB-Protokollen](Appendix.MariaDB.CommonDBATasks.Logs.md)
+ [Konfigurieren der Binärprotokollierung für MariaDB](USER_LogAccess.MariaDB.BinaryFormat.md)
+ [Zugriff auf binäre MariaDB-Protokolle](USER_LogAccess.MariaDB.Binarylog.md)
+ [Aktivieren der MariaDB-Binärprotokoll-Kommentierung](USER_LogAccess.MariaDB.BinarylogAnnotation.md)
# Zugriff auf MariaDB-Fehlerprotokolle
Das MariaDB-Fehlerprotokoll wird in die `.err`-Datei geschrieben. Sie können diese Datei mithilfe der Amazon-RDS-Konsole oder durch Abrufen des Protokolls mithilfe der Amazon-RDS-API, der Amazon-RDS-CLI oder von AWS-SDKs ansehen. Die Datei `.err` wird alle 5 Minuten bereinigt und ihre Inhalte werden an `mysql-error-running.log` angefügt. Die `mysql-error-running.log`-Datei wird dann jede Stunde rotiert und die stündlich erstellten Dateien der letzten 24 Stunden werden aufbewahrt. An den Namen jeder Protokolldatei wird die Stunde ihrer Erstellung (in UTC) angefügt. Die Protokolldateien verfügen auch über einen Zeitstempel, anhand dessen Sie feststellen können, wann die Protokolleinträge geschrieben wurden.
MariaDB schreibt das Fehlerprotokoll nur beim Startup, Herunterfahren und beim Auftreten von Fehlern. Eine DB-Instance kann Stunden oder Tage lang laufen, ohne dass neue Einträge in das Fehlerprotokoll geschrieben werden. Wenn Sie keine neuen Einträge sehen, sind im Server keine Fehler aufgetreten, die zu einem Eintrag in das Protokoll geführt hätten.
# Zugriff auf die MariaDB-Slow-Query- und allgemeinen Protokolle
Das Slow-Query-Protokoll von MariaDB und das allgemeine Protokoll können in eine Datei oder in eine Datenbanktabelle mithilfe der Parametereinstellungen in Ihrer DB-Parametergruppe geschrieben werden. Weitere Informationen zum Erstellen und Ändern einer DB-Parametergruppe finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md). Sie müssen diese Parameter festlegen, bevor Sie das Slow-Query-Protokoll oder das allgemeine Protokoll in der Amazon-RDS-Konsole bzw. mithilfe von Amazon-RDS-API, AWS CLI oder AWS-SDKs sehen können.
Sie können MariaDB-Protokolle mithilfe der Parameter in dieser Liste kontrollieren:
+ `slow_query_log` oder `log_slow_query`: Um das Slow-Query-Protokoll zu erstellen, auf 1 setzen. Der Standardwert ist 0.
+ `general_log` Um das allgemeine Protokoll zu erstellen, auf 1 setzen. Der Standardwert ist 0.
+ `long_query_time` oder `log_slow_query_time`: Um zu vermeiden, dass schnell ausgeführte Abfragen im Slow-Query-Protokoll aufgenommen werden, legen Sie die kürzeste Laufzeit für eine einzutragende Abfrage in Sekunden fest. Der Standardwert liegt bei 10 Sekunden, der Mindestwert bei 0. Wenn log\$1output = FILE, können Sie einen Gleitkommawert angeben, der die Mikrosekundenauflösung festlegt. Wenn log\$1output = TABLE, können Sie einen Ganzzahlwert angeben, der die Sekundenauflösung festlegt. Nur Abfragen, deren Laufzeit den Wert `long_query_time` oder `log_slow_query_time` übersteigt, werden im Protokoll aufgenommen. Wenn Sie beispielsweise `long_query_time` oder `log_slow_query_time` auf 0,1 setzen, verhindert dies Einträge von allen Abfragen, die weniger als 100 Millisekunden lang ausgeführt werden.
+ `log_queries_not_using_indexes`: Um alle Abfragen zu protokollieren, die keinen Index für das Slow-Query-Protokoll verwenden, setzen Sie diesen Parameter auf 1. Der Standardwert ist 0. Abfragen, die keinen Index verwenden, werden protokolliert, auch wenn ihre Laufzeit niedriger als der Wert des `long_query_time`-Parameters ist.
+ `log_output option`: Sie können eine der folgenden Optionen für den `log_output`-Parameter festlegen:
+ **TABLE** (Standard): schreibt allgemeine Abfragen in die `mysql.general_log`-Tabelle und Slow-Queries in die `mysql.slow_log`-Tabelle.
+ **FILE**: schreibt sowohl allgemeine als auch Slow-Query-Protokolle in das Dateisystem. Protokolldateien werden stündlich rotiert.
+ **NONE**: Die Protokollierung ist deaktiviert.
Wenn Protokollierung aktiviert ist, rotiert Amazon RDS Tabellenprotokolle oder löscht Protokolldateien in regelmäßigen Intervallen. Dies ist eine Vorsichtsmaßnahme, um möglichst zu vermeiden, dass eine umfangreiche Protokolldatei die Datenbanknutzung blockiert oder die Leistung beeinträchtigt. `FILE`- und `TABLE`-Protokollierung führen das Rotieren und Löschen wie folgt aus:
+ Wenn die `FILE`-Protokollierung aktiviert ist, werden Protokolldateien stündlich geprüft und Protokolldateien, die älter als 24 Stunden sind, werden gelöscht. In einigen Fällen kann die Größe der verbleibenden kombinierten Protokolldatei nach dem Löschen die Schwelle von 2 % des zugeteilten Speicherplatzes für eine DB-Instance überschreiten. In diesen Fällen werden die umfangreichsten Protokolldateien gelöscht, bis die Größe den Schwellenwert nicht mehr überschreitet.
+ Wenn die `TABLE`-Protokollierung aktiviert ist, werden in einigen Fällen Protokolltabellen alle 24 Stunden überschrieben. Diese Rotation erfolgt, wenn der von den Tabellenprotokollen verwendete Speicherplatz mehr als 20 Prozent des zugeteilten Speicherplatzes ausmacht. Sie tritt auch auf, wenn die Größe aller kombinierten Protokolle mehr als 10 GB beträgt. Wenn der für eine DB-Instance verwendete Speicherplatz 90 Prozent des Speicherplatzes überschreitet, der der DB-Instance zugeteilt ist, werden die Grenzwerte für die Protokollrotation reduziert. Protokolltabellen werden dann rotiert, wenn der von den Tabellenprotokollen verwendete Speicherplatz mehr als 10 Prozent des zugeteilten Speicherplatzes ausmacht. Sie werden auch rotiert, wenn die Größe aller kombinierten Protokolle mehr als 5 GB beträgt.
Beim Rotieren von Protokolldateien wird die aktuelle Protokolltabelle in eine Sicherungsprotokolltabelle kopiert, und die Einträge in der aktuellen Protokolltabelle werden entfernt. Sofern bereits eine Sicherungsprotokolltabelle vorhanden ist, wird diese gelöscht, bevor die aktuelle Protokolltabelle ins Backup kopiert wird. Sie können die Sicherungsprotokolltabelle abfragen, wenn dies nötig ist. Die Backup-Protokolltabelle für die `mysql.general_log`-Tabelle ist als `mysql.general_log_backup` benannt. Die Backup-Protokolltabelle für die `mysql.slow_log`-Tabelle ist als `mysql.slow_log_backup` benannt.
Sie können die `mysql.general_log`-Tabelle rotieren, wenn Sie die Prozedur `mysql.rds_rotate_general_log` aufrufen. Sie können die `mysql.slow_log`-Tabelle rotieren, wenn Sie die Prozedur `mysql.rds_rotate_slow_log` aufrufen.
Tabellenprotokolle werden während des Upgrades einer Datenbankversion rotiert.
Amazon RDS zeichnet `TABLE`- und `FILE`-Protokollrotation in einem Amazon-RDS-Ereignis auf und sendet Ihnen eine Benachrichtigung.
Um mit den Protokollen über die Amazon-RDS-Konsole, Amazon-RDS-API, Amazon-RDS-CLI, oder AWS SDKs zu arbeiten, setzen Sie den Parameter `log_output` auf FILE. Wie das MariaDB-Fehlerprotokoll werden auch diese Protokolldateien stündlich rotiert. Die Protokolldateien, die während der vorherigen 24 Stunden angelegt wurden, werden aufbewahrt.
Weitere Informationen zu den Slow-Query- und allgemeinen Protokollen finden Sie in den folgenden Themen in der MariaDB-Dokumentation:
+ [Slow-Query-Protokoll](http://mariadb.com/kb/en/mariadb/slow-query-log/)
+ [Allgemeines Abfrageprotokoll](http://mariadb.com/kb/en/mariadb/general-query-log/)
# MariaDB-Protokolle in Amazon Logs veröffentlichen CloudWatch
Sie können Ihre MariaDB-DB-Instance so konfigurieren, dass Protokolldaten in einer Protokollgruppe in Amazon CloudWatch Logs veröffentlicht werden. Mit CloudWatch Logs können Sie eine Echtzeitanalyse der Protokolldaten durchführen und diese CloudWatch zum Erstellen von Alarmen und zum Anzeigen von Metriken verwenden. Sie können CloudWatch Logs verwenden, um Ihre Protokolldatensätze in einem äußerst langlebigen Speicher zu speichern.
Amazon RDS veröffentlicht jedes MariaDB-Datenbankprotokoll als separaten Datenbank-Stream in der Protokollgruppe. Angenommen, Sie konfigurieren die Exportfunktion so, dass sie das Slow-Query-Protokoll enthält. Dann werden Slow-Query-Daten in einem Slow-Query-Protokollstream in der `/aws/rds/instance/my_instance/slowquery`-Protokollgruppe gespeichert.
Das Fehlerprotokoll ist standardmäßig aktiviert. Die folgende Tabelle fasst die Anforderungen für die anderen MariaDB-Protokolle zusammen.
| Protokoll | Anforderung |
| --- | --- |
| Prüfungsprotokoll | Die DB-Instance muss eine benutzerdefinierte Optionsgruppe mit der Option `MARIADB_AUDIT_PLUGIN` verwenden. |
| Allgemeines Protokoll | Die DB-Instance muss eine benutzerdefinierte Parametergruppe mit der Parametereinstellung `general_log = 1` verwenden, um das allgemeine Protokoll zu aktivieren. |
| Slow-Query-Protokoll | Die DB-Instance muss eine benutzerdefinierte Parametergruppe mit der Parametereinstellung `slow_query_log = 1` oder `log_slow_query = 1` verwenden, um das Slow-Query-Protokoll zu aktivieren. |
| Fehlerprotokoll zur IAM-Datenbankauthentifizierung | Sie müssen den Protokolltyp `iam-db-auth-error` für eine DB-Instance aktivieren, indem Sie eine DB-Instance erstellen oder ändern. |
| Protokollausgabe | Die DB-Instance muss eine benutzerdefinierte Parametergruppe mit der Parametereinstellung verwenden`log_output = FILE`, um Protokolle in das Dateisystem zu schreiben und sie in CloudWatch Logs zu veröffentlichen. |
## Konsole
**Um MariaDB-Protokolle von der Konsole aus in CloudWatch Logs zu veröffentlichen**
1. Öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Databases (Datenbanken)** und dann die DB-Instance, die Sie ändern möchten.
1. Wählen Sie **Modify** aus.
1. Wählen Sie im Abschnitt **Protokollexporte** die Protokolle aus, die Sie in Logs veröffentlichen möchten CloudWatch .
1. Wählen Sie **Weiter** und dann auf der zusammenfassenden Seite **Modify DB Instance** (DB-Instance ändern) aus.
## AWS CLI
Sie können ein MariaDB-Protokoll mit dem veröffentlichen. AWS CLI Sie können den Befehl [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) mit den folgenden Parametern aufrufen:
+ `--db-instance-identifier`
+ `--cloudwatch-logs-export-configuration`
**Anmerkung**
Eine Änderung der Option `--cloudwatch-logs-export-configuration` wird immer sofort auf die DB-Instance angewendet. Aus diesem Grund sind die Optionen `--apply-immediately` und `--no-apply-immediately` wirkungslos.
Sie können MariaDB-Protokolle auch veröffentlichen, indem Sie die folgenden AWS CLI Befehle aufrufen:
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-s3.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-s3.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html)
Führen Sie einen dieser AWS CLI Befehle mit den folgenden Optionen aus:
+ `--db-instance-identifier`
+ `--enable-cloudwatch-logs-exports`
+ `--db-instance-class`
+ `--engine`
Je nachdem, welchen AWS CLI Befehl Sie ausführen, sind möglicherweise andere Optionen erforderlich.
**Example**
Das folgende Beispiel ändert eine bestehende MariaDB-DB-Instance, um Protokolldateien in Logs zu veröffentlichen. CloudWatch Der `--cloudwatch-logs-export-configuration`-Wert ist ein JSON-Objekt. Der Schlüssel für dieses Objekt ist `EnableLogTypes` und dessen Wert ist ein Array von Zeichenfolgen mit einer beliebigen Kombination aus `audit`, `error`, `general` und `slowquery`.
Für Linux, macOS oder Unix:
```
1. aws rds modify-db-instance \
2. --db-instance-identifier mydbinstance \
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["audit","error","general","slowquery"]}'
```
Für Windows:
```
1. aws rds modify-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --cloudwatch-logs-export-configuration '{"EnableLogTypes":["audit","error","general","slowquery"]}'
```
**Example**
Der folgende Befehl erstellt eine MariaDB-DB-Instance und veröffentlicht Protokolldateien in Logs. CloudWatch Der Wert `--enable-cloudwatch-logs-exports` ist ein JSON-Array mit Zeichenfolgen. Die Zeichenfolgen können eine beliebige Kombination von `audit`, `error`, `general` und `slowquery` sein.
Für Linux, macOS oder Unix:
```
1. aws rds create-db-instance \
2. --db-instance-identifier mydbinstance \
3. --enable-cloudwatch-logs-exports '["audit","error","general","slowquery"]' \
4. --db-instance-class db.m4.large \
5. --engine mariadb
```
Für Windows:
```
1. aws rds create-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --enable-cloudwatch-logs-exports '["audit","error","general","slowquery"]' ^
4. --db-instance-class db.m4.large ^
5. --engine mariadb
```
## RDS-API
Sie können MariaDB-Protokolle mithilfe der RDS-API veröffentlichen. Sie können die [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html)-Operation mit folgenden Parametern aufrufen:
+ `DBInstanceIdentifier`
+ `CloudwatchLogsExportConfiguration`
**Anmerkung**
Eine Änderung des Parameters `CloudwatchLogsExportConfiguration` wird immer sofort auf die DB-Instance angewendet. Aus diesem Grund ist der Parameter `ApplyImmediately` wirkungslos.
Sie können MariaDB-Protokolle auch veröffentlichen, indem Sie die folgenden RDS-API-Operationen aufrufen:
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromS3.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromS3.html)
+ [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html)
Führen Sie eine dieser RDS-API-Operationen mit den folgenden Parametern aus:
+ `DBInstanceIdentifier`
+ `EnableCloudwatchLogsExports`
+ `Engine`
+ `DBInstanceClass`
Je nachdem, welchen AWS CLI Befehl Sie ausführen, sind möglicherweise andere Parameter erforderlich.
# Protokollrotation und -aufbewahrung für MariaDB
Wenn Protokollierung aktiviert ist, rotiert Amazon RDS Tabellenprotokolle oder löscht Protokolldateien in regelmäßigen Intervallen. Dies ist eine Vorsichtsmaßnahme, um möglichst zu vermeiden, dass eine umfangreiche Protokolldatei die Datenbanknutzung blockiert oder die Leistung beeinträchtigt.
Die MariaDB-Slow-Query-Protokolldatei, die Fehlerprotokolldatei und die allgemeine Protokolldatei sind auf eine Größe beschränkt, die 2 Prozent des zugeteilten Speicherplatzes für eine DB-Instance nicht überschreiten darf. Um diesen Schwellwert einzuhalten, werden Protokolle automatisch stündlich rotiert und Protokolldateien, die älter als 24 Stunden sind, werden entfernt. Wenn die kombinierte Größe der Protokolle nach dem Löschen von alten Protokolldateien den Schwellwert überschreitet, werden die umfangreichsten Protokolldateien gelöscht, bis die Größe den Schwellwert nicht mehr überschreitet.
Amazon RDS rotiert Fehlerprotokolldateien für die IAM-Datenbankauthentifizierung, die größer als 10 MB sind. Amazon RDS entfernt Fehlerprotokolldateien für die IAM-Datenbankauthentifizierung, die älter als fünf Tage oder größer als 100 MB sind.
# Verwalten von tabellenbasierten MariaDB-Protokollen
Sie können die allgemeinen und Slow-Query-Protokolle an Tabellen auf der DB-Instance weiterleiten. Erstellen Sie dazu eine DB-Parametergruppe und legen Sie den `log_output`-Serverparameter auf `TABLE` fest. Allgemeine Abfragen werden anschließend in der `mysql.general_log`-Tabelle und Slow-Queries in der`mysql.slow_log`-Tabelle protokolliert. Sie können die Tabellen abfragen, um auf Protokollinformationen zuzugreifen. Durch Aktivieren dieser Protokollierung wird die Datenmenge erhöht, die in die Datenbank geschrieben wird, was die Performance beeinträchtigen kann.
Das allgemeine Protokoll und das Slow-Query-Protokoll sind standardmäßig deaktiviert. Zum Aktivieren der Protokollierung in Tabellen müssen Sie auch die folgenden Serverparameter auf `1` setzen.
+ `general_log`
+ `slow_query_log` oder `log_slow_query`
Protokolltabellen wachsen stetig, bis die entsprechenden Protokollierungsaktivitäten ausgeschaltet werden, indem der entsprechende Parameter auf gesetzt wir `0`. Mit der Zeit sammelt sich häufig eine große Datenmenge an und belegt einen beträchtlichen Anteil Ihres zugeteilten Speicherplatzes. Amazon RDS erlaubt Ihnen nicht, die Protokolltabellen zu kürzen, aber Sie können ihre Inhalte verschieben. Beim Rotieren einer Tabelle wird deren Inhalt in einer Sicherungstabelle gespeichert, und anschließend wird eine neue leere Protokolldatei angelegt. Sie können Protokolltabellen mithilfe der folgenden Befehlszeilenprozeduren manuell rotieren, wobei die Eingabeaufforderung mit bezeichnet is `PROMPT>`:
```
PROMPT> CALL mysql.rds_rotate_slow_log;
PROMPT> CALL mysql.rds_rotate_general_log;
```
Um alte Daten komplett zu entfernen und den Speicherplatz zurückzugewinnen, rufen Sie die entsprechende Prozedur zweimal nacheinander auf.
# Konfigurieren der Binärprotokollierung für MariaDB
Das *Binärprotokoll* ist eine Reihe von Protokolldateien, die Informationen zu Datenänderungen enthalten, die an einer MariaDB-Server-Instance vorgenommen wurden. Das Binärprotokoll enthält Informationen wie die folgenden:
+ Ereignisse, die Datenbankänderungen wie Tabellenerstellungen oder Zeilenänderungen beschreiben
+ Informationen über die Dauer jeder Anweisung, durch die Daten aktualisiert wurden
+ Ereignisse für Anweisungen, durch die Daten aktualisieren werden hätten können, aber nicht wurden
Das binäre Protokoll zeichnet Anweisungen auf, die während der Replikation gesendet werden. Es ist auch für einige Wiederherstellungsvorgänge erforderlich. Weitere Informationen finden Sie unter [Binärprotokoll](https://mariadb.com/kb/en/binary-log/) in der MariaDB-Dokumentation.
Das Feature für automatisierte Backups bestimmt, ob die Binärprotokollierung für MariaDB ein- oder ausgeschaltet wird. Ihnen stehen folgende Optionen zur Verfügung:
Aktivieren der Binärprotokollierung
Legen Sie den Aufbewahrungszeitraum für Backups auf einen positiven Wert größer 0 fest.
Deaktivieren der Binärprotokollierung
Legen Sie den Aufbewahrungszeitraum für Backups auf 0 fest.
Weitere Informationen finden Sie unter [Aktivieren von automatisierten Backups](USER_WorkingWithAutomatedBackups.Enabling.md).
MariaDB in Amazon RDS unterstützt die binären Protokollformate *row-based*, *statement-based* und *mixed*. Das standardmäßige binäre Protokollierungsformat ist *mixed*. Weitere Details zu anderen binären Protokollierungsformaten in MariaDB finden Sie unter [Binary Log Formats](http://mariadb.com/kb/en/mariadb/binary-log-formats/) in der MariaDB-Dokumentation.
Wenn Sie die Replikation verwenden möchten, ist das Binärprotokollformat wichtig. Dies liegt daran, dass es den Datensatz der Datenänderungen bestimmt, der in der Quelle aufgezeichnet und an die Replikationsziele gesendet wird. Weitere Informationen über Vor- und Nachteile verschiedener binärer Protokollierungsformate finden Sie unter [Vorteile und Nachteile einer auf Anweisungen und einer auf Zeilen basierenden Replikation](https://dev.mysql.com/doc/refman/5.7/en/replication-sbr-rbr.html) in der MySQL-Dokumentation.
**Wichtig**
Wenn das binäre Protokollierungsformat auf "row-based" eingestellt ist, kann das zu sehr umfangreichen binären Protokolldateien führen. Große binäre Protokolldateien verringern den Speicherplatz, der einer DB-Instance zur Verfügung steht. Sie können auch die Zeitspanne erhöhen, um einen Wiederherstellungsvorgang einer DB-Instance auszuführen.
Die Replikation vom Typ „statement-based“ kann zu Inkonsistenzen zwischen der Quell-DB-Instance und einem Lesereplikat führen. Weitere Informationen finden Sie unter [ Unsafe Statements for Statement-based Replication](https://mariadb.com/kb/en/library/unsafe-statements-for-statement-based-replication/) in der MariaDB-Dokumentation.
Durch die Aktivierung der binären Protokollierung wird die Anzahl der I/O Festplattenschreibvorgänge in der DB-Instance erhöht. Sie können die IOPS-Nutzung mit der `WriteIOPS` CloudWatch Metrik überwachen.
**Stellen Sie das binäre Protokollierungsformat für MariaDB wie folgt ein:**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon RDS-Konsole unter [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Wählen Sie im Navigationsbereich **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie in der Liste die zu ändernde Parametergruppe, die von der DB-Instance verwendet wird.
Eine Standard-Parametergruppe kann nicht modifiziert werden. Erstellen Sie eine neue Parametergruppe und ordnen Sie diese der DB-Instance zu, wenn die DB-Instance eine Standardparametergruppe verwendet.
Weitere Informationen zu DB-Parametergruppen finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md).
1. Wählen Sie für **Parameter group actions (Parametergruppenaktionen)** die Option **Bearbeiten**.
1. Stellen Sie den Parameter `binlog_format` auf das binäre Protokollierungsformat Ihrer Wahl ein (**ROW**, **STATEMENT** oder **MIXED**).
Sie können die Binärprotokollierung deaktivieren, indem Sie den Aufbewahrungszeitraum für Backups einer DB-Instance auf Null festlegen. Dadurch werden jedoch tägliche automatische Backups deaktiviert. Durch das Deaktivieren automatisierter Backups wird die Sitzungsvariable `log_bin` ausgeschaltet oder deaktiviert. Dadurch wird die Binärprotokollierung auf der DB-Instance von RDS für MariaDB deaktiviert, wodurch wiederum die Sitzungsvariable `binlog_format` auf den Standardwert `ROW` in der Datenbank zurückgesetzt wird. Wir empfehlen, Backups nicht zu deaktivieren. Weitere Informationen zur Einstellung **Aufbewahrungszeitraums für Backups** finden Sie unter [Einstellungen für DB-Instances](USER_ModifyInstance.Settings.md).
1. Wählen Sie **Änderungen speichern**, um die Aktualisierungen in dieser DB-Parametergruppe zu speichern.
Da der Parameter `binlog_format` in RDS für MariaDB dynamisch ist, müssen Sie die DB-Instance nicht neu starten, damit die Änderungen übernommen werden.
**Wichtig**
Das Ändern einer DB-Parametergruppe wirkt sich auf alle DB-Instances aus, die diese Parametergruppe verwenden. Wenn Sie unterschiedliche binäre Logging-Formate für verschiedene MariaDB-DB-Instances in einer AWS Region angeben möchten, müssen die DB-Instances unterschiedliche DB-Parametergruppen verwenden. Diese Parametergruppen identifizieren unterschiedliche Protokollierungsformate. Weisen Sie den einzelnen DB-Instances die entsprechende DB-Parametergruppe zu.
# Zugriff auf binäre MariaDB-Protokolle
Mithilfe des Dienstprogramms mysqlbinlog können Sie Binärprotokolle in Textformat aus DB-Instances in MariaDB herunterladen. Das binäre Protokoll wird auf Ihren lokalen Computer heruntergeladen. Weitere Informationen über die Verwendung des Dienstprogramms mysqlbinlog finden Sie unter [Using mysqlbinlog](http://mariadb.com/kb/en/mariadb/using-mysqlbinlog/) in der MariaDB-Dokumentation.
Verwenden Sie zum Ausführen des Dienstprogramms mysqlbinlog mit einer Amazon-RDS-Instance die folgenden Optionen:
+ Legen Sie die Option `--read-from-remote-server` fest.
+ `--host` Geben Sie den DNS-Namen vom Endpunkt dieser Instance an.
+ `--port`Geben Sie den von der Instance verwendeten Port an.
+ `--user`: Geben Sie einen MariaDB-Benutzer an, dem die Slave-Berechtigung für Replikation erteilt wurde.
+ `--password`: Geben Sie das Passwort für den Benutzer an oder lassen Sie einen Passwortwert aus, damit das Hilfsprogramm zur Eingabe eines Passworts auffordert.
+ `--result-file`: Geben Sie die lokale Datei an, die den Output empfängt.
+ Geben Sie die Namen einer oder mehrerer Binärprotokolldateien an. Verwenden Sie für eine Liste der verfügbaren Protokolle den SQL-Befehl SHOW BINARY LOGS.
Weitere Informationen über Optionen für mysqlbinlog finden Sie unter [mysqlbinlog Options](http://mariadb.com/kb/en/mariadb/mysqlbinlog-options/) in der MariaDB-Dokumentation.
Im Folgenden wird ein Beispiel gezeigt:
Für Linux, macOS oder Unix:
```
mysqlbinlog \
--read-from-remote-server \
--host=mariadbinstance1.1234abcd.region.rds.amazonaws.com \
--port=3306 \
--user ReplUser \
--password \
--result-file=/tmp/binlog.txt
```
Für Windows:
```
mysqlbinlog ^
--read-from-remote-server ^
--host=mariadbinstance1.1234abcd.region.rds.amazonaws.com ^
--port=3306 ^
--user ReplUser ^
--password ^
--result-file=/tmp/binlog.txt
```
In der Regel bereinigt Amazon RDS ein binäres Protokoll so bald wie möglich. Allerdings muss das binäre Protokoll immer noch auf der Instance verfügbar sein, sodass mysqlbinlog darauf zugreifen kann. Verwenden Sie die gespeicherte Prozedur `mysql.rds_set_configuration`, um anzugeben, wie viele Stunden RDS die binären Protokolldateien aufbewahren soll. Geben Sie einen Zeitraum an, in dem Sie genügend Zeit haben, um die Protokolle herunterzuladen. Nachdem Sie den Aufbewahrungszeitraum festgelegt haben, überwachen Sie die Speichernutzung für die DB-Instance, um sicherzustellen, dass die aufbewahrten binären Protokolle nicht zu viel Speicherplatz beanspruchen.
Das folgende Beispiel setzt den Aufbewahrungszeitraum auf 1 Tag.
```
call mysql.rds_set_configuration('binlog retention hours', 24);
```
Verwenden Sie die gespeicherte Prozedur `mysql.rds_show_configuration`, um die aktuelle Einstellung anzeigen zu lassen.
```
call mysql.rds_show_configuration;
```
# Aktivieren der MariaDB-Binärprotokoll-Kommentierung
In einer MariaDB-DB-Instance können Sie das Ereignis `Annotate_rows` verwenden, um ein Zeilenereignis mit einer Kopie der SQL-Abfrage zu kommentieren, die das Zeilenereignis ausgelöst hat. Diese Methode bietet eine ähnliche Funktionalität wie das Aktivieren des Parameters `binlog_rows_query_log_events` für eine RDS-for-MySQL-DB-Instance.
Sie können Binärprotokoll-Anmerkungen global aktivieren, indem Sie eine benutzerdefinierte Parametergruppe erstellen und den Parameter `binlog_annotate_row_events` auf **1** setzen. Sie können Anmerkungen auch auf Sitzungsebene aktivieren, indem Sie aufrufe `SET SESSION binlog_annotate_row_events = 1`. Verwenden Sie `replicate_annotate_row_events`, um Binärprotokoll-Anmerkungen auf der Replika-Instance zu replizieren, falls binäre Protokollierung darauf aktiviert ist. Für die Nutzung dieser Einstellungen sind keine besonderen Berechtigungen erforderlich.
Nachfolgend sehen Sie ein Beispiel für eine zeilenbasierte Transaktion in MariaDB. Die Verwendung von zeilenbasierter Protokollierung wird ausgelöst, indem der Transaktionsisolationslevel auf "read-committed" eingestellt wird.
```
CREATE DATABASE IF NOT EXISTS test;
USE test;
CREATE TABLE square(x INT PRIMARY KEY, y INT NOT NULL) ENGINE = InnoDB;
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
BEGIN
INSERT INTO square(x, y) VALUES(5, 5 * 5);
COMMIT;
```
Ohne Anmerkungen sehen die Einträge des Binärprotokolls für die Transaktion wie folgt aus:
```
BEGIN
/*!*/;
# at 1163
# at 1209
#150922 7:55:57 server id 1855786460 end_log_pos 1209 Table_map: `test`.`square` mapped to number 76
#150922 7:55:57 server id 1855786460 end_log_pos 1247 Write_rows: table id 76 flags: STMT_END_F
### INSERT INTO `test`.`square`
### SET
### @1=5
### @2=25
# at 1247
#150922 7:56:01 server id 1855786460 end_log_pos 1274 Xid = 62
COMMIT/*!*/;
```
Die folgende Anweisung aktiviert Anmerkungen auf Sitzungsebene für diese Transaktion und deaktiviert die Anmerkungen nach dem Übertragen der Transaktion:
```
CREATE DATABASE IF NOT EXISTS test;
USE test;
CREATE TABLE square(x INT PRIMARY KEY, y INT NOT NULL) ENGINE = InnoDB;
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
SET SESSION binlog_annotate_row_events = 1;
BEGIN;
INSERT INTO square(x, y) VALUES(5, 5 * 5);
COMMIT;
SET SESSION binlog_annotate_row_events = 0;
```
Mit Anmerkungen sehen die Einträge des Binärprotokolls für die Transaktion wie folgt aus:
```
BEGIN
/*!*/;
# at 423
# at 483
# at 529
#150922 8:04:24 server id 1855786460 end_log_pos 483 Annotate_rows:
#Q> INSERT INTO square(x, y) VALUES(5, 5 * 5)
#150922 8:04:24 server id 1855786460 end_log_pos 529 Table_map: `test`.`square` mapped to number 76
#150922 8:04:24 server id 1855786460 end_log_pos 567 Write_rows: table id 76 flags: STMT_END_F
### INSERT INTO `test`.`square`
### SET
### @1=5
### @2=25
# at 567
#150922 8:04:26 server id 1855786460 end_log_pos 594 Xid = 88
COMMIT/*!*/;
```