Docker für Einsteiger: Ein praktischer Leitfaden zu Containern

Grundlegende Docker-Konzepte

Jetzt, wo du Docker installiert hast, möchtest du vielleicht gleich loslegen und Container starten. Aber bevor wir das tun, ist es wichtig, ein paar Schlüsselkonzepte zu verstehen, die die Grundlage für die Arbeit von Docker bilden. Diese Konzepte werden dir helfen, Docker effektiver zu nutzen und die üblichen Anfängerfallen zu vermeiden.

Das Herzstück von Docker sind Imagesdie als Blaupausen für Container dienen; Containerdie die laufenden Instanzen dieser Images sind, und Docker Hub, ein zentrales Repository für die gemeinsame Nutzung und Verwaltung von Images.

Lass uns jedes dieser Konzepte genauer untersuchen.

Docker-Bilder

Docker-Images sind die grundlegenden Bausteine von Containern. Sie sind unveränderliche, schreibgeschützte Vorlagen, die alles enthalten, was zum Ausführen einer Anwendung benötigt wird, einschließlich des Betriebssystems, des Anwendungscodes, der Laufzeit und der Abhängigkeiten.

Bilder werden mithilfe einer Dockerfile erstellt, in der die Anweisungen für die Erstellung eines Bildes Schicht für Schicht festgelegt sind.

Images können in Container-Registries wie Docker Hub gespeichert und von dort abgerufen werden.

Hier sind einige Beispielbefehle für die Arbeit mit Bildern:

• docker pull nginx: Hol dir das neueste Nginx-Image von Docker Hub.
• docker images: Listet alle verfügbaren Bilder auf dem lokalen Rechner auf.
• docker rmi nginx: Entferne ein Image vom lokalen Rechner.

Docker Container

Ein Docker-Container ist eine laufende Instanz eines Docker-Images. Container bieten eine isolierte Laufzeitumgebung, in der Anwendungen laufen können, ohne sich gegenseitig oder das Hostsystem zu stören. Jeder Container hat sein eigenes Dateisystem, Netzwerk und Prozessraum, teilt sich aber den Host-Kernel.

Container folgen einem einfachen Lebenszyklus, der das Erstellen, Starten, Stoppen und Löschen umfasst. Hier findest du eine Übersicht über die gängigen Befehle zur Containerverwaltung:

1. Einen Container erstellen: docker create oder docker run
2. Starte einen Container: docker start
3. Anhalten eines Containers: docker stop
4. Neustart eines Containers: docker restart
5. Löschen eines Containers: docker rm

Schauen wir uns ein praktisches Beispiel an. Der folgende Befehl führt einen Nginx-Container im abgetrennten Modus (im Hintergrund) aus und ordnet Port 80 im Container dem Port 8080 auf dem Host-Rechner zu:

docker run -d -p 8080:80 nginx

Nachdem du diesen Befehl ausgeführt hast, zieht Docker das Nginx-Image (falls noch nicht vorhanden), erstellt einen Container und startet ihn.

Um alle laufenden und gestoppten Container zu überprüfen:

docker ps -a

Dadurch wird eine Liste aller Container und Details wie ihr Status und die zugewiesenen Häfen angezeigt.

Docker Hub

Docker Hub ist ein cloudbasierter Registrierungsdienst zum Finden, Speichern und Verteilen von Container-Images. Nutzer können benutzerdefinierte Images in Docker Hub einstellen und sie öffentlich oder privat teilen.

Hier sind einige Befehle für die Interaktion mit Docker Hub:

• docker login: Authentifiziere dich mit Docker Hub.
• docker push my-image: Lade ein selbst erstelltes Image auf Docker Hub hoch.
• docker search ubuntu: Suche nach offiziellen und Gemeinschaftsbildern.
• docker pull ubuntu: Lade ein Ubuntu-Image vom Docker Hub herunter.

Neu in der Containerisierung? Verschaffe dir eine solide Grundlage mit dem Kurs Containerization and Virtualization Concepts.

Deinen ersten Docker Container ausführen

