Lección 148: Integración de Docker con Spring Boot para la contenedorización de aplicaciones

Antes de meternos en el código, vamos a entender por qué Docker es tan importante. Imagina que tu proyecto Spring Boot funciona perfecto en tu máquina local, pero en el servidor empieza a "portarse mal": no es la versión de Java correcta, no están instaladas las librerías necesarias, o igual el servidor se fue a tomar un café. Docker resuelve esos problemas, creando contenedores que autosuficientes, portátiles y predecibles.

Ahora que estás listo para convertir tu proyecto Spring Boot en un contenedor, vamos con la parte práctica.

Configuración de Docker para Spring Boot

Para integrar Spring Boot con Docker necesitaremos unos pasos clave. Todo empieza creando un Dockerfile.

Paso 1: Crear el Dockerfile

El Dockerfile es un archivo "mágico" que le dice a Docker cómo empaquetar tu aplicación. Dentro indicamos la imagen base (por ejemplo, openjdk), copiamos tu JAR y le decimos a Docker cómo ejecutar la app.

Así se vería el Dockerfile mínimo para Spring Boot:

# Usamos la imagen base con Java 17 (o tu versión)
FROM eclipse-temurin:17-jdk

# Indicamos el directorio de trabajo dentro del contenedor
WORKDIR /app

# Copiamos el archivo JAR al contenedor
COPY target/your-app-name-1.0.0.jar app.jar

# Indicamos el comando para ejecutar la aplicación
ENTRYPOINT ["java", "-jar", "app.jar"]

• FROM: la imagen base para el contenedor (en este caso, OpenJDK).
• WORKDIR: define el directorio de trabajo dentro del contenedor.
• COPY: mueve archivos desde tu proyecto local al contenedor.
• ENTRYPOINT: indica el comando que se ejecuta cuando arranca el contenedor.

Ten en cuenta: target/your-app-name-1.0.0.jar es tu JAR compilado, generado previamente con Maven (mvn package).

Paso 2: Construir la imagen Docker

Una vez que el Dockerfile está listo, vamos a crear la imagen Docker. La imagen es la "versión empaquetada" de tu aplicación, que contiene todo lo necesario:

docker build -t your-app-name:1.0.0 .

• -t your-app-name:1.0.0: le da nombre y versión a tu imagen.
• .: indica el directorio actual donde está el Dockerfile.

Si todo fue bien, deberías ver algo como:

Successfully built <image-id>

Para comprobar que la imagen se creó, usa:

docker images

Paso 3: Ejecutar el contenedor

Ahora que tenemos la imagen, podemos lanzar el contenedor. Se hace así:

docker run -p 8080:8080 your-app-name:1.0.0

• -p 8080:8080: mapea el puerto de tu máquina local al contenedor. Por ejemplo, tu aplicación Spring Boot atiende peticiones en localhost:8080.
• your-app-name:1.0.0: la imagen que acabamos de crear.

Después de ejecutar ese comando, la aplicación debería estar disponible en http://localhost:8080.

Práctica: Mejorar el Dockerfile

El Dockerfile mínimo es suficiente para empezar, pero podemos mejorarlo.

Las imágenes Docker se pueden optimizar para ocupar menos espacio. Para eso se usa la técnica "multi-stage build".

Aquí tienes un Dockerfile mejorado:

# Primera etapa: construir la aplicación
FROM maven:3.8.7-eclipse-temurin-17 AS builder

WORKDIR /build
COPY pom.xml ./
COPY src ./src

RUN mvn clean package -DskipTests

# Segunda etapa: crear la imagen mínima
FROM eclipse-temurin:17-jre

WORKDIR /app
COPY --from=builder /build/target/your-app-name-1.0.0.jar app.jar

ENTRYPOINT ["java", "-jar", "app.jar"]

Qué ocurre aquí:

1. Primera etapa: bajamos maven, compilamos el proyecto (sin tests, para acelerar).
2. Segunda etapa: usamos una imagen ligera jre (solo la JVM, sin herramientas de desarrollo), copiamos el JAR compilado al contenedor.

Este enfoque reducirá el tamaño final de la imagen, ya que Maven y el código fuente no estarán en la imagen final.

Práctica: Crear y probar el contenedor

Ciclo completo:

1. Crea el JAR de tu aplicación:

   
   mvn clean package
   

2. Construye la imagen:

   
   docker build -t your-app-name:1.0.0 .
   

3. Arranca el contenedor:

   
   docker run -p 8080:8080 your-app-name:1.0.0
   

Ahora puedes probar la aplicación en el navegador o con Postman.

Trabajo con variables de entorno

En aplicaciones reales a menudo hace falta configurar parámetros (por ejemplo, la conexión a la base de datos). En vez de incrustarlos en el código, es mejor usar variables de entorno.

Actualicemos el Dockerfile para manejar variables de entorno:

ENV SPRING_PROFILES_ACTIVE=prod

ENTRYPOINT ["java", "-jar", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "app.jar"]

Ahora el perfil activo de Spring puede configurarse a través de la variable SPRING_PROFILES_ACTIVE. Por ejemplo:

docker run -p 8080:8080 -e SPRING_PROFILES_ACTIVE=dev your-app-name:1.0.0

Errores típicos y cómo evitarlos

1. Error: "Connection refused" al intentar acceder al contenedor. Esto pasa si no has mapeado los puertos. Asegúrate de especificar -p 8080:8080 al arrancar.
2. Error: "No such file or directory" al ejecutar el contenedor. Comprueba que la ruta al JAR en el COPY del Dockerfile sea correcta.
3. Imagen demasiado grande. Usa multi-stage build como se describió arriba.
4. La aplicación no encuentra la base de datos. Configura variables de entorno para que la app pueda conectarse a recursos externos, por ejemplo a la base de datos.

¿Cómo ayuda Docker en la vida real?

• En las entrevistas: saber crear contenedores y trabajar con Dockerfile es un must-have para los desarrolladores modernos.
• En proyectos: usando Docker puedes levantar rápidamente tanto entornos locales como entornos de producción.
• En microservicios: cada microservicio puede correr en su propio contenedor. Actualizar, escalar y gestionar se vuelve más fácil.

Si consigues dominar Docker y la integración con Spring Boot, te volverás imprescindible para el equipo! Prepárate para usar estos conocimientos en futuras lecciones sobre despliegue en la nube y arquitectura de microservicios.