Ein Container ist kein kleiner virtueller Rechner

Wer zum ersten Mal Docker verwendet, tippt einen Befehl ein, wartet ein paar Sekunden und bekommt eine Anwendung, die in ihrer eigenen Umgebung läuft. Die Anwendung bringt Bibliotheken und Werkzeuge mit, hat ein eigenes Dateisystem und sieht oft sogar eine eigene Netzwerkadresse.

Das sieht ein wenig nach einer virtuellen Maschine aus. Schließlich läuft da etwas „getrennt“ vom eigentlichen Rechner. Die Ähnlichkeit endet allerdings an einer ziemlich entscheidenden Stelle: Ein normaler Linux-Container startet keinen eigenen Linux-Kernel. Er nutzt den Kernel der Umgebung, in der die Container-Laufzeit arbeitet.

Ein Container ist damit auch nicht einfach ein Prozess mit einer besonders schicken Verpackung. Er ist eine kontrollierte Kombination aus Prozessen, isolierten Systemsichten, Ressourcenbegrenzungen und einem vorbereiteten Dateisystem. Die Unterscheidung lohnt sich. Wer sie versteht, kann später besser einschätzen, was Docker leistet, was ein Container gerade nicht schützt und weshalb Docker unter Windows häufig eine virtuelle Maschine benötigt.

Ich beginne bewusst mit Linux. Dort liegen die zentralen Mechanismen, die Docker, Podman und andere Container-Werkzeuge nutzen. Die Benutzeroberflächen unterscheiden sich. Die grundlegenden Kernel-Funktionen sind dagegen weitgehend dieselben.

↑ Nach oben

Was bedeutet Containerisierung technisch?

Ein gewöhnlicher Linux-Prozess hat einen Prozesskontext, offene Dateien, Speicherbereiche, Berechtigungen und einen Zugriff auf Betriebssystem-Schnittstellen. Der Linux-Kernel verwaltet all das. Mehrere Prozesse können dieselben Ressourcen sehen oder voneinander getrennte Ansichten erhalten.

Containerisierung nutzt diese Möglichkeit gezielt. Ein Prozess sieht beispielsweise eine eigene Prozessliste, eine andere Netzwerkumgebung und einen anderen Verzeichnisbaum. Zusätzlich können CPU- und Speichernutzung begrenzt werden.

Zwei Container mit gemeinsamem Linux-Kernel

Die Container haben getrennte Prozessumgebungen und nutzen denselben Linux-Kernel. Die Darstellung zeigt Zuständigkeiten und ist kein zwingender Ablauf jedes Systemaufrufs.

  • Container A
    • Java-Anwendung
    • Bibliotheken
    • Prozesssicht A
  • Container B
    • PostgreSQL
    • Bibliotheken
    • Prozesssicht B

Gemeinsame Ebenen, von oben nach unten:

  1. Container-Runtime und konfigurierte Linux-Kernelfunktionen
  2. Gemeinsamer Linux-Kernel
  3. Physische CPU, RAM, SSD und Netzwerk

Die Linux-Kernel-Funktionen stellen keine vollständig neue CPU bereit. Beide Container werden als Prozesse auf demselben Kernel ausgeführt. Für die Systemaufrufe gelten deshalb die Möglichkeiten und Beschränkungen dieses Kernels.

Was ist dann eine Container-Runtime?

Eine Runtime sorgt dafür, dass ein Container gemäß einer vorgegebenen Konfiguration gestartet wird. Sie richtet unter anderem Namespaces, Ressourcenbeschränkungen, Mounts, Berechtigungen und den Startprozess ein. Die genaue Arbeitsteilung zwischen höheren Werkzeugen, OCI-Runtimes und dem Kernel ist unterschiedlich.

Docker ist dabei nicht einfach gleichbedeutend mit dem Linux-Kernel-Mechanismus. Docker bietet ein komplettes System aus Kommandozeile, API, Engine, Image-Verwaltung, Netzwerken und weiteren Funktionen. Podman stellt viele vergleichbare Bedienfunktionen mit einem anderen Betriebsmodell bereit.

↑ Nach oben

Namespaces: Eine andere Sicht auf dasselbe System

Namespaces sind eine zentrale Grundlage der Linux-Containerisierung. Sie erlauben dem Kernel, bestimmten Prozessen eine isolierte Sicht auf ausgewählte Systemressourcen zu geben.

Das bedeutet nicht, dass jedes Namespace vollständig alles voneinander trennt. Es gibt unterschiedliche Namespace-Arten, die jeweils andere Ressourcen betreffen.

Namespace Typische Wirkung
PID Separate Sicht auf Prozesskennungen und Prozesshierarchie
Mount Eigenständige Sicht auf Dateisystem-Mounts
Network Eigene Netzwerkgeräte, IP-Adressen, Routingtabellen und Ports
UTS Getrennte Host- und Domainnamen
IPC Trennung bestimmter Interprozess-Kommunikationsressourcen
User Abbildung von Benutzer- und Gruppenkennungen
Cgroup Separate Sicht auf bestimmte cgroup-Zuordnungen
Time Bestimmte Zeit-Namespaces, etwa monotone Zeit-Offsets

Die Tabelle beschreibt die grundsätzlichen Mechanismen, nicht das Standardprofil jeder Container-Laufzeit. Welche Namespaces tatsächlich erzeugt oder geteilt werden, ist konfigurierbar.

Warum sehe ich im Container nicht alle Host-Prozesse?

Ein Prozess innerhalb eines neuen PID-Namespace sieht eine andere Prozesshierarchie als ein Prozess auf dem Host. Der erste Prozess dieses Namespace erscheint dort als PID 1.

Das ist mehr als Kosmetik. PID 1 besitzt unter Linux spezielle Aufgaben, etwa bei der Behandlung verwaister Kindprozesse und Signale. Eine Anwendung, die im Container PID 1 ist, sollte deshalb Signale korrekt behandeln und gegebenenfalls Kindprozesse aufräumen.

Daraus erklärt sich ein alltägliches Problem: Ein Container stoppt nicht sauber oder sammelt Zombie-Prozesse, weil die gestartete Anwendung nicht auf die Prozessrolle vorbereitet wurde. Ein passender Init-Prozess im Container kann helfen. Einfach mehr kill -9 ist selten die eleganteste Architektur.

User-Namespaces: Root ist nicht automatisch Host-Root

In einem User-Namespace können Benutzerkennungen aus Sicht des Containers anders auf Benutzerkennungen des Hosts abgebildet werden. Eine Anwendung kann im Container als UID 0 erscheinen, obwohl sie auf dem Host nicht dieselben Rechte wie der echte Root-Benutzer besitzt.

Das ist wichtig für rootless Container. Dabei werden geeignete Containerprozesse und gegebenenfalls Laufzeitkomponenten ohne umfassende Host-Root-Rechte betrieben.

Allerdings gilt auch hier: Eine solche Abbildung ist nur eine Schicht. Unsichere Mounts, zusätzliche Linux-Capabilities oder privilegierte Konfigurationen können die Schutzwirkung deutlich reduzieren.

↑ Nach oben

cgroups: Damit ein Container nicht alles verbraucht

Namespaces beantworten vor allem die Frage: Was sieht ein Prozess?

Control Groups, kurz cgroups, beantworten eine andere: Wie viele Ressourcen darf eine Gruppe von Prozessen beanspruchen und wie wird deren Nutzung beobachtet?

Der Linux-Kernel kann damit unter anderem CPU- und Speichernutzung steuern und kontrollieren. Bei cgroup v2 existiert dafür ein gemeinsames hierarchisches Modell.

Nehmen wir zwei Container. Der erste führt einen CPU-intensiven Build aus. Im zweiten läuft ein kleiner Dienst. Ohne passende Begrenzungen kann der Build erhebliche Hostressourcen belegen. Mit cgroups lassen sich beispielsweise CPU-Zeitanteile beziehungsweise Quoten und Speichergrenzen festlegen.

Host: 16 GiB RAM
  |
  +-- Container A: Speicherlimit 2 GiB
  |
  +-- Container B: Speicherlimit 1 GiB
  |
  +-- Host und weitere Prozesse: Rest

