Docker verstehen: Containerisierung einfach erklärt

Docker hat die Art und Weise, wie Entwickler Software erstellen und bereitstellen, grundlegend verändert. Doch was steckt hinter diesem mächtigen Werkzeug, und wie lässt es sich optimal einsetzen? Dieser Artikel erklärt die Kernkonzepte von Docker, von Containern bis zu Dockerfiles, und zeigt, warum es die Entwicklungsumgebungen revolutioniert hat.

Warum Docker? Das Problem der Umgebungsinkonsistenz

Jeder Entwickler kennt das Frustpotenzial: Eine Anwendung läuft perfekt auf dem lokalen Rechner, scheitert jedoch im Test- oder Produktionssystem – obwohl dieselbe Codebasis verwendet wird. Die Ursache liegt in der Umgebungsinkonsistenz: Unterschiedliche Betriebssysteme, installierte Bibliotheken oder Konfigurationsdateien führen zu unvorhersehbarem Verhalten. Docker löst dieses Problem durch Containerisierung, indem Anwendungen inklusive aller Abhängigkeiten in isolierte, portable Umgebungen verpackt werden.

"Docker stellt sicher, dass Software überall gleich funktioniert – vom Laptop bis zum Server."

Statt jede Maschine manuell zu konfigurieren, wird die gesamte Laufzeitumgebung in einem Container gebündelt. Dies spart nicht nur Zeit, sondern reduziert auch Fehlerquellen bei der Bereitstellung.

Docker vs. Virtuelle Maschinen: Ein klarer Vergleich

Virtuelle Maschinen (VMs) und Docker-Container verfolgen ähnliche Ziele, nutzen jedoch unterschiedliche Ansätze. Eine VM emuliert ein vollständiges Betriebssystem und ist daher ressourcenintensiv. Docker-Container hingegen teilen sich den Kernel des Host-Betriebssystems und sind dadurch schneller und leichter.

| Merkmal | Virtuelle Maschine | Docker-Container | |-----------------------|------------------------|-----------------------| | Betriebssystem | Vollständig integriert | Wird geteilt | | Startzeit | Mehrere Minuten | Wenige Sekunden | | Ressourcenverbrauch | Hoch | Gering | | Größe | Gigabyte | Megabyte |

Ein anschaulicher Vergleich verdeutlicht den Unterschied:

• Virtuelle Maschine = Ein komplett möbliertes Haus mit eigenem Stromnetz.
• Docker-Container = Eine möblierte Wohnung in einem Hochhaus – effizient und flexibel.

Die Docker-Architektur: Wie alles zusammenarbeitet

Docker basiert auf einer Client-Server-Architektur, bei der verschiedene Komponenten nahtlos zusammenarbeiten. Der Entwickler interagiert über die Docker CLI (Command Line Interface) mit dem System, während der Docker Engine (Daemon) im Hintergrund die eigentliche Arbeit übernimmt.

Kernkomponenten im Überblick

• Docker Client: Die Schnittstelle für Benutzerbefehle wie docker run oder docker build.
• Docker Engine: Der zentrale Dienst, der Container erstellt, verwaltet und ausführt.
• Docker Images: Blaupausen für Container, die Anwendungscode, Abhängigkeiten und Konfiguration enthalten.
• Docker Containers: Laufende Instanzen von Images, die die Anwendung ausführen.
• Docker Hub: Eine öffentliche Registry zum Speichern und Teilen von Images.

Ein typischer Arbeitsablauf sieht so aus:

1. Der Entwickler schreibt Befehle im Terminal (z. B. docker run nginx).
2. Der Docker Client sendet diese an die Docker Engine.
3. Die Engine lädt das Image herunter (falls nicht lokal vorhanden) oder erstellt einen neuen Container.
4. Der Container wird gestartet und die Anwendung läuft.

Docker Images: Die Blaupausen der Container

Ein Docker Image ist eine schreibgeschützte Vorlage, die alle notwendigen Komponenten für eine Anwendung enthält. Dazu gehören:

• Anwendungscode
• Abhängigkeiten (Bibliotheken, Tools)
• Laufzeitumgebung
• Konfigurationsdateien

Images werden mithilfe einer Dockerfile erstellt – einer Textdatei, die schrittweise Anweisungen zur Erstellung des Images enthält. Ein einfaches Beispiel für eine Python-Anwendung:

# Basisimage wählen
FROM python:3.12-slim

# Arbeitsverzeichnis festlegen
WORKDIR /app

# Anwendungscode kopieren
COPY . .

# Abhängigkeiten installieren
RUN pip install --no-cache-dir -r requirements.txt

