Lección 159: Contenerización del proyecto usando Docker

Antes de ponernos a usar Docker, recordemos sus elementos clave:

Paso 1: Preparar el Dockerfile

Dockerfile — es la receta que indica cómo preparar la image de Docker. Para nuestra aplicación Spring Boot quedaría así:

# Usamos la imagen base con Java 17
FROM openjdk:17-jdk-slim

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

# Copiamos nuestro JAR compilado al contenedor
COPY target/myapp-0.0.1-SNAPSHOT.jar app.jar

# Indicamos el comando para arrancar la app
ENTRYPOINT ["java", "-jar", "app.jar"]

Estructura del Dockerfile

1. FROM: Indicamos la imagen base. En nuestro caso es Java 17. Si más adelante cambias la versión del JDK, solo tendrás que sustituir esta línea.
2. WORKDIR: Definimos el directorio de trabajo dentro del contenedor donde se ejecutará nuestro código.
3. COPY: Copiamos el archivo myapp-0.0.1-SNAPSHOT.jar desde la carpeta actual al contenedor.
4. ENTRYPOINT: Definimos el comando que se ejecuta al arrancar el contenedor.

Nota: Antes de construir la image de Docker asegúrate de que tu proyecto Spring Boot está compilado con mvn clean package o con ./gradlew bootJar. El archivo JAR se crea en la carpeta target o en build/libs.

Paso 2: Construir la imagen Docker

Ahora que nuestro Dockerfile está listo, vamos a construir la image de Docker. Abre el terminal en la carpeta raíz del proyecto (donde está el Dockerfile) y ejecuta el comando:

docker build -t myapp .

Por si acaso, desgranemos el comando:

• docker build: Orden a Docker para construir la image.
• -t myapp: Indicamos el nombre para la image (myapp).
• .: Usamos el directorio actual como contexto de construcción.

Si todo está correcto, verás un mensaje como:
Successfully built <image-id>
Successfully tagged myapp:latest

Puedes comprobar la image construida con el comando:

docker images

Paso 3: Ejecutar el contenedor

El contenedor se ejecuta desde la image usando docker run. Así es como se hace:

docker run -p 8080:8080 myapp

En ese comando:

• -p 8080:8080: Mapeamos el puerto 8080 del contenedor al equipo local.
• myapp: El nombre de nuestra image.

Si todo ha ido bien, tu aplicación estará disponible en: http://localhost:8080. ¡Enhorabuena, acabas de arrancar tu aplicación Spring Boot dentro de un contenedor!

Paso 4: Optimizar el Dockerfile

Tu image ya funciona, pero puede ser pesada y eso alarga el despliegue. Vamos a optimizarla.

Usaremos construcción multi-etapa:

# Etapa 1: Compilar la aplicación
FROM maven:3.8.5-openjdk-17 AS builder
WORKDIR /build
COPY pom.xml .
COPY src ./src
RUN mvn clean package -DskipTests

# Etapa 2: Crear una imagen ligera
FROM openjdk:17-jdk-slim
WORKDIR /app
COPY --from=builder /build/target/myapp-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java", "-jar", "app.jar"]

Ahora usamos Maven solo en la etapa de compilación, y para ejecutar la app usamos una imagen ligera openjdk:17-jdk-slim. Esto reduce considerablemente el tamaño final de la image de Docker.

Paso 5: Publicar la image Docker

Para compartir tu image o desplegarla en un servidor, tienes que subirla a un Docker Registry. El más popular es Docker Hub.

1. Autentícate en Docker Hub:

docker login

2. Reetiqueta la image (sustituye username por tu usuario):

docker tag myapp username/myapp:latest

3. Sube la image:

docker push username/myapp:latest

Ahora la image estará disponible para descargar:

docker pull username/myapp:latest

Paso 6: Problemas y cómo solucionarlos

Al trabajar con contenedores puedes encontrarte con varios problemas:

1. No se encuentra el archivo JAR: Asegúrate de haber compilado el proyecto antes de ejecutar docker build.
2. Conflictos de puertos: Si el puerto 8080 está ocupado, usa otro, por ejemplo:

   
   docker run -p 9090:8080 myapp
   

3. Image enorme: Usa imágenes ligeras (por ejemplo, openjdk:17-jdk-slim).
4. No funciona el acceso a librerías (por ejemplo, a la base de datos): Los contenedores están aislados, asegúrate de que pueden "ver" tu base de datos. Usa Docker Compose para configurar la red.

Paso 7: Uso de Docker Compose

Si la aplicación usa varios servicios (por ejemplo, base de datos + app), podemos montarlos con Docker Compose.

Crea un archivo docker-compose.yml:

version: '3.8'
services:
  app:
    build:
      context: .
    ports:
      - "8080:8080"
    depends_on:
      - db
  db:
    image: postgres:15
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: myappdb

Comando para arrancar:

docker-compose up

Ahora Docker Compose levantará la aplicación y la base de datos al mismo tiempo.

La contenerización no es solo una moda, es el estándar en el desarrollo moderno. Las images Docker ayudan a:

• Desplegar la aplicación rápidamente en un servidor o en la nube.
• Garantizar aislamiento y compatibilidad del entorno.
• Automatizar pipelines de CI/CD.

En las entrevistas de trabajo seguro que valorarán tus habilidades con Docker, y en proyectos reales ahorrarás un montón de tiempo en la configuración del entorno.

Ahora tienes todas las herramientas para empaquetar y desplegar tu proyecto! 🎉