Skip to content

Latest commit

 

History

History
194 lines (127 loc) · 5.29 KB

part3.adoc

File metadata and controls

194 lines (127 loc) · 5.29 KB

Docker

Tabla de contenidos

Resumen

Resumen del tutorial de Docker Hub

Objetivos

  • Conocer como ejecutar aplicaciones Java en Docker.

  • Generar Dockerfile para un proyecto.

  • Generar Docker Compose para un Dockerfile.

  • Conocer los Dockerfile Multistage

1. Desarrollo

En el siguiente ejemplo vamos a partir de una aplicación de Spring compilada en un .jar, podemos generar un Dockerfile y Compose que se encargue de desplegarlo.

1.1. Consideraciones del proyecto a desplegar

Spring es un framework web Java que permite desplegar proyectos web en un .war (para lanzarlos desde un servidor tomcat o similar) o desde un .jar donde lleva el servidor web también embebido.

Spring Logo
Figure 1. Logo de Spring

En nuestro caso vamos a desplegar un fichero .jar para simplificar el proceso.

1.2. Analizando el proyecto a desplegar

En primer lugar debemos buscar en los archivos .properties de la carpeta src/main/resources para ver en qué puerto se está desplegando.

spring step1
Figure 2. Fichero de properties

En este paso podemos ver que se ejecuta en el puerto 8090.

1.3. Compilar el proyecto

El siguiente paso es compilar el proyecto ejecutando ./mvn install

spring step2
Figure 3. Resultado de compilar el proyecto

Tras realizarse correctamente la compilación podemos buscar el .jar de nuestro proyecto.

spring step3
Figure 4. Ejecutable del proyecto

Por lo tanto sabemos que nuestro ejecutable se encuentra en la ruta target/wtcdefinition-0.0.1-SNAPSHOT.jar

1.4. Creación de Dockerfile

Una vez hemos recopilado esta información podemos realizar el Dockerfile de nuestro proyecto.

FROM openjdk:8-jdk-alpine (1)

RUN mkdir -p /usr/app/ (2)

WORKDIR /usr/app (3)

COPY wtcdefinition-0.0.1-SNAPSHOT.jar /usr/app (4)

EXPOSE 8090 (5)

CMD ["java", "-jar", "wtcdefinition-0.0.1-SNAPSHOT.jar"] (6)

  1. Nombre de la imagen para ejecutar Java (SDK 8)

  2. Directorio donde copiar el .jar

  3. Directorio donde ejecutar las ordenes con docker run

  4. Copiamos el .jar de nuestro proyecto al contenedor

  5. Exponemos el puerto 8090

  6. Comando para ejecutar nuestro .jar con Java

1.5. Creación de docker-compose.yml con los datos analizados

A partir de la información anterior podemos crear un fichero docker-compose.yml que nos ayude a ejecutar nuestra aplicación sin necesida de tener que recordar todos los parametros de la invocación.

Example 1. Archivo de definición docker-compose.yml para nuestra aplicación.
version: '3.3' (1)

services: (2)
   couchbase: (3)
     build: . (4)
     ports:
       - "8090:8090" (5)

  1. Versión de formato de docker-compose (actualmente es esa).

  2. Servicios que componen el docker-compose.

  3. Nombre que le damos al servicio. Puede ser el que queramos.

  4. Ruta relativa donde encontrar el Dockerfile del servicio

  5. Puertos de la aplicación

Cuando la configuración del docker-compose.yml tiene algún servicio que use build, antes de poder lanzar la orden docker-compose up tenemos que hacer un docker-compose build para que ejecute la configuración definida en el dockerfile.

2. Avanzado

2.1. Creación de Dockerfile MultiStage

En lugar de compilar el .jar previamente a constuir la imagen Docker, podemos crear un Dockerfile que tambien lo compile. Estos Dockerfile que contienen multiples FROM se llaman Multistage.

FROM openjdk:8-jdk-alpine as build (1)

RUN mkdir -p /usr/app/ (2)

WORKDIR /usr/app (3)

COPY mvnw . (4)

COPY .mvn .mvn (4)

COPY pom.xml . (4)

COPY src src (5)

RUN sh mvnw install -DskipTests (6)

FROM openjdk:8-jdk-alpine (7)

RUN mkdir -p /usr/app/ (8)

WORKDIR /usr/app (8)

COPY --from=build /usr/app/target/wtcdefinition-0.0.1-SNAPSHOT.jar /usr/app (9)

EXPOSE 8090 (10)

CMD ["java", "-jar", "wtcdefinition-0.0.1-SNAPSHOT.jar"] (11)

  1. Primer Stage llamado build. Imagen que nos permita compilar. Pueden ser diferentes.

  2. Directorio donde vamos a compilar.

  3. Directorio donde ejecutar las siguientes ordenes.

  4. Copiamos solo los ficheros necesarios para Maven.

  5. Copiamos el código fuente de la aplicación

  6. Compilamos usando Maven.

  7. Segundo Stage. Imagen que nos permita ejecutar. Partimos de cero.

  8. Creamos el directorio para ejecutar nuestro programa.

  9. Copiamos el programa compilado en el Stage anterior.

  10. Exponemos el puerto 8090

  11. Comando para ejecutar nuestro .jar con Java

3. Actividades

3.1. Crear Dockerfile Multistage y docker-compose.yml para jar2compose

Crea un fichero Dockerfile de tipo Multistage y un docker-compose.yml para compilar y ejecutar el proyecto.

3.2. Crea Dockerfile y docker-compose.yml para un helloworld

Elige un lenguaje web y crea un Hello World que se pueda ejecutar mediante un Dockerfile y docker-compose.yml. Puede ser .Net, NodeJS, Ruby, PHP, etc.