---
title: "KeyHelp: Große Datenbanken importieren und exportieren ohne Zeitüberschreitung"
date: 2026-10-01T22:21:33+02:00
modified: 2026-11-09T11:44:22+01:00
category: linux
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/keyhelp-grosse-datenbanken-importieren-exportieren-phpmyadmin-mariadb-dump
keywords:
  - KeyHelp
  - MariaDB
  - phpMyAdmin
  - mariadb-dump
  - Datenbank
  - Webhosting
reading_time: 8
variables:
  - name: password
    label: "Passwort (password)"
    generated_in_browser: true
---

# KeyHelp: Große Datenbanken importieren und exportieren ohne Zeitüberschreitung

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{password}}` | Passwort (password) | wird im Browser des Lesers zufällig erzeugt |

Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten, statt die Befehle selbst umzuschreiben.

Ein Shop mit einigen hundert Megabyte Datenbank zieht auf einen KeyHelp-Server um, und der Import im Browser bricht mit einer knappen Fehlermeldung ab. Diese Anleitung zeigt, welche Grenzen KeyHelp für Import und Export setzt, wo sie konfiguriert sind und wie Sie große Datenbanken trotzdem zuverlässig übertragen: per `mariadb-dump` und `mariadb` auf der Kommandozeile oder, bis zu einer bestimmten Größe, in phpMyAdmin. Grundlage ist ein KeyHelp-Server wie in [KeyHelp installieren und absichern](https://s-edv.com/anleitungen/keyhelp-installieren-absichern-eigener-server).

**Kurzfassung:** phpMyAdmin nimmt in KeyHelp 26.1.1 Dateien bis 128 MiB an, die Grenze gilt für die hochgeladene, also gegebenenfalls komprimierte Datei. Länger als rund 120 Sekunden darf ein Import im Browser nicht laufen, dann antwortet Apache mit „Gateway Timeout“. Danach bleibt eine unvollständig gefüllte Tabelle zurück. Auf der Kommandozeile greifen diese Grenzen nicht: Ein Export von 470 MiB SQL mit `mariadb-dump` dauert 5,5 Sekunden, der Import mit `mariadb` dauert 22,5 Sekunden. Eine einzelne Anweisung über 16 MiB scheitert dagegen auch auf der Kommandozeile an `max_allowed_packet`.

## Voraussetzungen

- [ ] **KeyHelp-Server**, Version 26.1.1 (Build 3698) auf Debian 12.15 mit MariaDB 10.11.18.
- [ ] **Kundenkonto mit Datenbank**, im Beispiel `kunde1` mit der Datenbank `kunde1_db` und dem gleichnamigen Datenbankbenutzer.
- [ ] **Kommandozeile auf dem Server** für den Weg über `mariadb-dump`. Die Befehle laufen als root, bis auf `SET GLOBAL` mit den Zugangsdaten des Datenbankbenutzers. Kunden brauchen dafür einen SSH-Zugang, den der Admin unter den [Berechtigungen des Kunden](https://s-edv.com/anleitungen/keyhelp-berechtigungen-kunden-dns-editor-ssh-datenbank-fernzugriff) freigibt.
- [ ] **Beispieldaten:** Die Tabelle `bestellungen` enthält eine Million Zeilen Zufallsdaten, Größe laut `information_schema`:

```plaintext
table_name	table_rows	MiB
bestellungen	951938	418
```

## Schritt 1: Die Grenzen von KeyHelp kennen

phpMyAdmin und Adminer laufen in KeyHelp nicht im PHP-Pool des Kunden, sondern im Pool der KeyHelp-Oberfläche. Laut [KeyHelp-Wissensdatenbank](https://kb.keyhelp.de/article/konfigurationsdateien-speicherpfade-118.html) ist `fpm/pool.d/keyhelp.conf` die „PHP-FPM Konfiguration für die KeyHelp-Oberfläche und die verbundenen Dienste (Webmail, PhpMyAdmin)“. Dort steht:

```bash
$ grep -rE "upload_max|post_max|max_execution|memory_limit|max_input_time" /etc/php/8.2/fpm/pool.d/ | head -40
```

```plaintext
/etc/php/8.2/fpm/pool.d/keyhelp.conf:php_admin_value[memory_limit] = 256M
/etc/php/8.2/fpm/pool.d/keyhelp.conf:php_admin_value[post_max_size] = 144M
/etc/php/8.2/fpm/pool.d/keyhelp.conf:php_admin_value[upload_max_filesize] = 128M
/etc/php/8.2/fpm/pool.d/keyhelp.conf:php_admin_value[max_execution_time] = 240
```

Die PHP-Einstellungen, die Sie pro Kunde im Panel setzen, wirken also nicht auf phpMyAdmin. Die zweite Grenze sitzt im Apache. Die Weiterleitung an diesen PHP-Pool wartet höchstens 120 Sekunden auf eine Antwort:

```bash
$ sed -n 60,72p /etc/apache2/keyhelp/keyhelp.conf
```

```plaintext
    <Proxy fcgi://keyhelp_keyhelp.socket>
        ProxySet connectiontimeout=5 timeout=120
    </Proxy>
```

Die dritte Grenze gilt für jeden Weg, auch für die Kommandozeile: MariaDB nimmt keine einzelne Anweisung an, die größer als `max_allowed_packet` ist. KeyHelp setzt den Wert in einer eigenen Datei:

```bash
$ head -12 /etc/mysql/mariadb.conf.d/90-tuning.cnf
```

```plaintext
# KeyHelp Tuning Settings
max_allowed_packet      = 16M
```

> **Prüfen:** Die Importseite von phpMyAdmin zeigt die Upload-Grenze direkt an, zum Beispiel „Durchsuchen Sie Ihren Computer: (Maximal: 128MiB)“.

## Schritt 2: Datenbank auf der Kommandozeile exportieren

Damit das Passwort nicht in der Befehlszeile und im Verlauf steht, legen Sie eine Datei mit den Zugangsdaten an, zum Beispiel `/root/k1.cnf`. Die Datei sollte nur für Sie lesbar sein (Rechte 600):

```ini
[client]
user=kunde1_db
password={{password}}
```

Führen Sie den Export mit `--single-transaction` und `--quick` aus:

```bash
time mariadb-dump --defaults-extra-file=/root/k1.cnf --single-transaction --quick kunde1_db > /root/kunde1_db.sql
ls -lh /root/kunde1_db.sql
```

```plaintext
real	0m5.537s
-rw-r--r-- 1 root root 470M Oct  1 19:20 /root/kunde1_db.sql
```

Für die Übertragung auf einen anderen Server lohnt sich die Kompression in einem Schritt:

```bash
time (mariadb-dump --defaults-extra-file=/root/k1.cnf --single-transaction --quick kunde1_db | gzip > /root/export.sql.gz)
ls -lh /root/export.sql.gz
```

```plaintext
real	0m18.875s
-rw-r--r-- 1 root root 260M Oct  1 19:35 /root/export.sql.gz
```

Zufallsdaten lassen sich schlecht komprimieren, aus 470 MiB werden 260 MiB.

> **Prüfen:** Ein vollständiger Dump beginnt mit einem Kopf wie `-- MariaDB dump 10.19 Distrib 10.11.18-MariaDB` und enthält je Tabelle `DROP TABLE IF EXISTS` und `CREATE TABLE`.

## Schritt 3: Datenbank auf der Kommandozeile importieren

Der Import liest die Datei über die Standardeingabe ein. Weil der Dump `DROP TABLE IF EXISTS` enthält, ersetzt er gleichnamige Tabellen in der Zieldatenbank vollständig:

```bash
time mariadb --defaults-extra-file=/root/k1.cnf kunde1_db < /root/kunde1_db.sql
mariadb --defaults-extra-file=/root/k1.cnf kunde1_db -e "SELECT COUNT(*) FROM bestellungen"
```

```plaintext
real	0m22.484s
COUNT(*)
1000000
```

Komprimierte Dumps müssen Sie nicht erst entpacken. Hier ist `/root/kunde1_db.sql.gz` mit `gzip -k /root/kunde1_db.sql` entstanden:

```bash
time (gunzip -c /root/kunde1_db.sql.gz | mariadb --defaults-extra-file=/root/k1.cnf kunde1_db)
```

```plaintext
real	0m25.213s
```

Auch eine Tabelle mit sechs Millionen Zeilen und rund 2,5 GB SQL läuft so ohne Abbruch durch:

```bash
time (gunzip -c /root/protokoll.sql.gz | mariadb --defaults-extra-file=/root/k1.cnf kunde1_db)
mariadb --defaults-extra-file=/root/k1.cnf kunde1_db -e "SELECT COUNT(*) FROM protokoll"
```

```plaintext
real	1m46.720s
COUNT(*)
6000000
```

> **Prüfen:** Vergleichen Sie die Zeilenzahl wichtiger Tabellen mit `SELECT COUNT(*)` auf Quell- und Zielserver.

## Schritt 4: Import in phpMyAdmin bis 128 MiB

Im Kundenbereich öffnen Sie unter „Ressourcen“, „Datenbanken“ in der Zeile der Datenbank die Aktion „Datenbank-Weboberfläche“. Damit öffnet sich phpMyAdmin. Wählen Sie dort die Datenbank und den Reiter „Importieren“.

![phpMyAdmin-Importseite für die Datenbank kunde1_db mit dem Hinweis Maximal 128MiB, Zeichencodierung utf-8 und aktivierter Option Teilweiser Import](https://s-edv.com/uploads/2026/10/96d50c46937e0f6dafda70ebf1a94c299281e3901472bcc3fcbff5707448b3f2-1024.png)
*Die Importseite zeigt die Upload-Grenze aus dem PHP-Pool von KeyHelp*

Laut Seite darf die Datei „komprimiert (gzip, zip) oder unkomprimiert“ sein. Drei Beispiele für Dateien:

- **65 MiB gzip** mit 250.000 Zeilen: „Der Import wurde erfolgreich abgeschlossen, 146 Abfragen wurden ausgeführt. (teil.sql.gz)“
- **146 MiB gzip:** „Möglicherweise wurde eine zu große Datei hochgeladen. Bitte lesen Sie die Dokumentation zur Lösung dieses Problems.“ Im Fehlerprotokoll von Apache steht dazu `PHP Warning: POST Content-Length of 152297925 bytes exceeds the limit of 150994944 bytes in Unknown on line 0`, also die 144 MiB aus `post_max_size`.
- **27 MB gzip mit rund 2,5 GB SQL** (sechs Millionen kurze Zeilen): Der Upload geht durch, der Import nicht. Nach rund zwei Minuten zeigt der Browser „Gateway Timeout“.

Die Grenze von 128 MiB gilt also für die hochgeladene Datei. Eine gut komprimierbare Tabelle passt gezippt durch, scheitert dann aber an der Laufzeit.

> **Prüfen:** Nach dem Import zeigt phpMyAdmin die Zahl der ausgeführten Abfragen. Prüfen Sie zusätzlich die Zeilenzahl mit `SELECT COUNT(*)`.

## Schritt 5: Was bei einem Abbruch in der Datenbank bleibt

Bei der dritten Datei ist in phpMyAdmin „Teilweiser Import“ eingeschaltet. Die Option soll laut Oberfläche den Import unterbrechen, „falls das Skript erkennt, dass es sich dem PHP-Timeout-Limit nähert“. Das PHP-Limit liegt aber bei 240 Sekunden, Apache gibt schon nach 120 Sekunden auf. Im Zugriffsprotokoll von KeyHelp steht die Anfrage mit Status 504:

```plaintext
"POST /db/index.php?route=/import HTTP/2.0" 504 9867
```

Im Fehlerprotokoll folgt rund zwei Minuten später:

```plaintext
[proxy_fcgi:error] [pid 665:tid 679] (70007)The timeout specified has expired:
```

Die Tabelle ist danach nicht leer, sondern unvollständig gefüllt. Auch bei späteren Kontrollen stehen dort unverändert 4.361.744 von 6.000.000 Zeilen:

```plaintext
COUNT(*)
4361744
```

Ein abgebrochener Import ist damit gefährlicher als eine Fehlermeldung vor dem Start: Eine Website kann mit unvollständigen Daten weiterlaufen. Löschen Sie die betroffenen Tabellen und importieren Sie neu, im Zweifel auf der Kommandozeile.

> Prüfen Sie nach jedem Abbruch die Zeilenzahl. Das Zugriffsprotokoll der Oberfläche liegt unter `/var/log/apache2/keyhelp/access.log`.

## Schritt 6: Export in phpMyAdmin

Der Export hat die Upload-Grenze nicht. Im Reiter „Exportieren“ exportieren Sie die Datenbank mit der Exportmethode „Schnell“ im Format „SQL“. Der Download mit 497.589.534 Byte ist nach rund 30 Sekunden vollständig und endet mit der letzten Zeile des Dumps. Für größere Exporte nutzen Sie die Kommandozeile aus Schritt 2.

> **Prüfen:** Die letzte Zeile eines vollständigen Exports lautet `/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;`.

## Schritt 7: Weboberfläche für Datenbanken wählen (Admin)

Als Admin legen Sie unter „Konfiguration“, „Datenbank-Administration“ fest, welches Werkzeug Kunden bekommen. Zur Auswahl stehen „phpMyAdmin 5.2.3“ und „Adminer 6.0.1“. Über „Benutzerdefinierte Zugriffs-URL“ verweisen Sie auf eine eigene Installation, laut Hinweis gilt die URL dann „im gesamten Control Panel“.

![KeyHelp-Konfiguration Datenbank-Administration mit aktiviertem Client, Auswahl phpMyAdmin 5.2.3 und leerem Feld Benutzerdefinierte Zugriffs-URL](https://s-edv.com/uploads/2026/10/a673e3e7cf7fe18630181b926d408e4f3b22a8efa540a285ce5526681eabae67-1024.png)
*Hier wählt der Admin phpMyAdmin oder Adminer*

Beide Werkzeuge liegen unter `/home/keyhelp/www/`.

> **Prüfen:** Im Kundenbereich führt der Menüpunkt „Datenbank-Weboberfläche“ unter „Tools“ auf `/db/` und damit zu phpMyAdmin.

## Typische Fehler

**„Möglicherweise wurde eine zu große Datei hochgeladen.“** Die Datei ist größer als die Grenze aus dem PHP-Pool der Oberfläche. Komprimieren Sie den Dump mit gzip oder weichen Sie auf die Kommandozeile aus.

**„Gateway Timeout“ beim Import.** Der Import läuft länger als die 120 Sekunden aus `ProxySet timeout=120`. „Teilweiser Import“ verhindert das nicht. Die Tabelle ist danach unvollständig, siehe Schritt 5.

**„ERROR 2006 (HY000) at line 1: Server has gone away“.** Diese Meldung kommt beim Import einer einzelnen Anweisung mit 20 MB. Das Journal von MariaDB nennt den Grund:

```plaintext
[Warning] Aborted connection 355 to db: 'kunde1_db' user: 'kunde1_db' host: 'localhost' (Got a packet bigger than 'max_allowed_
```

Nur den Client mit `--max-allowed-packet=64M` zu starten, reicht nicht, die Meldung kommt erneut. Erst wenn zusätzlich der Wert im Server als root mit `SET GLOBAL` angehoben ist, steht die Zeile mit 20.000.000 Zeichen in der Tabelle:

```bash
$ mariadb -e "SET GLOBAL max_allowed_packet=67108864"
$ mariadb --defaults-extra-file=/root/k1.cnf --max-allowed-packet=64M kunde1_db < /root/zeile.sql
$ mariadb -e "SET GLOBAL max_allowed_packet=16777216"
```

Der dritte Befehl setzt den Wert danach wieder auf 16 MiB zurück. Laut [KeyHelp-Wissensdatenbank](https://kb.keyhelp.de/article/konfigurationsdateien-speicherpfade-118.html) können manuelle Änderungen in von KeyHelp erstellten Dateien überschrieben werden.

## Häufige Fragen

### Gelten die PHP-Einstellungen des Kunden für phpMyAdmin?

Nein. Für phpMyAdmin gelten die Werte aus `/etc/php/8.2/fpm/pool.d/keyhelp.conf`, der Pool läuft als Benutzer `keyhelp`. Ein Kunden-Pool ist dort nicht beteiligt.

### Wie lange darf ein Import im Browser dauern?

Die Anfrage endet nach rund 120 Sekunden mit 504. Der Import von 1.000.000 Zeilen (470 MiB SQL) dauert auf der Kommandozeile 22,5 Sekunden.

### Hilft es, den Dump in mehrere Dateien zu teilen?

Nur bedingt. Jede Datei muss unter 128 MiB bleiben und in unter zwei Minuten importiert sein. Mit `--where` lässt sich ein Teil einer Tabelle exportieren, zum Beispiel so:

```bash
mariadb-dump --defaults-extra-file=/root/k1.cnf --single-transaction --quick --where="id<=250000" kunde1_db bestellungen | gzip > /root/teil.sql.gz
```

Die Datei mit 250.000 Zeilen (65 MiB gzip) läuft in phpMyAdmin ohne Fehler durch. Sie ersetzt aber die ganze Tabelle: Vorher stehen dort 1.000.000 Zeilen, danach 250.000. Jeder so erzeugte Teil-Dump legt die Tabelle mit `DROP TABLE IF EXISTS` neu an, wie in Schritt 3 gezeigt.

## Fazit

Für kleine und mittlere Datenbanken reicht phpMyAdmin in KeyHelp: Bis 128 MiB Dateigröße und rund zwei Minuten Laufzeit funktioniert der Import, komprimierte Dumps sparen Upload. Darüber hinaus ist die Kommandozeile der verlässliche Weg, dort läuft auch der Import von 2,5 GB SQL ohne Abbruch durch. Prüfen Sie nach jedem Import die Zeilenzahl, denn ein Abbruch im Browser hinterlässt keine leere, sondern eine unvollständig gefüllte Tabelle.

## Weiterführende Anleitungen und Quellen

- [KeyHelp installieren und absichern](https://s-edv.com/anleitungen/keyhelp-installieren-absichern-eigener-server)
- [KeyHelp: Berechtigungen für Kunden festlegen](https://s-edv.com/anleitungen/keyhelp-berechtigungen-kunden-dns-editor-ssh-datenbank-fernzugriff)
- [MySQL- und PostgreSQL-Backups mit cron automatisieren](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud)
- [KeyHelp-Wissensdatenbank: Konfigurationsdateien und Speicherpfade](https://kb.keyhelp.de/article/konfigurationsdateien-speicherpfade-118.html)
- [Keyweb: KeyHelp, alle Funktionen im Überblick](https://www.keyweb.de/de/keyhelp/keyhelp/alle-funktionen-im-ueberblick)
