So überwachen Sie Kubernetes mit Grafana und Prometheus

Kubernetes-Überwachung mit Grafana & Prometheus: Schritt-für-Schritt-Anleitung

Kubernetes-Überwachung mit Grafana & Prometheus: Schritt-für-Schritt-Anleitung

Kubernetes hat sich zur grundlegenden Schicht für moderne Anwendungsbereitstellungen entwickelt, doch seine dynamische, verteilte Natur macht eine umfassende Beobachtbarkeit zu einer unverzichtbaren Voraussetzung für den Betriebserfolg. Sie müssen den Zustand Ihrer Nodes, die Leistung Ihrer Pods und den Status Ihres Clusters verstehen, um Zuverlässigkeit zu gewährleisten und kostspielige Ausfallzeiten zu vermeiden. Diese Anleitung bietet einen definitiven, schrittweisen Weg zur Beherrschung der Überwachung von Kubernetes mit Grafana und Prometheus und verwandelt rohe Metriken in umsetzbare Erkenntnisse, mit denen Sie Ihre Infrastruktur proaktiv verwalten können.

Was Sie lernen werden

Am Ende dieser Anleitung verstehen Sie, wie Sie einen vollständigen, produktionsreifen Monitoring-Stack auf Ihrem Kubernetes-Cluster mit dem branchenüblichen kube-prometheus-stack bereitstellen. Sie können Grafana mit Prometheus verbinden, vorgefertigte Dashboards für sofortige Einblicke importieren und mit einem klaren Plan für die Anpassung von Alarmen und Visualisierungen an Ihre spezifischen Anforderungen gehen. Die wichtigste Erkenntnis ist, dass das kube-prometheus-stack Helm-Chart die schnellste und zuverlässigste Methode ist, um ein Full-Stack-Kubernetes-Monitoring zu erreichen.

Der branchenübliche Monitoring-Stack für Kubernetes

Die Kombination aus Prometheus und Grafana ist der De-facto-Standard für Kubernetes-Überwachung. Laut Branchendaten nutzen schätzungsweise 75 % der Organisationen, die Kubernetes einsetzen, Prometheus und Grafana für ihre Beobachtbarkeitsanforderungen. Dies ist kein bloßer Trend, sondern ein Zeugnis für die Leistungsfähigkeit und Flexibilität dieses Open-Source-Toolkits.

• Prometheus ist ein von der Cloud Native Computing Foundation (CNCF) abgeschlossenes Projekt, das auf Zuverlässigkeit und Skalierbarkeit ausgelegt ist. Es funktioniert, indem es Metriken von verschiedenen Zielen (wie Ihren Anwendungs-Pods oder Kubernetes-Nodes) in festgelegten Intervallen abruft und in einer Zeitreihendatenbank speichert. Sie können diese Daten dann mit PromQL (Prometheus Query Language) abfragen, einer leistungsstarken und flexiblen Sprache zum Aggregieren und Analysieren von Metriken.
• Grafana ist die Visualisierungsschicht. Es integriert sich nahtlos in Prometheus und verwandelt die rohen, abgerufenen Daten in schöne, Echtzeit-Dashboards und Diagramme. Diese visuelle Darstellung macht es erheblich einfacher, Trends zu erkennen, Anomalien zu entdecken und Leistungsprobleme auf einen Blick zu beheben. Grafana kann auch als einheitliche Benutzeroberfläche für andere Datenquellen dienen, aber für Kubernetes ist Prometheus sein wichtigster Partner.

Voraussetzungen für Ihre Einrichtung

Bevor Sie beginnen, stellen Sie sicher, dass Sie die folgenden Tools installiert und konfiguriert haben. Diese Anleitung setzt einen funktionierenden Kubernetes-Cluster voraus, sei es eine lokale Entwicklungsumgebung wie Minikube oder ein Produktionscluster in der Cloud.

