Docker Compose für Einsteiger: Services deployen in 5 Minuten

Docker Compose macht das Orchestrieren von Multi-Container-Anwendungen einfach und reproduzierbar. Dieser Leitfaden erklärt die Grundlagen und zeigt drei praktische Beispiele – von Nginx bis zum Monitoring Stack.

Was ist Docker Compose und warum sollte ich es nutzen?

Wer Docker kennt, weiß: Ein einzelner Container lässt sich mit docker run starten. Aber moderne Anwendungen bestehen selten aus einem einzigen Service. Eine typische Webanwendung braucht einen Webserver, eine Datenbank, vielleicht einen Cache und ein Backup-Tool. Diese manuell zu starten, zu verknüpfen und zu konfigurieren, ist fehleranfällig und schwer reproduzierbar.

Docker Compose löst dieses Problem mit einer einfachen YAML-Datei: docker-compose.yml. Darin beschreiben Sie alle Services, ihre Konfiguration, Volumes und Netzwerke – und starten alles mit einem einzigen Befehl.

Der praktische Nutzen für Unternehmen: Entwicklungsumgebungen sind sofort reproduzierbar, neue Kollegen können mit einem Befehl starten, und Deployments werden konsistent und dokumentiert.

Die Grundstruktur einer docker-compose.yml

Eine Compose-Datei besteht aus wenigen Schlüsselbereichen:

version: "3.9"

services:
  mein-service:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
    environment:
      - NGINX_HOST=localhost
    networks:
      - frontend

networks:
  frontend:

volumes:
  daten:

Services definieren die einzelnen Container. Jeder Service hat mindestens ein image (oder ein build-Kontext) und optional Ports, Volumes, Umgebungsvariablen und Netzwerke.

Volumes persistieren Daten über Container-Neustarts hinaus. Ohne Volumes gehen Datenbankeinträge beim Neustart verloren.

Networks isolieren die Kommunikation zwischen Services. Services im gleichen Netzwerk können sich per Servicename ansprechen (DNS-basiert).

Environment-Variablen konfigurieren Container zur Laufzeit. Für sensible Werte wie Passwörter empfiehlt sich eine .env-Datei:

DB_PASSWORD=sicheres_passwort_hier

Die Compose-Datei referenziert sie dann mit ${DB_PASSWORD}.

Beispiel 1: Nginx als Reverse Proxy

Der einfachste Einstieg – ein Nginx-Webserver, der statische Dateien aus einem lokalen Verzeichnis ausliefert:

version: "3.9"

services:
  webserver:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./html:/usr/share/nginx/html:ro
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./certs:/etc/nginx/certs:ro
    restart: unless-stopped

Das :ro markiert Volumes als read-only – der Container kann die Dateien lesen, aber nicht verändern. restart: unless-stopped sorgt dafür, dass der Container nach einem Neustart des Hosts automatisch wieder startet.

Professionelle Server-Administration – Binary System Services

Beispiel 2: WordPress mit MariaDB

Ein klassisches Beispiel für Multi-Container-Orchestrierung:

version: "3.9"

services:
  db:
    image: mariadb:10.11
    volumes:
      - db_daten:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wp_user
      MYSQL_PASSWORD: ${DB_PASSWORD}
    restart: unless-stopped

  wordpress:
    image: wordpress:latest
    ports:
      - "8080:80"
    depends_on:
      - db
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_NAME: wordpress
      WORDPRESS_DB_USER: wp_user
      WORDPRESS_DB_PASSWORD: ${DB_PASSWORD}
    volumes:
      - wp_daten:/var/www/html
    restart: unless-stopped

volumes:
  db_daten:
  wp_daten:

Wichtig: depends_on stellt sicher, dass die Datenbank vor WordPress gestartet wird. Der WordPress-Container spricht die Datenbank über den Servicenamen db an – Docker Compose kümmert sich um die interne Namensauflösung.

Die Passwörter stehen in einer .env-Datei und werden nicht in die docker-compose.yml eingebettet – damit lässt sich die YAML-Datei sicher ins Git einchecken.

Beispiel 3: Einfacher Monitoring Stack

Ein minimaler Stack aus Uptime-Kuma für Verfügbarkeitsüberwachung:

version: "3.9"

services:
  uptime-kuma:
    image: louislam/uptime-kuma:latest
    volumes:
      - uptime_daten:/app/data
    ports:
      - "3001:3001"
    restart: unless-stopped

volumes:
  uptime_daten:

Mehr zum Thema Monitoring für kleine Unternehmen: IT-Monitoring für kleine Unternehmen

Die wichtigsten Befehle im Überblick

# Services starten (im Hintergrund)
docker compose up -d

# Services stoppen und Container entfernen
docker compose down

# Logs eines Services anzeigen (live)
docker compose logs -f wordpress

# Laufende Container anzeigen
docker compose ps

# Service neu starten
docker compose restart wordpress

# In Container einloggen
docker compose exec wordpress bash

# Images aktualisieren und neu starten
docker compose pull && docker compose up -d

Der -d Flag (detached) startet alles im Hintergrund. Ohne ihn läuft Compose im Vordergrund und zeigt alle Logs direkt an – nützlich beim Debugging.

Best Practices für den produktiven Einsatz

Immer .env-Dateien für Secrets nutzen und diese in .gitignore aufnehmen. Passwörter gehören nicht in die Compose-Datei selbst.

Named Volumes statt Bind Mounts für Datenbank-Daten verwenden. Named Volumes werden von Docker verwaltet und sind portabler.

restart: unless-stopped für alle produktiven Services setzen, damit sie nach Server-Neustarts automatisch wieder verfügbar sind.

Regelmäßige Image-Updates einplanen: docker compose pull zieht aktuelle Images, docker compose up -d startet neu mit dem neuen Image.

Backups nicht vergessen: Volumes müssen separat gesichert werden. Ein einfaches Backup-Script, das Volumes per docker run --volumes-from sichert, sollte Teil jedes produktiven Setups sein.

Docker Compose ist ein hervorragender Einstieg in Container-basierte Infrastruktur. Für komplexere Anforderungen mit Hochverfügbarkeit und automatischem Scaling folgen Tools wie Kubernetes – aber für die meisten KMU-Anwendungen ist Compose die pragmatische, wartbare Lösung.

Mehr zu Server-Administration