Performance-Monitoring und Observability

Docker hat die Art und Weise, wie wir Anwendungen entwickeln und deployen, grundlegend verändert. Mit Containern sind wir flexibel, schnell und portabel unterwegs. Doch sobald Anwendungen wachsen, steigen auch die Anforderungen an Transparenz, Performance-Kontrolle und Fehlersuche.

Hier kommen zwei Begriffe ins Spiel, die in modernen DevOps- und Cloud-Umgebungen unverzichtbar sind:

👉 Performance-Monitoring
👉 Observability

In diesem Beitrag erfährst du:

Was der Unterschied zwischen Monitoring und Observability ist
Welche Tools sich für Docker eignen
Wie du deine Container im Blick behältst – in Echtzeit und retrospektiv
Konkrete Beispiele mit Prometheus, Grafana, cAdvisor, Loki und mehr

🧠 Monitoring vs. Observability – was ist der Unterschied?

✅ Monitoring

Monitoring bedeutet: Metriken erfassen, speichern und auswerten. Typische Monitoring-Daten:

CPU-Auslastung
Arbeitsspeicherverbrauch
Netzwerktraffic
Anzahl von Anfragen oder Fehlern

🌐 Observability

Observability geht weiter: Sie beschreibt die Fähigkeit, den internen Zustand eines Systems allein anhand seiner Outputs (Logs, Metriken, Traces) zu verstehen.

Die drei Säulen der Observability:

Metriken – numerische Werte über Zeit (z. B. CPU, RAM, Anfragen/s)
Logs – Textbasierte Informationen über Ereignisse (z. B. Fehler, Warnungen)
Traces – Ablaufverfolgung von Requests durch verteilte Systeme (Distributed Tracing)

🛠️ Die Toolchain für Docker Observability

Hier eine Übersicht moderner Open-Source-Tools, die perfekt mit Docker zusammenarbeiten:

Zweck	Tool	Beschreibung
Metriken	Prometheus	Time-Series-Datenbank für Monitoring
Visualisierung	Grafana	Dashboards für alles – Metriken, Logs, Traces
Container-Stats	cAdvisor	Echtzeit-Monitoring von Docker-Containern
Logs	Loki + Promtail	Zentrale Log-Sammlung mit Grafana-Integration
Tracing	Jaeger / Tempo	Distributed Tracing
All-in-One	Elastic Stack (ELK)	Elasticsearch, Logstash, Kibana für Logs und mehr

📊 Beispiel: Monitoring mit Prometheus + Grafana

Schritt 1: Prometheus konfigurieren

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'docker'
    static_configs:
      - targets: ['cadvisor:8080']

Schritt 2: Docker-Compose Setup

version: '3'
services:
  cadvisor:
    image: gcr.io/cadvisor/cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:rw
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro

  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"

Mit diesem Setup bekommst du:

Echtzeit-Container-Daten (CPU, Memory etc.)
Eine leistungsstarke PromQL-Abfragesprache
Schöne Dashboards in Grafana

📁 Logs sammeln mit Loki + Promtail

Logs sind Gold wert – besonders bei Bugs oder Performanceproblemen.

Setup:

services:
  loki:
    image: grafana/loki:latest
    ports:
      - "3100:3100"
    command: -config.file=/etc/loki/local-config.yaml

  promtail:
    image: grafana/promtail:latest
    volumes:
      - /var/log:/var/log
      - /etc/promtail:/etc/promtail
    command: -config.file=/etc/promtail/config.yml

Logs landen zentral in Loki und können über Grafana durchsucht werden – inklusive Zeitfilter, Labeling und mehr.

🔁 Distributed Tracing mit Jaeger oder Tempo

Gerade in Microservice-Architekturen ist es wichtig, Anfragen über mehrere Services hinweg zu verfolgen.

Tools wie Jaeger oder Grafana Tempo ermöglichen dir:

Latenzen zu analysieren
Bottlenecks zu identifizieren
User Flows zu visualisieren

Instrumentierung:

Die Anwendung muss Tracing unterstützen (z. B. mit OpenTelemetry SDKs für Node.js, Python, Go etc.)

🧪 Use Case: Fehler finden in Echtzeit

Stell dir vor, deine App wird langsam. So findest du heraus, woran es liegt:

Grafana Dashboard checken: CPU-Spikes? Memory knapp?
Logs in Loki durchsuchen: Gibt es Exceptions oder ungewöhnliche Warnungen?
Tracing öffnen: Dauert ein bestimmter Microservice besonders lange?
Alerting: Prometheus kann bei Schwellenwerten (z. B. CPU > 90%) automatisch Alarme auslösen

🚨 Bonus: Alerts mit Prometheus + Alertmanager

groups:
- name: docker-alerts
  rules:
  - alert: HighCPU
    expr: rate(container_cpu_usage_seconds_total[1m]) > 0.9
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "Container nutzt zu viel CPU"

E-Mails, Slack-Nachrichten, PagerDuty? Alles möglich!

🔚 Fazit

Performance-Monitoring und Observability sind keine Luxus-Features – sie sind essenziell für jedes moderne Software-System.

Mit den richtigen Tools kannst du:

Probleme frühzeitig erkennen
Nutzererlebnisse verbessern
Infrastrukturressourcen effizienter nutzen

Wenn du Docker ernsthaft nutzt, solltest du spätestens jetzt mit deinem Monitoring-Stack loslegen. Starte klein mit Prometheus und Grafana – und erweitere nach und nach mit Logs, Tracing und Alerting.

🙌 Weiterführende Links

Links

Github

Docker mit Prometheus und Grafana