• Ein laufender Kubernetes-Cluster: Sie benötigen einen Cluster, um den Monitoring-Stack bereitzustellen. Für lokale Tests eignen sich Minikube oder Kind hervorragend.
• Helm: Der Kubernetes-Paketmanager ist für die Bereitstellung des kube-prometheus-stack unerlässlich. Stellen Sie sicher, dass Helm v3.2+ auf Ihrem lokalen Rechner installiert ist.
• kubectl: Das Kubernetes-Befehlszeilentool muss für die Kommunikation mit Ihrem Cluster konfiguriert sein.

Schritt-für-Schritt-Bereitstellung: Verwendung des kube-prometheus-stack

Die effizienteste und empfohlene Methode zur Bereitstellung von Prometheus und Grafana für das Kubernetes-Monitoring ist die Verwendung des kube-prometheus-stack Helm-Charts. Dieses Chart wird von der Prometheus-Community gepflegt und bündelt alle notwendigen Komponenten in einem einzigen, einfach zu verwaltenden Paket. Es enthält:

• Prometheus Operator: Verwaltet die Prometheus- und Alertmanager-Instanzen.
• Prometheus: Der zentrale Metrik-Server.
• Alertmanager: Behandelt von Prometheus gesendete Alarme.
• Grafana: Die Visualisierungsplattform.
• Node Exporter: Sammelt Node-Level-Metriken (CPU, Arbeitsspeicher, Festplatte) von Ihren Kubernetes-Nodes.
• kube-state-metrics: Generiert Metriken über den Zustand von Kubernetes-Objekten wie Pods, Bereitstellungen und Diensten.

1. Hinzufügen des Prometheus-Community-Helm-Repositorys

Fügen Sie zunächst das offizielle Helm-Repository hinzu und aktualisieren Sie es, um sicherzustellen, dass Sie die neuesten Chart-Versionen erhalten.

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

2. Installieren des Stacks

Sie können den Stack mit einem einzigen Helm-Befehl installieren und ihn mit verschiedenen Parametern anpassen. Dieses Beispiel erstellt einen monitoring-Namespace und aktiviert persistenten Speicher für Prometheus- und Grafana-Daten.

helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace \
  --set grafana.service.type=NodePort \
  --set grafana.service.nodePort=30094 \
  --set grafana.adminPassword=admin \
  --set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.accessModes=["ReadWriteOnce"] \
  --set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.resources.requests.storage=50Gi \
  --set prometheus.prometheusSpec.retention=30d

• grafana.adminPassword=admin: Legt das Admin-Passwort für Grafana fest. Ändern Sie dies in der Produktion.
• --set grafana.service.type=NodePort: Macht Grafana über einen NodePort außerhalb des Clusters zugänglich, um einen einfachen Zugriff zu ermöglichen.
• prometheus.prometheusSpec.retention=30d: Legt die Aufbewahrungsdauer der Prometheus-Daten auf 30 Tage fest, was für die langfristige Trendanalyse unerlässlich ist.

3. Überprüfen der Installation

Überprüfen Sie, ob alle Pods im monitoring-Namespace ausgeführt werden.

kubectl get pods -n monitoring

Die Ausgabe sollte mehrere Pods mit dem Status Running anzeigen, darunter solche für Grafana, Prometheus, Alertmanager, node-exporter und kube-state-metrics.

Verbinden von Grafana mit Ihrer Prometheus-Datenquelle

Das kube-prometheus-stack Helm-Chart konfiguriert Prometheus oft automatisch als Datenquelle in Grafana. Es ist jedoch am besten, die Verbindung zu überprüfen.

Zugriff auf die Grafana-Oberfläche

Um auf die Grafana-Weboberfläche zuzugreifen, können Sie Port-Forwarding für lokale Tests verwenden oder den Dienst für die Produktion mit einem LoadBalancer oder Ingress freigeben.

Option A: Port-Forwarding (Für schnellen lokalen Zugriff)

Dies ist die einfachste Möglichkeit, vorübergehend auf Ihr Dashboard zuzugreifen.

kubectl port-forward -n monitoring svc/prometheus-grafana 3000:80

Öffnen Sie nun Ihren Browser und gehen Sie zu http://localhost:3000.

