Docker- und Container-Konzepte

12 September 2025
Zusammenfassung: In diesem umfassenden Leitfaden lernen Sie die Grundlagen von Docker und Container-Technologien kennen und erfahren, wie Sie Ihre Anwendungen in moderne Softwareentwicklungs- und DevOps-Prozesse integrieren können. Sie entdecken die Unterschiede zwischen Containern und virtuellen Maschinen, verstehe
Docker- und Container-Konzepte

Schritt 1 — Docker- und Container-Konzepte

Docker-Container bündeln alle Abhängigkeiten und Konfigurationen, die für den Betrieb einer Anwendung erforderlich sind, in einem einzigen Paket. Dies ermöglicht:

  • die Beseitigung des „Es funktioniert auf meinem Rechner“-Problems
  • konsistente Ausführung desselben Images in verschiedenen Umgebungen
  • schnelles Starten und Stoppen von Anwendungen

Container basieren auf den Linux-Technologien „Namespaces“ und „cgroups“. Namespaces isolieren Netzwerk, Prozesse und Benutzerbereiche jedes Containers. Cgroups ermöglichen die Ressourcenkontrolle (CPU, RAM, Festplatte).

Schritt 2 — Docker-Installation

Installation unter Ubuntu/Debian:

sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg lsb-release
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Überprüfen Sie die Installation:

docker --version
docker compose version

Stellen Sie sicher, dass der Docker-Dienst aktiv ist:

sudo systemctl status docker

Schritt 3 — Verwaltung von Docker-Images

Docker-Images enthalten das Dateisystem und alle Abhängigkeiten, die für den Betrieb von Containern erforderlich sind.

docker pull nginx:latest
docker images
docker rmi nginx:latest
docker tag nginx:latest meinrepo/nginx:v1
docker save -o nginx.tar nginx:latest
docker load -i nginx.tar

Images bestehen aus mehreren Schichten, was Speicherplatz spart und Build-Zeiten optimiert. Als Best Practice sollten Sie Ihre Dockerfile-Befehle logisch gruppieren und unnötige Pakete entfernen.

Schritt 4 — Verwaltung von Docker-Containern

Container sind laufende Instanzen von Images.

# Container starten
docker run -d --name web -p 8080:80 nginx:latest

# Laufende Container auflisten
docker ps

# Alle Container auflisten
docker ps -a

# Logs anzeigen
docker logs -f web

# In Container einsteigen
docker exec -it web bash

# Container stoppen/starten
docker stop web
docker start web

# Container löschen
docker rm web

Container sind flüchtig (ephemeral). Für persistente Daten sollten Volumes verwendet werden.

Schritt 5 — Volumes und Datenmanagement

Volumes ermöglichen die dauerhafte Speicherung von Daten außerhalb des Containers.

docker volume create meinvol
docker run -d -v meinvol:/daten nginx
docker volume ls
docker volume inspect meinvol
docker volume rm meinvol

Volumes werden standardmäßig unter /var/lib/docker/volumes/ gespeichert.

Ein Beispiel zum Mounten eines lokalen Host-Verzeichnisses:

docker run -d -v /home/benutzer/daten:/daten nginx

Backup eines Volumes:

docker run --rm -v meinvol:/daten -v $(pwd):/backup busybox tar czf /backup/vol_backup.tar.gz /daten

Schritt 6 — Netzwerkmanagement

Docker-Netzwerke ermöglichen die Kommunikation zwischen Containern.

docker network ls
docker network create meinnetz
docker run -d --name app1 --network=meinnetz nginx
docker run -d --name app2 --network=meinnetz nginx
docker exec -it app1 ping app2

Bridge-Modus ist Standard. Benutzerspezifische Netzwerke ermöglichen automatische DNS-Namensauflösung.

Schritt 7 — Docker Compose

Docker Compose erlaubt es, Multi-Container-Anwendungen über eine YAML-Datei zu definieren.

Beispiel docker-compose.yml:

version: '3.9'
services:
  web:
    image: nginx
    ports:
      - "80:80"
# Anwendung starten
docker compose up -d

# Status prüfen
docker compose ps

# Logs ansehen
docker compose logs

# Anwendung stoppen
docker compose down

Man kann auch build: anstelle von image: verwenden, um Images aus Dockerfiles zu bauen.

Schritt 8 — Verwendung von Docker Registry

Registries dienen zum Speichern und Verteilen von Docker-Images. Docker Hub ist die Standard-Registry, aber man kann auch eine eigene betreiben.

# Bei Docker Hub anmelden
docker login

# Image taggen und pushen
docker tag nginx:latest meinbenutzer/nginx:v1
docker push meinbenutzer/nginx:v1

Lokale Registry betreiben:

docker run -d -p 5000:5000 --name registry registry:2

docker tag nginx:latest localhost:5000/nginx
docker push localhost:5000/nginx
docker pull localhost:5000/nginx

Schritt 9 — Dockerfile & Multi-Stage Build

Ein Dockerfile definiert, wie ein Docker-Image gebaut wird.

Einfaches Beispiel:

FROM python:3.11-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "main.py"]

Image bauen:

docker build -t meineapp:1.0 .

Multi-Stage Build Beispiel:

# Builder-Phase
FROM node:18 AS builder
WORKDIR /build
COPY . .
RUN npm install && npm run build

# Laufzeit-Phase
FROM nginx:alpine
COPY --from=builder /build/dist /usr/share/nginx/html

CMD ["nginx", "-g", "daemon off;"]

Ergebnis: kleinere Images und bessere Performance.

Schritt 10 — Orchestrierung (Swarm vs Kubernetes)

Orchestrierungs-Tools verwalten mehrere Container und Hosts. Beliebte Optionen sind Docker Swarm und Kubernetes.

Docker Swarm:

docker swarm init
docker service create --replicas 3 --name web nginx

Kubernetes:

kubectl apply -f deployment.yaml
kubectl get pods
kubectl scale deployment web --replicas=5

Swarm ist einfacher, aber Kubernetes ist leistungsfähiger und flexibler.

Schritt 11 — Sicherheits-Best-Practices

  • Vermeide root-Rechte im Container
  • Verwende minimale Basis-Images (z. B. alpine)
  • Setze Ressourcen-Limits (CPU, RAM)
  • Scanne Images regelmäßig (z. B. Trivy)
  • Halte Docker aktuell
  • Vermeide feste Secrets im Dockerfile

Image-Scan mit Trivy:

trivy image meineapp:1.0

Schritt 12 — Monitoring & Logging

Verwende eingebaute Docker-Kommandos oder integriere Tools:

Logs anzeigen:

docker logs meineapp

Monitoring-Tools:

  • Prometheus
  • Grafana
  • cAdvisor
  • ELK Stack / Loki

Beispiel Prometheus + Grafana:

  • Verwende node-exporter & cadvisor als Exporter
  • Visualisiere Metriken in Grafana-Dashboards

Schritt 13 — Praxisbeispiel: Flask App

Projektstruktur:

app/
├── main.py
├── requirements.txt
└── Dockerfile

main.py:

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hallo von Docker!"

requirements.txt:

flask

Dockerfile:

FROM python:3.11-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "main.py"]

Build & Run:

docker build -t flask-app .
docker run -d -p 5000:5000 flask-app

Rufe http://localhost:5000 auf, um die App zu testen.

Fazit

In diesem Leitfaden haben Sie Schritt für Schritt gelernt, wie Sie mit Docker und Container-Technologien arbeiten. Von der Verwaltung von Images und Containern über Netzwerke und Volumes bis hin zu Multi-Container-Orchestrierung und Sicherheit — Sie sind jetzt in der Lage, eigene Anwendungen zu dockerisieren und produktionsbereit bereitzustellen.

Nächste Schritte

  • Grundlagen von Kubernetes erlernen
  • Helm Charts erkunden
  • CI/CD-Pipelines mit Jenkins oder GitHub Actions implementieren
  • Monitoring mit Prometheus und Grafana einrichten
Zurück zur Artikelseite