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 Multi-Container-Anwendungen mit Docker Compose. Die Befehle sind nach Workflow organisiert und mit realistischen Beispielen versehen.

Erste Schritte

Projekt initialisieren

# Generate a basic docker-compose.yml from an existing container
docker compose convert > docker-compose.yml

# Generate from a Dockerfile
docker compose build

# Verify the configuration is valid
docker compose config

Dienste starten

# Start all services in the background
docker compose up -d

# Start a specific service
docker compose up -d web

# Start with a custom compose file
docker compose -f docker-compose.yml -f docker-compose.override.yml up -d

# Start and attach to logs
docker compose up

# Start, attach to logs, and detach with Ctrl+C
docker compose up --detach-attach

Service-Management

Dienste steuern

# Stop all services (containers remain)
docker compose stop

# Stop and remove containers
docker compose down

# Stop, remove containers, and networks
docker compose down --remove-orphans

# Stop, remove everything including volumes
docker compose down -v

# Restart a specific service
docker compose restart web

# Pause/resume services
docker compose pause
docker compose unpause

# Start/stop a single service
docker compose start web
docker compose stop web

Logs anzeigen

# View all service logs
docker compose logs

# View logs for a specific service
docker compose logs web

# Follow logs in real-time
docker compose logs -f web

# Show last 50 lines
docker compose logs --tail=50 web

# Show logs from the last hour
docker compose logs --since=1h web

Befehle innerhalb von Containern ausführen

# Run a command in a running service
docker compose exec web ls -la

# Open an interactive shell in a service
docker compose exec web bash

# Run as a different user
docker compose exec -u www-data web whoami

# Execute in a different service
docker compose exec db psql -U postgres

# Run in the background, capture output
docker compose exec web cat /etc/os-release

Images und Builds

Dienste bauen

# Alle Dienste bauen
docker compose build

# Einen spezifischen Dienst bauen
docker compose build web

# Erneuten Build ohne Cache erzwingen
docker compose build --no-cache web

# Build mit Build-Argumenten
docker compose build --build-arg NODE_ENV=production web

Gleichzeitig bauen und starten

docker compose up --build

Neuere Base-Images ziehen

docker compose pull

Images ziehen und Services bauen

docker compose up --build --pull always

### Image Management