Diese vereinfachte Rechnung ist keine Garantie für genau verteilte physische Speicherseiten. Insbesondere Dateicaches, gemeinsam genutzte Speicherbereiche und Kernel-Accounting verlangen eine genauere Betrachtung.

Was passiert beim Speicherlimit?

Ein überschrittenes Speicherlimit führt nicht automatisch zu einer freundlichen Meldung „Bitte später erneut versuchen“. Abhängig von Kernel, Konfiguration und Situation kann der Speicherdruck zu einem Out-of-Memory-Ereignis führen. Prozesse im betroffenen Bereich können beendet werden.

Wenn der Container danach neu startet, ist die Ursache noch nicht beseitigt. Wer nur auf den grünen Neustartindikator schaut, sieht unter Umständen eine Endlosschleife aus Speicherüberlastung und Prozessneustarts.

CPU-Limits und CPU-Requests sind nicht dasselbe

Bei einfachen Container-Laufzeiten kann man CPU-Anteile gewichten oder Limits definieren. In Orchestrierungsplattformen kommen zusätzlich Konzepte wie Requests hinzu. Dabei handelt es sich um verschiedene Mechanismen. Eine CPU-Anforderung ist nicht zwangsläufig eine harte Begrenzung, ein CPU-Limit dagegen kann Drosselung bewirken.

Die Details hängen vom verwendeten Laufzeitsystem ab. Für das Grundlagenverständnis reicht zunächst: Container erhalten nicht automatisch eine eigene CPU. Sie konkurrieren um die reale CPU und können dabei reguliert werden.

↑ Nach oben

Images: Warum ein Container reproduzierbar starten kann

Ein Container-Image beschreibt eine Dateisystemgrundlage und Startkonfiguration. Es ist nicht die laufende Anwendung selbst. Aus einem Image lassen sich mehrere Containerinstanzen erzeugen.

Ein Image enthält beispielsweise die für eine Anwendung erforderlichen Laufzeitbibliotheken, Konfigurationsdateien und Binärdateien. Es muss nicht unbedingt eine vollständige Linux-Distribution samt Init-System mitbringen.

Viele Images bestehen aus mehreren Layern. Diese Schichten können bei mehreren Images gemeinsam genutzt und zwischengespeichert werden. Beim Start eines Containers wird üblicherweise eine beschreibbare Ebene über die nicht veränderlichen Image-Schichten gelegt.

Bei einem Copy-on-Write-Verfahren bleibt eine Datei der Image-Schicht zunächst gemeinsam nutzbar. Wird sie im Container verändert, legt der Storage-Treiber die benötigte beschreibbare Kopie in der Container-Ebene an. Details und Kosten hängen vom eingesetzten Storage-Treiber und Dateisystem ab. Volumes und Bind Mounts folgen eigenen Regeln und liegen außerhalb dieser Ebene. Docker beschreibt das Schichtenmodell und Copy-on-Write.

Container-Instanz
+---------------------------+
| Beschreibbare Container-   |
| Ebene                     |
+---------------------------+
| Image: App-Dateien        |
+---------------------------+
| Image: Laufzeitumgebung   |
+---------------------------+
| Image: Basisdateisystem   |
+---------------------------+

Dieses Modell vereinfacht die konkrete Storage-Implementierung. Das Prinzip ist jedoch wichtig: Die Daten in der beschreibbaren Ebene gehören zur Containerinstanz. Wenn die Instanz gelöscht wird, kann auch dieser Zustand verloren gehen.

Was macht ein Dockerfile?

Ein Dockerfile beschreibt, wie ein Image aufgebaut werden soll. Nehmen wir eine einfache Java-Anwendung als Beispiel:

# Schematisches Beispiel, kein vollständig lauffähiges Projekt.
FROM eclipse-temurin:21-jre
WORKDIR /app
COPY app.jar /app/app.jar
USER 10001
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

Die Grundidee ist klar: Eine bestimmte Java-Laufzeit wird als Basis gewählt, das JAR hineinkopiert und ein Startkommando festgelegt.

Der Beispieltext setzt voraus, dass eine passende Datei app.jar bereits gebaut wurde und die Zugriffsrechte für den Benutzer stimmen. Er ist kein Nachweis für einen getesteten Produktionscontainer.

