Docker con Spring y Spring Boot

Nuevo enfoque para desplegar una aplicación

¿Cómo funciona la implementación tradicional?

Proceso de implementación descrito en un documento
Los equipos de operaciones siguen los siguientes pasos:
- Setup Hardware
- Setup OS (Linux, Windows, Mac, …)
- Install Software (Java, PHP, NodeJs, Python,…)
- Setup Applications Dependencies
- Install Application
Enfoque manual:
- Toma mucho tiempo
- Alta probabilidad de cometer errores

Pero ahora tenemos un nuevo enfoque para desplegar la aplicación. Debemos instalar Docker y si queremos tener nuestros propios contenedores debemos crear una cuenta en Docker Hub.

Creación de imágenes Docker

Dockerfile

FROM openjdk:18.0-slim
COPY target/*.jar app.jar
EXPOSE 5000
ENTRYPOINT ["java","-jar","/app.jar"]

Dockerfile contiene instrucciones para crear imágenes de Docker
- FROM: Establecer imagen base.
- COPY: Copia nuevos archivos o directorios en la imagen.
- EXPOSE: Informar a Docker sobre el puerto en el que escucha el contenedor en tiempo de ejecución
- ENTRYPOINT: configura un comando que se ejecutará al poner en marcha el contenedor.

Spring Boot Dockerfile

Crear una imagen de Docker y ejecutarla

So if you are not in the specific folder, you can do a CD to this specific folder.

cd [Spring Boot project folder]

docker --version

ls

docker container ls

docker build -t jlvbcoop/hello-world-docker:v1 .

docker run -d -p 5000:5000 jlvbcoop/hello-world-docker:v1

docker container ls

docker build command

http://localhost:5000

Spring Boot application

Este enfoque no es correcto.

Una de las cosas que hemos hecho es que la creación del archivo JAR se hizo por separado. Ejecutamos una instalación en nuestra máquina local y luego copiamos el archivo jar en la imagen de Docker.
La mejor práctica es compilar todo lo que se necesita dentro de la imagen de Docker.
No se recomienda construir algo en tu máquina local y copiarlo en una imagen de Docker. Si haces algo en la máquina local y lo copias en una imagen local, existe la posibilidad de que si lo ejecuta en la máquina de otra persona, el resultado sea diferente.

Creación de la imagen Spring Boot Docker mediante Dockerfile en varias etapas

Multi Stage Dockerfile

FROM maven:3.8.6-openjdk-18-slim AS build
WORKDIR /home/app
COPY . /home/app
RUN mvn -f /home/app/pom.xml clean package

FROM openjdk:18.0-slim
EXPOSE 5000
COPY --from=build /home/app/target/*.jar app.jar
ENTRYPOINT [ "sh", "-c", "java -jar /app.jar" ]

Crear el archivo JAR como parte de la creación de la imagen Docker
BUILD STAGE.

Lo que sucederá al final de esta etapa es que tendremos un archivo JAR creado.

Solo con OpenJDK no es suficiente. Queremos construir el archivo Java y para construir el archivo Java necesitamos también Maven.
```
FROM maven:3.8.6-openjdk-18-slim AS build 
```
Configuración del directorio de trabajo.

WORKDIR /home/app

Copiando todo desde el directorio actual a /home/app.

COPY . /home/app

Ejecutar el comando mvn clean package.

RUN mvn -f /home/app/pom.xml clean package
SECOND STAGE.

Por qué usamos una nueva imagen? La imagen de Maven puede contener muchas otras cosas además de OpenJDK. Cuando ejecuto un contenedor, quiero usar una imagen de contenedor lo más pequeña posible.
```
FROM openjdk:18.0-slim
```
Copie el archivo jar creado en la carpeta de target.
```
COPY --from=build /home/app/target/*.jar app.jar
```
La primera etapa es construir el archivo jar y la segunda etapa es ejecutarlo.

Su compilación no hace uso de nada construido en nuestra máquina local.

Dockerfile

Crear una imagen de Docker y poner en marcha el container
Si no está en la carpeta correcta, puedes hacer un CD a esta carpeta.
```
docker container ls

docker container stop [containerID]

docker build -t jlvbcoop/hello-world-docker:v2 .
```
Verás que mvn clean install ahora se está ejecutando dentro de la imagen de Docker y esto lleva mucho tiempo.
```
docker image list

docker container run -d -p 5000:5000 jlvbcoop/hello-world-docker:v2

docker container ls
```

Dockerfile

docker run

Docker container

http://localhost:5000

Dockerfile

Hay un problema con este enfoque.

El caso es que ya vimos que la compilación lleva mucho tiempo. Incluso si haces un pequeño cambio en el código y vuelves a ejecutar la compilación, volverá a tardar más de 5 minutos.

Creación de la imagen de Spring Boot Docker – Optimización de Dockerfile

En el último paso, pasamos a un enfoque de varias etapas y vimos que la compilación tardo mucho tiempo. Incluso con un pequeño cambio de código, este causará que toda la aplicación se reconstruya nuevamente.

¿Cómo podemos evitar que esto suceda?

Creación de la imagen de Spring Boot Docker - Optimización de Dockerfile

FROM maven:3.8.6-openjdk-18-slim AS build
WORKDIR /home/app

COPY ./pom.xml /home/app/pom.xml
COPY ./src/main/java/com/jlvbcoop/rest/webservices/restfulwebservices/RestfulWebServicesApplication.java /home/app/src/main/java/com/jlvbcoop/rest/webservices/restfulwebservices/RestfulWebServicesApplication.java

RUN mvn -f /home/app/pom.xml clean package

COPY . /home/app
RUN mvn -f /home/app/pom.xml clean package

FROM openjdk:18.0-slim
EXPOSE 5000
COPY --from=build /home/app/target/*.jar app.jar
ENTRYPOINT [ "sh", "-c", "java -jar /app.jar" ]

Docker usa algo llamado capas
Capas en las imagenes de Docker

Una de las cosas más importantes que debemos comprender es que Docker usa algo llamado capas. Cada comando que se ejecute en el proceso de contrucción crea una capa separada. Lo que Docker intenta hacer es reutilizar la capas creadas tanto como sea posible.

Entonces, lo más importante es asegurarsnos de que todas las cosas importantes que no cambian estén presentes al comienzo de la construcción.

Cuando se trata de aplicaciones Java, el paso que lleva más tiempo es descargar las dependencias. Sin embargo, lo bueno es que las dependencias no cambian muy a menudo. Y es por eso que lo que estamos tratando de hacer es copiar un par de archivos en el comienzo de la construcción y ejecutar una primera vez mvn clean package.
```
COPY ./pom.xml /home/app/pom.xml
COPY ./src/main/java/com/jlvbcoop/rest/webservices/restfulwebservices/RestfulWebServicesApplication.java /home/app/src/main/java/com/jlvbcoop/rest/webservices/restfulwebservices/RestfulWebServicesApplication.java
```
Los archivos son el pom.xml y Spring Boot Application Class. Estos dos archivos no cambiarán con frecuencia, todos los demás archivos cambiaran muy a menudo. Y es por eso que lo que estamos haciendo es copiar estos dos archivos y ejecutar una primera compilación.
```
RUN mvn -f /home/app/pom.xml clean package
```
Una vez que realizamos esa compilación, copiamos todos los archivos y luego realizamos otra compilación.
```
COPY . /home/app
RUN mvn -f /home/app/pom.xml clean package
```
Cachear capas para reutilizarlas.

Lo mejor de este enfoque es que si no hacemos ningún cambio en el pom.xml o RestfulWebServicesApplication.java, las cinco primeras capas se reutilizarán y lo único que sucederá es el siguiente paso, mvn clean package.

mvn clean package descargará todas las dependencias por nosotros y esto es el que lleva mucho tiempo. Lo que estamos tratando de hacer es asegurarnos de que esto sudeda solo cuando haya un cambio en pom.xml o en la clase de la aplicación.

Docker almacenará en caché cada capa e intentará reutilizarla. Docker nos permitirá que hagamos uso de esta función para que nuestra compilación sea eficiente.

Dockerfile

Cree una imagen de Docker y poner en marcha el contenedor

docker container ls

docker container stop [containerID]

docker build -t jlvbcoop/hello-world-docker:v3 .

Esta es la primera construcción. Entonces, obviamente, esto es algo que llevará tiempo.

docker image list

docker container run -d -p 5000:5000 jlvbcoop/hello-world-docker:v3

docker container ls

Si hacemos cambios en el código, sin modificar el pom.xml o el archivo de la aplicación, la próxima compilación llevará mucho menos tiempo.

docker container stop [containerID]

docker build -t jlvbcoop/hello-world-docker:v4 .

Creación de una imagen de Docker con el ‘plugin’ Spring Boot Maven

El Spring Boot Maven Plugin es uno de los ‘plugins’ MAVEN más populares que existen. Este se incluye automáticamente en el pom.xml.

Con Spring Boot Maven plugin no necesitamos crear un archivo Dockerfile, por tanto, yano necesitaremos el archivo Dockerfile y lo eliminamos.

Delete Dockerfile

Spring Boot Maven Plugin - Create Docker Image
Spring Boot Maven Plugin: Proporciona compatibilidad con Spring Boot en Apache Maven.

Comando para construir una imagen de contenedor:
```
mvn spring-boot:build-image
```
Una de las cosas importantes que debes recordar acerca de este comando Spring Boot build Image, es que creará una imagen muy eficiente. Creará una imagen mucho más pequeña que las imágenes anteriores que hemos creado.

Y otra cosa es que este proceso de creación de imágenes también es eficiente. La primera compilación llevará mucho tiempo y, a partir de ahí, verás que las compilaciones posteriores son mucho más rápidas.

Build a Docker image and run

docker container ls

docker container stop [containerID]

docker container run -d -p 5000:5000 hello-world-java:0.0.1-SNAPSHOT

0 comentarios

Dejar un comentario

¿Quieres unirte a la conversación?
Siéntete libre de contribuir!

Docker con Spring y Spring Boot

Nuevo enfoque para desplegar una aplicación

¿Cómo funciona la implementación tradicional?

Proceso de implementación descrito en un documento

Los equipos de operaciones siguen los siguientes pasos:

Enfoque manual:

Creación de imágenes Docker

Dockerfile

Dockerfile contiene instrucciones para crear imágenes de Docker

Crear una imagen de Docker y ejecutarla

Este enfoque no es correcto.

Creación de la imagen Spring Boot Docker mediante Dockerfile en varias etapas

Multi Stage Dockerfile

Crear el archivo JAR como parte de la creación de la imagen Docker

Crear una imagen de Docker y poner en marcha el container

Hay un problema con este enfoque.

Creación de la imagen de Spring Boot Docker – Optimización de Dockerfile

Creación de la imagen de Spring Boot Docker - Optimización de Dockerfile

Docker usa algo llamado capas

Capas en las imagenes de Docker

Cachear capas para reutilizarlas.

Cree una imagen de Docker y poner en marcha el contenedor

Creación de una imagen de Docker con el ‘plugin’ Spring Boot Maven

Spring Boot Maven Plugin - Create Docker Image

Build a Docker image and run

Dejar un comentario

Deja una respuesta Cancelar la respuesta

Buscar

Suscríbete a nuestro Blog

JlvbCoop

Docker con Spring y Spring Boot

Nuevo enfoque para desplegar una aplicación

¿Cómo funciona la implementación tradicional?

Compartir esta entrada

Creación de imágenes Docker

Este enfoque no es correcto.

Creación de la imagen Spring Boot Docker mediante Dockerfile en varias etapas

Hay un problema con este enfoque.

Creación de la imagen de Spring Boot Docker – Optimización de Dockerfile

Capas en las imagenes de Docker

Cachear capas para reutilizarlas.

Creación de una imagen de Docker con el ‘plugin’ Spring Boot Maven

Dejar un comentario

Deja una respuesta Cancelar la respuesta

Buscar

Suscríbete a nuestro Blog

JlvbCoop