Crear Imagen de Docker Desde una Aplicación Java

1. Introducción

Docker es una buena opción cuando se trata de hacer que las aplicaciones sean desplegables en diferentes entornos. En este tutorial, aprenderemos a empaquetar nuestras aplicaciones Java en una imagen de Docker que pueda ejecutarse de manera consistente en cualquier lugar.

Usaremos nuestra aplicación de carga de archivos creada previamente y la configuraremos para generar un archivo JAR ejecutable. Luego, lo empaquetaremos en una imagen de Docker.

Empecemos.

2. Configuración de Nuestro Proyecto Java

Para este tutorial, utilizaremos Maven para gestionar las dependencias y los procesos de construcción de nuestro proyecto.

2.1 Configuración de Maven (pom.xml)

Primero, configuremos nuestro archivo pom.xml para empaquetar el archivo jar junto con todas sus dependencias. Para esto, utilizaremos el maven-assembly-plugin que se añadirá a nuestros plugins bajo la sección <build>:

<plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.5.0</version>
    <configuration>
        <archive>
            <manifest>
                <mainClass>com.namastecode.SpringBoot3ThymeleafApplication</mainClass>
            </manifest>
        </archive>
        <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
                <goal>single</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Desglosemos las partes importantes:

• <mainClass> especifica el punto de entrada de nuestra aplicación.
• <descriptorRefs> configurado con jar-with-dependencies empaquetará nuestra aplicación y todas sus dependencias en un solo archivo JAR.
• <execution> le indica a Maven que se ejecute durante la fase de package del ciclo de vida de Maven.

Ahora, cuando ejecutamos mvn package, Maven creará dos archivos JAR en el directorio target - uno con dependencias y otro sin. El JAR con dependencias tendrá un sufijo jar-with-dependencies.

Podemos probar que la aplicación se ejecuta correctamente usando el comando:

java -jar target/spring-boot-3-thymeleaf-0.0.1-SNAPSHOT-jar-with-dependencies.jar

Ahora estamos listos para crear una imagen de Docker.

3. Dockerizar Aplicación Java

Los contenedores son una excelente manera de empaquetar aplicaciones Java. Proporcionan un entorno consistente para ejecutar aplicaciones, sin importar dónde se desplieguen. Veamos cómo crear una imagen de Docker para nuestra aplicación Java.

3.1 Crear Dockerfile

Comenzamos añadiendo un Dockerfile en la raíz de nuestro proyecto:

spring-boot-3-thymeleaf/
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/namastecode/
|   |           |   -- Other files        
│   │           └── SpringBoot3ThymeleafApplication.java
│   └── test/
│       └── java/
├── pom.xml
└── Dockerfile

Un Dockerfile es simplemente un archivo de texto que contiene instrucciones para que Docker ensamble una imagen. Cada instrucción crea una nueva capa inmutable que se basa en la anterior.

Comenzaremos definiendo nuestra imagen base y el directorio de trabajo donde queremos colocar nuestra aplicación dentro del contenedor. Luego, copiaremos el archivo JAR y añadiremos las instrucciones para ejecutarlo:

FROM eclipse-temurin:23-jre-alpine

WORKDIR /app

COPY target/spring-boot-3-thymeleaf-0.0.1-SNAPSHOT-jar-with-dependencies.jar app.jar

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

Para nuestra imagen base, estamos utilizando eclipse-temurin:23-jre-alpine, que es una versión ligera del JRE (Java Runtime Environment) basada en Alpine Linux. Esta es una opción ideal para ejecutar aplicaciones Java en un contenedor cuando no se requieren dependencias específicas.

Definimos /app como el directorio de trabajo dentro del contenedor. Aquí es donde nuestra aplicación será copiada utilizando el comando COPY. Finalmente, establecemos el entrypoint para ejecutar nuestra aplicación con el comando java -jar. El entrypoint es el comando que se ejecutará cuando el contenedor se inicie.

3.2 Crear una Imagen de Docker

Ahora, ejecutamos el comando build para crear una nueva imagen desde la raíz de nuestro proyecto:

docker build -t spring-boot-3-thymeleaf .

Después de que se crea la imagen, podemos simplemente ejecutar docker image ls para verificar que la imagen se construyó correctamente.

3.3 Ejecutando la Imagen de Docker

Finalmente, ejecutemos nuestra aplicación Java Dockerizada:

docker run -p 8090:8090 spring-boot-3-thymeleaf:latest

Esto iniciará un nuevo contenedor y ejecutará nuestra aplicación Java dentro de él. Deberíamos ver los registros de nuestra aplicación Spring Boot en la terminal. Además, estamos mapeando el puerto 8090 en el host al puerto 8090 en el contenedor, que es el puerto que nuestra aplicación Spring Boot expone. Para verificar que la aplicación está en funcionamiento, podemos visitar http://localhost:8090 en nuestro navegador web.

4. Conclusión

En este tutorial, aprendimos cómo crear una imagen de Docker a partir de una aplicación Java. Comenzamos configurando nuestro proyecto de Maven para empaquetar la aplicación con sus dependencias, luego creamos un Dockerfile para definir la imagen y, finalmente, construimos y ejecutamos la imagen de Docker.

Puedes encontrar el código completo en GitHub.