Nachdem wir nun die Kernkonzepte von Docker kennengelernt haben, ist es an der Zeit, sie in die Tat umzusetzen! Beginnen wir damit, unseren ersten Container zu starten, um sicherzustellen, dass Docker korrekt installiert ist und wie erwartet funktioniert.

Um deine Docker-Installation zu testen, öffne die PowerShell (Windows) oder das Terminal (Mac und Linux) und führe sie aus:

docker run hello-world

Dies zieht das hello-world Image von DockerHub und führt es in einem Container aus.

Docker hello-world image Beispiel

Jetzt gehen wir einen Schritt weiter und lassen eine reale Anwendung laufen - einen Nginx-Webserver. Führe den folgenden Befehl aus:

docker run -d -p 8080:80 nginx

Der obige Befehl macht Folgendes:

• Das -d Flag lässt den Container im Detached Mode laufen, das heißt, er läuft im Hintergrund.
• Das -p 8080:80 Flag ordnet Port 80 innerhalb des Containers dem Port 8080 auf deinem lokalen Rechner zu, damit du auf den Webserver zugreifen kannst.

Sobald der Befehl erfolgreich ausgeführt wurde, öffne einen Browser und besuche ihn: http://localhost:8080

Zugriff auf den Webserver unter localhost:8080

Du solltest die Standardbegrüßungsseite von Nginx sehen, die bestätigt, dass dein Webserver in einem Container läuft!

Du wirst auch einen Container in deinem Docker Desktop sehen:

Nginx Container läuft auf Port 8080

Dein erstes Docker Image erstellen

Bis jetzt haben wir vorgefertigte Images von Docker Hub verwendet. Was aber, wenn du eine maßgeschneiderte Umgebung für deine Anwendung brauchst? Hier kommt das Erstellen deines eigenen Docker-Images ins Spiel.

Um ein Docker-Image zu erstellen, musst du ein Dockerfile schreiben, ein Skript, das die Image-Erstellung automatisiert. Dies gewährleistet Konsistenz und Übertragbarkeit in verschiedenen Umgebungen. Sobald ein Image erstellt ist, kann es als Container ausgeführt werden, um Anwendungen in einer isolierten Umgebung auszuführen. 

In diesem Abschnitt lernst du die Grundlagen, wie du ein Dockerfile schreibst, ein benutzerdefiniertes Image erstellst und es als Container ausführst.

Dockerfile Grundlagen

Ein Dockerfile ist ein Skript, das eine Reihe von Anweisungen enthält, die festlegen, wie ein Docker-Image erstellt wird. Es automatisiert den Prozess der Image-Erstellung und sorgt für Konsistenz in verschiedenen Umgebungen. Jede Anweisung in einem Dockerfile erstellt eine neue Ebene im Bild. Hier ist ein Beispiel für ein Dockerfile für eine einfache Python-Flask-App:

# Base image containing Python runtime
FROM python:3.9

# Set the working directory inside the container
WORKDIR /app

# Copy the application files from the host to the container
COPY . /app

# Install the dependencies listed in requirements.txt
RUN pip install -r requirements.txt

# Define the command to run the Flask app when the container starts
CMD ["python", "app.py"]

In dem obigen Befehl:

• -v my-volume:/app/data bindet den Speicher my-volume in das Verzeichnis /app/data innerhalb des Containers ein.
• Alle Daten, die in /app/data gespeichert sind, bleiben erhalten, auch wenn der Container angehalten oder entfernt wird.

Das obige Dockerfile aufschlüsseln:

• FROM python:3.9: Gibt das Basis-Image an, auf dem Python 3.9 vorinstalliert ist.
• WORKDIR /app: Legt /app als Arbeitsverzeichnis innerhalb des Containers fest.
• COPY . /app: Kopiert alle Dateien aus dem aktuellen Verzeichnis des Hosts nach /app im Container.
• RUN pip install -r requirements.txt: Installiert alle erforderlichen Abhängigkeiten innerhalb des Containers.
• CMD ["python", "app.py"]: Legt den Befehl fest, der beim Start des Containers ausgeführt werden soll.

