Spring Boot Actuator est un sous-projet de Spring Boot qui fournit des fonctionnalités prêtes pour la production pour vous aider à surveiller et gérer votre application. Il offre un ensemble de points de terminaison intégrés qui vous permettent d'obtenir des informations sur la santé, les métriques et l'environnement de votre application, ainsi que de la contrôler de manière dynamique.

Qu’est-ce que l’actionneur Spring Boot ?

Spring Boot Actuator fournit plusieurs points de terminaison prêts à l'emploi qui peuvent être utilisés pour surveiller et interagir avec votre application. Ces points de terminaison sont accessibles via HTTP, JMX ou à l'aide de Spring Boot Admin.

Principales caractéristiques de l'actionneur Spring Boot

1. Vérifications de santé : surveillez la santé de votre application et de ses dépendances.
2. Métriques : collectez diverses métriques telles que l'utilisation de la mémoire, le garbage collection, les détails des requêtes Web, etc.
3. Informations sur l'environnement : accédez aux propriétés de l'environnement de l'application.
4. Informations sur l'application : récupérez des informations sur la version de l'application, telles que la version et le nom.
5. Niveaux de journalisation dynamiques : modifiez les niveaux de journalisation sans redémarrer l'application.
6. Traçage HTTP : tracez les requêtes HTTP.

Configuration de l'actionneur Spring Boot

1. Ajout d'une dépendance d'actionneur

Pour utiliser Actuator dans votre application Spring Boot, vous devez ajouter la dépendance Actuator à votre fichier pom.xml :

org.springframework.bootspring-boot-starter-actuator

Si vous utilisez Gradle, ajoutez ce qui suit à votre fichier build.gradle :

implementation 'org.springframework.boot:spring-boot-starter-actuator'

2. Activation des points de terminaison de l'actionneur

Par défaut, seuls quelques points de terminaison sont activés. Vous pouvez activer des points de terminaison supplémentaires dans votre fichier application.yml :

management:
  endpoints:
    web:
      exposure:
        include: "*"  # This exposes all available endpoints
  endpoint:
    health:
      show-details: always  # Show detailed health information

Utilisation des points de terminaison de l'actionneur

Une fois Actuator configuré, vous pouvez accéder aux différents points de terminaison fournis par celui-ci. Voici quelques points de terminaison couramment utilisés :

1. Point final de santé

Le point de terminaison /actuator/health fournit des informations sur l'état de santé de votre application :

GET http://localhost:8080/actuator/health

Exemple de réponse :

{
  "status": "UP",
  "components": {
    "db": {
      "status": "UP",
      "details": {
        "database": "H2",
        "result": 1
      }
    },
    "diskSpace": {
      "status": "UP",
      "details": {
        "total": 499963174912,
        "free": 16989374464,
        "threshold": 10485760,
        "exists": true
      }
    }
  }
}

2. Point final des métriques

Le point de terminaison /actuator/metrics fournit diverses métriques liées à votre application :

GET http://localhost:8080/actuator/metrics

Exemple de réponse :

{
  "names": [
    "jvm.memory.used",
    "jvm.gc.pause",
    "system.cpu.usage",
    "system.memory.usage",
    "http.server.requests"
  ]
}

Pour obtenir des détails sur une statistique spécifique :

GET http://localhost:8080/actuator/metrics/jvm.memory.used

Exemple de réponse :

{
  "name": "jvm.memory.used",
  "description": "The amount of used memory",
  "baseUnit": "bytes",
  "measurements": [
    {
      "statistic": "VALUE",
      "value": 5.1234567E7
    }
  ],
  "availableTags": [
    {
      "tag": "area",
      "values": [
        "heap",
        "nonheap"
      ]
    },
    {
      "tag": "id",
      "values": [
        "PS Eden Space",
        "PS Survivor Space",
        "PS Old Gen",
        "Metaspace",
        "Compressed Class Space"
      ]
    }
  ]
}

3. Point final de l'environnement

Le point de terminaison /actuator/env fournit des informations sur les propriétés de l'environnement :

GET http://localhost:8080/actuator/env

Exemple de réponse :

{
  "activeProfiles": [],
  "propertySources": [
    {
      "name": "systemProperties",
      "properties": {
        "java.runtime.name": {
          "value": "Java(TM) SE Runtime Environment"
        },
        "java.vm.version": {
          "value": "25.181-b13"
        }
      }
    },
    {
      "name": "systemEnvironment",
      "properties": {
        "PATH": {
          "value": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        },
        "HOME": {
          "value": "/root"
        }
      }
    }
  ]
}

4. Point de terminaison d'informations

Le point de terminaison /actuator/info fournit des informations sur l'application :

GET http://localhost:8080/actuator/info

Pour personnaliser les informations, ajoutez des propriétés dans votre application.yml :

info:
  app:
    name: My Spring Boot Application
    description: This is a sample Spring Boot application
    version: 1.0.0

Sécurisation des points de terminaison de l'actionneur

Par défaut, tous les points de terminaison Actuator sont accessibles sans authentification. Pour sécuriser ces points de terminaison, vous pouvez utiliser Spring Security. Ajoutez la dépendance Spring Security à votre pom.xml :

org.springframework.bootspring-boot-starter-security

Mettez à jour votre application.yml pour restreindre l'accès :

management:
  endpoints:
    web:
      exposure:
        include: "*"  # Expose all endpoints
  endpoint:
    health:
      show-details: always  # Show detailed health information

spring:
  security:
    user:
      name: admin  # Default username
      password: admin  # Default password

# Restrict actuator endpoints to authenticated users
management:
  endpoints:
    web:
      exposure:
        include: "*"
  endpoint:
    health:
      show-details: always
  security:
    enabled: true
    roles: ACTUATOR

Créez une classe de configuration de sécurité pour configurer la sécurité HTTP :

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/actuator/**").hasRole("ACTUATOR")
                .anyRequest().authenticated()
            .and()
            .httpBasic();
    }
}

Avec cette configuration, seuls les utilisateurs authentifiés dotés du rôle ACTUATEUR peuvent accéder aux points de terminaison Actuator.

Personnalisation des points de terminaison de l'actionneur

Vous pouvez créer des points de terminaison d'actionneur personnalisés pour exposer des informations supplémentaires ou des fonctionnalités spécifiques à votre application. Voici un exemple de création d'un point de terminaison personnalisé :

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

@Endpoint(id = "custom")
@Component
public class CustomEndpoint {

    @ReadOperation
    public String customEndpoint() {
        return "Custom Actuator Endpoint";
    }
}

Accédez à votre point de terminaison personnalisé à :

GET http://localhost:8080/actuator/custom

Conclusion

Spring Boot Actuator fournit un ensemble d'outils robustes pour vous aider à surveiller et à gérer votre application. En tirant parti de ses points de terminaison intégrés et de la possibilité de créer des points de terminaison personnalisés, vous pouvez obtenir des informations précieuses sur les performances et la santé de votre application. Sécurisez ces points de terminaison avec Spring Security pour garantir que seuls les utilisateurs autorisés y ont accès, et vous disposerez d'une application prête pour la production, facile à gérer et à surveiller.

Actuator est un élément essentiel de toute application Spring Boot, vous permettant de garder le doigt sur le pouls de l'environnement d'exécution de votre application et de répondre rapidement aux problèmes dès qu'ils surviennent. Commencez à utiliser Spring Boot Actuator dès aujourd’hui pour améliorer l’observabilité et les capacités opérationnelles de votre application.