Aktualisieren der MySQL DB-Engine - Amazon Relational Database Service

Aktualisieren der MySQL DB-Engine

Sofern Amazon RDS eine neue Version der Datenbank-Engine unterstützt, können Sie Ihre DB-Instances auf die neue Version aktualisieren. Es gibt zwei Arten von Upgrades für MySQL-DB-Instances: Upgrades von Hauptversionen und Upgrades von Nebenversionen.

Hauptversions-Upgrades können Datenbankänderungen enthalten, die nicht mit vorhandenen Anwendungen rückwärts kompatibel sind. Daher müssen Sie Hauptversions-Upgrades Ihrer DB-Instances manuell durchführen. Sie können ein Hauptversions-Upgrade starten, indem Sie Ihre DB-Instance ändern. Bevor Sie ein Hauptversions-Upgrade durchführen, wird jedoch das Befolgen der Schritte unter Upgrades von Hauptversionen für MySQL empfohlen.

Nebenversions-Upgrades enthalten dagegen nur Änderungen, die mit vorhandenen Anwendungen abwärtskompatibel sind. Sie können ein Nebenversions-Upgrade manuell starten, indem Sie Ihre DB-Instance ändern. Alternativ können Sie auch beim Erstellen oder Ändern einer DB-Instance die Option Auto minor version upgrade (Automatisches Nebenversions-Upgrade) aktivieren. Hierdurch wird Ihre DB-Instance automatisch aktualisiert, nachdem die neue Version von Amazon RDS getestet und genehmigt wurde. Weitere Informationen zum Ausführen eines Upgrades finden Sie unter Upgrade der Engine-Version für eine DB-Instance .

Wenn Ihre MySQL-DB-Instance Lesereplikate verwendet, müssen Sie alle Lesereplikate aktualisieren, bevor Sie die Quell-Instance aktualisieren. Wenn sich Ihre DB-Instance in einer Multi-AZ-Bereitstellung befindet, werden sowohl die Primär- als auch die Standby-Replikate aktualisiert. Ihre DB-Instance ist möglicherweise erst verfügbar, wenn das Upgrade abgeschlossen ist.

Übersicht über das Aktualisieren

Wenn Sie die AWS Management Console verwenden, um eine DB-Instance zu aktualisieren, werden die gültigen Upgrade-Ziele für die DB-Instance angezeigt. Sie können auch den folgenden AWS CLI-Befehl verwenden, um die gültigen Upgrade-Ziele für eine DB-Instance zu identifizieren:

Für Linux, macOS oder Unix:

aws rds describe-db-engine-versions \ --engine mysql \ --engine-version version-number \ --query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text

Für Windows:

aws rds describe-db-engine-versions ^ --engine mysql ^ --engine-version version-number ^ --query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text

Führen Sie beispielsweise den folgenden AWS CLI-Befehl aus, um die gültigen Upgrade-Ziele für eine MySQL Version 5.6.43 DB-Instance zu identifizieren:

Für Linux, macOS oder Unix:

aws rds describe-db-engine-versions \ --engine mysql \ --engine-version 5.6.43 \ --query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text

Für Windows:

aws rds describe-db-engine-versions ^ --engine mysql ^ --engine-version 5.6.43 ^ --query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text

Amazon RDS macht zwei DB-Snapshots während des Upgrades. Der erste DB-Snapshot gehört zur DB-Instance, bevor Änderungen am Upgrade vorgenommen wurden. Wenn das Upgrade bei Ihren Datenbanken nicht funktioniert, können Sie diesen Snapshot wiederherstellen, um eine DB-Instance zu erstellen, auf der die alte Version ausgeführt wird. Der zweite DB-Snapshot wird erstellt, wenn das Upgrade abgeschlossen ist.

Anmerkung

Amazon RDS nimmt nur DB-Snapshots auf, wenn Sie den Sicherungsaufbewahrungszeitraum für Ihre DB-Instance auf eine Zahl größer als 0 festgelegt haben. Informationen über das Ändern Ihres Aufbewahrungszeitraums für Backups finden Sie unter Ändern einer Amazon RDS-DB-Instance.