⚠️ Wichtig: Port-Forwarding ist nur für lokale Tests und Entwicklung geeignet. Für eine dauerhafte Produktionseinrichtung sollten Sie Grafana über einen Dienst vom Typ LoadBalancer oder einen Ingress-Controller freigeben.

Option B: LoadBalancer (Empfohlen für Cloud-Umgebungen)

Wenn Sie bei einem Cloud-Anbieter wie UpCloud, AWS oder GCP laufen, können Sie den Grafana-Dienst einfach patchen, um einen LoadBalancer zu verwenden.

kubectl patch svc prometheus-grafana -n monitoring -p '{"spec": {"type": "LoadBalancer"}}'

Rufen Sie dann die externe IP-Adresse ab:

kubectl get svc -n monitoring prometheus-grafana

Greifen Sie auf Grafana unter http://<EXTERNE-IP>:80 zu.

Anmelden

Verwenden Sie die Standard-Anmeldeinformationen:

• Benutzername: admin
• Passwort: Das Passwort, das Sie während der Installation festgelegt haben (z. B. admin oder prom-operator).

Navigieren Sie nach der Anmeldung zu Configuration > Data Sources, um zu bestätigen, dass eine Prometheus-Datenquelle vorhanden ist und funktioniert. Klicken Sie darauf und verwenden Sie die Schaltfläche Test, um die Konnektivität zu überprüfen.

Erstellen von Dashboards: Von vorgefertigt bis benutzerdefiniert

Mit Grafana, das mit Prometheus verbunden ist, können Sie mit der Visualisierung Ihrer Kubernetes-Metriken beginnen. Der schnellste Weg, wertvolle Erkenntnisse zu gewinnen, ist der Import vorgefertigter Dashboards aus der Grafana-Community.

Importieren vorgefertigter Dashboards

Grafana bietet eine umfangreiche Bibliothek von Community-Dashboards, die Sie mit ihren eindeutigen IDs importieren können.

1. Bewegen Sie den Mauszeiger über das +-Symbol in der Seitenleiste und wählen Sie Import.
2. Geben Sie eine Dashboard-ID in das Feld "Find and import dashboards" ein. Zwei sehr empfehlenswerte Dashboards sind:
   • 1860: Node Exporter Full – bietet detaillierte Metriken zu den Nodes Ihres Clusters, einschließlich CPU, Arbeitsspeicher, Festplatte und Netzwerk.
   • 8588: Kubernetes Deployment Statefulset Daemonset – bietet eine Ansicht Ihrer Kubernetes-Workloads.
3. Klicken Sie auf Load, wählen Sie dann Ihre Prometheus-Datenquelle aus und klicken Sie auf Import.

Diese Dashboards geben Ihnen sofort einen umfassenden Überblick über die Gesundheit Ihres Clusters, ohne dass Sie PromQL-Abfragen schreiben müssen.

Erstellen benutzerdefinierter Dashboards mit PromQL

Während vorgefertigte Dashboards ein guter Ausgangspunkt sind, müssen Sie oft benutzerdefinierte Ansichten erstellen, die auf Ihre spezifischen Anwendungen zugeschnitten sind. Hier kommt PromQL ins Spiel.

Um ein neues Dashboard zu erstellen, klicken Sie auf das +-Symbol und wählen Sie New Dashboard. Klicken Sie dann auf Add visualization und wählen Sie Ihre Prometheus-Datenquelle aus.

Hier sind einige wichtige PromQL-Abfragen für das Kubernetes-Monitoring:

• CPU-Auslastung pro Pod:

  sum(rate(container_cpu_usage_seconds_total{namespace!="kube-system", pod!=""}[5m])) by (pod)

• Speichernutzung pro Pod:

  sum(container_memory_working_set_bytes{namespace!="kube-system", pod!=""}) by (pod) / 1024 / 1024 / 1024

• Pod-Status nach Phase:

  sum(kube_pod_status_phase) by (phase)

  Diese Abfrage eignet sich perfekt für ein Stat-Panel, mit dem Sie auf einen Blick sehen können, ob alle Ihre Pods ausgeführt werden.

