Docker Compose Guide: Vereinfachen Sie die Multi-Container-Entwicklung

Docker Compose vereinfacht die Verwaltung von Docker-Anwendungen mit mehreren Containern und ermöglicht es Entwicklern, mühelos komplexe Anwendungen zu schreiben und auszuführen.

Zwischenzeitliche DevOps-Ingenieure, Backend-Entwickler und Cloud-native Entwickler, insbesondere diejenigen, die an Microservices oder Multi-Service-Architekturen arbeiten, stehen oft vor der Herausforderung, zahlreiche miteinander verbundene Container zu verwalten. Docker Compose geht auf diese Komplexität ein und rationalisiert die Entwicklungs- und Testabläufe. 

In diesem Artikel erfährst du alles, was du brauchst, um Docker Compose zu nutzen. Schau dir unseren Leitfaden "Docker für Anfänger" an, wenn du gerade erst mit Docker anfängst. 

Was ist Docker Compose?

Docker Compose ist ein Tool zur Definition und Orchestrierung von Docker-Anwendungen mit mehreren Containern über eine einzige YAML-Konfigurationsdatei. 

Mit Compose kannst du ganz einfach Dienste, Netzwerke, Volumes, Umgebungseinstellungen und Abhängigkeiten festlegen. Es ist ideal für die lokale Entwicklung, Testaufbauten, Rapid Prototyping und kleinere Produktionsumgebungen.

Zu den häufigen Anwendungsfällen von Docker Compose gehört die Erstellung lokaler Umgebungen, die reale Systeme widerspiegeln, wie z.B. Microservices-Architekturen. Durch die klare Definition des Zusammenspiels der Komponenten sorgt Compose für Konsistenz, Benutzerfreundlichkeit und schnellere Iterationszyklen.

Du fragst dich vielleicht, warum du nicht einfach Kubernetes verwenden solltest. Erstens ist es für kleine Projekte und lokale Tests zu viel des Guten. Wie du in unserem Kubernetes vs. Kubernetes entdecken wirst. Docker tutorial, ist Kubernetes besser geeignet, um mehrere Container in Clustern zu verwalten. In unserem Kurs "Containerisierung und Virtualisierung mit Docker und Kubernetes " erfährst du, wie du mit Docker und Kubernetes Anwendungen erstellen und einsetzen kannst. 

Warum Docker Compose vs. Docker Compose? Manuelle Docker-Befehle?

Mehrere Container einzeln zu verwalten, kann schnell chaotisch werden, denn:

• Komplexe Unterhaltsverpflichtungen, 
• Inkonsistente Umgebungen, und 
• Probleme mit der Skalierbarkeit. 

Mit manuellen Befehlen riskierst du menschliche Fehler, Konfigurationsabweichungen und ineffiziente Arbeitsabläufe. 

Docker Compose hilft, diese Probleme zu lösen, indem es alle Anwendungsdienste und Abhängigkeiten in einer YAML-Datei definiert. Das sorgt für Konsistenz, Skalierbarkeit und ein einfaches Abhängigkeitsmanagement, wodurch Fehler deutlich reduziert und die Produktivität gesteigert werden.

Compose ist schneller, als die Container manuell zu erstellen und zu verbinden. Außerdem erstellt compose ein Standardnetzwerk für die Kommunikation zwischen allen Containern. Außerdem verwaltet es die Volumes und stellt sicher, dass sie bei einem Austausch oder Neustart des Dienstes automatisch wieder eingebunden werden. 

Wie du Anwendungen für maschinelles Lernen mit Docker und Kubernetes containerisierst, erfährst du in unserem Tutorial How to Containerize an Application Using Docker . 

Was ist der Unterschied zwischen Docker und Docker Compose?

Während Docker die Plattform zum Erstellen, Ausführen und Verwalten von Containern ist, ist Docker Compose das Tool, mit dem sich mehrere Container mithilfe einer YAML-Datei definieren und verwalten lassen, meist docker-compose.yml. 

