Einrichtung von Prometheus, Grafana und Spring Boot

Der schnellste Weg, Prometheus und Grafana zum Laufen zu bringen, ist über Docker. So sparst du jede Menge Zeit bei der Konfiguration und Sicherheit, denn Docker bietet eine solide Basis. Die bereitgestellten Docker-Images sind schon gut vorkonfiguriert, was den Einstieg super einfach macht.
Falls du Docker-Compose noch nicht installiert hast, schau dir am besten diese Dokumentation an: https://docs.docker.com/compose/install/linux/.

Um loszulegen, erstellst du auf deinem Server, wo bereits Docker und Docker-Compose installiert sind, einfach eine neue `docker-compose.yml`-Datei:

ACHTUNG: Das Passwort solltest du auf jeden Fall nicht auf "admin" lassen, wenn der Server von außen verfügbar ist. Ansonsten dringen gerne solche Viecher wie Script-Kids in euer System ein.

Im Verzeichnis, in dem sich deine docker-compose.yml befindet, musst du noch eine Datei mit dem Namen prometheus.yml erstellen. Füge dann folgenden Code hinzu:

Hier haben wir nun einen Scrape-Job definiert, der auf den Service localhost:9090 zugreift, das ist der Prometheus-Server selbst. Durch diese Konfiguration werden in Prometheus verschiedene Expressions geladen, die du nutzen kannst, um Metrikdaten bezüglich des Prometheus-Servers einzulesen.

Nachdem die Konfiguration steht, musst du die Docker-Container starten. Dazu nutzt du den Befehl:

Falls keine weitere Firewall oder Ähnliches im Weg steht, sollten Prometheus und Grafana erreichbar sein.

Um auf Prometheus zuzugreifen, nimmst du folgenden Link:
<server-ip>:9090

Da wir in der Konfigurationsdatei einen Scraper definiert haben, der die Metriken aus dem Prometheus-Container ausliest, kannst du als Beispiel mit folgendem Link die Anzahl an HTTP-Requests 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, nimmst du folgenden Link:
<server-ip>:3000

Hier loggst du dich mit dem Passwort ein, das du in der docker-compose.yml-Datei definiert hast.

Wie du siehst, ist Grafana noch ziemlich leer. Bevor du dein eigenes Dashboard definierst, musst du Prometheus einbinden. Dazu nutzt du folgenden Link:
<server-ip>:3000/connections/datasources/new

Da wählst du einfach nur Prometheus aus und verwendest als URL:
<server-ip>:9090

Speichere das dann ab.

In Grafana werden Metrikdaten in Dashboards definiert und je nach Konfiguration visuell angezeigt. Um ein Dashboard zu erstellen, öffne folgenden Link:
<server-ip>:3000/dashboards

Hier erstellst du ein neues Dashboard, indem du oben rechts auf "New" klickst. Danach wählst du "Add visualization" und als Data Source nimmst du, wie vorher definiert, Prometheus aus.

Jetzt gehen wir anwendungsbezogen an das Monitoring ran.

Stell dir vor, du hast eine Spring Boot-Applikation, in der viel Datenverkehr herrscht und jede Menge Logs in verschiedenen Bereichen gespeichert werden. In diesem Abschnitt zeige ich dir, wie du das Ganze einrichtest – mit einer Prometheus-Dependency, Promtail zum Einsenden der Logs in Richtung Loki. Loki fungiert dabei als Schnittstelle, die Grafana nutzt, um die Log-Dateien visuell darzustellen.

Wir nutzen Maven als Build-Tool, aber mit Gradle funktioniert es genauso – die Herangehensweise bleibt die gleiche.

Maven:

In deiner pom.xml-Datei musst du folgende Dependency hinzufügen:

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

Gradle:

Für Gradle musst du deine build.gradle anpassen. Füge diesen Code hinzu:

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

Dann buildest du nochmal dein Projekt neu, um die Änderungen zu übernehmen.

