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.
# MySQL-Datenbank-Logdateien
Sie können die MySQL-Protokolle direkt über die Amazon RDS-Konsole, die Amazon RDS-API AWS CLI, oder überwachen AWS SDKs. Sie können auf MySQL-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**
+ [Überblick über RDS-for-MySQL-Datenbankprotokolle](USER_LogAccess.MySQL.LogFileSize.md)
+ [Veröffentlichen von MySQL-Protokollen in Amazon CloudWatch Logs](USER_LogAccess.MySQLDB.PublishtoCloudWatchLogs.md)
+ [Senden der an Tabellen](Appendix.MySQL.CommonDBATasks.Logs.md)
+ [Konfiguration von RDS für MySQL-Binärprotokollierung für Single-AZ-Datenbanken](USER_LogAccess.MySQL.BinaryFormat.md)
+ [Konfigurieren der MySQL-Binärprotokollierung für DB-Cluster mit Multi-AZ](USER_Binlog.MultiAZ.md)
+ [Zugriff auf MySQL-Binärprotokolle](USER_LogAccess.MySQL.Binarylog.md)
# Überblick über RDS-for-MySQL-Datenbankprotokolle
Sie können die folgenden Arten von RDS-for-MySQL-Protokolldateien überwachen:
+ Fehler-log
+ Slow-Query-Protokoll
+ Allgemeines Protokoll
+ Prüfungsprotokoll
+ Instance-Protokoll
+ Fehlerprotokoll zur IAM-Datenbankauthentifizierung
Das RDS-for-MySQL-Fehlerprotokoll wird standardmäßig generiert. Sie können die langsamen Abfrage- und allgemeinen Protokolle generieren, indem Sie Parameter in Ihrer DB-Parametergruppe festlegen.
**Topics**
+ [RDS-for-MySQL-Fehlerprotokolle](#USER_LogAccess.MySQL.Errorlog)
+ [RDS-für-MySQL-Protokolle für langsame Abfragen und allgemeine Protokolle](#USER_LogAccess.MySQL.Generallog)
+ [MySQL Audit-Protokoll](#USER_LogAccess.MySQL.Auditlog)
+ [Protokollrotation und -aufbewahrung für RDS für MySQL](#USER_LogAccess.MySQL.LogFileSize.retention)
+ [Größenbeschränkungen für Redo-Protokolle](#USER_LogAccess.MySQL.LogFileSize.RedoLogs)
## RDS-for-MySQL-Fehlerprotokolle
RDS für MySQL schreibt Fehler in die `mysql-error.log`-Datei. 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.
RDS f0r MySQL 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 führen würden.
Konstruktionsbedingt werden die Fehlerprotokolle gefiltert, sodass nur unerwartete Ereignisse wie Fehler angezeigt werden. Die Fehlerprotokolle enthalten jedoch auch einige zusätzliche Datenbankinformationen, z. B. den Abfragefortschritt, die nicht angezeigt werden. Daher kann die Größe der Fehlerprotokolle auch ohne tatsächliche Fehler aufgrund laufender Datenbankaktivitäten zunehmen. Und obwohl Sie in den Fehlerprotokollen möglicherweise eine bestimmte Größe in Byte oder Kilobyte sehen AWS-Managementkonsole, haben sie möglicherweise 0 Byte, wenn Sie sie herunterladen.
RDS für MySQL schreibt `mysql-error.log` alle 5 Minuten auf die Festplatte. Es fügt den Inhalt des Protokolls `mysql-error-running.log` an.
RDS für MySQL rotiert die Datei `mysql-error-running.log` stündlich. Es behält die in den letzten zwei Wochen erzeugten Protokolle bei.
**Anmerkung**
Der Aufbewahrungszeitraum für das Protokoll ist zwischen Amazon RDS und unterschiedlich Aurora.
## RDS-für-MySQL-Protokolle für langsame Abfragen und allgemeine Protokolle
Das Slow-Query-Protokoll von RDS für MySQL und das allgemeine Protokoll können in eine Datei oder in eine Datenbanktabelle geschrieben werden. Legen Sie dazu die Parameter in Ihrer DB-Parametergruppe fest. 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 Protokoll für langsame Abfragen oder das allgemeine Protokoll in der Amazon RDS-Konsole oder mithilfe der Amazon RDS-API, Amazon RDS-CLI oder anzeigen können AWS SDKs.
Sie können RDS-for-MySQL-Protokolle mithilfe der Parameter in dieser Liste kontrollieren:
+ `slow_query_log` 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`: Damit vermieden wird, dass schnell ausgeführte Abfragen im Slow-Query-Protokoll aufgenommen werden, legen Sie die kürzeste Laufzeit für eine zu protokollierende 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 `long_query_time`-Wert übersteigt, werden im Protokoll aufgenommen. Wenn Sie beispielsweise `long_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, die keinen Index für das Slow-Query-Protokoll verwenden im Protokoll aufzunehmen, auf 1 setzen. Abfragen, die keinen Index verwenden, werden protokolliert, auch wenn ihre Laufzeit niedriger als der Wert des Parameters `long_query_time` ist. Der Standardwert ist 0.
+ `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 langsame Abfragen in die `mysql.slow_log`-Tabelle.
+ **FILE**– schreibt Protokolle allgemeiner und langsamer Abfragen in das Dateisystem.
+ **NONE**– Die Protokollierung ist deaktiviert.
Damit langsame Abfragedaten in Amazon CloudWatch Logs angezeigt werden, müssen die folgenden Bedingungen erfüllt sein:
+ CloudWatch Protokolle müssen so konfiguriert sein, dass sie langsame Abfrageprotokolle enthalten.
+ `slow_query_log` muss aktiviert sein.
+ muss `log_output` auf `FILE` festgelegt sein.
+ Die Abfrage muss länger dauern als die für `long_query_time` konfigurierte Zeit.
Weitere Informationen zu den Slow-Query- und allgemeinen Protokollen finden Sie in den folgenden Themen in der MySQL-Dokumentation:
+ [Das Slow-Query-Protokoll](https://dev.mysql.com/doc/refman/8.0/en/slow-query-log.html)
+ [Das allgemeine Abfrageprotokoll](https://dev.mysql.com/doc/refman/8.0/en/query-log.html)
## MySQL Audit-Protokoll
Für den Zugriff auf das Audit-Protokoll muss die DB-Instance eine benutzerdefinierte Optionsgruppe mit der Option `MARIADB_AUDIT_PLUGIN` verwenden. Weitere Informationen finden Sie unter [MariaDB-Audit-Plugin-Support für MySQL](Appendix.MySQL.Options.AuditPlugin.md).
## Protokollrotation und -aufbewahrung für RDS für MySQL
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. RDS für MySQL behandelt Rotation und Löschen wie folgt:
+ Die MySQL-Slow-Query-Protokolldatei, Fehlerprotokolldatei und allgemeine Protokolldatei sind auf eine Größe beschränkt, die 2 % des zugewiesenen Speicherplatzes für eine DB-Instance nicht überschreiten darf. Um diesen Schwellenwert einzuhalten, werden die Protokolle automatisch stündlich gedreht. MySQL entfernt Protokolldateien, die älter als zwei Wochen sind. Wenn die kombinierte Größe der Protokolle nach dem Löschen von alten Protokolldateien den Schwellwert überschreitet, werden die ältesten Protokolldateien gelöscht, bis die Größe den Schwellwert nicht mehr überschreitet.
+ Wenn die `FILE`-Protokollierung aktiviert ist, werden Protokolldateien stündlich untersucht und Protokolldateien, die älter als zwei Wochen 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 ältesten 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 Schwellen 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. Sie können die Ereigniskategorie `low storage` abonnieren, um Benachrichtigungen zu erhalten, wenn Protokolltabellen rotiert werden, um Speicherplatz freizugeben. Weitere Informationen finden Sie unter [Arbeiten mit Amazon-RDS-Ereignisbenachrichtigungen](USER_Events.md).
Wenn Protokolltabellen rotiert werden, wird die aktuelle Protokolltabelle zuerst in eine Backup-Protokolltabelle kopiert. Dann werden die Einträge aus der aktuellen Protokolltabelle 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.
Um mit den Protokollen von der Amazon RDS-Konsole, der Amazon RDS-API, der Amazon RDS-CLI oder zu arbeiten AWS SDKs, setzen Sie den `log_output` Parameter auf FILE. So wie das MySQL-Fehlerprotokoll, werden diese Protokolldateien stündlich rotiert. Die Protokolldateien, die in den letzten zwei Wochen generiert wurden, werden aufbewahrt. Beachten Sie, dass der Aufbewahrungszeitraum bei Amazon RDS und Aurora jeweils unterschiedlich ist.
## Größenbeschränkungen für Redo-Protokolle
Bei RDS für MySQL Version 8.0.32 beträgt der Standardwert dieses Parameters 256 MB. Dieser Betrag wird abgeleitet, indem der Standardwert des Parameters `innodb_log_file_size` (128 MB) mit dem Standardwert des Parameters `innodb_log_files_in_group` (2) multipliziert wird. Weitere Informationen finden Sie unter [Best practices for configuring parameters for Amazon RDS für MySQL, part 1: Parameters related to performance](https://aws.amazon.com/blogs/database/best-practices-for-configuring-parameters-for-amazon-rds-for-mysql-part-1-parameters-related-to-performance/).
Bei Version 8.0.33 von RDS für MySQL und höher wird der `innodb_redo_log_capacity`-Parameter anstelle des `innodb_log_file_size`-Parameters verwendet. Der Amazon-RDS-Standardwert für den Parameter `innodb_redo_log_capacity` ist 2 GB. Weitere Informationen finden Sie unter [Änderungen in MySQL 8.0.30](https://dev.mysql.com/doc/relnotes/mysql/8.0/en/news-8-0-30.html) in der MySQL-Dokumentation.
Ab MySQL 8.4 aktiviert Amazon RDS den Parameter `innodb_dedicated_server` standardmäßig. Mit dem Parameter `innodb_dedicated_server` berechnet die Datenbank-Engine die Parameter `innodb_buffer_pool_size` und `innodb_redo_log_capacity`. Weitere Informationen finden Sie unter [Konfigurieren der Pufferpoolgröße und der Redo-Protokollkapazität in MySQL 8.4](Appendix.MySQL.CommonDBATasks.Config.Size.8.4.md).
# Veröffentlichen von MySQL-Protokollen in Amazon CloudWatch Logs
Sie können die MySQL-DB-Instance so konfigurieren, dass Protokolldaten in einer Protokollgruppe in Amazon CloudWatch Logs veröffentlicht werden. Mit CloudWatch Logs können Sie Echtzeitanalysen der Protokolldaten durchführen, und mit CloudWatch können Sie Alarme und Metriken erstellen. Sie können CloudWatch Logs verwenden, um Ihre Protokolldatensätze in einem Speicher mit hoher Beständigkeit abzulegen.
Amazon RDS veröffentlicht jedes MySQL-Datenbankprotokoll als separaten Datenbank-Stream in der Protokollgruppe. Wenn Sie beispielsweise die Exportfunktion so konfigurieren, dass das Slow-Query-Protokoll berücksichtigt wird, werden Slow-Query-Daten in einem Slow-Query-Protokollstream in der Protokollgruppe `/aws/rds/instance/my_instance/slowquery` gespeichert.
Das Fehlerprotokoll ist standardmäßig aktiviert. Die folgende Tabelle fasst die Anforderungen für die anderen MySQL-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` 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 `log_output = FILE` verwenden, um Protokolle in das Dateisystem zu schreiben und sie in CloudWatch Logs zu veröffentlichen. |
## Konsole
**So veröffentlichen Sie MySQL-Protokolle in CloudWatch Logs über die Konsole**
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 **Ändern** aus.
1. Wählen Sie im Bereich **Protokollexporte** die Protokolle aus, die Sie in CloudWatch Logs veröffentlichen möchten.
1. Wählen Sie **Weiter** und dann auf der zusammenfassenden Seite **Modify DB Instance** (DB-Instance ändern) aus.
## AWS CLI
Sie können MySQL-Protokolle über veröffentliche 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 MySQL-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 nach verwendetem AWS CLI-Befehl müssen möglicherweise noch weitere Optionen angegeben werden.
**Example**
Im folgenden Beispiel wird eine vorhandene MySQL-DB-Instance so konfiguriert, dass Protokolldateien in CloudWatch Logs veröffentlicht werden. 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**
Im folgenden Beispiel wird eine MySQL-DB-Instance erstellt und die Protokolldateien in CloudWatch Logs veröffentlicht. 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 MySQL
```
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 MySQL
```
## RDS-API
Sie können MySQL-Protokolle über die RDS-API veröffentlichen. Die Aktion [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) kann dazu mit den folgenden Parametern aufgerufen werden:
+ `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 MySQL-Protokolle auch veröffentlichen, indem Sie in der RDS-API die folgenden 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 nach ausgeführtem AWS CLI-Befehl müssen möglicherweise noch weitere Parameter angegeben werden.
# Senden der an Tabellen
Sie können die allgemeinen und Slow-Query-Protokolle an Tabellen in der DB-Instance weiterleiten, indem Sie eine DB-Parametergruppe erstellen und den `log_output`-Serverparameter auf `TABLE` setzen. 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. Um die Protokollierung in Tabellen zu aktivieren, müssen Sie auch die Serverparameter `general_log` und `slow_query_log` auf `1` setzen.
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.
# Konfiguration von RDS für MySQL-Binärprotokollierung für Single-AZ-Datenbanken
Das *Binärprotokoll* ist eine Reihe von Protokolldateien, die Informationen zu Datenänderungen enthalten, die an einer MySQL-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 [The Binary Log](https://dev.mysql.com/doc/refman/8.0/en/binary-log.html) in der MySQL-Dokumentation.
Die Funktion für automatisierte Backups bestimmt, ob die binäre Protokollierung für MySQL 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).
MySQL in Amazon RDS unterstützt die binären Protokollformate *row-based*, *statement-based* und *mixed*. Wir empfehlen gemischt, sofern Sie kein spezifisches Format des Binärprotokolls benötigen. Einzelheiten zu den verschiedenen MySQL-Binärprotokollformaten finden Sie in der MySQL-Dokumentation unter [Binary Logging Formats](https://dev.mysql.com/doc/refman/8.0/en/binary-log-formats.html).
Zur Verwendung der Replikation ist das binäre Protokollierungsformat wichtig, da 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/8.0/en/replication-sbr-rbr.html) in der MySQL-Dokumentation.
**Wichtig**
Mit MySQL 8.0.34 hat MySQL den Parameter `binlog_format` als veraltet eingestuft. In späteren MySQL-Versionen plant MySQL, den Parameter zu entfernen und nur die zeilenbasierte Replikation zu unterstützen. Daher empfehlen wir, für neue MySQL-Replikationseinrichtungen die zeilenbasierte Protokollierung zu verwenden. Weitere Informationen finden Sie unter [binlog\$1format](https://dev.mysql.com/doc/refman/8.0/en/replication-options-binary-log.html#sysvar_binlog_format) in der MySQL-Dokumentation.
Die MySQL-Versionen 8.0 und 8.4 akzeptieren den Parameter `binlog_format`. Bei Verwendung dieses Parameters gibt MySQL eine Warnmeldung zur Veralterung aus. In einer zukünftigen Hauptversion wird MySQL den Parameter `binlog_format` entfernen.
Die anweisungsbasierte Replikation kann zu Inkonsistenzen zwischen dem Quell-DB-Instance- und einem Lese-Replikat führen. Weitere Informationen finden Sie unter [ Determination of Safe and Unsafe Statements in Binary Logging](https://dev.mysql.com/doc/refman/8.0/en/replication-rbr-safe-unsafe.html) in der MySQL-Dokumentation.
Durch die Aktivierung der binären Protokollierung wird die Anzahl der I/O Festplattenschreibvorgänge im erhöht. Sie können die IOPS-Nutzung mit der `WriteIOPS` `` CloudWatch Metrik überwachen.
**Stellen Sie das MySQL-binäres-Protokollierungsformat wie folgt ein:**
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 **Parameter groups (Parametergruppen)** aus.
1. Wählen Sie die zu ändernde DB-Parametergruppe aus, die der DB-Instance zugeordnet ist.
Eine Standard-Parametergruppe kann nicht modifiziert werden. Erstellen Sie eine neue Parametergruppe und ordnen Sie diese dem DB-Instance- zu, wenn der DB-Instance- eine Standardparametergruppe verwendet.
Weitere Informationen zu Parametergruppen finden Sie unter [Parametergruppen für Amazon RDS](USER_WorkingWithParamGroups.md).
1. Wählen Sie unter **Aktionen** die Option **Bearbeiten** aus.
1. Legen Sie den Parameter `binlog_format` auf das binäre Protokollierungsformat Ihrer Wahl fest (`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 Sicherungen wird die Sitzungsvariable `log_bin` ausgeschaltet oder deaktiviert. Dadurch wird die Binärprotokollierung auf der DB-Instance von RDS für MySQL 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 **Save changes (Änderungen speichern)**, um die Aktualisierungen in dieser DB--Parametergruppe zu speichern.
Da der Parameter `binlog_format` in RDS für MySQL dynamisch ist, müssen Sie die DB-Instance nicht neu starten, damit die Änderungen übernommen werden. (Beachten Sie, dass dieser Parameter in Aurora MySQL statisch ist. Weitere Informationen finden Sie unter [Konfigurieren der Aurora-MySQL-Binärprotokollierung](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/USER_LogAccess.MySQL.BinaryFormat.html).)
**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 MySQL-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.
# Konfigurieren der MySQL-Binärprotokollierung für DB-Cluster mit Multi-AZ
Die binäre Protokollierung in Amazon RDS for MySQL Multi-AZ-DB-Clustern zeichnet alle Datenbankänderungen auf, um Replikation, point-in-time Wiederherstellung und Prüfung zu unterstützen. In DB-Clustern mit Multi-AZ synchronisieren Binärprotokolle Sekundärknoten mit dem Primärknoten, wodurch die Datenkonsistenz in allen Availability Zones gewährleistet und reibungslose Failover ermöglicht werden.
Um die Binärprotokollierung zu optimieren, unterstützt Amazon RDS die Komprimierung von Binärprotokolltransaktionen, wodurch der Speicherbedarf für Binärprotokolle reduziert und die Replikationseffizienz verbessert werden.
**Topics**
+ [Komprimieren von Binärprotokolltransaktionen für DB-Cluster mit Multi-AZ](#USER_Binlog.MultiAZ.compression)
+ [Komprimieren von Binärprotokolltransaktionen für DB-Cluster mit Multi-AZ](#USER_Binlog.MultiAZ.configuring)
## Komprimieren von Binärprotokolltransaktionen für DB-Cluster mit Multi-AZ
Bei der Komprimierung von Binärprotokolltransaktionen wird der zstd-Algorithmus verwendet, um die Größe der in Binärprotokollen gespeicherten Transaktionsdaten zu reduzieren. Wenn diese Option aktiviert ist, komprimiert die MySQL-Datenbank-Engine Transaktionsnutzlasten zu einem einzigen Ereignis, wodurch der Speicheraufwand minimiert wird I/O . Dieses Feature verbessert die Datenbankleistung, reduziert die Größe des Binärprotokolls und optimiert die Ressourcennutzung für die Verwaltung und Replikation von Protokollen in DB-Clustern mit Multi-AZ.
Amazon RDS bietet die Komprimierung von Binärprotokolltransaktionen für DB-Cluster mit Multi-AZ von RDS für MySQL über die folgenden Parameter:
+ `binlog_transaction_compression` – Wenn diese Option aktiviert ist (`1`), komprimiert die Datenbank-Engine Transaktionsnutzdaten und schreibt sie als einzelnes Ereignis in das Binärprotokoll. Dies reduziert den Speicherverbrauch und den Overhead. I/O Der Parameter ist standardmäßig deaktiviert.
+ `binlog_transaction_compression_level_zstd` – Konfiguriert die zstd-Komprimierungsstufe für Binärprotokolltransaktionen. Höhere Werte erhöhen das Kompressionsverhältnis, wodurch der Speicherbedarf weiter reduziert wird, aber die CPU- und Speichernutzung für die Komprimierung erhöht werden. Der Standardwert ist 3 mit einem Bereich von 1–22.
Mit diesen Parametern können Sie die Komprimierung von Binärprotokollen auf der Grundlage der Workload-Merkmale und der Ressourcenverfügbarkeit optimieren. Weitere Informationen finden Sie unter [Binary Log Transaction Compression](https://dev.mysql.com/doc/refman/8.4/en/binary-log-transaction-compression.html) in der MySQL-Dokumentation.
Die Komprimierung von Binärprotokolltransaktionen bietet die folgenden wesentlichen Vorteile:
+ Durch die Komprimierung wird die Größe von Binärprotokollen verringert, insbesondere bei Workloads mit großen Transaktionen oder hohen Schreibvolumen.
+ Kleinere Binärprotokolle reduzieren den Netzwerk- und I/O Overhead und verbessern so die Replikationsleistung.
+ Der Parameter `binlog_transaction_compression_level_zstd` ermöglicht die Steuerung des Kompromisses zwischen dem Komprimierungsverhältnis und dem Ressourcenverbrauch.
## Komprimieren von Binärprotokolltransaktionen für DB-Cluster mit Multi-AZ
Um die Komprimierung von Binärprotokolltransaktionen für einen DB-Cluster mit Multi-AZ von RDS für MySQL zu konfigurieren, ändern Sie die entsprechenden Cluster-Parametereinstellungen entsprechend Ihren Workload-Anforderungen.
### Konsole
**So aktivieren Sie die Komprimierung von Binärprotokolltransaktionen**
1. Ändern Sie die DB-Cluster-Parametergruppe, um den Parameter `binlog_transaction_compression` auf `1` festzulegen.
1. (Optional) Passen Sie den Wert des Parameters `binlog_transaction_compression_level_zstd` an Ihre Workload-Anforderungen und die Ressourcenverfügbarkeit an.
Weitere Informationen finden Sie unter [Ändern von Parametern in einer DB-Cluster-Parametergruppe ](USER_WorkingWithParamGroups.ModifyingCluster.md).
### AWS CLI
Um die Komprimierung von Binärprotokolltransaktionen mit dem zu konfigurieren AWS CLI, verwenden Sie den Befehl [modify-db-cluster-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster-parameter-group.html).
**Example**
Für Linux, macOS oder Unix:
```
aws rds modify-db-cluster-parameter-group \
--db-cluster-parameter-group-name your-cluster-parameter-group \
--parameters "ParameterName=binlog_transaction_compression,ParameterValue=1,ApplyMethod=pending-reboot"
```
Für Windows:
```
aws rds modify-db-cluster-parameter-group ^
--db-cluster-parameter-group-name your-cluster-parameter-group ^
--parameters "ParameterName=binlog_transaction_compression,ParameterValue=1,ApplyMethod=pending-reboot"
```
### RDS-API
Verwenden Sie den Vorgang [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBClusterParameterGroup.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBClusterParameterGroup.html), um die Komprimierung von Binärprotokolltransaktionen mithilfe der Amazon-RDS-API zu konfigurieren.
# Zugriff auf MySQL-Binärprotokolle
Sie können das Dienstprogramm mysqlbinlog verwenden, um Binärprotokolle aus RDS-for-MySQL-DB-Instances herunterzuladen oder zu streamen. Das Binärprotokoll wird auf den lokalen Computer heruntergeladen, von wo aus Sie Aktionen, wie die Wiedergabe eines Protokolls mithilfe des Hilfsprogramms mysql ausführen können. Weitere Informationen über die Verwendung des Dienstprogramms mysqlbinlog finden Sie unter [Verwenden von mysqlbinlog zum Sichern binärer Protokolldateien](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog-backup.html) in der MySQL-Dokumentation.
Verwenden Sie zum Ausführen des Dienstprogramms mysqlbinlog mit einer Amazon-RDS-Instance die folgenden Optionen:
+ `--read-from-remote-server` – Erforderlich.
+ `--host` – der DNS-Name vom Endpunkt der Instance.
+ `--port` – der von der Instance verwendete Port.
+ `--user` – ein MySQL-Benutzer, dem die Berechtigung `REPLICATION SLAVE` erteilt wurde.
+ `--password` – das Passwort für den MySQL-Benutzer oder lassen Sie einen Passwortwert aus, damit das Dienstprogramm zur Eingabe eines Passworts auffordert.
+ `--raw` – Laden Sie die Datei im Binärformat herunter.
+ `--result-file` – die lokale Datei, die den raw-Output empfangen soll.
+ `--stop-never` – Streamen Sie die binären Protokolldateien.
+ `--verbose` – Wenn Sie das Binlog-Format `ROW` verwenden, schließen Sie diese Option ein, um die Zeilenereignisse als Pseudo-SQL-Anweisungen anzuzeigen. Weitere Informationen zur Option `--verbose` finden Sie unter [mysqlbinlog row event display](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog-row-events.html) in der MySQL-Dokumentation.
+ Geben Sie die Namen einer oder mehrerer Binärprotokolldateien an. Verwenden Sie den SQL-Befehl `SHOW BINARY LOGS`, um eine Liste der verfügbaren Protokolle abzurufen.
Weitere Informationen über mysqlbinlog-Optionen finden Sie unter [mysqlbinlog – Hilfsprogramm für die Verarbeitung binärer Protokolldateien](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog.html) in der MySQL-Dokumentation.
Die folgenden Beispiele veranschaulichen die Verwendung des Dienstprogramms mysqlbinlog.
Für Linux, macOS oder Unix:
```
mysqlbinlog \
--read-from-remote-server \
--host=MySQLInstance1.cg034hpkmmjt.region.rds.amazonaws.com \
--port=3306 \
--user ReplUser \
--password \
--raw \
--verbose \
--result-file=/tmp/ \
binlog.00098
```
Für Windows:
```
mysqlbinlog ^
--read-from-remote-server ^
--host=MySQLInstance1.cg034hpkmmjt.region.rds.amazonaws.com ^
--port=3306 ^
--user ReplUser ^
--password ^
--raw ^
--verbose ^
--result-file=/tmp/ ^
binlog.00098
```
Binärprotokolle müssen auf der DB-Instance verfügbar bleiben, damit das Dienstprogramm mysqlbinlog auf sie zugreifen kann. Verwenden Sie die gespeicherte Prozedur [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) und geben Sie einen Zeitraum mit ausreichend Zeit für den Download der Protokolle an, um die Verfügbarkeit sicherzustellen. Wenn diese Konfiguration nicht festgelegt ist, löscht Amazon RDS die Binärprotokolle so schnell wie möglich, was zu Lücken in den Binärprotokollen führt, die das Dienstprogramm mysqlbinlog abruft.
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\$1show\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_show_configuration), um die aktuelle Einstellung anzeigen zu lassen.
```
call mysql.rds_show_configuration;
```