MySQL-Datenbanken über die Befehlszeile importieren und exportieren

Das Beherrschen von MySQL-Datenbankimport- und -exportoperationen über die Befehlszeile ist eine unverzichtbare Fähigkeit für jeden Datenbankadministrator oder Backend-Ingenieur. Das Dienstprogramm `mysqldump` exportiert eine Datenbank in eine portable `.sql`-Datei, die alle DDL- und DML-Anweisungen enthält, die zur vollständigen Rekonstruktion des Schemas und der Daten erforderlich sind, während der `mysql`-Client-Befehl das Gegenteil übernimmt — diese Datei zurück in eine laufende MySQL-Instanz zu streamen.

Dieser Leitfaden behandelt jedes praktische Szenario: Einzeldatenbankexporte, Mehrfachdatenbank-Dumps, strukturbasierte Sicherungen, komprimierte Übertragungen, Zeichensatzbehandlung und sichere Importworkflows — einschließlich Grenzfälle, die in Produktionsumgebungen zu stiller Datenbeschädigung oder fehlgeschlagenen Wiederherstellungen führen.

Voraussetzungen

Bevor Sie einen Befehl in diesem Leitfaden ausführen, überprüfen Sie Folgendes:

• MySQL Server (5.7, 8.0 oder 8.4) ist installiert und der `mysqld`-Prozess läuft
• Die Binärdateien `mysqldump` und `mysql` befinden sich in Ihrem System-`PATH` (bestätigen Sie dies mit `which mysqldump`)
• Sie besitzen ein MySQL-Konto mit mindestens den Berechtigungen `SELECT`, `LOCK TABLES`, `SHOW VIEW` und `TRIGGER` für den Export; `CREATE`, `INSERT`, `ALTER` und `DROP` für den Import
• Auf dem Ziel ist ausreichend Speicherplatz vorhanden — ein komprimierter Dump kann beim Import um das 5- bis 10-fache expandieren
• Sie haben Shell-Zugriff auf den Server (lokales Terminal, SSH oder eine verwaltete VPS Hosting-Umgebung)

Datenbanken mit mysqldump exportieren

`mysqldump` ist das kanonische logische Backup-Tool, das mit MySQL gebündelt ist. Es serialisiert Datenbankobjekte in ein menschenlesbares SQL-Skript. Im Gegensatz zu physischen Backup-Tools wie Percona XtraBackup ist `mysqldump` speicher-engine-agnostisch und funktioniert über MySQL-Versionen hinweg und sogar mit MariaDB-Forks.

1. Eine einzelne Datenbank exportieren

“`bash

mysqldump -u [username] -p [database_name] > [filename].sql

“`

Parameterübersicht:

• `-u [username]` — MySQL-Konto, das für die Verbindung verwendet wird
• `-p` — Löst eine interaktive Passwortabfrage aus (übergeben Sie das Passwort niemals inline als `-p[password]` auf gemeinsam genutzten Systemen; es ist in der `ps aux`-Ausgabe sichtbar)
• `[database_name]` — Zielschema für den Export
• `> [filename].sql` — Leitet stdout in die Ausgabedatei um

Beispiel:

“`bash

mysqldump -u root -p mydatabase > mydatabase_backup.sql

“`

Dies erzeugt eine Datei mit `CREATE TABLE`-, `INSERT`- und `ALTER TABLE`-Anweisungen, die ausreichen, um `mydatabase` von Grund auf neu zu erstellen.

Kritischer Grenzfall: Standardmäßig setzt `mysqldump` zu Beginn des Dumps eine globale Lesesperre (`FLUSH TABLES WITH READ LOCK`). Verwenden Sie auf stark frequentierten InnoDB-Servern stattdessen `–single-transaction`, um einen konsistenten Snapshot zu erstellen, ohne Schreibvorgänge zu blockieren:

“`bash

mysqldump -u root -p –single-transaction mydatabase > mydatabase_backup.sql

“`

`–single-transaction` funktioniert nur zuverlässig mit InnoDB-Tabellen. Wenn Ihre Datenbank MyISAM-Tabellen enthält, ist die Sperre unvermeidlich.

2. Mehrere Datenbanken exportieren

“`bash

mysqldump -u [username] -p –databases db1 db2 > multiple_databases_backup.sql

“`

Das Flag `–databases` weist `mysqldump` an, `CREATE DATABASE`- und `USE`-Anweisungen in die Ausgabe aufzunehmen, wodurch der Dump eigenständig wird. Ohne dieses Flag werden diese Anweisungen weggelassen, und der Dump setzt voraus, dass beim Import bereits eine Zieldatenbank ausgewählt ist.

Beispiel:

“`bash

mysqldump -u root -p –databases db1 db2 > multiple_databases_backup.sql

“`

3. Alle Datenbanken exportieren

“`bash

mysqldump -u root -p –all-databases > all_databases_backup.sql

“`

Dies exportiert jedes Schema, auf das der verbindende Benutzer zugreifen kann, einschließlich der Systemdatenbanken `mysql`, `information_schema` und `performance_schema`. Vermeiden Sie den Import von Systemdatenbanken über größere MySQL-Versionsgrenzen hinweg — das Schema der Berechtigungstabelle hat sich zwischen MySQL 5.7 und 8.0 erheblich geändert, und der Import des alten `mysql`-Schemas in eine neue 8.0-Instanz beschädigt die Authentifizierung.

So schließen Sie Systemschemata aus:

“`bash

mysqldump -u root -p –all-databases

–ignore-table=mysql.user

–ignore-table=mysql.db

> all_user_databases_backup.sql

“`

4. Nur Tabellenstruktur exportieren (ohne Daten)

“`bash

mysqldump -u root -p –no-data mydatabase > structure_only.sql

“`

Dies ist unschätzbar wertvoll für die Schema-Versionskontrolle, Code-Reviews oder das Einrichten einer leeren Staging-Umgebung. Die Ausgabe enthält nur `CREATE TABLE`-, `CREATE VIEW`-, `CREATE PROCEDURE`- und ähnliche DDL-Anweisungen — keine `INSERT`-Zeilen.

5. Bestimmte Tabellen exportieren

“`bash

mysqldump -u root -p mydatabase table1 table2 > tables_backup.sql

“`

Beachten Sie, dass beim Export bestimmter Tabellen auf diese Weise `mysqldump` keine `CREATE DATABASE`- oder `USE`-Anweisungen enthält. Sie müssen sicherstellen, dass die Zieldatenbank vor dem Import vorhanden ist.

6. Mit gespeicherten Prozeduren, Triggern und Events exportieren

Standardmäßig enthält `mysqldump` Trigger, lässt jedoch gespeicherte Prozeduren, Funktionen und geplante Events aus. Für eine vollständige Anwendungssicherung:

“`bash

mysqldump -u root -p

–routines

–triggers

–events

–single-transaction

mydatabase > full_backup.sql

“`

Das Vergessen von `–routines` ist eine der häufigsten Ursachen für fehlerhafte Anwendungswiederherstellungen — Schema und Daten sind vorhanden, aber die Geschäftslogik fehlt.

7. Komprimierter Export

Leiten Sie die Ausgabe direkt durch `gzip`, um die Dateigröße um 60–80 % zu reduzieren:

“`bash

mysqldump -u root -p mydatabase | gzip > mydatabase_backup.sql.gz

“`

Für maximale Komprimierung bei großen Datenbanken (auf Kosten der CPU-Zeit):

“`bash

mysqldump -u root -p mydatabase | gzip -9 > mydatabase_backup.sql.gz

“`

Datenbanken mit dem mysql-Client importieren

Der `mysql`-Befehlszeilenclient akzeptiert eine SQL-Datei über stdin-Umleitung und führt jede Anweisung sequenziell gegen den Zielserver aus.

1. In eine vorhandene Datenbank importieren

“`bash

mysql -u [username] -p [database_name] < [filename].sql

“`

Beispiel:

“`bash

mysql -u root -p mydatabase < mydatabase_backup.sql

“`

Wichtig: Wenn die `.sql`-Datei mit `–databases` oder `–all-databases` exportiert wurde, enthält sie bereits `CREATE DATABASE`- und `USE`-Direktiven. Geben Sie in diesem Fall keinen Datenbanknamen in der Befehlszeile an — dies führt zu einem Konflikt:

“`bash

mysql -u root -p < all_databases_backup.sql

“`

2. In eine neue Datenbank importieren

Die Zieldatenbank muss vorhanden sein, bevor Sie in sie importieren können. MySQL erstellt sie nicht automatisch aus einem einfachen Tabellen-Dump.

Schritt 1 — Datenbank erstellen:

“`bash

mysql -u root -p -e "CREATE DATABASE newdatabase CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"

“`

Schritt 2 — Dump importieren:

“`bash

mysql -u root -p newdatabase < mydatabase_backup.sql

“`

Geben Sie den Zeichensatz und die Kollation beim Erstellen der Datenbank immer explizit an. Das Verlassen auf Serverstandards ist eine häufige Quelle von Kodierungsfehlern, insbesondere bei der Migration zwischen Servern mit unterschiedlichen `character_set_server`-Konfigurationen.

3. Einen komprimierten Dump importieren

“`bash

gunzip < mydatabase_backup.sql.gz | mysql -u root -p mydatabase

“`

