Come funzionano i livelli delle immagini Docker e la cache di build?

Question

Accepted Answer

Le immagini Docker vengono costruite in **livelli** — ogni istruzione del Dockerfile crea un livello, e Docker **memorizza nella cache** i livelli per accelerare le ricostruzioni. Comprendere i livelli e la cache è fondamentale per scrivere Dockerfile efficienti che si compilano velocemente e producono immagini più piccole.

## Livelli — ogni istruzione aggiunge un livello

```text
Each Dockerfile instruction (FROM, RUN, COPY, etc.) creates a read-only LAYER:
  → layers stack to form the image; layers are CACHED and SHARED between images
  → if a layer is unchanged, Docker REUSES the cached layer (skips rebuilding it)
→ Layer caching makes rebuilds fast — only changed layers (and those AFTER) rebuild.
```

## La regola della cache (l'ordine è importante)

```text
Docker caches layers IN ORDER. When an instruction's input changes, that layer AND
ALL layers AFTER IT are rebuilt (cache invalidated from that point down).
→ Put STABLE things EARLY and FREQUENTLY-CHANGING things LATE in the Dockerfile.
```

## L'ottimizzazione classica: dipendenze prima del codice

```dockerfile
# ✅ GOOD — copy dependency manifest first, install, THEN copy code
COPY package*.json ./
RUN npm install          # this layer is cached UNLESS package.json changes
COPY . .                 # code changes here don't invalidate the npm install layer

# ❌ BAD — copy everything first
COPY . .                 # ANY code change invalidates...
RUN npm install          # ...so npm install RE-RUNS on every code change (slow!)
```

Copiando i file di dipendenza e installando **prima** di copiare il resto del codice, il livello di installazione delle dipendenze (lento) rimane memorizzato nella cache tra i cambiamenti del codice — un'ottimizzazione enormemente importante che rende le ricostruzioni veloci.

## Ridurre la dimensione dell'immagine

```text
✓ Combine related RUN commands (fewer layers) and clean up in the SAME layer
  RUN apt-get update && apt-get install -y x && rm -rf /var/lib/apt/lists/*
✓ Use small base images (alpine, slim, distroless)
✓ Use .dockerignore to exclude unneeded files from the build context
✓ Use multi-stage builds (build artifacts in one stage, copy only what's needed)
```

## Perché è importante

Comprendere i livelli di Docker e la cache di build è importante per **scrivere Dockerfile efficienti** che si compilano velocemente e producono immagini più piccole, quindi è una conoscenza pratica preziosa che influisce significativamente sulla produttività degli sviluppatori e sullo schieramento.

Il concetto fondamentale — ogni istruzione del Dockerfile crea un **livello** memorizzato nella cache e riutilizzabile, e Docker **riutilizza i livelli della cache invariati** mentre ricostruisce i livelli modificati e tutto ciò che viene dopo di loro — spiega come rendere veloci le compilazioni.

La **regola critica della cache** (la cache si invalida dalla prima istruzione modificata in poi, quindi l'ordine è importante: cose stabili all'inizio, cose che cambiano frequentemente alla fine) guida l'**ottimizzazione più importante**: copiare i file di dipendenza e installare le dipendenze **prima** di copiare il codice dell'applicazione, quindi il livello di installazione delle dipendenze lento rimane memorizzato nella cache tra i frequenti cambiamenti del codice (piuttosto che rieseguire `npm install`/`pip install` ad ogni cambio di codice — una differenza tra ricostruzioni veloci e dolorosamente lente).

Comprendere questo pattern da solo migliora drasticamente i tempi di compilazione, una costante preoccupazione per l'esperienza dello sviluppatore.

Conoscere le tecniche per **ridurre la dimensione dell'immagine** — combinare comandi RUN con la pulizia nello stesso livello, usare immagini di base piccole (alpine, slim, distroless), `.dockerignore` per escludere file non necessari, e build multi-stage — produce immagini più piccole e più veloci da schierare (riducendo l'archiviazione, il tempo di trasferimento e la superficie di attacco).

Poiché le compilazioni Docker avvengono costantemente (nello sviluppo e in CI/CD) e le compilazioni lente o le immagini gonfie danneggiano la produttività e lo schieramento, e poiché comprendere i livelli e la cache è ciò che consente di scrivere Dockerfile che si compilano velocemente e rimangono piccoli, comprendere i livelli di Docker e la cache di build — il modello dei livelli, la regola di cache dipendente dall'ordine, l'ottimizzazione dipendenze-prima-del-codice, e le tecniche di riduzione delle dimensioni — è una conoscenza preziosa e frequentemente applicata per l'uso efficiente di Docker, un'abilità chiave che distingue coloro che scrivono Dockerfile veloci e snelli da coloro che soffrono di compilazioni lente e immagini gonfie.