Docker y Java: Contenerización de aplicaciones — Guía completa

Introducción a Docker y Java: por qué la contenedorización cambia el desarrollo

El desarrollo de software moderno es impensable sin la contenedorización. Docker se ha convertido en el estándar de facto para empaquetar, distribuir y ejecutar aplicaciones. Para los desarrolladores de Java, el uso de Docker resuelve problemas clave: "funciona en mi máquina" y las dificultades con la configuración del entorno. En este artículo, analizaremos cómo contenedorizar aplicaciones Java, desde un simple archivo JAR hasta un microservicio complejo en Spring Boot.

Docker permite aislar la aplicación junto con sus dependencias (JVM, bibliotecas, utilidades del sistema) en un contenedor ligero y portátil. Esto es especialmente importante para Java, donde la versión del JDK, la configuración de memoria y las bibliotecas del sistema pueden influir enormemente en el comportamiento del programa.

Qué aprenderá en este artículo

• Creación de Dockerfile para aplicaciones Java
• Optimización del tamaño de las imágenes
• Trabajo con proyectos multimódulo de Maven/Gradle
• Mejores prácticas de seguridad y rendimiento

1. Fundamentos: creación de un Dockerfile para una aplicación Java

Empecemos con un ejemplo sencillo. Supongamos que tiene una aplicación Java compilada en un archivo JAR. Este es el Dockerfile mínimo que la empaquetará en un contenedor:

# Usamos la imagen oficial de OpenJDKFROM openjdk:17-jdk-slim

# Establecemos el directorio de trabajoWORKDIR /app

# Copiamos el archivo JAR al contenedorCOPY target/myapp.jar app.jar

# Abrimos el puerto que escucha la aplicaciónEXPOSE 8080

# Comando para ejecutarENTRYPOINT ["java", "-jar", "app.jar"]

Este Dockerfile hace tres cosas simples: toma una imagen base con JDK 17, copia el JAR compilado y lo ejecuta. Sin embargo, en proyectos reales, este enfoque no es eficiente: cada vez que se modifica el código, Docker reconstruye toda la imagen, incluida la copia del JAR.

Compilación multi-etapa (Multi-stage build)

Para separar las etapas de compilación y ejecución, use Dockerfile multi-etapa. Esto reduce la imagen final, excluyendo las herramientas de compilación (Maven, Gradle, JDK para compilación).

# Etapa de compilaciónFROM maven:3.9.6-eclipse-temurin-17 AS builderWORKDIR /buildCOPY pom.xml .RUN mvn dependency:go-offlineCOPY src ./srcRUN mvn clean package -DskipTests

# Etapa finalFROM openjdk:17-jdk-slimWORKDIR /appCOPY --from=builder /build/target/*.jar app.jarEXPOSE 8080ENTRYPOINT ["java", "-jar", "app.jar"]

La primera etapa usa una imagen completa de Maven para compilar, la segunda usa una imagen JRE mínima para ejecutar. La imagen final pesa ~200 MB en lugar de 700+ MB.

2. Optimización de imágenes: reducimos el tamaño y aceleramos la compilación

Las imágenes grandes ralentizan el despliegue y aumentan el tiempo de carga. Aquí hay varias técnicas para Java:

Use JLink para crear una JRE mínima

A partir de Java 9, puede crear una JRE personalizada que contenga solo los módulos necesarios. Esto reduce drásticamente el tamaño de la imagen.

FROM openjdk:17-jdk-slim AS jre-builderRUN jlink \    --add-modules java.base,java.logging,java.sql \    --strip-debug \    --no-man-pages \    --no-header-files \    --compress=2 \    --output /jre

FROM debian:bookworm-slimCOPY --from=jre-builder /jre /jreWORKDIR /appCOPY target/myapp.jar app.jarENV PATH="/jre/bin:${PATH}"ENTRYPOINT ["java", "-jar", "app.jar"]

Una imagen así puede pesar solo 40-60 MB en lugar de 200+ MB.

Almacenamiento en caché de capas de Docker

Docker almacena en caché cada capa. Para acelerar la compilación, coloque los archivos que cambian con poca frecuencia (dependencias) al principio del Dockerfile y los que cambian con frecuencia (código fuente) al final.

FROM maven:3.9.6-eclipse-temurin-17 AS builderWORKDIR /build# Primero copiamos solo el pom.xml y descargamos las dependenciasCOPY pom.xml .RUN mvn dependency:go-offline# Luego copiamos los fuentes y compilamosCOPY src ./srcRUN mvn clean packag