Empaquetar y desplegar Spring Boot: jar ejecutable, Actuator y Docker

Lección 8 de 8: empaquetar y desplegar. Tu aplicación funciona en tu computadora; ahora hay que llevarla a un servidor. Vas a ver qué hay dentro del jar ejecutable, cómo configurarlo al arrancar, cómo responder a las herramientas que vigilan si está viva con Actuator, cómo meterla en un contenedor de Docker y qué revisar antes de abrirla al público.

Un solo archivo para llevar a cualquier lado

Durante el curso arrancaste la aplicación con ./mvnw spring-boot:run, que compila y ejecuta en un paso. Para llevarla a un servidor se hace otra cosa: se empaqueta en un archivo .jar que contiene todo lo necesario, Tomcat incluido. En el servidor solo hace falta Java:

./mvnw package                 # compila, corre las pruebas y crea target/tienda-0.0.1-SNAPSHOT.jar
java -jar target/tienda-0.0.1-SNAPSHOT.jar

Si alguna prueba falla, package se detiene y no crea el jar; es una red de seguridad que conviene respetar. Para ver qué se creó:

terminal$ du -h target/tienda-0.0.1-SNAPSHOT.jar
22M	target/tienda-0.0.1-SNAPSHOT.jar
$ jar tf target/tienda-0.0.1-SNAPSHOT.jar | grep -E "^META-INF/MANIFEST|^org/springframework/boot/loader/launch/JarLauncher|^BOOT-INF/classes/com/ejemplo/tienda/T|^BOOT-INF/classes/application|^BOOT-INF/lib/spring-(core|webmvc)-|^BOOT-INF/lib/tomcat-embed-core"
META-INF/MANIFEST.MF
org/springframework/boot/loader/launch/JarLauncher.class
BOOT-INF/classes/application.properties
BOOT-INF/classes/com/ejemplo/tienda/TiendaApplication.class
BOOT-INF/lib/spring-core-7.1.0.jar
BOOT-INF/lib/spring-webmvc-7.1.0.jar
BOOT-INF/lib/tomcat-embed-core-11.0.27.jar
$ jar tf target/tienda-0.0.1-SNAPSHOT.jar | grep -c "^BOOT-INF/lib/.*\.jar$"
42
$ jar xf target/tienda-0.0.1-SNAPSHOT.jar META-INF/MANIFEST.MF && grep -E "^(Main-Class|Start-Class|Spring-Boot-Version)" META-INF/MANIFEST.MF
Main-Class: org.springframework.boot.loader.launch.JarLauncher
Start-Class: com.ejemplo.tienda.TiendaApplication
Spring-Boot-Version: 4.2.0

Unos 22 MB para una aplicación de un solo controlador: casi todo son las bibliotecas. Es un fat jar (jar gordo): por fuera, un jar normal; por dentro, tu código más otros jars completos. Java no sabe cargar jars dentro de jars, así que Spring Boot agrega su propio lanzador, y el MANIFEST.MF le dice a Java que arranque primero ese lanzador (Main-Class), que a su vez arranca tu clase (Start-Class).

Lo que hay dentro del jar tienda-0.0.1-SNAPSHOT.jar: META-INF/MANIFEST.MF, que dice qué clase arranca; org/springframework/boot/loader, el lanzador de Spring Boot; BOOT-INF/classes, con tu código y tus recursos; y BOOT-INF/lib, con las bibliotecas como jarsLo que hay dentro del jartienda-0.0.1-SNAPSHOT.jarMETA-INF/MANIFEST.MFdice qué clase arrancaorg/springframework/boot/loader/el lanzador de Spring BootBOOT-INF/classes/tu código y tus recursosBOOT-INF/lib/las bibliotecas, como jars
Un fat jar de Spring Boot: tu código, las bibliotecas y el lanzador que las carga. Esquema: decodigo.com.

Configurarlo al arrancar

Todo lo de la lección 4 aplica tal cual al jar: puedes pasar argumentos, variables de entorno o perfiles sin recompilar. Este mismo jar arrancó en el puerto 9090:

java -jar target/tienda-0.0.1-SNAPSHOT.jar --server.port=9090
SPRING_PROFILES_ACTIVE=prod java -jar target/tienda-0.0.1-SNAPSHOT.jar    # Linux y macOS

