Docker Compose में build बनाम image का सही उपयोग
Docker Compose में image और build कीवर्ड के बीच का अंतर समझें। जानें कि VPS पर Dockerfile में बदलाव करने के बाद भी compose up क्यों अपडेट नहीं होता और इसे कैसे ठीक करें।
Docker Compose build बनाम image: संक्षिप्त उत्तर
Docker Compose फ़ाइल में, image: उस image की पहचान करता है जिसका उपयोग करना है, जिसमें local image, tag या digest reference शामिल हैं, और build: Compose को बताता है कि source से image कैसे build करनी है। केवल image: सेट करें और Compose, pull_policy के अनुसार image का उपयोग करेगा या उसे pull करेगा। केवल build: सेट करें और Compose कॉन्फ़िगर किए गए builder के साथ image build करेगा, जिसे project के नाम और service के नाम से व्युत्पन्न एक नाम देगा। दोनों को सेट करें और pull_policy यह नियंत्रित करता है कि Compose pull करे या build; जब यह build करता है, तो यह परिणाम को image: में दिए गए नाम के साथ tag करता है, जो कि आपके द्वारा चुने गए नाम के तहत image build करने और उसे push करने का तरीका है। Builder स्थानीय रूप से या remote Docker host पर चल सकता है।
यही पूरा अंतर है। नीचे दी गई हर चीज़ का मतलब सर्वर पर संचालन के संदर्भ में है। यह मानकर चला गया है कि Docker Engine और Compose plugin पहले से इंस्टॉल हैं; VPS पर Docker चलाना उस भाग को कवर करता है।
तीनों रूप पूर्ण विवरण में
एक प्रकाशित tag का उपयोग करें, यदि वह default pull policy के अंतर्गत मौजूद नहीं है तो उसे pull करें। इस प्रक्रिया में कहीं भी Dockerfile शामिल नहीं है।
services:
web:
image: nginx:1.27
restart: unless-stopped
ports:
- "80:80"प्रोजेक्ट डायरेक्टरी में मौजूद Dockerfile से build करें। यह build Dockerfile द्वारा आवश्यक images को pull और dependencies को download भी कर सकती है।
services:
web:
build: .
restart: unless-stopped
ports:
- "80:80"परिणाम को docker compose build के साथ build और tag करें; स्पष्ट pull policy के बिना, up build करने से पहले इस image को pull करने का प्रयास करता है। इसके बाद docker compose push उस सटीक tag को registry में भेज सकता है।
services:
web:
build:
context: .
dockerfile: Dockerfile
image: registry.example.com/acme/web:1.4.2
restart: unless-stopped
ports:
- "80:80"context वह डायरेक्टरी है जिसे builder को भेजा जाता है। dockerfile को उस context के सापेक्ष resolve किया जाता है, इसलिए dockerfile: docker/prod.Dockerfile के साथ context: . का उपयोग सामान्य और सही है। प्रत्येक service container के पीछे image का नाम और image ID देखने के लिए docker compose images चलाएँ; यह पुष्टि करने के लिए Compose file की जाँच करें कि क्या service image:, build: या दोनों का उपयोग करती है।
Dockerfile में बदलाव करने के बाद docker compose up फिर से build क्यों नहीं करता है?
क्योंकि सामान्य up एक मौजूदा image का ही पुन: उपयोग करता है, जब तक कि आप build का अनुरोध न करें या ऐसी policy configure न करें जिसके लिए इसकी आवश्यकता हो।
जब Compose किसी ऐसी service को start करता है जिसमें केवल build: section होता है, तो वह उपलब्ध होने पर मौजूदा image का उपयोग करता है। यह आपके Dockerfile को नहीं पढ़ता, source files की तुलना नहीं करता, और न ही किसी timestamp को देखता है। image: और build: दोनों के मौजूद होने पर और किसी स्पष्ट pull_policy के न होने पर, Compose पहले pull करने का प्रयास करता है और यदि image registry या platform cache में उपलब्ध नहीं होती है, तभी build करता है। मौजूदा image को ही पर्याप्त मान लिया जाता है।
इसलिए आप app.py को edit करते हैं, docker compose up -d चलाते हैं, और देखते हैं कि Compose container को running रिपोर्ट करता है, जबकि वह पुराना code ही serve कर रहा होता है। कुछ भी fail नहीं हुआ, इसलिए किसी ने आपको चेतावनी भी नहीं दी। इसका संकेत वह status शब्द है जिसे Compose container नाम के बगल में print करता है: जिस container को Compose ने replace किया है, वह recreated या started रिपोर्ट करता है, और जिस container को Compose ने नहीं छेड़ा है, वह running रिपोर्ट करता है।
दो जाँचें इसे स्पष्ट कर देती हैं। docker compose images उस image ID को print करता है जिसका उपयोग प्रत्येक container कर रहा है, इसलिए deploy से पहले इसे नोट करें और बाद में तुलना करें। docker image ls में एक CREATED column होता है, लेकिन cached builds और reproducible timestamps का मतलब है कि केवल वह तारीख यह साबित नहीं करती कि आपका नवीनतम source build किया गया है या नहीं।
कौन से flags rebuild को बाध्य करते हैं
docker compose up -d --buildपहले build करता है, फिर उन सभी containers को recreate करता है जिनकी image बदल गई है। यह वह flag है जिसे ज्यादातर लोग ढूंढ रहे होते हैं।docker compose build webकेवल एक service को build करता है और कुछ भी start नहीं करता। इसके बादdocker compose up --no-deps -d webचलाएं ताकि केवल उस container को replace किया जा सके और बाकी stack चलता रहे।docker compose build --no-cache webcached layers को अनदेखा करता है और service को फिर से build करता है।docker compose build --pullFROMमें base image का नया version pull करने का प्रयास करता है, ताकिnode:22जैसा moving tag मार्च में डाउनलोड की गई copy के बजाय उसकी वर्तमान सामग्री को प्राप्त कर सके।docker compose up -d --force-recreatecontainer को फिर से बनाने (recreate) के लिए बाध्य करता है, भले ही configuration और image न बदली हो। यह flag स्वयं build का अनुरोध नहीं करता है, लेकिन यदि image गायब हो या pull policy की आवश्यकता हो तोupअभी भी build कर सकता है। जब आपका मतलब--buildहो, तब इसका उपयोग करना एक सामान्य गलती है।
आप इस निर्णय को file के भीतर भी ले जा सकते हैं। Compose specification के शब्दों में, pull_policy: build का अर्थ है कि Compose image को build करता है, और यदि वह पहले से मौजूद है तो उसे फिर से build करता है। तब हर up एक build की लागत लगाता है, जो laptop पर तो ठीक है लेकिन server पर शायद ही कभी वांछित होता है।
services:
web:
build: .
image: registry.example.com/acme/web:dev
pull_policy: buildएक और interaction जानना उपयोगी है। docker compose pull उन services के लिए भी images pull करने का प्रयास करता है जिनमें build section होता है, और यदि वह pull विफल हो जाता है तो यह आपको बताता है कि इसके बजाय image को build किया जाना चाहिए। उन services को चुपचाप छोड़ने के लिए --ignore-buildable पास करें।
बिल्ड कैश यह कैसे तय करता है कि आपका डिप्लॉयमेंट समय कितना होगा
बिल्डर प्रत्येक Dockerfile निर्देश की जांच करता है कि क्या उसका परिणाम कैश से दोबारा इस्तेमाल किया जा सकता है, बशर्ते वह निर्देश और उसके इनपुट अपरिवर्तित हों। COPY के लिए, इनपुट में फाइल की सामग्री और मेटाडेटा शामिल होते हैं, लेकिन मॉडिफिकेशन टाइम शामिल नहीं होता। एक बार जब कोई लेयर कैश में नहीं मिलती (miss), तो उस पर निर्भर बाद के सभी स्टेप्स को फिर से बिल्ड किया जाता है।
यह एक नियम तय करता है कि आपका डिप्लॉयमेंट सेकंड में होगा या मिनटों में। Dockerfile को इस क्रम में व्यवस्थित करें कि जो चीजें शायद ही कभी बदलती हैं, वे ऊपर रहें और जो हर कमिट पर बदलती हैं, वे नीचे।
FROM node:22-slim
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
CMD ["node", "server.js"]npm ci, COPY . . के ऊपर स्थित होता है, इसलिए सोर्स फाइल में बदलाव करने पर भी इंस्टॉल लेयर कैश में बनी रहती है और बिल्ड कॉपी स्टेप से फिर से शुरू होता है। यदि आप उन दो लाइनों को आपस में बदल देते हैं, तो एक अक्षर का बदलाव भी हर डिपेंडेंसी को फिर से इंस्टॉल कर देगा, क्योंकि COPY . . उस लेयर को अमान्य (invalidate) कर देता है जिस पर npm ci आधारित है। यही तर्क pip install -r requirements.txt और go mod download पर भी लागू होता है।
जब आपको संदेह हो कि कोई पुरानी लेयर आपके फिक्स को छिपा रही है, तो --no-cache सही टूल है। इसे डिफ़ॉल्ट रूप से इस्तेमाल करना गलत है, क्योंकि यह उस पुन: उपयोग (reuse) को खत्म कर देता है जिसे Dockerfile के सही क्रम से हासिल किया जाता है।
एक चीज जो इमेज सेट करती है और जिसे Compose ओवरराइड कर सकता है: Dockerfile का CMD वह है जिसे इमेज डिफ़ॉल्ट रूप से चलाती है, और सर्विस में मौजूद command: की (key) उसे बदल देती है। command और entrypoint कैसे इंटरैक्ट करते हैं यहाँ महत्वपूर्ण है, क्योंकि Compose ओवरराइड एक नई बिल्ड की गई इमेज को बिल्कुल पुरानी इमेज की तरह व्यवहार करने पर मजबूर कर सकता है।
Build context और .dockerignore
context: . प्रोजेक्ट डायरेक्टरी को बिल्डर के लिए उपलब्ध कराता है। बिना किसी अपवाद के, इसमें .git और आपके सोर्स के बगल में रखी कोई भी डेटा डायरेक्टरी शामिल हो जाती है, हालाँकि BuildKit अप्रयुक्त फाइलों को छोड़ देता है और बदलावों को क्रमिक रूप से ट्रांसफर करता है। यदि किसी ऐसे प्रोजेक्ट का बिल्ड 'transferring-context' चरण पर रुक जाता है जिसमें कोई बदलाव नहीं हुआ है, तो इसका मतलब है कि कॉन्टेक्स्ट बहुत बड़ा है।
कॉन्टेक्स्ट के रूट पर मौजूद एक .dockerignore फाइल उन पाथ्स को ट्रांसफर से बाहर रखती है। इसका सिंटैक्स .gitignore के समान है।
.git
node_modules
*.log
data/
.envइसके दो फायदे हैं। ट्रांसफर छोटा हो जाता है, जिससे उन फाइलों को भेजने में लगने वाला समय कम हो जाता है। और COPY . . अब .env को इमेज में कॉपी नहीं कर सकता, जहाँ से इमेज पुल करने वाला कोई भी व्यक्ति उसे पढ़ सके।
समय के साथ धीमा होने वाला बिल्ड अक्सर bind mount के कारण होता है। एक named volume आपके प्रोजेक्ट डायरेक्टरी के बाहर रहता है, लेकिन ./data:/var/lib/postgresql/data जैसा bind mount बिल्ड कॉन्टेक्स्ट के अंदर होता है, इसलिए जैसे-जैसे डेटाबेस बढ़ता है, आपके बिल्ड हर हफ्ते धीमे होते जाते हैं। .dockerignore में एक लाइन इसे ठीक कर देती है। Named volumes बनाम bind mounts इस विषय के व्यापक पहलुओं को कवर करता है।
Build arguments में भी इसी तरह का जोखिम होता है। args: के माध्यम से पास किए गए मान इमेज हिस्ट्री या प्रोवेनेंस मेटाडेटा में रह सकते हैं, इसलिए वहाँ केवल वर्जन नंबर रखें, कभी भी टोकन न डालें। पूर्वनिर्धारित प्रॉक्सी आर्गुमेंट्स को डिफ़ॉल्ट रूप से बिल्ड कैश और docker history से बाहर रखा जाता है, जब तक कि उन्हें Dockerfile में स्पष्ट रूप से संदर्भित न किया गया हो। Compose में Env फाइल्स और सीक्रेट्स बताता है कि क्रेडेंशियल्स को कहाँ रखना चाहिए।
क्या आपको VPS पर build करना चाहिए या कहीं और build करके pull करना चाहिए?
जिस सर्वर पर आपका traffic आता है, उसी पर build करना सबसे आसान तरीका है क्योंकि यह सबसे छोटा रास्ता है: git pull, और फिर docker compose up -d --build। यह एक छोटे सर्वर के लिए ठीक है जिस पर अभी कोई निर्भर नहीं है। यह दो ऐसे कारणों से समस्या बन जाता है जिन्हें आप माप सकते हैं, और एक ऐसे कारण से जो केवल खराब समय पर ही सामने आता है।
Memory. एक build प्रक्रिया आपकी live application के साथ ही compilers और bundlers चलाती है, और अधिकांश stacks में ये सबसे अधिक memory का उपयोग करते हैं। एक JavaScript bundler या Rust compile 1 GB के VPS पर उपलब्ध memory को पूरी तरह खत्म कर सकता है। Memory खत्म होने पर, kernel memory उपयोग, allocation context और oom_score_adj के आधार पर एक badness score का उपयोग करके OOM victim चुनता है; यह केवल सबसे बड़ी process को ही kill नहीं करता। Build Killed के साथ रुक सकता है और exit status 137 दे सकता है, या इसके बजाय आपका database kill हो सकता है और deploy के बीच में ही site down हो सकती है। dmesg -T | grep -i oom kernel log में OOM messages खोजता है; इसे access करने के लिए log पढ़ने की अनुमति आवश्यक है।
Disk. Builds अपने पीछे image layers और build cache छोड़ जाते हैं। docker system df उनका disk उपयोग दिखाता है; BuildKit का periodic garbage collection अपनी configured policies के अनुसार cache को reclaim करता है। Dangling images के लिए docker image prune और cached layers के लिए docker builder prune का उपयोग करके जगह खाली करें। Disk भर जाने पर केवल build ही नहीं रुकता। Database भी लिखना बंद कर देता है, और वह विफलता एक धीमे deploy से कहीं अधिक महंगी पड़ती है।
Reproducibility. बिना push या export किए, सर्वर पर बनी image केवल उसी सर्वर पर मौजूद रहती है। यदि पुरानी image उपलब्ध नहीं है, तो rollback करने का अर्थ है पुराने commit को checkout करना और फिर से build करना, और उस build के वही परिणाम देने की गारंटी नहीं होती, क्योंकि base tag बदल चुका होता है और package mirrors भी बदल गए होते हैं। कहीं और build करके tag push करने से rollback एक साधारण बदलाव बन जाता है: image: को पिछले tag पर point करें और docker compose up -d चलाएं।
जो व्यवस्था सबसे बेहतर काम करती है वह स्पष्ट है। आपकी continuous integration प्रक्रिया build चलाती है और registry.example.com/acme/web:<git-sha> को push करती है, और VPS पर मौजूद Compose file में image: होता है जिसमें कोई build: key नहीं होती। इसके बाद deployment केवल दो commands का काम है जिसमें लगभग कोई memory खर्च नहीं होती।
docker compose pull
docker compose up -dPrivate tags को pull करने के लिए credentials save करने हेतु सर्वर पर docker login registry.example.com चलाएं।
Build section को delete करने के बजाय development के लिए रखें, इसे एक ऐसी file में रखें जिसका नाम आप खुद तय करें।
# compose.dev.yaml
services:
web:
build:
context: .
pull_policy: builddocker compose -f compose.yaml -f compose.dev.yaml up -d --buildउस file का नाम compose.dev.yaml रखें, न कि compose.override.yaml। Compose एक override file को मौजूद होने पर अपने आप load कर लेता है, इसलिए यदि गलती से कोई override file सर्वर पर copy हो गई, तो वह चुपचाप वहीं build करना शुरू कर देगी। कई Compose files को layer करना बताता है कि merge प्रत्येक key को कैसे हल करता है।
अन्यत्र निर्माण करने पर आर्किटेक्चर संबंधी समस्या
एक सिंगल प्लेटफॉर्म इमेज उसी CPU आर्किटेक्चर को वहन करती है जिसके लिए उसे बनाया गया है। यदि आप Apple Silicon लैपटॉप पर ARM इमेज बनाते हैं, उसे push करते हैं, और फिर उस इमेज का उपयोग x86_64 VPS पर करते हैं, तो Docker कंटेनर निर्माण के दौरान चेतावनी देता है यदि वह बिना किसी स्पष्ट प्लेटफॉर्म के एक असंगत cached इमेज का उपयोग करता है। एमुलेशन के बिना, यह प्रक्रिया exec format error के साथ विफल हो जाती है, जो एक दूषित बाइनरी की तरह दिखाई देती है, जबकि वास्तव में ऐसा नहीं है। लक्ष्य के लिए स्पष्ट रूप से बिल्ड करें:
docker buildx build --platform linux/amd64 \
-t registry.example.com/acme/web:1.4.2 --push .यदि आपका लैपटॉप x86 है और आप x86 के बजाय ARM VPS चलाते हैं, तो यही बेमेल स्थिति विपरीत रूप से घटित होती है। CI को उसी आर्किटेक्चर पर बिल्ड करने देने से जिस पर आप डिप्लॉय करते हैं, यह समस्या समाप्त हो जाती है। एक मल्टी-प्लेटफॉर्म इमेज भी इसका समाधान करती है: इमेज pull करते समय Docker स्वयं मेल खाने वाले वेरिएंट का चयन कर लेता है।
डिप्लॉयमेंट के बाद क्या जाँचें
docker compose imagesहर चल रहे container के पीछे का image और tag प्रिंट करता है। बदला हुआ image ID इस बात का प्रमाण है कि नया build service में है।docker compose configvariable substitution के बाद merged file को प्रिंट करता है, ताकि आप किसी भी चीज़ को चलाने से पहले उस अंतिम image नाम को पढ़ सकें जिसका उपयोग Compose करेगा।docker compose logs -f webswap के बाद पहले आधे मिनट के लिए। जो container बार-बार start होकर exit होता है, वह केवल तभी restart होता है यदि उसकी restart policy ऐसा करने के लिए कहती है; कारण जानने के लिए logs देखें।docker image lsएक CREATED कॉलम दिखाता है। build output और deployed image ID को भी देखें, क्योंकि केवल creation timestamp यह साबित नहीं करता कि rebuild चला था या नहीं।
यदि आप अभी भी उस file को तैयार कर रहे हैं जिसके विरुद्ध ये जाँचें चलती हैं, तो VPS पर Compose file की मूल बातें आसपास की keys को कवर करती हैं, और Compose command cheat sheet बाकी subcommands की सूची देती है।
FAQ
क्या मैं एक ही service में build और image दोनों का उपयोग कर सकता हूँ?
हाँ, और जिस प्रोजेक्ट को आप स्वयं build करते हैं, उसके लिए यह एक सामान्य सेटअप है। जब Compose build: सेक्शन से build करता है, तो यह परिणाम को image: के मान के साथ टैग करता है; बिना किसी स्पष्ट pull_policy के, up पहले pull करने का प्रयास करता है। वह टैग वही है जिसे docker compose push एक registry में भेजता है और जिसे दूसरी मशीन pull करती है। बिना image: की key के भी Compose build तो करता है, लेकिन यह image का नाम प्रोजेक्ट और service के आधार पर रखता है, और चेतावनी देता है कि यह missing attribute image को push होने से रोकता है।
docker compose up मेरे Dockerfile में किए गए बदलावों को क्यों नहीं उठाता?
क्योंकि सामान्य up मौजूदा image का ही पुन: उपयोग करता है, जब तक कि आप build का अनुरोध न करें या ऐसी policy कॉन्फ़िगर न करें जिसके लिए इसकी आवश्यकता हो। यह यह तय करने के लिए कि क्या rebuild की आवश्यकता है, image की तुलना आपके Dockerfile या source files से नहीं करता है। docker compose up -d --build चलाएँ, या किसी एक service को बदलने के लिए docker compose build web के बाद docker compose up --no-deps -d web चलाएँ। service पर pull_policy: build सेट करने से हर up rebuild हो जाता है, जो development मशीन के लिए उपयुक्त है।
--build और --force-recreate के बीच क्या अंतर है?
--build image को फिर से build करता है, और फिर उन containers को recreate करता है जिनकी image बदल गई है। --force-recreate container को recreate करने के लिए मजबूर करता है, भले ही configuration और image न बदली हो; यह स्वयं build का अनुरोध नहीं करता है। यदि आपका बदलाव source या Dockerfile में है, तो --build वह flag है जिसकी आपको आवश्यकता है। --force-recreate का उपयोग container को रीसेट करने के लिए किया जाता है, उदाहरण के लिए, उसी image को रखते हुए उसकी writable layer को साफ़ करने के लिए।
क्या मुझे अपनी Docker images को VPS पर build करना चाहिए या कहीं और?
कहीं और build करें और एक बार जब box traffic serve करने लगे, तो एक tag pull करें। एक build memory के लिए आपके application के साथ प्रतिस्पर्धा करती है, और memory समाप्त होने पर kernel एक adjustable OOM score का उपयोग करके एक victim चुनता है, जो build या आपके database को target कर सकता है। builds डिस्क पर cache भी छोड़ती हैं, हालाँकि BuildKit अपनी garbage collection policies के अनुसार इसे स्वचालित रूप से reclaim कर लेता है। बिना users वाले छोटे प्रोजेक्ट के लिए सर्वर पर build करना ठीक है, और यदि आप build: सेक्शन को केवल development वाले Compose file में रखते हैं, तो बाद में इसे स्थानांतरित करने में बहुत कम मेहनत लगती है।
मैं Docker build cache को अपनी डिस्क भरने से कैसे रोकूँ?
यह देखने के लिए कि आपकी images और build cache में से प्रत्येक कितनी जगह ले रहा है, docker system df चलाएँ। docker builder prune cached layers को हटा देता है और docker image prune पिछली builds द्वारा छोड़ी गई dangling images को हटा देता है। -a जोड़ने से क्रमशः सभी unused build cache या containers द्वारा संदर्भित न की गई सभी images हट जाती हैं; यह अगली build के पूरी तरह से cold होने की गारंटी नहीं देता है। सर्वर पर docker system prune -af --volumes को शेड्यूल न करें, क्योंकि यह stopped containers और unused anonymous volumes को हटा देता है, जिससे maintenance के दौरान anonymous volume में मौजूद database data जोखिम में पड़ सकता है।