Docker verwaltet einzelne Container, aber mit Docker Compose kannst du sie zu einem einzigen Dienst zusammenfassen. Zum Beispiel eine Anwendung mit einem Backend, Frontend, einer Datenbank, Caching und so weiter. 

Du kannst deine Container auch ohne Docker Compose bauen und ausführen. Wenn du jedoch alles in einer einzigen docker-compose.yml Datei zusammenfasst, ist es einfacher, mehrere Container zu verwalten. Außerdem ist es möglich, deine Anwendung in jeder Umgebung mit einem einzigen Befehl zu starten. 

Das Verständnis von Docker und Docker Compose ist entscheidend für deine nächsten Bewerbungsgespräche. Stell sicher, dass du bereit bist, indem du die 26 besten Docker-Interview-Fragen und -Antworten für 2025 entdeckst. 

Grundlagen von Docker Compose

Bevor du in die praktischen Details eintauchst, ist es wichtig, die Grundprinzipien und die Syntax von Docker Compose zu verstehen. Bevor du compose verwendest, stelle sicher, dass du Docker installiert hast. Befolge dazu die Anweisungen in unserem Installiere Docker unter Ubuntu: Vom Aufbau bis zum ersten Container guide. 

Konzeptioneller Rahmen

Docker Compose abstrahiert die Komplexität der Container-Orchestrierung für die lokale Entwicklung und einfachere Implementierungen. Mit einer YAML-formatierten Compose-Datei gibst du an, welche Dienste sie benötigen, definierst ihre Abhängigkeiten, gibst Netzwerke, Volumes, Umgebungsvariablen und mehr an. Compose verwaltet effizient das Starten, Stoppen, Skalieren und Verbinden dieser Dienste.

Core Compose-Syntax

Docker Compose basiert auf einer unkomplizierten YAML-Syntax. Zu den wichtigsten Komponenten gehören:

• services für die Definition von containerisierten Anwendungen
• images oder build Kontexte zur Angabe von Containern
• ports für die Offenlegung von Diensten
• volumes für persistente Datenspeicherung
• networks für die dienststellenübergreifende Kommunikation

Dienstdefinition und Anwendungsarchitektur

Compose-Dateien stellen die Dienste und Verbindungen der Anwendung dar.

Dienstleistungen definieren

Dienste sind der Kern einer Compose-Datei. Du kannst mehrere Dienste (z. B. Web-Frontends, Datenbanken und Caching-Dienste) klar definieren und benennen und Abhängigkeiten über einfache Schlüsselwörter wie depends_on festlegen, um die Startreihenfolge der Container zu steuern.

Grundlagen der Netzwerkarbeit

Docker Compose erstellt automatisch Standardnetzwerke, um die Kommunikation zwischen den definierten Diensten zu erleichtern. Bei Bedarf können die Entwickler auch benutzerdefinierte Netzwerke für eine verbesserte Isolierung oder detaillierte Netzwerkanforderungen festlegen.

Volumen Management

Volumes ermöglichen die Persistenz von Daten über den Lebenszyklus von Containern hinaus. Du kannst benannte Volumes angeben oder Host-Verzeichnisse in Container einbinden, um sicherzustellen, dass Datenbanken, Protokolle oder andere zustandsabhängige Daten konsistent bleiben.

Umgebungsvariablen

Compose vereinfacht die sichere Übergabe von Umgebungsvariablen und Geheimnissen an Container. Es unterstützt direkte Deklarationen unter Diensten und referenziert Variablen, die in env Dateien gespeichert sind, sowie Kompositionsdateien, um sensible Werte sicher und getrennt von Docker-Definitionen zu halten.

Docker Compose Skalierung und Orchestrierung

Docker Compose vereinfacht auch die grundlegende Skalierung und Orchestrierung, was besonders für schnelle Lasttestszenarien oder die Evaluierung paralleler Dienste nützlich ist.

Dienstleistungen skalieren

Mit dem Compose-Flag "--scale" kannst du schnell mehrere Kopien von Diensten aufsetzen. Das macht Testszenarien wie die Bewertung der Lastverteilung oder die Bearbeitung gleichzeitiger Anfragen einfach.

Zum Beispiel kann die Skalierung eines Flask-Anwendungscontainers mit nur einem Befehl erfolgen:

docker-compose up --scale flaskapp=4

Docker Compose vs. Docker Swarm und Kubernetes

Docker Compose eignet sich zwar hervorragend für die lokale Entwicklung und kleinere Setups, ist aber bei der Orchestrierung auf mehreren Hosts und im Produktionsmaßstab begrenzt. Für komplexe, produktionsreife Szenarien mit zahlreichen Hosts sind robustere Orchestratoren wie Docker Swarm oder Kubernetes geeignet, da sie einen leistungsstarken Lastausgleich, Selbstheilung, fortschrittliche Netzwerke und eine groß angelegte Skalierbarkeit bieten, die in Compose nicht verfügbar sind.

Unsere Docker Compose vs. Docker Compose. Der Kubernetes-Blogpost geht näher auf die wichtigsten Unterschiede zwischen Docker Compose und Kubernetes ein.  

Optimierungstechniken für eine effiziente Nutzung von Compose

Die effiziente Nutzung von Docker Compose umfasst die Optimierung von Builds, das Hinzufügen von Health Checks und die Verwaltung von Dienstressourcen. In diesem Abschnitt erfährst du mehr über diese Optimierungstechniken.

Effiziente Aufbaustrategien

Die Verwendung von mehrstufigen Builds in Dockerfiles hilft, die Größe von Docker-Images zu reduzieren, während die explizite Nutzung von Build-Caching die Entwicklungs- und CI-Prozesse erheblich beschleunigt.

Gesundheitskontrollen und Richtlinien für den Neustart

Compose ermöglicht es dir, explizite Container-Zustandsprüfungen zu definieren, um die Zuverlässigkeit der Anwendung zu gewährleisten. Neustartrichtlinien sorgen dafür, dass ausgefallene Container automatisch neu gestartet werden, um die Ausfallsicherheit zu erhöhen.

Verwaltung der Ressourcengrenzen

Wenn du CPU- und Speicherlimits direkt in den Compose YAML-Definitionen festlegst, kannst du die Ressourcenzuweisungen kontrollieren und so die Vorhersehbarkeit und Ressourceneffizienz verbessern.

Ein Beispiel-Snippet für Ressourcenlimits:

services:
  flaskapp:
    image: flask
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M

Praktisches Beispiel: Multicontainer-Anwendung

Hier ein vereinfachtes Beispiel aus der Praxis: eine Python-Flask-Anwendung in Kombination mit Redis:

services:
  redis:
    image: redis:7
    container_name: redis
    ports:
      - "6379:6379"
    restart: always
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 5s
      retries: 3
  web:
    build: .
    container_name: flask_app
    command: gunicorn app:app --worker-class gevent --bind 0.0.0.0:5000 --timeout 3000
    ports:
      - "5000:5000"
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

  worker:
    build: .
    container_name: celery_worker
    command: celery -A celery_worker.celery worker --loglevel=info
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

Die Docker Compose-Datei definiert eine Multicontainer-App mit drei Diensten:

1. redis
2. Web (Flask-App mit Gunicorn)
3. Arbeiter (Selleriearbeiter)

Für den Dienst redis:

• Verwendet das offizielle Redis 7 Image.
• Setzt den Containernamen auf redis.
• Ordnet Port 6379 im Container auf 6379 auf dem Host zu.
• Startet immer neu, wenn er abstürzt (Neustart: immer).
• Definiert eine healthcheck, die redis-cli ping alle 30 Sekunden ausführt, nach 5 Sekunden eine Pause einlegt und es 3 Mal wiederholt, bevor sie den Container für ungesund erklärt.

Für den Webdienst:

• Erstellt das Bild aus dem aktuellen Verzeichnis (build: . ).
• Benennt den Container flask_app.
• Führt den Befehl gunicorn app:app mit gevent Arbeitern, Bindung an 0.0.0.0:5000, mit einem langen Timeout von 3000 Sekunden
• Ordnet den Container-Port 5000 dem Port 5000 auf dem Host zu.
• Deklariert eine Abhängigkeit vom redis Dienst und stellt sicher, dass Redis zuerst startet.
• Setzt eine Umgebungsvariable REDIS_URL, die auf den internen Redis-Container zeigt.
• Lädt zusätzliche Umgebungsvariablen aus der Datei .env.
• Mounten von drei lokalen Ordnern in den Container:
• ./shorts zu /app/shorts,
• ./temp_uploads zu /app/temp_uploads 
• ./uploads zu /app/uploads
• So konfiguriert, dass er immer neu startet, wenn er abstürzt.

Für den Arbeiter Dienst:

• Baut auch das Image aus dem aktuellen Verzeichnis (build: .), wobei dieselbe Dockerdatei verwendet wird wie bei der web Dienst.
• Benennt den Container: celery_worker.
• Führt den Befehl celery -A celery_worker.celery worker --loglevel=info aus, der einen Celery-Worker startet, um Hintergrundaufträge zu bearbeiten.
• Deklariert eine Abhängigkeit vom redis Dienst und stellt sicher, dass Redis zuerst startet.
• Setzt die gleiche REDIS_URL Umgebungsvariable, um sich mit dem Redis-Broker zu verbinden.
• Lädt andere Umgebungsvariablen aus der Datei .env.
• Mounten Sie die gleichen drei Ordner wie die web Dienst, so dass sowohl die Web-App als auch der Worker Dateien und Uploads gemeinsam nutzen können.
• So konfiguriert, dass er immer neu startet, wenn er abstürzt.

Entdecke weitere Docker-Projektideen in unserem 10 Docker-Projektideen-Tutorial. 

Erstellen und Ausführen von Multi-Container-Anwendungen

Docker Compose bietet ein unkompliziertes Toolset für routinemäßige Containeraufgaben:

Bilder vom Gebäude

Verwende docker compose build, um Container-Images entsprechend deiner definierten Dockerdateien zu erzeugen. Weitere Informationen über das Erstellen von Docker-Images findest du in unserem How to Learn Docker from Scratch: Ein Leitfaden für Datenfachleute tutorial. 

Laufende Dienste

Mit docker compose up werden alle in der Kompositionsdatei definierten Dienste gestartet. Für den abgetrennten Modus verwendest du docker compose up -d. In unserem Kurs Einführung in Docker erfährst du mehr darüber, wie ein Container im Hintergrund läuft. 

Laufende Container anzeigen

Um aktive Container und ihren Status anzuzeigen, verwende docker compose ps, um alle laufenden Dienste aufzulisten.

Dienste stoppen

Verwende docker compose down, um die laufenden Dienste anzuhalten. 

Protokolle ansehen

Verwende docker compose logs, um die Logs zu überprüfen. Mit docker logs container_name kannst du einen Container angeben, aus dem die Logs geprüft werden sollen. Um die Protokolle zu streamen, verwende docker compose -f container_name. 

In unserem Leitfaden "Top 18 Docker Commands to Build, Run, and Manage Containers " werden weitere Docker-Befehle beschrieben, damit du Anwendungen in verschiedenen Umgebungen sicher verwalten kannst.

Docker Compose Erweiterte Anwendungsfälle 

Compose-Workflows passen sich an komplexere Entwicklungs-Setups oder unterschiedliche Umgebungskonfigurationen an.

Multi-Umgebung-Konfiguration

Mehrere Compose-Dateien oder Override-Dateien erleichtern die Einrichtung verschiedener Umgebungen (Entwicklung, Test, Produktion). So bleiben die Definitionen wartbar und lesbar und ermöglichen schnelle Änderungen ohne unübersichtliche Konfigurationen.

Abhängigkeitsmanagement

Während depends_on die grundlegende Startreihenfolge regelt, können in komplexen Szenarien Initialisierungsskripte (wie z.B. "wait-for-it") eingesetzt werden, die sicherstellen, dass Container nur dann gestartet werden, wenn bestimmte Bedingungen erfüllt sind, z.B. wenn die Datenbank bereit ist.

