Bagaimana cara kerja layer image Docker dan build caching?

Question

Accepted Answer

Image Docker dibangun dalam **layer** — setiap instruksi Dockerfile membuat sebuah layer, dan Docker **cache** layer untuk mempercepat rebuild. Memahami layer dan caching adalah kunci untuk menulis Dockerfile yang efisien yang build cepat dan menghasilkan image yang lebih kecil.

## Layer — setiap instruksi menambah sebuah 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.
```

## Aturan caching (urutan 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.
```

## Optimasi klasik: dependency sebelum 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!)
```

Dengan copy file dependency dan install **sebelum** copy sisa code, layer install dependency yang (lambat) tetap cache di seluruh perubahan code — optimasi yang sangat penting yang membuat rebuild cepat.

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

## Mengapa ini penting

Memahami Docker layer dan build caching penting untuk **menulis Dockerfile yang efisien** yang build dengan cepat dan menghasilkan image yang lebih kecil, jadi ini adalah pengetahuan praktis yang berharga yang secara signifikan mempengaruhi produktivitas developer dan deployment.

Konsep fundamental — setiap instruksi Dockerfile membuat sebuah **layer** yang cache dan dapat digunakan kembali, dan Docker **menggunakan kembali layer cache yang tidak berubah** sambil rebuild layer yang berubah dan semua yang setelahnya — menjelaskan cara membuat build cepat.

**Aturan caching kritis** (cache menjadi invalid dari instruksi pertama yang berubah ke bawah, jadi urutan penting: hal yang stabil di awal, hal yang sering berubah di akhir) mendorong **optimasi tunggal paling penting**: copy file dependency dan install dependency **sebelum** copy code aplikasi, jadi layer install dependency yang lambat tetap cache di seluruh perubahan code yang sering (daripada menjalankan `npm install`/`pip install` pada setiap perubahan code — perbedaan antara rebuild cepat dan rebuild yang sangat lambat).

Memahami pola ini saja secara dramatis meningkatkan waktu build, sebuah kekhawatiran pengalaman developer yang konstan.

Mengetahui teknik untuk **mengurangi ukuran image** — menggabungkan perintah RUN dengan cleanup di layer yang sama, menggunakan base image kecil (alpine, slim, distroless), `.dockerignore` untuk mengecualikan file yang tidak diperlukan, dan multi-stage builds — menghasilkan image yang lebih kecil dan lebih cepat untuk deploy (mengurangi storage, waktu transfer, dan attack surface).

Karena Docker build terjadi terus-menerus (dalam development dan CI/CD) dan build lambat atau image yang membengkak merusak produktivitas dan deployment, dan karena memahami layer dan caching adalah yang memungkinkan menulis Dockerfile yang build cepat dan tetap kecil, memahami Docker layer dan build caching — model layer, aturan caching yang bergantung urutan, optimasi dependency-sebelum-code, dan teknik pengurangan ukuran — adalah pengetahuan yang berharga dan sering diterapkan untuk penggunaan Docker yang efisien, keterampilan kunci yang membedakan mereka yang menulis Dockerfile yang cepat dan lean dari mereka yang menderita build lambat dan image yang membengkak.