---
title: "Container-Logs fluten die Platte: Was passiert und wie Sie es verhindern"
date: 2026-11-15T16:47:20+01:00
modified: 2026-11-15T19:12:20+01:00
category: docker
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/ernstfall-docker-logs-platte-voll-max-size
keywords:
  - Ernstfall
  - Docker
  - Logging
  - Docker Compose
  - Speicherplatz
  - json-file
  - Troubleshooting
reading_time: 8
ai_notice: "Mit KI erstellt – redaktionelle Prüfung ausstehend"
---

# Container-Logs fluten die Platte: Was passiert und wie Sie es verhindern

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

Docker hebt jede Zeile auf, die ein Container ausgibt. Ohne Grenze wächst die Logdatei, bis die Platte voll ist, und dann trifft es nicht nur den Container, der zu viel redet, sondern alle Container auf diesem Docker-Host. Für diese Anleitung wurde genau das herbeigeführt: ein Container, der ununterbrochen schreibt, in einem Docker-Daemon, dessen Datenverzeichnis nur 1,5 GB Platz hatte. Gemessen wurde, wie schnell es geht, was danach noch funktioniert, wie Sie zurückkommen und welche Einstellung das verhindert.

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

**Kurzfassung:** Ein Container ohne Log-Grenze füllte 1,5 GB Docker-Speicher in 11 bis 13 Sekunden. Laufende Container liefen weiter, aber kein neuer Container startete mehr, und ein Neustart ließ den betroffenen Container aus. Eine Logdatei mit `truncate` zu leeren gab den Platz in unter einer Sekunde frei. Mit `max-size: 10m` und `max-file: 3` belegte dieselbe Ausgabe 27 statt 208 MB. Die Grenze in der `daemon.json` gilt aber nur für Container, die danach neu angelegt werden.

## 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).
- [ ] Root-Rechte auf dem Host, weil die Logdateien unter `/var/lib/docker` liegen.
- [ ] Für Schritt 3 eine kurze Wartungspause: Docker wird neu gestartet, und die Container werden neu angelegt.

## Schritt 1: Den Platzfresser finden

Ist die Platte voll, suchen Sie zuerst den größten Container-Ordner. Jeder Container hat dort ein eigenes Verzeichnis, in dem auch seine Logdatei liegt:

```bash
$ sudo du -sm /var/lib/docker/containers/* | sort -rn | head -3
```

Ausgabe:

```plaintext
1524	/var/lib/docker/containers/661af9e5be35…
1	/var/lib/docker/containers/e8813c90f6dd…
```

Den Namen zur ID zeigt `docker ps -a --no-trunc`. Den genauen Pfad der Logdatei liefert Docker selbst:

```bash
$ docker inspect -f '{{.LogPath}}' CONTAINER
```

> **Prüfen:** **Verifizieren:** Der Pfad endet auf `-json.log` und liegt in dem Ordner, den `du` als größten gemeldet hat.

## Schritt 2: Logdatei leeren und den Container bremsen

Löschen Sie die Logdatei nicht mit `rm`: Docker hält sie offen, der Platz würde erst frei, wenn Docker sie schließt. Leeren Sie sie stattdessen, so wie im Test:

```bash
$ sudo truncate -s 0 "$(docker inspect -f '{{.LogPath}}' CONTAINER)"
```

Im Test war der Platz danach in 0,4 Sekunden wieder frei. Der Container schrieb aber weiter und hatte bis zum Stopp schon wieder 260 bis 320 MB belegt. Halten Sie ihn deshalb an, bis die Grenze aus Schritt 3 gesetzt ist:

```bash
$ docker stop CONTAINER
```

Ein Container ohne `restart`-Regel, der während der vollen Platte neu gestartet wurde, lief im Test danach nicht von selbst wieder an. Starten Sie solche Container von Hand:

```bash
$ docker start NACHBAR
```

> **Prüfen:** **Verifizieren:** `df -h /var/lib/docker` zeigt wieder freien Platz, und `docker ps` listet alle Container, die laufen sollen.

## Schritt 3: Grenze für alle Container setzen

Die Grenze gilt dauerhaft, wenn Sie sie in `/etc/docker/daemon.json` eintragen. Gibt es die Datei schon, ergänzen Sie nur die beiden Einträge:

Datei: `/etc/docker/daemon.json`

```json
{
  "log-driver": "json-file",
  "log-opts": {"max-size": "10m", "max-file": "3"}
}
```

Danach starten Sie Docker neu. Im Test geschah das durch einen Neustart des Docker-Daemons. Auf einem normalen Host stoppt dieser Befehl alle Container und startet sie je nach `restart`-Regel wieder:

```bash
$ sudo systemctl restart docker
```

Jetzt kommt der Teil, an dem es in der Praxis meist hängt: Bestehende Container behalten ihre alte Einstellung. Im Test lief ein Container, der vor der Änderung angelegt worden war, nach `docker compose up -d` weiter ohne Grenze, sein Ordner wuchs auf 928 MB. Erst ein neu angelegter Container übernahm die Grenze. Legen Sie deshalb jedes Projekt neu an:

```bash
$ docker compose up -d --force-recreate
```

Ein Projekt, das Sie lieber einzeln regeln, bekommt die Grenze direkt in der `compose.yaml`. Compose legt den Container beim nächsten `up -d` dann von selbst neu an:

Datei: `compose.yaml`

```yaml
services:
  app:
    image: alpine:3.24.4
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"
```

> **Prüfen:** **Verifizieren:** Für jeden Container zeigt `docker inspect` die Grenze:
>
> ```bash
> $ docker inspect -f '{{.HostConfig.LogConfig.Type}} {{.HostConfig.LogConfig.Config}}' CONTAINER
> ```
>
> Ausgabe:
>
> ```plaintext
> json-file map[max-file:3 max-size:10m]
> ```
>
> Steht beim Treiber `json-file` dort `map[]`, wurde der Container noch nicht neu angelegt. Beim Treiber `local` zeigt Docker auch mit seiner eingebauten Grenze `map[]`.

## So wurde gemessen

Getestet mit Docker 29.9.3 und Docker Compose 5.7.1 in einem eigenen Docker-Daemon, der selbst in einem Container lief. Sein Datenverzeichnis lag auf einer 1,5 GB großen RAM-Disk, voll lief also nur das Docker-Datenverzeichnis, nicht das System des Testrechners. Der laute Container war Alpine 3.24.4 und gab mit `yes` ohne Pause dieselbe Logzeile von 148 Bytes aus, wie sie ein Webdienst schreiben könnte. Daneben lief ein zweiter Container, der jede Sekunde eine Zeile in ein eigenes Volume schrieb.

Für den Vergleich der Einstellungen gab ein Container genau eine Million Zeilen aus, 141 MB, jede Einstellung dreimal. Danach wurde der Ordner des Containers gemessen und gezählt, wie viele Zeilen `docker logs` noch lieferte. Für den Ernstfall füllte der laute Container dreimal die ganze Platte. Jedes Mal wurde geprüft, was noch funktionierte, dann die Logdatei geleert. Die Wirkung der `daemon.json` wurde in einem eigenen Lauf mit freier Platte gemessen.

## Ergebnis 1: Was die Einstellungen kosten