Oder mit `zcat` (auf den meisten Linux-Distributionen gleichwertig):

“`bash

zcat mydatabase_backup.sql.gz | mysql -u root -p mydatabase

“`

4. Import mit Fortschrittsüberwachung

Bei großen Dumps gibt der Standard-`mysql`-Client kein Feedback. Verwenden Sie `pv` (Pipe Viewer), um einen Echtzeit-Fortschrittsbalken anzuzeigen:

“`bash

pv mydatabase_backup.sql | mysql -u root -p mydatabase

“`

Installieren Sie `pv` mit `apt install pv` oder `yum install pv`. Auf einem Dedicated Server, der mehrere Gigabyte große Produktionsdatenbanken verwaltet, ist diese Transparenz betrieblich entscheidend.

mysqldump vs. alternative Backup-Methoden

Für Umgebungen, die mehrere Produktionsdatenbanken auf einem verwalteten VPS mit cPanel betreiben, bleibt `mysqldump` aufgrund seiner Kompatibilität und Einfachheit die am universellsten unterstützte Option.

Erweiterte Konfiguration und Grenzfälle

Zeichensätze korrekt behandeln

Zeichensatz-Fehlanpassungen sind für einen unverhältnismäßig großen Anteil beschädigter Importe verantwortlich. Der sicherste Ansatz ist, in jeder Phase explizit zu sein:

“`bash

mysqldump -u root -p

–default-character-set=utf8mb4

mydatabase > mydatabase_backup.sql

“`

“`bash

mysql -u root -p

–default-character-set=utf8mb4

mydatabase < mydatabase_backup.sql

“`

Hinweis: `utf8` in MySQL ist eine 3-Byte-Teilmenge, die keine 4-Byte-Unicode-Zeichen speichern kann (Emojis, bestimmte CJK-Ideogramme). Verwenden Sie für neue Datenbanken immer `utf8mb4`.

Große Importe beschleunigen

Standardmäßig führt MySQL nach jeder `INSERT`-Anweisung im Dump einen vollständigen Commit durch. Bei großen Datensätzen ist dies katastrophal langsam. Fügen Sie am Anfang Ihrer Importsitzung Folgendes hinzu:

“`bash

mysql -u root -p mydatabase <<EOF

SET foreign_key_checks = 0;

SET unique_checks = 0;

SET autocommit = 0;

SOURCE /path/to/mydatabase_backup.sql;

COMMIT;

SET foreign_key_checks = 1;

SET unique_checks = 1;

EOF

“`

Alternativ können Sie mit `–extended-insert` (standardmäßig aktiviert) und `–disable-keys` exportieren, um Einfügungen zu bündeln und den Index-Neuaufbau bis nach dem Datenladen zu verschieben.

Backups mit Cron automatisieren

Ein produktionstauglicher automatisierter Backup-Eintrag in `/etc/cron.d/mysql-backup`:

“`bash

0 2 * * * root mysqldump -u backup_user -p'StrongPass'

–single-transaction –routines –triggers –events

mydatabase | gzip > /backups/mydatabase_$(date +%F).sql.gz

“`

Verwenden Sie einen dedizierten MySQL-Benutzer mit den minimal erforderlichen Berechtigungen anstelle von `root`. Erstellen Sie ihn mit:

“`sql

CREATE USER 'backup_user'@'localhost' IDENTIFIED BY 'StrongPass';

GRANT SELECT, LOCK TABLES, SHOW VIEW, TRIGGER, EVENT ON *.* TO 'backup_user'@'localhost';

FLUSH PRIVILEGES;

“`

Anmeldedaten mit .my.cnf sichern

Das Übergeben von Passwörtern in der Befehlszeile macht sie im Shell-Verlauf und in Prozesslisten sichtbar. Speichern Sie Anmeldedaten in `~/.my.cnf`:

“`ini

[client]

user=root

password=YourSecurePassword

“`

Berechtigungen sofort setzen:

“`bash

chmod 600 ~/.my.cnf

“`

Damit übernehmen alle `mysqldump`- und `mysql`-Befehle die Anmeldedaten automatisch ohne die Flags `-u` und `-p`.

Remote-Datenbankexport

So dumpen Sie eine Datenbank von einem entfernten MySQL-Server:

“`bash

mysqldump -h remote.server.com -P 3306 -u remoteuser -p remotedatabase > remote_backup.sql

“`

Stellen Sie sicher, dass die entfernte MySQL-Instanz Verbindungen von Ihrer IP-Adresse zulässt und Port 3306 in der Firewall geöffnet ist. Für verschlüsselte Übertragungen tunneln Sie über SSH:

“`bash

ssh -L 3307:127.0.0.1:3306 user@remote.server.com -N &

mysqldump -h 127.0.0.1 -P 3307 -u remoteuser -p remotedatabase > remote_backup.sql

“`

Praktische Entscheidungsmatrix

Wichtige technische Erkenntnisse

• Verwenden Sie für InnoDB-Datenbanken immer `–single-transaction`, um das Blockieren von Anwendungsschreibvorgängen während des Exports zu vermeiden
• Geben Sie `utf8mb4` immer explizit an — verlassen Sie sich niemals auf Serverstandard-Zeichensatzannahmen
• Fügen Sie `–routines`, `–triggers` und `–events` in jede vollständige Anwendungssicherung ein, oder Sie riskieren den Verlust der Geschäftslogik
• Importieren Sie niemals Systemschematabellen (`mysql.*`) über größere MySQL-Versionsgrenzen hinweg
• Speichern Sie Anmeldedaten in `~/.my.cnf` mit `chmod 600` — übergeben Sie Passwörter niemals als Inline-Argumente
• Für Datenbanken über 10 GB sollten Sie `mysqlpump` oder die parallelen Dump-Dienstprogramme der MySQL Shell in Betracht ziehen, da `mysqldump` zum Engpass wird
• Überprüfen Sie jedes Backup, indem Sie eine Testwiederherstellung in einer isolierten Umgebung durchführen, bevor Sie sich für die Notfallwiederherstellung darauf verlassen
• Wenn Sie mehrere Client-Datenbanken hosten, isolieren Sie Umgebungen mit separaten VPS Control Panels, um mandantenübergreifenden Zugriff während Wiederherstellungsoperationen zu verhindern
• Ergänzen Sie Ihre Datenbank-Backup-Strategie mit einem gültigen SSL-Zertifikat auf jeder webbasierten Anwendungsschicht, die sich mit MySQL verbindet, um das Abfangen von Anmeldedaten während der Übertragung zu verhindern

FAQ

Was ist der Unterschied zwischen mysqldump und mysqlpump?

`mysqldump` ist einzelthreadig und erzeugt eine einzelne SQL-Datei — zuverlässig und universell kompatibel. `mysqlpump`, eingeführt in MySQL 5.7.8, unterstützt den parallelen Export mehrerer Datenbanken und Tabellen gleichzeitig, was die Dump-Zeit auf Mehrkern-Servern erheblich reduziert. Allerdings hat `mysqlpump` bekannte Probleme mit konsistenten Backups von Datenbanken mit gemischten Engines und ist weniger geeignet für versionsübergreifende Migrationen.

Kann ich einen MySQL 5.7-Dump in MySQL 8.0 importieren?

Ja, mit Einschränkungen. Benutzerdaten und Anwendungsschemata werden sauber importiert. Importieren Sie jedoch niemals die `mysql`-Systemdatenbank direkt — das Authentifizierungs-Plugin wurde in 8.0 von `mysql_native_password` auf `caching_sha2_password` geändert, und das Importieren alter Berechtigungstabellen wird die Authentifizierung beschädigen. Erstellen Sie Benutzer manuell mit `CREATE USER`- und `GRANT`-Anweisungen neu.

Warum schlägt mein Import mit „ERROR 1005: Can’t create table” aufgrund von Fremdschlüsseleinschränkungen fehl?

Dies geschieht, wenn Tabellen in einer Reihenfolge importiert werden, die Fremdschlüsselabhängigkeiten verletzt. Die Lösung besteht darin, `SET foreign_key_checks = 0;` Ihrer Importsitzung voranzustellen und `SET foreign_key_checks = 1;` nach Abschluss anzuhängen. Alternativ können Sie mit `–single-transaction` exportieren, was die referenzielle Integrität in der Dump-Datei selbst bewahrt.

Wie exportiere ich nur die Daten ohne die CREATE TABLE-Anweisungen?

Verwenden Sie das Flag `–no-create-info`: `mysqldump -u root -p –no-create-info mydatabase > data_only.sql`. Dies ist nützlich, wenn Sie Daten in ein vorhandenes Schema neu laden müssen, ohne dessen Struktur zu ändern.

Was ist der sicherste Weg, einen MySQL-Dump zwischen zwei entfernten Servern zu übertragen?

Leiten Sie den Dump direkt über SSH weiter, ohne eine Zwischendatei auf die Festplatte zu schreiben: `mysqldump -u root -p sourcedb | ssh user@destination.server "mysql -u root -p targetdb"`. Dies ist sowohl schneller als auch sicherer als das Kopieren einer Klartextdatei `.sql`, insbesondere beim Betrieb in einer Shared Web Hosting-Umgebung, in der Festplattenquoten eine Einschränkung darstellen.