Dockerizar una aplicación Spring Boot

Visión general

En este artículo, cubriremos el proceso de creación de un Estibador imagen de un Bota de Spring aplicación, usando Dockerfile y Maven y luego ejecutamos la imagen que hemos creado.

El código fuente de este tutorial se puede encontrar en Github.

Este tutorial asume que tiene Docker instalado en su máquina. Si no, puede seguir al oficial Instalación de Docker guía basada en su sistema operativo.

Si desea leer más sobre Docker, lo hemos cubierto en detalle en – Docker: una introducción de alto nivel.

La aplicación Spring Boot

Comencemos con una simple aplicación Spring Boot. La mejor manera de comenzar con un proyecto esqueleto es visitar Spring Initializr. Seleccione su versión preferida de Spring Boot y agregue la dependencia «Web». ¡Generelo como un proyecto Maven y listo!

El proyecto incluye un controlador REST simple con un solo mapeo que solo espera un nombre como la variable de ruta y luego genera una cadena para saludarlo:

@RestController
public class DemoController {

  @GetMapping("/greet/{name}")
  public String greeting(@PathVariable String name) {
    return "Hi!! " + name;
  }
}

Para ejecutar la aplicación, use el siguiente comando de Maven de la carpeta raíz del proyecto:

Te puede interesar:Leer y escribir XML en Java

$ mvn spring-boot:run

Como de costumbre, la aplicación se ejecutará en el puerto 8080. Para probar este punto final, navegue en su navegador (o use rizo, cartero, etc.) a «http: // localhost: 8080 / greet / john«, verá una respuesta similar a:

Dockerizar la aplicación Spring Boot

Ahora vamos a dockerizar nuestra aplicación Spring Boot creada anteriormente. Cubriremos los dos enfoques más utilizados:

• Dockerfile – Especificar un archivo que contiene comandos nativos de Docker para construir la imagen
• Maven – Usando un plugin de Maven para construir la imagen

Dockerizar usando Dockerfile

Un Dockerfile es solo un archivo regular .txt archivo que incluye comandos nativos de Docker que se utilizan para especificar las capas de una imagen. Para hacerlo, creemos un archivo de texto llamado «Dockerfile»:

El contenido del archivo en sí puede verse así:

FROM java:8-jdk-alpine

COPY ./target/demo-docker-0.0.1-SNAPSHOT.jar /usr/app/

WORKDIR /usr/app

RUN sh -c 'touch demo-docker-0.0.1-SNAPSHOT.jar'

ENTRYPOINT ["java","-jar","demo-docker-0.0.1-SNAPSHOT.jar"]

Echemos un vistazo a los comandos y los comprendamos completamente antes de continuar:

• DE – La palabra clave FROM le dice a Docker que use una imagen base determinada como base de compilación. Hemos utilizado ‘java’ con la etiqueta ‘8-jdk-alpine’. Piense en una etiqueta como una versión. La imagen base cambia de un proyecto a otro. Puede buscar imágenes en docker-hub.
• COPIAR – Esto le dice a Docker que copie archivos del sistema de archivos local a una carpeta específica dentro de la imagen de compilación. Aquí copiamos nuestro .jar archivo a la imagen de compilación (imagen de Linux) dentro /usr/app.
• WORKDIR – Los WORKDIR instrucción establece el directorio de trabajo para cualquier RUN, CMD, ENTRYPOINT, COPY y ADD instrucciones que siguen en el Dockerfile. Aquí cambiamos el workdir a /usr/app para no tener que escribir el camino largo una y otra vez.
• CORRER – Esto le dice a Docker que ejecute una línea de comandos de shell dentro del sistema de destino. Aquí prácticamente simplemente «tocamos» nuestro archivo para que tenga su hora de modificación actualizada (Docker crea todos los archivos contenedores en un estado «sin modificar» de forma predeterminada).
• PUNTO DE ENTRADA – Esto le permite configurar un contenedor que se ejecutará como ejecutable. Es donde le dice a Docker cómo ejecutar su aplicación. Sabemos que ejecutamos nuestra aplicación de arranque de Spring como java -jar <app-name>.jar, entonces lo ponemos en una matriz.

Puede encontrar más documentación en el Referencia de Dockerfile página.

Antes de seguir adelante, necesitamos un Spring Boot .jar archivo. Este archivo se utilizará para crear la imagen de Docker como se mencionó anteriormente.

Te puede interesar:Java convertir entero en cadena

Ejecutar el mvn clean install comando para asegurarse de que se genera.

Construyamos la imagen usando este Dockerfile. Para hacerlo, vaya al directorio raíz de la aplicación y ejecute este comando:

$ docker build -t greeting-app .

Construimos la imagen usando docker build. Le dimos un nombre con el -t flag y especificó el directorio actual donde está el Dockerfile. La imagen se crea y almacena en nuestro registro de Docker local.

Revisemos nuestra imagen:

$ docker images

Y finalmente, ejecutemos nuestra imagen:

$ docker run -p 8090:8080 greeting-app 

Podemos ejecutar imágenes de Docker usando el docker run mando.

Sabemos que cada contenedor es un entorno aislado en sí mismo y tenemos que mapear el puerto del sistema operativo host. 8090 y el puerto dentro del contenedor – 8080, que se especifica como -p 8090:8080 argumento.

Te puede interesar:Lectura y escritura de CSV en Java con Apache Commons CSV

Ahora, podemos acceder al punto final en http://localhost:8080/greet/john:

¡Nuestra aplicación Spring Boot se está ejecutando con éxito dentro de un contenedor Docker!

Dockerizar usando Maven

En la sección anterior escribimos un Dockerfile simple y construimos nuestra aplicación usando el nativo docker build mando. Sin embargo, hay un par de problemas que podemos encontrar en nuestros proyectos utilizando este método:

• los .jar nombre – Tenemos que mencionar el nombre del jar (junto con la versión) en el archivo. A medida que nuestra aplicación crezca, nuestras versiones cambiarán y tendremos que, una y otra vez, actualizar este Dockerfile también.
• Usando la terminal – Tenemos que abrir manualmente una terminal y ejecutar comandos de Docker. Sería bueno si pudiéramos convertirlo en parte de un ciclo de vida de Maven para que podamos construir imágenes como parte de nuestras canalizaciones de CI / CD (Integración continua / Entrega continua).

Hay muchos plugins de Maven disponibles que podemos usar en nuestro pom.xml archivo que nos haría la vida mucho más fácil. La forma en que funciona este plugin de Maven es que crea internamente el Dockerfile en función de la configuración en el pom.xml file y luego usa el Dockerfile generado para construir la imagen.

Con este método, no es necesario que actualicemos manualmente el nombre ni que ejecutemos la terminal.

Estaremos usando el fabric8io / docker-maven-plugin.

El plugin debe estar ubicado en nuestro pom.xml archivo después del build etiqueta. Este será un plugin de compilación opcional que utiliza perfiles de Maven. Siempre es una buena idea usar esto a través de perfiles porque queremos el mvn clean install comando para trabajar en la máquina de un desarrollador, que tampoco tiene Docker instalado:

Te puede interesar:Bibliotecas para leer y escribir archivos CSV en Java

<profiles>
   <profile>
      <activation>
         <property>
            <name>docker</name>
         </property>
      </activation>
      <build>
         <plugins>
            <plugin>
               <groupId>io.fabric8</groupId>
               <artifactId>docker-maven-plugin</artifactId>
               <version>0.26.0</version>
               <extensions>true</extensions>
               <configuration>
                  <verbose>true</verbose>
                  <images>
                     <image>
                        <name>${project.artifactId}</name>
                        <build>
                           <from>java:8-jdk-alpine</from>
                           <entryPoint>
                              <exec>
                                 <args>java</args>
                                 <args>-jar</args>
                                 <args>/maven/${project.artifactId}-${project.version}.jar</args>
                              </exec>
                           </entryPoint>
                           <assembly>
                              <descriptorRef>artifact</descriptorRef>
                           </assembly>
                        </build>
                     </image>
                  </images>
               </configuration>
               <executions>
                  <execution>
                     <id>build</id>
                     <phase>post-integration-test</phase>
                     <goals>
                        <goal>build</goal>
                     </goals>
                  </execution>
               </executions>
            </plugin>
         </plugins>
      </build>
   </profile>
</profiles>

Echemos un vistazo más de cerca a esto:

• Nuestro perfil se llama docker – Si tenemos que construir la imagen usando Maven, debemos ejecutar el comando con -Ddocker.
• los <name> etiqueta: esta etiqueta especifica el nombre de la imagen, que es el artifactId – en nuestro caso, es demo-docker.
• los <from> etiqueta: esta etiqueta especifica la imagen base de java:8-jdk-alpine.
• los <args> etiqueta: esta etiqueta se utiliza para especificar cómo debe ejecutarse la imagen.

Ahora construyamos la imagen:

$ mvn clean install -Ddocker 

Revisemos nuestra imagen:

$ docker images

Finalmente, ejecutaremos nuestra imagen:

$ docker run -p 8090:8080 demo-docker 

Ahora verifique el punto final REST (http: // localhost: 8090 / greet / john) en el navegador.

Nota: Debe detener los contenedores que se estaban ejecutando anteriormente y que están usando el puerto. 8090o, de lo contrario, obtendrá un error.

Puede verificar fácilmente qué contenedores se están ejecutando usando:

Te puede interesar:Leer y escribir CSV en Java

$ docker ps 

Ahora, si el puerto ya está en uso, puede cambiar el puerto o eliminar el contenedor antiguo usando:

$ docker rm -f <container-id>

Otra forma sencilla es detener todos los contenedores:

 $ docker rm -f $(docker ps -a -q) 

Conclusión

En este artículo, cubrimos las dos formas más comúnmente utilizadas para contener una aplicación Spring Boot usando Docker.

El primer enfoque se realizó utilizando un Dockerfile simple para construir la imagen, y el segundo enfoque es usar un plugin de Maven.

Una vez creada la imagen, existen muchas formas de ejecutarla. En este artículo, confiamos en el nativo docker run mando. Una forma más accesible es utilizar docker-compose si tiene muchas imágenes que necesita ejecutar.

Para un entorno de producción solemos optar por Kubernetes o Docker-enjambre para escalar nuestra aplicación en función del tráfico de red automáticamente.

 

Te puede interesar:Cómo enviar correos electrónicos en Java