¿Qué es el contexto de compilación y por qué usar un archivo .dockerignore?

Question

Accepted Answer

Cuando ejecutas `docker build`, Docker envía el **contexto de compilación** (los archivos en el directorio de compilación) al demonio. Un archivo **.dockerignore** excluye archivos innecesarios de este contexto — acelerando compilaciones, reduciendo tamaño de imagen y evitando fugas de archivos sensibles.

## El contexto de compilación

```bash
docker build -t myapp .     # the "." is the build context — the directory sent to the daemon
# → Docker tarballs the ENTIRE context directory and sends it to the daemon BEFORE building
# → a big context (node_modules, .git, large files) = slow builds, more data transferred
```

El **contexto de compilación** es el conjunto de archivos que Docker envía al demonio para compilar la imagen. Todo en el directorio de compilación se incluye a menos que se excluya — por lo que un contexto hinchado ralentiza cada compilación.

## .dockerignore — excluir archivos innecesarios

```text
# .dockerignore (like .gitignore, for the build context)
node_modules        # don't send local deps (they're installed in the image anyway)
.git                # don't send version history
*.log
.env                # ⚠️ don't send SECRETS into the build context/image
Dockerfile
dist
.vscode
```

`.dockerignore` funciona como `.gitignore`, excluyendo archivos del contexto de compilación.

## Por qué es importante (tres beneficios)

```text
✓ FASTER builds — a smaller context transfers faster; fewer files to process
  (also helps caching: COPY . . won't be invalidated by irrelevant file changes)
✓ SMALLER images — excluded files (node_modules, .git) don't get COPYed into the image
✓ SECURITY — keep SECRETS (.env, keys, credentials) out of the context AND the image
  (a COPY . . could otherwise copy a .env file into the image — a real leak risk)
```

## Por qué es importante

Entender el contexto de compilación y `.dockerignore` es valioso para **compilaciones Docker eficientes y seguras**, por lo que es conocimiento prácticamente útil.

Muchos desarrolladores no se dan cuenta de que `docker build .` envía el **directorio de contexto de compilación completo al demonio** antes de compilar — por lo que un contexto hinchado (que contenga `node_modules`, `.git`, artefactos de compilación, archivos grandes) hace que **cada compilación sea más lenta** (más datos para transferir y procesar) y arriesga copiar archivos no deseados en la imagen.

El archivo **`.dockerignore`** (funcionando como `.gitignore`) aborda esto con tres beneficios concretos: **compilaciones más rápidas** (un contexto más pequeño se transfiere y procesa más rápido, y también mejora el almacenamiento en caché de capas ya que `COPY . .` no se invalidará por cambios en archivos irrelevantes), **imágenes más pequeñas** (los archivos excluidos no se copian — p. ej. no incluir `node_modules` locales que se reinstalan de todas formas), y crucialmente **seguridad** (manteniendo **secretos como archivos `.env`, claves y credenciales fuera del contexto de compilación e imagen** — ya que un `COPY . .` copiaría un `.env` en la imagen, un riesgo real y común de fuga de credenciales).

Este beneficio de seguridad es particularmente importante, ya que incrustar accidentalmente secretos o archivos sensibles en imágenes mediante una copia demasiado amplia es un error genuino que `.dockerignore` ayuda a prevenir.

Ya que las compilaciones ocurren constantemente y la eficiencia de compilación, tamaño de imagen y evitar fugas de secretos importan, y ya que entender el contexto de compilación y usar `.dockerignore` mejora directamente los tres, entender el contexto de compilación y `.dockerignore` es conocimiento Docker valioso y prácticamente relevante — una práctica simple pero importante para compilaciones rápidas, eficientes y seguras que es fácil de pasar por alto pero significativamente impactante, especialmente para prevenir la inclusión accidental de secretos en imágenes.