Wie funktioniert Docker unter der Haube?

Question

Accepted Answer

Docker nutzt Linux-Kernel-Funktionen — **Namespaces** (Isolation), **cgroups** (Ressourcenkontrolle) und **Union-Dateisysteme** (geschichtete Images) — um leichte Container zu erstellen. Das Verständnis der zugrunde liegenden Mechanismen erklärt, wie Container Isolation und Effizienz erreichen.

## Namespaces — Isolation

```text
Linux NAMESPACES isolate what a process can SEE — giving each container its own view:
  PID namespace     → its own process tree (container sees only its processes)
  NET namespace     → its own network interfaces, IPs, ports
  MNT namespace     → its own filesystem mounts
  UTS namespace     → its own hostname
  IPC, USER namespaces → isolated IPC, user/group ID mapping
→ Namespaces are WHY a container feels like a separate machine (isolated view),
  while actually sharing the host kernel.
```

## cgroups — Ressourcenkontrolle

```text
Control Groups (CGROUPS) LIMIT and account for resource usage per container:
  → CPU, memory, disk I/O, network bandwidth
→ cgroups are WHY you can set resource limits (-m, --cpus) — the kernel enforces them.
```

## Union-Dateisystem — geschichtete Images

```text
UNION/OVERLAY filesystems (overlayfs) stack image LAYERS:
  → read-only image layers + a thin writable container layer on top, merged into one view
  → layers are SHARED between images/containers (one copy on disk) → space-efficient
→ This is WHY images are layered, cached, and shareable, and containers are lightweight.
```

## Die Architektur

```text
Docker CLI → Docker DAEMON (dockerd) → containerd → runc (creates containers using
  namespaces + cgroups). The daemon manages images, containers, networks, volumes.
→ Containers are just ISOLATED PROCESSES on the host (not VMs) — using kernel features,
  sharing the host kernel → lightweight and fast.
```

## Warum es wichtig ist

Das Verständnis, wie Docker unter der Haube funktioniert, ist wertvollles Wissen auf Senior-Level, weil es **Container entmystifiziert** und ihre Schlüsseleigenschaften (Isolation, Effizienz, Ressourcenkontrolle) erklärt und damit die Fähigkeit vertieft, containerisierte Systeme zu verstehen, zu konfigurieren und Fehler darin zu beheben.

Die entscheidende Erkenntnis ist, dass **Container keine VMs sind — sie sind isolierte Prozesse auf dem Host**, die Linux-Kernel-Funktionen nutzen, weshalb sie leicht und schnell sind (sie teilen sich den Host-Kernel, anstatt separate Betriebssysteme auszuführen).

Das Verständnis der **drei Kernmechanismen** erklärt die Eigenschaften: **Namespaces** isolieren, was ein Prozess sehen kann (sein eigener Prozessbaum, Netzwerk, Dateisystem, Hostname — das ist der *Grund*, warum ein Container sich wie eine separate Maschine anfühlt, obwohl er den Kernel teilt), **cgroups** begrenzen und erfassen Ressourcennutzung (das ist der *Grund*, warum man CPU- und Speichergrenzen setzen kann — der Kernel erzwingt sie), und **Union/Overlay-Dateisysteme** stapeln Image-Schichten (das ist der *Grund*, warum Images geschichtet, gecacht und teilbar sind, und Container leicht sind — schreibgeschützte Schichten, die über mehrere Container hinweg geteilt werden, mit einer dünnen beschreibbaren Schicht oben).

Das Verständnis der **Architektur** (CLI → Daemon → containerd → runc, wobei der Daemon alles verwaltet) bietet das vollständige Bild, wie Docker funktioniert.

Dieses tiefere Verständnis hilft bei der Überlegung von Isolationsgrenzen (und ihren Sicherheitsimplikationen, da Container den Kernel teilen), erklärt Leistungs- und Effizienzmerkmale und unterstützt die Fehlerbehebung.

Da das Verständnis der zugrunde liegenden Mechanismen (Namespaces, cgroups, Union-Dateisysteme) erklärt, *warum* sich Container verhalten, wie sie es tun — ihre Isolation, Effizienz, Ressourcenkontrolle und die wichtige Tatsache, dass sie den Host-Kernel teilen (mit Sicherheitsimplikationen) — und die Fähigkeit vertieft, mit containerisierten Systemen sicher zu arbeiten, ist das Verständnis, wie Docker unter der Haube funktioniert, wertvollses Wissen auf Senior-Level, das einen von der Nutzung von Docker zu seinem echten Verständnis erhebt, ein Thema, das die für Senior-Positionen erwartete Tiefe widerspiegelt und nützlich ist, um Container-Verhalten, Sicherheitsgrenzen und Leistung zu verstehen.