# Docker Compose — Multi-Container-Anwendungen orchestrieren

> Praxis-Guide zu Docker Compose — Services starten, Logs verfolgen, Container skalieren und Compose-Dateien strukturieren, mit Beispielen für jeden Befehl.

Source: https://www.jpkc.com/db/cheatsheets/containers/docker-compose/

<!-- PROSE:intro -->
Docker Compose beschreibt eine komplette Anwendung aus mehreren Containern in einer einzigen YAML-Datei – Services, Netzwerke und Volumes inklusive. Statt jeden Container einzeln mit langen `docker run`-Befehlen zu starten, bringst du den gesamten Stack mit einem `docker compose up` hoch und mit `docker compose down` wieder weg. Seit Compose v2 ist das Tool als Subcommand `docker compose` direkt in die Docker-CLI integriert – das alte `docker-compose` mit Bindestrich gilt als veraltet. Dieser Guide zeigt dir die wichtigsten Befehle für den Alltag, vom Starten und Skalieren einzelner Services über das Verfolgen von Logs bis zu typischen Bausteinen der Compose-Datei.
<!-- PROSE:intro:end -->

## Grundlegende Befehle

`docker compose up` — Erstellt und startet alle in der Compose-Datei definierten Services.

```bash
docker compose up
```

`docker compose up -d` — Startet die Services im Hintergrund (Detached-Modus).

```bash
docker compose up -d
```

`docker compose down` — Stoppt und entfernt Container, Netzwerke und die Standard-Volumes.

```bash
docker compose down
```

`docker compose down -v` — Stoppt die Services und entfernt die in der Compose-Datei deklarierten benannten Volumes.

```bash
docker compose down -v
```

`docker compose down --rmi all` — Stoppt die Services und entfernt alle von ihnen genutzten Images.

```bash
docker compose down --rmi all
```

`docker compose start` — Startet bereits erstellte (existierende) Container.

```bash
docker compose start
```

`docker compose stop` — Stoppt laufende Services, ohne die Container zu entfernen.

```bash
docker compose stop
```

`docker compose restart` — Startet alle Services neu.

```bash
docker compose restart
```

`docker compose restart <service>` — Startet einen bestimmten Service neu.

```bash
docker compose restart nginx
```

## Service-Verwaltung

`docker compose ps` — Listet die Container und ihren Status für das aktuelle Projekt auf.

```bash
docker compose ps
```

`docker compose ps -a` — Listet alle Container auf, auch gestoppte.

```bash
docker compose ps -a
```

`docker compose up -d <service>` — Startet nur einen bestimmten Service (samt seiner Abhängigkeiten).

```bash
docker compose up -d web
```

`docker compose stop <service>` — Stoppt einen bestimmten Service.

```bash
docker compose stop worker
```

`docker compose rm <service>` — Entfernt gestoppte Service-Container.

```bash
docker compose rm worker
```

`docker compose up -d --scale <service>=<n>` — Skaliert einen Service auf n Instanzen.

```bash
docker compose up -d --scale worker=3
```

`docker compose up -d --no-deps <service>` — Erstellt einen Service neu, ohne seine Abhängigkeiten neu zu starten.

```bash
docker compose up -d --no-deps web
```

## Logs & Monitoring

`docker compose logs` — Zeigt die Logs aller Services an.

```bash
docker compose logs
```

`docker compose logs -f` — Verfolgt (streamt) die Logs aller Services in Echtzeit.

```bash
docker compose logs -f
```

`docker compose logs <service>` — Zeigt die Logs eines bestimmten Service an.

```bash
docker compose logs nginx
```

`docker compose logs -f --tail <n> <service>` — Verfolgt die Logs und zeigt nur die letzten n Zeilen.

```bash
docker compose logs -f --tail 50 web
```

`docker compose logs --since <time>` — Zeigt Logs ab einem bestimmten Zeitpunkt oder Zeitraum.

```bash
docker compose logs --since 30m
```

`docker compose top` — Zeigt die laufenden Prozesse in jedem Service-Container an.

```bash
docker compose top
```

## Befehle ausführen

`docker compose exec <service> <command>` — Führt einen Befehl in einem laufenden Service-Container aus.

```bash
docker compose exec web bash
```

`docker compose exec -T <service> <command>` — Führt einen Befehl ohne Pseudo-TTY aus (für Skripte).

```bash
docker compose exec -T db mysqldump mydb > backup.sql
```

`docker compose exec -u <user> <service> <command>` — Führt einen Befehl als bestimmter Benutzer aus.

```bash
docker compose exec -u root web bash
```

`docker compose run <service> <command>` — Führt einen einmaligen Befehl in einem neuen Container aus (nicht im laufenden).

```bash
docker compose run web npm install
```

`docker compose run --rm <service> <command>` — Führt einen einmaligen Befehl aus und entfernt den Container danach.

```bash
docker compose run --rm web php artisan migrate
```

## Bauen & Images holen

`docker compose build` — Baut oder rebuildet alle Service-Images.

```bash
docker compose build
```

