Wie du deine Spring Boot Anwendung mit Spring Actuator und Micrometer überwachen kannst

Im Bereich der Anwendungsentwicklung mit Spring Boot ist es wichtig, sich nicht nur auf die Entwicklung zu konzentrieren, sondern auch auf die Leistungsüberwachung. In diesem umfangreichen Guide werden wir die Schritte zur Einrichtung der Überwachung für deine Spring Boot-Anwendung mithilfe von Spring Actuator und Micrometer sowie die Verwendung von Prometheus und Grafana zur effektiven Metrik-Verarbeitung und Visualisierung untersuchen.

Spring Boot Monitoring verstehen

Das Monitoring ist ein wesentlicher Bestandteil, um die Stabilität einer Anwendung sicherzustellen. Es ermöglicht Entwicklern, den reibungslosen Ablauf des Systems zu überprüfen und potenzielle Probleme zu erkennen. Im Zusammenhang mit Spring Boot machen verschiedene Tools wie Spring Actuator und Micrometer das Monitoring zu einem mühelosen Prozess.

Spring Actuator führt Funktionen in Produktionsqualität in deine Anwendung ein und bietet zahlreiche Endpunkte zur Überwachung und Verwaltung deiner Anwendung. Micrometer hingegen bietet einen einfachen Mechanismus zur Instrumentierung deines Codes zur Metriken-Sammlung, die dann an verschiedene Überwachungssysteme weitergeleitet werden können.

Lass uns tiefer in diese Tools und ihren Einrichtungsprozess eintauchen.

Integration von Spring Actuator

Der erste Schritt besteht darin, die Spring Actuator Dependency in deine Spring Boot Anwendung einzubinden. Wenn du Maven verwendest, kannst du dies tun, indem du den folgenden Code zu deiner pom.xml Datei hinzufügst:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>

Nach der Integration wird Spring Actuator automatisch mehrere Endpunkte wie /health und /info zur Verfügung stellen. Die meisten dieser Endpunkte sind jedoch standardmäßig geschützt. Um sie zu aktivieren, musst du die folgenden Eigenschaften zu deiner application.properties Datei hinzufügen:

management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

Implementierung von Micrometer

Micrometer ermöglicht es dir, in Zusammenarbeit mit Spring Actuator verschiedene Metriken aus deiner Anwendung zu erfassen. Du kannst Micrometer in deine Anwendung integrieren, indem du die folgende Abhängigkeit zu deiner pom.xml hinzufügst:

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

Mit Micrometer integriert kannst du die Request-Raten mithilfe des folgenden Code-Snippets überwachen. Betrachten wir ein Beispiel für einen Spring MVC Controller:

@RestController
public class SampleController {

    @Autowired
    private MeterRegistry registry;

    @RequestMapping("/hello")
    public String hello() {
        registry.counter("requests_to_hello_endpoint").increment();
        return "Hallo Welt!";
    }
}

Die Instanz MeterRegistry ermöglicht es dir, eine Counter-Metrik mit dem Namen requests_to_hello_endpoint zu erstellen und zu inkrementieren, jedes Mal wenn der Endpunkt /hello aufgerufen wird.

Verbindung mit Prometheus und Grafana

Mit Spring Actuator und Micrometer benötigst du ein robustes Monitoringsystem wie Prometheus und ein leistungsstarkes Visualisierungstool wie Grafana, um das Beste aus deinen gesammelten Metriken herauszuholen. Du kannst diese Tools lokal oder in einem Docker-Container ausführen.

Um Prometheus einzurichten, musst du eine Konfigurationsdatei prometheus.yml im Stammverzeichnis hinzufügen:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'spring-actuator'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['<Die IP deiner Spring Boot-Anwendung>:<Port>']

Als nächstes kannst du Grafana verwenden, um die von Prometheus gesammelten Daten zu visualisieren.

Einrichten von Prometheus und Grafana mit Docker Compose

Die Ausführung von Prometheus und Grafana in einer Docker-Umgebung vereinfacht den Einrichtungsprozess. Dies kann mit Docker Compose erreicht werden.

Erstelle zunächst eine docker-compose.yml Datei im Stammverzeichnis deines Projekts:

version: '3'
services:
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    ports:
      - 9090:9090

  grafana:
    image: grafana/grafana:latest
    depends_on:
      - prometheus
    ports:
      - 3000:3000

Diese Konfiguration richtet Prometheus mit der Konfigurationsdatei prometheus.yml ein (die sich ebenfalls im Stammverzeichnis deines Projekts befinden sollte). Prometheus wird auf Port 9090 freigegeben. Grafana wird ebenfalls eingerichtet, abhängig von Prometheus, und auf Port 3000 freigegeben.

Führe docker compose up im Verzeichnis aus, in dem sich deine docker-compose.yml Datei befindet. Dieser Befehl startet Prometheus und Grafana.

Verbindung deiner Spring Boot-Anwendung

Damit Prometheus Metriken sammeln kann, muss auf deine Spring Boot Anwendung zugegriffen werden können. Stelle daher sicher, dass deine Anwendung ausgeführt wird und über das Netzwerk erreichbar ist.

Um dies zu erleichtern, ersetze in deiner prometheus.yml Datei die Zeile scrape_configs <localhost>:<Der Port deiner Spring Boot-Anwendung> durch die Adresse und den Port deiner ausgeführten Spring Boot Anwendung. Prometheus wird Metriken vom /actuator/prometheus Endpunkt abrufen.

static_configs:
- targets: ['localhost:8080']

Wenn deine Spring Boot-Anwendung lokal läuft und Prometheus in einem Docker-Container läuft, kannst du möglicherweise Probleme mit der Connection aufgrund der unterschiedlichen Netzwerkkontexte haben. Du kannst dieses Problem lösen, indem du host.docker.internal anstelle von localhost verwendest.

static_configs:
- targets: ['host.docker.internal:8080']

Für Grafana, sobald beide Dienste ausgeführt werden, rufe localhost:3000 in deinem Webbrowser auf (wenn erforderlich, ersetze localhost durch die IP deines Docker-Hosts). Der Standard-Benutzername und das Passwort für Grafana lauten admin. Nach der Anmeldung füge Prometheus als Datenquelle hinzu. Gib http://prometheus:9090 als URL ein und klicke auf “Save & Test”. Wenn alles korrekt eingerichtet ist, zeigt Grafana eine funktionierende Datenquelle an.

Mit Docker Compose wird die Einrichtung eines Überwachungsstapels mit Prometheus und Grafana einfach und die Verbindung mit deiner lokal ausgeführten Spring Boot-Anwendung gewährleistet ein robustes Monitoring.

Fazit

Die Überwachung deiner Spring Boot-Anwendung ist ein wichtiger Schritt, um deine Stabilität und Leistungsfähigkeit zu erhalten. Durch die Nutzung von Spring Actuator und Micrometer und deren Integration mit robusten Tools wie Prometheus und Grafana kannst du deine Anwendung effektiv überwachen, wertvolle Metriken sammeln und sie für eine einfache Interpretation visualisieren. Mit diesen Tools bist du gut gerüstet, um potenzielle Probleme zu identifizieren und anzugehen, bevor sie eskalieren.