Pindho Docker image layers lan build caching kerja?

Question

Accepted Answer

Docker images dibangun ing **layers** — saben Dockerfile instruction nggawa layer, lan Docker **caches** layers kanggo nyepetaken rebuilds. Ngerti layers lan caching iku kunci kanggo nulis Dockerfiles sing efisien sing bangun cepet lan ngasilaken images sing luwih cilik.

## Layers — saben instruction nambah layer

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

## Caching rule (order penting)

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

## Optimisasi klasik: dependencies sadurunge 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!)
```

Awan ngopi file dependencies lan nginstal **sadurunge** ngopi kode sing liya, layer dependency-install sing (alon) tetep cached liwat perubahan code — optimisasi kang penting banget sing nggawe rebuilds cepet.

## Ngurangi ukuran image

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

## Apa bedane

Ngerti Docker layers lan build caching iku penting kanggo **nulis Dockerfiles sing efisien** sing bangun cepet lan ngasilaken images sing luwih cilik, dadi iku pengetahuan praktis berharga sing nyagawake efek signifikan kanggo produktivitas developer lan deployment.

Konsep dasar — saben Dockerfile instruction nggawa cached, reusable **layer**, lan Docker **nggunakake maneh unchaged cached layers** nalika rebuild changed layers lan kabeh sing sesudahane — njelasaken carane nggawe builds cepet.

**Critical caching rule** (cache invalidates saka instruction sing pisanan diganti mudhun, dadi order penting: stabil things wiwitan, frequently-changing things pungkasan) drive **optimisasi paling penting:** ngopi file dependencies lan nginstal dependencies **sadurunge** ngopi kode aplikasi, dadi layer alon dependency-install tetep cached liwat sering perubahan code (tinimbang ngulang `npm install`/`pip install` ing saben perubahan code — perbedaan antarane bangun cepet lan rebuilds sing nyenengake). Ngerti pola iki wae nggawe rebuild times luwih apik banget, kepedulian user-experience sing tetap.

Nguningake teknik kanggo **ngurangi ukuran image** — ngggabung RUN commands karo cleanup ing layer siji, nggunakake base images cilik (alpine, slim, distroless), `.dockerignore` kanggo ngasingake file sing ora kabutuhan, lan multi-stage builds — ngasilaken images luwih cilik, luwih cepet-deploy (ngurangi storage, transfer time, lan attack surface).
\