Über unsMediaKontaktImpressum
Antje Landschulz 04. August 2020

Monitoring mit Prometheus und Grafana bei Systemen unter Last

Für die frühzeitige Erkennung und Behebung systemkritischer Probleme, insbesondere bei Systemen unter Last, ist ein gutes Monitoring unerlässlich. Das Open-Source-Monitoring-System Prometheus und das Open-Source-Visualisierungstool Grafana lassen sich hierfür sehr gut miteinander kombinieren.

Prometheus ist als Zeitreihendatenbank ideal geeignet für das Speichern von für das Monitoring relevanten Metrikdaten, wie CPU-Auslastung, JVM Heap Size und Anzahl an Fehlermeldungen. Die gespeicherten Daten lassen sich mit der von Prometheus zur Verfügung gestellten Abfragesprache PromQL auslesen. Dies ermöglicht dem Team, frühzeitig zu erkennen, wann ein für das System kritischer Schwellenwert überschritten worden ist, und proaktiv zu handeln.

Besonders komfortabel und zeitsparend ist für Entwickler und Administratoren die Visualisierung der relevanten Daten in Form von Dashboards. Hierzu bietet sich Grafana mit seiner Schnittstelle zu Prometheus an. Um alle Interessierten über das Überschreiten eines definierten Schwellenwertes zu informieren, können mit Hilfe von Grafana Alert Notifications beispielsweise an eine E-Mail-Adresse oder einen Chatraum versendet werden.

Dieser Artikel führt in das Monitoring mit Prometheus und Grafana ein und zeigt, wie Sie ein Monitoring und Alerting System mit Prometheus und Grafana für Ihre Einsatzszenarien realisieren können.

Prometheus

Prometheus ist ein Open-Source-Monitoring- und Alerting-System, das 2012 von SoundCloud entwickelt wurde. Seit 2016 ist Prometheus Teil der Cloud Native Computing Foundation und ist damit nach Kubernetes das zweite Projekt, das der Cloud Native Computing Foundation beigetreten ist. Prometheus ist größtenteils in Go geschrieben. Die Go-Komponenten werden als statische Binärdateien deployt [1].

Während gängige Monitoringlösungen, wie z. B. Nagios, aus einem Monolithen bestehen, zeichnet sich Prometheus durch einen modularen Aufbau aus. Darüber hinaus unterscheidet sich Prometheus von anderen Monitoringlösungen in der Art und Weise, wie Metrikdaten abgespeichert werden. Die meisten der gängigen Monitoringlösungen speichern Metrikdaten in konventionellen relationalen Datenbanken ab. Dies führt jedoch beim Auslesen von Metrikdaten über einen bestimmten Zeitraum zu Performance-Problemen. Prometheus geht einen anderen Weg und speichert die Metrikdaten in einer Zeitreihendatenbank ab. Das Wurzelelement einer solchen Zeitreihendatenbank ist ein Zeitstrahl. Sämtliche Informationen sind mit einem spezifischen Punkt auf dem Zeitstrahl verknüpft. Somit entsprechen die Abfragen dem nativen Datenschema der Datenbank. Für das Auslesen der Metrikdaten aus der Zeitreihendatenbank haben die Entwickler von Prometheus sogar eine eigene Abfragesprache namens PromQL entwickelt. PromQL stellt die zum Abfragen einer Zeitreihendatenbank benötigten Funktionen zu Verfügung. Die Abfragen erfolgen hierbei über eine RESTful API. Eine weitere Besonderheit von Prometheus ist das Pullen von Metrikdaten. Dies bedeutet, dass der Prometheus-Server eine Liste sämtlicher Monitoringziele vorhält, die er reihum abfragt [2].

Prometheus-Architektur

Abb. 1 zeigt die Prometheus-Architektur. Hauptkomponente ist der Prometheus-Server mit der Zeitreihendatenbank (TSDB). Der Prometheus-Server ist ausschließlich für das Sammeln, Speichern und Interpretieren von Metrikdaten zuständig. Die Metrikdaten werden klassisch auf einer lokalen Festplatte oder SSD gespeichert.

Die Metriken werden per Pull-Prinzip eingesammelt. Für die Anwendungsfälle, in denen ein Pullen von Metrikdaten nicht möglich ist, wie beispielsweise bei Anwendungen im IoT-Bereich, stellt Prometheus zudem ein Pushgateway zur Verfügung. In diesen Fällen senden die zu monitorenden Applikationen ihre Metriken an das Pushgateway, und der Prometheus-Server greift sich dann von dem Pushgateway die Metriken ab.

