Docker Tutorial & Architekturvergleich: Microservices vs. Monolith

Einführung

Docker ist längst kein Nischenthema mehr – in modernen Softwareprojekten ist es ein zentraler Bestandteil der Entwicklungs- und Deploymentsstrategie geworden. Dieser Beitrag richtet sich an Entwickler:innen, die in die Welt von Docker einsteigen wollen und verstehen möchten, warum Containerisierung besonders im Vergleich zu monolithischen Architekturen so mächtig ist.


Was ist Docker?

Docker ist eine Plattform zur Containerisierung von Anwendungen. Ein Container ist eine isolierte Umgebung, die alles enthält, was eine Anwendung zum Laufen braucht: Code, Laufzeitumgebung, Bibliotheken und Konfigurationen.

Vorteile von Docker:

  • Plattformunabhängigkeit (läuft auf jedem System mit Docker Engine)
  • Leichtgewichtiger als virtuelle Maschinen
  • Einfaches Deployment und Skalierung
  • Unterstützung moderner CI/CD-Prozesse

Docker in der Praxis – Ein einfaches Tutorial

Lass uns direkt loslegen. Ziel: Wir erstellen ein kleines Python-Web-API mit Flask und verpacken es in einen Docker-Container.

1. Projektstruktur vorbereiten

mkdir flask-docker-app
cd flask-docker-app

2. Python-API mit Flask

Erstelle eine Datei namens app.py:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hallo von Docker & Flask!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

3. Abhängigkeiten festhalten

requirements.txt:

flask==2.3.2
  1. Dockerfile schreiben
# Basis-Image
FROM python:3.11-slim

# Arbeitsverzeichnis setzen
WORKDIR /app

# Abhängigkeiten kopieren und installieren
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# App-Datei kopieren
COPY app.py .

# Container starten
CMD ["python", "app.py"]

5. Docker-Image bauen

docker build -t flask-docker-app .

6. Container starten

docker build -t flask-docker-app .

Jetzt öffne deinen Browser und gehe auf http://localhost:5000. Du solltest die Nachricht „Hallo von Docker & Flask!“ sehen.


Monolithische Architektur vs. Microservices mit Docker

Nun zum spannenden Architektur-Vergleich. Warum überhaupt Container? Was bringt Docker im Vergleich zu einem klassischen Monolithen?

Was ist eine monolithische Architektur?

Ein Monolith ist eine einzige, zusammenhängende Codebasis, die alle Funktionalitäten eines Systems vereint. Beispiel: Ein Webshop enthält in einer Anwendung sowohl:

  • Benutzerverwaltung
  • Produktkatalog
  • Warenkorb
  • Bezahlfunktion
  • E-Mail-Benachrichtigung

Alles läuft als eine Anwendung mit einem Deployment, häufig auf einem großen Server oder einer VM.

Vorteile:

  • Einfacher Start
  • Weniger technologische Komplexität
  • Weniger Overhead für kleine Projekte

Nachteile:

  • Schwer skalierbar (alles oder nichts)
  • Änderungen in einem Modul können das ganze System beeinflussen
  • Lange Build- und Deploy-Zeiten
  • Schwer wartbar bei wachsender Codebasis

Microservices + Docker: Die moderne Alternative

Statt ein großes System in einem Block zu bauen, wird es in kleine, unabhängige Services aufgeteilt, z.B.:

  • user-service
  • product-service
  • payment-service
  • email-service

Jeder dieser Services läuft in einem eigenen Docker-Container – unabhängig voneinander entwickelt, getestet und deployed.

Vorteile:

  • Unabhängige Skalierung der einzelnen Komponenten
  • Technologiemix möglich (z.B. Python für den einen Service, Go für den anderen)
  • Schnellere Entwicklungszyklen
  • Fehlerisolierung – ein kaputter Service reißt nicht das ganze System mit

Nachteile:

  • Komplexeres Systemdesign (Netzwerk, Kommunikation, Monitoring)
  • DevOps-Kompetenz wird wichtiger
  • Eventuelle Overhead durch Service-Kommunikation (REST, gRPC, Messaging)

Praxisbeispiel: Webshop als Microservices

Stell dir einen Online-Shop vor. Statt eines einzigen Monolithen teilst du das System auf:

  • Jeder Microservice hat ein eigenes Git-Repo
  • Wird in einen eigenen Docker-Container gepackt
  • Deployt über Kubernetes oder Docker Compose
  • Kommunikation über REST oder Event-Bus (z.B. RabbitMQ)

Durch diese Trennung kannst du z. B. den product-service hochskalieren, wenn es viele Suchanfragen gibt – ohne den payment-service zu belasten.


Fazit: Warum Docker die Basis moderner Architekturen ist

Docker macht es möglich, skalierbare, modulare Systeme effizient zu bauen und zu betreiben. Besonders in der Welt der Microservices ist Docker das Rückgrat für Flexibilität und Geschwindigkeit.

MonolithMicroservices mit Docker
Ein BlockEinzelne Services
Schwer skalierbarFeingranulare Skalierung
Eine TechnologieMix möglich
Träge DeploymentsSchnelle Iteration
Einfacher StartKomplexer Aufbau

Ob du neu in die Entwicklung einsteigst oder an der nächsten Cloud-Architektur arbeitest – Docker zu verstehen und zu beherrschen ist heute Pflicht.


Bonus: Tools & Links für deinen Einstieg


Wenn dir der Beitrag gefallen hat oder du Fragen hast: Schreib einen Kommentar oder teil ihn mit deinem Dev-Team 🚀

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert