🔍 Qu'est-ce que l'Actuator ?

L'Actuator est une bibliothèque centrale qui expose une série d'endpoints HTTP ou des MBean JMX, vous permettant de :
Monitorer la santé de l'application et ses indicateurs de performance.
Auditer les journaux de runtime et tracer les requêtes.
Collecter des infomrations sur l'environnement (variables d'environnement, propriétés de configuration).
Gérer l'application de manière dynamique (ajuster les niveaux de journalisation, obtenir des informations sur les threads).

C'est un outil indispensable pour les développeurs et les équipes DevOps pour maintenir et surveiller les applications en production.

✨ Fonctionnalités Principales

L'Actuator fournit une variété d'endpoints couvrant les scénarios clés de surveillance et de gestion :

• ✅ Check de santé (/health) : Vérifie rapidement si l'application et ses dépendances critiques (comme la base de données ou les files d'attente) sont opérationnelles.
• 📊 Collecte d'indicateurs (/metrics) : Accède aux métriques JVM (mémoire, threads, GC), ainsi qu'aux statistiques des requêtes HTTP.
• ⚙️ Informations sur l'environnement (/env) : Affiche toutes les variables d'environnement et les propriétés de configuration, aidant à résoudre les problèmes de configuration.
• 📝 Gestion des journaux (/loggers) : Permet de modifier dynamiquement les niveaux de journalisation sans redémarrer l'applicasion.
• 🧵 Analyse des Threads (/threaddump) : Fournit un instantané des threads actuels pour analyser les blocages ou les goulets d'étranglement.
• ℹ️ Informations de l'Application (/info) : Affiche des métadonnées personnalisées comme la version de l'application.
• 📂 Endpoints de Mappage (/mappings) : Liste toutes les correspondances des contrôleurs Spring MVC.
• ➕ Et bien d'autres... comme /beans, /conditions, /httptrace, /scheduledtasks.

⚡ Intégration rapide (avec Maven)

Ajoutez simplement cette dépendance dans votre fichier pom.xml :

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

Configuration de base (dans application.yml ou application.properties)

gestion:
  endpoints:
    web:
      exposition:
        inclure: '*' # Expose tous les endpoints (à utiliser avec précaution en production)
        # Il est recommandé de ne pas exposer tous les endpoints pour des raisons de sécurité
  serveur:
    port: 8081 # Port optionnel pour les endpoints Actuator
  endpoint:
    health:
      afficher-détails: toujours # Affiche les détails des checks de santé

Les endpoints par défaut sont /actuator/health et /actuator/info. Utiliser '\*' pour exposer tous les endpoints est risqué, donc il est préféré de spécifier ceux nécessaires (comme health, info, metrics).

Exemples d'endpoints courants (requêtes HTTP GET)

Santé de l'Application : http://localhost:8080/actuator/health (retourne {"status":"UP"} si tout fonctionne correctement)

Informations de l'Application : http://localhost:8080/actuator/info (nécessite de configurer les propriétés info.\*)

Vue des indicateurs : http://localhost:8080/actuator/metrics (liste tous les noms de métriques)

Indicateur spécifique (comme jvm.memory.used) : http://localhost:8080/actuator/metrics/jvm.memory.used

Configuraton de l'Environnement : http://localhost:8080/actuator/env

Instantané des Threads : http://localhost:8080/actuator/threaddump

Protection des endpoints sensibles : une priorité !

Les endpoints sensibles comme /env ou /threaddump doivent être protégés. Intégrez Spring Security pour renforcer la sécurité :

@Configuration
@EnableWebSecurity
public class ActuatorSecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                // Accès libre pour les endpoints health et info
                .requestMatchers(EndpointRequest.to("health", "info")).permitAll()
                // Les autres endpoints nécessitent le rôle ADMIN
                .requestMatchers(EndpointRequest.toAnyEndpoint()).hasRole("ADMIN")
                // Règles de sécurité pour les autres endpoints...
                .anyRequest().authenticated()
            )
            .httpBasic(Customizer.withDefaults()); // ou d'autres mécanismes d'authentification
        return http.build();
    }
}

Extension : Créer vos propres endpoints

Personnalisez Actuator en ajoutant vos propres fonctionnalités de surveillance :

import org.springframework.boot.actuate.endpoint.annotation.Endpoint;
import org.springframework.boot.actuate.endpoint.annotation.ReadOperation;
import org.springframework.stereotype.Component;

@Component
@Endpoint(id = "maFonctionnalite") // L'ID de l'endpoint, accessible à /actuator/maFonctionnalite
public class MonEndpointPersonnalise {

    @ReadOperation // Correspond à une requête HTTP GET
    public String obtenirStatutMaFonctionnalite() {
        // Implémentez votre logique personnalisée ici
        return "Statut de la fonctionnalité : Opérationnel";
    }

    // Vous pouvez également définir @WriteOperation (POST), @DeleteOperation
}

Avancé : Intégration avec Prometheus et Grafana

Connectez les métriques Actuator avec Prometheus pour une surveillance puissante :

Ajoutez cette dépendance :

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

Configurer l'exposition des métriques pour Prometheus :

gestion:
  endpoints:
    web:
      exposition:
        inclure: health, info, prometheus # Assurez-vous d'inclure prometheus

Accéder aux métriques Prometheus : http://localhost:8080/actuator/prometheus

Configurer Prometheus pour collecter ces données et utiliser Grafana pour créer des tableaux de bord visuels.

Conclusion

Spring Boot Actuator est un pilier pour construire des applications robustes et observables. Il offre :

• Des fonctionnalités de surveillance prêtes à l'emploi pour la production.
• Une variété d'endpoints pour répondre aux besoins essentiels.
• Une capacité d'extension et d'intégration flexible.
• Une intégration nativement supportée avec les outils de surveillance cloud natives comme Prometheus et Grafana.

Intégrez Actuator maintenant pour doter vos applications d'une "vue interne" et améliorer leur stabilité et leur facilité de maintenance !