Das Image ersetzt auch nicht die Softwarequalität. Wenn das JAR einen Fehler enthält, bleibt es im Container derselbe Fehler. Der Container kann ihn nur besonders reproduzierbar ausführen.

Tags sind bequem, Digests sind eindeutiger

Ein Image-Tag wie latest oder ein Versionslabel ist ein Name, der auf ein Image zeigen kann. Der Inhalt hinter einem Tag kann sich ändern. Für reproduzierbare und sicherheitskritische Builds ist es deshalb sinnvoll, die genaue Image-Version beziehungsweise ihren Digest festzuhalten.

Reproduzierbarkeit erfordert mehr als einen Dockerfile. Abhängigkeiten, Build-Werkzeuge, Netzwerquellen und externe Artefakte müssen ebenfalls kontrolliert werden. Ein Image ist ein guter Baustein. Es ist kein Zauberstab gegen nichtdeterministische Builds.

↑ Nach oben

Vom Image zum laufenden Container

Ein typischer Docker-Befehl startet eine Containerinstanz aus einem Image:

docker run --rm --name webtest -p 127.0.0.1:8080:80 nginx:stable

Beispiel, nicht in diesem Artikel ausgeführt. Die konkrete Veröffentlichung des Ports und das Netzwerkverhalten können sich je nach Plattform unterscheiden.

Der Befehl kombiniert mehrere Entscheidungen:

  • docker run erzeugt und startet die Containerinstanz.
  • --rm entfernt sie nach dem Beenden.
  • --name gibt ihr einen lesbaren Namen.
  • -p 127.0.0.1:8080:80 bindet einen Hostport an den Dienstport im Container, hier bewusst an die Loopback-Adresse.
  • nginx:stable bezeichnet das zu verwendende Image.

Danach liefert die Container-Laufzeit nicht einfach ein „zweites Linux“. Sie startet den konfigurierten Prozess in der vorbereiteten Umgebung.

Der Lebenszyklus einer Containerinstanz

Ein Image kann lokal vorhanden sein, ohne dass daraus gerade ein Container läuft. Ein Container kann erstellt, gestartet, angehalten und entfernt werden. Ein gestoppter Container ist nicht automatisch verschwunden.

Image vorhanden
       |
       v
Container erzeugen
       |
       v
Container starten
       |
       v
Prozess läuft
       |
       +--> Stoppen --> erneut starten
       |
       +--> Entfernen --> beschreibbarer Zustand weg

Ein Container ist damit eher wegwerfbare Ausführungsumgebung als dauerhaft gepflegter Server. Das schließt dauerhafte Dienste nicht aus, verlangt aber eine saubere Trennung zwischen Laufzeitinstanz und persistenten Daten.

↑ Nach oben

Dateisysteme und Volumes: Wohin mit den Daten?

Eine Anwendung produziert oft Daten, die einen Containerwechsel überstehen sollen. Eine Datenbank ist das offensichtlichste Beispiel. Ihre Tabellen dürfen nicht verschwinden, nur weil das Container-Image aktualisiert wird.

Dafür gibt es unter anderem Volumes und Bind Mounts.

Volumes

Ein Docker-Volume wird durch die Containerplattform verwaltet. Es kann unabhängig vom Lebenszyklus einzelner Container bestehen und bei neuen Instanzen wieder eingebunden werden.

docker volume create app-data

Ein Volume ist allerdings noch kein Backup. Es kann gelöscht werden, beschädigt werden oder auf demselben physischen Datenträger liegen wie die übrigen Daten.

Bind Mounts

Ein Bind Mount verbindet einen konkret angegebenen Hostpfad mit einem Pfad im Container.

# Unter Linux, schematisch:
docker run --rm -v "$PWD/config:/app/config:ro" example/app:1

Das kann in Entwicklungsumgebungen praktisch sein. Es schafft aber auch direkte Beziehungen zwischen Container und Hostdateisystem. Wer einen großen Hostpfad schreibbar einbindet, darf sich nicht über weitreichende Dateiänderungen wundern.