```bash
# Von Compose erstellte Images auflisten
docker compose ls

# Image-Details für einen Service anzeigen
docker compose images web

# Ungenutzte Images entfernen
docker compose up --remove-orphans --prune

# Images für die Registry taggen
docker compose run --rm web bash -c "echo $IMAGE"

Networking

Network Commands

# Von Compose erstellte Netzwerke auflisten
docker compose networks

# Netzwerkkonfiguration prüfen
docker compose run --rm web ip addr show

# Einen anderen Service aus einem Container heraus pingen
docker compose exec web ping db

# Einen laufenden Container mit einem Compose-Netzwerk verbinden
docker network connect myapp_default container_id

# Konnektivität zwischen Services testen
docker compose run --rm web curl http://db:5432

Service Discovery

Docker Compose provides automatic DNS-based service discovery. Services can reference each other by their service name:

# Verbinden Sie sich innerhalb Ihrer Anwendung über den Service-Namen mit der Datenbank:
DATABASE_URL=postgresql://postgres:password@db:5432/myapp

# Analog für Redis:
REDIS_URL=redis://redis:6379

Volumes

Volume Commands

# Alle Volumes auflisten
docker compose volumes

# Ein Volume erstellen
docker compose volume create mydata

# Ungenutzte Volumes entfernen
docker compose down -v

# Spezifisches Volume entfernen
docker compose volume rm myapp_mydata

# Ein Volume untersuchen
docker volume inspect myapp_mydata

Backup and Restore

# Ein Volume sichern
docker compose run --rm postgres pg_dump -U postgres myapp > backup.sql

# Aus einem Backup wiederherstellen
cat backup.sql | docker compose exec -T postgres psql -U postgres myapp

# Ein Volume in einer tar-Datei sichern
docker run --rm \
  -v myapp_mydata:/data:ro \
  -v $(pwd):/backup \
  alpine tar czf /backup/backup.tar.gz -C /data .

# Aus einer tar-Datei wiederherstellen
docker run --rm \
  -v myapp_mydata:/data \
  -v $(pwd):/backup \
  alpine tar xzf /backup/backup.tar.gz -C /data

Environment Variables

Loading Variables

# .env-Datei verwenden (wird automatisch geladen)
# .env:
#   DATABASE_URL=postgresql://...
#   API_KEY=secret123

# Spezifische Variablen überschreiben
docker compose up -d -e DATABASE_URL=postgresql://other:5432/db

# Aus einer spezifischen Datei laden
docker compose --env-file .env.prod up -d

# Aufgelöste Umgebungsvariablen anzeigen
docker compose run --rm web env

# Variablen inline setzen
docker compose run -e FOO=bar web echo $FOO

Variable Interpolation

# docker-compose.yml
services:
  web:
    image: myapp
    environment:
      DB_HOST: ${DB_HOST:-db}
      DB_PORT: ${DB_PORT:-5432}
      NODE_ENV: ${NODE_ENV:-development}

Docker Compose File Reference

Common Top-Level Keys

version: "3.9"

services:
  web:
    build: .
    image: myapp:latest
    ports:
      - "3000:3000"
      - "9229:9229"
    environment:
      - NODE_ENV=production
      - DATABASE_URL=${DATABASE_URL}
    volumes:
      - ./src:/app/src
      - /app/node_modules
    depends_on:
      - db
      - redis
    networks:
      - frontend
      - backend
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  db:
    image: postgres:15-alpine
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: ${DB_NAME}
    networks:
      - backend
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data
    networks:
      - backend
    restart: unless-stopped

volumes:
  postgres_data:
  redis_data:

networks:
  frontend:
  backend:
    internal: true

Key Directives

Profiles

# Verfügbare Profile auflisten
docker compose config --format json | jq '.profile'

# Mit spezifischem Profil starten
docker compose --profile worker up -d

# Mit mehreren Profilen starten
docker compose --profile worker --profile scheduler up -d

# Nur Services ohne Profile starten
docker compose --profile development up -d

# docker-compose.yml
services:
  web:
    # Startet immer
    image: myapp:web

  worker:
    # Startet nur mit --profile worker
    image: myapp:worker
    profiles: ["worker"]

  scheduler:
    # Startet nur mit --profile scheduler
    image: myapp:scheduler
    profiles: ["scheduler"]

Troubleshooting

Debugging Services

# Service-Konfiguration anzeigen
docker compose config

# Laufende Container mit Ports anzeigen
docker compose ps

# Health-Status prüfen
docker compose ps --filter "health=healthy"

# Ressourcenauslastung anzeigen
docker compose top

# cgroup-Limits anzeigen
docker compose run --rm web cat /sys/fs/cgroup/memory/memory.limit_in_bytes

Common Issues

# Port bereits belegt
# 1. Herausfinden, was den Port belegt
# lsof -i :3000        (macOS/Linux)
# netstat -ano | findstr :3000  (Windows)

# 2. Prozess beenden oder Port-Mapping ändern
# docker compose up -d  # nach der Behebung

# Container beendet sich sofort
docker compose logs web
docker compose run --rm web bash  # Interaktion mit dem Container

# DNS-Auflösung innerhalb von Compose schlägt fehl
# Services finden sich nicht über den Namen
docker compose exec web nslookup db
# Lösung: Sicherstellen, dass die Services im selben Netzwerk sind

# Berechtigungsprobleme bei Volumes
docker compose exec web chown -R www-data:www-data /app/data

# Build schlägt mit Cache-Fehler fehl
docker compose build --no-cache
docker system prune -a  # alle ungenutzten Daten löschen

Health Check Patterns

# HTTP Health Check
healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
  interval: 30s
  timeout: 10s
  retries: 3
  start_period: 40s

# Befehlsbasierter Health Check
healthcheck:
  test: ["CMD", "pg_isready", "-U", "postgres"]
  interval: 10s
  timeout: 5s
  retries: 5

# Shell-basierter Health Check
healthcheck:
  test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} || exit 1"]
  interval: 10s
  timeout: 5s
  retries: 5

Production Deployment

Docker Compose vs Docker Swarm

# Deployment mit Docker Swarm (Legacy Swarm Mode)
docker stack deploy -c docker-compose.yml myapp

# Docker Compose v3 unterstützt die Swarm-Deploy-Syntax
# docker-compose.yaml kann sowohl mit docker compose als auch mit Swarm verwendet werden

# Für Kubernetes-Deployments Kompose verwenden
kompose convert -f docker-compose.yml -o k8s/
kubectl apply -f k8s/

# Für systemd-basierte Deployments
# Compose als systemd-Service installieren
# https://github.com/manaime/compose2systemd

Security Best Practices

# Niemals in der Produktion verwenden:
services:
  web:
    privileged: true # GEFÄHRLICH
    network_mode: "host" # GEFÄHRLICH
# Tun Sie stattdessen dies:
services:
  web:
    read_only: true
    tmpfs:
      - /tmp
    security_opt:
      - no-new-privileges:true
    user: "1000:1000"
    networks:
      - backend

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 CLI Cheat Sheet - Container-Management
• Nginx Cheat Sheet - Reverse Proxy für Ihre Stacks