Nachdem das Upgrade abgeschlossen ist, können Sie nicht zur vorherigen Version der Datenbank-Engine zurückkehren. Wenn Sie zur vorherigen Version zurückkehren möchten, stellen Sie den ersten DB-Snapshot wieder her, um eine neue DB-Instance zu erstellen.

Sie steuern, wann Ihre DB-Instance auf eine neue Version aktualisiert werden soll, die von Amazon RDS unterstützt wird. Diese Kontrollebene hilft Ihnen, die Kompatibilität mit bestimmten Datenbankversionen aufrechtzuerhalten und neue Versionen mit Ihrer Anwendung zu testen, bevor sie produktiv bereitgestellt werden. Wenn Sie bereit sind, können Sie Versions-Upgrades zu den Zeiten durchführen, die am besten zu Ihrem Zeitplan passen.

Wenn Ihre DB-Instance die Lesereplikation verwendet, müssen Sie alle Read Replicas aktualisieren, bevor Sie die Quell-Instance aktualisieren.

Wenn sich die DB-Instance in einer Multi-AZ-Bereitstellung befindet, erfolgt das Upgrade sowohl für die primären als auch Standby-DB-Instances. Die primären und die Standby-DB-Instances werden gleichzeitig aktualisiert, und es kommt zu einem Ausfall, bis das Upgrade abgeschlossen ist. Die Dauer des Nutzungsausfalls ist von Ihrer Datenbank-Engine-Version und der Größe Ihrer DB-Instance abhängig.

Upgrades von Hauptversionen für MySQL

Amazon RDS unterstützt die folgenden direkten Upgrades für Hauptversionen des MySQL-Datenbank-Engine:

  • MySQL 5.5 auf MySQL 5.6

  • MySQL 5.6 auf MySQL 5.7

  • MySQL 5.7 auf MySQL 8.0

Anmerkung

Sie können DB-Instances mit MySQL-Version 5.7 und 8.0 nur mit DB-Instances der neuesten und der aktuellen Generation erstellen (zusätzlich zur DB-Instance-Klasse db.m3 der vorherigen Generation).

Es ist möglich, dass Sie eine MySQL 5.6-DB-Instance, die auf einer DB-Instance-Klasse einer früheren Generation ausgeführt wird (nicht db.m3), auf eine MySQL 5.7-DB-Instance upgraden müssen. In einem solchen Fall ändern Sie zunächst die DB-Instance so, dass diese eine DB-Instance-Klasse der neuesten oder aktuellen Generation verwendet. Anschließend können Sie die DB-Instance so modifizieren, dass sie die Datenbank-Engine von MySQL Version 5.7 nutzt. Weiterführende Informationen zu Amazon RDS-DB-Instance-Klassen finden Sie unter DB-Instance-Klassen.

Übersicht über Upgrades von MySQL-Hauptversionen

Hauptversion-Upgrades können Datenbankänderungen enthalten, die nicht mit vorhandenen Anwendungen rückwärts kompatibel sind. Folglich werden Hauptversion-Upgrades in Amazon RDS nicht automatisch ausgeführt, sondern Sie müssen Ihre DB-Instance manuell ändern. Sie sollten jedes Upgrade gründlich testen, bevor Sie es auf Ihre Produktions-Instances anwenden.

Um das Upgrade einer Hauptversion für eine DB-Instance der MySQL-Version 5.5 auf Amazon RDS zu MySQL-Version 5.6 oder höher auszuführen, sollten Sie zunächst alle verfügbaren Betriebssystem-Updates vornehmen. Nach Abschluss der Betriebssystemaktualisierungen müssen Sie auf die nächsthöhere Hauptversion aktualisieren: 5.5 auf 5.6, dann 5.6 auf 5.7 und anschließend 5.7 auf 8.0. Vor dem 24. April 2014 erstellte MySQL-DB-Instances zeigen verfügbare Updates für das Betriebssystem an, bis es angewendet wurde. Weitere Informationen zu Betriebssystem-Updates finden Sie unter Anwenden von Updates für eine DB-Instance.

