🚀 Caché en Docker y Optimización de Builds

Una de las habilidades más importantes al trabajar con Docker no es únicamente saber crear imágenes, sino hacerlo de forma eficiente.

En esta clase se explica cómo funciona el sistema de caché de Docker, un concepto que muchos desarrolladores desconocen y que puede reducir builds de varios minutos a apenas unos segundos.

🧱 Docker funciona mediante capas

Para comprender la caché es necesario entender primero cómo está construida una imagen de Docker.

Una imagen no es un único bloque monolítico, sino una sucesión de capas (layers) que se van apilando unas sobre otras.

Cada instrucción importante del Dockerfile genera una nueva capa:

FROM
RUN
COPY
ADD
y otras instrucciones similares

Docker construye la imagen desde la capa inferior hacia arriba, reutilizando aquellas que no hayan cambiado.

💾 Cómo funciona la caché

Cada vez que Docker ejecuta una instrucción:

Comprueba si esa capa ya existe.
Calcula si hubo algún cambio respecto a la ejecución anterior.
Si no cambió nada, reutiliza la capa existente.
Si detecta un cambio, vuelve a construir esa capa y todas las siguientes.

Gracias a este mecanismo, Docker evita repetir trabajo innecesario durante cada build.

❌ Un Dockerfile mal organizado

Un error muy habitual consiste en copiar todo el proyecto antes de instalar las dependencias.

Por ejemplo:

COPY . .
RUN npm install

A primera vista parece correcto.

Sin embargo, cualquier modificación en un archivo del proyecto hará que Docker considere modificada la capa del COPY, invalidando también la capa donde se ejecuta npm install.

Como consecuencia:

Se reinstalan todas las dependencias.
El build vuelve a realizar trabajo innecesario.
El tiempo de construcción aumenta considerablemente.

⚠️ El problema aparece con cambios pequeños

Durante la clase se modifica únicamente el archivo server.js.

Aunque el cambio es mínimo, Docker detecta que la capa del COPY ha cambiado.

Como la instalación de dependencias ocurre después, también debe volver a ejecutarse.

Esto significa que un simple cambio en una línea de código puede provocar una reinstalación completa de paquetes.

✅ La forma correcta de aprovechar la caché

La solución consiste en separar la copia del archivo package.json del resto del código.

El orden recomendado es:

COPY package.json .
RUN npm install
COPY . .

Con este enfoque:

primero se copia el archivo que define las dependencias;
después se instalan los paquetes;
finalmente se copia el resto del proyecto.

Así, mientras package.json no cambie, Docker reutilizará la capa donde instaló las dependencias.

⚡ Builds mucho más rápidos

Cuando únicamente cambia un archivo como server.js:

Docker reutiliza la instalación de dependencias.
Solo vuelve a copiar los archivos modificados.
El build puede completarse prácticamente al instante.

En la demostración, la reconstrucción tarda 0 segundos porque todas las dependencias permanecen cacheadas.

🔄 La regla más importante de la caché

Docker procesa las capas en orden.

Si una capa cambia:

todas las capas posteriores quedan invalidadas.

Por eso es tan importante colocar primero aquellas instrucciones que cambian con poca frecuencia (como instalar dependencias) y dejar para el final las que cambian continuamente (como copiar el código fuente).

💰 Impacto en despliegues y costes

Comprender este funcionamiento no solo mejora la velocidad de desarrollo.

También puede reducir:

tiempos de despliegue;
consumo de recursos;
costes de infraestructura en servicios cloud como AWS.

Un Dockerfile bien estructurado supone una diferencia importante en proyectos reales.

📌 Ideas clave de esta clase

Quédate con estos conceptos:

Docker construye imágenes mediante capas.
Cada instrucción del Dockerfile genera una nueva capa.
Docker reutiliza automáticamente las capas que no cambian.
Un cambio invalida todas las capas posteriores.
Instalar dependencias después de copiar todo el proyecto rompe la caché.
Copiar primero package.json permite reutilizar npm install.
Un Dockerfile bien organizado puede reducir builds de minutos a segundos.
Comprender la caché mejora tanto el desarrollo como los despliegues en producción.

🚀 Lo siguiente

Ahora que entiendes cómo funciona la caché de Docker, ya puedes comenzar a estructurar tus Dockerfiles pensando en el rendimiento.

Con unos pequeños cambios en el orden de las instrucciones conseguirás builds mucho más rápidos, despliegues más eficientes y un mejor aprovechamiento de los recursos.

💡 Tip: Antes de escribir un Dockerfile, piensa qué archivos cambian con frecuencia y cuáles permanecen estables. Colocar primero los elementos más estables es la clave para sacar el máximo partido al sistema de caché de Docker.