TL;DR

Das kube-prometheus-stack Helm Chart installiert Prometheus, Grafana und Alertmanager in einem Schritt. Du bekommst vorkonfigurierte Dashboards, Recording Rules und Alerts für alle Kubernetes-Komponenten. Diese Anleitung erklärt Installation, die wichtigsten Values und typische Anpassungen.

kube-prometheus-stack: Monitoring für Kubernetes

Monitoring ist kein Nice-to-have — ohne Metriken fliegst du blind. Das kube-prometheus-stack Helm Chart (früher prometheus-operator) ist der De-facto-Standard für Kubernetes-Monitoring. Es bringt alles mit: Prometheus, Grafana, Alertmanager, node-exporter und kube-state-metrics.

Statt jede Komponente einzeln zu installieren, bekommst du ein abgestimmtes Setup mit über 30 vorkonfigurierten Grafana-Dashboards und sinnvollen Default-Alerts.

Was steckt im Chart?

Komponente	Funktion
Prometheus Operator	Verwaltet Prometheus-Instanzen als Custom Resources
Prometheus	Sammelt und speichert Metriken
Grafana	Visualisierung und Dashboards
Alertmanager	Alert-Routing und Benachrichtigungen
node-exporter	Host-Level-Metriken (CPU, RAM, Disk)
kube-state-metrics	Kubernetes-Objekt-Metriken (Pods, Deployments, etc.)

Voraussetzungen

Kubernetes ab v1.25
Helm v3
mindestens 2 GB freier RAM im Cluster

Los geht's — prüfe dein Setup:

kubectl get nodes -o wide
helm version --short

Teil 1: Installation

Helm Repo und Namespace

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

# Namespace erstellen
kubectl create namespace monitoring

Basis-Installation

Für den Einstieg reicht eine Installation mit minimalen Anpassungen:

helm install kube-prometheus-stack prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --set grafana.adminPassword=dein-sicheres-pw \
  --set prometheus.prometheusSpec.retention=14d \
  --set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.resources.requests.storage=20Gi

Das dauert 1-2 Minuten. Prüfe den Status:

kubectl get pods -n monitoring -w

Alle Pods sollten nach kurzer Zeit Running oder Completed (für Jobs) zeigen.

Zugriff auf Grafana

# Port-Forward starten
kubectl port-forward svc/kube-prometheus-stack-grafana -n monitoring 3000:80

# Browser öffnen: http://localhost:3000
# User: admin
# Password: dein-sicheres-pw (wie oben gesetzt)

Du findest unter "Dashboards" > "Browse" bereits über 30 vorkonfigurierte Dashboards für Nodes, Pods, Namespaces, API-Server und mehr.

Teil 2: Die wichtigsten Values erklärt

Das Chart hat hunderte Values. Hier die, die du wirklich kennen musst.

Values-Datei anlegen

Statt alles per --set zu übergeben, arbeite mit einer Values-Datei:

# values-monitoring.yaml
prometheus:
  prometheusSpec:
    # Wie lange Metriken gespeichert werden
    retention: 14d
    # Maximale Speichergröße (überschreibt retention)
    retentionSize: "18GB"
    # Persistent Storage
    storageSpec:
      volumeClaimTemplate:
        spec:
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 20Gi
    # Resource Limits
    resources:
      requests:
        cpu: 500m
        memory: 1Gi
      limits:
        memory: 2Gi
    # Welche ServiceMonitors Prometheus findet
    serviceMonitorSelectorNilUsesHelmValues: false
    podMonitorSelectorNilUsesHelmValues: false

grafana:
  adminPassword: "dein-sicheres-pw"
  persistence:
    enabled: true
    size: 5Gi
  # Zusätzliche Dashboards per ConfigMap
  sidecar:
    dashboards:
      enabled: true
      searchNamespace: ALL

alertmanager:
  alertmanagerSpec:
    storage:
      volumeClaimTemplate:
        spec:
          resources:
            requests:
              storage: 5Gi

Die zwei Zeilen serviceMonitorSelectorNilUsesHelmValues: false und podMonitorSelectorNilUsesHelmValues: false sind entscheidend — ohne sie findet Prometheus nur ServiceMonitors mit dem Label des Helm-Releases, nicht die aus anderen Namespaces.

Installation mit Values-Datei

helm upgrade --install kube-prometheus-stack \
  prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  -f values-monitoring.yaml

Teil 3: Eigene ServiceMonitors erstellen

Ein ServiceMonitor sagt Prometheus: "Scrape diese Endpoints." Wenn du eine eigene App mit /metrics-Endpoint hast:

# servicemonitor-myapp.yaml
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: myapp-metrics
  namespace: monitoring
  labels:
    release: kube-prometheus-stack
spec:
  namespaceSelector:
    matchNames:
      - production
  selector:
    matchLabels:
      app: myapp
  endpoints:
    - port: metrics
      interval: 30s
      path: /metrics

kubectl apply -f servicemonitor-myapp.yaml

# Prüfen, ob Prometheus den Target aufnimmt
kubectl port-forward svc/kube-prometheus-stack-prometheus -n monitoring 9090:9090
# Browser: http://localhost:9090/targets