Während des Upgrades einer Hauptversion von MySQL führt Amazon RDS die MySQL-Binärdatei mysql_upgrade aus, um die Tabellen zu aktualisieren, falls erforderlich. Außerdem leert Amazon RDS während des Upgrades einer Hauptversion die Tabellen slow_log und general_log. Speichern Sie die Protokollinhalte vor dem Upgrade einer Hauptversion, um die Protokollinformationen zu erhalten.

MySQL-Hauptversions-Upgrades sind normalerweise in etwa 10 Minuten abgeschlossen. Einige Aktualisierungen können aufgrund der Klassengröße der DB-Instance länger dauern, oder weil die Instance bestimmten Richtlinien in Bewährte Methoden für Amazon RDSnicht entspricht. Wenn Sie eine DB-Instance von der Amazon RDS-Konsole aktualisieren, zeigt der Status der DB-Instance an, wann das Upgrade abgeschlossen ist. Wenn Sie mit AWS Command Line Interface (AWS CLI) aktualisieren, verwenden Sie den Befehl describe-db-instances und überprüfen Sie den Status-Wert.

Upgrades auf MySQL-Version 5.7 sind möglicherweise langsam

MySQL-Version 5.6.4 hat ein neues Datums- und Uhrzeitformat für die datetime-, time-, und timestamp-Spalten eingeführt, die Dezimalstellen in Datums- und Zeitwerten zulassen. Beim Aktualisieren einer DB-Instance auf MySQL Version 5.7 erzwingt MySQL die Konvertierung aller Datums- und Uhrzeitspalten in das neue Format.

Da bei dieser Konvertierung Ihre Tabellen neu erstellt werden, kann die Aktualisierung der DB-Instance beträchtlich dauern. Die erzwungene Konvertierung erfolgt für alle DB-Instances, die eine frühere Version als MySQL 5.6.4 ausführen. Sie erfolgt auch für alle DB-Instances, für die ein Upgrade von einer MySQL-Version niedriger als 5.6.4 auf eine andere Version als 5.7 durchgeführt wurde.

Wenn Ihre DB-Instance eine Version niedriger als MySQL Version 5.6.4 ausführt oder von einer Version vor 5.6.4 upgegradet wurde, sollten Sie einen zusätzlichen Schritt durchführen. Sie sollten in einem solchen Fall die Spalten datetime, time und timestamp Ihrer Datenbank konvertieren, ehe Sie ein Upgrade der DB-Instance auf MySQL Version 5.7 durchführen. Diese Konvertierung kann den Zeitaufwand für das Upgrade der DB-Instance auf MySQL-Version 5.7 erheblich reduzieren. Zur Aktualisierung Ihrer Datums- und Uhrzeitspalten auf das neue Format erteilen Sie den Befehl ALTER TABLE <table_name> FORCE; für jede Tabelle, die Datums- oder Uhrzeitspalten enthält. Da das Ändern einer Tabelle die Tabelle als schreibgeschützt sperrt, wird empfohlen, diese Aktualisierung während eines Wartungsfensters auszuführen.

Verwenden Sie die folgende Abfrage, um alle Tabellen in Ihrer Datenbank zu finden, die über die Spalten datetime, time oder timestamp verfügen und um einen ALTER TABLE <table_name> FORCE;-Befehl für die einzelnen Tabellen zu erstellen.

SELECT DISTINCT CONCAT('ALTER TABLE `', REPLACE(is_tables.TABLE_SCHEMA, '`', '``'), '`.`', REPLACE(is_tables.TABLE_NAME, '`', '``'), '` FORCE;') FROM information_schema.TABLES is_tables INNER JOIN information_schema.COLUMNS col ON col.TABLE_SCHEMA = is_tables.TABLE_SCHEMA AND col.TABLE_NAME = is_tables.TABLE_NAME LEFT OUTER JOIN information_schema.INNODB_SYS_TABLES systables ON SUBSTRING_INDEX(systables.NAME, '#', 1) = CONCAT(is_tables.TABLE_SCHEMA,'/',is_tables.TABLE_NAME) LEFT OUTER JOIN information_schema.INNODB_SYS_COLUMNS syscolumns ON syscolumns.TABLE_ID = systables.TABLE_ID AND syscolumns.NAME = col.COLUMN_NAME WHERE col.COLUMN_TYPE IN ('time','timestamp','datetime') AND is_tables.TABLE_TYPE = 'BASE TABLE' AND is_tables.TABLE_SCHEMA NOT IN ('mysql','information_schema','performance_schema') AND (is_tables.ENGINE = 'InnoDB' AND syscolumns.MTYPE = 6);

Vorabprüfung bei Upgrades von MySQL 5.7 auf 8.0

MySQL 8.0 ist in vielen Punkten nicht mit MySQL 5.7 kompatibel. Diese Inkompatibilitäten können bei einem Upgrade von MySQL 5.7 auf MySQL 8.0 Probleme verursachen. Damit das Upgrade erfolgreich durchgeführt werden kann, sind einige Vorbereitungsmaßnahmen auf Ihrer Datenbank durchzuführen. Im Folgenden finden Sie eine allgemeine Liste dieser Inkompatibilitäten:

  • Es darf keine Tabellen geben, die veraltete Datentypen oder Funktionen verwenden.

  • Es darf keine verwaisten FRM-Dateien geben.

  • Es darf keine Auslöser mit fehlenden oder leeren Definern oder ungültigen Erstellungskontexten geben.

  • Es darf keine partitionierte Tabelle mit einer Speicher-Engine geben, für die es keine native Partitionierungsunterstützung gibt.

  • Es darf keine Verletzungen von Schlüsselwörtern oder reservierten Wörtern geben. Einige Schlüsselwörter sind in MySQL 8.0 möglicherweise reserviert, die zuvor nicht reserviert waren.

    Weitere Informationen finden Sie unter Schlüsselwörter und reservierte Wörter in der MySQL-Dokumentation.

  • Es darf keine Tabellen in der MySQL 5.7 mysql-Systemdatenbank geben, die denselben Namen wie eine Tabelle haben, die vom MySQL 8.0-Daten-Dictionary verwendet wird.

  • Es dürfen keine veralteten SQL-Modi in Ihrer sql_mode-Systemvariableneinstellung definiert sein.

  • Es darf keine Tabellen oder gespeicherte Prozeduren mit einzelnen ENUM- oder SET-Spaltenelementen geben, deren Länge 255 Zeichen oder 1020 Bytes überschreitet.

  • Vor dem Upgrade auf MySQL 8.0.13 oder höher darf es keine Tabellenpartitionen innerhalb von freigegebenen InnoDB-Tabellenräumen geben.

  • Es darf keine Abfragen oder gespeicherten Programmdefinitionen aus MySQL 8.0.12 oder früher geben, die ASC oder DESC-Qualifizierer für GROUP BY-Klauseln verwenden.

  • Ihre MySQL 5.7-Installation darf keine Funktionen verwenden, die in MySQL 8.0 nicht unterstützt werden.

    Weitere Informationen finden Sie unter In MySQL 8.0 entfernte Funktionen in der MySQL-Dokumentation.

  • Es darf keine Namen für Fremdschlüsseleinschränkungen mit mehr als 64 Zeichen geben.

  • Um die Unicode-Unterstützung zu verbessern, sollten Sie die Konvertierung von Objekten, die den utf8mb3-Zeichensatz verwenden, in Objekte in Betracht ziehen, die den utf8mb4-Zeichensatz verwenden. Der utf8mb3-Zeichensatz ist veraltet. Sie sollten darüber hinaus anstelle von utf8 die Verwendung von utf8mb4 für Zeichensatzverweise in Betracht ziehen, da utf8 zurzeit ein Alias für den utf8mb3-Zeichensatz ist.

    Weitere Informationen finden Sie unter Der utf8mb3-Zeichensatz (UTF-8-Unicode-Kodierung mit 3 Bytes) in der MySQL-Dokumentation.

Wenn Sie ein Upgrade von MySQL 5.7 auf 8.0 starten, führt Amazon RDS Vorabprüfungen durch, um eventuelle Inkompatibilitäten zu entdecken. Informationen zum Ausführen von Upgrades auf MySQL 8.0 finden Sie unter Ausführen von MySQL Upgrades in der MySQL-Dokumentation.

