Configuration de Prometheus, Grafana et Spring Boot

La manière la plus rapide de mettre Prometheus et Grafana en service est d’utiliser Docker. Cela permet de gagner beaucoup de temps en matière de configuration et de sécurité, car Docker offre une base solide. Les images Docker fournies sont déjà bien préconfigurées, ce qui rend la prise en main particulièrement simple.
Si Docker Compose n’est pas encore installé, nous vous recommandons de consulter la documentation suivante : https://docs.docker.com/compose/install/linux/.

Pour commencer, créez simplement un nouveau fichier docker-compose.yml sur votre serveur, où Docker et Docker Compose sont déjà installés :

ATTENTION : Il est fortement déconseillé de laisser le mot de passe sur « admin » si le serveur est accessible depuis l’extérieur. Dans le cas contraire, des scripts automatisés ou des attaques opportunistes pourraient compromettre votre système.

Dans le répertoire où se trouve votre fichier docker-compose.yml, vous devez créer un fichier nommé prometheus.yml. Ajoutez ensuite le code suivant :

Nous avons ici défini une tâche de scraping qui accède au service localhost:9090, c’est-à-dire au serveur Prometheus lui-même. Grâce à cette configuration, différentes expressions sont disponibles dans Prometheus et peuvent être utilisées pour analyser les métriques liées au serveur Prometheus.

Une fois la configuration terminée, vous devez démarrer les conteneurs Docker à l’aide de la commande suivante :

S’il n’y a pas de pare-feu ou de restriction supplémentaire, Prometheus et Grafana devraient maintenant être accessibles.

Pour accéder à Prometheus, utilisez le lien suivant :
<server-ip>:9090

Comme un scraper a été configuré pour lire les métriques du conteneur Prometheus, vous pouvez par exemple afficher le nombre de requêtes HTTP via le lien suivant :
<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

Pour accéder à Grafana, utilisez le lien suivant :
<server-ip>:3000

Connectez-vous ensuite avec le mot de passe défini dans le fichier docker-compose.yml.

Comme vous pouvez le constater, Grafana est encore relativement vide. Avant de créer votre propre tableau de bord, vous devez d’abord connecter Prometheus. Pour cela, rendez-vous à l’adresse suivante :
<server-ip>:3000/connections/datasources/new

Sélectionnez Prometheus et utilisez l’URL suivante :
<server-ip>:9090

Enregistrez ensuite la configuration.

Dans Grafana, les métriques sont définies et affichées visuellement dans des tableaux de bord. Pour créer un tableau de bord, ouvrez le lien suivant :
<server-ip>:3000/dashboards

Créez ensuite un nouveau tableau de bord en cliquant sur « New » en haut à droite. Sélectionnez ensuite « Add visualization » et choisissez Prometheus comme source de données, comme défini précédemment.

Passons maintenant au monitoring côté application.

Imagine que tu disposes d’une application Spring Boot avec un trafic important et de nombreux logs répartis sur différents composants. Dans cette section, je vais te montrer comment mettre tout cela en place : avec une dépendance Prometheus et Promtail pour envoyer les logs vers Loki. Loki joue ici le rôle d’interface utilisée par Grafana pour afficher visuellement les fichiers de logs.

Nous utilisons Maven comme outil de build, mais cela fonctionne exactement de la même manière avec Gradle ; l’approche reste identique.

Maven :

Dans ton fichier pom.xml, tu dois ajouter la dépendance suivante :

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

Gradle :

Pour Gradle, adapte ton fichier build.gradle et ajoute le code suivant :

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

Ensuite, reconstruis ton projet afin de prendre en compte les modifications.

Afin de pouvoir exposer et lire les métriques, tu dois impérativement ajouter la configuration suivante dans ton fichier application.properties ou application.yml :

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

Cela permet de rendre les métriques Prometheus accessibles via l’endpoint approprié.

Attention : si Spring Boot Security est activé, tu dois autoriser explicitement cet endpoint afin de pouvoir accéder aux métriques.

Il te reste maintenant à configurer le scraper dans la configuration Prometheus.

Pour cela, ajoute le contenu suivant à ton fichier prometheus.yml :

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']
  

Une fois les modifications effectuées, redémarre le conteneur.

Si tout s’est bien déroulé, tu devrais désormais trouver de nouvelles expressions dans Prometheus ou Grafana, comme par exemple jvm_info.

L’analyse des logs Spring Boot dans Grafana est particulièrement utile, car elle te permet de surveiller en temps réel les performances et le comportement de ton application. Grâce à la visualisation centralisée des logs, tu peux identifier et analyser les problèmes plus rapidement, ce qui rend les processus de débogage et d’optimisation bien plus efficaces. Grafana te permet également de rechercher les logs de manière interactive et de les corréler avec différentes métriques, simplifiant considérablement le diagnostic des erreurs.

Pour cette étape, Docker doit également être installé afin de déployer l’image Docker Promtail sur le serveur où s’exécute Spring Boot. Promtail est chargé d’envoyer les logs vers Loki. Loki peut lui aussi être installé sous forme d’image Docker et est ensuite interrogé par Grafana, qui propose déjà une source de données Loki pour afficher visuellement les logs. Cette partie n’a plus de lien direct avec Prometheus.

Pour cela, crée sur le serveur Spring Boot un fichier docker-compose.yaml avec le contenu suivant :

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
  

Attention : le chemin ../tomcat/logs n’est qu’un exemple. Il est important d’adapter ce chemin à l’emplacement réel de tes fichiers de logs, qui peut être différent dans ton environnement.

Crée ensuite un nouveau fichier nommé promtail-config.yml et utilise le modèle suivant comme contenu :

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
  

Assure-toi d’adapter l’entrée url à l’adresse de ton serveur Grafana.
Tu peux ensuite démarrer le conteneur.

Loki peut être installé sur le même serveur que Grafana. Pour cela, il suffit d’étendre le fichier docker-compose.yml sur ton serveur :

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

  # ajouter loki
  loki:
    image: grafana/loki:2.9.10
    container_name: loki
    command: -config.file=/etc/loki/local-config.yaml
    restart: always
    ports:
      - "3100:3100"
  

Tu peux ensuite démarrer le conteneur Loki.

Rends-toi à nouveau à l’adresse suivante :

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

et sélectionne cette fois-ci Loki comme source de données. Comme URL, utilise :

<server-ip>:3100

Tu peux ensuite créer un nouveau tableau de bord et utiliser Loki comme source de données.

Et voilà ! La configuration est enfin terminée. Tu peux désormais profiter de la visualisation des logs et des métriques de ton application Spring Boot dans Grafana, de manière simple et claire. Le fait de tout voir au même endroit facilite grandement le suivi des performances et permet de réagir rapidement en cas de problème potentiel.

Avec Grafana, tu disposes d’un outil puissant pour représenter efficacement les données collectées. Tu peux créer des tableaux de bord interactifs qui te donnent, en un coup d’œil, une vision précise de l’état de ton application. Que ce soit pour la surveillance des performances ou l’analyse des erreurs, la combinaison de Prometheus, Grafana et Spring Boot t’offre le contrôle et les insights dont tu as besoin.

Amuse-toi bien à expérimenter avec les métriques et les logs !