🐳 Docker

Multilingual DevOps cheat sheet: Linux, Docker, Git, Kubernetes, Helm, Terraform, practical scenarios & templates.

Docker ist eine Plattform zum Ausführen von Anwendungen in isolierten Containern. Dieses Spickzettel enthält Befehle für die Arbeit mit Images, Containern, Netzwerken, Volumes sowie Docker Compose und Swarm.

📦 Grundlegende Befehle

Befehl	Beispiel	Beschreibung
docker		Der Hauptbefehl der Docker-CLI zum Ausführen von Unterbefehlen und Verwalten von Containern, Images, Netzwerken und Volumes
docker version		Installierte Docker-Version (Client und Server) anzeigen. Nützlich zur Überprüfung der Installation
	docker version --format '{{.Client.APIVersion}}'	Nur die Docker-Client-API-Version anzeigen
	docker version --format '{{.Server.Version}}'	Nur die Docker-Server- (Engine-)Version anzeigen
	docker version --format '{{json .}}'	Vollständige Versionsinformationen im JSON-Format ausgeben
docker system info		Allgemeine Docker-Systeminformationen anzeigen: Anzahl der Container, Images, Ressourcen
	docker info	Docker-Daten anzeigen: Versionen, Netzwerke, Anzahl der Container und Images
	docker info --format '{{json .}}'	Informationen im JSON-Format ausgeben — nützlich für Automatisierung
	docker info --format '{{.NCPU}} CPUs, {{.MemTotal}} bytes RAM'	Anzahl der CPUs und Gesamtspeicher anzeigen
	docker info --format '{{.Driver}}'	Den von Docker verwendeten Storage-Treiber anzeigen
docker image pull		Ein Image von Docker Hub oder einer anderen Registry herunterladen. Container können ohne Images nicht ausgeführt werden
	docker pull ubuntu	Das neueste verfügbare Ubuntu-Image herunterladen
	docker pull nginx:alpine	Das schlanke Nginx-Image basierend auf Alpine Linux herunterladen
	docker pull redis:7	Redis-Image in Version 7 herunterladen
docker container run		Einen neuen Container aus einem Image erstellen und starten
	docker run -it ubuntu bash	Ubuntu mit einem interaktiven Bash-Terminal ausführen
	docker run -d nginx	Nginx im Detached-Modus (Hintergrund) starten
	docker run -p 8080:80 nginx	Nginx ausführen und Container-Port 80 an Host-Port 8080 binden
docker container ls		Laufende Container auflisten
	docker ps	Nur laufende Container anzeigen
	docker ps -a	Alle Container einschließlich gestoppter anzeigen
	docker ps --format '{{.Names}}'	Nur Containernamen ausgeben
docker container start		Einen oder mehrere gestoppte Container starten
	docker start container_name	Einen Container nach Namen starten
	docker start $(docker ps -aq)	Alle Container starten
	docker start -ai container_name	Einen Container starten und interaktives Terminal anhängen
docker container stop		Einen laufenden Container stoppen
	docker stop container_name	Einen Container nach Namen stoppen
	docker stop $(docker ps -q)	Alle laufenden Container stoppen
	docker stop -t 5 container_name	Einen Container mit 5 Sekunden Zeit zum Beenden stoppen
docker container restart		Einen Container neu starten
	docker restart container_name	Einen bestimmten Container neu starten
	docker restart $(docker ps -q)	Alle laufenden Container neu starten
	docker restart -t 10 container_name	Einen Container mit 10 Sekunden Verzögerung neu starten
docker container rm		Einen Container entfernen
	docker rm container_name	Einen bestimmten gestoppten Container entfernen
	docker rm $(docker ps -aq)	Alle gestoppten Container entfernen
	docker rm -f container_name	Einen laufenden Container erzwingen und entfernen
docker image ls		Heruntergeladene Images auflisten
	docker images	Alle Images auf dem Host anzeigen
	docker images -a	Alle Images einschließlich Zwischenebenen anzeigen
	docker images --format '{{.Repository}}:{{.Tag}}'	Nur Imagenamen und Tags ausgeben
docker image rm		Ein oder mehrere Images aus dem lokalen Speicher entfernen
	docker rmi test1:latest	Image mit Tag latest aus Repository test1 entfernen
	docker rmi 1a2b3c4d5e6f	Ein Image nach seiner ID entfernen
	docker rmi $(docker images -q)	Alle Images entfernen (mit Vorsicht verwenden!)

🔁 Containerverwaltung

Befehl	Beispiel	Beschreibung
docker container exec		Einen Befehl in einem laufenden Container ausführen
	docker exec -it container bash	Eine interaktive Bash-Shell im Container container starten
	docker exec container ls /app	ls-Befehl im Verzeichnis /app innerhalb des Containers ausführen
	docker exec -d container touch /tmp/testfile	Einen Befehl im Container im Detached-Modus ausführen (ohne Warten)
docker container logs		Container-Logs anzeigen
	docker logs container	Alle Logs des Containers container anzeigen
	docker logs -f container	Container-Logs in Echtzeit verfolgen
	docker logs --tail 50 container	Die letzten 50 Zeilen der Logs anzeigen