Diese Vorabprüfungen müssen durchgeführt werden. Sie können nicht ausgelassen werden. Die Vorabprüfungen bieten folgende Vorteile:

  • Sie können ungeplante Ausfallzeiten während des Upgrades vermeiden.

  • Wenn es Inkompatibilitäten gibt, verhindert Amazon RDS das Upgrade und stellt Ihnen ein Protokoll mit Informationen zu den Inkompatibilitäten bereit. Sie können das Protokoll für die Vorbereitung Ihrer Datenbank auf das Upgrade auf MySQL 8.0 verwenden, indem Sie die Inkompatibilitäten beseitigen. Ausführliche Informationen zum Entfernen von Inkompatibilitäten finden Sie unter Vorbereiten der Installation für ein Upgrade in der MySQL-Dokumentation und Upgrade auf MySQL 8.0? Hier ist, was Sie wissen müssen... im MySQL Server-Blog.

Die Vorabprüfungen enthalten einige Prüfungen, die in MySQL enthalten sind, und einige spezifische Prüfungen, die vom Amazon RDS-Team erstellt wurden. Informationen zu den von MySQL bereitgestellten Vorabprüfungen finden Sie unter Upgrade Checker-Dienstprogramm.

Die Vorabprüfungen werden ausgeführt, bevor die DB-Instance aufgrund des Upgrades angehalten wird. Sie verursachen also keine Ausfallzeiten. Wird während der Vorabprüfungen eine Inkompatibilität entdeckt, bricht Amazon RDS automatisch das Upgrade ab, ehe die DB-Instance angehalten wird. Zudem generiert Amazon RDS ein Inkompatibilitätsereignis. Weitere Informationen über Amazon RDS-Ereignisse finden Sie unter Verwenden von Amazon RDS-Ereignisbenachrichtigungen.

Amazon RDS zeichnet detaillierte Informationen zu allen Inkompatibilitäten in der Protokolldatei PrePatchCompatibility.log auf. In den meisten Fällen enthalten die Protokolleinträge einen Link zur MySQL-Dokumentation mit Informationen zur Lösung des Inkompatibilitätsproblems. Weitere Informationen zum Anzeigen von Protokolldateien finden Sie unter Anzeigen und Auflisten von Datenbank-Protokolldateien.

Aufgrund der Art der Vorabprüfungen werden die Objekte in Ihrer Datenbank geprüft. Diese Analyse verbraucht Ressourcen und verlängert die Zeit, die für die Durchführung des Upgrades benötigt wird.

Anmerkung

Amazon RDS führt Vorabprüfungen nur bei einem Upgrade von MySQL 5.7 auf MySQL 8.0 durch. Sie werden nicht bei Upgrades auf Versionen niedriger als MySQL 8.0 durchgeführt. So werden beispielsweise bei einem Upgrade von MySQL 5.6 auf MySQL 5.7 keine Vorabprüfungen durchgeführt.

Testen eines Upgrades

Ehe Sie ein Upgrade einer Hauptversion auf Ihrer DB-Instance durchführen, sollten Sie sorgfältig prüfen, ob Ihre Datenbank mit der neuen Version kompatibel ist. Darüber hinaus sollten Sie die Kompatibilität aller Anwendungen mit der neuen Version testen, die auf die Datenbank zugreifen. Wir empfehlen Ihnen folgendes Vorgehen.