# Standardbefehl definieren
CMD ["python", "app.py"]

Die Dockerfile wird mit folgendem Befehl in ein Image umgewandelt:

docker build -t mein-python-app .

Das -t flag weist dem Image einen Tag zu (hier: mein-python-app).

Layer: Die Bausteine eines Docker Images

Jede Anweisung in einer Dockerfile erzeugt eine neue Schicht (Layer). Diese Schichten sind übereinander gestapelt und werden beim Erstellen eines Images kombiniert. Änderungen an früheren Schichten erfordern das erneute Erstellen aller nachfolgenden Schichten – ein Grund, warum Dockerfiles sorgfältig strukturiert sein sollten.

Docker Compose: Mehrere Container koordinieren

In der Praxis bestehen Anwendungen oft aus mehreren Diensten, z. B. einer Webanwendung, einer Datenbank und einem Caching-Server. Docker Compose ermöglicht es, solche Multi-Container-Umgebungen mit einer einzigen Konfigurationsdatei (docker-compose.yml) zu definieren und zu starten.

Ein Beispiel für eine docker-compose.yml für eine Webanwendung mit PostgreSQL-Datenbank:

version: '3.8'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: geheim
    volumes:
      - postgres-data:/var/lib/postgresql/data

volumes:
  postgres-data:

Mit dem Befehl

docker compose up

werden alle definierten Dienste gestartet. Docker Compose übernimmt dabei die Verwaltung der Netzwerke und Volumes – ein enormer Vorteil für Entwickler.

Wichtige Docker-Befehle für den Alltag

Die Arbeit mit Docker erfordert einige Grundbefehle, die regelmäßig genutzt werden. Hier eine Auswahl der wichtigsten:

Images verwalten

• docker pull nginx: Lädt das offizielle Nginx-Image von Docker Hub herunter.
• docker images: Listet alle lokal gespeicherten Images auf.
• docker build -t mein-app .: Erstellt ein Image aus einer Dockerfile.
• docker rmi nginx: Entfernt ein Image (hier: nginx).

Container steuern

• docker run nginx: Startet einen neuen Container basierend auf dem Nginx-Image.
• docker ps: Zeigt laufende Container an (-a für alle Container).
• docker stop CONTAINER_ID: Stoppt einen laufenden Container.
• docker start CONTAINER_ID: Startet einen gestoppten Container.
• docker logs CONTAINER_ID: Zeigt die Protokolle eines Containers an.
• docker exec -it CONTAINER_ID bash: Öffnet eine interaktive Shell im Container.

Aufräumen

• docker system prune: Entfernt nicht genutzte Docker-Objekte (Images, Container, Netzwerke).
• docker container prune: Löscht gestoppte Container.
• docker image prune: Entfernt ungenutzte Images.

Datenpersistenz: Volumes und Netzwerke

Container sind flüchtig – sobald sie gelöscht werden, gehen alle darin gespeicherten Daten verloren. Docker Volumes bieten eine Lösung, um Daten dauerhaft zu speichern. Ein Volume wird außerhalb des Containers angelegt und bleibt auch nach dessen Löschung erhalten.

Ein Beispiel:

docker volume create meine-daten

In einer docker-compose.yml kann ein Volume wie folgt eingebunden werden:

services:
  db:
    image: postgres:15
    volumes:
      - meine-daten:/var/lib/postgresql/data

Docker bietet zudem verschiedene Netzwerktypen, um die Kommunikation zwischen Containern zu ermöglichen:

• Bridge: Standardnetzwerk für isolierte Container-Kommunikation.
• Host: Container nutzt das Netzwerk des Hosts (keine Isolation).
• None: Container hat kein Netzwerkzugriff.

Mit docker network ls lassen sich alle verfügbaren Netzwerke anzeigen.

Fazit: Docker als Game-Changer für Entwickler

Docker hat die Softwareentwicklung demokratisiert, indem es Konsistenz und Portabilität in den Vordergrund stellt. Ob für lokale Entwicklung, Testumgebungen oder die Bereitstellung in der Cloud – Containerisierung mit Docker spart Zeit, reduziert Fehler und vereinfacht die Zusammenarbeit im Team. Wer die Grundlagen beherrscht, kann komplexe Anwendungsarchitekturen effizient verwalten und sich auf das Wesentliche konzentrieren: die Entwicklung hochwertiger Software.

Die Zukunft der Containerisierung sieht vielversprechend aus, insbesondere mit neuen Tools wie Docker Desktop für Entwickler und erweiterter Integration in Cloud-Plattformen. Wer heute in Docker investiert, ist für die Herausforderungen der modernen Softwareentwicklung bestens gerüstet.