Die gesammelten Daten können mit Hilfe der prometheus-eigenen Abfragesprache PromQL ausgelesen und in der Prometheus Web UI, in Grafana oder in einem anderen API Client visualisiert werden. Für das Alerting stellt Prometheus den Alert-Manager zur Verfügung. Auf das Alerting mit Prometheus werde ich in diesem Artikel nicht weiter eingehen, da ich stattdessen das Alerting mit Grafana vorstellen werde.

Prometheus Datenmodell

Prometheus speichert die Daten als Zeitreihen. Die eindeutige Identifizierung einer Zeitreihe erfolgt über Metrikname und Label. Der Metrikname beschreibt ein allgemeines Merkmal eines Systems, wie z. B. die Gesamtzahl der empfangenen HTTP-Requests. Labels werden verwendet, um zwischen den verschiedenen Eigenschaften einer Metrik zu unterscheiden. Unter Verwendung eines Labels kann z. B. nach allen HTTP-Requests gefiltert werden, die beim Aufruf die Methode POST verwendet haben.

Metriken

Die Prometheus-Client-Bibliotheken stellen vier Arten von Metriken zu Verfügung.

  • Counter: Ein Counter ist ein einfacher Zähler, der nur inkrementiert werden kann. Bei einem Neustart des Systems kann der Counter auf 0 zurückgesetzt werden. Beispiele für einen Counter sind die Anzahl an Aufrufen einer REST-URL und die Anzahl an Fehlermeldungen.

  • Gauge: Gauge ist eine Zahl, die sich beliebig nach oben und unten ändern kann. Beispiele für Gauge sind die CPU-Auslastung und die JVM Heap Size.

  • Histogram: Ein Histogram fasst statistische Informationen zusammen, z. B. über die Dauer der Bearbeitung von HTTP-Requests. Mit Hilfe eines Histograms lässt sich die Frage beantworten, wie viele Aufrufe länger als 100 ms dauern.

  • Summary: Eine Summary fasst ähnlich wie ein Histogram statistische Informationen zusammen. Im Beispiel der Dauer der Bearbeitung von HTTP-Requests lässt sich mit Hilfe einer Summary die Frage beantworten, welche Antwortzeiten in 95 Prozent der Anfragen garantiert werden können [3].

Abfragesprache PromQL

PromQL ist eine spezielle Abfragesprache zum Auslesen von Metrikdaten aus der Zeitreihendatenbank Prometheus. Wichtig hierbei ist, dass PromQL kein SQL ist, auch wenn jeder, der mit SQL vertraut ist, sich schnell in PromQL zurechtfinden dürfte. Eine weitere Besonderheit von PromQL ist, dass PromQL nur Lesezugriff gewährt.

Die einfachste Zeitreihenabfrage ist die Ausgabe aller Zeitreihen einer Metrik. Die folgende Beispielabfrage gibt alle Zeitreihen der Metrik http_requests_total zurück:

http_requests_total

Die Ausgabe von Zeitreihen kann man einschränken, indem man die Zeitreihen nach vorgegebenen Werten für bestimmte Labels filtert. Die erste Beispielabfrage lässt sich z. B. einschränken, indem man nur nach den Zeitreihen der Metrik http_requests_total mit dem Wert "apiserver" für das Label "job" und dem Wert "/api/comments" für das Label "handler" sucht:

http_requests_total{job="apiserver", handler="/api/comments"}

Die zweite Beispielabfrage kann man wiederum auf einen bestimmten Zeitraum, z. B. die letzten fünf Minuten, begrenzen, indem man den Zeitraum in eckigen Klammern angibt:

http_requests_total{job="apiserver", handler="/api/comments"}[5m]

Außer den einfachen Zeitreihenabfragen bietet PromQL auch die Möglichkeit, Zeitreihenabfragen unter Verwendung von Funktionen und Operatoren durchzuführen. Folgendes Beispiel liest die durchschnittliche Gesamtzahl an HTTP-Requests gemessen in den letzten fünf Minuten aus:

rate(http_requests_total[5m])

Die durchschnittliche Gesamtzahl an HTTP-Requests gemessen in den letzten fünf Minuten kann man wie folgt aufsummieren und nach dem Job filtern:

sum(rate(http_requests_total[5m])) by (job)

Mit der folgenden Beispielabfrage kann man sich die drei Top CPU-User gemessen in den letzten fünf Minuten und gruppiert nach der Applikation und dem Prozesstyp anzeigen lassen:

topk(3, sum(rate(instance_cpu_time_ns[5m])) by (app, proc))

Die Prometheus Dokumentation enthält einen eigenen Abschnitt zur Abfragesprache PromQL mit hilfreichen Beispielen zum Erlernen von PromQL sowie einer umfangreichen Referenz, in der neben den Grundlagen auch ausführlich die Verwendung von Funktionen und Operatoren behandelt wird.

Erste Schritte mit Prometheus

Prometheus-Installation

Auf der Prometheus-Internetseite stehen die aktuellen Prometheus-Binärdateien zum Herunterladen für verschiedene Betriebssysteme zur Verfügung. Prometheus ist aber auch als Docker-Image verfügbar. Wenn Sie Prometheus also lieber als Docker-Container laufen lassen möchten, können Sie sich von Docker Hub das Prometheus-Docker-Image herunterladen.

In der Konfigurationsdatei prometheus.yml können Sie im Abschnitt scrape_configs Ihre zu monitorenden Applikationen hinzufügen und konfigurieren, in welchem Zeitintervall die Metriken abgegriffen werden sollen. Anschließend können Sie den Prometheus-Server mit folgendem Befehl starten:

./prometheus --config.file=prometheus.yml

Den Prometheus-Server können Sie nun aufrufen, indem Sie im Browser die URL http://localhost:9090 eingeben.

Monitoring-Status

Unter Status | Targets werden die Applikationen angezeigt, die vom Prometheus-Server gemonitort werden. Das ist zum einen Prometheus selbst und zum anderen die in der Konfigurationsdatei prometheus.yml eingetragenen zu monitorenden Applikationen. Ist eine Applikation gerade nicht verfügbar, so wird der Status als "down" gemeldet. Somit haben Sie zugleich einen guten Überblick über die aktuelle Verfügbarkeit Ihrer Applikationen. Wenn Sie unter "Endpoint" auf die URL Ihrer zu monitorenden Applikation klicken, werden die vom Prometheus-Server abgegriffenen Metriken in textueller Form jeweils bestehend aus einem Hilfetext, dem Metriktyp und den zugehörigen Werten dargestellt.

Prometheus Expression Browser

Unter Graph wird Ihnen der Expression Browser von Prometheus angezeigt. Im Expression Browser können Sie PromQL-Abfragen ausführen und sich das Ergebnis als Konsolenausgabe oder Grafen anzeigen lassen. Zum schnellen Ausführen und Testen von PromQL-Abfragen ist der Expression Browser von Prometheus durchaus sehr hilfreich. Viel eleganter geht die Visualisierung von Metrikdaten allerdings in Grafana.

Grafana

Grafana ist ein Open-Source-Visualisierungstool, das in Go implementiert ist. Das Grafana-Projekt wurde 2014 von Torkel Ödegaard initiiert [4]. Inzwischen hat sich Grafana zu einem äußerst beliebten Open-Source-Projekt mit einer aktiven Community entwickelt.

Das Visualisierungstool Grafana besteht hauptsächlich aus einem Server, der HTTP und HTTPS spricht und ein grafisches Webinterface zur Verfügung stellt. Unter der Haube verfügt Grafana über eine Plug-in-Schnittstelle für verschiedene Backends, wie z. B. Prometheus, InfluxDB und OpenTSDB [5].

Im Folgenden zeige ich Ihnen, wie Sie mit Hilfe von Grafana Dashboards erstellen, Alert Rules definieren und Alert Notifications versenden können.

Erste Schritte mit Grafana

Grafana Installation

Auf der Grafana-Internetseite stehen die aktuellen Grafana-Binärdateien zum Herunterladen für verschiedene Betriebssysteme zur Verfügung. Genauso wie Prometheus ist Grafana ebenfalls als Docker-Image verfügbar. Wenn Sie es bevorzugen, Grafana als Docker-Container laufen zu lassen, können Sie sich folglich von Docker Hub das Grafana-Docker-Image herunterladen. Das Grafana-Docker-Image können Sie sich aber auch direkt von der Grafana-Internetseite herunterladen.

Die Grafana-Installationsanleitung beschreibt, wie in Abhängigkeit vom Betriebssystem der Grafana-Server gestartet werden kann. Anschließend können Sie den Grafana-Server aufrufen, indem Sie im Browser die URL http://localhost:3000 eingeben. Der initiale Benutzername sowie das initiale Passwort ist jeweils admin. Nach dem ersten Login werden Sie aufgefordert, das Passwort zu ändern.

Einrichten der Datenquelle in Grafana

Der erste Schritt, um Prometheus Metrikdaten in Grafana zu visualisieren, ist das Hinzufügen von Prometheus als Datenquelle. Hierzu selektieren Sie links in der Symbolleiste das Zahnrad für Configuration, wählen den Eintrag Data Sources, klicken auf Add data source und fügen Prometheus als Datenquelle hinzu. Nachdem Sie einen Namen und die URL für die Prometheus-Datenquelle angegeben haben, klicken Sie auf Save & Test. Wenn Grafana auf die Prometheus-Datenquelle zugreifen kann, wird Ihnen die Meldung "Data source is working" angezeigt.

Erstellen eines Dashboards in Grafana

Im zweiten Schritt erstellen Sie ein Dashboard. Selektieren Sie links in der Symbolleiste das Pluszeichen für Create, wählen Sie den Eintrag Dashboard, und klicken Sie auf Add new panel. Rechts im Register Panel können Sie unter Visualization den Visualisierungstyp, z. B. Graph, bestimmen. Ebenfalls im Register Panel können Sie unter Settings | Panel title einen Namen für das Diagramm vergeben. Im Register Query direkt unter dem Diagramm wählen Sie zunächst die zuvor eingerichtete Prometheus Datenquelle aus und geben dann im Eingabefeld zu Metrics Ihre PromQL-Abfrage ein. Grafana unterstützt Sie hierbei mit einer komfortablen Autovervollständigung. Anschließend klicken Sie ganz oben rechts auf Save. Sie werden nun aufgefordert, einen Namen für das Dashboard zu vergeben.

Sie können zu Ihrem Dashboard weitere Diagramme mit dem gewünschten Visualisierungstyp hinzufügen, indem Sie in der Symbolleiste oben rechts in Ihrem Dashboard auf das Symbol mit dem Säulendiagramm und dem kleinen Pluszeichen für Add panel klicken. Jedes Mal, wenn Sie Ihre Änderungen an dem Dashboard speichern, werden Sie aufgefordert, eine Änderungsbeschreibung anzugeben. Es empfiehlt sich, eine sinnvolle Änderungsbeschreibung zu verwenden für den Fall, dass man zu einem späteren Zeitpunkt die jetzige Version des Dashboards wiederherstellen möchte. Wenn Sie in der Symbolleiste oben rechts in Ihrem Dashboard auf das Zahnrad für Dashboard settings klicken und anschließend links in den Dashboard Settings den Eintrag Versions selektieren, wird Ihnen die Änderungshistorie angezeigt. Sie haben dann die Möglichkeit, eine vorherige Version wiederherzustellen.

Alerting in Grafana

Um benachrichtigt zu werden, sobald ein definierter Schwellenwert überschritten worden ist, können Sie sich von Grafana Alert Notifications schicken lassen. Zunächst müssen Sie hierfür in Grafana einen Notification Channel einrichten. Selektieren Sie links in der Symbolleiste die Glocke für Alerting, wählen Sie Notification channels aus und klicken Sie auf Add channel. Unter Type geben Sie an, wohin Grafana die Alert Notifications schicken soll. Sie können sich Alert Notifications beispielsweise an eine E-Mail-Adresse oder einen Slack Channel schicken lassen. Füllen Sie die Felder für Ihren Notification Channel aus, und klicken Sie auf Send Test. Wenn Grafana erfolgreich eine Test Notification an Ihren Notification Channel senden konnte, wird Ihnen die Meldung "Test notification sent" angezeigt. Klicken Sie anschließend auf Save, um die Einrichtung Ihres Notification Channels in Grafana zu speichern.

Im nächsten Schritt definieren Sie Alert Rules in Ihrem Dashboard. Klicken Sie hierzu jeweils auf den kleinen Pfeil rechts neben dem Diagrammnamen und wählen Sie Edit. Im Register Alert direkt unter dem Diagramm klicken Sie auf Create Alert. Vergeben Sie unter Rule | Name einen Namen für Ihre Alert Rule. Unter Conditions selektieren Sie eine Ihrer zuvor erstellten Queries und definieren, unter welchen Bedingungen eine Alert Notification gesendet werden soll. Im Abschnitt Notifications wählen Sie unter Send to den zuvor eingerichteten Notification Channel aus und tragen unter Message den Nachrichtentext ein, den Ihre Alert Notification enthalten soll. Die erstellte Alert Rule können Sie testen, indem sie ganz unten auf Test rule klicken. Grafana zeigt Ihnen nun in einem separaten Fenster das Testergebnis an, d. h. ob die Regel gefeuert hat und welcher Wert für Ihre Query zurückgeliefert worden ist. Abschließend klicken Sie ganz oben rechts auf Save, um Ihre Alert Rule abzuspeichern.