Erstellen und Ausführen des Images

Sobald das Dockerfile definiert ist, kannst du das Image mit den folgenden Befehlen erstellen und ausführen:

Schritt 1: Das Bild erstellen

docker build -t my-flask-app .

Der obige Befehl:

• Verwendet das aktuelle Verzeichnis (.) als Baukontext.
• Liest die Dockerfile und führt ihre Anweisungen aus.
• Markiert (-t) das resultierende Bild als my-flask-app.

Schritt 2: Das Image als Container ausführen

docker run -d -p 5000:5000 my-flask-app

Der obige Befehl:

• Führt den Container im losgelösten Modus aus (-d).
• Ordnet Port 5000 innerhalb des Containers dem Port 5000 auf dem Host zu (-p 5000:5000).

Sobald sie läuft, kannst du auf die Flask-Anwendung zugreifen, indem du in einem Browser zu http://localhost:5000 navigierst.

Docker Volumes und Persistenz

Standardmäßig sind die Daten in einem Docker-Container temporär- sobald der Container anhält oder entfernt wird, verschwinden die Daten. Um Daten über Container-Neustarts hinweg zu erhalten und sie zwischen mehreren Containern zu teilen, bietet Docker Volumes, einen eingebauten Mechanismus zur effizienten Verwaltung von persistentem Speicher.

Im Gegensatz zur Speicherung von Daten im Dateisystem des Containers werden Volumes von Docker separat verwaltet, was sie effizienter, flexibler und einfacher zu sichern macht.

Im nächsten Abschnitt erfahren wir, wie du Docker-Volumes erstellst und verwendest, um die Datenpersistenz in deinen Containern sicherzustellen.

Docker-Volumes erstellen und verwenden

Schritt 1: Ein Volumen erstellen

Bevor wir ein Volume verwenden können, müssen wir es erstellen. Führe den folgenden Befehl aus:

docker volume create my-volume

Dadurch wird ein benanntes Volume mit dem Namen my-volume erstellt, das von Docker unabhängig von einem bestimmten Container verwaltet wird.Schritt 2: Verwende das Volumen in einem Container

Jetzt starten wir einen Container und mounten das Volume darin:

docker run -d -v my-volume:/app/data my-app

In dem obigen Befehl:

• -v my-volume:/app/data bindet den Speicher my-volume in das Verzeichnis /app/data innerhalb des Containers ein.
• Alle Daten, die in /app/data gespeichert sind, bleiben erhalten, auch wenn der Container angehalten oder entfernt wird.

Docker Compose für Multi-Container-Anwendungen

Bisher haben wir mit Einzelcontainer-Anwendungen gearbeitet, aber viele reale Anwendungen benötigen mehrere Container, um zusammenzuarbeiten. Eine Webanwendung kann zum Beispiel einen Backend-Server, eine Datenbank und eine Caching-Schicht benötigen, die jeweils in einem eigenen Container laufen. Die manuelle Verwaltung dieser Container mit separaten docker run Befehlen kann schnell mühsam werden.

Hier kommt Docker Compose ins Spiel.

Was ist Docker Compose?

Docker Compose ist ein Tool, das die Verwaltung von Multicontainer-Anwendungen vereinfacht. Anstatt mehrere docker run Befehle auszuführen, kannst du einen ganzen Anwendungsstapel mit einer docker-compose.yml Datei definieren und ihn mit einem einzigen Befehl bereitstellen.

Schreiben einer Docker Compose Datei

Jetzt wollen wir ein reales Beispiel erstellen - eine einfache Node.js-Anwendung, die sich mit einer MongoDB-Datenbank verbindet. Anstatt die beiden Container getrennt zu verwalten, definieren wir sie in einer docker-compose.yml Datei.

Hier siehst du, wie wir unser Multi-Container-Setup in Docker Compose definieren:

version: '3'
services:
  web:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - database
  database:
    image: mongo
    volumes:
      - db-data:/data/db
volumes:
  db-data:

Die obige Datei aufschlüsseln:

• version: '3': Gibt die Version von Docker Compose an.
• services:: Definiert einzelne Dienste (Container).
• web:: Definiert die Node.js-Webanwendung.
• database:: Definiert den MongoDB-Datenbankcontainer.
• volumes:: Erstellt ein benanntes Volume (db-data) für die Persistenz von MongoDB-Daten.

Ausführen von Anwendungen mit mehreren Containern

Sobald die Datei docker-compose.yml fertig ist, können wir den gesamten Anwendungsstapel mit einem einzigen Befehl starten:

docker-compose up -d

Der vorherige Befehl startet sowohl den Web- als auch den Datenbankcontainer im losgelösten Modus (-d).

Um alle Dienste zu stoppen, verwende:

docker-compose down

Dadurch werden alle Container angehalten und entfernt, während die Volumes und Netzwerkeinstellungen erhalten bleiben.

Grundlagen der Docker-Vernetzung

Bisher haben wir uns auf den Betrieb von Containern und die Verwaltung von Speicherplatz konzentriert, aber was passiert, wenn Container miteinander kommunizieren müssen? In den meisten realen Anwendungen arbeiten Container nicht isoliert - sie müssen Daten austauschen, egal ob ein Webserver mit einer Datenbank kommuniziert oder Microservices miteinander interagieren.

Docker bietet eine Reihe von Netzwerkoptionen für unterschiedliche Anwendungsfälle, von isolierten internen Netzwerken bis hin zu Konfigurationen mit externem Zugriff.

Bist du bereit, deine Docker-Kenntnisse zu verbessern? Melde dich für den Kurs Docker für Fortgeschrittene an, um mehr über mehrstufige Builds, fortgeschrittene Netzwerke und vieles mehr zu erfahren!

Was ist ein Docker-Netzwerk?

Docker Networking ist eine eingebaute Funktion, die es Containern ermöglicht, miteinander zu kommunizieren, sei es auf demselben Host oder über mehrere Hosts in einer verteilten Umgebung. Es bietet Netzwerkisolierung, Segmentierung und Konnektivitätsoptionen, die für verschiedene Einsatzszenarien geeignet sind.

Docker unterstützt mehrere Netzwerktypen, die jeweils unterschiedliche Anwendungsfälle bedienen:

• Brücke (Standard): Die Container auf demselben Host kommunizieren über ein internes virtuelles Netzwerk. Jeder Container erhält seine private IP-Adresse innerhalb des Brückennetzwerks, und sie können sich gegenseitig über Containernamen erreichen.
• Beispiel: docker network create my-bridge-network
• Ideal für den Betrieb von mehreren Containern auf einem einzigen Host, die sicher kommunizieren müssen, ohne dass die Dienste nach außen hin sichtbar sind.
• Host: Container nutzen den Netzwerkstack des Hosts und verwenden direkt die IP-Adresse und die Ports des Hosts.
• Beispiel: docker run --network host nginx
• Nützlich, wenn du eine hohe Leistung brauchst und keine Netzwerkisolierung erforderlich ist, z. B. bei der Ausführung von Überwachungsagenten oder Anwendungen mit niedriger Latenz.
• Overlay: Ermöglicht die Kommunikation von Containern auf verschiedenen Hosts durch die Schaffung eines verteilten Netzwerks.
• Beispiel: docker network create --driver overlay my-overlay-network
• Entwickelt für orchestrierte Implementierungen wie Docker Swarm, bei denen sich die Dienste über mehrere Knotenpunkte erstrecken.
• Macvlan: Weist jedem Container eine eindeutige MAC-Adresse zu, so dass er wie ein physisches Gerät im Netzwerk erscheint.
• Beispiel: docker network create -d macvlan --subnet=192.168.1.0/24 my-macvlan
• Wird verwendet, wenn Container direkten Netzwerkzugang benötigen, z. B. bei der Integration von Altsystemen oder bei der Interaktion mit physischen Netzwerken.

Container in eigenen Netzwerken betreiben

Wir zeigen dir, wie du ein eigenes Brückennetz einrichtest und benutzerdefiniertes Bridge-Netzwerk für die Container-Kommunikation einrichten und verwenden.

