Breaking

Post Top Ad

Your Ad Spot

martes, 9 de julio de 2019

Dockerizing una aplicación de arranque de Spring

Visión general

En este artículo, cubriremos el proceso de creación de una imagen de Docker de una aplicación Spring Boot , utilizando Dockerfile y Maven y luego ejecutaremos la imagen que hemos creado.
El código fuente de este tutorial se puede encontrar en Github .
Este tutorial asume que tienes Docker instalado en tu máquina. Si no, puede seguir la guía de instalaciónoficial de Docker 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 de arranque de primavera

Vamos a empezar con una aplicación de arranque de primavera simple. La mejor manera de comenzar con un proyecto de esqueleto es visitar Spring Initializr . Seleccione su versión preferida de Spring Boot, y agregue la dependencia "Web". ¡Genérelo como un proyecto de Maven y ya está todo listo!
Primavera Initializr
El proyecto incluye un controlador REST simple con una sola asignación que solo espera un nombre como 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 por su navegador (o use curl , cartero , etc.) hasta " http: // localhost: 8080 / greet / john ", verá una respuesta que se parece a algo como:
Respuesta REST 1

Dockerizing la aplicación de arranque de primavera

Ahora vamos a dockerizar nuestra aplicación Spring Boot hecha anteriormente. Cubriremos los dos enfoques más utilizados:
  • Dockerfile - Especificando un archivo que contiene comandos nativos de Docker para construir la imagen
  • Maven - Usando un plugin de Maven para construir la imagen

Dockerizing utilizando Dockerfile

Un archivo Docker es solo un .txtarchivo normal que incluye comandos nativos de Docker que se usan para especificar las capas de una imagen. Para hacerlo, vamos a crear un archivo de texto llamado "Dockerfile":
Archivo docker
El contenido del archivo en sí puede verse algo 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 comprenderemos completamente antes de continuar:
  • FROM : la palabra clave FROMle dice a Docker que use una imagen base determinada como base de construcción. Hemos utilizado 'java' con la etiqueta '8-jdk-alpine'. Piense en una etiqueta como una versión. La imagen base cambia de proyecto a proyecto. Puede buscar imágenes en el docker-hub.
  • COPIAR : esto le dice a Docker que copie los archivos del sistema de archivos local a una carpeta específica dentro de la imagen de construcción. Aquí, copiamos nuestro .jararchivo a la imagen de compilación (imagen de Linux) que está dentro /usr/app.
  • WORKDIR - La WORKDIRinstrucción establece el directorio de trabajo para cualquier RUNCMDENTRYPOINTCOPYADDlas instrucciones que siguen en el Dockerfile. Aquí cambiamos el direccionamiento de trabajo a /usr/apppara que no tengamos que escribir el camino largo una y otra vez.
  • EJECUTAR : esto le indica a Docker que ejecute una línea de comandos de shell dentro del sistema de destino. Aquí prácticamente solo "tocamos" nuestro archivo para que tenga su hora de modificación actualizada (Docker crea todos los archivos de contenedor en un estado "sin modificar" de forma predeterminada).
  • ENTRYPOINT : esto le permite configurar un contenedor que se ejecutará como un ejecutable. Es donde le dices a Docker cómo ejecutar tu aplicación. Sabemos que ejecutamos nuestra aplicación Spring-Boot java -jar <app-name>.jar, así que la colocamos en una matriz.
