Kaip veikia Docker vaizdo sluoksniai ir sukūrimo podėlis?

Question

Accepted Answer

Docker vaizdai sudaromi iš **sluoksnių** — kiekviena Dockerfile instrukcija sukuria sluoksnį, ir Docker **podėlyje saugo** sluoksnius, kad pagreitintų pakartotinius sukūrimus. Sluoksnių ir podėlio supratimas yra raktas rašant efektyvius Dockerfiles, kurie greitai sudaromi ir sukuria mažesnius vaizdus.

## Sluoksniai — kiekviena instrukcija prideda sluoksnį

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

## Podėlio taisyklė (eilutės tvarka svarbi)

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

## Klasikinis optimizavimas: priklausomybės prieš kodą

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

Nukopijavus priklausomybių failus ir juos įdiegus **prieš** kopijuojant likusį kodą, (lėtas) priklausomybių įdiegimo sluoksnis išlieka podėlyje per kodo pakeitimus — ypač svarbus optimizavimas, kuris pagreitina pakartotinius sukūrimus.

## Vaizdo dydžio sumažinimas

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

## Kodėl tai svarbu

Docker sluoksnių ir sukūrimo podėlio supratimas yra svarbus **rašant efektyvius Dockerfiles**, kurie greitai sudaromi ir sukuria mažesnius vaizdus, todėl tai vertinga praktinė žinios, kuri žymiai paveikia programuotojo produktyvumą ir diegimą.

Pamatinė koncepcija — kiekviena Dockerfile instrukcija sukuria podėlyje saugomą, pakartotinai naudojamą **sluoksnį**, ir Docker **pakartotinai naudoja nepakitus,us podėlyje saugotus sluoksnius**, tuo tarpu kurie iš naujo sudaromi pakitę sluoksniai ir visi jų atgal — paaiškina, kaip pagreitinti sukūrimus.

**Kritinė podėlio taisyklė** (podėlis nebesuvalidas nuo pirmo pasikeitusio instrukcijos žemyn, todėl eilutės tvarka svarbi: stabilūs dalykai pradžioje, dažnai keičiami dalykai gale) paskatina **vienintelį svarbiausią optimizavimą**: priklausomybių failų kopijuojimą ir priklausomybių įdiegimą **prieš** aplikacijos kodo kopijuojimą, kad lėtas priklausomybių įdiegimo sluoksnis liktų podėlyje per dažnus kodo pakeitimus (o ne iš naujo vykdytų `npm install`/`pip install` kiekvienam kodo pakeitimui — skirtumas tarp greitų ir skausmingai lėtų pakartotinių sukūrimų).

Šito šablono supratimas vienas pats dramatiškai sutrumpina sukūrimo laiką, nuolatinę programuotojo patirties problemą.

Žinojimas apie **vaizdo dydžio mažinimo** metodus — RUN komandų sujungimas su valymu tame pačiame sluoksnyje, mažų bazinių vaizdų naudojimas (alpine, slim, distroless), `.dockerignore` nereikalingiems failams atmesti ir kelių etapų sukūrimai — pagamina mažesnius, greitesniam diegimui skirtus vaizdus (sumažina saugyklą, perdavimo laiką ir atakos paviršių).

Nes Docker sukūrimai vyksta nuolat (plėtojime ir CI/CD) ir lėti sukūrimai arba išpūsti vaizdai žeidžia produktyvumą ir diegimą, ir kadangi sluoksnių ir podėlio supratimas yra tai, kas leidžia rašyti Dockerfiles, kurie greitai sudaromi ir lieka nedideli, Docker sluoksnių ir sukūrimo podėlio supratimas — sluoksnio modelis, nuo eilutės tvarkos priklausoma podėlio taisyklė, priklausomybių prieš kodą optimizavimas ir dydžio mažinimo metodai — yra vertinga, dažnai taikoma žinios efektyviam Docker naudojimui, pagrindinė įgūdis, išskiriantis tuos, kurie rašo greitus, švarūs Dockerfiles nuo tų, kurie kenčia nuo lėtų sukūrimų ir išpūstų vaizdų.