Mit wenigen Schritten haben Sie somit in Grafana ein Dashboard erstellt, das relevante Prometheus-Metrikdaten visualisiert und beim Überschreiten eines systemkritischen Wertes eine Alert Notification an einen Notification Channel Ihrer Wahl versendet.

Export und Import von Dashboards in Grafana

Ihre Dashboards in Grafana können Sie mit Teamkolleg*innen oder anderen Teams teilen. Grafana speichert ein Dashboard als JSON-Modell ab, sodass Sie Ihr Dashboard als JSON-Datei exportieren und Ihre Kolleg*innen die JSON-Datei bei sich importieren können. Hierzu klicken Sie in Ihrem Dashboard oben links neben dem Namen des Dashboards auf das Symbol für Share dashboard. Im sich nun öffnenden Fenster klicken Sie im Register Export auf Save to file. Grafana exportiert daraufhin Ihr Dashboard als JSON-Datei. Ihre Kolleg*innen können dann das Dashboard bei sich importieren, indem sie links in der Symbolleiste das Pluszeichen für Create selektieren, Import auswählen und auf Upload .json file klicken.

Darüber hinaus werden von der Grafana-Community für viele Anwendungsszenarien bereits fertige Dashboards zur Verfügung gestellt, die Sie bei sich importieren, anpassen und erweitern können. Hierzu tragen Sie im Textfeld unter Import via grafana.com die URL, von der das Dashboard importiert werden soll, ein und klicken anschließend auf Load.

Testen von PromQL-Abfragen in Grafana

Seit der Version 6.0 stellt Grafana analog zum Expression Browser in Prometheus ein Feature namens Explore zur Verfügung. Mit diesem Feature können Sie, genauso wie mit dem Expression Browser in Prometheus, Ihre PromQL-Abfragen testen und sich das Ergebnis aufbereitet in grafischer und tabellarischer Form anzeigen lassen. Im Gegensatz zum Expression Browser in Prometheus müssen Sie in Grafana jedoch nicht zwischen den beiden Darstellungsformen hin und herwechseln, sondern bekommen alles in einer Ansicht präsentiert. Die Autovervollständigung beim Eingeben Ihrer PromQL-Abfragen ist in Grafana ebenfalls wesentlicher komfortabler als im Expression Browser in Prometheus.

Fazit

Ein Monitoring- und Alerting-System bestehend aus Prometheus und Grafana lässt sich schnell und einfach aufsetzen. Für das Monitoring relevante Metrikdaten werden in der eigens hierfür konzipierten Zeitreihendatenbank Prometheus gespeichert und lassen sich ohne großen Aufwand mit der prometheus-eigenen Abfragesprache PromQL auslesen. Die Visualisierung der relevanten Daten in Form von Dashboards lässt sich in Grafana leicht umsetzen und bietet einen echten Mehrwert für Entwickler und Administratoren. Das Alerting lässt sich in Grafana ebenfalls bequem realisieren, sodass Ihr Team beim Überschreiten eines definierten Schwellenwertes benachrichtigt wird und proaktiv handeln kann.

Für den Einstieg und die tägliche Arbeit mit Prometheus und Grafana empfehle ich Ihnen jeweils die Internetseiten von Prometheus und Grafana. Auf beiden Internetseiten finden Sie hilfreiche Tutorials und ausführliche Dokumentationen.

Quellen
  1. Prometheus
  2. M. G. Loschwitz: Allzeit im Blick, Prometheus-Tutorial, Teil 1: Monitoring, Alerting und Trending, iX 8/2018, S. 96
  3. F. Stäber: Prometheus-Monitoring für Java-Entwickler
  4. Grafana
  5. M. Loschwitz: Der Datenvisualisierer Grafana und seine Backends

Autorin

Antje Landschulz

Antje Landschulz arbeitet als Software-Entwicklerin im Smart-Home-Umfeld bei der Deutschen Telekom AG. Zuvor war sie als Java-Entwicklerin für IT-Consultingunternehmen in Deutschland und in der Schweiz tätig.
>> Weiterlesen
Das könnte Sie auch interessieren

Kommentare (0)

Neuen Kommentar schreiben