Unter Windows und macOS kommen zusätzliche Dateisystem- und VM-Grenzen hinzu. Die Performance von Bind Mounts kann dort je nach Pfad und Architektur deutlich anders ausfallen als auf einem nativen Linux-Host.

↑ Nach oben

Containernetzwerke: Eigene IP, aber nicht automatisch eigene Maschine

Ein Container kann einen eigenen Netzwerk-Namespace mit virtueller Netzwerkschnittstelle, Routingtabelle und Ports erhalten. Üblicherweise koppelt ein virtuelles Ethernet-Paar den Container an ein Bridge-Netz im Host.

Vereinfacht:

Container A                Container B
  eth0                        eth0
    |                           |
  veth A                     veth B
    +------------+--------------+
                 |
           Linux-Bridge
                 |
            Host-Netz
                 |
       Routing / NAT / Firewall

Eine von Docker konfigurierte Bridge kann Kommunikation zwischen Containern ermöglichen. Die genaue Namensauflösung und Erreichbarkeit hängt von der Netzart und Konfiguration ab.

Was macht -p 8080:80?

Die Angabe veröffentlicht einen Port des Containers über einen Hostport. Bei Docker ist ohne explizite Hostadresse häufig eine Bindung an alle Hostschnittstellen vorgesehen. Das ist in einem lokalen Experiment schnell übersehen.

Deshalb bevorzuge ich bei rein lokalen Tests eine explizite Loopback-Bindung:

docker run --rm -p 127.0.0.1:8080:80 nginx:stable

Auch das sollte man nicht mit einer vollständigen Sicherheitsgarantie verwechseln. Betriebssystem, Docker-Version und Netzwerkkonfiguration bleiben relevant.

Warum localhost manchmal für Verwirrung sorgt

localhost bezeichnet aus Sicht eines Prozesses dessen eigene Netzwerkumgebung. Innerhalb eines Containers ist das im Normalfall nicht einfach die Loopback-Adresse des Hosts.

Wenn ein Java-Service im Container auf localhost:5432 zugreift, sucht er dort einen Datenbankdienst in seiner eigenen Netzwerksicht. Läuft die Datenbank in einem zweiten Container, braucht er normalerweise dessen Dienstadresse im gemeinsamen Container-Netz.

Das ist kein Docker-Bug. Es ist die erwartete Konsequenz der Netzwerktrennung.

↑ Nach oben

Docker Compose: Mehrere Dienste als eine Anwendung beschreiben

Eine Anwendung besteht selten nur aus einem Prozess. Vielleicht gibt es einen Webservice, eine Datenbank und einen kleinen Worker. Man könnte jeden Container einzeln über lange CLI-Aufrufe starten. Das ist fehleranfällig.

Docker Compose beschreibt mehrere Dienste und ihre Beziehungen in einer YAML-Datei. Ein bewusst minimiertes Beispiel:

services:
  web:
    image: nginx:stable
    ports:
      - '127.0.0.1:8080:80'
    restart: unless-stopped

Das Beispiel demonstriert das Format, nicht den Betrieb einer vollständigen Anwendung. In einem realen Projekt würde ich verwendete Image-Versionen gezielt fixieren, Persistenz und Gesundheitsprüfungen definieren und Geheimnisse nicht in die Compose-Datei schreiben.

Compose löst auch keine fachlichen Abhängigkeiten. Ein Container, der „gestartet“ wurde, ist nicht zwangsläufig bereits bereit für Anfragen. Datenbanken können initialisieren, Migrationen können laufen und Netzwerkdienste können noch nicht lauschen.

Startreihenfolge und Bereitschaft sind unterschiedliche Eigenschaften. Wer mehrere Dienste orchestriert, muss mit beiden umgehen.

↑ Nach oben

Docker, Podman und systemorientierte Container

Nicht jede Containerumgebung hat dieselbe Architektur oder Zielsetzung.

Docker: Engine, Daemon und API

Docker verwendet eine Client-Server-Architektur. Der Client docker spricht mit dem Docker-Daemon dockerd, der unter anderem Container, Netzwerke und Images verwaltet.

