Monitoring Docker-Umgebungen mit Prometheus & Grafana

Docker hat die Art und Weise revolutioniert, wie wir Anwendungen entwickeln, testen und deployen. Containerisierte Anwendungen sind leichtgewichtig, portabel und skalierbar – doch diese Flexibilität bringt auch neue Herausforderungen mit sich, besonders wenn es um das Monitoring und Debugging geht.

Hier kommen drei zentrale Konzepte der Beobachtbarkeit (Observability) ins Spiel:

Logging – Was ist passiert?
Tracing – Was ist wann und wie passiert?
Metriken – Wie gut funktioniert das System?

In diesem Tutorial schauen wir uns an, wie du diese Konzepte in einer Docker-Umgebung implementierst – inklusive einer praktischen Einführung in Prometheus und Grafana zur Visualisierung und Analyse.

1. Logging in Docker

Was ist Logging?

Logs sind textbasierte Aufzeichnungen von Ereignissen in deinem System. Sie helfen dir dabei, Fehlerquellen zu finden, das Verhalten von Anwendungen nachzuvollziehen und Sicherheitsvorfälle zu analysieren.

Standard Docker Logging

Docker-Container schreiben per Standard ihre Logs auf stdout und stderr. Diese kannst du einfach über den Befehl einsehen:

docker logs <container-name>

Aber: Diese Methode ist nicht skalierbar. In produktiven Umgebungen solltest du ein zentrales Logging-System wie ELK Stack (Elasticsearch, Logstash, Kibana), Fluentd, oder Loki (von Grafana Labs) einsetzen.

Beispiel: Fluent Bit + Elasticsearch + Kibana

# docker-compose.yml (Ausschnitt)
fluent-bit:
  image: fluent/fluent-bit:latest
  volumes:
    - ./fluent-bit.conf:/fluent-bit/etc/fluent-bit.conf
  depends_on:
    - elasticsearch
    - kibana

Mit einem Tool wie Fluent Bit kannst du Logs aus verschiedenen Containern sammeln und zentral abspeichern.

2. Tracing: Der Weg durch den Stack

Was ist Tracing?

Tracing bedeutet, einzelne Anfragen durch mehrere Services hinweg zu verfolgen – besonders in Microservice-Architekturen essenziell. Es beantwortet Fragen wie:

Warum dauert ein API-Call 2 Sekunden?
Welcher Service hat eine Exception ausgelöst?
Welche Abhängigkeiten beeinflussen die Performance?

OpenTelemetry und Jaeger

OpenTelemetry ist der Industriestandard für Tracing. Zusammen mit Jaeger oder Zipkin kannst du Traces visualisieren.

Beispiel: OpenTelemetry Collector mit Jaeger

jaeger:
  image: jaegertracing/all-in-one:latest
  ports:
    - "16686:16686"
    - "14268:14268"

In deinem Anwendungscode fügst du ein OpenTelemetry SDK ein, das Traces automatisch generiert und an Jaeger sendet.

3. Metriken sammeln mit Prometheus

Was sind Metriken?

Metriken sind numerische Daten über den Zustand deines Systems: CPU-Auslastung, Anfragen pro Sekunde, Fehlerquoten, etc. Sie sind ideal für Alerting, Visualisierung und Kapazitätsplanung.

Warum Prometheus?

Prometheus ist ein Open-Source Monitoring-System, das besonders gut mit Kubernetes und Docker harmoniert. Es sammelt regelmäßig Metriken über HTTP von sogenannten „Targets“ (z. B. Container, Exporter).

Prometheus + Node Exporter Setup

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

node-exporter:
  image: prom/node-exporter
  ports:
    - "9100:9100"

Prometheus Konfiguration

# prometheus.yml
scrape_configs:
  - job_name: 'node'
    static_configs:
      - targets: ['node-exporter:9100']

Jetzt kannst du deine Docker-Hosts, Services oder auch eigene Exporter überwachen.

4. Visualisierung mit Grafana

Was ist Grafana?

Grafana ist ein leistungsstarkes Dashboard-Tool, das Daten aus Prometheus, Loki, Elasticsearch und vielen weiteren Quellen visualisieren kann.

Beispiel-Dashboard: CPU-Auslastung

Data Source: Prometheus
Query: rate(node_cpu_seconds_total{mode="user"}[1m])
Diagrammtyp: Time series

Du kannst Alarme setzen, Panels verschachteln und sogar Logs und Metriken kombinieren.

5. Logging + Tracing + Metriken: Alles vereint

Die wahre Stärke liegt in der Kombination dieser drei Disziplinen. Beispiel:

Ein Service-Fehler wird im Log erkannt.
Ein Trace zeigt, welcher Microservice betroffen ist.
Metriken zeigen, dass der Speicherverbrauch ansteigt.

Mit Tools wie Grafana Tempo (für Tracing), Grafana Loki (für Logging) und Prometheus (für Metriken) hast du ein konsistentes Observability-Ökosystem.

Fazit

Die drei Säulen der Observability – Logging, Tracing und Metriken – sind unerlässlich für den Betrieb moderner, containerisierter Anwendungen. In Docker-Umgebungen lassen sie sich elegant und skalierbar mit Open-Source-Tools wie Prometheus, Grafana, OpenTelemetry und Jaeger integrieren.

Eine durchdachte Beobachtbarkeits-Strategie hilft nicht nur beim Debugging – sie ist auch ein Baustein für hohe Verfügbarkeit, Performance und User-Zufriedenheit.

Nächste Schritte

Richte ein lokales Stack mit Docker Compose ein (Prometheus + Grafana + Loki).
Integriere OpenTelemetry in deine Applikation.
Erstelle ein Alerting-Konzept auf Basis deiner Metriken.
Baue Dashboards für Dev, QA und Produktion.

Links

Linux Monitoring