Wie funktionieren Docker-Image-Schichten und Build-Caching?

Question

Accepted Answer

Docker-Images werden in **Schichten** erstellt — jede Dockerfile-Anweisung erstellt eine Schicht, und Docker **cached** Schichten, um Rebuilds zu beschleunigen. Das Verständnis von Schichten und Caching ist der Schlüssel zum Schreiben effizienter Dockerfiles, die schnell erstellt werden und kleinere Images erzeugen.

## Schichten — jede Anweisung fügt eine Schicht hinzu

```text
Each Dockerfile instruction (FROM, RUN, COPY, etc.) creates a read-only LAYER:
  → layers stack to form the image; layers are CACHED and SHARED between images
  → if a layer is unchanged, Docker REUSES the cached layer (skips rebuilding it)
→ Layer caching makes rebuilds fast — only changed layers (and those AFTER) rebuild.
```

## Die Caching-Regel (Reihenfolge ist wichtig)

```text
Docker caches layers IN ORDER. When an instruction's input changes, that layer AND
ALL layers AFTER IT are rebuilt (cache invalidated from that point down).
→ Put STABLE things EARLY and FREQUENTLY-CHANGING things LATE in the Dockerfile.
```

## Die klassische Optimierung: Abhängigkeiten vor Code

```dockerfile
# ✅ GOOD — copy dependency manifest first, install, THEN copy code
COPY package*.json ./
RUN npm install          # this layer is cached UNLESS package.json changes
COPY . .                 # code changes here don't invalidate the npm install layer

# ❌ BAD — copy everything first
COPY . .                 # ANY code change invalidates...
RUN npm install          # ...so npm install RE-RUNS on every code change (slow!)
```

Durch das Kopieren von Abhängigkeitsdateien und das Installieren **vor** dem Kopieren des restlichen Codes bleibt die (langsame) Abhängigkeits-Installationsschicht über Codeänderungen hinweg im Cache — eine enorm wichtige Optimierung, die Rebuilds schnell macht.

## Reduzieren der Image-Größe

```text
✓ Combine related RUN commands (fewer layers) and clean up in the SAME layer
  RUN apt-get update && apt-get install -y x && rm -rf /var/lib/apt/lists/*
✓ Use small base images (alpine, slim, distroless)
✓ Use .dockerignore to exclude unneeded files from the build context
✓ Use multi-stage builds (build artifacts in one stage, copy only what's needed)
```

## Warum es wichtig ist

Das Verständnis von Docker-Schichten und Build-Caching ist wichtig für das **Schreiben effizienter Dockerfiles**, die schnell erstellt werden und kleinere Images erzeugen, daher ist es wertvoll praktisches Wissen, das die Produktivität von Entwicklern und das Deployment erheblich beeinflusst.

Das grundlegende Konzept — jede Dockerfile-Anweisung erstellt eine gecachete, wiederverwendbare **Schicht**, und Docker **verwendet unveränderte gecachete Schichten wiederverwendet**, während geänderte Schichten und alles danach neu erstellt werden — erklärt, wie man Builds schnell macht.

Die **kritische Caching-Regel** (Cache wird von der ersten geänderten Anweisung abwärts ungültig, daher ist die Reihenfolge wichtig: stabile Dinge zuerst, häufig geänderte Dinge später) fährt die **einzelne wichtigste Optimierung**: Abhängigkeitsdateien kopieren und Abhängigkeiten installieren **vor** dem Kopieren des Anwendungscodes, sodass die langsame Abhängigkeits-Installationsschicht über die häufigen Codeänderungen hinweg im Cache bleibt (anstatt `npm install`/`pip install` bei jeder Codeänderung erneut auszuführen — ein Unterschied zwischen schnellen und schmerzhaft langsamen Rebuilds).

Das Verständnis dieses Musters allein verbessert die Build-Zeiten dramatisch, ein konstantes Anliegen der Developer Experience.

Das Kennen von Techniken zur **Reduzierung der Image-Größe** — Kombinieren von RUN-Befehlen mit Cleanup in derselben Schicht, Verwendung von kleinen Basis-Images (alpine, slim, distroless), `.dockerignore` zum Ausschluss unnötiger Dateien und Multi-Stage-Builds — erzeugt kleinere, schneller bereitzustellende Images (Reduzierung von Speicher, Transferzeit und Angriffsfläche).

Da Docker-Builds ständig stattfinden (in der Entwicklung und CI/CD) und langsame Builds oder übergewichtige Images die Produktivität und das Deployment beeinträchtigen, und da das Verständnis von Schichten und Caching es ermöglicht, Dockerfiles zu schreiben, die schnell erstellt werden und klein bleiben, ist das Verständnis von Docker-Schichten und Build-Caching — das Schichtenmodell, die reihenfolgeabhängige Caching-Regel, die Abhängigkeiten-vor-Code-Optimierung und Größenreduktions-Techniken — wertvoll, häufig angewendetes Wissen für effiziente Docker-Nutzung, eine Schlüsselfähigkeit, die diejenigen unterscheidet, die schnelle, schlanke Dockerfiles schreiben, von denen, die unter langsamen Builds und übergewichtigen Images leiden.