En esta lección vas a entender Qué es un Dockerfile y por qué es tan importante cuando quieres crear tus propias imágenes de Docker. Un Dockerfile es la receta que describe cómo preparar el entorno de una aplicación: imagen base, dependencias, archivos, puerto documentado y comando de arranque.
La clave es verlo como una receta reproducible. Si otra persona clona tu proyecto, puede construir la misma imagen sin instalar dependencias a mano en su máquina.
👉 Y recuerda, si quieres aprender más de Linux, pincha en este curso de Linux gratis.
🐳 Si quieres aprender más de Docker, pincha en este curso de Docker gratis.
Qué es un Dockerfile
Problema: instalar dependencias a mano funciona en tu equipo, pero no garantiza que otra persona, un servidor o un pipeline de CI pueda repetir exactamente el mismo entorno.
Qué aporta Docker: permite convertir esos pasos en instrucciones versionadas. A partir de esa receta, Docker construye una imagen que luego se puede ejecutar como contenedor.
| Concepto | Qué representa | Ejemplo mental |
|---|---|---|
| Dockerfile | La receta de construcción. | Define pasos, archivos y comando final. |
| Imagen | El resultado construido. | Una plantilla versionada de la aplicación. |
| Contenedor | La imagen en ejecución. | El proceso real que arranca desde esa imagen. |
Ejemplo práctico de Dockerfile
Este ejemplo usa Node.js con Alpine y un tag fijo. Evitar latest ayuda a que la construcción sea más reproducible y a que los cambios de versión no entren sin avisar.
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY src/ ./src/
EXPOSE 3000
CMD ["node", "src/index.js"]Qué hace cada instrucción
- FROM define la imagen base sobre la que se construye la nueva imagen.
- WORKDIR fija el directorio de trabajo dentro de la imagen.
- COPY copia archivos del proyecto al contexto de construcción.
- RUN ejecuta comandos durante la construcción de la imagen.
- EXPOSE documenta el puerto esperado, pero no lo publica por sí solo en el host.
- CMD define el comando por defecto al arrancar el contenedor.
Construir y ejecutar la imagen
Una vez creado el archivo, puedes construir la imagen y lanzar un contenedor de prueba. La publicación real del puerto ocurre al ejecutar el contenedor con la opción de mapeo, no con EXPOSE.
docker build -t mi-app:1.0 .
docker run --rm -p 3000:3000 mi-app:1.0Si el build falla, revisa primero el contexto de construcción, la ruta de los archivos copiados y si package-lock.json existe en el proyecto. No metas secretos reales dentro del Dockerfile: todo lo que queda en una capa puede terminar dentro del historial de la imagen.
Errores comunes y buenas prácticas
Copiar todo demasiado pronto
Si copias todo el proyecto antes de instalar dependencias, cualquier cambio pequeño puede invalidar la caché y hacer que el build tarde más. Por eso suele convenir copiar primero los archivos de dependencias y después el código fuente.
Usar latest sin control
latest parece cómodo, pero puede cambiar con el tiempo. En ejemplos didácticos puede aparecer, pero para trabajos reproducibles conviene usar tags concretos y actualizar versiones de forma consciente.
Confundir EXPOSE con publicar puertos
EXPOSE documenta el puerto que la imagen espera usar. Para acceder desde el host necesitas publicar el puerto al ejecutar el contenedor o definir ports en Compose.
Meter credenciales en la imagen
No guardes tokens, contraseñas ni claves privadas en instrucciones RUN, ENV o archivos copiados. Usa variables seguras, secretos del orquestador o configuración externa según el entorno.
Multi-stage sin complicarlo
Un build multi-stage separa fases: una etapa puede instalar o compilar dependencias y otra quedarse solo con lo necesario para ejecutar. Así reduces tamaño y superficie de ataque.
FROM node:20-alpine AS deps
WORKDIR /app
COPY package*.json ./
RUN npm ci
FROM node:20-alpine
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY src/ ./src/
CMD ["node", "src/index.js"]No necesitas usar multi-stage desde el primer día, pero es una técnica muy útil cuando tu imagen empieza a crecer o cuando quieres separar herramientas de compilación del runtime final.
Siguiente paso en el curso
Ahora que ya sabes Qué es un Dockerfile, conecta esta lección con imágenes, contenedores y Compose. El Dockerfile define cómo construir la imagen; Compose puede usar esa imagen o construirla como parte de un stack con varios servicios.
Lecciones relacionadas del curso Docker
- Dockerfile: lección pilar para profundizar en instrucciones y patrones.
- imágenes de Docker: entiende el resultado que se genera al construir.
- contenedor Docker: repasa qué ocurre cuando ejecutas una imagen.
- Docker Compose: aprende a levantar servicios usando imágenes propias.
- guía completa de Docker: índice principal del curso.
Documentación oficial y recursos
- Dockerfile reference: referencia oficial de instrucciones.
- Docker build best practices: buenas prácticas oficiales para construir imágenes.
- Dockerfile overview: explicación oficial del concepto y del flujo de build.
Un Dockerfile bien escrito no es solo una lista de comandos: es documentación ejecutable del entorno de tu aplicación. Empieza con ejemplos pequeños, usa tags fijos y revisa la caché de construcción antes de complicar el archivo.
Cuando domines esta base, podrás crear imágenes más limpias, reproducibles y fáciles de integrar con Compose, CI/CD y despliegues reales.
