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 *