Se puede encontrar más documentación en la página de referencia de Dockerfile .
Antes de seguir adelante, necesitamos un .jararchivo Spring Boot Este archivo se utilizará para crear la imagen de Docker como se mencionó anteriormente.
Ejecute el mvn clean installcomando para asegurarse de que se genera.
Vamos a construir 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 .
Docker construir 1
Construimos la imagen utilizando docker buildLe dimos un nombre con la -tbandera y especificamos el directorio actual donde está el archivo Docker. La imagen está construida y almacenada en nuestro registro local de docker.
Veamos nuestra imagen:
$ docker images
Imágenes de docker 1
Y por último, vamos a ejecutar nuestra imagen:
$ docker run -p 8090:8080 greeting-app 
Docker run 1
Podemos ejecutar imágenes Docker usando el docker runcomando.
Sabemos que cada contenedor es un entorno aislado en sí mismo y tenemos que asignar el puerto del sistema operativo host ( 8090y el puerto dentro del contenedor) 8080, que se especifica como el -p 8090:8080argumento.
Ahora, podemos acceder al punto final en http://localhost:8080/greet/john:
Respuesta REST 2
¡Nuestra aplicación Spring Boot se está ejecutando con éxito dentro de un contenedor Docker!

Dockerizing utilizando Maven

En la sección anterior escribimos un archivo Docker simple y compilamos nuestra aplicación usando el docker buildcomando nativo Sin embargo, hay algunos problemas que podemos encontrar en nuestros proyectos usando este método:
  • El .jarnombre : tenemos que mencionar el nombre del frasco (junto con la versión) en el archivo. A medida que nuestra aplicación crezca, nuestras versiones cambiarán y debemos, una y otra vez, actualizar este Dockerfile también.
  • Uso del terminal : tenemos que abrir manualmente un terminal y ejecutar los comandos de Docker. Sería bueno si pudiéramos convertirlo en parte de un ciclo de vida de Maven para poder construir imágenes como parte de nuestras tuberías de CI / CD (Integración continua / Entrega continua).
Hay muchos complementos de Maven disponibles que podemos usar en nuestro pom.xmlarchivo que harían nuestra vida mucho más fácil. La forma en que funciona este complemento de Maven es que crea internamente el Dockerfile en función de la configuración en el pom.xmlarchivo y luego utiliza el Dockerfile generado para generar la imagen.
Al utilizar este método, no es necesario que actualicemos manualmente el nombre ni ejecutemos el terminal.
El complemento debe estar ubicado en nuestro pom.xmlarchivo después de la buildetiqueta. Este será un complemento de compilación opcional utilizando los perfiles de Maven. Siempre es una buena idea usar esto a través de los perfiles porque queremos que el mvn clean installcomando normal funcione en la máquina de un desarrollador, que no tiene instalado Docker también:
<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, deberíamos ejecutar el comando con -Ddocker.
  • La <name>etiqueta: esta etiqueta especifica el nombre de la imagen, que es el artifactId- en nuestro caso, es demo-docker.
  • La <from>etiqueta: esta etiqueta especifica la imagen base de java:8-jdk-alpine.
  • La <args>etiqueta: esta etiqueta se utiliza para especificar cómo debe ejecutarse la imagen.
Ahora vamos a construir la imagen:
$ mvn clean install -Ddocker 
Docker construir 2
Veamos nuestra imagen:
$ docker images
Imágenes de docker 2
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 estén ejecutando anteriormente y que están utilizando el puerto 8090, o de lo contrario obtendrá un error.
Puede comprobar fácilmente qué contenedores se están ejecutando utilizando:
$ docker ps 
Ahora, si el puerto ya está en uso, puede cambiar el puerto o eliminar el contenedor antiguo con:
$ docker rm -f <container-id>
Otra forma fácil es detener todos los contenedores:
 $ docker rm -f $(docker ps -a -q) 

Conclusión

En este artículo, cubrimos las dos formas más utilizadas para contener una aplicación Spring Boot usando Docker.
El primer enfoque se realizó mediante el uso de un sencillo archivo Docker para crear la imagen, y el segundo enfoque está utilizando un complemento de Maven.
Una vez que se crea la imagen, hay muchas formas de ejecutarla. En este artículo, nos basamos en el docker runcomando nativo Una forma más accesible es utilizar la función docker-compose si tiene muchas imágenes que necesita ejecutar.
Para un entorno de producción, generalmente optamospor Kubernetes o Docker-swarm para escalar nuestra aplicación en función del tráfico de red automáticamente.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas