మల్టీ-స్టేజ్ బిల్డ్లు ఒకే Dockerfile లో బహుళ FROM స్టేజ్లను ఉపయోగిస్తాయి — అప్లికేషన్ను ఒక స్టేజ్లో (అన్ని బిల్డ్ టూల్ల ఉపయోగంతో) నిర్మించి, చివరి ఆర్టిఫ్యాక్ట్లను మాత్రమే శుభ్ర, కనిష్ట చివరి స్టేజ్లోకి కాపీ చేస్తాయి. ఇది చాలా చిన్న, మరింత సురక్షితమైన ఉత్పత్తి చిత్రాలను సృష్టిస్తుంది.
సమస్య: బిల్డ్ టూల్లు చిత్రాన్ని ఫూర్తిచేస్తాయి
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.
మల్టీ-స్టేజ్ బిల్డ్
# 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 బిల్డ్ స్టేజ్ నుండి ఆర్టిఫ్యాక్ట్లను చివరి చిత్రంలోకి కాపీ చేస్తుంది. చివరి చిత్రం బిల్డ్ స్టేజ్ నుండి మీరు స్పష్టంగా కాపీ చేసిన వాటిని మినహాయించి ఏదీ కలిగి ఉండదు — కాబట్టి బిల్డ్ టూల్లు, dev డిపెండెన్సీలు, మరియు సోర్స్ ఉత్పత్తిలో చేర్చబడవు.
ప్రయోజనాలు
✓ 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.
ఇది ఎందుకు ముఖ్యమైనది
మల్టీ-స్టేజ్ బిల్డ్లను అర్థం చేసుకోవడం చిన్న, సురక్షితమైన ఉత్పత్తి చిత్రాలను తయారు చేయడం కోసం విలువైనది, కాబట్టి ఇది ఉత్పత్తి-నాణ్యత Docker చిత్రాలను నిర్మించడానికి ముఖ్యమైన ఆచరణాత్మక జ్ఞానం.
ఇది పరిష్కరించే సమస్య వాస్తవమైనది మరియు సాధారణమైనది: అప్లికేషన్ను నిర్మించడానికి బిల్డ్ టూల్లు (కంపైలర్లు, SDK లు, dev డిపెండెన్సీలు) అవసరమయ్యే చివరి ఉత్పత్తి చిత్రం కలిగి ఉండకూడదు — వాటిని చేర్చడం చిత్రాన్ని ఫూర్తిచేస్తుంది (పెద్ద సైజ్, నెమ్మదిగా స్థాపన మరియు పుల్లు) మరియు దాడి ఉపరితలాన్ని పెంచుతుంది (ఎక్కువ ఇన్స్టాల్ చేసిన సాఫ్ట్వేర్ అంటే మరిన్ని సంభావ్య బద్దకాలు). మల్టీ-స్టేజ్ బిల్డ్లు ఇల్లను మెరుగైన విధంగా పరిష్కరిస్తాయి బహుళ FROM స్టేజ్లను ఉపయోగించడం ద్వారా: అన్ని టూల్ల ఉపయోగంతో ఒక స్టేజ్లో అప్లికేషన్ను నిర్మించి, ఆపై చివరి ఆర్టిఫ్యాక్ట్లను మాత్రమే (--from=build) శుభ్ర, కనిష్ట చివరి స్టేజ్లోకి కాపీ చేసి ఇతర ప్రతిదీ మినహాయించండి.
ఇది నాటకీయంగా చిన్న చిత్రాలను సృష్టిస్తుంది (తరచుగా 10x+ చిన్నది — కేవలం రানటైమ్ మరియు ఆర్టిఫ్యాక్ట్లు) మరియు మరింత సురక్షితమైనది (బిల్డ్ టూల్లు లేదా అనవసరమైన ప్యాకేజీలు లేవు దోపిడీకి), ఒక Dockerfile లో ఏదీ ఉంచుతూ (ప్రత్యేక బిల్డ్ స్క్రిప్ట్లు లేవు).
ఈ నమూనా సంకలిత భాషలకు ప్రామాణికమైనది (Go, Rust, Java, ఇక్కడ కంపైలర్ రানటైమ్లో అవసరం లేదు) మరియు ఫ్రంటెండ్/Node బిల్డ్ల కోసం (ఇక్కడ బిల్డ్ టూలింగ్ మరియు సోర్స్ ఉత్పత్తిలో అవసరం లేదు).
చిన్న, సురక్షితమైన ఉత్పత్తి చిత్రాలు స్థాపన వేగానికి, నిల్వకు, మరియు సంरक्षணకు ముఖ్యమైనవి కాబట్టి, మరియు మల్టీ-స్టేజ్ బిల్డ్లు వాటిని సాధించడానికి ప్రామాణిక, ప్రభావవంతమైన పద్ధతి కాబట్టి (బిల్డ్ పরిసరాన్ని విస్మరించిన రানటైమ్ చిత్రం నుండి విభజించడం), మల్టీ-స్టేజ్ బిల్డ్లను అర్థం చేసుకోవడం — ఫూర్తి/సంरक्षణ సమస్య వారు పరిష్కరిస్తారు, అవి ఎలా పనిచేస్తాయి, మరియు వారి ప్రయోజనాలు — విలువైన, తరచుగా-వర్తించిన జ్ఞానం ఉత్పత్తి-నాణ్యత Docker చిత్రాలను నిర్మించడానికి, విస్తృతంగా ఉపయోగించిన ఉత్తమ ఆచరణ నిజ-ప్రపంచ Dockerfiles లో మరియు సమర్థవంతమైన, సురక్షితమైన కంటేనరైజ్డ అప్లికేషన్లను ఉత్పత్తి చేయడానికి కీ నైపుణ్యం.