`docker compose build <service>` — Baut das Image eines bestimmten Service.

```bash
docker compose build web
```

`docker compose build --no-cache` — Baut ohne Layer-Cache (sauberer Neubau).

```bash
docker compose build --no-cache
```

`docker compose pull` — Lädt die aktuellen Images für alle Services herunter.

```bash
docker compose pull
```

`docker compose up -d --build` — Baut die Images neu, bevor die Services gestartet werden.

```bash
docker compose up -d --build
```

`docker compose push` — Lädt die gebauten Service-Images in eine Registry hoch.

```bash
docker compose push
```

## Konfiguration & Debugging

`docker compose config` — Validiert die Compose-Datei und gibt sie aufgelöst aus.

```bash
docker compose config
```

`docker compose config --services` — Listet alle in der Compose-Datei definierten Service-Namen auf.

```bash
docker compose config --services
```

`docker compose config --volumes` — Listet alle in der Compose-Datei definierten Volume-Namen auf.

```bash
docker compose config --volumes
```

`docker compose -f <file> up -d` — Nutzt eine bestimmte Compose-Datei statt der Standarddatei.

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

`docker compose -f docker-compose.yml -f docker-compose.override.yml up -d` — Führt mehrere Compose-Dateien zusammen (spätere überschreiben frühere).

```bash
docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d
```

`docker compose --env-file <file> up -d` — Gibt eine Environment-Datei für die Variablen-Substitution an.

```bash
docker compose --env-file .env.production up -d
```

`docker compose --profile <name> up -d` — Startet Services, die mit einem bestimmten Profil markiert sind.

```bash
docker compose --profile debug up -d
```

## Volumes & Netzwerke

`docker compose cp <service>:<src> <dest>` — Kopiert Dateien aus einem Service-Container ins lokale Dateisystem.

```bash
docker compose cp web:/var/log/app.log ./logs/
```

`docker compose cp <src> <service>:<dest>` — Kopiert Dateien aus dem lokalen Dateisystem in einen Service-Container.

```bash
docker compose cp ./config.json web:/app/config.json
```

`docker volume ls` — Listet alle Docker-Volumes auf (auch die von Compose erstellten).

```bash
docker volume ls
```

`docker volume inspect <project>_<volume>` — Inspiziert ein bestimmtes Compose-Volume (mit Projektnamen als Präfix).

```bash
docker volume inspect myapp_db-data
```

`docker network ls` — Listet alle Docker-Netzwerke auf (auch die von Compose erstellten).

```bash
docker network ls
```

`docker network inspect <project>_<network>` — Inspiziert ein Compose-Netzwerk und zeigt die verbundenen Container.

```bash
docker network inspect myapp_default
```

## Häufige Compose-Datei-Snippets

`ports:` — Einfacher Service mit Port-Mapping.

```yaml
services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
```

`build:` — Service, der aus einem lokalen Dockerfile gebaut wird, mit Bind-Mount.

```yaml
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    volumes:
      - .:/app
```

`depends_on:` — Wartet, bis der Health-Check einer Abhängigkeit erfolgreich ist, bevor gestartet wird.

```yaml
services:
  web:
    depends_on:
      db:
        condition: service_healthy
```

`healthcheck:` — Definiert einen Health-Check für einen Service.

```yaml
services:
  web:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 30s
      timeout: 10s
      retries: 3
```

`volumes:` — Definiert ein benanntes Volume für persistente Datenspeicherung.

```yaml
services:
  db:
    volumes:
      - db-data:/var/lib/mysql
volumes:
  db-data:
    driver: local
```

`env_file:` — Lädt Umgebungsvariablen aus einer Datei in den Service.

```yaml
services:
  web:
    env_file:
      - .env
      - .env.local
```

<!-- PROSE:outro -->
## Fazit

Docker Compose ist das Bindeglied zwischen einem einzelnen Container und einer ausgewachsenen Orchestrierung: Für Entwicklung, Tests und kleinere Deployments deckt es fast jeden Bedarf ab. Wenn dein Stack wächst, lohnt sich der Blick auf Profile, mehrstufige Compose-Dateien und Health-Checks – so bleibt aus einer YAML-Datei ein reproduzierbares, versionierbares Abbild deiner gesamten Anwendung.

## Weiterführende Links

- [Docker Compose – offizielle Dokumentation](https://docs.docker.com/compose/) – Referenz und Anleitungen (englisch)
- [Compose-Dateispezifikation](https://docs.docker.com/reference/compose-file/) – alle Schlüssel und Optionen im Detail (englisch)
- [Docker – Wikipedia](https://de.wikipedia.org/wiki/Docker_(Software)) – Hintergrund und Ökosystem
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [ddev](https://www.jpkc.com/db/cheatsheets/containers/ddev/) – lokale PHP-Entwicklungsumgebungen auf Docker-Basis
- [docker](https://www.jpkc.com/db/cheatsheets/containers/docker/) – einzelne Container und Images direkt verwalten
- [helm](https://www.jpkc.com/db/cheatsheets/containers/helm/) – Paketmanager für Kubernetes-Deployments