---
title: "Datenbank im laufenden Betrieb kopiert: Wie oft ist das Backup kaputt?"
date: 2026-11-15T16:33:30+01:00
modified: 2026-11-15T19:12:02+01:00
category: backup
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/ernstfall-datenbank-live-kopiert-backup-kaputt
keywords:
  - Ernstfall
  - Backup
  - PostgreSQL
  - MariaDB
  - SQLite
  - Docker
  - Restore
  - Datenbank
reading_time: 12
ai_notice: "Mit KI erstellt – redaktionelle Prüfung ausstehend"
---

# Datenbank im laufenden Betrieb kopiert: Wie oft ist das Backup kaputt?

> Mit KI erstellt – redaktionelle Prüfung ausstehend ([KI-Transparenz](https://s-edv.com/ki-transparenz))

Ein Skript kopiert nachts den Datenordner eines Datenbank-Containers auf das NAS, die Datenbank läuft dabei weiter: So sehen viele Backups im HomeLab und in kleinen Firmen aus. Ob eine solche Kopie im Ernstfall etwas wert ist, lässt sich nicht am Skript ablesen, sondern nur an der Kopie selbst. Für diese Anleitung wurden deshalb 348 Kopien von PostgreSQL, MariaDB und SQLite gezogen, während die Datenbank Buchungen schrieb. Jede Kopie wurde zurückgespielt, geöffnet und nachgerechnet.

**Dies ist Teil 1 der Reihe „Ernstfall“.** Jeder Teil macht absichtlich etwas kaputt, misst, was passiert, und zeigt den Weg zurück.

**Kurzfassung:** Von 240 Ordnerkopien im laufenden Betrieb waren 136 in Ordnung. Bei MariaDB startete keine der 30 langsam gezogenen Kopien mehr, bei SQLite war jede langsam gezogene Kopie beschädigt, bei PostgreSQL waren es 2 von 30. Zehn SQLite-Kopien bestanden die Prüfung der Datenbank und enthielten trotzdem falsche Kontostände. Der Kopierbefehl meldete in den meisten dieser Fälle keinen Fehler. Per Dump, aus der pausierten und aus der gestoppten Datenbank entstanden 108 Kopien, alle in Ordnung. Nur bei SQLite mit Rollback-Journal kam der Dump unter Dauerlast in 4 von 10 Versuchen nicht zustande und meldete das mit einem Fehler.

## Was Sie brauchen

- [ ] Einen Linux-Server mit Docker und Docker Compose, siehe [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Eine Datenbank im Container, deren Datenordner als Bind-Mount auf dem Host liegt. Die Beispiele nutzen den Dienstnamen `db`, die Datenbank `bank` und den Ordner `./d`.
- [ ] Einen Ort für die Sicherung außerhalb des Datenordners, in den Beispielen `./dump`, im Container als `/dump` eingebunden.

## Schritt 1: Dump statt Ordnerkopie

Ein Dump ist das Sicherungswerkzeug der Datenbank selbst. Er liest einen festen Stand, während die Datenbank weiterläuft. Im Test liefen diese drei Befehle unter voller Schreiblast.

PostgreSQL:

```bash
$ docker compose exec -T db sh -c 'pg_dump -U postgres -Fc bank > /dump/bank.dump'
```

MariaDB, das Passwort steht im Container bereits in der Variable `MARIADB_ROOT_PASSWORD`:

```bash
$ docker compose exec -T db sh -c 'mariadb-dump -uroot -p"$MARIADB_ROOT_PASSWORD" --single-transaction bank > /dump/bank.sql'
```

SQLite hat keinen Server. Hier schreibt `VACUUM INTO` eine saubere Kopie in eine neue Datei. Die Zieldatei darf noch nicht existieren. Prüfen Sie den Rückgabewert: Schreibt die Anwendung ohne Pause und nutzt die Datei das Rollback-Journal, kann der Befehl mit `database is locked` abbrechen.

```bash
$ sqlite3 -cmd ".timeout 30000" d/bank.db "VACUUM INTO 'dump/bank.db'"
```

> **Prüfen:** **Verifizieren:** Der Befehl endet ohne Meldung, und die Datei im Ordner `dump` ist größer als null. Ob sie etwas taugt, zeigt erst Schritt 3.

## Schritt 2: Ordnerkopie nur aus dem Stillstand

Soll es eine Kopie des Datenordners sein, dann darf die Datenbank währenddessen nicht schreiben. Am saubersten ist der Stopp. Im Test wurde dabei zuerst die Anwendung angehalten, dann die Datenbank:

```bash
$ docker compose stop db
$ cp -a d /backup/d-kopie
$ docker compose start db
```

Kürzer ist die Unterbrechung mit `pause`. Docker friert die Prozesse ein, die Datenbank schreibt nicht weiter, und Verbindungen bleiben bestehen:

```bash
$ docker compose pause db
$ cp -a d /backup/d-kopie
$ docker compose unpause db
```

Die Kopie aus der Pause sieht für die Datenbank aus wie der Stand nach einem Stromausfall. PostgreSQL und MariaDB starteten sie im Test jedes Mal mit einer Wiederherstellung aus dem eigenen Protokoll, danach stimmten alle Kontostände. Bei SQLite gibt es keinen Datenbankdienst zum Pausieren. Dort müssen Sie die Anwendung pausieren oder stoppen, die in die Datei schreibt. Kopieren Sie immer den ganzen Ordner, bei SQLite also auch die Dateien mit den Endungen `-wal` und `-journal`.

> **Prüfen:** **Verifizieren:** `docker compose ps` zeigt den Dienst danach wieder als `Up` ohne den Zusatz `(Paused)`.

## Schritt 3: Kopie zurückspielen und prüfen

Eine Sicherung zählt erst, wenn sie einmal gestartet wurde. Spielen Sie sie in einen zweiten, leeren Container ein, nie in die laufende Datenbank. Im Test hieß dieser Dienst `v`, nutzte dasselbe Image und einen eigenen Datenordner. Einen Dump laden Sie so:

```bash
$ docker compose exec -T v pg_restore -U postgres -d bank --no-owner --exit-on-error /dump/bank.dump
$ docker compose exec -T v sh -c 'mariadb -uroot -p"$MARIADB_ROOT_PASSWORD" bank < /dump/bank.sql'
```

Eine Ordnerkopie binden Sie als Datenordner des zweiten Containers ein und starten ihn. Danach prüfen Sie mit dem Werkzeug der Datenbank:

```bash
$ docker compose exec -T v pg_amcheck -U postgres -d bank --install-missing --heapallindexed
$ docker compose exec -T v sh -c 'mariadb-check -uroot -p"$MARIADB_ROOT_PASSWORD" bank'
$ sqlite3 /backup/d-kopie/bank.db "PRAGMA integrity_check"
```

Zum Schluss gehört eine Abfrage dazu, deren Ergebnis Sie kennen: die Zahl der Datensätze, eine Summe, der jüngste Eintrag. Im Test war das die Summe aller Kontostände.

> **Prüfen:** **Verifizieren:** `pg_amcheck` endet ohne Ausgabe, `mariadb-check` meldet für jede Tabelle `OK`, SQLite antwortet mit `ok`. Ihre Kontrollabfrage liefert den erwarteten Wert.

## So wurde gemessen

Getestet mit PostgreSQL 18.7, MariaDB 11.8.9 und SQLite 3.53.4, jeweils im Container auf einem Linux-Server mit Docker, Datenordner als Bind-Mount. Die Einstellungen blieben auf den Vorgaben der Images: bei PostgreSQL Prüfsummen, `full_page_writes` und `fsync` eingeschaltet, bei MariaDB `innodb_flush_log_at_trx_commit=1` und Doublewrite eingeschaltet.

Jede Datenbank enthielt eine Million Konten mit je 1.000 Einheiten Guthaben und eine Tabelle für Buchungen. Die Last bestand aus Überweisungen zwischen zwei Konten samt Buchungseintrag, die Summe aller Konten muss also immer genau eine Milliarde ergeben. Bei PostgreSQL und MariaDB schrieben acht Verbindungen gleichzeitig, bei SQLite eine. Die Datenbanken schafften dabei 130 bis 270 Buchungen pro Sekunde (PostgreSQL), 140 bis 230 (MariaDB) und 30 bis 130 (SQLite).

Verglichen wurden fünf Verfahren. „Live, schnell“ ist `cp -a` auf denselben Datenträger und dauerte im Median 0,2 bis 0,4 Sekunden, keine Kopie länger als 0,8 Sekunden. „Live, langsam“ ist `rsync -a --bwlimit=20000`, also rund 20 MB pro Sekunde wie bei einer Kopie über das Netz auf ein NAS. Sie dauerte je nach Größe der Datenbank 11 Sekunden (SQLite, 210 MB), 22 Sekunden (MariaDB, 430 MB) und 47 Sekunden (PostgreSQL, 920 MB). Dazu kamen Pause, Dump und Stopp wie in Schritt 1 und 2.

Jede Kopie von PostgreSQL und MariaDB wurde in einem frischen Container gestartet, jede SQLite-Kopie mit `sqlite3` geöffnet. Jede bekam eines von vier Urteilen: in Ordnung, veralteter Stand (fehlerfrei, aber älter als der Beginn der Kopie), defekt (startet, aber Prüfwerkzeug oder Kontostände stimmen nicht) oder startet nicht. Je Datenbank und Modus waren 30 schnelle und 30 langsame Live-Kopien geplant, dazu 15 aus der Pause, 10 Dumps und 3 aus dem Stopp. SQLite mit Rollback-Journal lief in die Zeitgrenze und wurde in zwei weiteren Läufen mit neuer Datenbank zu Ende geführt. Die laufende Datenbank blieb fehlerfrei, wo eine Endkontrolle lief: volle Summe, keine Abweichung. In den beiden abgebrochenen Läufen folgten auf die falschen schnellen Kopien beziehungsweise auf die langsamen noch fehlerfreie Kopien derselben Datenbank.

## Ergebnis 1: Die Zahlen

![Matrix: Ergebnis aller Kopien je Datenbank und Verfahren, Live-Kopien fallen aus, Pause, Dump und Stopp liefern nur gute Kopien](https://s-edv.com/uploads/2026/11/1ccc93f9b6834b7dc7f94c7ce26f65e794e2883ef2afd911c9c55b47b4a5d776-1024.png)
*Ergebnis aller Kopien je Datenbank und Verfahren: Live-Kopien fallen aus, Pause, Dump und Stopp sind vollständig in Ordnung*

| Live-Kopie | Kopien | in Ordnung | veraltet | defekt | startet nicht |
| --- | --- | --- | --- | --- | --- |
| PostgreSQL: live kopiert, schnell | 30 | 30 | 0 | 0 | 0 |
| PostgreSQL: live kopiert, langsam | 30 | 28 | 0 | 1 | 1 |
| MariaDB: live kopiert, schnell | 30 | 29 | 0 | 1 | 0 |
| MariaDB: live kopiert, langsam | 30 | 0 | 0 | 0 | 30 |
| SQLite, WAL: live kopiert, schnell | 30 | 29 | 0 | 1 | 0 |
| SQLite, WAL: live kopiert, langsam | 30 | 0 | 0 | 30 | 0 |
| SQLite, Rollback-Journal: live kopiert, schnell | 30 | 20 | 0 | 10 | 0 |
| SQLite, Rollback-Journal: live kopiert, langsam | 30 | 0 | 0 | 30 | 0 |
| SQLite, WAL: nur `bank.db` ohne `-wal`, schnell | 30 | 0 | 29 | 1 | 0 |

Die Verfahren aus Schritt 1 und 2 stehen nicht in der Tabelle, weil es dort nichts zu unterscheiden gibt: Alle 108 entstandenen Kopien waren in Ordnung, bei jeder Datenbank. 4 Dumps von SQLite mit Rollback-Journal kamen nicht zustande, dazu mehr in Ergebnis 3.

Bei den Live-Kopien entscheidet die Dauer. Die schnelle Kopie ging bei PostgreSQL in allen 30 Fällen gut, bei MariaDB und SQLite im Modus WAL in 29 von 30. Sobald die Kopie so lange dauerte wie über ein Netz, kippte das Bild. MariaDB lieferte in 30 Versuchen keine einzige startfähige Kopie, SQLite keine einzige unbeschädigte. PostgreSQL hielt am besten durch, verlor aber auch 2 von 30.

## Ergebnis 2: Wie sich die kaputten Kopien zeigten

![Vier Kacheln: unbrauchbare Live-Kopien nach Art des Schadens, startet nicht, Prüfung meldet Schaden, Prüfung bestanden aber Inhalt falsch, veralteter Stand](https://s-edv.com/uploads/2026/11/4357e9d8b77d57ec6363eebf39ce117092db80f2c38f04341e5606cb86530a92-1024.png)
*Die fehlerhaften Live-Kopien nach Art des Schadens: startet nicht, Prüfwerkzeug meldet Fehler, stille Abweichung, veralteter Stand*

**MariaDB** scheiterte laut. Alle 30 langsamen Kopien brachen beim Start ab, die Meldungen stehen unten bei den typischen Fehlern. Die eine defekte schnelle Kopie startete, meldete beim ersten Zugriff aber die Tabelle `buchung` als beschädigt.

**PostgreSQL** scheiterte seltener, dafür tückischer. Eine Kopie startete nicht, weil der Prüfpunkt fehlte, auf den die Steuerdatei verwies. Die andere startete mit einer normalen Wiederherstellung und nahm Verbindungen an. `pg_dump` las sie fehlerfrei aus. Die Summe der Konten ergab aber 847.509.011 statt einer Milliarde, 39.120 Konten passten nicht zu ihren Buchungen, und die Hälfte der Buchungen fehlte. Unter den Werkzeugen der Datenbank meldete nur `pg_amcheck` den Schaden, dazu schlugen die eigenen Kontrollabfragen an. In beiden Fällen hatte PostgreSQL während der Kopie Protokolldateien aufgeräumt, die `rsync` noch kopieren wollte.

**Der Rückgabewert des Kopierbefehls sagt nichts aus.** `rsync` endete bei allen 30 toten MariaDB-Kopien mit 0. Bei PostgreSQL meldete es viermal den Wert 24, weil Dateien während der Kopie verschwunden waren. Zwei dieser vier Kopien waren in Ordnung, zwei waren die beiden Ausfälle.

## Ergebnis 3: SQLite kopiert sich nicht von selbst

Im Modus WAL liegen die jüngsten Änderungen in der Datei `bank.db-wal`. Wer nur `bank.db` sichert, bekommt eine Datenbank, die jede Prüfung besteht und trotzdem alt ist: In 29 von 30 Fällen fehlten die letzten Buchungen, im Median 159 und höchstens 232. Bei einer Anwendung, die selten schreibt, kann der Abstand deutlich größer sein, weil SQLite die Datei erst nach rund 1.000 geänderten Seiten nachzieht.

Mit Rollback-Journal, der Voreinstellung von SQLite, waren 10 von 30 schnellen Kopien falsch, obwohl bei neun von ihnen das Journal mitkopiert wurde. Bei der zehnten war das Journal während der Kopie verschwunden, `cp` meldete das als Fehler. Diese Kopien sind der unangenehmste Fund der Messreihe: `PRAGMA integrity_check` antwortete mit `ok`, die Datei ließ sich normal öffnen, aber ein bis vier Konten passten nicht zu ihren Buchungen, und bei sechs dieser Kopien stimmte auch die Gesamtsumme nicht. Die Kopie hatte eine Überweisung mittendrin erwischt. Ohne eigene Kontrollabfrage fällt das nicht auf.

Die langsamen Kopien waren in beiden Modi ausnahmslos beschädigt. `PRAGMA integrity_check` meldete den Schaden jedes Mal. Eine einfache Abfrage der Summe lief dagegen bei allen 60 durch und lieferte jedes Mal eine falsche Zahl.

Der Befehl `.backup` der SQLite-Kommandozeile war unter Dauerlast keine Hilfe: Im Modus WAL wurde nach der Zeitgrenze von 120 Sekunden abgebrochen, mit Rollback-Journal endete nach 30 Sekunden mit einem Fehler. Das ist je ein Versuch. Mit Rollback-Journal meldete der Befehl `database is locked`. Für den Modus WAL nennt die Dokumentation von SQLite den wahrscheinlichen Grund: Schreibt eine andere Verbindung in die Quelle, beginnt die Sicherung von vorn. `VACUUM INTO` lief im Modus WAL in allen 10 Versuchen durch, im Mittel in weniger als einer Sekunde. Mit Rollback-Journal sperrt jeder Schreibvorgang die Datei kurz für alle Leser, unter Dauerlast kommt ein langer Lesevorgang wie `VACUUM INTO` deshalb oft nicht durch. Dort gelangen 6 von 10 Versuchen nach 11 bis 30 Sekunden, 4 brachen nach 30 bis 55 Sekunden mit `database is locked` ab. Eine Datei entstand dann nicht. Das ist ein lauter Fehler, den ein Skript am Rückgabewert erkennt, und damit etwas anderes als eine Kopie, die still falsch ist.

## Was das für Ihr Backup heißt

Prüfen Sie, wie Ihre Sicherung heute an die Datenbank kommt. Kopiert ein Skript, ein NAS-Auftrag oder ein Backup-Programm den Datenordner eines laufenden Containers, ist das der Fall, der im Test am schlechtesten abschnitt. Das gilt auch für Anwendungen, bei denen die Datenbank nicht auffällt: Viele kleine Dienste legen ihre Daten in einer SQLite-Datei im Datenordner ab.

Der zuverlässige Weg ist ein Dump vor der Dateisicherung. Das Backup-Programm sichert dann die Dump-Datei, und der Datenordner der Datenbank kann aus der Sicherung herausbleiben. Wie Sie das mit cron automatisieren, zeigt [MySQL und PostgreSQL Backup automatisieren](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud). Passt ein Dump nicht, pausieren oder stoppen Sie den Container für die Dauer der Kopie.

## Typische Fehler

**MariaDB: `InnoDB: Plugin initialization aborted with error Data structure corruption`**

Alle 30 langsamen Live-Kopien starteten nicht. Bei zehn wurde das Protokoll gesichert, neun davon zeigten diese Meldung, gefolgt von `Unknown/unsupported storage engine: InnoDB` und `Aborting`. Die Datendateien und das Protokoll stammen aus verschiedenen Momenten. Nehmen Sie eine ältere Sicherung oder einen Dump. Der Hinweis auf `innodb_force_recovery` im Protokoll dient nur dazu, noch lesbare Daten zu retten, nicht zum Weiterbetrieb.

**MariaDB: `` Table `bank`.`buchung` is corrupted. Please drop the table and recreate. ``**

Die Kopie startet, im Protokoll steht aber `log sequence number … is in the future`. Die Kopie ist für den Weiterbetrieb unbrauchbar. Nehmen Sie eine andere Sicherung.

**PostgreSQL: `PANIC: could not locate a valid checkpoint record`**

Der Kopie fehlt das Stück Protokoll, mit dem der Start beginnen müsste. Verwenden Sie eine andere Sicherung.

**PostgreSQL: `heap tuple … lacks matching index tuple within index "konto_pkey"`**

Diese Meldung stand im Protokoll der Kopie, als `pg_amcheck` sie prüfte. Unter den Werkzeugen der Datenbank war das das einzige Zeichen, `pg_dump` las dieselbe Kopie ohne Fehler. Aufgefallen wäre sie sonst nur über eine eigene Kontrollabfrage. Trauen Sie einer solchen Kopie nicht, auch wenn Abfragen Ergebnisse liefern.

**SQLite: `database disk image is malformed`**

Die Datei wurde kopiert, während die Anwendung schrieb. Ziehen Sie die Sicherung künftig mit `VACUUM INTO` oder bei gestoppter Anwendung.

**SQLite: `database is locked` bei `VACUUM INTO`**

Die Anwendung hält die Datei durchgehend zum Schreiben gesperrt. Wiederholen Sie den Befehl, pausieren Sie die Anwendung für die Dauer der Sicherung oder stellen Sie die Datenbank auf den Modus WAL um, wenn die Anwendung das erlaubt.

**`rsync` meldet `file has vanished` und endet mit 24**

Die Datenbank lief während der Kopie. Die Kopie kann in Ordnung sein, verlassen können Sie sich darauf nicht.

## Häufige Fragen

### Warum ging die schnelle Kopie bei PostgreSQL immer gut?

Weil sie meist nach 0,4 Sekunden fertig war und PostgreSQL nach einem Prüfpunkt ganze Seiten ins Protokoll schreibt. Die PostgreSQL-Dokumentation verlangt für eine einfache Dateikopie einen gestoppten Server. Für den laufenden Betrieb nennt sie einen gleichzeitigen Snapshot des Dateisystems oder eine Sicherung mit kontinuierlicher Archivierung.

## Fazit

Eine Ordnerkopie im laufenden Betrieb ist Glückssache, und das Glück hängt an der Dauer der Kopie. Schon bei 20 MB pro Sekunde war bei MariaDB und SQLite jede Kopie verloren, und der Kopierbefehl merkte davon nichts. Dump, Pause und Stopp lieferten in 112 Versuchen 108 gute Kopien und keine einzige schlechte. Entscheidend ist der letzte Schritt: Eine Sicherung, die nie gestartet und nachgerechnet wurde, ist eine Vermutung. Im nächsten Teil der Reihe läuft die Platte voll.

## Weiterführende Anleitungen und Quellen

- [Ernstfall Teil 11: Zertifikat abgelaufen, Uhr falsch](https://s-edv.com/anleitungen/ernstfall-zertifikat-abgelaufen-uhr-falsch)
- [Ernstfall Teil 12: SQLite auf der Netzfreigabe](https://s-edv.com/anleitungen/ernstfall-sqlite-netzfreigabe-smb-nobrl)
- [Ernstfall Teil 13: Harter Abbruch](https://s-edv.com/anleitungen/ernstfall-harter-abbruch-kill-datenbank-redis)
- [Ernstfall Teil 2: Platte voll](https://s-edv.com/anleitungen/ernstfall-platte-voll-docker-dienste-datenbanken)
- [Ernstfall Teil 3: Update zurückdrehen](https://s-edv.com/anleitungen/ernstfall-update-zurueckdrehen-downgrade-docker)
- [Ernstfall Teil 4: PostgreSQL 16 auf 18 per Tag](https://s-edv.com/anleitungen/ernstfall-postgresql-16-auf-18-tag-upgrade)
- [Ernstfall Teil 5: Container-Logs fluten die Platte](https://s-edv.com/anleitungen/ernstfall-docker-logs-platte-voll-max-size)
- [Ernstfall Teil 6: down -v, prune, rm](https://s-edv.com/anleitungen/ernstfall-docker-volumes-geloescht-down-v-prune)
- [Ernstfall Teil 7: Angreifer kennt das Backup-Passwort](https://s-edv.com/anleitungen/ernstfall-ransomware-restic-append-only-angriff)
- [Ernstfall Teil 8: Restore-Rennen](https://s-edv.com/anleitungen/ernstfall-restore-rennen-restic-borgbackup-kopia)
- [Ernstfall Teil 9: Registry weg, Internet weg](https://s-edv.com/anleitungen/ernstfall-docker-registry-internet-weg-offline-start)
- [Ernstfall Teil 10: Admin-Passwort weg](https://s-edv.com/anleitungen/ernstfall-admin-passwort-vergessen-zuruecksetzen-docker)
- [PostgreSQL pg_dump und pg_restore](https://s-edv.com/anleitungen/postgresql-pg-dump-pg-restore-backup-migration)
- [MySQL und PostgreSQL Backup automatisieren mit cron](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud)
- [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
- [Docker Compose absichern](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root)
- [PostgreSQL: Sicherung auf Dateisystemebene](https://www.postgresql.org/docs/current/backup-file.html)
- [PostgreSQL: pg_amcheck](https://www.postgresql.org/docs/current/app-pgamcheck.html)
- [MariaDB: mariadb-dump](https://mariadb.com/kb/en/mariadb-dump/)
- [SQLite: How To Corrupt An SQLite Database File](https://www.sqlite.org/howtocorrupt.html)
- [SQLite: Online Backup API](https://www.sqlite.org/backup.html)
- [SQLite: VACUUM INTO](https://www.sqlite.org/lang_vacuum.html)