Konfigurieren von Alarmen und Benachrichtigungen

Überwachung ist nur die halbe Miete; Sie müssen auch benachrichtigt werden, wenn etwas schief geht. Dies ist die Aufgabe von Alertmanager, der im kube-prometheus-stack enthalten ist.

Einrichten von Alarmregeln

Sie können Alertmanager so konfigurieren, dass Benachrichtigungen an verschiedene Kanäle wie Slack, E-Mail oder PagerDuty gesendet werden. Eine gängige und effektive Einrichtung besteht darin, Alarme an einen dedizierten Slack-Kanal zu senden.

1. Erstellen Sie zunächst einen eingehenden Webhook in Ihrem Slack-Workspace.
2. Dann müssen Sie die Alertmanager-Konfiguration ändern. Sie können dies tun, indem Sie während eines Helm-Upgrades eine benutzerdefinierte values.yaml-Datei bereitstellen oder das Secret direkt bearbeiten.
3. Aktualisieren Sie den Abschnitt alertmanager in Ihrer values.yaml-Datei mit einer Route und einem Empfänger, der auf Ihre Slack-Webhook-URL verweist:

alertmanager:
  config:
    route:
      receiver: 'slack-notifications'
      group_wait: 30s
      group_interval: 5m
      repeat_interval: 1h
    receivers:
      - name: 'slack-notifications'
        slack_configs:
          - api_url: 'https://hooks.slack.com/services/your/webhook/url'
            send_resolved: true
            title: '{{ .CommonLabels.alertname }} ({{ .Status | toUpper }})'
            text: >-
              {{ range .Alerts }}
              *Alert:* {{ .Labels.alertname }}
              *Severity:* {{ if .Labels.severity }}{{ .Labels.severity }}{{ else }}n/a{{ end }}
              *Summary:* {{ if .Annotations.summary }}{{ .Annotations.summary }}{{ else }}n/a{{ end }}
              *Description:* {{ if .Annotations.description }}{{ .Annotations.description }}{{ else }}n/a{{ end }}
              {{- end }}

Nachdem Sie diese Änderungen mit einem helm upgrade angewendet haben, werden Alarme an Ihren Slack-Kanal gesendet.

Best Practices für das Produktions-Monitoring

Um sicherzustellen, dass Ihr Monitoring-Stack in einer Produktionsumgebung robust und skalierbar ist, befolgen Sie diese wichtigen Best Practices.

• Persistenten Speicher konfigurieren: Aktivieren Sie bei der Bereitstellung in der Produktion immer persistenten Speicher für sowohl Prometheus als auch Grafana. Dadurch wird sichergestellt, dass Ihre Metrikdaten und Dashboard-Konfigurationen Pod-Neustarts und Cluster-Upgrades überleben. Im kube-prometheus-stack wird dies durch die Einstellungen persistence und storageSpec im Helm-Chart gesteuert.
• Abfrageleistung optimieren: Abfragen mit hoher Kardinalität können Ihre Dashboards und Prometheus selbst verlangsamen. Um die Leistung zu erhalten, aggregieren Sie Ihre PromQL-Abfragen immer an der Quelle. Anstatt beispielsweise container_cpu_usage_seconds_total abzufragen, aggregieren Sie es nach Namespace: sum by (namespace) (rate(container_cpu_usage_seconds_total[5m])). Dies reduziert die Datenmenge, die Grafana verarbeiten muss.
• Angemessene Aufbewahrungsfristen festlegen: Die Standard-Aufbewahrungsfrist für Prometheus beträgt 15 Tage. Passen Sie diese an Ihre Bedürfnisse an. Eine längere Aufbewahrungsfrist (z. B. 30-60 Tage) ist nützlich für die langfristige Trendanalyse, erfordert jedoch mehr Speicherplatz.
• Konfiguration als Code verwalten: Wenn sich Ihre Monitoring-Anforderungen weiterentwickeln, werden Sie wahrscheinlich Dashboards und Alarmregeln anpassen. Exportieren Sie Ihre Dashboards als JSON und speichern Sie sie zusammen mit Ihren Alarmregeln in der Versionskontrolle (z. B. Git). Diese als GitOps bekannte Praxis macht Ihre Monitoring-Einrichtung reproduzierbar und prüfbar.
• Scrape-Intervalle anpassen: Das Standard-Scrape-Intervall für Prometheus beträgt 30 Sekunden. Für kritische Metriken mit hoher Geschwindigkeit möchten Sie möglicherweise häufiger scrapen, aber seien Sie sich bewusst, dass dies die Last auf Prometheus und den API-Server Ihres Clusters erhöht. Sie können diese Intervalle in den Helm-Werten anpassen.

