Što su višefazne izgradnje i zašto ih koristiti?

Question

Accepted Answer

**Višefazne izgradnje** koriste više `FROM` faza u jednoj Dockerfile — primjena se gradi u jednoj fazi (sa svim alatima za izgradnju) i samo se konačni artefakti kopiraju u čistu, minimalnu konačnu fazu. To proizvodi **mnogo manje, sigurnije** slike za proizvodnju.

## Problem: alati za izgradnju otežavaju sliku

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

## Višefazna izgradnja

```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` kopira artefakte iz faze izgradnje u konačnu sliku. Konačna slika **isključuje sve iz faze izgradnje osim onoga što eksplicitno kopirate** — zato alati za izgradnju, razvojne ovisnosti i izvorni kod ne završe u proizvodnji.

## Prednosti

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

## Zašto je to važno

Razumijevanje višefaznih izgradnji je vrijedno za **proizvodnju malih, sigurnih slika za proizvodnju**, pa je to važno praktično znanje za izgradnju Docker slika proizvodne kvalitete.

Problem koji rješava je stvaran i čest: izgradnja aplikacije zahtijeva **alate za izgradnju** (kompajlere, SDK-e, razvojne ovisnosti) koje **konačna slika za proizvodnju ne bi trebala sadržavati** — njihovo uključivanje otežava sliku (veća veličina, sporije implementacije i preuzimanja) i povećava **površinu napada** (više instaliranog softvera znači više potencijalnih ranjivosti). **Višefazne izgradnje** rješavaju ovo elegantno korištenjem više `FROM` faza: primjena se gradi u fazi sa svim alatima, a zatim se **kopiraju samo konačni artefakti** (`--from=build`) u čistu, minimalnu konačnu fazu koja isključuje sve ostalo.

To proizvodi slike koje su **dramatično manje** (često 10x+ manje — samo runtime i artefakti) i **sigurnije** (bez alata za izgradnju ili nepotrebnih paketa za iskorištavanje), dok se sve održava u jednoj Dockerfile (bez zasebnih skripti za izgradnju).

Ovaj obrazac je standardan za kompajlirane jezike (Go, Rust, Java, gdje kompajler nije potreban tijekom izvođenja) i za frontend/Node izgradnje (gdje tooling za izgradnju i izvorni kod nisu potrebni u proizvodnji).

Pošto male, sigurne slike za proizvodnju važne za brzinu implementacije, pohranu i sigurnost, i pošto su višefazne izgradnje standardna, učinkovita tehnika za njihovo postizanje (odvajanje okruženja za izgradnju od štedljive runtime slike), razumijevanje višefaznih izgradnji — problem otežavanja/sigurnosti koji rješavaju, kako rade i njihove prednosti — je vrijednost, često primjenjivano znanje za izgradnju Docker slika proizvodne kvalitete, najbolja praksa koja se široko koristi u stvarnim Dockerfile datotekama i ključna vještina za proizvodnju učinkovitih, sigurnih aplikacija u kontejnerima.