TL;DR

• kube-prometheus-stack (Helm-Chart) installiert Prometheus, Grafana, Alertmanager und die Kubernetes-Exporters in einem Befehl.
• ServiceMonitors sind der Kubernetes-native Weg, um Prometheus auf deine Anwendungs-Metriken aufmerksam zu machen — kein manuelles Targets-Konfigurieren mehr.
• Loki ergänzt den Stack um zentrale Log-Sammlung mit Grafana-Integration — Metriken und Logs in einem Dashboard.
• Die vier goldenen Signale (Latency, Traffic, Errors, Saturation) bilden die Basis jedes sinnvollen Dashboards.

Kubernetes Observability Stack: Prometheus, Grafana und Loki in 2 Stunden

Ein Observability Stack ist die Grundlage jedes ernsthaften Kubernetes-Betriebs: Ohne Metriken, Logs und Alerts bist du blind. Dieser Guide zeigt den kompletten Aufbau mit kube-prometheus-stack + Loki — von der Helm-Installation bis zu eigenen ServiceMonitors und Alert-Regeln.

Die 4 goldenen Signale: Was du wirklich überwachen musst

Bevor du Tools installierst, kläre, was du überwachen willst. Die Praxis hat vier universelle Signale etabliert:

Schritt 1: kube-prometheus-stack installieren

Der Stack bündelt Prometheus, Grafana, Alertmanager, kube-state-metrics und node-exporter in einem Chart:

# Helm-Repo hinzufügen
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

# Installieren (Namespace: monitoring)
helm install kube-prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring --create-namespace \
  --set grafana.adminPassword="dein-sicheres-passwort"

# Status prüfen
kubectl -n monitoring get pods

Nach wenigen Minuten laufen alle Komponenten:

NAME                                                     READY   STATUS
alertmanager-kube-prometheus-alertmanager-0              2/2     Running
prometheus-kube-prometheus-prometheus-0                  2/2     Running
kube-prometheus-grafana-7f9c8b6d9d-xxxxx                 2/2     Running
kube-prometheus-kube-state-metrics-xxxxx                 1/1     Running
prometheus-node-exporter-xxxxx                           1/1     Running

Schritt 2: Grafana erreichbar machen

kubectl -n monitoring port-forward svc/kube-prometheus-grafana 8080:80
# Browser: http://localhost:8080 (admin / dein-passwort)

Der Stack bringt vorgefertigte Dashboards mit: Kubernetes-Cluster, Nodes, Pods, Kubelet, etc. — alles direkt einsatzbereit.

Schritt 3: Eigene Anwendung mit ServiceMonitor anbinden

Der Kubernetes-native Weg, Prometheus auf deine App-Metriken aufmerksam zu machen. Voraussetzung: Deine Anwendung exponiert Metriken im Prometheus-Format (z.B. über eine /metrics-Route).

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: my-app
  namespace: production
spec:
  selector:
    matchLabels:
      app: my-app
  endpoints:
    - port: metrics        # Port-Name im Service
      path: /metrics
      interval: 30s

apiVersion: v1
kind: Service
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  selector:
    app: my-app
  ports:
    - name: metrics
      port: 9090
      targetPort: 9090

kubectl apply -f service-monitor.yaml -f service.yaml

Prometheus entdeckt den ServiceMonitor automatisch (das Chart hat prometheus-operator integriert). Nach ~1 Minute erscheinen die Metriken unter http://localhost:9090 im Prometheus-UI.

Schritt 4: Alerts definieren

Alertmanager benachrichtigt dich per Mail, Slack oder Webhook. Eigene Regeln:

apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: app-alerts
  namespace: monitoring
