Volver a herramientas
¿Qué es un Dockerfile?
Un Dockerfile es un archivo de texto que contiene instrucciones para construir una imagen Docker. Usar multi-stage builds permite crear imágenes optimizadas y ligeras.
- Multi-stage builds: Separa build de producción para imágenes más pequeñas
- FROM: Define la imagen base
- COPY/ADD: Copia archivos al contenedor
- RUN: Ejecuta comandos durante la construcción
- EXPOSE: Define puertos expuestos
- CMD/ENTRYPOINT: Define el comando por defecto
Preguntas frecuentes
¿Qué es un multi-stage build en Dockerfile y por qué usarlo?
Un multi-stage build usa múltiples instrucciones FROM en un mismo Dockerfile, donde cada etapa puede usar una imagen base distinta. Solo los archivos necesarios se copian de una etapa a otra con `COPY --from=`. El resultado es una imagen final mucho más pequeña porque excluye herramientas de compilación, librerías temporales y archivos intermedios. Por ejemplo, compilas tu app Go en una imagen con golang:alpine y despliegas el binario en scratch, reduciendo la imagen de 800 MB a menos de 20 MB.
¿Cómo optimizar un Dockerfile para Node.js con multi-stage?
Para optimizar un Dockerfile Node.js, usa dos etapas. Primera etapa (builder): imagen `node:20-alpine`, copia `package*.json`, ejecuta `npm ci --only=production`, copia el código y ejecuta `npm run build`. Segunda etapa (production): imagen `node:20-alpine`, copia solo `node_modules` y la carpeta `dist` desde builder. Añade `USER node` por seguridad, expón el puerto y define `CMD ["node", "dist/index.js"]`. Esto elimina devDependencies, source maps y archivos fuente de la imagen final.
¿Cómo crear un Dockerfile para una aplicación Python con Flask o Django?
Para Python usa imagen `python:3.11-slim`. Copia `requirements.txt` y ejecuta `pip install --no-cache-dir -r requirements.txt`. El flag `--no-cache-dir` evita que la caché de pip aumente el tamaño. Luego copia el código. Para Flask expón el puerto 5000 y usa `CMD ["gunicorn", "-b", "0.0.0.0:5000", "app:app"]`. Para Django expón el 8000. Como buena práctica, ordena las capas de menos a más cambiantes para maximizar la caché de Docker: primero dependencias, luego código.
¿Cuáles son las mejores prácticas de seguridad en un Dockerfile?
Las mejores prácticas de seguridad incluyen: usar imágenes base oficiales y ligeras como `alpine` o `slim`, no ejecutar como root añadiendo `USER nonroot`, instalar solo paquetes necesarios con `--no-cache-dir` o `apt-get clean`, copiar solo archivos necesarios usando `.dockerignore`, usar `COPY` en lugar de `ADD` para archivos locales, fijar versiones específicas de imágenes (evitar `latest`), habilitar healthchecks con `HEALTHCHECK`, y en producción usar multi-stage builds para minimizar la superficie de ataque.