Apakah itu multi-stage builds dan mengapa menggunakannya?

Question

Accepted Answer

**Multi-stage builds** menggunakan pelbagai peringkat `FROM` dalam satu Dockerfile — membina aplikasi dalam satu peringkat (dengan semua alat pembinaan) dan menyalin hanya artifak akhir ke dalam peringkat akhir yang bersih dan minimum. Ini menghasilkan image pengeluaran yang **jauh lebih kecil dan lebih selamat**.

## Masalah: alat pembinaan membengkakkan image

```text
Building an app needs build tools (compilers, dev dependencies, SDKs), but the
FINAL image shouldn't include them:
  → they bloat the image (larger size, slower deploys)
  → they increase the attack surface (more software = more vulnerabilities)
→ You want only the built artifact + its runtime in the final image.
```

## Multi-stage build

```dockerfile
# STAGE 1: "build" — has all the build tools (compile/bundle the app)
FROM node:20 AS build
WORKDIR /app
COPY package*.json ./
RUN npm install              # includes dev dependencies, build tools
COPY . .
RUN npm run build            # produces /app/dist

# STAGE 2: final — a clean, minimal image with ONLY the built artifact
FROM nginx:alpine
COPY --from=build /app/dist /usr/share/nginx/html   # copy ONLY the build output
# → the final image has NO build tools, no dev dependencies — just nginx + the built files
```

`--from=build` menyalin artifak daripada peringkat build ke dalam image akhir. Image akhir **mengecualikan segala-galanya daripada peringkat build kecuali apa yang anda salin secara eksplisit** — jadi alat pembinaan, dev dependencies, dan kod sumber tidak berakhir dalam pengeluaran.

## Faedah

```text
✓ SMALLER images — only the runtime + artifacts (often 10x+ smaller)
✓ More SECURE — fewer packages = smaller attack surface (no compilers/build tools)
✓ Faster deploys/pulls (smaller images transfer faster)
✓ One Dockerfile — build and final image together (no separate build scripts)
→ Common for compiled languages (Go, Rust, Java) and Node/frontend builds.
```

## Mengapa ia penting

Memahami multi-stage builds adalah berharga untuk **menghasilkan image pengeluaran yang kecil dan selamat**, jadi ia merupakan pengetahuan praktikal yang penting untuk membina image Docker berkualiti pengeluaran.

Masalah yang diselesaikannya adalah nyata dan biasa: membina aplikasi memerlukan **alat pembinaan** (compiler, SDK, dev dependencies) yang **image pengeluaran akhir tidak sepatutnya mengandungi** — memasukkannya membengkakkan image (saiz lebih besar, penempatan dan pull lebih perlahan) dan meningkatkan **permukaan serangan** (lebih banyak perisian yang dipasang bermakna lebih banyak potensi kerentanan). **Multi-stage builds** menyelesaikan ini dengan elegan dengan menggunakan pelbagai peringkat `FROM`: membina aplikasi dalam satu peringkat dengan semua alat, kemudian **menyalin hanya artifak akhir** (`--from=build`) ke dalam peringkat akhir yang bersih dan minimum yang mengecualikan segala-galanya yang lain.

Ini menghasilkan image yang **jauh lebih kecil** (selalunya 10x+ lebih kecil — hanya runtime dan artifak) dan **lebih selamat** (tiada alat pembinaan atau pakej yang tidak perlu untuk dieksploitasi), sambil mengekalkan segala-galanya dalam satu Dockerfile (tiada skrip pembinaan berasingan).

Corak ini adalah standard untuk bahasa yang dikompil (Go, Rust, Java, di mana compiler tidak diperlukan pada runtime) dan untuk pembinaan frontend/Node (di mana alat pembinaan dan kod sumber tidak diperlukan dalam pengeluaran).

Memandangkan image pengeluaran yang kecil dan selamat penting untuk kelajuan penempatan, storan, dan keselamatan, dan memandangkan multi-stage builds ialah teknik standard yang berkesan untuk mencapainya (memisahkan persekitaran pembinaan daripada image runtime yang ringan), memahami multi-stage builds — masalah bengkak/keselamatan yang diselesaikannya, cara ia berfungsi, dan faedahnya — ialah pengetahuan berharga yang kerap digunakan untuk membina image Docker berkualiti pengeluaran, satu amalan terbaik yang digunakan secara meluas dalam Dockerfile dunia sebenar serta kemahiran utama untuk menghasilkan aplikasi ber-container yang cekap dan selamat.