docker inspect		Detaillierte JSON-Informationen zu einem Container oder Image abrufen
	docker inspect container	Details des Containers container anzeigen
	docker inspect --format '{{.NetworkSettings.IPAddress}}' container	Die IP-Adresse des Containers anzeigen
docker container stats		Echtzeit-Statistiken zur Ressourcennutzung von Containern anzeigen
	docker stats	CPU-, Speicher-, Netzwerk- und Festplattennutzung für alle Container anzeigen
	docker stats container_name	Nur Statistiken für einen bestimmten Container anzeigen
	docker stats --no-stream	Einmalige Momentaufnahme der Statistiken anzeigen und beenden
docker container rename		Einen Container umbenennen
	docker rename old_name new_name	Container von old_name in new_name umbenennen
docker container cp		Dateien zwischen einem Container und dem Host kopieren
	docker cp container:/src/file.txt ./file.txt	Eine Datei vom Container in das aktuelle Host-Verzeichnis kopieren
	docker cp ./config.yaml container:/app/config.yaml	Eine Datei vom Host in den Container kopieren
	docker cp CONTAINER:/var/logs/app.log - | tar x -O | grep "ERROR"	Eine Logdatei aus dem Container streamen und Zeilen mit “ERROR” filtern, ohne auf Platte zu speichern
docker container top		Laufende Prozesse in einem Container anzeigen
	docker top container	Prozesse des Containers container anzeigen
docker container pause		Alle Prozesse in einem Container anhalten
	docker pause container	Den Container container anhalten
docker container unpause		Einen angehaltenen Container fortsetzen
	docker unpause container	Den Container container fortsetzen
docker container update		Container-Einstellungen ohne Neustart aktualisieren
	docker update --memory 500m container	Den Speicherverbrauch des Containers auf 500 MB begrenzen

🧱 Images und Dockerfile

Befehl	Beispiel	Beschreibung
docker buildx build		Ein Docker-Image aus einem Dockerfile erstellen
	docker build -t my_image .	Ein Image mit Tag my_image aus dem aktuellen Verzeichnis erstellen
	docker build -t my_image:1.0 .	Ein Image mit Tag 1.0 erstellen
	docker build --no-cache -t my_image .	Ein Image ohne Cache für einen sauberen Build erstellen
docker container commit		Ein Image aus dem aktuellen Zustand eines Containers erstellen
	docker commit container my_img:v1	Image my_img mit Tag v1 aus Container container erstellen
	docker commit -m "Added config" container my_img:v2	Ein Image mit Commit-Nachricht erstellen
	docker commit -a "John Doe" container my_img:latest	Ein Image mit Angabe des Autors erstellen
docker image tag		Einen Image-Tag hinzufügen oder ändern
	docker tag my_image myrepo/my_image:latest	Einen Tag zum Push in die Registry myrepo hinzufügen
	docker tag my_image:1.0 my_image:stable	Tag stable für Image mit Tag 1.0 erstellen
	docker tag my_image my_image:backup	Einen backup-Tag zu einem lokalen Image hinzufügen
docker image push		Ein Image zu Docker Hub oder einer anderen Registry hochladen
	docker push myrepo/my_image:latest	Image mit Tag latest ins Repository myrepo hochladen
	docker push myrepo/my_image:1.0	Image mit Tag 1.0 hochladen
	docker push myrepo/my_image	Image mit Standard-Tag latest hochladen
docker login		Bei Docker Hub oder einer anderen Registry authentifizieren
	docker login	Benutzername und Passwort interaktiv für Docker Hub eingeben
	docker login myregistry.local:5000	Bei einer privaten Registry anmelden
	docker login -u username -p password	Login mit Benutzername und Passwort (nicht empfohlen)
docker logout		Von Docker Hub oder einer anderen Registry abmelden
	docker logout	Von Docker Hub abmelden
	docker logout myregistry.local:5000	Von privater Registry abmelden
HEALTHCHECK		Dockerfile-Anweisung zur automatischen Überprüfung des Container-Gesundheitsstatus
	HEALTHCHECK --interval=30s --timeout=5s --retries=3 CMD curl -f http://localhost/ || exit 1	Healthcheck hinzufügen, um die Dienstverfügbarkeit alle 30 Sekunden zu prüfen
	docker inspect --format='{{json .State.Health}}' container_name	Den Healthcheck-Status eines laufenden Containers prüfen

🔌 Netzwerke und Volumes

Befehl	Beispiel	Beschreibung
docker network ls		Alle Docker-Netzwerke auflisten
	docker network ls	Alle erstellten Docker-Netzwerke anzeigen
	docker network ls --filter driver=bridge	Nur Netzwerke mit dem Treiber bridge anzeigen
	docker network ls --format '{{.Name}}'	Nur Netzwerknamen anzeigen
docker network create		Ein neues Docker-Netzwerk erstellen
	docker network create my_net	Ein Netzwerk my_net mit Standardeinstellungen erstellen
	docker network create --driver bridge my_bridge_net	Ein Netzwerk mit dem Treiber bridge erstellen
	docker network create --subnet=192.168.10.0/24 my_custom_net	Ein Netzwerk mit einem angegebenen Subnetz erstellen
docker network connect		Einen Container mit einem Netzwerk verbinden
	docker network connect my_net container	Container container mit Netzwerk my_net verbinden
	docker network connect --alias db_net my_net container	Mit Alias db_net verbinden
