dockerize

name	dockerize
description	Generar Dockerfile optimizado. Activar cuando el usuario quiera crear contenedor, generar imagen Docker, configurar Docker Compose, contenerizar aplicacion o crear un Dockerfile multi-stage.

Generar Dockerfile optimizado

Resumen

Este skill genera un Dockerfile siguiendo las mejores prácticas de la industria: multi-stage builds para reducir el tamaño de la imagen final, ejecución con usuario no-root para seguridad, capas optimizadas para aprovechar la caché y health checks para la orquestación.

Un buen Dockerfile no es solo "que funcione", sino que sea seguro, rápido de construir, pequeño y mantenible.

Proceso

1. Detectar el stack del proyecto. Consultar el stack detectado en la configuración de Alfred para seleccionar la imagen base adecuada. Identificar el lenguaje, framework y runtime necesarios:

   • Node.js: node:XX-alpine o node:XX-slim.
   • Python: python:XX-slim o python:XX-alpine.
   • Rust: multi-stage con rust:XX para build y debian:XX-slim o gcr.io/distroless para runtime.
   • Go: multi-stage con golang:XX para build y scratch o gcr.io/distroless para runtime.

2. Diseñar multi-stage build. Separar la fase de construcción de la de ejecución:

   # Fase de build: incluye herramientas de compilación
   FROM node:20-alpine AS builder
   WORKDIR /app
   COPY package*.json ./
   RUN npm ci --only=production
   COPY . .
   RUN npm run build
   
   # Fase de runtime: solo lo necesario para ejecutar
   FROM node:20-alpine AS runtime
   WORKDIR /app
   COPY --from=builder /app/dist ./dist
   COPY --from=builder /app/node_modules ./node_modules
   

3. Optimizar el orden de capas para caché. Las capas que cambian menos van primero:

   • Primero: ficheros de dependencias (package.json, requirements.txt, Cargo.toml).
   • Segundo: instalación de dependencias.
   • Tercero: copia del código fuente.
   • Cuarto: build.

   Esto asegura que un cambio en el código no invalida la caché de dependencias.

4. Configurar usuario no-root. Nunca ejecutar la aplicación como root dentro del contenedor:

   RUN addgroup --system app && adduser --system --ingroup app app
   USER app
   

5. Añadir health check. Permitir al orquestador (Docker Compose, Kubernetes) verificar que la aplicación está sana:

   HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
     CMD curl -f http://localhost:3000/health || exit 1
   

6. Generar .dockerignore. Excluir todo lo que no es necesario en la imagen:

   node_modules
   .git
   .env
   *.md
   tests/
   .github/
   

7. Configurar variables de entorno. Usar ENV para valores por defecto y documentar qué variables se deben pasar en runtime con ARG o -e.

8. Verificar la imagen resultante. Comprobar el tamaño final, que no incluye herramientas de build innecesarias y que arranca correctamente.

Criterios de éxito

• El Dockerfile usa multi-stage build.
• La imagen base es mínima (alpine, slim o distroless).
• La aplicación se ejecuta con usuario no-root.
• Las capas están ordenadas para maximizar el uso de caché.
• Hay un health check configurado.
• Existe un .dockerignore que excluye ficheros innecesarios.
• La imagen final no incluye herramientas de build, tests ni código fuente innecesario.

Que NO hacer

• No usar latest como tag de imagen base. Siempre fijar la versión concreta (por ejemplo, node:20.11-alpine) para mejorar la reproducibilidad de los builds.
• No ejecutar la aplicación como root dentro del contenedor. Crear un usuario de sistema dedicado con los permisos mínimos necesarios.
• No copiar node_modules al contenedor desde el host. Instalar las dependencias dentro del contenedor para evitar incompatibilidades de plataforma y binarios nativos.
• No incluir secretos en la imagen (ficheros .env, claves privadas, tokens). Los secretos se pasan en runtime como variables de entorno o mediante sistemas de gestión de secretos.