Docker Compose Anleitung: Vom Einsteiger zum Profi

Docker Compose Anleitung: Alles was Sie wissen müssen

Docker Compose ist das unverzichtbare Tool für jeden, der mit mehreren Docker-Containern arbeitet. Diese Anleitung führt Sie von den Grundlagen bis zu fortgeschrittenen Konzepten.

Was ist Docker Compose?

Docker Compose ermöglicht es Ihnen, Multi-Container Docker-Anwendungen zu definieren und zu starten. Statt jeden Container einzeln zu konfigurieren und zu starten, beschreiben Sie Ihre gesamte Anwendung in einer einzigen YAML-Datei.

Ohne Docker Compose:

docker network create myapp
docker run -d --name db --network myapp -e POSTGRES_PASSWORD=secret postgres:15
docker run -d --name redis --network myapp redis:7
docker run -d --name app --network myapp -p 3000:3000 myapp:latest

Mit Docker Compose:

# docker-compose.yml
services:
  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: secret
  redis:
    image: redis:7
  app:
    build: .
    ports:
      - "3000:3000"

Ein einziges docker compose up startet alles.

Installation

macOS und Windows

Docker Compose ist in Docker Desktop integriert. Nach der Installation von Docker Desktop ist docker compose automatisch verfügbar.

Linux (Ubuntu/Debian)

# Docker installieren
sudo apt update
sudo apt install docker.io

# Docker Compose Plugin installieren
sudo apt install docker-compose-plugin

# Verifizieren
docker compose version

Ihr erstes docker-compose.yml

Erstellen Sie eine Datei namens docker-compose.yml:

version: '3.8'

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html

Starten Sie mit:

docker compose up

Öffnen Sie http://localhost:8080 – fertig!

Die wichtigsten Befehle

Befehl	Beschreibung
docker compose up	Startet alle Services
docker compose up -d	Startet im Hintergrund (detached)
docker compose down	Stoppt und entfernt Container
docker compose ps	Zeigt laufende Services
docker compose logs	Zeigt Logs aller Services
docker compose logs -f web	Folgt Logs eines Services
docker compose exec web sh	Shell in Container öffnen
docker compose build	Baut Images neu
docker compose pull	Zieht neueste Images

Praktisches Beispiel: WordPress mit MySQL

version: '3.8'

services:
  wordpress:
    image: wordpress:latest
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress_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: wordpress
      MYSQL_PASSWORD: wordpress_password
      MYSQL_ROOT_PASSWORD: root_password
    volumes:
      - db_data:/var/lib/mysql
    restart: unless-stopped

volumes:
  wordpress_data:
  db_data:

Was passiert hier?

• Zwei Services: wordpress und db
• WordPress wartet auf MySQL (depends_on)
• Daten bleiben in benannten Volumes erhalten
• Bei Crash werden Container neu gestartet (restart: unless-stopped)

Wichtige Konzepte im Detail

1. Volumes: Daten persistent speichern

services:
  db:
    image: postgres:15
    volumes:
      # Benanntes Volume (von Docker verwaltet)
      - db_data:/var/lib/postgresql/data
      # Bind Mount (Host-Verzeichnis)
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql

volumes:
  db_data:

2. Networks: Container verbinden

services:
  frontend:
    networks:
      - frontend_net

  backend:
    networks:
      - frontend_net
      - backend_net

  database:
    networks:
      - backend_net

networks:
  frontend_net:
  backend_net:

Container können nur kommunizieren, wenn sie im selben Netzwerk sind.

3. Environment Variables

services:
  app:
    environment:
      - NODE_ENV=production
      - API_KEY=${API_KEY}  # Aus .env-Datei
    env_file:
      - .env.production

.env-Datei (NICHT committen!):

API_KEY=geheim123
DB_PASSWORD=sicher456

4. Healthchecks

services:
  web:
    image: nginx
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

5. Ressourcen begrenzen

services:
  app:
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M
        reservations:
          cpus: '0.25'
          memory: 256M

Entwicklung vs. Produktion

Development (docker-compose.override.yml)

# docker-compose.yml (Basis)
version: '3.8'
services:
  app:
    build: .
    environment:
      - NODE_ENV=development

# docker-compose.override.yml (automatisch gemergt in dev)
version: '3.8'
services:
  app:
    volumes:
      - .:/app
      - /app/node_modules
    command: npm run dev
    ports:
      - "3000:3000"
      - "9229:9229"  # Debugger

Production (docker-compose.prod.yml)

# docker-compose.prod.yml
version: '3.8'
services:
  app:
    image: myapp:latest
    environment:
      - NODE_ENV=production
    restart: always
    deploy:
      replicas: 3

Starten mit:

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

Häufige Probleme und Lösungen

Problem: Port bereits belegt

Error: bind: address already in use

Lösung:

# Prozess auf Port finden
lsof -i :8080
# Oder anderen Port nutzen
ports:
  - "8081:80"

Problem: Container kann anderen nicht erreichen

Lösung: Services erreichen sich über den Service-Namen, nicht localhost:

# Falsch im App-Code
DATABASE_URL=localhost:5432

# Richtig
DATABASE_URL=db:5432  # "db" ist der Service-Name

Problem: Änderungen werden nicht übernommen

Lösung:

docker compose up --build  # Rebuilded Images
docker compose down -v && docker compose up  # Löscht auch Volumes

Problem: Volumes nehmen zu viel Platz

Lösung:

docker system prune -a --volumes  # VORSICHT: Löscht alles Ungenutzte!
docker volume prune  # Nur ungenutzte Volumes

Best Practices

1. Immer .env für Secrets nutzen – Niemals Passwörter in docker-compose.yml committen

2. Spezifische Image-Tags verwenden – postgres:15 statt postgres:latest

3. Healthchecks definieren – Für besseres Monitoring und depends_on

4. Restart-Policies setzen – unless-stopped oder always für Produktion

5. Ressourcen-Limits – Verhindern, dass ein Container alles frisst

6. Netzwerke isolieren – Nicht alles ins default-Netzwerk

Nützliche Compose-Erweiterungen

Logging konfigurieren

services:
  app:
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

Profiles für optionale Services

services:
  app:
    # Immer gestartet

  debug:
    profiles: ["debug"]
    # Nur mit: docker compose --profile debug up

  testing:
    profiles: ["test"]

Fazit

Docker Compose vereinfacht die Container-Orchestrierung erheblich. Mit einer einzigen YAML-Datei können Sie komplexe Multi-Container-Anwendungen definieren, starten und verwalten.

Nächste Schritte:

• Experimentieren Sie mit den Beispielen
• Containerisieren Sie Ihre bestehenden Projekte
• Erkunden Sie Docker Swarm oder Kubernetes für größere Deployments

Bei Fragen zur Container-Strategie oder DevOps-Optimierung helfen wir bei Balane Tech gerne weiter.