Accès aux endpoints via HTTP ou JMX

Introduction aux protocoles d'accès Actuator

Spring Boot Actuator offre une flexibilité quant à la manière dont les informations de surveillance et de gestion peuvent être consultées. Les deux principaux protocoles supportés sont HTTP(S) et JMX (Java Management Extensions). Le choix entre ces deux méthodes dépend largement de l'environnement de déploiement, des outils de monitoring utilisés et des politiques de sécurité en place.

L'accès via HTTP est le plus courant pour les applications web, offrant une interface simple et accessible via des navigateurs, des outils en ligne de commande comme cURL, ou directement par des systèmes de monitoring comme Prometheus. JMX, quant à lui, est un standard Java pour la gestion et la surveillance, souvent privilégié dans des environnements plus traditionnels ou lorsque l'exposition d'endpoints HTTP supplémentaires n'est pas souhaitée.

Il est important de savoir comment configurer et utiliser ces deux canaux d'accès pour tirer pleinement parti des capacités d'Actuator dans différents scénarios.

Accès via HTTP : Le standard pour le web

Pour les applications web construites avec Spring Boot (utilisant `spring-boot-starter-web` ou `spring-boot-starter-webflux`), l'accès aux endpoints Actuator via HTTP est activé par défaut. Ces endpoints sont servis sous un chemin de base commun, qui est `/actuator` par défaut.

Ainsi, pour accéder à l'endpoint de santé, l'URL serait typiquement `http://:/actuator/health`. De même, pour les métriques, ce serait `http://:/actuator/metrics`. Vous pouvez interroger ces URLs directement depuis un navigateur ou utiliser un outil comme cURL :

# Vérifier la santé
curl http://localhost:8080/actuator/health

# Lister les métriques disponibles
curl http://localhost:8080/actuator/metrics

# Obtenir une métrique spécifique
curl http://localhost:8080/actuator/metrics/jvm.memory.used

La configuration de quels endpoints sont exposés via HTTP se fait via les propriétés `management.endpoints.web.exposure.include` et `management.endpoints.web.exposure.exclude`. Par défaut (depuis Spring Boot 2.x), seuls `health` et `info` sont exposés sur le web pour des raisons de sécurité. Pour exposer tous les endpoints (à utiliser avec prudence), vous pouvez définir :

management.endpoints.web.exposure.include=*

Ou pour exposer sélectivement `health`, `info`, `metrics`, et `loggers` :

management.endpoints.web.exposure.include=health,info,metrics,loggers

Il est crucial de sécuriser les endpoints Actuator exposés via HTTP, en particulier ceux qui pourraient révéler des informations sensibles (`env`, `beans`) ou permettre des modifications (`loggers`, `shutdown`). Ceci est généralement réalisé en intégrant Spring Security, qui peut protéger ces chemins comme n'importe quelle autre ressource web. L'accès HTTP est particulièrement bien adapté pour l'intégration avec des outils de monitoring modernes qui fonctionnent sur ce protocole, comme Prometheus qui 'scrape' l'endpoint `/actuator/prometheus`.

Accès via JMX : Surveillance standard Java

JMX (Java Management Extensions) est une technologie Java standard conçue pour la surveillance et la gestion des applications. Spring Boot Actuator expose automatiquement ses endpoints sous forme de MBeans (Managed Beans) JMX, permettant ainsi leur consultation via des outils compatibles JMX comme JConsole, VisualVM (souvent inclus dans le JDK), ou des systèmes de monitoring d'entreprise supportant JMX.

Par défaut, tous les endpoints Actuator sont exposés via JMX, à moins que JMX ne soit globalement désactivé (`spring.jmx.enabled=false`). Les MBeans Actuator se trouvent généralement sous le domaine `org.springframework.boot`. Chaque endpoint est représenté par un MBean spécifique, par exemple :

• `org.springframework.boot:type=Endpoint,name=Health`
• `org.springframework.boot:type=Endpoint,name=Metrics`
• `org.springframework.boot:type=Endpoint,name=Loggers`

En utilisant un client JMX comme JConsole, vous pouvez naviguer dans l'arborescence des MBeans jusqu'à trouver ceux d'Actuator. Vous pouvez ensuite inspecter leurs attributs (qui correspondent souvent aux données retournées par l'endpoint HTTP) et invoquer leurs opérations. Par exemple, le MBean `Health` a une opération `health()` qui retourne les détails de santé, et le MBean `Loggers` a des opérations comme `getLogLevel(String loggerName)` et `setLogLevel(String loggerName, String level)`.

Si vous souhaitez limiter les endpoints exposés via JMX, vous pouvez utiliser les propriétés `management.endpoints.jmx.exposure.include` et `management.endpoints.jmx.exposure.exclude`, de manière similaire à la configuration HTTP. Par exemple, pour n'exposer que `health` et `info` via JMX :

management.endpoints.jmx.exposure.include=health,info
management.endpoints.jmx.exposure.exclude=*

L'accès JMX est particulièrement utile dans les environnements où l'accès réseau direct via HTTP aux instances d'application est restreint ou non souhaité pour des raisons de sécurité. Il s'intègre bien avec les plateformes de gestion Java existantes et ne nécessite pas l'ouverture de ports HTTP supplémentaires dédiés à la gestion.

Configurer et choisir la méthode d'accès

Spring Boot offre une configuration fine pour contrôler l'exposition des endpoints sur les deux canaux. Les propriétés clés résident sous `management.endpoints.web.exposure.*` pour HTTP et `management.endpoints.jmx.exposure.*` pour JMX. Vous pouvez choisir d'exposer tous les endpoints (`*`), aucun (en excluant `*`), ou une liste spécifique d'endpoints.

Il est tout à fait possible d'avoir les deux méthodes d'accès activées simultanément, avec potentiellement des ensembles d'endpoints différents exposés sur chaque canal. Par exemple, vous pourriez exposer uniquement `health` via HTTP pour un load balancer, tout en exposant un ensemble plus large d'endpoints via JMX pour une surveillance interne détaillée.

Le choix dépend de vos besoins :

• Privilégiez HTTP si vous développez une application web standard, si vous utilisez des outils de monitoring modernes basés sur HTTP (Prometheus, Grafana, Datadog Agent), ou si vous avez besoin d'un accès simple via navigateur ou cURL. N'oubliez pas la sécurité !
• Privilégiez JMX si l'exposition HTTP est une préoccupation de sécurité, si vous utilisez déjà des outils de monitoring basés sur JMX, ou pour des applications non-web où le serveur HTTP n'est pas le composant principal.

En comprenant ces deux modes d'accès et leur configuration, vous pouvez adapter la manière dont votre application Spring Boot expose ses informations opérationnelles pour s'intégrer au mieux à votre infrastructure et à vos pratiques de monitoring.