Schritt 1: Ein benutzerdefiniertes Netzwerk erstellen

Bevor wir Container einsetzen können, müssen wir zunächst ein dediziertes Netzwerk erstellen:

docker network create my-custom-network

Dieser Befehl erstellt ein isoliertes Netzwerk, dem Container für die Kommunikation zwischen den Containern beitreten können.

Schritt 2: Container im Netzwerk betreiben

Starten wir nun zwei Container und verbinden sie mit unserem neu erstellten Netzwerk:

docker run -d --network my-custom-network --name app1 my-app
docker run -d --network my-custom-network --name app2 my-app

• Das --network my-custom-network Flag verbindet den Container mit dem angegebenen Netzwerk.
• Das --name Flag vergibt einen eindeutigen Containernamen, damit er leichter referenziert werden kann.

Beide app11 and app2 can now communicate using their container names. You can test the connectivity using the ping` Befehl in einem der Container:

docker exec -it app1 ping app2

Wenn alles richtig eingerichtet ist, erhältst du eine Antwort, die bestätigt, dass die Container miteinander kommunizieren können.

Inspektion von Docker-Netzwerken

Um die Netzwerkkonfiguration und die angeschlossenen Container zu überprüfen, verwende:

docker network inspect my-custom-network

Dieser Befehl liefert Details über das Netzwerk, einschließlich IP-Bereiche, verbundene Container und Konfigurationen.

Ports freigeben und veröffentlichen

Wenn du Container betreibst, die von außen zugänglich sein müssen, kannst du bestimmte Ports freigeben.

Um zum Beispiel einen Nginx-Webserver zu betreiben und ihn auf Port 8080 deines lokalen Rechners freizugeben, verwende:

docker run -d -p 8080:80 nginx

Dadurch wird Port 80 innerhalb des Containers auf Port 8080 auf dem Host abgebildet, sodass der Dienst über http://localhost:8080.

Bewährte Praktiken für Docker-Netzwerke

• Verwende benutzerdefinierte Netzwerke: Vermeide es, das Standard-Bridge-Netzwerk für Produktionseinsätze zu verwenden, um unbeabsichtigten Zugriff zwischen Containern zu vermeiden.
• Nutzen Sie die DNS-basierte Erkennung: Anstatt IP-Adressen fest zu codieren, kannst du Containernamen verwenden, um eine dynamische Dienstsuche zu ermöglichen.
• Schränke die externe Exposition ein: Verwende Firewalls oder Netzwerkrichtlinien, um den Zugang zu Diensten zu kontrollieren.
• Überwache den Verkehr: Verwende Tools wie docker network inspect, Wireshark oder Prometheus, um den Netzwerkverkehr zu analysieren und Anomalien zu erkennen.
• Optimiere Overlay-Netzwerke: Wenn du ein verteiltes Netzwerk einrichtest, solltest du die Latenzzeiten in Overlay-Netzwerken verringern, indem du die hostlokalen Routing-Optionen nutzt.

Docker Best Practices und nächste Schritte

Nachdem du nun die Grundlagen von Docker kennengelernt hast, ist es an der Zeit, deine Fähigkeiten auszubauen und Best Practices anzuwenden, die dir helfen, sichere, effiziente und wartbare containerisierte Anwendungen zu erstellen.

Die folgenden Best Practices helfen dir, deine Docker-Workflows zu optimieren und häufige Fallstricke zu vermeiden.

• Verwende offizielle Basisbilder: Bevorzuge immer offizielle und gut gewartete Basis-Images, um Sicherheit und Stabilität zu gewährleisten. Offizielle Bilder sind optimiert, werden regelmäßig aktualisiert und enthalten mit geringerer Wahrscheinlichkeit Sicherheitslücken.
• Halte die Bilder klein: Reduziere die Bildgröße, indem du minimale Basisbilder wählst (z. B. python:3.9-slim statt python:3.9). Entferne unnötige Abhängigkeiten und Dateien, um Speicherplatz und Abrufzeiten zu optimieren.
• Verwende mehrstufige Builds: Optimiere Dockerdateien, indem du Build- und Runtime-Abhängigkeiten trennst. Mehrstufige Builds stellen sicher, dass nur die notwendigen Artefakte in das endgültige Image aufgenommen werden, was die Größe und die Angriffsfläche reduziert.
• Kennzeichne Bilder richtig: Verwende immer versionierte Tags (z. B. my-app:v1.0.0) anstelle von latest, um unerwartete Aktualisierungen beim Abrufen von Bildern zu vermeiden.
• Scanne Bilder auf Schwachstellen: Verwende Sicherheitsscanner wie docker scan, Trivy oder Clair, um Sicherheitslücken in deinen Images zu identifizieren und zu beheben, bevor du sie einsetzt.
• Verwalte die Umgebungsvariablen sicher: Vermeide es, sensible Daten in Bildern zu speichern. Verwende Docker-Geheimnisse, Umgebungsvariablen oder externe Tools zur Verwaltung von Geheimnissen wie AWS Secrets Manager oder HashiCorp Vault.
• Verwende .dockerignore-Dateien: Schließe unnötige Dateien aus (z. B. .git, node_modules, venv), um die Größe des Baukontextes zu reduzieren und zu verhindern, dass sensible Dateien versehentlich in Bilder eingefügt werden.
• Aktiviere die Protokollierung und Überwachung: Nutze Tools wie Prometheus, Grafana und Fluentd für Container-Logs und Monitoring. Untersuche Logs mit docker logs und aktiviere strukturiertes Logging für bessere Beobachtbarkeit.

Sobald du die Grundlagen von Docker beherrschst, gibt es viele fortgeschrittene Themen zu erforschen. Hier sind ein paar Bereiche, die du als Nächstes erkunden solltest:

• Docker Swarm & Kubernetes: Entdecke Docker Swarm (integriertes Clustering) und Kubernetes (Orchestrierung auf Unternehmensniveau mit automatischer Skalierung und Service Discovery) für eine Orchestrierung auf Produktionsniveau.
• Bewährte Praktiken zur Containersicherheit: Um containerisierte Anwendungen zu sichern, befolge die Richtlinien des CIS Docker Benchmark und implementiere eine rollenbasierte Zugriffskontrolle (RBAC).
• CI/CD-Pipelines mit Docker: Automatisiere Image-Builds, Sicherheitsscans und Bereitstellungen mit GitHub Actions, GitLab CI oder Jenkins.
• Cloud-native Entwicklung: Nutze Docker mit Cloud-Plattformen wie AWS ECS, Azure Container Instances und Google Cloud Run für skalierbare und verwaltete Bereitstellungen.
• Strategien für die Datenpersistenz: Für eine optimale Speicherverwaltung solltest du die Unterschiede zwischen Docker-Volumes, Bind-Mounts und tmpfs kennen.

Fazit

Docker hat die Art und Weise, wie Entwickler Anwendungen erstellen, ausliefern und ausführen, revolutioniert und ist zu einem unverzichtbaren Werkzeug für die moderne Softwareentwicklung geworden.

In diesem Tutorial haben wir das Thema behandelt:

• Was Docker ist und warum es wichtig ist
• So installierst und betreibst du deinen ersten Container
• Schlüsselkonzepte wie Images, Container und Netzwerke
• Persistente Speicherung mit Docker-Volumes
• Multi-Container-Anwendungen mit Docker Compose
• Best Practices für Sicherheit, Leistung und Skalierbarkeit

Aber das ist erst der Anfang! Wenn du deine Docker-Kenntnisse vertiefen möchtest, kannst du einen Einführungskurs für Anfänger/innen besuchen. Wenn du dein Wissen vertiefen möchtest, kannst du einen Docker-Kurs für Fortgeschrittene belegen, der sich mit mehrstufigen Builds, Docker-Netzwerk-Tools und Docker Compose befasst. Schließlich kannst du auch eine Docker-Zertifizierung anstreben. Schau dir bei Interesse den The Complete Docker Certification (DCA) Guide für 2025 an!