Das ist aus Entwicklersicht komfortabel. Die Docker-API ist aber eine mächtige Schnittstelle. Wer unkontrolliert Zugriff auf einen privilegierten Docker-Socket vergibt, kann damit sehr weitreichende Aktionen auf dem Host ermöglichen.

Rootless Docker kann dieses Risiko in geeigneten Konfigurationen reduzieren. Es ändert jedoch nichts daran, dass Berechtigungen, Mounts und Laufzeitkonfiguration weiterhin sorgfältig gewählt werden müssen. Die Docker-Dokumentation beschreibt das Modell.

Podman: Ohne dauerhaften zentralen Daemon

Podman verfolgt ein anderes Betriebsmodell. Typischerweise gibt es keinen dauerhaft laufenden zentralen Daemon, an den jeder normale CLI-Aufruf gesendet wird. Podman kann Container und Pods verwalten und unterstützt den Betrieb ohne Host-Root-Rechte.

„Daemonless“ bedeutet nicht, dass nirgendwo Prozesse oder Hintergrunddienste existieren dürfen. Containerprozesse laufen natürlich weiter. Auch APIs oder Hilfsdienste können bei Bedarf bereitgestellt werden. Der Unterschied betrifft die grundlegende Organisation der Containerverwaltung.

Docker und Podman verwenden verwandte Konzepte und häufig OCI-kompatible Images. Sie sind aber nicht in jeder Netzwerkeinstellung, Compose-Funktion oder Integrationsschnittstelle identisch. Wer eine bestehende Umgebung umstellt, sollte deshalb die tatsächlich verwendeten Funktionen prüfen.

LXC und Incus: Eine vollständiger wirkende Linux-Umgebung

Docker und Podman werden häufig verwendet, um einzelne Anwendungen oder Dienste bereitzustellen. Systemcontainer verfolgen eine andere Zielrichtung: Sie stellen eine Umgebung bereit, die sich in der Administration stärker wie ein vollständiges Linux-System anfühlt.

LXC ist eine wesentliche Grundlage für Linux-Systemcontainer. Incus bietet eine Verwaltungsebene für Systemcontainer und auch virtuelle Maschinen. In einem Systemcontainer können mehrere Dienste, ein Init-System und umfangreichere Betriebssystemstrukturen laufen.

Der zentrale Unterschied zur klassischen VM bleibt bestehen: Ein Linux-Systemcontainer verwendet denselben Kernel wie der Host. Will ich einen völlig anderen Kernel starten, ist ein Systemcontainer nicht das passende Mittel. Incus erläutert die Unterschiede ausdrücklich.

Damit wird auch klar, warum „Container versus VM“ als einfache Zweiteilung zu grob ist. Ein Anwendungscontainer und ein Systemcontainer verwenden ähnliche Kernelmechanismen, lösen aber nicht zwingend dieselben Betriebsprobleme.

↑ Nach oben

Warum Linux-Container unter Windows eine VM benötigen können

Ein Linux-Container setzt einen Linux-Kernel voraus. Ein Windows-System verwendet dagegen den Windows-Kernel. Die notwendigen Linux-Kernel-Schnittstellen stehen nicht einfach nativ bereit.

Docker Desktop kann unter Windows deshalb einen Linux-Kernel in einer virtualisierten Umgebung verwenden, beispielsweise über WSL 2. Der Container läuft dann nicht unmittelbar auf dem Windows-Kernel, sondern innerhalb der Linux-Umgebung.

Windows-Host
    |
    +-- WSL-2-VM mit Linux-Kernel
          |
          +-- Container A
          +-- Container B

Das Modell ist vereinfacht. Microsoft beschreibt WSL 2 als Architektur mit einem echten Linux-Kernel in einer leichtgewichtigen VM. Einzelne Linux-Distributionen werden innerhalb dieser verwalteten Umgebung isoliert. Microsoft Learn: WSL.

Es ist also kein Widerspruch, wenn jemand sagt, er nutze „Docker statt einer VM“, während seine lokale Docker-Umgebung auf Windows im Hintergrund selbst virtualisiert ist. Er nutzt nur eine andere Abstraktionsebene und muss die VM nicht wie einen gewöhnlichen Linux-Desktop administrieren.

