Einrichtung von Prometheus, Grafana und Spring Boot

Der schnellste Weg, Prometheus und Grafana zum Laufen zu bringen, ist die Verwendung von Docker. Das spart bei der Konfiguration und Absicherung viel Zeit, da Docker eine solide Grundlage bietet. Die bereitgestellten Docker-Images sind bereits gut vorkonfiguriert, was den Einstieg sehr erleichtert.
Falls Sie Docker Compose noch nicht installiert haben, finden Sie hier die offizielle Dokumentation: https://docs.docker.com/compose/install/linux/.

Erstellen Sie zunächst eine neue Datei docker-compose.yml auf Ihrem Server, auf dem Docker und Docker Compose bereits installiert sind:

WARNUNG: Sie sollten das Passwort keinesfalls auf „admin“ belassen, wenn der Server von außen erreichbar ist. Andernfalls könnten sich Script-Kiddies und ähnliche Angreifer Zugang zu Ihrem System verschaffen.

In dem Verzeichnis, in dem sich Ihre docker-compose.yml befindet, müssen Sie zusätzlich eine Datei mit dem Namen prometheus.yml erstellen. Fügen Sie dann folgende Konfiguration hinzu:

Hier haben wir einen Scrape-Job definiert, der auf den Dienst unter localhost:9090 zugreift, also auf den Prometheus-Server selbst. Mit dieser Konfiguration lädt Prometheus verschiedene Ausdrücke, mit denen Sie Metrikdaten zum Prometheus-Server auslesen können.

Sobald die Konfiguration vorhanden ist, müssen Sie die Docker-Container mit folgendem Befehl starten:

Sofern keine Firewall oder ähnliche Einschränkungen vorliegen, sollten Prometheus und Grafana nun erreichbar sein.

Um auf Prometheus zuzugreifen, verwenden Sie folgende URL:
<server-ip>:9090

Da wir in der Konfigurationsdatei einen Scraper definiert haben, der Metriken aus dem Prometheus-Container ausliest, können Sie beispielsweise über diesen Link die Anzahl der HTTP-Anfragen anzeigen lassen:
<server-ip>:9090/graph?g0.expr=prometheus_http_requests_total&g0.tab=0&g0.display_mode=lines&g0.show_exemplars=0&g0.range_input=1h

Um auf Grafana zuzugreifen, verwenden Sie folgende URL:
<server-ip>:3000

Melden Sie sich mit dem in Ihrer docker-compose.yml-Datei definierten Passwort an.

Wie Sie sehen, ist Grafana noch ziemlich leer. Bevor Sie Ihr eigenes Dashboard definieren, müssen Sie Prometheus als Datenquelle verbinden. Öffnen Sie dazu folgende URL:
<server-ip>:3000/connections/datasources/new

Wählen Sie Prometheus aus und verwenden Sie folgende URL:
<server-ip>:9090

Speichern Sie die Konfiguration.

In Grafana werden Metrikdaten in Dashboards definiert und visualisiert. Um ein Dashboard zu erstellen, öffnen Sie folgende URL:
<server-ip>:3000/dashboards

Erstellen Sie ein neues Dashboard, indem Sie oben rechts auf „New“ klicken. Wählen Sie dann „Add visualization“ und anschließend Prometheus als Datenquelle aus.

Nun heben wir das Monitoring auf die Anwendungsebene.

Stellen Sie sich vor, Sie haben eine Spring-Boot-Anwendung mit hohem Traffic und zahlreichen Logs, die über verschiedene Bereiche verteilt gespeichert werden. In diesem Abschnitt zeige ich Ihnen, wie Sie alles mithilfe einer Prometheus-Abhängigkeit und Promtail einrichten, um Logs an Loki zu senden. Loki fungiert als Schnittstelle, über die Grafana Logdateien visualisiert.

Wir verwenden hier Maven als Build-Tool, aber der gleiche Ansatz funktioniert auch mit Gradle.

Maven:

Fügen Sie Ihrer pom.xml-Datei folgende Abhängigkeit hinzu:

<dependency>
  <groupId>io.micrometer</groupId>
  <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Gradle:

Passen Sie bei Gradle Ihre build.gradle-Datei an und fügen Sie folgende Zeile hinzu:

implementation 'io.micrometer:micrometer-registry-prometheus'

Bauen Sie anschließend Ihr Projekt neu, um die Änderungen zu übernehmen.

Damit die Metriken zugänglich sind, müssen Sie Folgendes in Ihrer application.properties oder application.yml ergänzen:

management.endpoints.web.exposure.include=prometheus
management.endpoint.prometheus.enabled=true

Damit wird sichergestellt, dass die Prometheus-Metriken über den entsprechenden Endpunkt bereitgestellt werden.

Warnung: Wenn Spring Boot Security aktiviert ist, stellen Sie sicher, dass Sie diesen Endpunkt explizit freigeben, damit Sie auf die Metriken zugreifen können.

