Docker Compose Cheatsheet - Die nützlichsten Befehle mit Beispielen

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

Compose-Datei Referenz: docker-compose.yml

Kernstruktur:

version: '3'       # Compose-Dateiversion

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:           # Benannter Volume
  db_data:

• services: Jeder Container in Ihrer Multi-Container-Anwendung. Im obigen Beispiel haben wir zwei Dienste: web und db.
• networks & volumes: Definieren isolierte Netzwerke und dauerhafte Speicherung - wir haben hier das appnet-Netzwerk und den db_data-Volume.

Beispiele

Einzeldienst mit Portzuordnung

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

Stellt die App auf Host-Port 8000 bereit und baut aus der Dockerfile im aktuellen Verzeichnis.

Mehrfachdienste 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 dauerhaften benannten Volume - db_data.

Verwendung von Build-Kontext und Dockerfile-Pfad

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

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

Datenfreigabe zwischen Diensten

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 denselben Volume zu (für statische Dateien oder Datenaustausch) - shared_data.

Erweitere Compose-Datei-Optionen

• environment: Festlegen von Umgebungsvariablen für Container.
• depends_on: Steuerung der Dienststartreihenfolge.
• deploy.replicas: Skalierung des Dienstes 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).

Wichtige Docker Compose-Befehle

Häufige Compose-Muster

• Datenbanken mit dauerhaften Daten

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

  DB-Daten werden im mysql_data-Volume über Container-Neustarts hinweg beibehalten.

• Bind-Mounting von Code für die Entwicklung

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

  Live-Edit-Code auf dem Host, automatisch im Container reflektiert.

Nützliche Flags

• -d: Abgetrennter Modus (im Hintergrund ausführen).
• --build: Erzwingt das erneute Erstellen von Images vor dem Start.
• --force-recreate: Erneutes Erstellen von Containern, selbst wenn sie unverändert sind.
• --remove-orphans: Entfernt Container, die nicht in der Compose-Datei definiert sind.

Definition und Anpassung von Diensten

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

• Dienste werden unter dem Schlüssel services definiert.
• Jeder Dienst stellt eine Container-Konfiguration dar, in der Sie Folgendes festlegen können:
  • Image: Wählen Sie ein Image von Docker Hub oder einem anderen Registry aus.
  • Ports: Mapping von Container-Ports zu 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 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 tut Ähnliches für PostgreSQL.

Anpassung von Netzwerken

• Netzwerke steuern, welche Dienste kommunizieren können. Compose erstellt ein Standardnetzwerk, aber Sie können mehr definieren, benutzerdefinierte Treiber festlegen, Optionen setzen und bestimmen, welche Dienste welchem Netzwerk beitreten, für eine fein abgestufte Isolation.
• Definieren Sie Netzwerke auf oberster Ebene unter networks und listen Sie auf, welchen Netzwerken ein Dienst beitreten soll, mit dem dienstebenen 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 an:

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

• Diese Einrichtung ermöglicht es dem app-Dienst, auf Benutzer im frontend- und backend-Netzwerk zuzugreifen, während db nur innerhalb des backend-Netzwerks zugänglich ist.

Anpassung von Volumes

• Volumes werden unter dem obersten Schlüssel volumes definiert. Mounten Sie sie in Container mit dem volumes-Schlüssel unter einem Dienst.
• Volumes können benannt werden, benutzerdefinierte Treiber verwenden und von mehreren Diensten für die Datenspeicherung und -freigabe genutzt werden.

Beispiel:

volumes:
  web_data:                # Benannter Volume für Web-Inhalte
  db_data:                 # Benannter 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 persistent gespeichert und ist für jeden Container verfügbar, der ihn mountet. db_data stellt sicher, dass Datenbankdaten beim erneuten Erstellen des Containers 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-Hostnamen für die Kommunikation zwischen Diensten.
