¿Cómo funcionan las capas de imagen de Docker y el almacenamiento en caché de compilación?

Question

Accepted Answer

Las imágenes de Docker se construyen en **capas** — cada instrucción de Dockerfile crea una capa, y Docker **almacena en caché** las capas para acelerar las recompilaciones. Entender las capas y el almacenamiento en caché es clave para escribir Dockerfiles eficientes que se compilen rápido y produzcan imágenes más pequeñas.

## Por qué es importante

```text
Each Dockerfile instruction (FROM, RUN, COPY, etc.) creates a read-only LAYER:
  → layers stack to form the image; layers are CACHED and SHARED between images
  → if a layer is unchanged, Docker REUSES the cached layer (skips rebuilding it)
→ Layer caching makes rebuilds fast — only changed layers (and those AFTER) rebuild.
```

## La regla de almacenamiento en caché (el orden importa)

```text
Docker caches layers IN ORDER. When an instruction's input changes, that layer AND
ALL layers AFTER IT are rebuilt (cache invalidated from that point down).
→ Put STABLE things EARLY and FREQUENTLY-CHANGING things LATE in the Dockerfile.
```

## La optimización clásica: dependencias antes del código

```dockerfile
# ✅ GOOD — copy dependency manifest first, install, THEN copy code
COPY package*.json ./
RUN npm install          # this layer is cached UNLESS package.json changes
COPY . .                 # code changes here don't invalidate the npm install layer

# ❌ BAD — copy everything first
COPY . .                 # ANY code change invalidates...
RUN npm install          # ...so npm install RE-RUNS on every code change (slow!)
```

Al copiar archivos de dependencias e instalar **antes** de copiar el resto del código, la capa de instalación de dependencias (lenta) permanece almacenada en caché entre cambios de código — una optimización tremendamente importante que hace que las recompilaciones sean rápidas.

## Reducir el tamaño de la imagen

```text
✓ Combine related RUN commands (fewer layers) and clean up in the SAME layer
  RUN apt-get update && apt-get install -y x && rm -rf /var/lib/apt/lists/*
✓ Use small base images (alpine, slim, distroless)
✓ Use .dockerignore to exclude unneeded files from the build context
✓ Use multi-stage builds (build artifacts in one stage, copy only what's needed)
```

## Por qué es importante

Entender las capas de Docker y el almacenamiento en caché de compilación es importante para **escribir Dockerfiles eficientes** que se compilen rápidamente y produzcan imágenes más pequeñas, por lo que es un conocimiento práctico valioso que afecta significativamente a la productividad del desarrollador y al despliegue.

El concepto fundamental — cada instrucción de Dockerfile crea una **capa** almacenada en caché y reutilizable, y Docker **reutiliza las capas en caché sin cambios** mientras recompila las capas modificadas y todo después de ellas — explica cómo hacer que las compilaciones sean rápidas.

La **regla crítica de almacenamiento en caché** (el caché se invalida desde la primera instrucción modificada hacia abajo, por lo que el orden importa: cosas estables al principio, cosas que cambian frecuentemente al final) impulsa la **optimización individual más importante**: copiar archivos de dependencias e instalar dependencias **antes** de copiar el código de la aplicación, para que la capa de instalación de dependencias lenta permanezca almacenada en caché entre los cambios de código frecuentes (en lugar de re-ejecutar `npm install`/`pip install` en cada cambio de código — una diferencia entre compilaciones rápidas y dolorosamente lentas).

Entender este patrón únicamente mejora dramáticamente los tiempos de compilación, una preocupación constante de la experiencia del desarrollador.

Conocer técnicas para **reducir el tamaño de la imagen** — combinar comandos RUN con limpieza en la misma capa, usar imágenes base pequeñas (alpine, slim, distroless), `.dockerignore` para excluir archivos innecesarios, y compilaciones multi-stage — produce imágenes más pequeñas y más rápidas de desplegar (reduciendo almacenamiento, tiempo de transferencia y superficie de ataque).

Dado que las compilaciones de Docker ocurren constantemente (en desarrollo e CI/CD) y las compilaciones lentas o imágenes infladas perjudican la productividad y el despliegue, y dado que entender las capas y el almacenamiento en caché es lo que permite escribir Dockerfiles que se compilen rápido y se mantengan pequeños, entender las capas de Docker y el almacenamiento en caché de compilación — el modelo de capas, la regla de almacenamiento en caché dependiente del orden, la optimización de dependencias-antes-del-código, y técnicas de reducción de tamaño — es un conocimiento valioso y frecuentemente aplicado para el uso eficiente de Docker, una habilidad clave que distingue a quienes escriben Dockerfiles rápidos y ágiles de quienes sufren compilaciones lentas e imágenes infladas.