docker network disconnect		Einen Container von einem Netzwerk trennen
	docker network disconnect my_net container	Container container vom Netzwerk my_net trennen
docker volume ls		Alle Docker-Volumes auflisten
	docker volume ls	Alle Docker-Volumes anzeigen
	docker volume ls --filter dangling=true	Nicht verwendete Volumes anzeigen
docker volume create		Ein neues Docker-Volume erstellen
	docker volume create my_vol	Ein Volume mit Namen my_vol erstellen
	docker volume create --driver local --opt type=tmpfs my_tmp_vol	Ein temporäres Volume mit tmpfs erstellen
docker volume inspect		Detaillierte Informationen über ein Volume anzeigen
	docker volume inspect my_vol	Details des Volumes my_vol im JSON-Format anzeigen
docker volume rm		Ein oder mehrere Volumes entfernen
	docker volume rm my_vol	Volume my_vol entfernen
	docker volume rm $(docker volume ls -qf dangling=true)	Alle ungenutzten Volumes entfernen

🧩 Docker-Plugins

Befehl	Beispiel	Beschreibung
docker plugin ls		Installierte Docker-Plugins auflisten
	docker plugin ls	Alle Plugins und deren Status anzeigen
docker plugin install		Ein Docker-Plugin aus einer Registry installieren
	docker plugin install vieux/sshfs	Das SSHFS-Volume-Plugin installieren
	docker plugin install store/weaveworks/net-plugin:latest_release	Das Weave-Netzwerk-Plugin installieren
docker plugin disable		Ein installiertes Plugin deaktivieren
	docker plugin disable vieux/sshfs	Das SSHFS-Plugin deaktivieren
docker plugin enable		Ein zuvor deaktiviertes Plugin aktivieren
	docker plugin enable vieux/sshfs	Das SSHFS-Plugin aktivieren
docker plugin rm		Ein Docker-Plugin entfernen
	docker plugin rm vieux/sshfs	Das SSHFS-Plugin entfernen

📋 Docker Compose

Befehl	Beispiel	Beschreibung
docker compose up		Container starten, die in docker-compose.yml definiert sind
	docker compose up	Alle Dienste im aktuellen Verzeichnis im interaktiven Modus starten
	docker compose up -d	Dienste im Detached-Modus (Hintergrund) starten
	docker compose up --build	Images vor dem Start der Dienste bauen
docker compose down		Container, Netzwerke und Volumes stoppen und entfernen, die durch up erstellt wurden
	docker compose down	Alle laufenden Dienste stoppen und zugehörige Ressourcen entfernen
	docker compose down --volumes	Zusätzlich Volumes entfernen, die von Compose erstellt wurden
	docker compose down --rmi all	Zusätzlich Images entfernen, die von Compose erstellt wurden
docker compose logs		Logs aller oder bestimmter Dienste anzeigen
	docker compose logs	Logs aller Dienste anzeigen
	docker compose logs -f	Logs in Echtzeit verfolgen
	docker compose logs web	Nur Logs des Dienstes web anzeigen
docker compose exec		Einen Befehl in einem laufenden Service-Container ausführen
	docker compose exec web bash	Eine interaktive Bash-Shell im web-Service-Container öffnen
	docker compose exec db ls /var/lib/postgresql	ls-Befehl im Datenbank-Container ausführen
	docker compose exec -d worker touch /tmp/done	Einen Befehl im worker-Container im Detached-Modus ausführen
docker compose build		Service-Images bauen oder neu bauen
	docker compose build	Alle Images aus docker-compose.yml bauen
	docker compose build web	Nur das web-Service-Image bauen
	docker compose build --no-cache	Images ohne Cache bauen
docker compose ps		Status aller Dienste und Container anzeigen
	docker compose ps -a	Alle Container einschließlich gestoppter anzeigen
	docker compose ps --services	Nur die Servicenamen anzeigen
docker compose pull		Service-Images aus Registry herunterladen/aktualisieren
	docker compose pull web	Nur Image für den Dienst web herunterladen
	docker compose pull --ignore-pull-failures	Trotz Fehlern bei einigen Images fortsetzen
docker compose restart		Alle oder bestimmte Dienste neu starten
	docker compose restart db	Nur den Dienst db neu starten
	docker compose restart -t 10	Dienste mit 10-Sekunden-Timeout neu starten
docker compose config		Die endgültige Compose-Konfiguration im YAML-Format anzeigen
	docker compose config --services	Alle Dienste in der Konfiguration auflisten
	docker compose config --volumes	Alle Volumes in der Konfiguration auflisten
docker compose start		Gestoppte Dienste starten, ohne Container neu zu erstellen
	docker compose start web	Den Dienst web starten
	docker compose start db api	Mehrere Dienste auf einmal starten
docker compose stop		Dienste stoppen, ohne Container zu entfernen
	docker compose stop web	Den Dienst web stoppen
	docker compose stop -t 5	Dienste mit 5-Sekunden-Timeout stoppen

📤 Export und Import

Befehl	Beispiel	Beschreibung
docker image save		Ein oder mehrere Docker-Images in ein TAR-Archiv speichern für späteren Import oder Transfer
	docker save -o image.tar my_img:tag	Ein Docker-Image in eine TAR-Datei speichern
	docker save my_image > my_image.tar	Alternative Methode, ein Image in eine Datei zu speichern
	docker save -o redis_latest.tar redis:latest	Ein bestimmtes Redis-Image in eine Datei speichern
