Jak fungují vrstvy Docker obrazů a build caching?

Question

IT Interview Practice · Accepted Answer

Docker obrazy se vytvářejí v **vrstvách** — každá instrukce v Dockerfile vytvoří vrstvu a Docker **cachuje** vrstvy, aby urychlil přestavby. Porozumění vrstvám a cachingu je klíčové pro psaní efektivních Dockerfile, které se vytvářejí rychle a produkují menší obrazy.

## Vrstvy — každá instrukce přidá vrstvu

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

## Pravidlo cachingu (pořadí záleží)

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

## Klasická optimalizace: závislosti před kódem

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

Kopírováním souborů se závislostmi a instalací **před** kopírováním zbytku kódu zůstane (pomalá) vrstva instalace závislostí cachována v průběhu změn kódu — je to velmi důležitá optimalizace, která zajistí rychlé přestavby.

## Redukce velikosti obrazu

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

## Proč je to důležité

Porozumění vrstvám Docker obrazů a build cachingu je důležité pro **psaní efektivních Dockerfile**, které se vytvářejí rychle a produkují menší obrazy, takže je to cenné praktické znalosti, které výrazně ovlivňují produktivitu vývojářů a nasazení.

Základní koncept — každá instrukce Dockerfile vytvoří cachovanou, znovu použitelnou **vrstvu**, a Docker **znovu používá nezměněné cachované vrstvy**, zatímco přestavuje změněné vrstvy a všechno po nich — vysvětluje, jak vytvořit rychlé buildy.

**Kritické pravidlo cachingu** (cache se zneplatňuje od první změněné instrukce dolů, takže pořadí záleží: stabilní věci na začátku, často se měnící věci na konci) vede k **jediné nejdůležitější optimalizaci**: kopírování souborů se závislostmi a instalaci závislostí **před** kopírováním kódu aplikace, aby pomalá vrstva instalace závislostí zůstala cachována v průběhu časté změny kódu (místo opětovného spouštění `npm install`/`pip install` při každé změně kódu — rozdíl mezi rychlými a bolestivě pomalými přestavbami).

Porozumění tomuto vzoru samo o sobě dramaticky zlepšuje dobu buildů, což je neustálý problém zkušenosti vývojářů.

Znalost technik pro **redukci velikosti obrazu** — kombinování RUN příkazů s čisticím procesem ve stejné vrstvě, používání malých základních obrazů (alpine, slim, distroless), `.dockerignore` pro vyloučení nepotřebných souborů a multi-stage buildy — produkuje menší, rychleji nasaditené obrazy (snižující úložiště, dobu přenosu a plochu útoku).

Protože se Docker buildy děje neustále (ve vývoji a CI/CD) a pomalé buildy nebo přerostlé obrazy poškozují produktivitu a nasazení, a protože porozumění vrstvám a cachingu je to, co umožňuje psaní Dockerfile, které se vytvářejí rychle a zůstávají malé, je porozumění vrstvám a build cachingu Docker — model vrstev, pravidlo cachingu závislé na pořadí, optimalizace závislostí-před-kódem a techniky redukce velikosti — cenné, často aplikované znalosti pro efektivní používání Docker, klíčová dovednost rozlišující ty, kteří píší rychlé, štíhlé Dockerfile od těch, kteří trpí pomalými buildy a přerostlými obrazy.

Vrstvy — každá instrukce přidá vrstvu

Pravidlo cachingu (pořadí záleží)

Klasická optimalizace: závislosti před kódem

Redukce velikosti obrazu

Proč je to důležité

Související otázky