Optimización de Imágenes de Docker

La optimización de imágenes en Docker consiste en hacer que las imágenes sean más rápidas de construir y más pequeñas de ejecutar.

Has aprendido a escribir tu propio Dockerfile. Has ejecutado el comando de construcción y tu aplicación funciona perfectamente. Estás orgulloso, pero pronto te das cuenta de dos problemas que aparecen en cuanto el proyecto crece:

¿Cómo es posible que algo tan simple ocupe tanto disco duro? ¿Y por qué el motor repite procesos que ya había hecho antes?

En este artículo vamos a mejorar nuestros Dockerfiles sin cambiar la aplicación. Vamos a aprender a aprovechar la caché para builds casi instantáneos y a usar Multi-stage Builds para crear imágenes mucho más pequeñas.

La caché de capas

Recuerda que una imagen son capas apiladas. Cuando ejecutas docker build, Docker recorre tu Dockerfile instrucción por instrucción.

Si Docker detecta un cambio en una línea (por ejemplo, has modificado el código fuente), invalida la caché para esa línea y para todas las líneas que van después.

El error común: Copiar todo al principio

# MAL USO DE LA CACHÉ ❌
FROM node:18
WORKDIR /app
COPY . .            # Aquí copias tu código
RUN npm install     # Aquí instalas dependencias (lento)
CMD ["node", "app.js"]

# BUEN USO DE LA CACHÉ ✅
FROM node:18
WORKDIR /app

# 1. Copiamos SOLO los archivos de definición de paquetes
COPY package.json package-lock.json .

# 2. Instalamos. Esta capa se cacheará y no se repetirá a menos que cambiemos dependencias.
RUN npm ci

# 3. AHORA copiamos el código fuente
COPY . .

CMD ["node", "app.js"]

Multi-stage Builds (Reduciendo el tamaño)

Ahora vamos a por el tamaño. Para compilar una aplicación (Java, Go, C#, o un frontend de React), necesitas muchas herramientas: compiladores (GCC), SDKs, gestores de paquetes (Maven, Node)…

Pero para ejecutar la aplicación, solo necesitas el binario o los archivos estáticos Si usas una imagen base con todas las herramientas (FROM golang o FROM node), tu imagen final pesará gigas porque lleva el compilador dentro, aunque ya no lo necesites.

Esta técnica nos permite usar una imagen “sucia y pesada” para compilar, y luego copiar solo el resultado a una imagen “limpia y ligera” para producción. Todo en un solo Dockerfile.

Ejemplo Práctico: Una App de React/Web

Imagina que tienes una web en React. Necesitas Node.js para compilarla (npm run build), pero para servirla solo necesitas un servidor web ligero (Nginx).

# --- ETAPA 1: BUILDER (El obrero) ---
# Le ponemos un alias "builder" para referirnos a ella luego
FROM node:18 AS builder
WORKDIR /app

COPY package*.json ./
RUN npm ci
COPY . .
# Esto crea la carpeta /app/dist con los HTML/CSS/JS optimizados
RUN npm run build

# --- ETAPA 2: RUNNER (El producto final) ---
# Empezamos DE CERO con una imagen vacía y ligera
FROM nginx:alpine

# Copiamos SOLO los archivos compilados de la etapa anterior
# --from=builder nos permite "robar" archivos de la otra imagen
COPY --from=builder /app/dist /usr/share/nginx/html

# No hace falta instalar Node, ni NPM, ni tener el código fuente original.
# Solo tenemos Nginx y los archivos estáticos.
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Resultados