Integration mit CI/CD

Compose lässt sich mühelos in kontinuierliche Integrationsworkflows integrieren und automatisiert die Einrichtung kompletter Testumgebungen. Plattformen wie GitLab CI und GitHub Actions bieten native oder einfache Ansätze für die Integration von Compose, die automatisierte Tests vereinfachen.

Bewährte Praktiken und gemeinsame Herausforderungen

Du kannst häufige Fallstricke vermeiden und wartbare Konfigurationen erstellen, indem du die Compose-Definitionen durchdacht organisierst und strukturierst.

Organisation von Dateien zusammenstellen

Halte deine Compose-Dateien übersichtlich und modular. Für einfachere Projekte kann eine einzige Datei ausreichen, aber für größere Anwendungen solltest du in Erwägung ziehen, die Konfiguration in mehrere Compose-Dateien aufzuteilen und die Überschreibungsfunktion zu nutzen. Dies ermöglicht es:

• Logische Trennung der Komponenten (z. B. docker-compose.backend.yml, docker-compose.frontend.yml)
• Leichtere Anpassung der lokalen an die Produktionsumgebung
• Optimierte Versionskontrolle und Zusammenarbeit, da sich Änderungen an einem Dienst nicht auf die gesamte Datei auswirken

Verwende aussagekräftige Dienstnamen und eine einheitliche Einrückung, damit die Dateien leichter zu lesen und zu navigieren sind.

Potenzielle Fallstricke

Sei dir dieser häufigen Fehltritte bewusst:

• Verwendung von latest Tags für Bilder: Dies führt zu Unvorhersehbarkeiten, da sich die tatsächliche Bildversion im Laufe der Zeit ändern kann. Pinne die Versionen der Bilder immer explizit an (z.B. postgres:15.1), um die Konsistenz in verschiedenen Umgebungen zu gewährleisten.
• Geheimnisse verschlüsseln: Füge niemals sensible Daten (z. B. API-Schlüssel, Passwörter) direkt in Compose-Dateien ein. Verwende stattdessen Umgebungsvariablen, .env Dateien (die von der Versionskontrolle ausgeschlossen sind) oder Tools zur Verwaltung von Geheimnissen wie Docker Secrets für eine sichere Handhabung.
• Zu komplexe Dienstdefinitionen: Widerstehe dem Drang, zu viel Logik oder zu viele Verantwortlichkeiten in einen einzigen Container zu packen. Befolge das Prinzip der einzigen Verantwortung und bevorzuge Einfachheit, wo immer es möglich ist.
• Vernachlässigung der expliziten Vernetzung: Definiere benutzerdefinierte Netzwerke in Compose, anstatt dich auf das Standardverhalten zu verlassen. Dies bietet eine bessere Kontrolle über die Dienstkommunikation, reduziert Portkonflikte und verbessert die Sicherheitsgrenzen.

Wenn du diese Praktiken anwendest, werden deine Compose-basierten Workflows stabiler, sicherer und einfacher zu warten sein, wenn du mit anderen zusammenarbeitest oder dich weiterentwickelst.

Fazit

Docker Compose vereinfacht die Erstellung, Verwaltung und Ausführung von Multi-Container-Anwendungen für Entwickler erheblich. Seine klaren, YAML-basierten Definitionen, die einfache Orchestrierung und die unkomplizierte Skalierung machen es zu einem unschätzbaren Wert für lokale Entwicklungsszenarien und einfachere Einsatzarchitekturen. Obwohl fortgeschrittene Orchestratoren wie Docker Swarm und Kubernetes besser für große Produktionsworkloads geeignet sind, bleibt Compose ein wichtiger Einstiegspunkt, um die Grundlagen der Container-Orchestrierung zu verstehen und die Arbeitsabläufe von Entwicklern zu verbessern.

Schau dir unsere Docker-Kurse an, um zu lernen:

• Containerisierung und Virtualisierung mit Docker und Kubernetes 
• Docker für Fortgeschrittene