---
title: 'Docker Compose Tutorial: Multi-Container-Apps einfach verwalten'
description: Lerne Docker Compose von Grund auf - Dieses Tutorial erklärt, wie du Multi-Container-Anwendungen mit einer einzigen YAML-Datei verwaltest und warum Docker Compose für Selfhosting unverzichtbar ist.
image:
  src: /images/blog/docker_compose_multi_container_applications.jpeg
authors:
  - name: Fabian Sander
    to: /about/fabiansander
    avatar:
      src: /images/blog/authors/fabian.png
date: 2025-12-16
tags: Economy, Information Technology
lastUpdated: 2026-04-13
published: true
---

# Docker Compose Tutorial für Einsteiger

Im [letzten Artikel](/de/blog/how-docker-works) haben wir uns angesehen, wie Docker unter der Haube funktioniert. Wir haben gelernt, was Images sind, wie der Daemon arbeitet und wie man einen einzelnen Container startet.

Aber mal ehrlich: Moderne Webanwendungen sind selten Einzelgänger.

Eine typische App besteht oft aus einem Frontend, einem Backend-Service, einer Datenbank wie [PostgreSQL](/de/blog/postgresql-helm-chart-kubernetes) und vielleicht noch einem Caching-Layer wie Redis. Wenn du versuchst, das alles mit einzelnen `docker run`-Befehlen im Terminal zu jonglieren, verlierst du schnell den Überblick. Du müsstest Netzwerke manuell anlegen, IP-Adressen verwalten und die Startreihenfolge beachten.

Genau hier kommt **Docker Compose** ins Spiel.

## Was ist Docker Compose?

Docker Compose ist ein Tool für Multi-Container-Anwendungen. Wenn das `Dockerfile` das Rezept für eine einzelne Komponente ist (zum Beispiel den Kuchen), dann ist Docker Compose die Speisekarte für das gesamte 3-Gänge-Menü.

Mit einer einzigen Datei, der `docker-compose.yml`, beschreibst du deine komplette Infrastruktur. Das Geniale: Du kannst deine gesamte Umgebung mit einem einzigen Befehl hochfahren.

**Warum ist das gerade für Selfhosting wichtig?**

Wenn du auf einem VPS deine eigenen Services hosten willst, brauchst du eine Lösung, die mehrere Container gleichzeitig verwaltet. Ohne Docker Compose wird das schnell unübersichtlich. Mit Docker Compose hast du alles im Griff. Egal ob du Nextcloud, GitLab, [n8n](/de/blog/self-hosted-n8n-on-hetzner) oder eine WordPress-Instanz betreibst.

## Die Anatomie der docker-compose.yml

Docker Compose nutzt YAML. Das ist ein Format, welches sowohl für Menschen als auch für Maschinen gut lesbar ist. Schauen wir uns die wichtigsten Bausteine an.

### Services: Die einzelnen Container

Unter `services` definierst du die Container, die laufen sollen. Jeder Service bekommt einen Namen (zum Beispiel `web` oder `db`), den du später auch für die interne Kommunikation nutzen kannst.

### Networks: Einfache Vernetzung

Früher war die Vernetzung von Containern kompliziert. Mit Docker Compose ist sie fast schon magisch. Services im gleichen Netzwerk können sich gegenseitig über ihren Service-Namen erreichen. Du musst keine IP-Adressen mehr hardcoden. Dein Backend ruft einfach `db:5432` auf, und Docker leitet es an den Datenbank-Container weiter.

### Volumes: Persistente Daten

Container sind vergänglich. Wenn du einen Datenbank-Container löschst, sind die Daten weg. Außer du nutzt Volumes. In der Compose-Datei definierst du, wo Daten persistent auf deinem Host-System gespeichert werden.

Hier ist ein praktisches Beispiel für ein Setup mit Web-App und Datenbank:

```yaml
version: '3.8'

services:
  webapp:
    build: ./app
    ports:
      - '8080:80'
    depends_on:
      - database
    environment:
      - DB_HOST=database
      - DB_USER=${DB_USER}
      - DB_PASS=${DB_PASSWORD}
    restart: unless-stopped

  database:
    image: postgres:15-alpine
    volumes:
      - db_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=${DB_USER}
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    restart: unless-stopped

volumes:
  db_data:
```

_Hinweis: Die Variablen wie `${DB_USER}` sind Umgebungsvariablen. Dazu gleich mehr._

## Die wichtigsten Docker Compose Befehle

Docker Compose macht deinen Workflow extrem effizient. Statt langer Shell-Scripte brauchst du nur eine Handvoll Befehle:

**Container starten:**

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

Dieser Befehl liest deine Konfiguration, lädt die nötigen Images, erstellt Netzwerke und startet alle Container im Hintergrund (`-d` für detached).

**Status checken:**

```bash
docker-compose ps
```

Zeigt dir sofort, welche Services laufen, welche Ports belegt sind und ob ein Container abgestürzt ist.

**Logs ansehen:**

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

Wichtig fürs Debugging. Hiermit siehst du die Log-Ausgaben aller Services gebündelt in einem Stream.

**Container stoppen:**

```bash
docker-compose down
```

Stoppt die Container und räumt die Netzwerke auf. Sauber und ordentlich.

**Container neu bauen:**

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

Wenn du Änderungen am Code gemacht hast, baut dieser Befehl die Images neu und startet die Container.

## Umgebungsvariablen und Sicherheit

Im Code-Beispiel oben haben wir `${DB_PASSWORD}` verwendet. Hardcodierte Passwörter in einer `yml`-Datei sind ein Sicherheitsrisiko – besonders wenn du den Code auf GitHub pushst.

Docker Compose unterstützt `.env`-Dateien automatisch. Leg eine Datei namens `.env` im gleichen Ordner an und pflege die Variablen:

```bash
DB_USER=admin
DB_PASSWORD=supergeheim
```

**Wichtig für die Sicherheit:**

- Füge `.env` zu deiner `.gitignore` hinzu
- Nutze auf dem Produktionsserver andere Passwörter als lokal
- Vergib niemals Standard-Passwörter wie "admin123"

## Docker Compose für Selfhosting auf deinem VPS

Warum ist Docker Compose perfekt für Selfhosting?

**1. Einfaches Setup auf einem VPS**
Du loggst dich per SSH auf deinen Hetzner-Server ein, lädst deine `docker-compose.yml` hoch und startest mit einem Befehl deine komplette Infrastruktur.

**2. Reproduzierbare Umgebungen**
Deine lokale Entwicklung sieht genauso aus wie dein Produktionsserver. Kein "Auf meinem Rechner läuft es aber!"-Problem mehr.

**3. Einfache Updates**
Neue Version deiner App? Ändere das Image-Tag in der `docker-compose.yml`, führe `docker-compose pull` und `docker-compose up -d` aus – fertig.

**4. Ressourcen-Effizienz**
Auf einem VPS mit 4GB RAM kannst du locker 5-10 kleinere Services gleichzeitig hosten, dank der schlanken Container-Architektur.

## Praxis-Beispiel: WordPress mit MySQL auf Hetzner

Hier ein komplettes Beispiel, wie du WordPress selbst hosten kannst:

```yaml
version: '3.8'

services:
  wordpress:
    image: wordpress:latest
    ports:
      - '80:80'
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: ${DB_USER}
      WORDPRESS_DB_PASSWORD: ${DB_PASSWORD}
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wordpress_data:/var/www/html
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: mysql:8.0
    environment:
      MYSQL_DATABASE: wordpress
      MYSQL_USER: ${DB_USER}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
    volumes:
      - db_data:/var/lib/mysql
    restart: unless-stopped

volumes:
  wordpress_data:
  db_data:
```

So startest du es auf deinem Server:

```bash
# Docker Compose Datei hochladen
scp docker-compose.yml root@dein-server.de:/opt/wordpress/

# Auf dem Server
ssh root@dein-server.de
cd /opt/wordpress
echo "DB_USER=wpuser" > .env
echo "DB_PASSWORD=sicheres-passwort" >> .env
echo "DB_ROOT_PASSWORD=noch-sichereres-passwort" >> .env

# Starten
docker-compose up -d
```

## Häufige Probleme und Lösungen

**Problem: Container startet nicht**

```bash
docker-compose logs service-name
```

Schau dir die Logs an. Meist fehlt eine Umgebungsvariable oder ein Volume-Pfad existiert nicht.

**Problem: Port schon belegt**
Ändere in der `docker-compose.yml` den Port links vom Doppelpunkt: `"8080:80"` statt `"80:80"`

**Problem: Container kann nicht auf andere Services zugreifen**
Prüfe, ob alle Services im gleichen Netzwerk sind und ob die Service-Namen richtig geschrieben sind.

## Best Practices für Docker Compose

1. **Nutze immer `restart: unless-stopped`**
   Damit starten deine Container nach einem Server-Neustart automatisch

2. **Trenne Entwicklung und Produktion**
   Nutze separate Compose-Dateien: `docker-compose.yml` für Entwicklung, `docker-compose.prod.yml` für Produktion

3. **Verwalte Secrets sicher**
   Nutze `.env`-Dateien für lokale Entwicklung und Docker Secrets oder Umgebungsvariablen für Produktion

4. **Verwende Healthchecks**
   Damit Docker automatisch prüft, ob deine Services wirklich laufen

5. **Limitiere Ressourcen**
   Besonders auf kleineren VPS wichtig – verhindert, dass ein Container alle Ressourcen frisst

## Von lokal zu produktiv: Der Deployment-Workflow

So sieht ein typischer Workflow aus:

1. **Lokal entwickeln**

   ```bash
   docker-compose up -d
   # Code ändern, testen
   docker-compose restart webapp
   ```

2. **Auf Server deployen**

   ```bash
   # Code zum Server pushen (Git, rsync, scp)
   ssh user@server
   docker-compose pull
   docker-compose up -d --build
   ```

3. **Überwachen**
   ```bash
   docker-compose logs -f
   docker-compose ps
   ```

## Fazit: Docker Compose für Selfhosting

Docker Compose verwandelt das Chaos einzelner Container in ein gut organisiertes System. Es ist das Tool, das dich vom "Rumspielen mit Docker" zum "Betreiben echter Produktivumgebungen" bringt.

**Die wichtigsten Vorteile:**

- **Alles an einem Ort:** Die gesamte Konfiguration liegt in einer Datei
- **Isolierte Umgebungen:** Du kannst mehrere Projekte parallel auf einem Server laufen lassen
- **Einfache Vernetzung:** Container kommunizieren über DNS-Namen
- **Perfekt für Selfhosting:** Ideal für VPS-Hosting auf dem Anbieter deiner Wahl

Ob du nun einen Blog, eine Cloud-Speicher-Lösung oder ein Monitoring-System hosten willst, Docker Compose macht es einfach, wartbar und reproduzierbar.

**Nächste Schritte:**

- Schnapp dir einen günstigen VPS
- Installiere Docker und Docker Compose
- Starte mit einem einfachen Hobby-Projekt
- Erweitere Schritt für Schritt deine Infrastruktur
- Lerne, wie du [Compose-Files direkt in Docker Swarm deployen](/de/blog/what-is-docker-swarm) kannst, um mehrere Hosts zu orchestrieren
- Verstehe, wie du [Docker, Compose, Swarm und Kubernetes gegeneinander abwägen](/de/blog/docker-vs-kubernetes) kannst, um das richtige Tool für dein Projekt zu wählen

---

_Möchtest du mehr über Deployment-Strategien und Selfhosting erfahren? Schau dir unsere Hosting-Lösungen auf lowcloud.io an – optimiert für Docker und moderne Container-Workflows._