Docker Compose Spickzettel – Die nützlichsten Befehle mit Beispielen

Hier ist ein Docker Compose Schnellreferenz mit kommentierten Beispielen, um Compose-Dateien und -Befehle schnell zu beherrschen.

Dieser Leitfaden ist Teil von Entwicklerwerkzeuge: Der vollständige Leitfaden zu modernen Entwicklungsworkflows.

Voraussetzungen

Der Docker Engine muss installiert sein, bevor Sie Compose verwenden. Unter Ubuntu folgen Sie der Anleitung Docker unter Ubuntu installieren, um die richtige Installationsmethode zu wählen und das docker compose-Plugin einzurichten.

Compose-Datei-Referenz: docker-compose.yml

Kernstruktur:

version: '3'       # Compose-Dateiformatversion

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:          # Custom Netzwerk
  appnet:
    driver: bridge

volumes:           # Benanntes Volume
  db_data:

• services: Jeder Container in Ihrer Multi-Container-App. Im obigen Beispiel gibt es zwei Dienste: web und db. Für individuelle Container-Operationen siehe das Docker Schnellreferenz.
• networks & volumes: Definieren Sie isolierte Netzwerke und persistente Speicherung - hier haben wir das appnet-Netzwerk und das db_data-Volume.

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 aus der Dockerfile im aktuellen Verzeichnis.

Mehrere Dienste mit gemeinsamem Volume und Custom-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 das persistente benannte Volume - db_data.

Verwenden von Build-Kontext und Dockerfile-Pfad

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

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 mysql_data-Volume über Container-Neustarts hinweg erhalten.

• Bind-Mounting von Code für die Entwicklung

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

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

Nützliche Flags

• -d: Detach-Modus (im Hintergrund ausführen).
• --build: Images vor dem Start neu bauen.
• --force-recreate: Container neu erstellen, auch wenn sich nichts geändert hat.
• --remove-orphans: Container entfernen, die nicht in der Compose-Datei definiert sind.

Definition und Anpassung von Diensten

Sie können in Docker Compose Dienste, Netzwerke und Volumes definieren und anpassen, indem Sie die docker-compose.yml-Datei nutzen, die alle Ihre Anwendungs-Configuration- und Orchestrierungsbedürfnisse zentralisiert.

• Services werden unter dem services-Schlüssel definiert.
• Jeder Dienst stellt eine Container-Konfiguration dar, bei der Sie Folgendes festlegen können:
  • Image: Wählen Sie ein Image aus dem Docker Hub oder einem anderen Registry.
  • Ports: Mappen Sie Container-Ports auf Host-Ports.
  • Umgebungsvariablen: Übergeben Sie Konfigurationswerte.
  • Volumes: Speichern Sie Daten dauerhaft oder teilen Sie Dateien/Ordner mit dem Host oder anderen Diensten.
  • Networks: 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 web-Dienst das nginx-Image, setzt eine Umgebungsvariable, hängt ein Volume an, öffnet Port 80 als 8080 auf dem Host und verbindet sich mit dem frontend-Netzwerk. Der db-Dienst macht Ähnliches für PostgreSQL.

Netzwerke anpassen

• Networks steuern, welche Dienste kommunizieren können. Compose erstellt ein Standard-Netzwerk, aber Sie können weitere definieren, Custom-Drivers angeben, Optionen setzen und bestimmen, welcher Dienst zu welchem Netzwerk gehört, für feingranulare Isolation.
• Definieren Sie Netzwerke auf der obersten Ebene unter networks und listen Sie auf, welche Netzwerke ein Dienst beitreten soll, mit dem dienst-spezifischen networks-Schlüssel.

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:

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

• Diese Einrichtung ermöglicht es dem app-Diensten, auf beide Nutzer in den frontend- und backend-Netzwerken zuzugreifen, während db nur innerhalb des backend-Netzwerks zugänglich ist.

Volumes anpassen

• Volumes werden unter dem obersten volumes-Schlüssel definiert. Mounten Sie sie an Container, indem Sie den volumes-Schlüssel unter einem Dienst verwenden.
• Volumes können benannt sein, Custom-Drivers nutzen und über mehrere Dienste hinweg geteilt werden, um Datenbeständigkeit und -teilung zu gewährleisten.

Beispiel:

volumes:
  web_data:                # Benanntes Volume für Web-Content
  db_data:                 # Benanntes Volume für Datenbank

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

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

• In diesem Beispiel wird web_data dauerhaft gespeichert und steht jedem Container zur Verfügung, der es mountet. db_data stellt sicher, dass Datenbankdaten bei der Neuercstellung von Containern nicht verloren gehen.
• Sie können Bind-Mounts mit Custom-Driver-Optionen für fortschrittliche 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-Hostnamen für die Kommunikation zwischen Diensten.
• Hängen Sie Dienste bei Bedarf an mehrere Netzwerke an, um den Zugriff zu kontrollieren.
• Verwenden Sie benannte Volumes für persistente Speicherung und Datenteilung.
• Definieren Sie alles mit YAML, um Versionskontrolle und einfache Deployment-Skripte zu ermöglichen.
• Für das Container-Management und die Visualisierung ziehen Sie Portainer unter Linux installieren in Betracht.

Mehrere Compose-Dateien

Um komplexe Multi-Service-Einrichtungen in Docker Compose zu organisieren, können Sie mehrere Compose-Dateien und Override-Dateien verwenden, was modularen, umgebungsspezifischen und skalierbaren Konfigurationen ermöglicht. So funktioniert es:

1. Struktur von Basis- und Override-Dateien

• Erstellen Sie eine Basisdatei (compose.yaml oder docker-compose.yml) mit allen gemeinsamen, standardmäßigen Dienstdefinitionen.
• 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 (automatisch angewendet)
|-- docker-compose.prod.yml      # Produktions-Overrides
|-- docker-compose.test.yml      # Test-Overrides (falls benötigt)

Die Basis-Konfiguration definiert Kern-Dienste, während jeder Override Einstellungen für eine spezifische Umgebung oder einen Fall anpasst.

2. So funktioniert das Datei-Override

• Merge: Wenn Sie docker compose up ausführen, fusioniert Docker Compose die Basis mit allen Overrides in Reihenfolge; nachfolgende Dateien überschreiben, erweitern oder ergänzen Einstellungen in früheren Dateien.
• Feld-Überschreibung: Wenn ein Dienst oder ein Feld in mehreren Dateien definiert ist, wird der Wert der zuletzt angegebenen Datei verwendet. Neue Felder werden hinzugefügt.

Merge-Beispiel:

• docker-compose.yml:

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

• docker-compose.override.yml:

  services:
    web:
      environment:
        - DEBUG=true
  

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

3. Befehlsnutzung für mehrere Dateien

• Standardverhalten: Wenn vorhanden, lädt Docker Compose docker-compose.override.yml automatisch zusammen mit docker-compose.yml, wenn Sie einen Befehl ausführen.
• Dateien manuell angeben: Verwenden Sie -f-Flags, um zu kontrollieren, welche Dateien gemerged werden und in welcher Reihenfolge:

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

  • Dies ignoriert die standardmäßige Override-Datei und verwendet die produktionsspezifischen Einstellungen.

4. Praktische Organisationsstrategien

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

5. Vorteile

• Klarheit: Hält einzelne Dateien klein und fokussiert.
• Skalierbarkeit: Leichte Hinzufügung neuer Dienste, Umgebungen oder Einstellungen.
• Wartbarkeit: Ändern oder prüfen Sie nur die relevanten Abschnitte für eine gegebene Deployment.

6. Beispiel: Umgebungswechsel

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-Einrichtungen mit mehreren Dateien - und die Nutzung des Override/Merge-Systems - stellt Modularität, umgebungsspezifische Anpassung und einfache Skalierbarkeit für große, Multi-Service-Docker-Anwendungen sicher.

Für die Produktionsdeployment auf einem einzelnen Linux-Host — Start beim Hochfahren, sauberes Herunterfahren, Updates und Protokollrotation — siehe Docker Compose als Linux-Dienst mit systemd ausführen. Für einen Vergleich mit Podman Quadlet, siehe Podman Quadlet vs Docker Compose für Linux-Dienste.

Nützliche Links

• https://docs.docker.com/compose/
• Docker Schnellreferenz
• Kubernetes Schnellreferenz
• Flutter Web-App mit dockerisierten Flutter-Build und Nginx dockerisieren
• Portainer unter Linux installieren
• Gitea-Server sichern und wiederherstellen