Utilizzo della cache di build

La creazione di immagini Docker può richiedere tempo, soprattutto per le applicazioni complesse. La build cache di Docker è una funzionalità intelligente che aiuta a velocizzare notevolmente il processo!

Funziona riutilizzando i layer delle build precedenti, così Docker non deve ricostruire tutto da zero ogni volta.

Quando crea un'immagine Docker usando un Dockerfile, Docker esegue ogni istruzione riga per riga.

• Ogni istruzione, come FROM, RUN o COPY, crea un nuovo "layer" nell'immagine.
• Questi layer vengono impilati uno sopra l'altro per formare l'immagine finale.

Prima di eseguire un'istruzione, Docker controlla se ha già creato esattamente quel layer in precedenza. Confronta:

• L'istruzione stessa (ad esempio RUN apt update).
• Il "contesto" per determinate istruzioni (ad esempio i file copiati con COPY).

Se trova un layer corrispondente, Docker lo riutilizza dalla cache invece di eseguire nuovamente l'istruzione.

La cache è molto utile, ma non viene sempre utilizzata. Se Docker rileva una modifica in un'istruzione o nel relativo contesto, la cache per quel layer e tutti i layer successivi viene invalidata.

Ciò significa che Docker ricostruirà l'immagine a partire da quel punto, ignorando tutti i layer memorizzati nella cache sottostanti.

Per massimizzare gli utilizzi della cache, disponga le istruzioni del Dockerfile da quelle meno soggette a modifiche a quelle più soggette a modifiche.

• Prima le dipendenze stabili: installi i pacchetti di sistema o le dipendenze dell'applicazione che cambiano raramente.
• Per ultimo il codice dell'applicazione: copi il codice sorgente dell'applicazione, che cambia frequentemente, il più tardi possibile.

Vediamo un esempio. Posizionando il comando RUN pip install (che in genere cambia meno spesso) prima di COPY . . (che cambia a ogni aggiornamento del codice), Docker può riutilizzare il layer delle dipendenze.

Immagini che requirements.txt contenga flask e gunicorn e che app.py sia l'applicazione principale.

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"]

Se cambia solo app.py, Docker ricostruisce soltanto gli ultimi layer COPY e CMD, risparmiando tempo!

Quando usa COPY . ., Docker controlla le modifiche in ogni file del contesto di build. Anche file piccoli e irrilevanti, come le cartelle .git o i dati di test locali, possono invalidare la cache.

Utilizzi un file .dockerignore per escludere file e directory non necessari dal contesto di build. In questo modo evita che attivino l'invalidazione della cache.

Inserisca un file denominato .dockerignore nella radice del contesto di build, accanto al Dockerfile.

Esempio di .dockerignore:

.git
.venv
__pycache__
*.log
node_modules

Ora, quando usa COPY . ., Docker ignora questi file, ottenendo hit della cache più affidabili!

A volte è necessario assicurarsi che tutto venga compilato da zero, ignorando completamente la cache. Questa opzione può essere utile per il debugging o per assicurarsi di avere le versioni più recenti delle dipendenze.

Può obbligare Docker a ricostruire l'immagine senza usare la cache aggiungendo il flag --no-cache al comando di build:

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

Sta creando un'immagine Docker per un'applicazione Node.js. Attualmente il suo Dockerfile è il seguente:

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

Quale modifica ottimizzerebbe maggiormente questo Dockerfile per il caching della build?

Ottimo lavoro! Ha imparato a sfruttare la build cache di Docker per creare immagini più velocemente.

• Docker crea le immagini layer dopo layer, riutilizzando i layer memorizzati nella cache quando possibile.
• Le modifiche a un'istruzione o al relativo contesto invalidano la cache a partire da quel punto.
• Ottimizzi l'ordine delle istruzioni disponendole da quelle meno soggette a modifiche a quelle più soggette a modifiche.
• Utilizzi .dockerignore per escludere i file irrilevanti dal contesto di build.
• Utilizzi --no-cache per forzare una build da zero quando necessario.

Un caching efficiente accelera i cicli di sviluppo e rende i deployment più agili!