En este documento, veremos las diferentes maneras de crear una imagen Docker.

• Creación de Imágenes usando Dockerfile
• Creación de Imágenes Docker usando DockerBuild
• Uso de Google JIB
• Despliegue de Imágenes en DockerHub
• Uso Docker Compose

Para esta configuración, crearemos un archivo llamado Dockerfile en la carpeta accounts el cual no deberá tener ninguna extensión.

• En este archivo definiremos la imagen base sobre la cual vamos a trabajar (Comando FROM), quien administrara esta imagen (Comando LABEL), pasaremos nuestro archivo jar a la imagen (Comando COPY) y el comando que usaremos para ejecutar el jar (Comando ENTRYPOINT separando cada palabra del comando por comillas).

• Para crear la imagen, desde la terminal usaremos el comando docker build indicando la ruta (en este caso ya que esta en el mismo folder accounts usaremos el valor de ".") y el valor de -t para darle un etiquetado, en este el nombre Nelork/accounts y la versión sera S4 de sección 4:

Comando:

docker build . -t Nelork/accounts:s4

Es importante mencionar que Docker Desktop debe estar ejecutándose para que este comando funcione. Una vez termine, veremos en este software que la imagen fue creada:

Con el comando docker images podemos ver las imágenes existentes y con el comando docker ps los contenedores que se están ejecutando. Un contenedor es una instancia de una imagen:

Para ejecutar un contenedor ejecutamos el comando:

docker run -d -p 8081:8080 Nelork/accounts:s4

donde

-d se usa para que no muestre la ejecución en tiempo real desde la ventana de comandos y en su lugar nos devuelva el id de la imagen. -p se usa para hacer el Port Mapping. Dado que una imagen Docker trabaja aislada de la red, necesitamos exponer un puerto para que se pueda tener acceso a la aplicación, en este caso elegimos el puerto 8081. El puerto 8080 es el interno y es donde funciona nuestra App de Spring Boot.

Lo anterior también nos sirve para crear múltiples contenedores de la misma imagen en diferente puerto expuesto:

Veremos en Docker que se ejecutan múltiples contenedores:

Podemos hacer una prueba desde Postman para ver que funcione nuestra App desde el contenedor:

Detenemos nuestros contenedores desde Docker Desktop:

Si queremos ver todos los contenedores, incluso si no están ejecutándose, podemos usar docker ps -a:

En esta opción, trabajaremos directamente con la ayuda de Maven. Se basa en el uso de buildpacks incluidos en el pluginde Spring Boot en Maven. Lo que tenemos que hacer es modificar el archivo pom.xml agregando la etiqueta <packaging> indicando que nuestro artefacto a generar es un jar y posteriormente en el plugin de Spring Boot en la etiqueta <configuration> agregamos la etiqueta <image> y dentro de ella <name> que indicara el nombre de la imagen. Algo a tener en cuenta es que ese nombre que le daremos debe cumplir ciertos patrones como por ejemplo que no debe ir en mayúsculas o caracteres extraños. En el nombre podemos usar como variable el nombre del artifact que creamos con Maven:

Una vez hecho este cambio, ejecutamos el comando:

mvn spring-boot:build-image

y se procederá a hacer la construcción:

Veremos que en Docker se construirá la imagen pero también tendrá las imágenes de los buildpacks como soporte:

Podemos usar los comandos del punto anterior para ver las imágenes y proceder a crear nuestro contenedor con la imagen que nos interesa:

Veremos en Docker que nuestro contenedor se ejecuta:

De nuevo hacemos una prueba desde Postman y todo funciona como se espera:

Con esta opción, Google brinda un plugin de Maven para crear una imagen de Java, la cual no requiere tener instalado localmente Docker en nuestro PC, ya que la imagen se puede crear directamente sobre un repositorio. En nuestro caso lo dejaremos en el Docker local por simplicidad.

Lo primero a realizar en esta opción es configurar en el archivo pom.xml el tema <packaging> con el valor jar para nuestra aplicación de Spring Boot. Luego en la opcion de <build> y dentro de los <plugins> agregamos el siguiente plugin que contiene la información de donde se incluye el nombre de la imagen que le vamos a dar:

En caso de que no se reconozca, se debe sincronizar Maven para que descargue el plugin.

Una vez detectado el plugin, ejecutamos el siguiente comando de Maven para construir la imagen:

mvn compile jib:dockerBuild

y veremos que se construye la imagen:

Veremos que finaliza exitosamente:

Veremos que en Docker Desktop se crea la imagen:

Creamos el contenedor y lo vemos ejecutandose en Docker Desktop:

Y finalmente hacemos pruebas con Postman donde vemos que funciona correctamente:

Para desplegar las imagenes locales en DockerHub ejecutamos el siguiente comando:

docker image push docker.io/nelork/accounts:s4

En el Docker Desktop, veremos que en la pestaña de Hub Repositories se tiene la imagen que ya se subio:

Si visitamos Docker Hub, vemos que la imagen se ha subido:

Ahora localmente podremos eliminar nuestra imagen y si la queremos volver a descargar del DockerHub, ejecutamos el siguiente comando:

docker pull nelork/accounts:s4

Y de esa manera tendremos la imagen localmente para trabajar.

Se puede repetir el mismo proceso con los otros microservicios y localmente tendremos las 3 imágenes de nuestro sistema:

Procedemos entonces a crear el archivo docker-compose.yml en el cual ingresaremos los 3 servicios con su descripción e indicando que se tomara la imagen de manera local (Docker Desktop instalado en el PC). Crearemos también una red (Network eazybytes) para que los microservicios puedan comunicarse entre si y adicional le daremos nombres a los contenedores para que no genere nombres aleatorios:

Posteriormente ejecutamos el siguiente comando para subir las 3 imágenes con ayuda del Docker Compose:

docker compose up -d

donde el termino -d evita que nos salga información en la consola:

Veremos que automáticamente se crean los contenedores:

En Docker Desktop podemos instalar plugins y extensiones, en este caso instalaremos una para ver los logs:

Con ella podremos ver los logs de los contenedores ejecutándose y podemos filtrarlo por el que queramos:

Por medio del siguiente comando podemos detener los 3 contenedores al mismo tiempo:

docker compose stop

Veremos que los contenedores se apagan:

En caso de que no los queramos apagar sino eliminar, usamos el siguiente comando:

docker compose down