Actuator: ¿está viva mi aplicación?

En un servidor nadie está mirando el registro todo el día. Las herramientas que vigilan tu aplicación (un balanceador de carga, Kubernetes, un monitor de disponibilidad) necesitan preguntarle cómo está. Spring Boot Actuator agrega endpoints para eso bajo /actuator. Se agrega con la dependencia Spring Boot Actuator (spring-boot-starter-actuator), y en application.properties se elige qué endpoints se publican por web:

spring.application.name=tienda
management.endpoints.web.exposure.include=health,info
management.endpoint.health.probes.enabled=true

De fábrica solo se publica health; aquí agregamos info, y con probes.enabled se activan las sondas de Kubernetes: liveness («¿el proceso sigue vivo?») y readiness («¿ya puede atender peticiones?»). Para que /actuator/info diga qué versión está corriendo, se agrega el objetivo build-info al plugin de Maven:

<plugin>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-maven-plugin</artifactId>
	<executions>
		<execution>
			<goals>
				<goal>build-info</goal>
			</goals>
		</execution>
	</executions>
</plugin>
terminal$ curl -s localhost:9090/
Tienda en línea
$ curl -s localhost:9090/actuator/health
{"groups":["liveness","readiness"],"status":"UP"}
$ curl -s localhost:9090/actuator/health/readiness
{"status":"UP"}
$ curl -s localhost:9090/actuator/info | jq
{
  "build": {
    "artifact": "tienda",
    "name": "tienda",
    "time": "1980-02-01T00:00:00Z",
    "version": "0.0.1-SNAPSHOT",
    "group": "com.ejemplo"
  }
}
$ curl -s -o /dev/null -w "%{http_code}\n" localhost:9090/actuator/env
404

health responde UP si todo está bien; si la aplicación tuviera una base de datos y esta se cayera, respondería DOWN con código 503, y el balanceador dejaría de mandarle tráfico. info dice qué artefacto y qué versión están corriendo, que es lo primero que quieres saber cuando alguien reporta un error. La hora de compilación sale como 1 de febrero de 1980, y no es un error: Maven 3.10 fija esa fecha en todos los proyectos para que dos compilaciones del mismo código den archivos idénticos (lo que se llama compilación reproducible), y build-info la toma de ahí. Y env, que no publicamos, responde 404: no existe para quien pregunta por web. (jq solo le da formato al JSON; si no lo tienes instalado, quítalo de la orden.)

Al detener la aplicación con Ctrl+C o con la señal que mandan los servidores (SIGTERM), Spring Boot no corta las peticiones a la mitad: deja de aceptar nuevas, espera a que terminen las que están en curso y luego se apaga. Es el graceful shutdown, y viene encendido:

registro al detenerla2026-11-22T10:20:22.886-06:00  INFO 166 --- [tienda] [ionShutdownHook] o.s.boot.tomcat.GracefulShutdown         : Commencing graceful shutdown. Waiting for active requests to complete
2026-11-22T10:20:22.891-06:00  INFO 166 --- [tienda] [tomcat-shutdown] o.s.boot.tomcat.GracefulShutdown         : Graceful shutdown complete

Ojo con la seguridad: no publiques todos los endpoints de Actuator

Es muy común encontrar en tutoriales la línea management.endpoints.web.exposure.include=*, que publica todo: las variables de entorno, la configuración, los beans, hasta un volcado de memoria (heapdump). Así se ve con esa línea:

terminal$ curl -s localhost:8080/actuator | jq -r '._links | keys[]' | head -8
beans
conditions
configprops
configprops-prefix
env
env-toMatch
health
health-path
$ curl -s localhost:8080/actuator/env/tienda.clave-api | jq .property
{
  "source": "Config resource 'class path resource [application.properties]' via location 'optional:classpath:/'",
  "value": "******"
}

Spring Boot oculta los valores de env por omisión (salen como ******), pero el resto sigue expuesto, y un heapdump puede contener contraseñas en memoria. En producción publica solo health e info, y si necesitas los demás, protégelos con Spring Security (hay un ejemplo de seguridad básica) o sírvelos en otro puerto con management.server.port que no sea accesible desde internet.

En un contenedor de Docker

Hoy lo más común es desplegar en contenedores. Un contenedor lleva tu jar y el Java exacto que necesita, así que corre igual en tu laptop que en cualquier nube. Este Dockerfile es todo lo que hace falta:

FROM eclipse-temurin:25-jre
RUN useradd --system --no-create-home spring
WORKDIR /app
COPY target/tienda-0.0.1-SNAPSHOT.jar app.jar
USER spring
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]
  • eclipse-temurin:25-jre: una imagen con Java 25. Es el JRE (solo para ejecutar), no el JDK: más pequeña y con menos herramientas que un atacante pudiera aprovechar.
  • useradd y USER spring: la aplicación corre con un usuario sin privilegios, no como root. Si alguien encontrara una falla en tu código, no sería dueño del contenedor.
  • COPY: copia el jar que creó ./mvnw package.

Lo construimos y lo arrancamos en el Docker de nuestra máquina. Para no abrir ningún puerto, lo arrancamos sin red (--network none) y le preguntamos su salud desde otro contenedor que comparte su red; en tu computadora usarías docker run -p 8080:8080 tienda:0.0.1 y abrirías localhost:8080:

terminal (en la máquina con Docker)$ docker build -t tienda:0.0.1 .
[1/4] FROM docker.io/library/eclipse-temurin:25-jre@sha256:4ed132f6832e9804b123e89a849a7b4502756ae64a4ee08ebab939d9d5d0a9fa
[2/4] RUN useradd --system --no-create-home spring
[3/4] WORKDIR /app
[4/4] COPY target/tienda-0.0.1-SNAPSHOT.jar app.jar
naming to docker.io/library/tienda:0.0.1 done
$ docker images tienda --format "{{.Repository}}:{{.Tag}}  {{.Size}}"
tienda:0.0.1  541MB
$ docker run -d --name tienda --network none tienda:0.0.1
f6cbcc8284e6
$ docker logs tienda | grep -E "Starting|Started"
2026-11-22T16:20:32.708Z  INFO 1 --- [tienda] [           main] com.ejemplo.tienda.TiendaApplication     : Starting TiendaApplication v0.0.1-SNAPSHOT using Java 25.0.5.1 with PID 1 (/app/app.jar started by spring in /app)
2026-11-22T16:20:34.058Z  INFO 1 --- [tienda] [           main] com.ejemplo.tienda.TiendaApplication     : Started TiendaApplication in 1.618 seconds (process running for 1.876)
$ docker run --rm --network container:tienda decodigo-springboot:4.2.0 curl -s localhost:8080/actuator/health
{"groups":["liveness","readiness"],"status":"UP"}
$ docker exec tienda id
uid=999(spring) gid=999(spring) groups=999(spring)

La imagen pesa más de 500 MB porque incluye un sistema Ubuntu mínimo y Java completo; tu jar es lo de menos. La última orden confirma que la aplicación corre con el usuario spring, sin privilegios, y no como root.

Sin Dockerfile: buildpacks. Spring Boot también puede crear la imagen sin que escribas un Dockerfile, con ./mvnw spring-boot:build-image. Usa Cloud Native Buildpacks, que eligen el Java, ajustan la memoria y separan las bibliotecas en capas. Necesita Docker y conexión a internet, porque descarga sus herramientas la primera vez; por eso no lo ejecutamos en nuestro entorno sin red, y aquí no hay una salida que no hayamos visto.

Las capas importan en las imágenes: Docker guarda cada capa por separado, y si solo cambió tu código, no vuelve a subir los 22 MB de bibliotecas. Spring Boot ya organiza el jar en capas pensando en eso:

terminal$ java -Djarmode=tools -jar target/tienda-0.0.1-SNAPSHOT.jar list-layers
dependencies
spring-boot-loader
snapshot-dependencies
application

Las bibliotecas cambian poco y van primero; tu código, que cambia en cada versión, va al final. La documentación de Spring Boot explica cómo extraerlas en un Dockerfile de varias etapas con java -Djarmode=tools -jar app.jar extract --layers; para empezar, el Dockerfile sencillo de arriba es suficiente.

El error que te ahorra: «no main manifest attribute»

Alguien limpió el pom.xml y quitó el bloque <build> con el spring-boot-maven-plugin, porque «no parecía hacer nada». Maven sigue creando un jar, pero:

terminal$ du -h target/sin-plugin-0.0.1-SNAPSHOT.jar
4.0K	target/sin-plugin-0.0.1-SNAPSHOT.jar
$ java -jar target/sin-plugin-0.0.1-SNAPSHOT.jar
no main manifest attribute, in target/sin-plugin-0.0.1-SNAPSHOT.jar

Sin el plugin, el jar solo trae tus clases: no tiene el lanzador, ni las bibliotecas, ni dice qué clase arranca. Por eso pesa 4 KB en vez de 22 MB. El plugin es el que convierte ese jar en uno ejecutable, al paso repackage de package. Devuelve el bloque <build> tal como lo genera start.spring.io.

Lista de revisión antes de producción

  • Versión con soporte. Spring Boot 4.2 recibe correcciones gratuitas hasta el 31 de diciembre de 2027; la 4.0, solo hasta el 31 de diciembre de 2026. Actualiza a la última versión de parche (4.2.x) con frecuencia: ahí llegan las correcciones de seguridad.
  • Secretos fuera del código, en variables de entorno o en el gestor de secretos de tu nube (lección 4).
  • Actuator con lo mínimo: health e info.
  • Errores sin detalles internos (lección 6): no actives server.error.include-stacktrace.
  • HTTPS. Lo habitual es que la aplicación hable HTTP dentro del servidor y un proxy como Nginx ponga el certificado hacia afuera; tenemos una guía de Nginx.
  • Un usuario sin privilegios para correr la aplicación, en el servidor y en el contenedor.
  • Base de datos real con migraciones (Flyway) y ddl-auto=validate, nunca create-drop.
  • Seguridad en los endpoints que lo necesiten, con Spring Security.

Retos

Reto 1. Haz que /actuator/info muestre también la sucursal y el correo de soporte, sin escribir código Java.

Ver la solución
info.tienda.sucursal=CDMX centro
info.tienda.soporte=soporte@ejemplo.com
management.info.env.enabled=true
terminal$ curl -s localhost:8080/actuator/info
{"tienda":{"sucursal":"CDMX centro","soporte":"soporte@ejemplo.com"}}

Todas las propiedades que empiezan con info. aparecen en el endpoint, pero solo si activas su fuente con management.info.env.enabled=true; viene apagada de fábrica.

Reto 2. Sin ejecutarlo: en un servidor con 16 núcleos, ¿cuántas copias del jar puedes arrancar en el mismo puerto 8080?

Ver la solución

Una sola: el puerto lo ocupa la primera y la segunda falla con el error de la lección 1. Para correr varias copias en la misma máquina, cada una necesita su puerto (--server.port) y un proxy como Nginx que reparta las peticiones entre ellas. Con contenedores, cada copia tiene su propia red, y es el orquestador (Docker Compose, Kubernetes) el que reparte.

Reto 3. ¿Por qué la imagen de Docker usa el JRE y no el JDK, si el JDK también puede ejecutar el jar?

Ver la solución

Porque en producción no compilas nada: solo ejecutas. El JRE no trae el compilador ni varias herramientas de diagnóstico, así que la imagen es más chica, se descarga más rápido y tiene menos programas que podrían tener una vulnerabilidad. La regla general en contenedores: lleva solo lo que la aplicación necesita para correr.

¿Y ahora qué?

Terminaste el curso: ya sabes crear un proyecto, conectar sus piezas con inyección de dependencias, hacer una API REST con datos en una base, configurarla por ambiente, validar lo que llega, probarla y desplegarla. Para afianzarlo, haz el test y revisa las rarezas, que reúnen los errores que más tiempo hacen perder. Después, los ejemplos resuelven tareas concretas: paginación, subir archivos, consumir otra API, seguridad, caché, tareas programadas y migraciones con Flyway.

Cada proyecto de esta lección se compiló con Spring Boot 4.2.0, Java 25 (Temurin 25.0.5.1) y Maven 3.10.1 en un contenedor limpio y sin acceso a la red, se arrancó y se le hicieron las peticiones que ves con curl antes de publicar la lección; los registros, las respuestas y los errores están copiados de esa ejecución. Las horas de los registros son de la Ciudad de México.