Um ein Hauptversions-Upgrade zu testen

  1. Informieren Sie sich in der Upgrade-Dokumentation von Oracle über die neue Version der Datenbank-Engine, um zu prüfen, ob es Kompatibilitätsprobleme geben könnte, die sich auf Ihre Datenbank oder Anwendungen auswirken könnten:

  2. Wenn Ihre DB-Instance Mitglied einer benutzerdefinierten DB-Parametergruppe ist, müssen Sie eine neue DB-Parametergruppe mit Ihren vorhandenen Einstellungen erstellen, die mit der neuen Hauptversion kompatibel ist. Geben Sie die neue DB-Parametergruppe an, wenn Sie Ihre Test-Instance aktualisieren, damit Ihr Upgrade-Test sicherstellt, dass sie ordnungsgemäß funktioniert. Weitere Informationen über das Erstellen einer Parametergruppe finden Sie unter Arbeiten mit DB-Parametergruppen.

  3. Erstellen Sie einen DB-Snapshot der zu aktualisierenden DB-Instance. Weitere Informationen finden Sie unter Erstellen eines DB-Snapshots.

  4. Stellen Sie den DB-Snapshot wieder her, um eine neue Test-DB-Instance zu erstellen. Weitere Informationen finden Sie unter Wiederherstellen aus einem DB--Snapshot.

  5. Ändern Sie diese neue Test-DB-Instance, um sie auf die neue Version upzugraden. Verwenden Sie dazu eine der folgenden Methoden. Wenn Sie in Schritt 2 eine neue Parametergruppe erstellt haben, geben Sie diese Parametergruppe an.

  6. Beurteilen Sie den Speicherplatz, den die upgegradete Instance verwendet, um zu bestimmen, ob das Upgrade zusätzlichen Speicherplatz benötigt.

  7. Führen Sie so viele Qualitätssicherungstests mit der upgegradeten DB-Instance durch, wie nötig, um sicherzustellen, dass Ihre Datenbank und Anwendung mit der neuen Version korrekt ausgeführt werden. Führen Sie alle nötigen neuen Tests aus, um die Auswirkungen von Kompatibilitätsproblemen zu bewerten, die Sie in Schritt 1 bestimmt haben. Testen Sie alle gespeicherten Prozeduren und Funktionen. Leiten Sie Testversionen Ihrer Anwendungen an die aktualisierte DB-Instance weiter.

  8. Wenn alle Tests erfolgreich sind, führen Sie das Upgrade für Ihre Produktions-DB-Instance durch. Wir empfehlen, dass Sie keine Schreiboperationen auf der DB-Instance zulassen, bis Sie bestätigen können, dass alles richtig ausgeführt wird.

Upgraden einer MySQL-DB-Instance

Informationen über das manuelle oder automatische Upgraden einer MySQL-DB-Instance finden Sie unter Upgrade der Engine-Version für eine DB-Instance .

Automatische Unterversion-Upgrades für MySQL

Wenn Sie beim Erstellen oder Ändern einer DB-Instance die Option Auto minor version upgrade (Automatische Minor-Versionsupgrades) aktivieren, können Sie Ihre DB-Instance automatisch aktualisieren lassen.

Bei einigen RDS for MySQL-Hauptversionen in einigen AWS-Regionen wird eine Unterversion von RDS als automatische Upgrade-Version bezeichnet. Nachdem eine Minor-Version von Amazon RDS getestet und freigegeben wurde, erfolgt das Upgrade der Minor-Version automatisch während Ihres Wartungsfensters. RDS legt nicht automatisch neuere freigegebene Minor-Versionen als die automatische Upgradeversion fest. Bevor RDS eine neuere automatische Upgradeversion bestimmt, werden mehrere Kriterien berücksichtigt, wie beispielsweise die folgenden:

  • Bekannte Sicherheitsprobleme

  • Fehler in der MySQL-Community-Version

  • Gesamtflottenstabilität seit Erscheinen der Minor-Version

Sie können den folgenden AWS CLI-Befehl und das folgende Skript verwenden, um die aktuelle automatische Upgrade-Ziel-Unterversion für eine bestimmte MySQL-Unterversion in einer bestimmten AWS-Region zu bestimmen.

aws rds describe-db-engine-versions --output=table --engine mysql --engine-version minor-version --region region

Der folgende AWS CLI Befehl bestimmt beispielsweise das automatische Unterversions-Upgrade-Ziel für MySQL-Unterversion 5.7.19 in der USA Ost (Ohio)-AWS-Region (us-east-2).

aws rds describe-db-engine-versions --output=table --engine mysql --engine-version 5.7.19 --region us-east-2

Ihre Ausgabe sieht Folgendem ähnlich.

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | DescribeDBEngineVersions | +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ || DBEngineVersions || |+-------------------------+-----------------------------+-------------------------+---------+----------------+------------+--------------------------------------+-----------------------+| || DBEngineDescription | DBEngineVersionDescription | DBParameterGroupFamily | Engine | EngineVersion | Status | SupportsLogExportsToCloudwatchLogs | SupportsReadReplica || |+-------------------------+-----------------------------+-------------------------+---------+----------------+------------+--------------------------------------+-----------------------+| || MySQL Community Edition| mysql 5.7.19 | mysql5.7 | mysql | 5.7.19 | available | True | True || |+-------------------------+-----------------------------+-------------------------+---------+----------------+------------+--------------------------------------+-----------------------+| ||| ExportableLogTypes ||| ||+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+|| ||| audit ||| ||| error ||| ||| general ||| ||| slowquery ||| ||+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+|| ||| ValidUpgradeTarget ||| ||+-------------------------------+----------------------------------+---------------------+-------------------------------------+-------------------------------------------------------+|| ||| AutoUpgrade | Description | Engine | EngineVersion | IsMajorVersionUpgrade ||| ||+-------------------------------+----------------------------------+---------------------+-------------------------------------+-------------------------------------------------------+|| ||| False | MySQL 5.7.21 | mysql | 5.7.21 | False ||| ||| False | MySQL 5.7.22 | mysql | 5.7.22 | False ||| ||| False | | mysql | 5.7.23 | False ||| ||| False | MySQL 5.7.24 | mysql | 5.7.24 | False ||| ||| False | MySQL 5.7.25 | mysql | 5.7.25 | False ||| ||| True | MySQL 5.7.26 | mysql | 5.7.26 | False ||| ||| False | MySQL 5.7.28 | mysql | 5.7.28 | False ||| ||| False | MySQL 5.7.30 | mysql | 5.7.30 | False ||| ||| False | MySQL 8.0.11 | mysql | 8.0.11 | True ||| ||| False | MySQL 8.0.13 | mysql | 8.0.13 | True ||| ||| False | MySQL 8.0.15 | mysql | 8.0.15 | True ||| ||| False | MySQL 8.0.16 | mysql | 8.0.16 | True ||| ||| False | MySQL 8.0.17 | mysql | 8.0.17 | True ||| ||| False | MySQL 8.0.19 | mysql | 8.0.19 | True ||| ||| False | MySQL 8.0.20 | mysql | 8.0.20 | True ||| ||+-------------------------------+----------------------------------+---------------------+-------------------------------------+-------------------------------------------------------+||

In diesem Beispiel ist der AutoUpgrade-Wert True für MySQL-Version 5.7.26. Das automatische Nebenversions-Upgrade-Ziel ist daher die MySQL-Version 5.7.26, die in der Ausgabe hervorgehoben wird.

Eine MySQL DB-Instance wird während Ihres Wartungsfensters automatisch aktualisiert, wenn die folgenden Kriterien erfüllt sind:

  • Für die DB-Instance ist die Option Auto Minor Version Upgrade (Automatisches Unterversions-Upgrade) aktiviert.

  • Die DB-Instance führt eine Minor-Version der DB-Engine aus, die niedriger ist als die aktuelle Minor-Version des automatischen Upgrades.

Weitere Informationen finden Sie unter Automatisches Upgraden der Engine-Unterversion.

Upgraden einer MySQL-Datenbank mit reduzierter Ausfallzeit

Wenn Ihre MySQL-DB-Instance aktuell von einer Produktionsanwendung verwendet wird, können Sie mit dem folgenden Verfahren die Datenbankversion Ihrer DB-Instance aktualisieren. Dieses Verfahren kann die Ausfallzeiten Ihrer Anwendung reduzieren.

Im Folgenden wird ein Beispiel für ein Upgrade der MySQL Version 5.5 auf MySQL Version 5.6 gezeigt. Sie können die gleichen allgemeinen Schritte für Upgrades auf andere Hauptversionen durchführen.

Upgrade einer MySQL-Datenbank, während eine DB-Instance verwendet wird

  1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon RDS-Konsole unter https://console.aws.amazon.com/rds/.

  2. Erstellen Sie ein Lesereplikat Ihrer MySQL 5.5-DB-Instance. Dieser Prozess erstellt eine aktualisierbare Kopie Ihrer Datenbank.

    1. Wählen Sie in der Konsole Databases (Datenbanken) und dann die DB-Instance aus, die Sie upgraden möchten.

    2. Wählen Sie unter Aktionen Create read replica (Read Replica erstellen) aus.

    3. Geben Sie für das Lesereplikat einen Wert im Feld DB instance identifier (DB-Instance-Kennung) ein und stellen Sie sicher, dass der Eintrag unter DB instance class (DB-Instance-Klasse) und die anderen Einstellungen mit Ihrer MySQL 5.5-DB-Instance übereinstimmen.

    4. Wählen Sie Read Replica erstellen aus.

  3. Wenn das Lesereplikat erstellt wurde und Status Available (Verfügbar) anzeigt, aktualisieren Sie das Lesereplikat auf MySQL 5.6:

    1. Wählen Sie in der Konsole Databases (Datenbanken) und dann das Lesereplikat aus, das Sie gerade erstellt haben.

    2. Wählen Sie Modify aus.

    3. Wählen Sie im Feld DB engine version die gewünschte Version von MySQL 5.6 für das Upgrade aus und klicken Sie auf Weiter.

    4. Wählen Sie für Einplanung von Änderungen die Option Sofort anwenden aus.

    5. Wählen Sie Modify DB instance (DB-Instance ändern) aus, um das Upgrade zu starten.

  4. Wenn das Upgrade abgeschlossen ist und Status Available (Verfügbar) anzeigt, überprüfen Sie, ob das aktualisierte Lesereplikat mit der MySQL-5.5-DB-Quellinstance auf dem neuesten Stand ist. Sie können dies durch Herstellung einer Verbindung zum Lesereplikat und Erteilen des Befehls SHOW SLAVE STATUS tun. Wenn das Seconds_Behind_Master-Feld 0 ist, ist die Replikation auf dem neuesten Stand.

  5. Machen Sie Ihr MySQL 5.6-Lesereplikat zu einer eigenständigen DB-Instance.

    Wichtig

    Wenn Sie Ihr MySQL 5.6-Lesereplikat auf eine eigenständige Single-AZ-DB-Instance hochstufen, handelt es sich nicht mehr um ein Replikationsreplikat für die MySQL 5.5-DB-Instance. Wir empfehlen, dass Sie Ihr MySQL 5.6-Lesereplikat während eines Wartungsfensters hochstufen, wenn sich Ihre Quell-MySQL-5.5-DB-Instance im schreibgeschützten Modus befindet und alle Schreiboperationen ausgesetzt sind. Wenn die Aktion abgeschlossen ist, können Sie Ihre Schreiboperationen an die aktualisierte MySQL 5.6 DB-Instance weiterleiten, um sicherzustellen, dass keine Schreiboperationen verloren gehen.

    Zusätzlich empfehlen wir, dass Sie, bevor Sie das MySQL 5.6-Lesereplikat hochstufen, alle erforderlichen Data Definition Language (DDL)-Operationen auf dem MySQL 5.6-Lesereplikat ausführen. Ein Beispiel hierfür ist das Erstellen von Indizes. Dieser Ansatz vermeidet negative Auswirkungen auf die Leistung des MySQL 5.6-Lesereplikats, nachdem es hochgestuft wurde. Gehen Sie folgendermaßen vor, um ein Lesereplikat hochzustufen.

    1. Wählen Sie auf der Konsole Databases (Datenbanken) und dann das Lesereplikat aus, das Sie gerade aktualisiert haben.

    2. Wählen Sie für Actions (Aktionen) Promote (Hochstufen) aus.

    3. Klicken Sie auf Yes (Ja), um automatische Sicherungen für die Lesereplikat-Instance zu aktivieren. Weitere Informationen finden Sie unter Arbeiten mit Sicherungen.

    4. Klicken Sie auf Continue.

    5. Klicken Sie auf Read Replica hochstufen.

  6. Sie haben jetzt eine upgegradete Version Ihrer MySQL-Datenbank. An dieser Stelle können Sie Ihre Anwendungen auf die neue MySQL 5.6-DB-Instance leiten, Lesereplikate hinzufügen, Multi-AZ-Unterstützung einrichten und so weiter.