Docker Compose für die lokale Entwicklung – Ein umfassender Leitfaden

Docker ist mittlerweile ein fester Bestandteil moderner Softwareentwicklung. Es ermöglicht Entwicklern, Anwendungen in Containern zu verpacken, die überall gleich laufen – egal ob auf deinem Laptop, im Testserver oder in der Cloud. Doch wenn man mehrere Container gleichzeitig betreiben will – z. B. eine Webanwendung, eine Datenbank und ein Cache – wird es schnell unübersichtlich. Genau hier kommt Docker Compose ins Spiel.

In diesem Beitrag zeige ich dir, wie du Docker Compose für deine lokale Entwicklung nutzen kannst. Wir bauen gemeinsam eine kleine Beispielanwendung mit mehreren Services und ich erkläre dir Schritt für Schritt, wie alles funktioniert.

Docker Compose für die lokale Entwicklung

📦 Was ist Docker Compose?

Docker Compose ist ein Tool, mit dem du Multi-Container-Anwendungen definieren und ausführen kannst. Die komplette Konfiguration erfolgt in einer Datei namens docker-compose.yml. Dort definierst du, welche Container gestartet werden sollen, welche Netzwerke sie verwenden, welche Umgebungsvariablen gesetzt werden, welche Volumes eingebunden sind und vieles mehr.

Statt also fünf docker run-Befehle auszuführen, reicht ein einfacher:

docker-compose up

Und schon laufen alle Services.

🛠 Voraussetzungen

Bevor du loslegst, solltest du Folgendes installiert haben:

Docker Desktop
Ein Terminal (z. B. iTerm2, PowerShell oder Terminal.app)
Ein Code-Editor (z. B. VS Code)

🚀 Beispiel: Web-App mit Node.js, MongoDB und Admin-Frontend

Nehmen wir an, du entwickelst eine Node.js-Anwendung, die auf MongoDB als Datenbank zugreift. Zusätzlich möchtest du Mongo Express verwenden, ein kleines Admin-Interface für MongoDB.

🔧 Projektstruktur

mein-projekt/
│
├── backend/
│   └── index.js
│   └── package.json
│   └── Dockerfile
│
├── docker-compose.yml
└── .env

Schritt 1: Node.js Backend vorbereiten

index.js

const express = require('express');
const mongoose = require('mongoose');

const app = express();
const PORT = process.env.PORT || 3000;

mongoose.connect('mongodb://mongo:27017/meine-datenbank', {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

app.get('/', (req, res) => {
  res.send('Hallo von Node.js und MongoDB!');
});

app.listen(PORT, () => {
  console.log(`Server läuft auf Port ${PORT}`);
});

package.json

{
  "name": "backend",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "express": "^4.18.2",
    "mongoose": "^7.2.2"
  }
}

Dockerfile

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm install

COPY . .

EXPOSE 3000
CMD ["npm", "start"]

🧩 Schritt 2: `docker-compose.yml` erstellen

version: '3.9'

services:
  backend:
    build: ./backend
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
    depends_on:
      - mongo

  mongo:
    image: mongo:6
    ports:
      - "27017:27017"
    volumes:
      - mongo-data:/data/db

  mongo-express:
    image: mongo-express
    ports:
      - "8081:8081"
    environment:
      - ME_CONFIG_MONGODB_SERVER=mongo
      - ME_CONFIG_BASICAUTH_USERNAME=admin
      - ME_CONFIG_BASICAUTH_PASSWORD=admin
    depends_on:
      - mongo

volumes:
  mongo-data:

Schritt 3: Projekt starten

Führe folgenden Befehl im Hauptverzeichnis aus:

docker-compose up --build

Die Anwendung läuft auf http://localhost:3000
Mongo Express ist erreichbar unter http://localhost:8081

Wenn du fertig bist:

docker-compose down

Das stoppt und entfernt alle Container, Netzwerke und Volumes (außer persistenten Volumes wie mongo-data).

🔄 Entwickler-Workflow

Für den lokalen Entwicklungsworkflow kannst du das Backend als Volume einbinden und mit nodemon arbeiten, damit du Code-Änderungen ohne Neustart sehen kannst.

Passe dazu docker-compose.yml an:

    volumes:
      - ./backend:/app

Und installiere nodemon:

npm install --save-dev nodemon

In der package.json:

"scripts": {
  "start": "nodemon index.js"
}

Jetzt läuft deine App „live“ und lädt sich automatisch neu, wenn du Code änderst – ideal für die Entwicklung!

🔒 Bonus: .env-Datei verwenden

Statt Umgebungsvariablen direkt in die Compose-Datei zu schreiben, kannst du sie in einer .env-Datei speichern:

PORT=3000
ME_CONFIG_BASICAUTH_USERNAME=admin
ME_CONFIG_BASICAUTH_PASSWORD=admin

Und dann in docker-compose.yml referenzieren:

environment:
  - PORT=${PORT}

🧠 Fazit

Docker Compose ist ein extrem nützliches Tool für die lokale Entwicklung – besonders wenn du mit mehreren Services arbeitest. Es spart dir Zeit, vermeidet Setup-Probleme und sorgt dafür, dass deine Umgebung stets reproduzierbar ist.

Mit ein wenig Planung kannst du damit nicht nur deine Anwendung lokal entwickeln, sondern auch in Testszenarien und später im Deployment einsetzen. Es lohnt sich, sich damit näher zu beschäftigen!