Damit du die Metrics auch auslesen kannst, musst du unbedingt folgendes in deiner application.properties oder application.yml hinzufügen:

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

Das sorgt dafür, dass die Prometheus-Metriken über den passenden Endpoint verfügbar sind.

Achtung: Wenn Spring Boot Security aktiviert ist, musst du den Endpoint entsprechend erlauben, damit du auf die Metriken zugreifen kannst.

Nun musst du den Scraper noch in der Prometheus-Konfiguration konfigurieren:

Dazu fügst du in der prometheus.yml folgenden Inhalt hinzu:

global:
  scrape_interval: 15s

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

Nachdem du die Änderungen vorgenommen hast, starte den Container neu.

Hat alles geklappt? Dann solltest du in Prometheus oder Grafana neue Expressions finden, wie z. B. jvm_info.

Das Auslesen von Spring Boot Logs in Grafana ist besonders sinnvoll, da es dir ermöglicht, die Performance und das Verhalten deiner Anwendung in Echtzeit zu überwachen. Durch die zentrale Visualisierung der Logs kannst du Probleme schneller identifizieren und analysieren, wodurch du effizientere Debugging- und Optimierungsprozesse einleiten kannst. Grafana bietet dir die Möglichkeit, Logs interaktiv zu durchsuchen und verschiedene Metriken zu korrelieren, was die Fehlerdiagnose erheblich vereinfacht. So behältst du nicht nur den Überblick über die Logs, sondern kannst auch fundierte Entscheidungen zur Verbesserung deiner Anwendung treffen.

In diesem Vorgang musst du ebenfalls Docker installiert haben, um den Docker-Image Promtail auf dem Server zu installieren, auf dem auch Spring Boot läuft. Promtail dient dazu, die Logs Richtung Loki zu schicken. Loki kann ebenfalls als Docker-Image installiert werden und wird von Grafana ausgelesen, denn Grafana bietet bereits eine Loki-Datenquelle, um die Logs visuell darzustellen. Das hat nichts mehr mit Prometheus zu tun.

Dazu erstellst du auf dem Spring Boot Server eine docker-compose.yaml 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

Achtung: Der Pfad ../tomcat/logs dient hier nur als Beispiel. Es ist wichtig, dass du den Pfad zu deinen Logs anpasst, da er bei dir anders sein könnte.

Hierzu erstellst du eine neue Datei namens promtail-config.yml und nimmst diese 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

Stelle sicher, dass du den url-Eintrag zum Grafana-Server anpasst.
Dann kannst du den Container auch starten.

Loki kannst du dort installieren, wo auch Grafana installiert ist. Dazu erweiterst du die docker-compose.yml auf deinem Server:

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"

Dann kannst du den Loki Container auch starten.

Dazu gehst du wieder unter:

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

und wählst als Data-Source diesmal Loki aus. Als URL nimmst du:

<server-ip>:3100

Dann kannst du ein neues Dashboard erstellen und nutzt dann Loki als Data Source.

Und da haben wir es! Die Konfiguration ist endlich abgeschlossen. Jetzt kannst du die Logs und Metrikdaten deiner Spring Boot-Anwendung in Grafana genießen und ganz einfach visualisieren. Die Möglichkeit, alles an einem Ort zu sehen, macht es viel einfacher, die Leistung deiner Anwendung zu überwachen und schnell auf potenzielle Probleme zu reagieren.

Mit Grafana hast du ein mächtiges Werkzeug, um die gesammelten Daten effektiv darzustellen. Du kannst interaktive Dashboards erstellen, die dir auf einen Blick zeigen, wie es um deine Anwendung steht. Egal, ob du Performance-Überwachung oder Fehleranalyse machst, das Zusammenspiel von Prometheus, Grafana und Spring Boot gibt dir die Kontrolle und Einblicke, die du benötigst.

Viel Spaß beim Experimentieren mit den Metriken und Logs!