↑ Nach oben

Sicherheit: Container sind eine Grenze, aber kein Tresor

Container trennen Prozesse und Ressourcen, teilen sich aber einen Kernel. Eine Schwachstelle im Kernel oder in einer privilegierten Runtime kann deshalb mehrere Container und unter Umständen den Host betreffen.

Zusätzliche Isolationsmechanismen können die Angriffsfläche reduzieren:

  • User-Namespaces und möglichst unprivilegierter Betrieb.
  • Linux-Capabilities, um weitreichende Einzelrechte zu begrenzen.
  • Seccomp, um bestimmte Systemaufrufe einzuschränken.
  • LSM-Regeln wie AppArmor oder SELinux, abhängig von der Plattform.
  • Beschränkte Mounts, Netzwerkverbindungen und Ressourcen.
  • Aktuelle Basisimages und überprüfte Abhängigkeiten.

Ein Image aus einer Registry ist auch nicht automatisch vertrauenswürdig. Es kann unsichere Pakete, veraltete Bibliotheken oder absichtlich schädliche Programme enthalten. Image-Scanning, Herkunftsnachweise und überprüfte Buildketten helfen, ersetzen aber keine sichere Laufzeitkonfiguration.

Warum --privileged kein harmloser Komfortschalter ist

Ein privilegierter Container erhält deutlich erweiterte Rechte und Zugriffe. Das kann in speziellen Entwicklungs- oder Systemanwendungsfällen notwendig sein. Wer es nur setzt, damit „die Fehlermeldung endlich weg ist“, hat vermutlich ein Berechtigungsproblem durch eine sehr große Sicherheitsöffnung ersetzt.

Bei Hardwarezugriffen sollte zuerst geklärt werden, welche konkrete Schnittstelle benötigt wird: etwa ein einzelnes Gerät, eine bestimmte Capability oder eine begrenzte API. So wenig Zugriff wie möglich ist zwar ein alter Grundsatz, aber hier überraschend praktisch.

↑ Nach oben

Wann sind Container eine gute Idee?

Container eignen sich besonders dann, wenn ich eine Anwendung samt ihrer Laufzeitumgebung reproduzierbar bauen, starten, austauschen und betreiben möchte.

Für einen Java-Service mit einer Datenbank ist das oft sinnvoll. Die Anwendung kann als Image gebaut werden, die Datenbank bekommt einen persistenten Datenträger und beide Dienste kommunizieren in einem definierten Netz. Eine andere Entwicklungsmaschine muss dann nicht jede Abhängigkeit manuell nachinstallieren.

Container sind weniger überzeugend, wenn ich einen anderen Betriebssystemkernel testen möchte, spezielle Hardware sehr genau nachbilden muss oder eine vollständige Linux-Desktopumgebung mit eigenständigen Betriebssystemdiensten benötige. Dafür kann eine VM geeigneter sein.

Es gibt außerdem keinen Grund, jede kleine Anwendung zwanghaft in Container zu verschieben. Ein lokal gestartetes Java-Programm ist nicht minderwertig, nur weil es kein Image besitzt. Wenn die Abhängigkeiten überschaubar sind, kann die direkte Ausführung einfacher sein.

Containerisierung ist ein Werkzeug zur kontrollierten Ausführung und Bereitstellung. Sie ist kein Qualitätsmerkmal an sich.

Die technischen Grundlagen von virtuellen Maschinen gehören in einen eigenen Artikel. Für die Entscheidung zwischen VM, Container oder beiden zusammen lohnt sich anschließend ein Vergleich anhand konkreter Anforderungen.

↑ Nach oben

Quellen und weiterführende Dokumentation

Die Grundlagen zu virtuellen Maschinen erklären das Isolationsmodell mit eigenem Gastkernel. Der Vergleich VM oder Container behandelt die praktische Technologieentscheidung.

Redaktionshinweis: CLI- und Dockerfile-Beispiele illustrieren die Funktionsweise. Sie sind keine dokumentierten End-to-End-Tests auf einer konkreten Docker- oder Podman-Version. Versionen, Rechte und plattformspezifische Details vor Veröffentlichung prüfen.

↑ Nach oben