---
title: "Harter Abbruch: Was Datenbanken und Redis nach kill -9 verlieren"
date: 2026-11-15T19:11:29+01:00
modified: 2026-11-15T19:13:01+01:00
category: datenbanken
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/ernstfall-harter-abbruch-kill-datenbank-redis
keywords:
  - Ernstfall
  - Redis
  - PostgreSQL
  - MariaDB
  - SQLite
  - Docker
  - Datenverlust
  - OOM-Killer
reading_time: 9
ai_notice: "Mit KI erstellt – redaktionelle Prüfung ausstehend"
---

# Harter Abbruch: Was Datenbanken und Redis nach kill -9 verlieren

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

Ein Container wird mitten im Schreiben hart beendet: Der OOM-Killer greift, jemand tippt `docker kill`, oder das Programm stürzt ab. Was ist danach noch da? Für diese Anleitung schrieben PostgreSQL, MariaDB, SQLite in zwei Betriebsarten und Redis in drei Einstellungen fortlaufend Einträge, bis der Container mit SIGKILL beendet oder regulär gestoppt wurde. Danach wurde gezählt, wie viele bestätigte Einträge den Neustart überlebt haben.

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

**Kurzfassung:** PostgreSQL, MariaDB und SQLite verloren in keinem Durchgang einen bestätigten Eintrag, die Prüfungen auf Beschädigung blieben sauber. Redis mit Voreinstellung verlor beim harten Abbruch jedes Mal alle Einträge seit dem letzten Abbild, bis zu 3.618 bestätigte Schlüssel. Mit eingeschaltetem Append-only-File (AOF) blieb alles erhalten. Ein regulärer Stopp sicherte bei allen Diensten alles. Beide Datenbanken spielten nach dem harten Abbruch beim Start ihr Protokoll nach, PostgreSQL brauchte dafür messbar länger, bei MariaDB zeigte sich kein klarer Unterschied.

## Was Sie brauchen

