Simplifica la Contenerización de Aplicaciones Java con Jib

/ Java, Spring / Por

Cómo Simplificar la Contenerización de Aplicaciones Java con Jib

¿Por qué containerizar aplicaciones Java?

La contenerización de aplicaciones es un enfoque popular que permite empacar software junto con todas sus dependencias, lo que proporciona un entorno de ejecución consistente. Para las aplicaciones Java, esto significa poder ejecutar el mismo código en diferentes entornos sin preocuparse por la configuración del sistema subyacente. En este artículo, nos enfocaremos en una herramienta que simplifica este proceso: Jib.

Contenido

Introducción a Jib

Jib es una herramienta de código abierto mantenida por Google para construir imágenes de Docker de aplicaciones Java. Lo que hace que Jib sea único es que no necesita un Dockerfile y, de hecho, no requiere que Docker esté instalado en tu máquina. Esto reduce las complejidades involucradas al construir y publicar imágenes Docker. A través de Jib, simplemente puedes integrar la construcción de imágenes en tu flujo de trabajo de Maven o Gradle.

Google publica Jib como un plugin tanto para Maven como para Gradle, lo cual es beneficioso porque Jib capturará cualquier cambio en tu aplicación cada vez que construyas, ahorrándote comandos separados de construcción o empujes de Docker y simplificando su adición a un pipeline de CI.

Creando una Aplicación de Saludo Simple

Para entender cómo usar Jib, vamos a crear una aplicación simple de Spring Boot que exponga un endpoint GET que responda con un saludo. Este servicio se puede acceder a través de:

http://localhost:8080/greeting

Código del Controlador

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.atomic.AtomicLong;

@RestController
public class GreetingController {

    private static final String template = "Hola Docker, %s!";
    private final AtomicLong counter = new AtomicLong();

    @GetMapping("/greeting")
    public Greeting greeting(@RequestParam(value="name", defaultValue="Mundo") String name) {
        return new Greeting(counter.incrementAndGet(), String.format(template, name));
    }
}

En este ejemplo, definimos un endpoint /greeting que devuelve un objeto Greeting con un mensaje que incluye el nombre pasado como parámetro.

Preparando el Despliegue

Antes de empezar a usar Jib, necesitas autenticarte con el repositorio de Docker donde piensas publicar tu imagen. Para hacer esto, puedes proporcionar tus credenciales de DockerHub en el archivo <tu_usuario>/.m2/settings.xml:

<servers>
    <server>
        <id>registry.hub.docker.com</id>
        <username>TuNombreDeUsuarioDockerHub</username>
        <password>TuContraseñaDockerHub</password>
    </server>
</servers>

Existen maneras más seguras de proporcionar las credenciales, como el uso de docker-credential-helpers, que encriptan la información en el sistema de archivos.

Desplegando en Docker Hub con Jib

Ahora que tienes Jib configurado, puedes usar el jib-maven-plugin para construir y publicar tu aplicación con un simple comando:

mvn compile com.google.cloud.tools:jib-maven-plugin:2.5.0:build -Dimage=$IMAGE_PATH

Donde IMAGE_PATH es la ruta objetivo en el registro de contenedores. Por ejemplo, para subir la imagen baeldungjib/spring-jib-app a DockerHub:

export IMAGE_PATH=registry.hub.docker.com/baeldungjib/spring-jib-app

Este comando construye la imagen Docker de tu aplicación y la sube a DockerHub.

Puedes seguir un proceso similar para subir imágenes a Google Container Registry o Amazon Elastic Container Registry.

Simplificando el Comando de Maven

Para hacer la construcción más fluida, puedes configurar Jib directamente en tu archivo pom.xml, lo que te permitirá acortar el comando anterior:

<project>
    ...
    <build>
        <plugins>
            ...
            <plugin>
                <groupId>com.google.cloud.tools</groupId>
                <artifactId>jib-maven-plugin</artifactId>
                <version>2.5.0</version>
                <configuration>
                    <to>
                        <image>${image.path}</image>
                    </to>
                </configuration>
            </plugin>
            ...
        </plugins>
    </build>
    ...
</project>

Con esta configuración, puedes simplemente ejecutar:

mvn compile jib:build

Esto reducirá la complejidad de tu flujo de trabajo de desarrollo.

Personalizando Aspectos de Docker

Por defecto, Jib hace supuestos sobre tu aplicación, incluyendo el uso de un FROM y ENTRYPOINT. Sin embargo, puedes personalizarlos según tus necesidades específicas.

Cambiando el Puerto

Si deseas que tu aplicación Java escuche en un puerto diferente, como 8082, puedes hacer lo siguiente en tu configuración:

<configuration>
    ...
    <container>
        <ports>
            <port>8082</port>
        </ports>
    </container>
</configuration>

Usando una Imagen Base Diferente

Si prefieres utilizar una imagen base distinta a la que Jib selecciona (que por defecto es la imagen de Java de Eclipse Temurin), aquí hay un ejemplo de cómo configurarlo para usar una imagen openjdk:alpine:

<configuration>
    ...
    <from>                           
        <image>openjdk:alpine</image>
    </from>
    ...
</configuration>

Personalizando Aspectos de Java

Además de los aspectos de Docker, Jib permite configurar varios aspectos de la ejecución de Java al empaquetar tu aplicación:

  • jvmFlags: Para pasar flags de inicio al JVM.
  • mainClass: Para especificar la clase principal; Jib intenta inferirla automáticamente, pero puedes hacerlo manualmente.
  • args: Para definir los argumentos del programa que se pasan al método main.

Conclusiones

En este artículo, exploramos cómo usar Jib para construir y publicar imágenes Docker de aplicaciones Java. Este proceso no solo simplifica la construcción de aplicaciones Java para su ejecución en contenedores, sino que también ayuda a los desarrolladores a enfocarse en escribir código en lugar de en la configuración del entorno.

La contenerización eficiente de aplicaciones Java utilizando Jib puede ser una gran ventaja para equipos que implementan DevOps y CI/CD, permitiendo despliegues más rápidos y fiables. Considera integrar Jib en tus proyectos de Spring Boot y aprovechar todos los beneficios de la contenerización.

Si tienes preguntas sobre la implementación de Jib o deseas compartir experiencias, no dudes en dejar un comentario.