docker image load		Docker-Images aus einem zuvor gespeicherten TAR-Archiv laden
	docker load < image.tar	Ein Docker-Image aus einer TAR-Datei laden
	docker load --input redis_latest.tar	Ein Image mit Parameter zur Datei laden
	docker load --quiet < my_image.tar	Ein Image ohne Fortschrittsanzeige laden
docker container export		Dateisystem eines Containers als TAR-Archiv exportieren, ohne Image-Historie oder Metadaten
	docker export container > file.tar	Container-Dateisystem in ein Archiv exportieren
	docker export my_container > my_container_fs.tar	Container nach Name exportieren
	docker export -o container_fs.tar container_id	Container nach ID mit dem Flag -o exportieren
docker image import		Ein neues Image aus einem TAR-Archiv eines Dateisystems erstellen
	docker import file.tar new_img	Archivdatei als neues Docker-Image importieren
	docker import https://example.com/image.tar my_new_image	Image direkt von einer URL importieren
	docker import - my_image < file.tar	Von Standardeingabe importieren

🧹 Aufräumen und Diagnose

Befehl	Beispiel	Beschreibung
docker system df		Docker-Speichernutzung anzeigen: Volumes, Images, Container und Build-Cache
	docker system df -v	Detaillierte Ausgabe mit Infos zu jedem Image, Container und Volume
	docker system df --format '{{json .}}'	Informationen im JSON-Format ausgeben
docker system prune		Alle ungenutzten Docker-Daten entfernen: gestoppte Container, ungenutzte Netzwerke, hängende Images und Build-Cache
	docker system prune -a	Unbenutzte Images einschließlich Zwischenschichten entfernen
	docker system prune --volumes	Unbenutzte Volumes zusammen mit anderen Ressourcen entfernen
docker image prune		Unbenutzte Docker-Images einschließlich hängender Schichten entfernen
	docker image prune -a	Alle unbenutzten Images einschließlich hängender entfernen
	docker image prune --filter "until=24h"	Images entfernen, die älter als 24 Stunden sind
docker container prune		Gestoppte Container entfernen, die Filtern entsprechen, oder alle, falls keine angegeben
	docker container prune --filter "until=24h"	Gestoppte Container entfernen, die älter als 24 Stunden sind
	docker container prune --force	Ohne Bestätigung entfernen

🐝 Docker Swarm

Befehl	Beispiel	Beschreibung
docker swarm init		Einen neuen Docker-Swarm-Cluster auf dem aktuellen Knoten initialisieren
	docker swarm init --advertise-addr 192.168.1.100	Cluster initialisieren und IP-Adresse angeben
	docker swarm init --listen-addr 0.0.0.0:2377	Mit angegebenem Listen-Port initialisieren
docker service create		Einen neuen Dienst im Swarm-Cluster erstellen
	docker service create --name nginx nginx	Einen Nginx-Dienst im Swarm erstellen
	docker service create --replicas 3 --name web webserver	Einen Dienst mit 3 Replikaten erstellen
	docker service create --name redis --publish 6379:6379 redis	Einen Dienst mit Port-Mapping erstellen
docker stack deploy		Einen Stack von Diensten im Swarm-Cluster anhand einer Compose-Datei bereitstellen
	docker stack deploy -c docker-compose.yml mystack	Stack aus Compose-Datei bereitstellen
	docker stack deploy --with-registry-auth -c compose.yml mystack	Mit Weitergabe der Registry-Authentifizierung bereitstellen
	docker stack deploy -c swarm-compose.yml mystack	Eine alternative Compose-Datei für den Stack verwenden
docker stack rm		Einen oder mehrere Stacks aus dem Swarm-Cluster entfernen
	docker stack rm mystack	Den Stack mystack entfernen
	docker stack rm	Alle Stacks entfernen (nicht empfohlen)
	docker stack rm mystack && docker swarm leave --force	Stack entfernen und Swarm verlassen

💼 Erweiterte Docker-Nutzung

🚀 Professionelle Docker-Befehle

Befehl	Beispiel	Beschreibung
docker buildx		Erweitertes Image-Build-Tool als Ersatz für docker build. Unterstützt Multi-Plattform, Caching, parallele Builds und Export in verschiedene Formate. Nützlich für CI/CD und plattformübergreifende Entwicklung
	docker buildx build --platform linux/arm64,linux/amd64 -t myimg:multi .	Ein Multi-Plattform-Image bauen (ARM und x86 gleichzeitig)
	docker buildx build --load -t localimg .	Ein Image bauen und in den lokalen Docker-Engine-Cache laden
	docker buildx build --push --platform linux/amd64,linux/arm64 -t repo/app:latest .	Ein Multi-Plattform-Image bauen und in eine Registry pushen
docker context		Docker-Kontexte für Remote- oder Multi-Umgebungen verwalten. Ermöglicht schnelles Umschalten zwischen lokaler und entfernter Docker-Engine
	docker context create myremote --docker "host=ssh://user@host"	Einen Kontext zum Verbinden mit einem Remote-Docker-Host erstellen
	docker context use myremote	Zum Remote-Kontext wechseln
	docker context ls	Verfügbare Kontexte und den aktiven auflisten
docker system events		Docker-Ereignisse in Echtzeit überwachen, gefiltert nach Ereignistyp (z. B. Container-Start). Nützlich für Monitoring und Automatisierung
	docker events --filter 'event=start'	Nur Container-Start-Ereignisse anzeigen
	docker events --since 1h --until 10m	Ereignisse der letzten Stunde bis vor 10 Minuten anzeigen
	docker events --filter 'type=network'	Nur netzwerkbezogene Ereignisse anzeigen
	docker events --filter 'image=nginx'	Ereignisse zum Image nginx anzeigen
docker container update		Ressourcenlimits und Einstellungen eines laufenden Containers ändern, ohne ihn neu zu starten
	docker update --cpus 2 --memory 1g my_container	Limit auf 2 CPUs und 1 GB RAM setzen
	docker update --restart unless-stopped my_container	Auto-Restart-Policy auf unless-stopped setzen
	docker update --pids-limit 200 my_container	Die Anzahl der Prozesse auf 200 begrenzen
docker container diff		Dateisystemänderungen in einem Container im Vergleich zu seinem ursprünglichen Image anzeigen. Nützlich für Debugging und Audits
	docker diff my_container	Alle Dateisystemänderungen im Container anzeigen
	docker diff my_container | grep '^A'	Nur hinzugefügte Dateien anzeigen (A — Added)
docker image history		Verlauf der Image-Layer anzeigen: Build-Befehle, Größe jeder Schicht und Erstellungszeit. Nützlich für Optimierung und Audits
	docker history my_image	Layer-Historie eines Images anzeigen
	docker history --no-trunc my_image	Vollständige Build-Befehle ohne Kürzung anzeigen
	docker history --format "{{.CreatedBy}}: {{.Size}}" my_image	Nur Build-Befehle und Layer-Größen ausgeben

🛠 Nützliche Docker-Praktiken und Automatisierung

• Image-Größe minimieren
  Basis-Images wie alpine oder scratch für minimale Größe verwenden.
  Um Layer zusammenzuführen, kann --squash beim Build genutzt werden (erfordert aktivierte experimentelle Features).
  Auch temporäre Dateien und Caches in einer einzigen Schicht entfernen:

  RUN apk add --no-cache curl && rm -rf /var/cache/apk/*

• Anzahl der Layer minimieren
  Befehle in einem RUN kombinieren, um die Anzahl der Layer und die finale Image-Größe zu reduzieren:

  RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

• Dockerfile-Build optimieren
  Multi-Stage-Builds verwenden, sodass nur notwendige Dateien im finalen Image verbleiben.
  Zuerst Abhängigkeiten kopieren und installieren, dann Code — verbessert Layer-Caching und beschleunigt Rebuilds.

• Secrets und Konfigurationen trennen
  Keine .env-Dateien, API-Keys oder privaten Zertifikate im Image speichern.
  Für Konfiguration verwenden:

  • docker secret (in Swarm)
    
  • Umgebungsvariablen (-e VAR=Wert oder .env)
    

  • Externe Volumes für Konfigurationen

• Build-Zeit-Secrets (BuildKit)
  Für sicheres Übergeben von Secrets während des Builds das Flag --secret verwenden:

  docker buildx build --secret id=mysecret,src=./secret.txt .

  Im Dockerfile ist das Secret unter /run/secrets/mysecret verfügbar:

  RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret

  🛡 Dadurch werden Secrets nicht in Image-Layern gespeichert.

• Rootless Docker
  Docker ohne Root-Rechte auszuführen verbessert die Sicherheit und reduziert das Risiko für den Host.
  Zum Aktivieren:

  dockerd-rootless-setuptool.sh install
  export PATH=/usr/bin:$PATH

  Überprüfen:

  docker info | grep Rootless

  ⚠ Einige Features (z. B. Portweiterleitung <1024) sind nicht verfügbar.

• Images auf Schwachstellen scannen
  Eingebaute Tools verwenden:

  docker scan my_image

  Oder das neue CLI:

  docker scout cves my_image

  Hilft, Schwachstellen in Basis-Images und Abhängigkeiten zu erkennen.

• Ressourcennutzung überwachen
  Container nach Speicher, CPU und Prozessanzahl begrenzen:

  docker run --memory=512m --cpus="1.5" --pids-limit=200 myimage

  Dies verhindert übermäßigen Ressourcenverbrauch.
  Man kann auch I/O begrenzen:

  docker run --device-read-bps /dev/sda:1mb --device-write-bps /dev/sda:1mb myimage

  Nützlich für Container, die das Subsystem nicht überlasten sollen.

• Automatisches Aufräumen
  Regelmäßig unbenutzte Images, Container, Volumes und Netzwerke entfernen:

  docker system prune -af --volumes

  ⚠ Vorsicht: Dieser Befehl löscht alle unbenutzten Ressourcen.

  Für selektives Aufräumen verwenden:

  docker image prune --filter "until=24h"

• CI/CD-Integration
  Build, Tests und Deployment in GitHub Actions, GitLab CI, Jenkins-Pipelines einbetten.
  Beispiel GitHub Actions Schritt:

  - run: docker build -t myapp:${GITHUB_SHA} .
  - run: docker push myapp:${GITHUB_SHA}

• Logging und Monitoring
  Logging-Driver (--log-driver) an zentrale Systeme wie ELK, Loki, Splunk anhängen.
  Prometheus + cAdvisor für Container-Metriken verwenden.

• Produktivbereitstellung
  Getrennte Konfigurationen für Entwicklung und Produktion mit docker-compose.override.yml.
  Für Hochverfügbarkeit und Skalierung verwenden:

  • Docker Swarm
    

  • Kubernetes

🐞 Debugging und Profiling von Docker-Containern

Befehl	Beispiel	Beschreibung
docker container exec		Führt einen Befehl in einem laufenden Container aus und ermöglicht interaktiven Zugriff oder das Ausführen von Prozessen in der isolierten Umgebung des Containers
	docker exec -it my_container bash	Ein interaktives Terminal (bash) in einem laufenden Container starten
	docker exec -it my_container sh	Eine minimale Shell im Container starten (falls bash nicht verfügbar ist)
	docker exec my_container ls /app	Einen Befehl im Container ohne interaktiven Modus ausführen
docker container logs		Zeigt Logs des angegebenen Containers an, um Ausgaben und Ereignisse zur Diagnose und Überwachung einzusehen
	docker logs -f --tail 100 my_container	Die letzten 100 Zeilen der Logs mit Live-Streaming anzeigen
	docker logs my_container	Alle verfügbaren Logs des Containers anzeigen
	docker logs --since 1h my_container	Logs der letzten Stunde anzeigen
docker inspect		Gibt detaillierte Informationen zu einem Docker-Objekt (Container, Image, Netzwerk usw.) im JSON-Format aus, einschließlich Konfiguration und Status
	docker inspect my_container	Vollständige JSON-Infos zum Container abrufen
	docker inspect --format '{{.State.Pid}}' my_container	Die PID des Hauptprozesses des Containers auf dem Host abrufen
	docker inspect --format '{{.NetworkSettings.IPAddress}}' my_container	Die IP-Adresse des Containers anzeigen
nsenter (with strace)		Linux-Tool zum Betreten der Namespaces eines anderen Prozesses (hier des Containers). Wird mit strace verwendet, um Systemaufrufe im Container zum Debugging nachzuverfolgen
	nsenter --target $(docker inspect --format '{{.State.Pid}}' my_container) --mount --uts --ipc --net --pid strace -p 1	Container-Namespaces betreten und Systemaufrufe des Prozesses 1 nachverfolgen
	nsenter --target $(docker inspect --format '{{.State.Pid}}' my_container) --mount --uts --ipc --net --pid bash	Eine Bash-Shell innerhalb der Container-Namespaces öffnen
	nsenter --target $(docker inspect --format '{{.State.Pid}}' my_container) --net netstat -tulnp	Offene Ports im Container anzeigen
tcpdump (inside container)		Konsolentool zum Erfassen und Analysieren von Netzwerkverkehr. Wird im Container verwendet, um Netzwerkprobleme zu diagnostizieren, Pakete zu analysieren und Verbindungen zu überwachen
	docker exec -it my_container tcpdump -i any	Netzwerkverkehr im Container erfassen und analysieren
	docker exec -it my_container tcpdump -nn port 80	Nur Verkehr auf Port 80 erfassen
	docker exec -it my_container tcpdump -w /tmp/dump.pcap	Verkehr in Datei speichern zur späteren Analyse
docker container stats		Zeigt aktuelle Ressourcennutzungsmetriken (CPU, Speicher, Netzwerk, Festplatte) für einen oder mehrere Container in Echtzeit
	docker stats my_container	Echtzeit-Auslastung von CPU, Speicher, Netzwerk und Festplatte des Containers anzeigen
	docker stats	Statistiken für alle Container anzeigen
	docker stats --no-stream	Statistiken einmalig ausgeben und beenden
docker container top		Zeigt die Liste der im Container laufenden Prozesse, ähnlich wie ps in Linux, um Container-Aktivität zu analysieren
	docker top my_container	Prozesse im Container anzeigen
	docker top my_container aux	Alternatives Ausgabeformat wie ps aux verwenden
	docker top my_container -eo pid,cmd	Nur PID und Befehl der Prozesse anzeigen
docker diff		Zeigt Änderungen im Dateisystem des Containers im Vergleich zum Basis-Image, einschließlich hinzugefügter, geänderter oder gelöschter Dateien
	docker diff my_container	Dateisystemänderungen im Container im Vergleich zum Basis-Image anzeigen
	docker diff my_container | grep '^A'	Nur hinzugefügte Dateien anzeigen (A — Added)
	docker diff my_container | grep '^C'	Nur geänderte Dateien anzeigen (C — Changed)
docker cp		Kopiert Dateien und Verzeichnisse zwischen Container und Host, ermöglicht Datenaustausch und Backups
—	—	—
	docker cp my_container:/path/to/file ./file	Datei vom Container zum Host kopieren
	docker cp ./config.yaml my_container:/app/config.yaml	Datei vom Host in den Container kopieren
	docker cp my_container:/var/log/app.log - | tar x -O | grep "ERROR"	Logdatei kopieren und Fehlerzeilen filtern, ohne sie auf Platte zu speichern

💡 Für erweitertes Debugging können nsenter, strace, tcpdump, gdb und andere Low-Level-Tools verwendet werden.

💼 Erweiterte Nutzung von Docker Compose

🚀 Professionelle Docker-Compose-Befehle

Befehl	Beispiel	Beschreibung
docker compose up		Startet und verwaltet den Lebenszyklus bestimmter Dienste aus der docker-compose.yml-Datei mit der Möglichkeit, im Hintergrund zu laufen
	docker compose up -d web db	Nur die Dienste web und db im Detached-Modus starten
	docker compose up --build	Images vor dem Start der Dienste neu bauen
	docker compose up --remove-orphans	Container entfernen, die nicht in der aktuellen Compose-Datei definiert sind
docker compose build		Images für Dienste gemäß Compose-Datei bauen mit Cache-Kontrolle und Parallelität
	docker compose build --no-cache	Images vollständig neu bauen, ohne Cache zu verwenden
	docker compose build --parallel	Alle Dienste gleichzeitig bauen, um den Prozess zu beschleunigen
	docker compose build web	Nur das Image des Dienstes web bauen
docker compose pull		Neueste Versionen von Images aus der Registry für alle oder bestimmte Dienste herunterladen
	docker compose pull	Images für alle Dienste herunterladen
	docker compose pull db	Nur das Image für den Dienst db herunterladen
	docker compose pull --ignore-pull-failures	Fortsetzen, auch wenn Fehler beim Herunterladen auftreten
docker compose restart		Alle oder bestimmte Dienste neu starten, ohne Container neu zu erstellen
	docker compose restart	Alle Dienste im aktuellen Projekt neu starten
	docker compose restart worker	Nur den Dienst worker neu starten
	docker compose restart web db	Mehrere Dienste gleichzeitig neu starten
docker compose exec		Einen Befehl in einem laufenden Service-Container ausführen, mit optionalem interaktivem Modus
	docker compose exec db psql -U user -d database	psql im db-Service-Container ausführen
	docker compose exec web sh	Eine Shell im web-Container öffnen
	docker compose exec api curl http://localhost:8080	curl-Anfrage aus dem api-Service-Container ausführen
docker compose config		Die endgültige Compose-Konfiguration ausgeben unter Berücksichtigung aller Dateien und Umgebungsvariablen
	docker compose config	Zusammengeführte Konfiguration im YAML-Format anzeigen
	docker compose config --services	Alle Dienste auflisten
	docker compose config --environment	Alle von Diensten verwendeten Umgebungsvariablen anzeigen
docker compose watch		Dienste bei Quellcode-Änderungen automatisch neu starten, nützlich für Entwicklung
	docker compose watch	Dateien überwachen und Dienste bei Änderungen neu starten
docker compose events		Compose-Ereignisse streamen: Dienststart, -stopp, -aktualisierung
	docker compose events --json	Ereignisse im JSON-Format empfangen
docker compose rm		Gestoppte Service-Container entfernen
	docker compose rm web db	Container der Dienste web und db entfernen
docker compose pause		Dienstbetrieb pausieren
	docker compose pause api	Den Dienst api pausieren
docker compose unpause		Pausierte Dienste fortsetzen
	docker compose unpause api	Den Dienst api fortsetzen
docker compose create		Container erstellen, ohne sie zu starten
	docker compose create web db	Container für web und db erstellen, aber nicht starten
docker compose images		Liste der von Diensten verwendeten Images anzeigen
	docker compose images	Images aller Dienste anzeigen
docker compose top		Prozesse innerhalb von Service-Containern anzeigen
	docker compose top web	Prozesse in Containern des Dienstes web anzeigen

🛠 Nützliche Praktiken und Automatisierung mit Docker Compose

• Trennung von Umgebungen
  Separate docker-compose.override.yml-Dateien für verschiedene Umgebungen verwenden — development, staging, production. Dies hilft, Konfigurationen zu isolieren und Konflikte zu vermeiden.
  Mehrere Konfigurationsdateien mit dem Flag -f kombinieren:

  docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

  Unterschiedliche .env-Dateien (.env.dev, .env.prod usw.) für die Verwaltung von Umgebungsvariablen verwenden.

• Sichere Speicherung von Secrets
  Keine sensiblen Daten (Passwörter, Tokens) direkt in Compose-Dateien einfügen. Stattdessen verwenden:

  • .env-Dateien für Umgebungsvariablen (nicht verschlüsselt, nicht in öffentliche Repos commiten)
    
  • docker secret und docker config für sichere Verwaltung von Secrets und Konfigurationen in Docker Swarm
    
  • Externe Volumes für Konfigurationsdateien mit Secrets
    

  • Externe Secret-Management-Systeme (z. B. HashiCorp Vault, AWS Secrets Manager)

• Startreihenfolge mit depends_on und healthcheck
  Dienste warten lassen, bis Abhängigkeiten bereit sind:

  services:
    db:
      image: postgres
      healthcheck:
        test: ["CMD-SHELL", "pg_isready -U postgres"]
        interval: 10s
        retries: 5
    api:
      image: my_api
      depends_on:
        db:
          condition: service_healthy

• Downtime während Updates minimieren
  Vor dem Aktualisieren der Dienste ausführen:

  docker compose pull && docker compose up -d --remove-orphans

  Die Option -d startet Container im Hintergrund, und --remove-orphans entfernt Container, die nicht in aktuellen Konfigurationen definiert sind.
  Zum vollständigen Stoppen und Entfernen alter Container falls nötig:

  docker compose down --remove-orphans

  Stellt sicher, dass frische Images geladen und ungenutzte Container ohne Ausfallzeit entfernt werden.

• Hot Code Reloading für Entwicklung
  volumes verwenden, um lokale Verzeichnisse in Container einzubinden. Änderungen am Code wirken sofort, ohne Images neu zu bauen.
  Dateiberechtigungen und Filesystem-Caching (besonders unter Windows und macOS) beachten, um Performance-Probleme zu vermeiden.

• Hot Code Reloading ohne Volumes (Compose 2.22+)

  develop:
    watch:
      - path: ./src
        action: sync
        target: /app

• Zentralisiertes Logging von Diensten
  Container-Logs an Monitoring- und Logsysteme wie ELK Stack, Loki, Prometheus, Fluentd weiterleiten.
  Docker-Logging-Treiber (--log-driver) aktivieren, um zentrale Log-Sammlung zu ermöglichen.
  Logging-Treiber in Compose-Dateien für Container konfigurieren:

  services:
    api:
      image: my_api
      logging:
        driver: "json-file"
        options:
          max-size: "10m"
          max-file: "3"

• Automatischer Neustart von Diensten
  Restart-Policy in docker-compose.yml konfigurieren:

  restart: unless-stopped

  Andere Restart-Policies sind:

  • no — kein automatischer Neustart (Standard)
    
  • always — Container immer neu starten
    

  • on-failure — nur bei Fehlern neu starten (optional mit Wiederholungsanzahl)

  In Produktion ist unless-stopped die beste Wahl, um Dienststabilität sicherzustellen.
  Ermöglicht automatische Wiederherstellung nach Fehlern oder Host-Neustarts.

• Service-Profile
  Nur bestimmte Gruppen von Diensten starten:

  services:
    db:
      image: postgres
      profiles: ["backend"]
    web:
      image: nginx
      profiles: ["frontend"]

  Nur das Frontend-Profil starten:

  docker compose --profile frontend up

🐞 Debugging und Profiling von Diensten in Docker Compose

Befehl	Beispiel	Beschreibung
docker compose exec		Einen Befehl in einem laufenden Dienst ausführen, mit Zugriff auf Container oder einzelnen Prozessen
	docker compose exec web sh	Eine Shell im web-Service-Container öffnen
	docker compose exec db psql -U user -d database	Den psql-Befehl im db-Service-Container ausführen
docker compose logs		Service-Logs zur Diagnose und Überwachung anzeigen
	docker compose logs -f db	Logs des Dienstes db in Echtzeit ansehen
	docker compose logs --tail=50 api	Die letzten 50 Zeilen der Logs des Dienstes api anzeigen
	docker compose logs --since=1h web	Logs der letzten Stunde des Dienstes web anzeigen
docker inspect		Detaillierte Informationen über den Container eines Dienstes anzeigen
	docker inspect $(docker compose ps -q web)	JSON mit detaillierten Infos über den web-Service-Container abrufen
docker container stats		Ressourcennutzung von Containern eines Dienstes überwachen
	docker stats $(docker compose ps -q worker)	CPU, Speicher und andere Ressourcennutzung des worker-Service-Containers verfolgen
docker compose run --rm		Einen temporären Container mit den Einstellungen eines Dienstes starten, nützlich für Debugging
	docker compose run --rm web sh	Einen einmaligen Container für den Dienst web mit interaktiver Shell starten
docker container cp		Dateien zwischen Host und Container kopieren
	docker cp $(docker compose ps -q db):/dump.sql ./dump.sql	Eine Datei aus dem db-Service-Container auf den Host kopieren

💡 Für komfortables Debugging komplexer Multi-Service-Setups docker compose run --rm verwenden, um einzelne Container mit notwendigen Netzwerken und Volumes zu starten, ohne Hauptdienste zu beeinflussen.

📚 Zusätzliche Ressourcen

🚫 Dateien mit .dockerignore ignorieren

Dateien und Ordner in .dockerignore eintragen, die nicht im Image enthalten sein sollen, um die Größe zu reduzieren und den Build zu beschleunigen:

node_modules/
*.log
.env

⚡ Befehle mit Aliassen vereinfachen

Aliasse für häufig genutzte Befehle erstellen, um sie schneller auszuführen:

alias dcu="docker compose up -d"
alias dcd="docker compose down"
alias dcb="docker compose build"

🧠 Tipp: Docker-Nutzung

• Nicht alles auswendig lernen — docker --help oder docker <Befehl> --help nutzen, um Befehle zu erkunden.
  
• Regelmäßig üben und mit kleinen Projekten experimentieren.
  

• Auf Image-Größen achten und unnötige Dateien mit .dockerignore ausschließen.

🌐 Nützliche Links

📘 Offizielle Docker-Dokumentation — umfassende Anleitungen und Referenzen zu allen Docker-Themen:
https://docs.docker.com/

📙 Docker Cheat Sheet — vollständiges offizielles Docker-Spickzettel:
https://dockerlabs.collabnix.com/docker/cheatsheet/

📗 Docker Hub — Images und Registries:
https://hub.docker.com/