Aprovechamiento de la caché de compilación

Crear imágenes de Docker puede llevar tiempo, especialmente en aplicaciones complejas. La caché de compilación de Docker es una función inteligente que ayuda a acelerar considerablemente el proceso.

Funciona reutilizando capas de compilaciones anteriores, por lo que Docker no tiene que volver a compilar todo desde cero cada vez.

Cuando crea una imagen de Docker mediante un Dockerfile, Docker ejecuta cada instrucción línea por línea.

• Cada instrucción, como FROM, RUN o COPY, crea una nueva "capa" en su imagen.
• Estas capas se apilan unas sobre otras para formar la imagen final.

Antes de ejecutar una instrucción, Docker comprueba si ya ha creado exactamente esa capa anteriormente. Compara lo siguiente:

• La propia instrucción (por ejemplo, RUN apt update).
• El "contexto" de determinadas instrucciones (por ejemplo, los archivos que se indican mediante COPY).

Si encuentra una capa coincidente, Docker la reutiliza desde la caché en lugar de volver a ejecutar la instrucción.

La caché es excelente, pero no siempre se utiliza. Si Docker detecta algún cambio en una instrucción o en su contexto, se invalida la caché de esa capa y de todas las capas posteriores.

Esto significa que Docker volverá a compilar a partir de ese punto, ignorando las capas almacenadas en caché que se encuentren por debajo.

Para maximizar los aciertos de caché, organice las instrucciones de su Dockerfile desde las que tienen menos probabilidades de cambiar hasta las que tienen más probabilidades de cambiar.

• Primero las dependencias estables: instale los paquetes del sistema o las dependencias de la aplicación que cambien con poca frecuencia.
• Al final, el código de la aplicación: copie el código fuente de su aplicación, que cambia con frecuencia, lo más tarde posible.

Veamos un ejemplo. Al colocar el comando RUN pip install (que normalmente cambia con menos frecuencia) antes de COPY . . (que cambia con cada actualización del código), Docker puede reutilizar la capa de dependencias.

Imagine que requirements.txt contiene flask y gunicorn, y que app.py es su aplicación principal.

Dockerfile:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
CMD ["python", "app.py"]

Si solo cambia app.py, Docker solo vuelve a crear las últimas capas COPY y CMD, lo que ahorra tiempo.

Cuando utiliza COPY . ., Docker comprueba si ha habido cambios en cada archivo del contexto de compilación. Incluso los archivos pequeños e irrelevantes (como las carpetas .git o los datos de pruebas locales) pueden invalidar la caché.

Utilice un archivo .dockerignore para excluir archivos y directorios innecesarios del contexto de compilación. Así evitará que provoquen invalidaciones de la caché.

Coloque un archivo llamado .dockerignore en la raíz del contexto de compilación (junto a su Dockerfile).

Ejemplo de .dockerignore:

.git
.venv
__pycache__
*.log
node_modules

Ahora, cuando utilice COPY . ., Docker ignorará estos archivos, lo que permitirá obtener aciertos de caché más fiables.

A veces querrá asegurarse de que todo se compile desde cero, ignorando completamente la caché. Esto puede resultar útil para depurar o para asegurarse de disponer de las versiones más recientes de las dependencias.

Puede forzar a Docker a volver a compilar sin utilizar la caché añadiendo la opción --no-cache al comando de compilación:

docker build --no-cache -t my-app:latest .

Está creando una imagen de Docker para una aplicación de Node.js. Actualmente, su Dockerfile tiene este aspecto:

FROM node:16-alpine
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

¿Qué cambio optimizaría mejor este Dockerfile para aprovechar la caché de compilación?

¡Buen trabajo! Ha aprendido a aprovechar la caché de compilación de Docker para crear imágenes más rápidamente.

• Docker crea las imágenes capa por capa y reutiliza las capas almacenadas en caché cuando es posible.
• Los cambios en una instrucción o en su contexto invalidan la caché a partir de ese punto.
• Optimice el proceso ordenando las instrucciones desde las que tienen menos probabilidades de cambiar hasta las que tienen más probabilidades de cambiar.
• Utilice .dockerignore para excluir archivos irrelevantes del contexto de compilación.
• Utilice --no-cache para forzar una compilación desde cero cuando sea necesario.

Una caché eficiente permite ciclos de desarrollo más rápidos y despliegues más ágiles.