Kako delujejo Docker slike (image layers) in predpomnilnik gradnje (build caching)?

Question

Accepted Answer

Docker slike so zgrajene v **plasteh** — vsak Dockerfile ukaz ustvari plast, in Docker **predpomni** plasti, da pospeši ponovne gradnje. Razumevanje plasti in predpomnilnika je ključno za pisanje učinkovitih Dockerfile-ov, ki se gradijo hitro in proizvajajo manjše slike.

## Plasti — vsak ukaz doda plast

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

## Pravilo predpomnilnika (vrstni red je pomemben)

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

## Klasična optimizacija: odvisnosti pred kodo

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

Z kopiranjem datotek odvisnosti in nameščanjem **pred** kopiranjem preostale kode ostane plast namestitve odvisnosti (počasna) predpomnjena med spremembami kode — izjemno pomembna optimizacija, ki naredi ponovne gradnje hitre.

## Zmanjšanje velikosti slike

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

## Zakaj je to pomembno

Razumevanje Docker plasti in predpomnilnika gradnje je pomembno za **pisanje učinkovitih Dockerfile-ov**, ki se gradijo hitro in proizvajajo manjše slike, zato je to dragoceno praktično znanje, ki bistveno vpliva na produktivnost razvojnega tima in razmestitev.

Temeljna koncept — vsak Dockerfile ukaz ustvari predpomnljen, ponovno uporaben **sloj**, in Docker **ponovno uporabi nespremenjene predpomnljene sloje**, medtem ko ponovno gradi spremenjene sloje in vse, kar pride za njimi — pojasnjuje, kako narediti gradnje hitre.

**Kritično pravilo predpomnilnika** (predpomnilnik se razveljavi od prvega spremenjenega ukaza naprej, zato je vrstni red pomemben: stabilne stvari zgodaj, pogosto spreminjajočih se stvari pozno) vodi **enajno najbolj pomembno optimizacijo**: kopiranje datotek odvisnosti in namestitev odvisnosti **pred** kopiranjem kode aplikacije, tako da plast namestitve odvisnosti (počasna) ostane predpomnjena med pogostimi spremembami kode (namesto da bi se `npm install`/`pip install` pognal pri vsaki spremembi kode — razlika med hitro in boleče počasno ponovnega gradnjo).

Razumevanje tega vzorca samo po sebi dramatično izboljša čase gradnje, kar je stalna skrb za izkušnjo razvojnega tima.

Znanje tehnik za **zmanjšanje velikosti slike** — kombiniranje RUN ukazov s čiščenjem v isti plasti, uporaba majhnih osnovnih slik (alpine, slim, distroless), `.dockerignore` za izključitev nepotrebnih datotek in večstopenjske gradnje — produce manjše, hitreje razmestljive slike (zmanjšanje shranjevanja, časa prenosa in napadalnega površja).

Ker se Docker gradnje dogajajo neprestano (v razvoju in CI/CD) in počasne gradnje ali prenatrpane slike škodijo produktivnosti in razmestitvi, ter ker je razumevanje plasti in predpomnilnika tisto, kar omogoča pisanje Dockerfile-ov, ki se gradijo hitro in ostajajo majhni, je razumevanje Docker plasti in predpomnilnika gradnje — model plasti, pravilo predpomnilnika odvisno od vrstnega reda, optimizacija odvisnosti pred kodo in tehnike zmanjšanja velikosti — dragoceno, pogosto uporabljeno znanje za učinkovito Docker uporabo, ključna veščina, ki loči tiste, ki pišejo hitre, vitke Dockerfile-e, od tistih, ki trpijo počasne gradnje in prenatrpane slike.