spec:
  groups:
    - name: my-app.rules
      rules:
        - alert: HighErrorRate
          expr: |
            sum(rate(http_requests_total{code=~"5.."}[5m]))
            / sum(rate(http_requests_total[5m])) > 0.05
          for: 10m
          labels:
            severity: warning
          annotations:
            summary: "Hohe Fehlerrate ({{ $value | humanizePercentage }})"
        - alert: PodRestartLoop
          expr: increase(kube_pod_container_status_restarts_total[15m]) > 5
          for: 5m
          labels:
            severity: critical
          annotations:
            summary: "Pod {{ $labels.pod }} startet im Loop"

Schritt 5: Loki für zentrale Logs

Loki sammelt Logs zentral und integriert sie direkt in Grafana:

helm repo add grafana https://grafana.github.io/helm-charts
helm upgrade --install loki grafana/loki-stack \
  --namespace monitoring \
  --set grafana.enabled=false \
  --set promtail.enabled=true

Danach in Grafana die Loki-Datenquelle hinzufügen: http://loki:3100. Logs aus allen Pods sind dann im Explore-Tab durchsuchbar:

{namespace="production"} |= "ERROR" |= "payment"

Best Practices für den Produktivbetrieb

1. Retention bewusst setzen: --set prometheus.prometheusSpec.retention=15d — mehr kostet Storage.
2. Ressourcen-Limits: Prometheus und Loki brauchen Limits, sonst fressen sie den Cluster.
3. Alerting-Kanäle definieren: Slack/Teams für Warnungen, E-Mail für kritische Alerts.
4. Dashboards versionieren: Grafana-Dashboards als JSON im Repo ablegen (Config-as-Code).
5. Backup der Konfiguration: PrometheusRules und Dashboards sind Code — in Git sichern.

Häufige Fehler und Lösungen

Fehler 1: ServiceMonitor wird nicht gefunden

Symptom: Metriken tauchen nicht auf. Lösung: kubectl get servicemonitor -n production und kubectl describe servicemonitor my-app prüfen. Label-Selector muss exakt zum Service passen. Oder: Prometheus-Scope prüfen — kubectl get prometheus -n monitoring -o yaml | grep serviceMonitorSelector.

Fehler 2: Grafana-Dashboards zeigen keine Daten

Symptom: Leere Panels. Lösung: Datenquelle prüfen (http://prometheus-operated:9090). Dann kubectl port-forward svc/prometheus-operated 9090:9090 und Metriken direkt testen.

Fehler 3: Loki braucht zu viel Speicher

Symptom: OOMKilled bei Loki. Lösung: --set loki.persistence.enabled=true und Limits setzen. Für kleine Cluster reicht der Single-Binary-Modus.

FAQ

Was ist der Unterschied zwischen Monitoring und Observability?

Monitoring zeigt vordefinierte Metriken (Ist die CPU hoch?). Observability erlaubt beliebige Fragen an Metriken, Logs und Traces (Warum ist die CPU hoch? Welcher Request hängt?). Ein guter Stack braucht beides.

Prometheus oder Grafana Cloud?

Für die meisten KMUs ist selbst-gehostet mit kube-prometheus-stack günstiger und DSGVO-einfacher (Daten bleiben im eigenen Cluster). Grafana Cloud lohnt sich ab großer Skalierung oder wenn du keine Infrastruktur betreiben willst.

Brauche ich wirklich Jaeger/Tracing?

Distributed Tracing (Jaeger, Tempo) lohnt sich erst ab Microservice-Architekturen mit mehreren Diensten. Starte mit Prometheus + Grafana + Loki — das deckt 80% der Fälle ab.

Ist der Stack DSGVO-konform?

Ja, wenn du: Logs auf personenbezogene Daten prüfst (ggf. Anonymisierung), Zugriff auf Grafana per SSO/RBAC beschränkst und die Retention begrenzt. Keine Daten verlassen deinen Cluster.

Nächste Schritte

Ein kompletter Observability Stack steht in 2 Stunden. Danach: Kubernetes Security Monitoring mit Falco, Kubernetes Chaos Engineering für Stabilitätstests und der Kubernetes Monitoring-Artikel zu Grafana für die Netzwerk-Perspektive.