Spring Boot con GraalVM Native Image: arranque en milisegundos
Cómo compilar Spring Boot 4 a ejecutable nativo con GraalVM: configuración, comando, y la comparación medida de arranque, memoria y tamaño frente a la JVM.
En resumen: GraalVM compila tu aplicación Spring Boot a un ejecutable nativo que no necesita JVM. En nuestra prueba arrancó en 0,034 s frente a 0,811 s con la JVM y usó 60 MB de memoria frente a 243 MB. A cambio, la compilación tardó casi 2 minutos, el binario solo funciona en el sistema donde se compila y la reflexión dinámica necesita configuración. Compensa en serverless, CLIs y servicios con muchas réplicas. Probado con Spring Boot 4.1.2 y GraalVM CE para Java 25.
Vídeo explicativo
Qué cambia
En la JVM, tu código se carga, se interpreta y el compilador JIT optimiza lo que más se usa mientras la aplicación corre. Con Native Image, todo eso ocurre antes, al compilar (AOT, ahead-of-time): GraalVM analiza qué código es alcanzable, descarta el resto y genera código máquina. Spring Boot colabora con su motor AOT, que en tiempo de build calcula los beans y genera la configuración que GraalVM necesita.
La aplicación
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
record Saludo(String mensaje, String runtime) {}
@RestController
class SaludoController {
@GetMapping("/hola/{nombre}")
Saludo hola(@PathVariable String nombre) {
String runtime = System.getProperty("org.graalvm.nativeimage.imagecode") != null ? "nativo" : "JVM";
return new Saludo("Hola, " + nombre, runtime);
}
}
En el pom.xml, con spring-boot-starter-parent como padre, basta con añadir el plugin de GraalVM (la versión la gestiona el padre):
<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>
Compilar
Necesitas un JDK de GraalVM con native-image y que JAVA_HOME apunte a él:
./mvnw -Pnative native:compile
El perfil native lo define el padre de Spring Boot. El resultado es target/<artifactId>, un ejecutable que lanzas directamente: ./target/native-demo. Si no quieres instalar GraalVM, ./mvnw -Pnative spring-boot:build-image genera una imagen Docker nativa usando Buildpacks.
Lo que medimos
Misma aplicación, mismo portátil (Apple Silicon, 10 núcleos):
JVM (java -jar) | Nativo | |
|---|---|---|
| Tiempo de build | Segundos | 116 s (unos 9 min de CPU repartidos en los núcleos) |
| Tamaño | 20 MB (jar) + JVM instalada | 66 MB (ejecutable, sin JVM) |
Arranque (Started DemoApplication in) | 0,811 s | 0,034 s |
| Memoria del proceso (RSS) tras una petición | 243 MB | 60 MB |
Respuesta de /hola/ana | {"mensaje":"Hola, ana","runtime":"JVM"} | {"mensaje":"Hola, ana","runtime":"nativo"} |
El arranque es 24 veces más rápido y la memoria cuatro veces menor. Son cifras de una aplicación mínima; en una real con JPA y seguridad los dos tiempos crecen, pero la proporción suele mantenerse.
Las limitaciones
- Mundo cerrado: GraalVM tiene que saber en tiempo de build qué clases se usan. La reflexión, los proxies dinámicos y los recursos cargados por nombre necesitan hints. Spring genera los suyos; para tus casos especiales existe
@RegisterReflectionForBindingoRuntimeHints. - Librerías: la mayoría del ecosistema Spring funciona, pero alguna librería con mucha reflexión puede fallar en ejecución, no al compilar. Prueba con
./mvnw -PnativeTest test. - Sin JIT en ejecución: para procesos largos con mucha carga, la JVM puede alcanzar más rendimiento máximo porque optimiza con datos reales.
- Un binario por plataforma: el ejecutable de macOS no funciona en Linux. Compila en CI o en Docker para el destino final.
- Builds lentos y con mucha memoria: no es algo para cada cambio en local; desarrolla en la JVM y compila nativo en el pipeline.
Cuándo usarlo
| Caso | ¿Nativo? |
|---|---|
| Funciones serverless (AWS Lambda, Cloud Run) donde el arranque se paga | Sí |
| Microservicios con muchas réplicas y escalado a cero | Sí |
| Herramientas de línea de comandos | Sí |
| Monolito de larga duración con mucha carga | Normalmente no |
| Aplicación que usa librerías con reflexión sin soporte nativo | No, o con trabajo extra |
Una alternativa intermedia es la caché AOT de la propia JVM (Java 25 trae mejoras en ese sentido), que acelera el arranque sin renunciar al JIT. La vemos en las novedades de Java 25.
Preguntas frecuentes
¿Necesito cambiar mi código?
En una aplicación Spring Boot normal, casi nunca. Los cambios suelen limitarse a añadir hints para reflexión propia o a sustituir alguna librería incompatible.
¿GraalVM es solo para nativo?
No. También es un JDK completo con un compilador JIT alternativo. Lo comparamos con otras distribuciones en JDK, JRE y JVM.
¿Quarkus o Spring Boot para nativo?
Quarkus nació pensando en nativo y suele ir algo por delante en tiempos; Spring Boot ha recortado mucha distancia. Lo comparamos en Spring Boot vs Quarkus.
Sigue aprendiendo
El despliegue de servicios Spring Boot en contenedores y en la nube se trabaja en el curso de Spring Boot Cloud. Para empaquetar la versión JVM, tienes Spring Boot con Docker.
Newsletter Semanal de Java
Cada viernes recibe lo más nuevo del ecosistema Java: frameworks, herramientas y mejores prácticas.
Sin spam. Cancela cuando quieras.