Qué es un Dockerfile

Un Dockerfile es un archivo de texto plano que contiene las instrucciones necesarias para construir una imagen personalizada. Cada línea representa un paso y se convierte en una capa dentro de la imagen final. Al aprender a escribir Dockerfiles entiendes cómo funciona Docker por dentro y puedes empaquetar cualquier aplicación a tu medida.

Instrucciones más comunes

• FROM: define la imagen base sobre la que construyes.
• WORKDIR: establece el directorio de trabajo dentro del contenedor.
• COPY: copia archivos del host a la imagen.
• RUN: ejecuta comandos durante la construcción (instalar paquetes, compilar, etc.).
• EXPOSE: documenta qué puerto escucha la aplicación.
• ENV: define variables de entorno.
• CMD: indica el comando por defecto al arrancar el contenedor.

Ejemplo 1: aplicación Node.js

# Dockerfile
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

Fíjate que primero copiamos package.json y luego el resto del código. Esto aprovecha la caché de capas: mientras las dependencias no cambien, Docker reutilizará la capa de npm ci en futuras builds, ahorrando minutos.

Ejemplo 2: aplicación PHP con Composer

FROM php:8.2-fpm-alpine
WORKDIR /var/www/html
RUN apk add --no-cache git unzip \
 && docker-php-ext-install pdo_mysql opcache
COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
COPY composer.json composer.lock ./
RUN composer install --no-dev --no-scripts --no-autoloader
COPY . .
RUN composer dump-autoload --optimize
EXPOSE 9000
CMD ["php-fpm"]

Aquí usamos una build multi-stage parcial copiando el binario de Composer desde otra imagen. Es un patrón muy eficiente.

Construir la imagen

Ubícate en la carpeta donde está el Dockerfile y ejecuta:

docker build -t miapp:1.0 .

El flag -t asigna una etiqueta (nombre:versión). El punto indica el contexto de build, es decir, la carpeta cuyo contenido estará disponible para las instrucciones COPY. Para ver el resultado:

docker images | grep miapp
docker run -d -p 3000:3000 miapp:1.0

Capas y caché: por qué importa el orden

Docker construye la imagen capa por capa. Si una capa cambia, todas las capas posteriores se reconstruyen. Por eso conviene poner primero las instrucciones que cambian poco (instalación de dependencias del sistema) y al final las que cambian con cada commit (tu código fuente). Así acortas el tiempo de build de minutos a segundos.

Buenas prácticas rápidas

• Usa imágenes base ligeras (alpine, slim) cuando sea posible.
• Agrupa comandos RUN con && para reducir capas.
• Crea un archivo .dockerignore para excluir node_modules, .git, archivos temporales y secretos.
• Nunca pongas contraseñas directamente en el Dockerfile; usa variables de entorno o secretos.
• Etiqueta tus imágenes con versiones claras, evita depender solo de latest.

Con un Dockerfile bien escrito tienes una receta reproducible que cualquier compañero de equipo puede usar para construir exactamente la misma imagen.