Introducción a Dockerfile

Dockerfile es un archivo de texto plano que contiene una secuencia de instrucciones para construir una imagen Docker. Cada instrucción en un Dockerfile representa una capa en la imagen final, definiendo cómo debe construirse esa capa. Gracias a Dockerfile, podemos definir y automatizar el proceso de creación de imágenes personalizadas, facilitando la adición o modificación de requisitos específicos y la reconstrucción de la imagen.

La importancia de Dockerfile reside en su capacidad para actuar como un "plano" o "receta" para nuestras imágenes y contenedores. De manera análoga a cómo un archivo pom.xml define la construcción de un proyecto Maven, un Dockerfile especifica cómo ensamblar una imagen de Docker de forma reproducible y eficiente.

Relación entre Dockerfile, Imagen y Contenedor

Para comprender mejor, consideremos la siguiente relación fundamental en el ecosistema Docker:

• Un Dockerfile es el conjunto de instrucciones para construir una imagen.
• Una Imagen Docker es una plantilla de solo lectura que contiene el sistema operativo, el software y las dependencias necesarias. Se construye a partir de un Dockerfile.
• Un Contenedor Docker es una instancia ejecutable de una imagen. Es el entorno aislado donde se ejecuta nuestra aplicación.

En resumen, se utiliza un Dockerfile para construir una imagen, y luego se ejecuta esa imagen para iniciar un contenedor.

Estructura Fundamental de un Dockerfile

Un Dockerfile está compuesto por una serie de isntrucciones y puede incluir comentarios precedidos por #. Su estructura principal se puede dividir en varias secciones:

# Información de la imagen base
FROM: Especifica la imagen base sobre la cual se construirá la nueva imagen. Es la primera instrucción obligatoria.

# Metadatos del constructor
LABEL: Permite añadir metadatos a la imagen. Un uso común es especificar el mantenedor.

# Instrucciones de operación de la imagen
RUN: Ejecuta comandos en una nueva capa durante la construcción de la imagen. Cada comando RUN crea una capa separada.
COPY/ADD: Copia archivos o directorios desde el host al sistema de archivos de la imagen en construcción. ADD puede además extraer archivos tar.
EXPOSE: Documenta los puertos de red que la aplicación dentro del contenedor utiliza.
WORKDIR: Define el directorio de trabajo predeterminado para las instrucciones RUN, CMD, ENTRYPOINT, COPY y ADD que le sigan.
ENV: Configura variables de entorno dentro de la imagen.

# Instrucciones de ejecución del contenedor
CMD: Proporciona comandos predeterminados para un contenedor en ejecución. Solo la última instrucción CMD en un Dockerfile tendrá efecto.
ENTRYPOINT: Configura un comando primario que siempre se ejecutará cuando se inicie el contenedor. Los parámetros pasados al comando `docker run` se adjuntan al ENTRYPOINT.

Para una referencia detallada de todos los parámetros de Dockerfile, se recomienda consultar la documentación oficial de Docker.

Creación de una Imagen Docker de JDK

En lugar de descargar un paquete JDK y configurarlo manualmente en cada entorno, podemos crear una imagen Docker que ya incluya Java. Este enfoque estandariza nuestro entorno de ejecución y simplifica el despliegue.

Preparación del Entorno Linux

Supongamos que estamos en un entorno Linux (por ejemplo, CentOS) para construir nuestra imagen.

1. Crear el directorio de trabajo para los archivos del Dockerfile y el JDK:``` mkdir -p /opt/docker_java_builder

2. **Transferir el paquete JDK tar.gz:**Necesitará una versión del JDK (por ejemplo, jdk-8u221-linux-x64.tar.gz) en su máquina local. Transfiérala al directorio /opt/docker_java_builder en su máquina Linux. Puede usar herramientas como scp o rz si lo tiene instalado:

   # Si no tienes lrzsz, instálalo:
   sudo yum install lrzsz -y
   # Luego usa rz para subir archivos:
   cd /opt/docker_java_builder
   rz
   
   

   Asegúrese de que el archivo JDK se encuentre en /opt/docker_java_builder/jdk-8u221-linux-x64.tar.gz (o el nombre de su paquete).

3. **Crear el archivo Dockerfile:**Dentro del mismo directorio /opt/docker_java_builder, cree un archivo llamado Dockerfile:

   cd /opt/docker_java_builder
   vi Dockerfile
   
   

   Inserte el siguiente contenido en el Dockerfile:

   # 1. Especifica la imagen base de CentOS 7
   FROM centos:7
   
   # 2. Define los metadatos del mantenedor
   LABEL maintainer="Desarrollador Java <dev.java@example.com>"
   
   # 3. Establece el directorio de trabajo dentro del contenedor
   WORKDIR /opt/java_runtime
   
   # 4. Copia el archivo tar.gz del JDK desde el host al directorio de trabajo del contenedor
   # Asegúrate de que 'jdk-8u221-linux-x64.tar.gz' está en el mismo directorio que el Dockerfile.
   COPY jdk-8u221-linux-x64.tar.gz .
   
   # 5. Descomprime el JDK, lo renombra y limpia el archivo tar.gz para reducir el tamaño de la imagen
   RUN tar -xzf jdk-8u221-linux-x64.tar.gz -C /opt/java_runtime/ && \
       mv /opt/java_runtime/jdk1.8.0_221 /opt/java_runtime/jdk8 && \
       rm /opt/java_runtime/jdk-8u221-linux-x64.tar.gz
   
   # 6. Configura las variables de entorno JAVA_HOME y PATH
   ENV JAVA_HOME="/opt/java_runtime/jdk8"
   ENV PATH="$JAVA_HOME/bin:$PATH"
   # ENV CLASSPATH=".:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar" # CLASSPATH no siempre es necesario
   
   # 7. (Opcional) Define un comando por defecto si el contenedor se ejecuta sin un comando específico.
   # Por ejemplo, para mostrar la versión de Java:
   # CMD ["java", "-version"]
   
   

4. **Construir la imagen Docker:**Ejecute el siguiente comando en el mismo directorio donde se encuentra su Dockerfile y el archivo JDK:

   docker build -t jdk-base:8u221 .
   
   

   • -t jdk-base:8u221: Asigna el nombre jdk-base y la etiqueta 8u221 a la nueva imagen.
   • .: Indica que Docker debe buscar el Dockerfile en el directorio actual.

   Durante la primera ejecución, Docker descargará la imagen base centos:7 si no la tiene localmente.

5. **Verificar la imagen construida:**Para listar las imágenes disponibles en su sistema Docker, utilice:

   docker images
   
   

   Debería ver jdk-base en la lista.

6. **Crear y ejecutar un contenedor a partir de la imagen:**Inicie un contenedor en modo interactivo para probar la instalación de Java:

   docker run -it jdk-base:8u221 /bin/bash
   
   

   Esto le dará una terminal Bash dentro de su nuevo contenedor.

7. **Verificar la instalación de Java dentro del contenedor:**Una vez dentro del contenedor, ejecute:

   java -version
   
   

   Debería ver la información de la versión de JDK 8, confirmando que su imagen se ha construido correctamente.