Kako optimizirate velikost Docker slike in uspešnost gradnje?

Question

Accepted Answer

Optimizacija Docker slik vključuje zmanjšanje **velikosti** (manjše, hitrejše, bolj varno) in izboljšanje **uspešnosti gradnje** (hitrejša gradnja preko cachiranja). Tehnike vključujejo minimalne osnovne slike, večstopenjske gradnje, optimizacijo slojev, BuildKit in premišljeno oblikovanje Dockerfile.

## Zmanjšanje velikosti slike

```text
✓ MINIMAL base images:
  - alpine (tiny, ~5MB) — but musl libc can cause compatibility issues for some apps
  - slim variants (e.g. python:3.12-slim) — smaller than full, fewer compat issues
  - DISTROLESS — only the app + runtime, NO shell/package manager (smallest, most secure)
  - scratch — empty base (for static binaries, e.g. Go) → minimal image
✓ MULTI-STAGE builds — build with tools, ship only the artifact (huge size savings)
✓ Combine RUN layers + clean up IN the same layer:
  RUN apt-get update && apt-get install -y x && rm -rf /var/lib/apt/lists/*
  (cleanup in a SEPARATE layer doesn't shrink the image — the files are in the earlier layer)
✓ .dockerignore — keep junk out of the context/image
✓ Remove caches, temp files, dev dependencies in production images
```

## Izboljšanje uspešnosti gradnje

```text
✓ LAYER CACHING — order Dockerfile so stable layers (deps) come before volatile (code)
✓ BUILDKIT (DOCKER_BUILDKIT=1 / default in modern Docker) — faster, parallel builds,
  better caching, build secrets, cache mounts
✓ CACHE MOUNTS — RUN --mount=type=cache,target=/root/.npm npm install
  → persist package-manager caches BETWEEN builds (don't re-download every time)
✓ Registry cache / --cache-from — reuse cached layers in CI (where the cache is cold)
```

## Primer večstopenjske gradnje + distroless

```dockerfile
FROM golang:1.22 AS build
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o app .

FROM gcr.io/distroless/static     # no shell, no OS — tiny and secure
COPY --from=build /app/app /app
ENTRYPOINT ["/app"]
# → final image is a few MB: just the static binary (vs ~800MB with the full golang image)
```

## Zakaj je to pomembno

Optimizacija velikosti Docker slike in uspešnosti gradnje je dragoceno znanje za starejše razvojne inženirje, ker neposredno vpliva na **hitrost uvajanja, stroške shranjevanja, varnost in produktivnost razvojnih inženirjev**, zato je praktično pomembno za kakovostno containerizacijo v produkciji. **Zmanjšanje velikosti slike** je pomembno, ker manjše slike hitreje razmeščamo in prenesemo, ceneje jih shranjujemo in so **bolj varne** (manj paketov = manjša napadna površina): uporaba **minimalnih osnovnih slik** (alpine, slim, in posebej **distroless** — ki vsebuje samo aplikacijo in runtime brez lupine ali upravljavca paketov, najmanjša in najbolj varna — ali `scratch` za statične binarne datoteke), **večstopenjske gradnje** (pošiljanje samo artefaktov) in previdna **optimizacija slojev** (kombiniranje RUN ukazov s čiščenjem v *istem* sloju, ker čiščenje v ločenem sloju dejansko ne zmanjša slike — pogosta napačna predstava) lahko dramatično zmanjšajo slike (npr. s ~800MB na nekaj MB). **Izboljšanje uspešnosti gradnje** je pomembno, ker počasne gradnje škodijo produktivnosti razvojnih inženirjev in pretoku CI: izkoriščanje **cachiranja slojev** (razvrščanje od stabilnega k spremenljivemu), **BuildKit** (hitrejše vzporedne gradnje z boljšim cachiranjem) in posebej **cache montaž** (ohranjanje cache upravljavcev paketov med gradnjami, tako da se odvisnosti ne prenesejo vsakič znova — pomembno pohitritev) in cache v registru za CI vse to naredi gradnje hitrejše.

Razumevanje teh tehnk — in subtilnih točk, kot so zakaj je čiščenje v istem sloju pomembno in kako distroless izboljšuje tako velikost kot varnost — odraža globino, potrebno za ustvarjanje resnično optimiziranih slik.

Ker ima velikost slike in hitrost gradnje pravi, trajni vpliv na razmeščanje, stroške, varnost in produktivnost, ter ker so te tehnike optimizacije (minimalne/distroless osnovne slike, večstopenjske gradnje, pravilno čiščenje slojev, BuildKit cache montaže) tiste, ki dosegajo kompaktne, hitre in varne slike, je razumevanje optimizacije Docker slik in gradnje dragoceno znanje za starejše razvojne inženirje pri produkcijski containerizaciji, ključna veščina, ki loči strokovno in optimizovano rabo Dockerja ter odraža strokovnost, pričakovano za gradnjo učinkovitih, varnih slik kontejnerjev v obsegu.