Teil 4: Alerting konfigurieren

Der Alertmanager ist installiert, aber ohne Receiver passiert bei Alerts nichts. Hier eine Konfiguration für Slack und E-Mail:

# In deiner values-monitoring.yaml ergänzen:
alertmanager:
  config:
    global:
      resolve_timeout: 5m
    route:
      group_by: ['alertname', 'namespace']
      group_wait: 30s
      group_interval: 5m
      repeat_interval: 4h
      receiver: 'slack-notifications'
      routes:
        - match:
            severity: critical
          receiver: 'slack-critical'
    receivers:
      - name: 'slack-notifications'
        slack_configs:
          - api_url: 'https://hooks.slack.com/services/DEIN/WEBHOOK/URL'
            channel: '#k8s-alerts'
            title: '{{ .GroupLabels.alertname }}'
            text: >-
              {{ range .Alerts }}
              *Alert:* {{ .Annotations.summary }}
              *Namespace:* {{ .Labels.namespace }}
              *Severity:* {{ .Labels.severity }}
              {{ end }}
      - name: 'slack-critical'
        slack_configs:
          - api_url: 'https://hooks.slack.com/services/DEIN/WEBHOOK/URL'
            channel: '#k8s-critical'
            title: 'CRITICAL: {{ .GroupLabels.alertname }}'

Anwenden:

helm upgrade kube-prometheus-stack \
  prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  -f values-monitoring.yaml

Eigene PrometheusRules

Neben den mitgelieferten Alerts kannst du eigene Regeln definieren:

# alert-rules-custom.yaml
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: custom-alerts
  namespace: monitoring
  labels:
    release: kube-prometheus-stack
spec:
  groups:
    - name: custom.rules
      rules:
        - alert: PodRestartingTooOften
          expr: increase(kube_pod_container_status_restarts_total[1h]) > 5
          for: 10m
          labels:
            severity: warning
          annotations:
            summary: "Pod {{ $labels.namespace }}/{{ $labels.pod }} restartet zu oft"
            description: "Mehr als 5 Restarts in der letzten Stunde"

kubectl apply -f alert-rules-custom.yaml

Teil 5: Nützliche PromQL-Queries

Wenn du dich in Grafana oder der Prometheus-UI bewegst, helfen diese Queries:

CPU-Auslastung pro Namespace:

sum(rate(container_cpu_usage_seconds_total{namespace!=""}[5m])) by (namespace)

Memory-Verbrauch pro Pod (Top 10):

topk(10, sum(container_memory_working_set_bytes{container!=""}) by (pod, namespace))

Verfügbarer Disk-Space auf Nodes:

node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"} * 100

Upgrade und Wartung

Beim Upgrade des Charts bleiben deine Daten erhalten, solange du Persistent Storage nutzt:

# Verfügbare Versionen prüfen
helm search repo prometheus-community/kube-prometheus-stack --versions | head -10

# Upgrade durchführen
helm upgrade kube-prometheus-stack \
  prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  -f values-monitoring.yaml

# CRDs manuell updaten (Helm updated keine CRDs automatisch)
kubectl apply --server-side -f \
  https://raw.githubusercontent.com/prometheus-community/helm-charts/main/charts/kube-prometheus-stack/charts/crds/crds/crd-servicemonitors.yaml

FAQ

Wie viel Speicher braucht Prometheus?

Als Faustregel: Pro 1.000 aktive Time-Series etwa 1-2 MB RAM. Ein typischer Cluster mit 10 Nodes und 100 Pods erzeugt circa 50.000 Time-Series — rechne mit 1-2 GB RAM für Prometheus.

Kann ich Prometheus-Daten langfristig speichern?

Für Langzeit-Storage (Monate/Jahre) nutze Thanos oder Cortex als Remote-Write-Ziel. Das kube-prometheus-stack Chart hat native Thanos-Integration — setze prometheus.prometheusSpec.thanos in deinen Values.

Warum sehe ich keine Metriken von meiner App?

Drei häufige Ursachen: (1) Dein Service hat kein Label, das zum ServiceMonitor-Selector passt. (2) Die serviceMonitorSelectorNilUsesHelmValues steht auf true und dein ServiceMonitor hat nicht das Release-Label. (3) Dein Metrics-Endpoint antwortet nicht auf dem konfigurierten Port/Pfad.

Wie deaktiviere ich Default-Alerts, die ich nicht brauche?

Setze einzelne Regel-Gruppen in den Values auf false:

defaultRules:
  rules:
    etcd: false
    kubeScheduler: false

Grafana zeigt "No Data" in Dashboards — was tun?

Prüfe den Datasource in Grafana unter Configuration > Data Sources. Die URL muss http://kube-prometheus-stack-prometheus.monitoring:9090 lauten. Falls geändert, korrigiere sie dort.

Nächster Schritt: Verbinde dein Monitoring mit Alerting in Slack oder Microsoft Teams. Oder richte Sealed Secrets ein, um Webhook-URLs und Passwörter sicher in Git zu speichern.

kube-prometheus-stack: Helm Install und Setup Anleitung