- [ ] Einen Linux-Server mit Docker, siehe [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Zugriff auf die Compose-Datei der Dienste, die Redis, PostgreSQL, MariaDB oder SQLite nutzen.

## Schritt 1: Redis-Persistenz prüfen

Viele Compose-Dateien starten Redis ohne eigene Konfiguration. Fragen Sie den laufenden Redis, wann er auf die Platte schreibt:

```bash
$ docker compose exec -T redis redis-cli CONFIG GET save
```

Ausgabe:

```plaintext
save
3600 1 300 100 60 10000
```

Das ist die Voreinstellung des offiziellen Images: ein Abbild der Daten nach einer Stunde mit mindestens einer Änderung, nach fünf Minuten mit 100 Änderungen oder nach einer Minute mit 10.000 Änderungen. Was zwischen zwei Abbildern geschrieben wird, liegt nur im Arbeitsspeicher.

> **Prüfen:** **Verifizieren:** Die Ausgabe zeigt die Regeln, nach denen Ihr Redis sichert. Ob Ihnen das reicht, hängt davon ab, wofür der Dienst Redis nutzt: als reinen Cache oder als Speicher für Sitzungen, Warteschlangen oder Zähler.

## Schritt 2: Append-only-File einschalten

Mit dem Append-only-File schreibt Redis jede Änderung in ein Protokoll und spielt es beim Start ein. In der Compose-Datei reicht eine Zeile:

Datei: `compose.yaml`

```yaml
services:
  redis:
    image: redis:8.10.3
    command: redis-server --appendonly yes --appendfsync everysec
    volumes:
      - ./redis:/data
```

`everysec` übergibt das Protokoll einmal pro Sekunde mit fsync an die Platte, `always` bei jedem Schreibvorgang. Danach den Dienst neu erstellen:

```bash
$ docker compose up -d redis
```

> Achtung bei vorhandenen Daten: Im Test startete Redis jedes Mal leer. Liegen in Ihrem Redis schon Daten, rät die Redis-Dokumentation, zuerst die Datei `dump.rdb` zu sichern, AOF dann im laufenden Betrieb mit `redis-cli CONFIG SET appendonly yes` einzuschalten und abzuwarten, bis `redis-cli INFO persistence` die Werte `aof_rewrite_in_progress:0`, `aof_rewrite_scheduled:0` und `aof_last_bgrewrite_status:ok` zeigt. Erst dann die Compose-Datei ändern und nach dem Neustart mit `DBSIZE` vergleichen. Sonst kann der Neustart laut Dokumentation Daten kosten.

> **Prüfen:** **Verifizieren:** Nach `docker compose stop redis` und `docker compose start redis` sind die Schlüssel noch da: `docker compose exec redis redis-cli DBSIZE` zeigt dieselbe Zahl wie vorher.

## Schritt 3: Nach einem Absturz prüfen

Nach einem harten Abbruch prüfen Sie die Datenbanken auf Beschädigung. Für PostgreSQL gibt es `pg_amcheck`. Es listet gefundene Beschädigungen auf, im Test endete es nach jedem Abbruch mit Rückgabewert 0. `--install-missing` legt dafür die Erweiterung amcheck in der Datenbank an.

```bash
$ docker compose exec db pg_amcheck -U postgres -d app --install-missing --heapallindexed; echo $?
```

Für MariaDB prüft `CHECK TABLE` eine Tabelle, in der letzten Spalte muss `OK` stehen:

```bash
$ docker compose exec db sh -c 'mariadb -uroot -p"$MARIADB_ROOT_PASSWORD" app -e "CHECK TABLE t"'
```

Für SQLite liefert die eingebaute Prüfung bei einer heilen Datei genau ein `ok`. Im Test lief `sqlite3` im Container, in dem auch die Datei lag. Auf dem Host muss es dafür installiert sein:

```bash
$ sqlite3 /pfad/zur/datenbank.db "PRAGMA integrity_check"
```

Ausgabe:

```plaintext
ok
```

> **Prüfen:** **Verifizieren:** Alle drei Prüfungen melden keinen Fehler. In den Testläufen war das nach jedem harten Abbruch so.

## So wurde gemessen

Getestet mit PostgreSQL 18.7, MariaDB 11.8.9 (InnoDB), SQLite 3.53.4 im Modus WAL und im Modus mit Rollback-Journal und Redis 8.10.3 in drei Einstellungen: Voreinstellung ohne AOF, AOF mit `everysec` und AOF mit `always`. Alle liefen in eigenen Containern unter Docker 29.8.2, die Daten lagen in Ordnern auf der Platte des Hosts.

Ein Schreiber legte fortlaufend Einträge an, jeweils einen pro Transaktion, und notierte jede ID erst, nachdem die Datenbank den Eintrag bestätigt hatte. Nach 15 Sekunden wurde der Container entweder mit `docker compose kill -s KILL` beendet, das entspricht einem OOM-Kill, der den Hauptprozess trifft, oder mit `docker compose stop` regulär gestoppt. Der Schreiber beendete sich vor dem Neustart, damit er nichts mehr nachschieben konnte. Danach startete der Container neu, und für jede einzelne bestätigte ID wurde nachgesehen, ob sie in der Datenbank steht, dazu liefen die Prüfungen aus Schritt 3. Jede Kombination lief fünfmal.

Der Schreiber für PostgreSQL, MariaDB und Redis lief in einem eigenen Container, hier gekürzt:

Datei: `schreib.sh`

```bash
i=0; : > /b/$d.ok
while [ ! -f /b/stopp ]; do i=$((i+1))
  case $d in
   pg)    psql -h pg -U postgres -d probe -qAtc "INSERT INTO t(id,v) VALUES($i,repeat('x',2000))" ;;
   maria) mariadb -h maria -uroot -p"$PW" probe -e "INSERT INTO t(id,v) VALUES($i,REPEAT('x',2000))" ;;
   redis-*) [ "$(redis-cli -h $d SET k$i 1)" = OK ] ;;
  esac && echo $i >> /b/$d.ok
done
```

Für SQLite lief eine Schleife mit `sqlite3 /d/db "INSERT INTO t VALUES($i, hex(randomblob(1000)))"` im SQLite-Container selbst, weil SQLite keine Netzverbindung kennt. Nach dem Neustart wurden alle vorhandenen IDs ausgelesen (`SELECT id FROM t` beziehungsweise `redis-cli --scan`) und mit der Liste der bestätigten verglichen.

Das Betriebssystem lief bei diesem Versuch weiter. Was ein Prozess vor dem Abbruch schon an den Kernel übergeben hatte, blieb also erhalten, auch wenn es noch nicht auf der Platte stand. Der Versuch bildet einen abstürzenden oder abgeschossenen Prozess ab.

## Ergebnis 1: Nur Redis ohne AOF verliert Daten

![Diagramm: sieben Speicherarten nach docker compose kill und docker compose stop, nur Redis mit Voreinstellung verliert beim harten Abbruch bestätigte Einträge](https://s-edv.com/uploads/2026/11/199a27a037ef457267250af41c9df294b9ffb44850baff3e0fd23a884ac8c96f-1024.png)
*Sieben Speicherarten nach kill und nach stop: nur Redis mit Voreinstellung verliert beim harten Abbruch bestätigte Einträge*

Bei PostgreSQL, MariaDB und beiden SQLite-Varianten stand nach jedem Neustart jede bestätigte ID in der Datenbank. In 11 der 40 Durchgänge dieser vier Varianten, nach kill wie nach stop, war genau ein Eintrag mehr da: Die Datenbank hatte ihn noch gespeichert, die Bestätigung erreichte den Schreiber aber nicht mehr. Wer nach einem Absturz abgleicht, muss mit solchen Einträgen rechnen. `pg_amcheck`, `CHECK TABLE` und `PRAGMA integrity_check` fanden in keinem Durchgang einen Fehler.

Redis mit Voreinstellung war nach dem harten Abbruch jedes Mal leer. In 15 Sekunden kamen 3.402 bis 3.618 bestätigte Schlüssel zusammen, aber jede Regel verlangt mindestens eine Minute seit dem letzten Abbild. Nach 15 Sekunden konnte keine greifen, Redis hatte nichts davon auf die Platte geschrieben. Mit AOF, ob `everysec` oder `always`, fehlte kein bestätigter Schlüssel. Bei diesem Versuch verhalten sich beide gleich, der Unterschied betrifft den Ausfall des ganzen Rechners.

## Ergebnis 2: Regulär gestoppt ist alles da

Mit `docker compose stop` bekam jeder Dienst sein Stoppsignal und Zeit zum Aufräumen. Alle Container waren nach weniger als einer Sekunde beendet, und alle sieben Varianten hatten danach jeden bestätigten Eintrag, auch Redis ohne AOF: Beim regulären Herunterfahren schreibt Redis ein Abbild, solange save-Regeln gesetzt sind wie in der Voreinstellung. Der Unterschied zwischen stop und kill entscheidet bei Redis mit Voreinstellung also über alles oder nichts.

Das Append-only-File kostet Schreibleistung. Mit `always` legte derselbe Schreiber in 15 Sekunden höchstens 1.294 Schlüssel an, mit `everysec` bis zu 3.665. Der Schreiber startete für jeden Schlüssel ein eigenes `redis-cli`, die absoluten Zahlen sagen deshalb wenig über Redis selbst, das Verhältnis aber zeigt den Preis von `always`.

## Ergebnis 3: Nach dem Abbruch spielt die Datenbank ihr Protokoll nach

![Diagramm: Zeit bis PostgreSQL und MariaDB nach kill und nach stop wieder Verbindungen annehmen](https://s-edv.com/uploads/2026/11/6b3328fe2915b7b22dc5fc615724f4099a81b730c5b94aa21b1bc91745ecd4a0-1024.png)
*Zeit bis PostgreSQL und MariaDB nach kill und nach stop wieder Verbindungen annehmen*

PostgreSQL nahm nach einem regulären Stopp nach 0,12 bis 0,13 Sekunden wieder Verbindungen an, nach dem harten Abbruch nach 0,45 bis 0,76 Sekunden. Bei MariaDB waren es 1,3 bis 2,8 gegen 1,6 bis 2,2 Sekunden, im Median 1,9 und 1,9 Sekunden, also kein klarer Unterschied. Abgefragt wurde alle 0,2 Sekunden mit `pg_isready` beziehungsweise `mariadb-admin ping`. Nach dem harten Abbruch meldeten beide eine Wiederherstellung. PostgreSQL:

Ausgabe:

```plaintext
LOG:  database system was not properly shut down; automatic recovery in progress
LOG:  redo starts at 0/1BC6F20
LOG:  redo done at 0/1CD5058
LOG:  database system is ready to accept connections
```

MariaDB mit InnoDB:

Ausgabe:

```plaintext
[Note] InnoDB: Starting crash recovery from checkpoint LSN=45418
[Note] InnoDB: To recover: 288 pages
[Note] mariadbd: ready for connections.
```

Bei Datenbanken dieser Größe geht es um Sekunden. Ein [Healthcheck](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root), der zu früh aufgibt, kann einen Dienst nach einem Absturz deshalb als defekt melden, obwohl er nur aufräumt.

## Was das für Ihren Server heißt

Bei PostgreSQL, MariaDB mit InnoDB und SQLite müssen Sie für einen abstürzenden Prozess nichts einstellen, die Voreinstellungen haben im Test gehalten. Prüfen Sie nach einem Absturz trotzdem wie in Schritt 3, bevor Sie weiterarbeiten.

Bei Redis kommt es darauf an, was darin liegt. Als reiner Cache ist ein Verlust egal, die Anwendung füllt ihn neu. Liegen dort Sitzungen, Warteschlangen oder Zähler, schalten Sie AOF ein wie in Schritt 2. Laut Redis-Dokumentation kann `everysec` bei einem Ausfall des ganzen Rechners bis zu einer Sekunde an Schreibvorgängen verlieren, `always` ist sicherer, aber langsamer.

Und wenn Sie Dienste beenden: lieber `docker compose stop` oder `down` als `kill`. Ein OOM-Killer fragt allerdings nicht. Gegen ihn hilft ein Speicherlimit, das zum Dienst passt, und eine Sicherung, wie sie [Teil 1 der Reihe](https://s-edv.com/anleitungen/ernstfall-datenbank-live-kopiert-backup-kaputt) zeigt.

## Typische Fehler

**Redis nach Neustart leer, `DBSIZE` zeigt 0**

Redis lief ohne AOF und wurde hart beendet, bevor ein Abbild entstand. Daten aus dem Arbeitsspeicher sind weg. Für die Zukunft AOF einschalten wie in Schritt 2.

**Container-Status `Exited (137)`**

Der Prozess wurde mit SIGKILL beendet, durch `docker kill` oder den OOM-Killer.

**Datenbank nimmt nach Absturz kurz keine Verbindungen an**

Sie spielt ihr Protokoll nach. Im Log von MariaDB steht dann `InnoDB: Starting crash recovery`, warten Sie auf `ready for connections`.

## Häufige Fragen

### Warum war manchmal ein Eintrag mehr da als bestätigt?

Die Datenbank hatte den Eintrag dauerhaft gespeichert, der Prozess des Schreibers erhielt die Bestätigung aber nicht mehr, weil er vorher beendet wurde. Das kam auch beim regulären Stopp vor, denn auch dabei endet der Schreiber mitten in seinem letzten Aufruf. Das ist kein Fehler, sondern zeigt, dass eine fehlende Bestätigung nicht „nicht gespeichert“ bedeutet.

### Warum hat Redis beim regulären Stopp nichts verloren?

Beim Herunterfahren nach SIGTERM schreibt Redis ein Abbild der Daten, auch ohne AOF. Beim harten Abbruch fehlt diese Gelegenheit.

## Fazit

Die klassischen Datenbanken überstanden den harten Abbruch in jedem Durchgang ohne Verlust und ohne Beschädigung, PostgreSQL brauchte nur beim Start etwas länger. Die Lücke liegt bei Redis mit Voreinstellung: Ein OOM-Kill oder `docker kill` löscht alles seit dem letzten Abbild, und das kann bei wenig Schreiblast eine Stunde zurückliegen. Eine Zeile in der Compose-Datei schließt sie. Damit endet die Reihe „Ernstfall“. Alle Teile stehen unten in der Liste.

## Weiterführende Anleitungen und Quellen

- [Ernstfall Teil 1: Datenbank im laufenden Betrieb kopiert](https://s-edv.com/anleitungen/ernstfall-datenbank-live-kopiert-backup-kaputt)
- [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)
- [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)
- [Redis mit Docker installieren](https://s-edv.com/anleitungen/redis-docker-in-memory-store)
- [Valkey mit Docker als Redis-Ersatz](https://s-edv.com/anleitungen/valkey-docker-redis-alternative)
- [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
- [Redis: Persistence](https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/)
- [PostgreSQL: pg_amcheck](https://www.postgresql.org/docs/18/app-pgamcheck.html)
- [MariaDB: CHECK TABLE](https://mariadb.com/docs/server/reference/sql-statements/table-statements/check-table)
- [SQLite: PRAGMA integrity_check](https://www.sqlite.org/pragma.html#pragma_integrity_check)
