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:

    $ 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.

    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.

    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:

    <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:

    $ 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.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *