Mise en place de Prometheus, Grafana et Spring Boot

La manière la plus rapide de faire fonctionner Prometheus et Grafana est d'utiliser Docker. On gagne beaucoup de temps au niveau de la configuration et de la sécurité grâce à la base solide suppliée par Docker. Les images Docker mises à disposition sont bien préconfigurées, ce qui rend le démarrage super simple.
Si Docker-compose n'est pas encore installé, tu peux consulter la documentation suivante: https://docs.docker.com/compose/install/linux/.

On commence par créer un nouveau ficher docker-compose.yml sur le serveur où Docker et Docker-Compose sont déjà installés:

ATTENTION: Il est important de changer le mot de passe par défaut "admin" si le serveur est accesible au public. Sinon, des petits malins comme des Script Kiddies se feront un plaisir d de pénétrer votre système.

Il faut créer un nouveau fichier prometheus.yml dans le répertoire qui contient le fichier docker-compose.yml, qui contient le code suivant:

Ici, nous avons défini un scrape job qui accède au service localhost:9090, c'est-à-dire au serveur Prometheus lui-même. Cette configuration permet de charger différentes expressions dans Prometheus, qui peuvent être utilisées pour lire des données de métriques concernant le serveur Prometheus.

Après la création du fichier de configuration, if faut démarrer le container Docker en utilisant la commande suivante:

Si aucun autre pare-feu ou autre ne se met en travers, Prometheus et Grafana devraient être accessibles.

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

Comme nous avons défini un scraper qui lit les métriques du conteneur Prometheus dans le fichier de configuration, tu peux afficher à titre d'exemple le nombre de requêtes HTTP en cliquant sur 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

On peut accéder à Grafana en suivant le lien suivant:
<server-ip>:3000

On se connecte en utilisant le mot de passe défini dans le fichier docker-compose.yml.

Comme on peut le constater, Grafana est encore plutôt vide. Avant de définir notre premier tableau de bord propre, il faut intégrer Prometheus en utilisant le lien suivant:
<server-ip>:3000/connections/datasources/new

On sélectionne Prometheus et entre l'URL suivante:
<server-ip>:9090

On enregistre les changements ensuite.

Dans Grafana, les données métriques sont définies dans des tableaux de bord et affichées visuellement selon la configuration. On peut créer un tableau de bord, en ouvrant le lien suivant :
<server-ip>:3000/dashboards

Pour créer un nouveau tableau de bord, on clique sur "New" en haut à droite, ensuite on sélectionne "Add visualization". Comme source de données, on choisit Prometheus.

Nous allons maintenant aborder le monitoring sous l'angle des applications.

Imagine que tu as une application Spring Boot dans laquelle il y a beaucoup de trafic de données et une quantité de logs stockés dans différentes zones. Dans cette section, je te montre comment mettre en place tout cela - avec la dépendance Prometheus Promtail pour envoyer les logs vers Loki. Loki fonctionne comme une interface qui utilise Grafana pour représenter visuellement les fichiers log.

Nous utilisons Maven comme outil de construction, mais cela fonctionne de la même manière avec Gradle - l'approche reste la même.

Maven:

Il faut ajouter la dépendence suivante dans le fichiert pom.xml:

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

Gradle:

Pour Gradle, il faut adapter le fichier build.gradle en ajoutant le code suivant:

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

Il faut ensuite reconstruire le projet pour appliquer les modifications.

Afin de pouvoir lire les métriques, il faut ajouter le contenu suivant soit dans le fichier application.properties soit dans le fichier application.yml:

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

Cela permet de s'assurer que les métriques Prometheus sont disponibles via le point d'accès approprié.

Attention: Si Spring Boot Security est activé, il fault autoriser le point d'accès en conséquence pour pouvoir accéder aux métriques.

Maintenant, il faut encore configurer le scraper dans la configuration de Prometheus en ajoutant le contenu suivant dans le fichier prometheus.yml:

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

Après avoir effectué les modifications, il faut redémarrer le conteneur.

Tout s'est bien passé ? On devrait alors trouver de nouvelles expressions dans Prometheus ou Grafana, comme par exemple jvm_info.

La lecture des logs de Spring Boot dans Grafana est particulièrement utile, car elle permet de surveiller les performances et le comportement de l'application en temps réel. En visualisant les logs de manière centralisée, on peut identifier et analyser les problèmes plus rapidement, ce qui permet de mettre en place des processus de débogage et d'optimisation plus efficaces. Grafana offre la possibilité de parcourir les logs de manière interactive et de mettre en corrélation différentes métriques, ce qui facilite considérablement le diagnostic des erreurs. Cela permet non seulement de garder une vue d'ensemble des logs, mais aussi de prendre des décisions éclairées pour améliorer ton application.

Dans ce processus, if faut également une installation de Docker pour pouvoir installer l'image Docker Promtail sur le serveur sur lequel fonctionne également Spring Boot. Promtail sert à envoyer les logs vers Loki. Loki peut également être installé en tant qu'image Docker et sera lu par Grafana, car Grafana offre déjà une source de données Loki pour représenter visuellement les logs. Cela n'a plus rien à voir avec Prometheus.

Pour cela, on crée  un fichier docker-compose.yaml sur le serveur Spring Boot 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 ne sert que comme exemple. Il est important de changer le chemin vers les fichiers logs, car il peut être différent sur ton serveur.

On crée un nouveau fichier promtail-config.yml et on prend 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

Il faut assurer que l'entrée url pointe vers le serveur Grafana.
On peut ensuit démarrer le conteneur.

On peut installer Loki là où Grafana est installé. Pour cela, il faut étendre le fichier docker-compose.yml sur le 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

  # 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"

En peut ensuite démarrer le conteneur Loki.

On continue sous:

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

et on sélectionne Loki comme source de données. Comme URL on prend la suivante:

<server-ip>:3100

On peut ensuite créer un nouveau tableau de bord pour utiliser Loki comme source de données.

Et voilà, on y est! La configuration est enfin terminée et on peut maintenant profiter des logs et des métriques de l'application Spring Boot dans Grafana et les visualiser très facilement. La possibilité de tout voir au même endroit rend beaucoup plus facile le suivi des performances de l'application et la réaction rapide aux problèmes potentiels.

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