Als Nächstes müssen Sie den Scraper in der Prometheus-Konfiguration einrichten.

Fügen Sie Ihrer prometheus.yml-Datei folgenden Abschnitt hinzu:

global:
  scrape_interval: 15s
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']
  - job_name: 'spring-boot'
    metrics_path: "/actuator/prometheus"
    static_configs:
      - targets: ['<springboot-server-ip>:8080']
  

Starten Sie nach dem Übernehmen der Änderungen den Container neu.

Wenn alles korrekt funktioniert hat, sollten Sie nun neue Ausdrücke in Prometheus oder Grafana finden, wie zum Beispiel jvm_info.

Das Auslesen von Spring-Boot-Logs in Grafana ist besonders nützlich, da es Ihnen ermöglicht, die Leistung und das Verhalten Ihrer Anwendung in Echtzeit zu überwachen. Die zentrale Log-Visualisierung hilft Ihnen, Probleme schneller zu erkennen und zu analysieren, was effizientere Debugging- und Optimierungsprozesse ermöglicht. Mit Grafana können Sie Logs interaktiv durchsuchen und mit Metriken korrelieren, was die Fehlerdiagnose erheblich vereinfacht. So behalten Sie nicht nur den Überblick über Ihre Logs, sondern können auch fundierte Entscheidungen treffen, um Ihre Anwendung zu verbessern.

Für dieses Setup muss ebenfalls Docker installiert sein, um das Promtail-Docker-Image auf dem Server auszuführen, auf dem Spring Boot läuft. Promtail wird verwendet, um Logs an Loki zu senden. Loki kann ebenfalls als Docker-Image installiert werden und wird von Grafana abgefragt, da Grafana bereits eine Loki-Datenquelle zur Visualisierung von Logs bereitstellt. Dieser Teil ist vollständig unabhängig von Prometheus.

Erstellen Sie dazu auf dem Spring-Boot-Server eine docker-compose.yaml-Datei mit folgendem Inhalt:

version: '3.8'
services:
  promtail:
    image: grafana/promtail:latest
    container_name: promtail
    volumes:
      - ../tomcat/logs:/var/log
      - ./promtail-config.yml:/etc/promtail/promtail-config.yml
    command: -config.file=/etc/promtail/promtail-config.yml
    restart: always
  

Warnung: Der Pfad ../tomcat/logs ist nur ein Beispiel. Achten Sie darauf, den Pfad an den tatsächlichen Speicherort Ihrer Logdateien anzupassen.

Erstellen Sie eine neue Datei mit dem Namen promtail-config.yml und verwenden Sie folgende Vorlage als Inhalt:

server:
  http_listen_port: 9080
  grpc_listen_port: 0
positions:
  filename: /tmp/positions.yaml
clients:
  - url: <grafana-server-ip>/loki/api/v1/push
scrape_configs:
  - job_name: "tomcat-logs"
    static_configs:
      - targets:
          - localhost
        labels:
          job: "tomcat"
          __path__: /var/log/*.log
  

Achten Sie darauf, den Eintrag url so anzupassen, dass er auf Ihren Grafana-Server verweist.
Anschließend können Sie den Container starten.

Loki sollte auf demselben Server wie Grafana installiert werden. Erweitern Sie dazu die docker-compose.yml auf Ihrem Server wie folgt:

version: '3.7'
services:
  prometheus:
    image: prom/prometheus
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
  grafana:
    image: grafana/grafana
    container_name: grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
  # loki hinzufügen
  loki:
    image: grafana/loki:2.9.10
    container_name: loki
    command: -config.file=/etc/loki/local-config.yaml
    restart: always
    ports:
      - "3100:3100"
  

Jetzt können Sie auch den Loki-Container starten.

Navigieren Sie erneut zu:

<server-ip>:3000/connections/datasources/new

Wählen Sie diesmal Loki als Datenquelle aus und verwenden Sie folgende URL:

<server-ip>:3100

Anschließend können Sie ein neues Dashboard erstellen und Loki als Datenquelle verwenden.

Und schon haben wir es geschafft! Die Konfiguration ist endlich abgeschlossen. Sie können nun sowohl Logs als auch Metrikdaten Ihrer Spring-Boot-Anwendung in Grafana visualisieren. Wenn alles an einem Ort verfügbar ist, wird die Überwachung der Anwendungsleistung deutlich einfacher und Sie können schnell auf mögliche Probleme reagieren.

Grafana bietet Ihnen eine leistungsstarke Möglichkeit, gesammelte Daten wirkungsvoll darzustellen. Sie können interaktive Dashboards erstellen, die auf einen Blick Einblick in den Zustand Ihrer Anwendung geben. Ob Performance-Monitoring oder Fehleranalyse – die Kombination aus Prometheus, Grafana und Spring Boot gibt Ihnen die Kontrolle und Transparenz, die Sie benötigen.

Viel Spaß beim Experimentieren mit Metriken und Logs!