• Hängen Sie Dienste an mehrere Netzwerke an, wie benötigt, um den Zugriff zu steuern.
• Verwenden Sie benannte Volumes für die dauerhafte Speicherung und Datenfreigabe.
• Definieren Sie alles mit YAML, um die Versionskontrolle und einfache Bereitstellungsskripte zu ermöglichen.

Mehrere Compose-Dateien

Um komplexe Mehrdienst-Konfigurationen in Docker Compose zu organisieren, können Sie mehrere Compose-Dateien und Überschreibungsdateien verwenden, was modulare, umgebungsspezifische und skalierbare Konfigurationen ermöglicht. Hier erfahren Sie, wie dies funktioniert:

1. Struktur von Basis- und Überschreibungsdateien

• Erstellen Sie eine Basisdatei (compose.yaml oder docker-compose.yml) mit allen gemeinsamen, standardmäßigen Servicedefinitionen.
• Fügen Sie umgebungsspezifische Überschreibungsdateien hinzu (z. B. docker-compose.override.yml, docker-compose.dev.yml, docker-compose.prod.yml).

Beispiel-Dateistruktur:

/projektverzeichnis
|-- docker-compose.yml           # Basis-Konfiguration
|-- docker-compose.override.yml  # Lokale/Entwicklungs-Überschreibungen (wird automatisch angewendet)
|-- docker-compose.prod.yml      # Produktions-Überschreibungen
|-- docker-compose.test.yml      # Test-Überschreibungen (falls benötigt)

Die Basis-Konfiguration definiert Kern-Dienste, während jede Überschreibungsdatei die Einstellungen für eine bestimmte Umgebung oder einen bestimmten Fall anpasst.

2. Funktionsweise von Datei-Überschreibungen

• Zusammenführen: Wenn Sie docker compose up ausführen, führt Docker Compose die Basisdatei mit allen Überschreibungsdateien in der angegebenen Reihenfolge zusammen; nachfolgende Dateien überschreiben, erweitern oder fügen Einstellungen aus vorherigen Dateien hinzu.
• Überschreiben von Feldern: Wenn ein Dienst oder 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 web-Dienst verwendet sowohl das Basis-Image und den Port als auch die überschriebene DEBUG-Umgebungsvariable.

3. Kommandonutzung für mehrere Dateien

• Standardverhalten: Wenn vorhanden, lädt Docker Compose automatisch docker-compose.override.yml zusammen mit docker-compose.yml, wenn Sie einen Befehl ausführen.
• Manuelles Angeben von Dateien: Verwenden Sie die -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 die Standard-Überschreibung und verwendet die produktionsspezifischen Einstellungen.

4. Praktische Organisationsstrategien

• Umgebungstrennung: Verwenden Sie eine Überschreibungsdatei pro Umgebung: Entwicklung, Test, Produktion usw.
• Mikro-Dienste und Teams: Teilen Sie die Konfiguration in separate Dateien für verschiedene Dienste oder Teams auf und kombinieren Sie sie nach Bedarf.
• Feature-Toggles: Zusätzliche Dateien können optionale Dienste oder Konfigurationen für temporäre Anforderungen einführen oder entfernen (z. B. eine compose.debug.yml für zusätzliche Protokollierung).

5. Vorteile

• Klarheit: Hält einzelne Dateien klein und fokussiert.
• Skalierbarkeit: Fügen Sie einfach neue Dienste, Umgebungen oder Einstellungen hinzu.
• Wartbarkeit: Ändern oder überprüfen Sie nur die relevanten Abschnitte für einen bestimmten 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 alle gemeinsame Konfiguration in der Basisdatei steht.

Die Organisation komplexer Compose-Konfigurationen mit mehreren Dateien - und die Nutzung des Überschreibungs-/Zusammenführungssystems - stellt Modularität, umgebungsspezifische Anpassung und einfache Skalierbarkeit für große, mehrdienstliche Docker-Anwendungen sicher.

Nützliche Links

• https://docs.docker.com/compose/
• Docker Cheatsheet
• Kubernetes Cheatsheet
• Dockerising Flutter Web app mit dockerisiertem Flutter-Build und Nginx
• Install Portainer auf Linux