Häufig gestellte Fragen

1. Was ist der einfachste Weg, Kubernetes mit Grafana und Prometheus zu überwachen? Die einfachste und am meisten empfohlene Methode ist die Verwendung des kube-prometheus-stack Helm-Charts. Es bündelt Prometheus, Grafana, Alertmanager, node-exporter und kube-state-metrics in einem einzigen Paket, und Sie können es mit nur wenigen Befehlen bereitstellen.

2. Ist es notwendig, kube-state-metrics für das Kubernetes-Monitoring zu verwenden? Ja, kube-state-metrics ist eine kritische Komponente, die Metriken über den Zustand Ihrer Kubernetes-Objekte generiert, wie die Anzahl der bereiten Pods oder den Status einer Bereitstellung. Ohne sie hätten Sie keine Einblicke in die Gesundheit Ihrer übergeordneten Kubernetes-Ressourcen.

3. Wie kann ich meine Kubernetes-Dashboards schneller laden lassen? Langsame Dashboards werden oft durch ineffiziente PromQL-Abfragen verursacht. Eine wichtige Lösung ist die Aggregation Ihrer Abfragen, um die Kardinalität zu reduzieren. Anstatt beispielsweise Daten für jeden Pod anzuzeigen, fassen Sie sie auf Namespace-Ebene mit Abfragen wie sum by (namespace) (rate(...)) zusammen.

4. Was ist der beste Weg, um Alarme von meinem Kubernetes-Monitoring zu erhalten? Prometheus arbeitet mit Alertmanager zusammen, der Benachrichtigungen an verschiedene Kanäle senden kann. Eine beliebte und einfache Methode ist die Konfiguration von Alertmanager, um Alarme über einen eingehenden Webhook an einen Slack-Kanal zu senden. Dies liefert Echtzeit-, umsetzbare Benachrichtigungen.

5. Muss ich Node Exporter manuell auf jedem Node installieren? Nein. Wenn Sie das kube-prometheus-stack Helm-Chart bereitstellen, wird automatisch ein Node Exporter DaemonSet bereitgestellt. Dadurch wird sichergestellt, dass ein Node Exporter-Pod auf jedem Node in Ihrem Cluster läuft, sodass Prometheus Node-Level-Metriken wie CPU-, Arbeitsspeicher- und Festplattennutzung ohne manuelles Eingreifen sammeln kann.

Quellen

1. UpCloud Global. (2025). Monitoring on UpCloud with Prometheus: Part 3.
2. Ubuntu Documentation. (2026). How to use Prometheus with Canonical Kubernetes.
3. Sfeir Institute. (2026). Create Effective Grafana Dashboards for Kubernetes Monitoring.
4. Ory. (2025). Monitoring.
5. GitHub - AkramGalal. (2025). deploying-prometheus-grafana-K8s-using-helm.
6. Go Packages. (2025). kube-prometheus.
7. GitHub - dotdc. (2026). grafana-dashboards-kubernetes.
8. Scaleway. (2025). Kubernetes Kapsule cluster monitoring with Prometheus & Grafana.
9. Mirantis. (2025). How to Set Up Prometheus & Grafana in K8s with Alertmanager & Slack Alerts.
10. Microsoft Learn. (2025). Using ConfigMap to customize Prometheus metric collection in Azure Monitor.
11. GitHub - Rurutia1027. (2025). Hands-on-Lab.K8s-Monitoring.

— Editorial Team