Docker CLI Cheat Sheet

Docker CLI Cheat Sheet

Vollständige Referenz der Docker CLI-Befehle, die Images, Container, Volumes, Netzwerke, Compose und Cleanup-Operationen abdeckt.

Ein praktischer Quick-Reference-Guide für Docker-Kommandozeilenoperationen. Die Befehle sind nach Kategorien organisiert, ergänzt durch gängige Flags und realistische Beispiele.

Images

Docker-Images sind schreibgeschützte Templates, die zur Erstellung von Containern verwendet werden.

Image erstellen (Build)

# Build from Dockerfile in current directory
docker build -t myapp:v1.0 .

# Build with custom Dockerfile name
docker build -t myapp:v1.0 -f Dockerfile.prod .

# Build with build arguments
docker build -t myapp:v1.0 --build-arg NODE_ENV=production .

# Build with no cache (fresh build)
docker build -t myapp:v1.0 --no-cache .

# Build for multiple platforms
docker buildx build --platform linux/amd64,linux/arm64 -t myapp:v1.0 .

Images herunterladen (Pull)

# Pull from Docker Hub
docker pull nginx:alpine

# Pull specific version
docker pull postgres:15.2-alpine

# Pull all tags for an image
docker pull -a myregistry.io/myimage

# Pull from private registry
docker pull myregistry.io/myapp:v1.0

Images hochladen (Push)

# Tag image for registry
docker tag myapp:v1.0 myregistry.io/myapp:v1.0

# Push to registry
docker push myregistry.io/myapp:v1.0

# Push all tags
docker push -a myregistry.io/myapp

Images auflisten

# List all images
docker images

# List with dangling (untagged) images
docker images -a

# List with digest information
docker images --digests

# Filter by reference
docker images --filter reference="nginx*"

# Format output
docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}"

Images entfernen

# Remove specific image
docker rmi nginx:alpine

# Remove by image ID
docker rmi abc123def456

# Force removal (even if used by stopped containers)
docker rmi -f nginx:alpine

# Remove multiple images
docker rmi nginx:alpine redis:alpine postgres:15

Images untersuchen (Inspect)

# View image details
docker inspect nginx:alpine

# Get specific field with format
docker inspect --format='{{.Config.Cmd}}' nginx:alpine

# View image layers
docker history nginx:alpine

# View history with human-readable sizes
docker history --human nginx:alpine

Images speichern und laden

# Image in tar-Datei speichern
docker save -o myapp.tar myapp:v1.0

# Mehrere Images speichern
docker save -o images.tar nginx:alpine redis:alpine

# Image aus tar-Datei laden
docker load -i myapp.tar

# Von stdin laden
docker load < myapp.tar

### Prune Images