![Balkendiagramm: Platzbedarf von einer Million Logzeilen je Log-Einstellung, json-file ohne Grenze 208 MB, mit max-size 27 MB](https://s-edv.com/uploads/2026/11/8ca6b5af39efbfdd13004b0f3e6662bb41b459603749fe860e09b6b81edaa24c-1024.png)
*Platzbedarf von einer Million Logzeilen je Einstellung, dazu die Zahl der noch lesbaren Zeilen*

| Einstellung | auf der Platte | mit `docker logs` lesbar |
| --- | --- | --- |
| `json-file` ohne Grenze (Vorgabe) | 208 MB | 1.000.000 Zeilen |
| `json-file`, 10 MB × 3 | 27 MB | 127.986 Zeilen |
| `json-file`, 10 MB × 3, `compress: "true"` | 8 MB | 127.985 Zeilen |
| `local` ohne eigene Angaben | 10 MB | 523.372 Zeilen |
| `local`, 10 MB × 3 | 7 MB | 147.715 Zeilen |
| `none` | kein Log | 0 Zeilen |

Ohne Grenze belegten 141 MB Ausgabe 208 MB, weil `json-file` zu jeder Zeile Zeitstempel und Herkunft als JSON speichert. Mit 10 MB × 3 blieben 27 MB, dafür waren nur noch die letzten 13 Prozent der Zeilen lesbar. Die Grenze schützt die Platte und kostet Verlauf. Wer Logs länger braucht, schickt sie an eine zentrale Stelle, siehe [Logs zentralisieren mit Grafana Loki](https://s-edv.com/anleitungen/logs-zentralisieren-grafana-loki).

Am sparsamsten war der Treiber `local`. Laut Docker-Dokumentation komprimiert er von sich aus und begrenzt ohne eigene Angaben auf fünf Dateien zu 20 MB. Im Test hielt er mit 10 MB rund die Hälfte aller Zeilen lesbar. Seine Dateien sind laut Dokumentation allein für den Docker-Daemon gedacht, nicht für Werkzeuge, die Logdateien direkt lesen.

## Ergebnis 2: Was bei voller Platte noch geht

![Übersicht: Bei voller Platte laufen bestehende Container weiter, docker exec, neue Container und Neustarts scheitern, nach truncate geht alles wieder](https://s-edv.com/uploads/2026/11/01e6908e5a8c6354b9cf87cab875518ea2eb46acd0da0cd80296f42631d7f32f-1024.png)
*Bei voller Platte laufen bestehende Container weiter, neue Container, docker exec und Neustarts scheitern, nach dem Leeren der Logdatei geht alles wieder*

In allen drei Durchgängen war die Platte nach 11 bis 13 Sekunden voll, und in allen drei zeigte sich dasselbe Bild. Die laufenden Container liefen weiter, auch der laute selbst. `docker ps` und `docker logs` funktionierten. Docker protokollierte für die verlorenen Zeilen Meldungen wie diese:

Ausgabe:

```plaintext
level=error msg="Error writing log message" driver=json-file error="error writing log entry: write /var/lib/docker/containers/…-json.log: no space left on device"
```

Alles, was Docker auf die Platte schreiben muss, scheiterte dagegen. `docker exec` und `docker run` brachen mit `no space left on device` ab. Am tückischsten war der Neustart: Der Nachbar-Container wurde gestoppt, konnte aber nicht wieder starten und blieb aus. Bei einem Neustart des ganzen Servers ist nach diesem Ergebnis mit Containern zu rechnen, die nicht anlaufen.

Der Nachbar schrieb jede Sekunde eine kurze Zeile in sein Volume. Sein Journal zeigt in zwei von drei Durchgängen erst beim Neustart eine Lücke, die kurzen Zeilen kamen also bis dahin noch an. Wie sich Datenbanken bei voller Platte verhalten, die mehr Platz brauchen, zeigt Teil 2 der Reihe.

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

Setzen Sie die Grenze in der `daemon.json`, bevor es nötig wird, und legen Sie danach alle Projekte einmal mit `--force-recreate` neu an. Die Vorgabe von Docker ist keine Grenze. Ein einzelner Container mit Fehlerschleife reicht, um Docker auf dem ganzen Host lahmzulegen, und auf einer großen Platte dauert es nur länger, bis es soweit ist.

Prüfen Sie außerdem neue Projekte: Bringt eine `compose.yaml` eigene `logging`-Optionen oder einen anderen Treiber mit, gelten laut Docker-Dokumentation diese statt der Vorgabe aus der `daemon.json`. Der Befehl aus dem Prüfkasten in Schritt 3 zeigt für jeden Container, was tatsächlich gilt.

## Typische Fehler

**`Error response from daemon: write /var/lib/docker/containerd/daemon/io.containerd.metadata.v1.bolt/meta.db: no space left on device`**

So endete im Test jeder Versuch, bei voller Platte einen neuen Container zu starten. Schaffen Sie zuerst Platz wie in Schritt 2.

**`Cannot restart container …: write /var/lib/docker/containers/…/hosts: no space left on device`**

Der Container wurde gestoppt, aber nicht wieder gestartet. Er bleibt aus, bis Sie nach dem Aufräumen `docker start` ausführen.

**`OCI runtime exec failed: write /var/lib/docker/tmp/runc-process…: no space left on device`**

Auch `docker exec` braucht Platz auf der Platte. Arbeiten Sie vom Host aus mit `du` und `truncate`.

**Der Platz ist nach `rm` der Logdatei nicht frei**

Docker hält die Datei offen. Leeren Sie sie mit `truncate -s 0` wie in Schritt 2 oder stoppen Sie den Container.

**`docker inspect` zeigt trotz `daemon.json` `map[]`**

Der Container stammt von vor der Änderung. Legen Sie ihn mit `docker compose up -d --force-recreate` neu an.

## Häufige Fragen

### Wie groß sollte die Grenze sein?

Für einen kleinen Server reichen 10 MB × 3 je Container. Rechnen Sie mit der Zahl Ihrer Container: 30 Container mit dieser Grenze belegen höchstens rund 900 MB.

### Gehen beim Leeren mit truncate Logs verloren?

Ja, alles, was bis dahin in der Datei stand. Wer die Zeilen braucht, kopiert die Datei vorher, sofern dafür Platz ist.

## Fazit

Ein Container ohne Log-Grenze ist eine Zeitbombe mit kurzer Lunte: 1,5 GB waren in gut zehn Sekunden voll. Die laufenden Container machen weiter, aber Docker lässt sich kaum noch bedienen, und neu gestartete Container bleiben aus. Zurück geht es schnell mit `truncate`. Vorbeugen ist ein Eintrag in der `daemon.json` und ein Neuanlegen aller Container, denn ohne das bleibt die Grenze wirkungslos. Im nächsten Teil der Reihe nehmen Löschbefehle mehr mit als gedacht.

## 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 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 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)
- [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
- [Logs zentralisieren mit Grafana Loki](https://s-edv.com/anleitungen/logs-zentralisieren-grafana-loki)
- [Docker Compose absichern](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root)
- [Docker-Container automatisch aktualisieren](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud)
- [Docker: JSON File logging driver](https://docs.docker.com/engine/logging/drivers/json-file/)
- [Docker: Local file logging driver](https://docs.docker.com/engine/logging/drivers/local/)
- [Docker: Configure logging drivers](https://docs.docker.com/engine/logging/configure/)
- [Docker Compose: logging](https://docs.docker.com/reference/compose-file/services/#logging)
