Artículo

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 buildSegundos116 s (unos 9 min de CPU repartidos en los núcleos)
Tamaño20 MB (jar) + JVM instalada66 MB (ejecutable, sin JVM)
Arranque (Started DemoApplication in)0,811 s0,034 s
Memoria del proceso (RSS) tras una petición243 MB60 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 @RegisterReflectionForBinding o RuntimeHints.
  • 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 pagaSí
Microservicios con muchas réplicas y escalado a ceroSí
Herramientas de línea de comandosSí
Monolito de larga duración con mucha cargaNormalmente no
Aplicación que usa librerías con reflexión sin soporte nativoNo, 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.

graalvm native image spring boot aot rendimiento java

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.

Compartir artículo