GraalVM Native Image : ce que ça change pour un microservice Spring Boot
AOT, indications d'exécution, build, ramasse-miettes, tests et méthode de mesure : tout ce qu'il faut savoir avant de passer en natif.
Compiler un microservice Spring Boot en exécutable natif avec GraalVM est devenu accessible : Spring Boot le prend en charge officiellement depuis la version 3. Mais ce n’est pas un simple drapeau à activer. C’est un changement de modèle d’exécution, avec de vrais gains, de vraies contraintes, et des pièges qu’il vaut mieux connaître avant de s’engager.
Le contexte
Sur la refonte d’une plateforme télécom de messagerie vocale, découpée en microservices Spring Boot sur Kubernetes, la latence et la consommation de ressources faisaient partie des objectifs. GraalVM Native Image a été l’un des leviers étudiés et mis en œuvre, aux côtés du tuning JVM et d’un cache distribué.
JVM ou natif : ce qui change vraiment
Sur la JVM, le code est chargé, interprété puis compilé pendant l’exécution par le compilateur JIT, qui optimise les chemins les plus utilisés. En natif, tout est compilé avant l’exécution (AOT) en un exécutable autonome qui n’embarque pas de JVM.
| JVM (JIT) | Native Image (AOT) | |
|---|---|---|
| Démarrage | Quelques secondes | Quelques dizaines de millisecondes |
| Mémoire au repos | Élevée (JVM, métadonnées, JIT) | Faible |
| Performance au démarrage | Faible, puis montée en charge | Maximale dès la première requête |
| Débit de pointe sur la durée | Très bon une fois « chaud » | Bon, souvent un peu inférieur |
| Code dynamique | Libre | Doit être déclaré au build |
| Temps de build | Court | Long et gourmand en mémoire |
Sur Kubernetes, les avantages du natif se traduisent par une mise à l’échelle plus rapide, des pods moins gourmands et des sondes de démarrage qui passent presque immédiatement.
Comment Spring prépare une application native
La compilation native repose sur une hypothèse de monde fermé : tout le code exécuté doit être connu au moment du build. Spring s’y adapte avec une étape de traitement AOT (process-aot), qui, au moment du build :
- évalue la configuration et génère le code Java des définitions de beans, au lieu de les découvrir par réflexion au démarrage ;
- génère les métadonnées dont GraalVM a besoin : réflexion, proxies, ressources, sérialisation.
Conséquence importante et souvent découverte trop tard : les conditions sont figées au build. Les @Profile et @ConditionalOnProperty qui ajoutent ou retirent des beans sont évalués à la compilation. On peut toujours changer la valeur d’une propriété à l’exécution, mais pas l’ensemble des beans présents. Un exécutable natif correspond donc à une configuration donnée.
Mettre en place le build
Avec le parent Spring Boot, le profil Maven native est déjà prêt ; il suffit d’ajouter le plugin GraalVM :
<build>
<plugins>
<plugin>
<groupId>org.graalvm.buildtools</groupId>
<artifactId>native-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
Trois façons de construire, selon le besoin :
# Exécutable natif local (nécessite GraalVM installé)
./mvnw -Pnative native:compile
# Image de conteneur native via Buildpacks (seul Docker est nécessaire)
./mvnw -Pnative spring-boot:build-image
# Tests exécutés en mode natif
./mvnw -PnativeTest test
La compilation native demande plusieurs gigaoctets de mémoire et plusieurs minutes. On la réserve à la CI, sur des runners correctement dimensionnés, et on garde la JVM pour le développement quotidien, plus rapide à recompiler.
Déclarer ce qui est dynamique
Spring génère automatiquement la plupart des métadonnées. Le reste concerne surtout les bibliothèques qui utilisent la réflexion, les ressources chargées par nom et les objets sérialisés.
Pour les DTO sérialisés en JSON sans être exposés par un contrôleur, une annotation suffit :
@Configuration
@RegisterReflectionForBinding({VoicemailEvent.class, NotificationPayload.class})
class NativeConfig { }
Pour les cas plus fins, on implémente un RuntimeHintsRegistrar :
public class AppRuntimeHints implements RuntimeHintsRegistrar {
@Override
public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
hints.reflection().registerType(VoicemailEvent.class, MemberCategory.values());
hints.resources().registerPattern("templates/*.xml");
}
}
@SpringBootApplication
@ImportRuntimeHints(AppRuntimeHints.class)
public class VoicemailApplication { /* … */ }
Quand on ne sait pas ce qu’une bibliothèque fait dynamiquement, l’agent de traçage de GraalVM l’observe pendant une exécution réelle sur la JVM et produit la configuration correspondante :
java -agentlib:native-image-agent=config-output-dir=src/main/resources/META-INF/native-image \
-jar target/voicemail-service.jar
On fait tourner les tests ou un scénario représentatif, puis on relit la configuration générée avant de la versionner : l’agent ne voit que les chemins effectivement exécutés.
Les pièges rencontrés en pratique
- Une erreur qui n’apparaît qu’en natif. Un
ClassNotFoundExceptionou un champ JSON vide en production, alors que tout passait sur la JVM : c’est presque toujours une indication manquante. D’où l’importance d’exécuter les tests en mode natif dans la CI. - Des bibliothèques non compatibles. Avant de se lancer, on vérifie chaque dépendance : la plupart des bibliothèques courantes publient leurs métadonnées dans le dépôt communautaire GraalVM Reachability Metadata, mais pas toutes.
- Le ramasse-miettes. GraalVM Community utilise par défaut le Serial GC, adapté aux petits tas et aux conteneurs modestes. Le G1 n’est disponible qu’avec Oracle GraalVM. Pour un service à gros tas et forte allocation, c’est un critère à mesurer. La taille du tas se règle toujours avec
-Xmx. - L’observabilité. Micrometer, les métriques Prometheus et le traçage OpenTelemetry fonctionnent, mais certains outils de diagnostic de la JVM (agents Java, certaines fonctions de JFR) ne sont pas disponibles ou le sont partiellement. À valider avant la production.
Quand ne pas passer en natif
Le natif n’est pas toujours le meilleur choix :
- pour un service qui tourne longtemps sous forte charge, le JIT, une fois chaud, peut atteindre un débit de pointe supérieur à celui du code compilé à l’avance ;
- pour une application très dynamique (plugins chargés à l’exécution, beaucoup de réflexion), le coût de maintenance des indications dépasse vite le gain ;
- quand le problème est surtout le temps de démarrage, il existe des alternatives qui gardent la JVM : CDS (Class Data Sharing), facilité par Spring Boot depuis la version 3.3, ou CRaC, qui restaure une application déjà démarrée à partir d’un instantané.
Mesurer avant de décider
La décision se prend service par service, sur des mesures comparables entre la version JVM et la version native :
- Même charge, générée par un outil comme Gatling ou k6, avec un scénario représentatif.
- Même environnement : mêmes limites CPU et mémoire de pod qu’en production.
- Quatre indicateurs : temps de démarrage (le log
Started … in), mémoire résidente (RSS) au repos et sous charge, latence au 95e et 99e centile, débit maximal soutenu. - Sur la durée : au moins quinze minutes de charge, pour laisser la JVM atteindre son régime de croisière.
Si le natif gagne nettement sur le démarrage et la mémoire sans perdre sur la latence et le débit, il est justifié. Sinon, la JVM bien réglée reste le choix le plus simple à exploiter.
Le natif est un outil pour un objectif précis : démarrer vite et consommer peu. Ce n’est pas une optimisation gratuite.
Ce que j’en retiens
- Le natif brille pour les services qui doivent démarrer vite, consommer peu et monter en charge souvent.
- Les conditions Spring sont figées au build : un exécutable correspond à une configuration.
- La réflexion et les ressources dynamiques se déclarent, et les tests tournent aussi en mode natif.
- Le build natif appartient à la CI, sur des runners dimensionnés pour.
- La décision se prend service par service, sur des mesures comparables, pas par principe.
Cet article vous a été utile ? Partagez-le.

Architecte et développeur backend senior Java / Spring Boot, 14 ans sur des systèmes critiques en télécoms, banque et mobilité. Basé à Dakar.