Hoe werken Docker image layers en build caching?

Question

Accepted Answer

Docker images worden gebouwd in **layers** — elke Dockerfile instructie creëert een layer, en Docker **cached** layers om rebuilds te versnellen. Het begrijpen van layers en caching is essentieel voor het schrijven van efficiënte Dockerfiles die snel bouwen en kleinere images produceren.

## Layers — elke instructie voegt een layer toe

```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.
```

## De caching regel (volgorde is belangrijk)

```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.
```

## De klassieke optimalisatie: dependencies vóór code

```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!)
```

Door dependency files te kopiëren en te installeren **voordat** je de rest van de code kopieert, blijft de (langzame) dependency-install layer gecached in code wijzigingen — een enorm belangrijke optimalisatie die rebuilds snel maakt.

## Image grootte verkleinen

```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)
```

## Waarom het belangrijk is

Het begrijpen van Docker layers en build caching is belangrijk voor het **schrijven van efficiënte Dockerfiles** die snel bouwen en kleinere images produceren, dus het is waardevolle praktische kennis die productiviteit en deployment aanzienlijk beïnvloedt.

Het fundamentele concept — elke Dockerfile instructie creëert een gecachede, herbruikbare **layer**, en Docker **hergebruikt ongewijzigde gecachede layers** terwijl het gewijzigde layers en alles daarna opnieuw bouwt — verklaart hoe je builds snel maakt.

De **kritische caching regel** (cache wordt ongeldig gemaakt vanaf de eerste gewijzigde instructie naar beneden, dus volgorde is belangrijk: stabiele zaken eerst, regelmatig veranderende zaken laatst) bepaalt de **enige meest belangrijke optimalisatie**: dependency files kopiëren en afhankelijkheden installeren **voordat** je application code kopieert, dus de langzame dependency-install layer blijft gecached in regelmatige code wijzigingen (in plaats van `npm install`/`pip install` telkens opnieuw uit te voeren bij elke code wijziging — een verschil tussen snelle en pijnlijk langzame rebuilds).

Het begrijpen van alleen dit patroon verbetert build times drastisch, een constant developer-experience concern.

Het kennen van technieken om **image grootte te verkleinen** — RUN commando's combineren met opschoning in dezelfde layer, kleine base images gebruiken (alpine, slim, distroless), `.dockerignore` om onnodig bestanden uit te sluiten, en multi-stage builds — produceert kleinere, sneller in te zetten images (reduceer opslag, transfer tijd en attack surface).

Daardat Docker builds constant plaatsvinden (in development en CI/CD) en langzame builds of opgeblazen images productiviteit en deployment schaden, en omdat het begrijpen van layers en caching is wat het mogelijk maakt Dockerfiles te schrijven die snel bouwen en klein blijven, is het begrijpen van Docker layers en build caching — het layer model, de order-afhankelijke caching regel, de dependencies-before-code optimalisatie, en size-reduction technieken — waardevolle, regelmatig toegepaste kennis voor efficiënt Docker gebruik, een sleutelkwaliteit die die onderscheidt die snelle, slanke Dockerfiles schrijven van die langzame builds en opgeblazen images ondergaan.