Docker Compose Cheat Sheet – Die nützlichsten Befehle mit Beispielen

Hier ist ein Docker Compose Cheat Sheet mit annotierten Beispielen, die Ihnen helfen, Compose-Dateien und -Befehle schnell zu beherrschen.

Dieser Leitfaden ist Teil von Entwickler-Tools: Der vollständige Leitfaden für moderne Entwicklungs-Workflows.

Voraussetzungen

Docker Engine muss installiert sein, bevor Sie Compose verwenden. Befolgen Sie auf Ubuntu die Anleitung Docker auf Ubuntu installieren, um die richtige Installationsmethode auszuwählen und das docker compose-Plugin einzurichten.

Compose-Datei-Referenz: docker-compose.yml

Kernstruktur:

version: '3'       # Version des Compose-Dateiformats

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Host-Port 8080:Container-Port 80
  db:
    image: postgres
    environment:            # Umgebungsvariablen
      POSTGRES_PASSWORD: example
    volumes:
      - db_data:/var/lib/postgresql/data

networks:          # Benutzerdefiniertes Netzwerk
  appnet:
    driver: bridge

volumes:           # Benanntes Volume
  db_data:

• services: Jeder Container in Ihrer Mehr-Container-Anwendung. Im obigen Beispiel haben wir zwei Dienste: web und db. Für einzelne Containeroperationen siehe das Docker Cheat Sheet.
• networks & volumes: Definieren Sie isolierte Netzwerke und persistenten Speicher – hier haben wir das Netzwerk appnet und das Volume db_data.

Beispiele

Einzelner Dienst mit Port-Mapping

services:
  app:
    build: .
    ports:
      - "8000:80"   # Host-Port 8000:Container-Port 80

Macht die App auf dem Host-Port 8000 verfügbar und baut das Image aus der Dockerfile im aktuellen Verzeichnis.

Mehrere Dienste mit gemeinsamem Volume und benutzerdefiniertem Netzwerk

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - type: bind
        source: ./app
        target: /app
    networks:
      - mynet
  db:
    image: postgres
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - mynet

networks:
  mynet:

volumes:
  db_data:

Web und DB im selben Netzwerk; DB verwendet ein persistendes benanntes Volume – db_data.

Verwendung von Build-Kontext und Dockerfile-Pfad

Sie können ein Docker-Image auf Abruf aus der in docker-compose.yml angegebenen Dockerfile bauen.

services:
  app:
    build:
      context: .
      dockerfile: docker/MyDockerfile

Daten zwischen Diensten teilen

services:
  web:
    image: nginx
    volumes:
      - shared_data:/usr/share/nginx/html
  worker:
    image: myworker
    volumes:
      - shared_data:/usr/src/app/data

volumes:
  shared_data:

Beide Dienste greifen auf dasselbe Volume zu (für statische Dateien oder Datenaustausch) – shared_data.

Erweiterte Compose-Datei-Optionen

• environment: Setzen Sie ENV-Variablen für Container.
• depends_on: Steuern Sie die Startreihenfolge der Dienste.
• deploy.replicas: Skalieren Sie den Dienst im Swarm-Modus.

Beispiel:

services:
  web:
    image: nginx
    deploy:
      replicas: 3
    depends_on:
      - db

Startet 3 Web-Instanzen; steuert nur die Startreihenfolge (nicht die Bereitschaft).

Wesentliche Docker Compose-Befehle

Häufige Compose-Muster

• Datenbanken mit persistenten Daten

  services:
    mysql:
      image: mysql
      environment:
        MYSQL_ROOT_PASSWORD: password
      volumes:
        - mysql_data:/var/lib/mysql
  
  volumes:
    mysql_data:
  

  DB-Daten bleiben im Volume mysql_data über Container-Neustarts hinweg erhalten.

• Bind-Mounting von Code für die Entwicklung

  services:
    app:
      build: .
      volumes:
        - .:/app
  

  Code live auf dem Host bearbeiten, automatisch im Container gespiegelt.

Nützliche Flags

• -d: Abgelöster Modus (im Hintergrund ausführen).
• --build: Erzwingt das Neubauen von Images vor dem Start.
• --force-recreate: Erstellt Container neu, auch wenn sie unverändert sind.
• --remove-orphans: Entfernt Container, die nicht in der Compose-Datei definiert sind.

Definieren und Anpassen von Diensten

Sie können Dienste, Netzwerke und Volumes in Docker Compose definieren und anpassen, indem Sie die Datei docker-compose.yml nutzen, die alle Konfigurations- und Orchestrierungsanforderungen Ihrer Anwendung zentralisiert.

• Dienste werden unter dem Schlüssel services definiert.
• Jeder Dienst repräsentiert eine Containerkonfiguration, in der Sie Folgendes festlegen können:
  • Image: Wählen Sie ein Image von Docker Hub oder einem anderen Registry aus.
  • Ports: Mappen Sie Container-Ports auf Host-Ports.
  • Umgebungsvariablen: Übergeben Sie Konfigurationswerte.
  • Volumes: Persistieren Sie Daten oder teilen Sie Dateien/Ordner mit dem Host oder anderen Diensten.
  • Netzwerke: Steuern Sie, auf welche Netzwerke der Dienst zugreifen kann.

Beispiel:

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Host-Port 8080:Container-Port 80
    environment:
      - NGINX_HOST=localhost
    volumes:
      - web_data:/usr/share/nginx/html
    networks:
      - frontend

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - backend

• Hier verwendet der Dienst web das nginx-Image, setzt eine Umgebungsvariable, hängt ein Volume an, öffnet Port 80 als 8080 auf dem Host und verbindet sich mit dem Netzwerk frontend. Der Dienst db macht etwas Ähnliches für PostgreSQL.

Anpassen von Netzwerken

• Netzwerke steuern, welche Dienste miteinander kommunizieren können. Compose erstellt ein Standardnetzwerk, aber Sie können weitere definieren, benutzerdefinierte Treiber angeben, Optionen festlegen und bestimmen, welcher Dienst welchem Netzwerk beitritt, um eine feingranulare Isolation zu erreichen.
• Definieren Sie Netzwerke auf der Top-Ebene unter networks und listen Sie auf, welche Netzwerke ein Dienst über den dienstspezifischen Schlüssel networks nutzen soll.

Beispiel:

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    driver_opts:
      com.docker.network.bridge.host_binding_ipv4: "127.0.0.1"

• Hängen Sie Netzwerke an Dienste an:

services:
  app:
    networks:
      - frontend
      - backend
  db:
    networks:
      - backend

• Diese Konfiguration ermöglicht es dem Dienst app, sowohl auf die Nutzer im frontend- als auch im backend-Netzwerk zuzugreifen, während db nur innerhalb des backend zugänglich ist.

Anpassen von Volumes

• Volumes werden unter dem Schlüssel volumes auf der Top-Ebene definiert. Mounten Sie sie in Container, indem Sie den Schlüssel volumes unter einem Dienst verwenden.
• Volumes können benannt sein, benutzerdefinierte Treiber verwenden und über mehrere Dienste hinweg für Datenpersistenz und -freigabe geteilt werden.

Beispiel:

volumes:
  web_data:                # Benanntes Volume für Webinhalte
  db_data:                 # Benanntes Volume für die Datenbank

services:
  web:
    volumes:
      - web_data:/usr/share/nginx/html

  db:
    volumes:
      - db_data:/var/lib/postgresql/data

• In diesem Beispiel wird web_data persistent gespeichert und für jeden Container verfügbar, der es mountet. db_data stellt sicher, dass Datenbankeinträge bei der Neuerstellung von Containern nicht verloren gehen.
• Sie können Bind-Mounts mit benutzerdefinierten Treiberoptionen für erweiterte Fälle definieren:

volumes:
  db_data:
    driver: local
    driver_opts:
      type: none
      device: /data/db_data
      o: bind

• Diese Konfiguration richtet einen Bind-Mount vom Host-Pfad /data/db_data in den Container ein.

Zusammenfassung der Best Practices:

• Verwenden Sie den Dienstnamen als DNS-Hostname für die Kommunikation zwischen Diensten.
• Hängen Sie Dienste an mehrere Netzwerke an, um den Zugriff zu steuern.
• Verwenden Sie benannte Volumes für persistente Speicherung und Datenaustausch.
• Definieren Sie alles mit YAML, was Versionskontrolle und einfache Deployment-Skripte ermöglicht.
• Für das Container-Management und die Visualisierung sollten Sie Portainer auf Linux installieren.

Mehrere Compose-Dateien

Um komplexe Mehr-Dienst-Setups in Docker Compose zu organisieren, können Sie mehrere Compose-Dateien und Override-Dateien verwenden, was modulare, umgebungsspezifische und skalierbare Konfigurationen ermöglicht. So funktioniert es:

1. Struktur von Basis- und Override-Dateien

• Erstellen Sie eine Basisdatei (compose.yaml oder docker-compose.yml), die alle gemeinsamen, standardmäßigen Dienstdefinitionen enthält.
• Fügen Sie umgebungsspezifische Override-Dateien hinzu (z. B. docker-compose.override.yml, docker-compose.dev.yml, docker-compose.prod.yml).

Beispiel-Dateistruktur:

/Projekt-Verzeichnis
|-- docker-compose.yml           # Basis-Konfiguration
|-- docker-compose.override.yml  # Lokale/Dev-Overrides (werden automatisch angewendet)
|-- docker-compose.prod.yml      # Produktions-Overrides
|-- docker-compose.test.yml      # Test-Overrides (falls benötigt)

Die Basis-Konfiguration definiert die Kerndienste, während jeder Override die Einstellungen für eine bestimmte Umgebung oder einen bestimmten Fall anpasst.

2. Wie Datei-Overrides funktionieren

• Zusammenführung: Wenn Sie docker compose up ausführen, führt Docker Compose die Basis mit allen Overrides in der Reihenfolge zusammen; nachfolgende Dateien überschreiben, erweitern oder fügen Einstellungen aus vorherigen Dateien hinzu.
• Überschreiben von Feldern: Wenn ein Dienst oder ein Feld in mehreren Dateien definiert ist, wird der Wert der zuletzt angegebenen Datei verwendet. Neue Felder werden hinzugefügt.

Beispiel-Zusammenführung:

• docker-compose.yml:

  services:
    web:
      image: myapp
      ports:
        - "8000:80"
  

• docker-compose.override.yml:

  services:
    web:
      environment:
        - DEBUG=true
  

• Ergebnis: Der Dienst web verwendet sowohl das Basis-Image und den Port als auch die überschriebene DEBUG-Umgebungsvariable.

3. Befehlsverwendung für mehrere Dateien

• Standardverhalten: Wenn vorhanden, lädt Docker Compose automatisch docker-compose.override.yml zusammen mit docker-compose.yml, wenn Sie einen beliebigen Befehl ausführen.
• Manuelles Angeben von Dateien: Verwenden Sie -f-Flags, um zu steuern, welche Dateien zusammengeführt werden und in welcher Reihenfolge:

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

  • Dies ignoriert den Standard-Override und verwendet die produktionsspezifischen Einstellungen.

4. Praktische Organisationsstrategien

• Umgebungstrennung: Verwenden Sie einen Override pro Umgebung: dev, test, prod usw.
• Microservices und Teams: Teilen Sie die Konfiguration in separate Dateien für verschiedene Dienste oder Teams auf und kombinieren Sie sie bei Bedarf.
• Feature-Toggles: Zusätzliche Dateien können optionale Dienste oder Konfigurationen für temporäre Bedürfnisse einführen oder entfernen (z. B. eine compose.debug.yml für erweiterte Protokollierung).

5. Vorteile

• Klarheit: Hält einzelne Dateien klein und fokussiert.
• Skalierbarkeit: Fügen Sie leicht neue Dienste, Umgebungen oder Einstellungen hinzu.
• Wartbarkeit: Ändern oder prüfen Sie nur relevante Abschnitte für ein bestimmtes Deployment.

6. Beispiel: Umgebungen wechseln

Entwicklung:

docker compose -f docker-compose.yml -f docker-compose.dev.yml up

Produktion:

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

Jede Umgebung erhält nur die für sie notwendige Konfiguration, wobei die gesamte gemeinsame Konfiguration in der Basisdatei liegt.

Die Organisation komplexer Compose-Setups mit mehreren Dateien – und die Nutzung des Override-/Merge-Systems – gewährleistet Modularität, umgebungsspezifische Anpassung und einfache Skalierbarkeit für große, mehrschichtige Docker-Anwendungen.

Für das Produktions-Deployment auf einem einzelnen Linux-Host — Start beim Booten, sauberes Herunterfahren, Updates und Log-Rotation — siehe Docker Compose als Linux-Dienst mit systemd ausführen.

Nützliche Links

• https://docs.docker.com/compose/
• Docker Cheat Sheet
• Kubernetes Cheat Sheet
• Flutter Web-App mit dockerisierter Flutter-Build und Nginx dockerisieren
• Portainer auf Linux installieren