¿Qué son las compilaciones multi-etapa y por qué usarlas?

Question

Accepted Answer

**Las compilaciones multi-etapa** usan múltiples etapas `FROM` en un solo Dockerfile — construyendo la aplicación en una etapa (con todas las herramientas de compilación) y copiando solo los artefactos finales a una etapa final limpia y mínima. Esto produce imágenes de producción **mucho más pequeñas y seguras**.

## El problema: las herramientas de compilación inflan la imagen

```text
Building an app needs build tools (compilers, dev dependencies, SDKs), but the
FINAL image shouldn't include them:
  → they bloat the image (larger size, slower deploys)
  → they increase the attack surface (more software = more vulnerabilities)
→ You want only the built artifact + its runtime in the final image.
```

## Compilación multi-etapa

```dockerfile
# STAGE 1: "build" — has all the build tools (compile/bundle the app)
FROM node:20 AS build
WORKDIR /app
COPY package*.json ./
RUN npm install              # includes dev dependencies, build tools
COPY . .
RUN npm run build            # produces /app/dist

# STAGE 2: final — a clean, minimal image with ONLY the built artifact
FROM nginx:alpine
COPY --from=build /app/dist /usr/share/nginx/html   # copy ONLY the build output
# → the final image has NO build tools, no dev dependencies — just nginx + the built files
```

El `--from=build` copia artefactos de la etapa de compilación a la imagen final. La imagen final **excluye todo de la etapa de compilación excepto lo que copias explícitamente** — así las herramientas de compilación, dependencias de desarrollo y código fuente no terminan en producción.

## Beneficios

```text
✓ SMALLER images — only the runtime + artifacts (often 10x+ smaller)
✓ More SECURE — fewer packages = smaller attack surface (no compilers/build tools)
✓ Faster deploys/pulls (smaller images transfer faster)
✓ One Dockerfile — build and final image together (no separate build scripts)
→ Common for compiled languages (Go, Rust, Java) and Node/frontend builds.
```

## Por qué es importante

Comprender las compilaciones multi-etapa es valioso para **producir imágenes de producción pequeñas y seguras**, por lo que es conocimiento práctico importante para construir imágenes Docker de calidad productiva.

El problema que resuelve es real y común: compilar una aplicación requiere **herramientas de compilación** (compiladores, SDKs, dependencias de desarrollo) que la **imagen de producción final no debería contener** — incluirlas infla la imagen (mayor tamaño, despliegues y descargas más lentos) e incrementa la **superficie de ataque** (más software instalado significa más vulnerabilidades potenciales). **Las compilaciones multi-etapa** resuelven esto elegantemente usando múltiples etapas `FROM`: compilando la aplicación en una etapa con todas las herramientas, luego **copiando solo los artefactos finales** (`--from=build`) a una etapa final limpia y mínima que excluye todo lo demás.

Esto produce imágenes que son **dramáticamente más pequeñas** (frecuentemente 10x+ más pequeñas — solo el runtime y artefactos) y **más seguras** (sin herramientas de compilación ni paquetes innecesarios para explotar), mientras se mantiene todo en un solo Dockerfile (sin scripts de compilación separados).

Este patrón es estándar para lenguajes compilados (Go, Rust, Java, donde el compilador no es necesario en runtime) y para compilaciones frontend/Node (donde las herramientas de compilación y el código fuente no son necesarios en producción).

Ya que imágenes de producción pequeñas y seguras importan para la velocidad de despliegue, almacenamiento y seguridad, y ya que las compilaciones multi-etapa son la técnica estándar y efectiva para lograrlas (separando el entorno de compilación de la imagen runtime esbelta), comprender las compilaciones multi-etapa — el problema de inflado/seguridad que resuelven, cómo funcionan y sus beneficios — es conocimiento valioso, aplicado frecuentemente para construir imágenes Docker de calidad productiva, una mejor práctica ampliamente usada en Dockerfiles del mundo real y una habilidad clave para producir aplicaciones containerizadas eficientes y seguras.