Dockerfile: creación y estructura del archivo

2.1 Conceptos principales de Dockerfile

Dockerfile — es un archivo de texto, que contiene una secuencia de comandos que Docker usa para crear una imagen. Sirve como una "receta" que describe cómo debe ensamblarse la imagen, desde la capa base hasta el estado final. Entender la estructura y el proceso de creación de Dockerfile es importante para un uso eficiente de Docker.

Conceptos principales de Dockerfile:

1. Idempotencia: los comandos en Dockerfile deben ser idempotentes: su ejecución repetida da el mismo resultado.
2. Secuencia: los comandos se ejecutan secuencialmente de arriba hacia abajo. El orden importa, ya que cada comando crea una nueva capa de la imagen.
3. Estructura en capas: prácticamente cada instrucción agrega una nueva capa a la imagen. Estas capas se almacenan en caché, lo que permite optimizar el proceso de compilación.

Estructura de Dockerfile:

Dockerfile se compone de instrucciones, cada una de las cuales realiza una función específica. Estas son las principales:

1. FROM: define la imagen base que se utilizará para crear la nueva imagen.
2. MAINTAINER: define el autor del Dockerfile (obsoleto, pero útil para información).
3. RUN: ejecuta comandos en el contenedor y crea una nueva capa.
4. COPY: copia archivos y directorios desde el contexto de compilación al sistema de archivos del contenedor.
5. ADD: copia archivos y directorios, admite extracción de archivos y descarga por URL.
6. WORKDIR: establece el directorio de trabajo para los comandos posteriores.
7. ENV: configura variables de entorno.
8. CMD: define el comando predeterminado que se ejecuta al iniciar el contenedor.
9. ENTRYPOINT: establece un comando que se ejecuta al iniciar el contenedor, con posibilidad de pasar argumentos.
10. EXPOSE: especifica los puertos que usa el contenedor.
11. VOLUME: crea un punto de montaje para volúmenes externos.

2.2 Creación del Dockerfile

Ejemplo de creación de un Dockerfile

Vamos a ver un ejemplo simple de cómo crear un Dockerfile para una aplicación web en Node.js.

Paso 1: Crear un Dockerfile básico

Crea un archivo llamado Dockerfile en la raíz de tu proyecto y agrega las siguientes líneas:

# Usamos una imagen base de Node.js
FROM node:14

# Establecemos el directorio de trabajo
WORKDIR /app

# Copiamos package.json y package-lock.json
COPY package*.json ./

# Instalamos las dependencias
RUN npm install

# Copiamos todos los archivos del proyecto
COPY . .

# Indicamos el puerto que usará la aplicación 
EXPOSE 3000

# Definimos el comando para iniciar la aplicación
CMD ["node", "app.js"]

Este Dockerfile realiza las siguientes acciones:

1. FROM node:14: usa la imagen oficial de Node.js versión 14 como base.
2. WORKDIR /app: establece el directorio de trabajo para los comandos siguientes.
3. COPY package*.json ./: copia los archivos package.json y package-lock.json al directorio de trabajo.
4. RUN npm install: instala dependencias desde el package.json.
5. COPY . .: copia todos los archivos del proyecto al directorio de trabajo del contenedor.
6. EXPOSE 3000: indica que la aplicación usará el puerto 3000.
7. CMD ["node", "app.js"]: define el comando para iniciar la aplicación.

Paso 2: Construir la imagen

Después de crear el Dockerfile, construye la imagen con el comando docker build:

docker build -t my-node-app .

Este comando creará una imagen llamada my-node-app, usando el Dockerfile desde el directorio actual.

Paso 3: Ejecutar el contenedor

Ejecuta el contenedor basado en la imagen creada utilizando el comando docker run:

docker run -d -p 3000:3000 my-node-app

Este ejemplo ejecuta el contenedor en modo background, redirigiendo el puerto 3000 del contenedor al puerto 3000 de la máquina anfitriona. Ahora puedes acceder a la aplicación a través de http://localhost:3000.

2.3 Instrucciones adicionales del Dockerfile

1. Configuración de variables de entorno

Puedes establecer variables de entorno que estarán disponibles en el contenedor utilizando la instrucción ENV.

ENV NODE_ENV=production

2. Uso de múltiples comandos RUN

A veces conviene combinar varios comandos en una sola instrucción RUN para reducir la cantidad de capas, disminuir el tamaño de la imagen y acelerar la construcción.

RUN apt-get update && apt-get install -y \
  curl \
  git \
  && rm -rf /var/lib/apt/lists/*

¡Útil! Si el comando no cabe en una línea, puedes usar el símbolo \ para continuar en la siguiente línea. Esto será interpretado como un único comando.

¡Útil! Para escribir múltiples comandos en una sola línea, puedes usar &&: command1 && command2 && command3. Esto permite ejecutar varios comandos de manera secuencial.

Optimización del orden de los comandos

Para usar eficazmente la caché de Docker, primero copia archivos que cambian raramente (por ejemplo, package.json) e instala las dependencias antes de añadir el resto de los archivos del proyecto.

Ejemplo de un Dockerfile avanzado

En proyectos más complejos, puede necesitarse un Dockerfile avanzado con configuraciones adicionales.

# Usamos una imagen base mínima de Node.js
FROM node:14-alpine

# Configuramos el directorio de trabajo
WORKDIR /usr/src/app

# Copiamos package.json e instalamos las dependencias
COPY package*.json ./
RUN npm install --only=production

# Copiamos el código fuente
COPY . .

# Especificamos el puerto de trabajo
EXPOSE 8080

# Configuramos variables de entorno
ENV NODE_ENV=production

# Iniciamos la aplicación
CMD ["node", "server.js"]