```bash
# Dangling (nicht getaggte) Images entfernen
docker image prune

# Alle ungenutzten Images entfernen (nicht nur dangling)
docker image prune -a

# Erzwingen ohne Bestätigung
docker image prune -f

Containers

Containers are running instances of images.

Run Containers

# Container im Vordergrund ausführen
docker run nginx:alpine

# Im Detached-Modus ausführen (Hintergrund)
docker run -d nginx:alpine

# Mit benutzerdefiniertem Namen ausführen
docker run -d --name web-server nginx:alpine

# Mit Port-Mapping ausführen
docker run -d -p 8080:80 nginx:alpine

# Mit mehreren Ports ausführen
docker run -d -p 8080:80 -p 8443:443 nginx:alpine

# Mit Umgebungsvariablen ausführen
docker run -d -e POSTGRES_PASSWORD=secret postgres:15

# Mit Env-Datei ausführen
docker run -d --env-file .env myapp:v1.0

# Mit Volume-Mount ausführen
docker run -d -v /host/path:/container/path nginx:alpine

# Mit Bind-Mount ausführen (schreibgeschützt)
docker run -d -v /host/path:/container/path:ro nginx:alpine

# Mit benanntem Volume ausführen
docker run -d -v mydata:/var/lib/postgresql/data postgres:15

# Mit Ressourcenlimits ausführen
docker run -d --memory=512m --cpus=1.5 myapp:v1.0

# Interaktiv mit Shell ausführen
docker run -it alpine:latest /bin/sh

# Mit Auto-Restart-Policy ausführen
docker run -d --restart=always nginx:alpine

# Mit Neustart bei Fehler ausführen (max. 3 Versuche)
docker run -d --restart=on-failure:3 myapp:v1.0

# Mit Netzwerk ausführen
docker run -d --network mynetwork myapp:v1.0

# Mit Hostname ausführen
docker run -d --hostname web01 nginx:alpine

# Mit Workdir ausführen
docker run -d -w /app myapp:v1.0

# Mit Benutzer ausführen
docker run -d -u 1000:1000 myapp:v1.0

# Container automatisch entfernen, wenn er beendet wird
docker run --rm -it alpine:latest /bin/sh

Start and Stop Containers

# Gestoppten Container starten
docker start web-server

# Mehrere Container starten
docker start web-server db-server cache-server

# Laufenden Container stoppen (graceful, SIGTERM)
docker stop web-server

# Stoppen mit Timeout (Sekunden)
docker stop -t 30 web-server

# Mehrere Container stoppen
docker stop web-server db-server

# Alle laufenden Container stoppen
docker stop $(docker ps -q)

Restart Containers

# Container neu starten
docker restart web-server

# Neustart mit Timeout
docker restart -t 10 web-server

Kill Containers

# Container killen (SIGKILL, keine Grace Period)
docker kill web-server

# Killen mit benutzerdefiniertem Signal
docker kill -s SIGINT web-server
# Alle laufenden Container beenden
docker kill $(docker ps -q)

Remove Containers

# Gestoppten Container entfernen
docker rm web-server

# Laufenden Container zwangsweise entfernen
docker rm -f web-server

# Mehrere Container entfernen
docker rm web-server db-server cache-server

# Alle gestoppten Container entfernen
docker container prune

# Entfernen inklusive Volumes
docker rm -v web-server

Pause and Unpause Containers

# Container pausieren (Prozesse einfrieren)
docker pause web-server

# Container fortsetzen
docker unpause web-server

Rename Containers

# Container umbenennen
docker rename web-server nginx-prod

Container Inspection

Commands to inspect and monitor running containers.

View Logs

# Container-Logs anzeigen
docker logs web-server

# Logs in Echtzeit verfolgen
docker logs -f web-server

# Die letzten N Zeilen anzeigen
docker logs --tail 100 web-server

# Logs seit einem bestimmten Zeitstempel anzeigen
docker logs --since 2024-01-15T10:00:00 web-server

# Logs der letzten 30 Minuten anzeigen
docker logs --since 30m web-server

# Logs mit Zeitstempeln anzeigen
docker logs -t web-server

# Optionen kombinieren
docker logs -f --tail 50 --since 10m web-server

Inspect Containers

# Container-Details anzeigen
docker inspect web-server

# Spezifisches Feld abrufen
docker inspect --format='{{.State.Status}}' web-server

# IP-Adresse abrufen
docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' web-server

# Port-Mappings abrufen
docker inspect --format='{{json .NetworkSettings.Ports}}' web-server

# Umgebungsvariablen abrufen
docker inspect --format='{{range .Config.Env}}{{println .}}{{end}}' web-server

# Volumes abrufen
docker inspect --format='{{json .Mounts}}' web-server | jq

Resource Statistics

# Live-Stream der Ressourcenauslastung
docker stats

# Statistiken für einen spezifischen Container
docker stats web-server

# Einzelner Snapshot (kein Stream)
docker stats --no-stream

# Benutzerdefiniertes Format
docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"

Running Processes

# Prozesse im Container anzeigen
docker top web-server

# Anzeige mit benutzerdefinierten ps-Optionen
docker top web-server aux

Port-Informationen

# Show port mappings
docker port web-server

# Show specific port mapping
docker port web-server 80

Dateisystem-Änderungen

# Show filesystem changes since container started
docker diff web-server

# A = added, C = changed, D = deleted

Stream-Events

# Stream Docker events
docker events

# Filter by container
docker events --filter container=web-server

# Filter by event type
docker events --filter type=container

# Filter by event (start, stop, die, etc.)
docker events --filter event=start

# Events since timestamp
docker events --since 60m

Ausführung

Befehle zur Interaktion mit laufenden Containern.

Befehle ausführen

# Run command in running container
docker exec web-server ls /etc/nginx

# Run interactive shell
docker exec -it web-server /bin/sh

# Run as specific user
docker exec -u root web-server cat /etc/passwd

# Run with environment variable
docker exec -e DEBUG=true web-server npm run debug

# Run with workdir
docker exec -w /app web-server npm test

# Run in detached mode
docker exec -d web-server nginx -s reload

An Container anhängen

# Attach to running container
docker attach web-server

# Detach with Ctrl+P, Ctrl+Q (not Ctrl+C)

Dateien kopieren

# Copy from host to container
docker cp ./config.json web-server:/app/config/

# Copy from container to host
docker cp web-server:/app/logs/ ./local-logs/

# Copy with container ID
docker cp abc123def456:/data/backup.tar ./backup.tar

Container exportieren

# Export container filesystem as tar
docker export web-server > backup.tar

# Export and compress
docker export web-server | gzip > backup.tar.gz

# Pipe to import
docker export web-server | docker import - myapp:backup

Container committen

# Create image from container
docker commit web-server myapp:modified

# Commit with message
docker commit -m "Added custom config" web-server myapp:modified

# Commit with author
docker commit -a "DevOps Team" web-server myapp:modified

# Commit with new CMD
docker commit --change 'CMD ["nginx", "-g", "daemon off;"]' web-server myapp:modified

Volumes

Volumes speichern Daten unabhängig vom Lebenszyklus des Containers.

Volumes erstellen

# Benanntes Volume erstellen
docker volume create mydata

# Mit spezifischem Driver erstellen
docker volume create --driver local mydata

# Mit Optionen erstellen
docker volume create --opt type=tmpfs --opt device=tmpfs mydata

List Volumes

# Alle Volumes auflisten
docker volume ls

# Nach Name filtern
docker volume ls --filter name=mydata

# Nach Driver filtern
docker volume ls --filter driver=local

Inspect Volumes

# Volume-Details anzeigen
docker volume inspect mydata

# Mountpoint abrufen
docker volume inspect --format='{{.Mountpoint}}' mydata

Remove Volumes

# Volume entfernen
docker volume rm mydata

# Mehrere Volumes entfernen
docker volume rm mydata cache sessions

# Erzwingen der Entfernung
docker volume rm -f mydata

Prune Volumes

# Alle ungenutzten Volumes entfernen
docker volume prune

# Erzwingen ohne Bestätigung
docker volume prune -f

Networks

Networks enable communication between containers.

Create Networks

# Bridge-Netzwerk erstellen
docker network create mynetwork

# Mit spezifischem Driver erstellen
docker network create --driver bridge mynetwork

# Overlay-Netzwerk erstellen (Swarm)
docker network create --driver overlay mynetwork

# Mit Subnetz erstellen
docker network create --subnet=192.168.1.0/24 mynetwork

# Mit Gateway erstellen
docker network create --subnet=192.168.1.0/24 --gateway=192.168.1.1 mynetwork

# Mit IP-Bereich erstellen
docker network create --subnet=192.168.1.0/24 --ip-range=192.168.1.128/25 mynetwork

# Anbindbares (attachable) Overlay-Netzwerk erstellen
docker network create --driver overlay --attachable mynetwork

# Mit Labels erstellen
docker network create --label env=prod mynetwork

List Networks

# Alle Netzwerke auflisten
docker network ls

# Nach Driver filtern
docker network ls --filter driver=bridge

# Nach Name filtern
docker network ls --filter name=my*

Inspect Networks

# Netzwerk-Details anzeigen
docker network inspect mynetwork

# Container-IPs abrufen
docker network inspect --format='{{range .Containers}}{{.Name}}: {{.IPv4Address}}{{println}}{{end}}' mynetwork

Connect Containers to Networks

# Laufenden Container mit Netzwerk verbinden
docker network connect mynetwork web-server

# Mit statischer IP verbinden
docker network connect --ip 192.168.1.100 mynetwork web-server
# Verbindung mit Alias herstellen
docker network connect --alias db mynetwork postgres-server

Disconnect Containers from Networks

# Container vom Netzwerk trennen
docker network disconnect mynetwork web-server

# Trennung erzwingen
docker network disconnect -f mynetwork web-server

Remove Networks

# Netzwerk entfernen
docker network rm mynetwork

# Mehrere Netzwerke entfernen
docker network rm net1 net2 net3

Prune Networks

# Alle ungenutzten Netzwerke entfernen
docker network prune

# Erzwingen ohne Bestätigung
docker network prune -f

Docker Compose

Docker Compose manages multi-container applications.

Start Services

# Alle Dienste starten (im Hintergrund/detached)
docker compose up -d

# Starten inklusive Build
docker compose up -d --build

# Spezifische Dienste starten
docker compose up -d web db

# Starten mit erzwungener Neuerstellung
docker compose up -d --force-recreate

# Starten mit Skalierung
docker compose up -d --scale web=3

# Starten mit Environment-Datei
docker compose --env-file .env.prod up -d

# Starten mit Projektnamen
docker compose -p myproject up -d

# Starten mit benutzerdefinierter Compose-Datei
docker compose -f docker-compose.prod.yml up -d

Stop Services

# Alle Dienste stoppen und entfernen
docker compose down

# Stoppen und Volumes entfernen
docker compose down -v

# Stoppen und Images entfernen
docker compose down --rmi all

# Stoppen und "Orphans" (verwaiste Container) entfernen
docker compose down --remove-orphans

# Stoppen ohne Entfernen
docker compose stop

# Spezifischen Dienst stoppen
docker compose stop web

Build Services

# Alle Dienste bauen
docker compose build

# Spezifischen Dienst bauen
docker compose build web

# Bauen ohne Cache
docker compose build --no-cache

# Parallel bauen
docker compose build --parallel

# Images vor dem Bauen pullen
docker compose build --pull

View Logs

# Alle Logs anzeigen
docker compose logs

# Logs in Echtzeit verfolgen
docker compose logs -f

# Letzte N Zeilen anzeigen
docker compose logs --tail 100

# Logs für einen spezifischen Dienst
docker compose logs web

# Logs mit Zeitstempeln
docker compose logs -t

List Services

# Laufende Services auflisten
docker compose ps

# Alle Services auflisten (einschließlich gestoppter)
docker compose ps -a

# Nur Service-IDs anzeigen
docker compose ps -q

Execute in Services

# Befehl im Service-Container ausführen
docker compose exec web ls /app

# Interaktive Shell starten
docker compose exec web /bin/sh

# Als spezifischer Benutzer ausführen
docker compose exec -u root web cat /etc/passwd

# Einmaligen Befehl ausführen
docker compose run --rm web npm test

# Mit Service-Ports ausführen
docker compose run --service-ports web

Scale Services

# Service auf 3 Instanzen skalieren
docker compose up -d --scale web=3

# Mehrere Services skalieren
docker compose up -d --scale web=3 --scale worker=2

Other Compose Commands

# Compose-Datei validieren
docker compose config

# Service-Images anzeigen
docker compose images

# Top-Prozesse anzeigen
docker compose top

# Services pausieren
docker compose pause

# Services fortsetzen
docker compose unpause

# Services neu starten
docker compose restart

# Spezifischen Service neu starten
docker compose restart web

# Alle Images pullen
docker compose pull

# Alle Images pushen
docker compose push

# Dateien aus Service kopieren
docker compose cp web:/app/logs ./logs

# Port-Mappings anzeigen
docker compose port web 80

System

System-level Docker commands.

System Information

# Systemweite Informationen anzeigen
docker info

# Docker-Version anzeigen
docker version

# Version anzeigen (kurz)
docker version --format='{{.Server.Version}}'

Disk Usage

# Festplattenbelegung anzeigen
docker system df

# Detaillierte Festplattenbelegung anzeigen
docker system df -v

System Events

# Echtzeit-Events streamen
docker system events

# Nach Typ filtern
docker system events --filter type=container
# Nach Image filtern
docker system events --filter image=nginx:alpine

Login to Registry

# Bei Docker Hub anmelden
docker login

# Bei privater Registry anmelden
docker login myregistry.io

# Anmeldung mit Zugangsdaten
docker login -u username -p password myregistry.io

# Abmelden
docker logout myregistry.io

Cleanup

Commands to reclaim disk space and remove unused resources.

System-Wide Prune

# Ungenutzte Daten entfernen (Images, Container, Netzwerke)
docker system prune

# Alle ungenutzten Daten inklusive Volumes entfernen
docker system prune -a --volumes

# Erzwingen ohne Bestätigung
docker system prune -f

# Nach Zeit filtern (älter als)
docker system prune --filter "until=24h"

Prune by Resource Type

# Container entfernen (gestoppt)
docker container prune

# Container entfernen, die älter als 1 Stunde sind
docker container prune --filter "until=1h"

# Images entfernen (dangling)
docker image prune

# Alle ungenutzten Images entfernen
docker image prune -a

# Volumes entfernen
docker volume prune

# Volumes mit Filter entfernen
docker volume prune --filter "label!=keep"

# Netzwerke entfernen
docker network prune

# Build-Cache entfernen
docker builder prune

# Gesamten Build-Cache entfernen
docker builder prune -a

Remove Everything

# Nuclear Option: Alle Container, Images, Volumes und Netzwerke entfernen
docker stop $(docker ps -aq) 2>/dev/null
docker rm $(docker ps -aq) 2>/dev/null
docker rmi $(docker images -q) 2>/dev/null
docker volume rm $(docker volume ls -q) 2>/dev/null
docker network rm $(docker network ls -q) 2>/dev/null

# Oder prune mit allen Flags verwenden
docker system prune -a --volumes -f

Clean Up Specific Resources

# Beendete Container entfernen
docker rm $(docker ps -q -f status=exited)

# In der letzten Stunde erstellte Container entfernen
docker rm $(docker ps -q -f created=1h)

# Dangling Images entfernen
docker rmi $(docker images -q -f dangling=true)

# Images mit spezifischem Label entfernen
docker rmi $(docker images -q -f label=stage=build)

# Volumes entfernen, die von keinem Container genutzt werden
docker volume rm $(docker volume ls -qf dangling=true)

Referenz der gängigen Flags

Exit Codes

Quick Reference

# See what's running
docker ps

# See all containers (including stopped)
docker ps -a

# See images
docker images

# See disk usage
docker system df

# Follow logs
docker logs -f <container>

# Shell into container
docker exec -it <container> /bin/sh

# Quick cleanup
docker system prune -f

# Full cleanup (destructive)
docker system prune -a --volumes -f

Nächste Schritte

• Kubernetes kubectl Cheat Sheet — Container im großen Stil orchestrieren
• Helm CLI Cheat Sheet — Anwendungen paketieren und bereitstellen
• Docker Multi-Stage Builds — Produktions-Images optimieren
• Container Building and Hardening — Best Practices für Sicherheit

Ressourcen & Verwandte Plattformen

• tobias-weiss.org - Weitere Cheat Sheets, Artikel und Shop-Produkte
• graphwiz.ai - KI, Knowledge Graphs und agentische Entwicklung
• courses.graphwiz.ai - Interaktive Übungsprüfungen und Lernleitfäden
• ki-kompetenz-training.org - EU AI Act konforme KI-Kompetenztrainings

Verwandte Cheat Sheets

• Docker Compose Cheat Sheet - Multi-Container-Apps
• Kubernetes Cheat Sheet - Orchestrierung im großen Stil