MinIO Docker: S3-संगत ऑब्जेक्ट स्टोरेज के लिए सेटअप गाइड

क्या आपको डेवलपमेंट के लिए ऑब्जेक्ट स्टोरेज चाहिए, लेकिन AWS S3 सेटअप करना और उसके लिए भुगतान नहीं करना चाहते?

MinIO आपको S3-संगत स्टोरेज देता है जो कहीं भी चल सकता है—आपके लैपटॉप, किसी VM, या Kubernetes क्लस्टर पर। यह ओपन-सोर्स है, यानी यह वेंडर-एग्नोस्टिक है और महीने के अंत में कोई अनपेक्षित बिल नहीं आएगा। और Docker के साथ मिलकर, MinIO चलाना और भी आसान हो जाता है क्योंकि आप अपनी मशीन पर कुछ भी सीधे इंस्टॉल किए बिना कुछ ही सेकंड में स्टोरेज सर्वर स्पिन-अप कर सकते हैं।

Docker कंटेनर MinIO को आपके सिस्टम से अलग रखते हैं और साथ ही आपको कॉन्फ़िगरेशन और डेटा परसिस्टेंस पर पूरा नियंत्रण देते हैं। आप स्थानीय रूप से S3 API का परीक्षण कर सकते हैं, प्रोडक्शन स्टोरेज सेटअप का मॉक कर सकते हैं, या छोटे प्रोजेक्ट्स के लिए हल्का-फुल्का ऑब्जेक्ट स्टोरेज चला सकते हैं।

इस लेख में, मैं आपको दिखाऊंगा कि Docker के साथ MinIO कैसे चलाएं, यह कैसे सत्यापित करें कि यह सही से काम कर रहा है, और सबसे आम कॉन्फ़िगरेशन विकल्प कैसे सेट करें।

यदि आप Docker में बिल्कुल नए हैं, तो बुनियादी बातों में महारत हासिल करने के लिए एक शनिवार दोपहर दें—DataCamp का Introduction to Docker कोर्स आपके लिए पर्याप्त है।

पूर्वापेक्षाएँ

Docker के साथ MinIO चलाने के लिए आपको तीन चीज़ों की ज़रूरत है।

Docker इंस्टॉल और रनिंग आपकी मशीन पर। आप टर्मिनल में docker --version चलाकर इसकी पुष्टि कर सकते हैं। यदि आपको संस्करण संख्या मिलती है, तो आप तैयार हैं।

मूलभूत जानकारी Docker commands की। आपको कंटेनर शुरू/बंद करना, लॉग देखना, और Docker इमेज के साथ काम करना आना चाहिए। यदि आपने docker run चलाया है या पहले Docker Compose के साथ काम किया है, तो आप ठीक रहेंगे।

परसिस्टेंट स्टोरेज के लिए एक स्थानीय डायरेक्टरी। MinIO को आपके डेटा को कंटेनर के बाहर स्टोर करने के लिए एक जगह चाहिए। अपनी होस्ट मशीन पर एक खाली डायरेक्टरी बनाएं—जैसे ~/minio/data ठीक काम करता है।

बस इतना ही। सूची छोटी और सरल है, लेकिन आगे बढ़ने से पहले सुनिश्चित करें कि आप सभी बॉक्स टिक कर चुके हैं।

Docker के साथ MinIO कैसे चलाएँ (सिंगल-नोड सेटअप)

सिंगल-नोड MinIO सेटअप Docker कंटेनर में MinIO का एक इंस्टेंस चलाता है और आपका सारा डेटा एक ही स्थान पर स्टोर करता है।

यह सेटअप डेवलपमेंट, टेस्टिंग, और छोटे पैमाने के प्रोडक्शन वर्कलोड्स के लिए काम करता है जहाँ आपको हाई-एवेलेबिलिटी या डिस्ट्रीब्यूटेड स्टोरेज की ज़रूरत नहीं होती। आप बिना मल्टीपल नोड्स की जटिलता के फुल S3 API कम्पैटिबिलिटी पाते हैं।

Docker Run के साथ MinIO चलाना

docker run कमांड एक नई लाइन में सब कुछ कॉन्फ़िगर करके MinIO को एक नए कंटेनर में शुरू करता है।

मूल कमांड यह है:

docker run -p 9000:9000 -p 9001:9001 \
  --name minio \
  -v ~/minio/data:/data \
  -e "MINIO_ROOT_USER=admin" \
  -e "MINIO_ROOT_PASSWORD=password123" \
  quay.io/minio/minio server /data --console-address ":9001"संचालित द्वारा

docker run के साथ MinIO चलाना

आइए देखें कि प्रत्येक भाग क्या करता है।

• पोर्ट 9000 API एंडपॉइंट है जहाँ आपकी एप्लिकेशन फ़ाइलें अपलोड और डाउनलोड करने के लिए कनेक्ट करती हैं। यहीं S3-संगत क्लाइंट अपने अनुरोध भेजते हैं।

• पोर्ट 9001 वह वेब कंसोल होस्ट करता है जहाँ आप बकेट मैनेज करते हैं, अनुमतियाँ सेट करते हैं, और स्टोरेज की निगरानी करते हैं। आप इसका उपयोग यह सत्यापित करने के लिए करेंगे कि MinIO सही से चल रहा है।

• -v ~/minio/data:/data फ्लैग आपकी लोकल डायरेक्टरी को कंटेनर के स्टोरेज लोकेशन से मैप करता है। MinIO जो कुछ भी स्टोर करता है वह आपकी होस्ट मशीन पर ~/minio/data में जाता है। जब आप कंटेनर को रोकते या हटाते हैं, आपका डेटा इस डायरेक्टरी में सुरक्षित रहता है।

• Environment variables आपकी एक्सेस क्रेडेंशियल्स सेट करती हैं। MINIO_ROOT_USER आपका एडमिन यूज़रनेम है और MINIO_ROOT_PASSWORD पासवर्ड। इन्हीं क्रेडेंशियल्स से आप वेब कंसोल में लॉगिन करेंगे और API एक्सेस कॉन्फ़िगर करेंगे।

• server /data आर्ग्युमेंट MinIO को सर्वर मोड में चलने और /data को स्टोरेज डायरेक्टरी के रूप में उपयोग करने को कहता है। --console-address ":9001" फ्लैग निर्दिष्ट करता है कि वेब कंसोल किस पोर्ट पर सुनेगा।

MinIO चलाने का एक वैकल्पिक तरीका भी है जो बढ़िया है अगर आपको लंबी, मल्टी-लाइन टर्मिनल कमांड पसंद नहीं।

नोट: MinIO अब अपने Docker Hub और Quay इमेजेज़ को अपडेट नहीं करता (अक्टूबर 2025 से)। इस लेख का कोड लोकल डेवलपमेंट के लिए अब भी काम करता है, लेकिन प्रोडक्शन उपयोग के लिए, Chainguard की MinIO इमेज (cgr.dev/chainguard/minio:latest) जैसी मेंटेंड वैकल्पिक इमेज पर विचार करें।

Docker Compose के साथ MinIO चलाना

Docker Compose आपको लंबी कमांड टाइप करने के बजाय YAML फ़ाइल में अपना MinIO सेटअप परिभाषित करने देता है।

इससे आपका कॉन्फ़िगरेशन दोहराने योग्य और वर्ज़न-कंट्रोल्ड हो जाता है। आप फ़ाइल टीम के साथ साझा कर सकते हैं, इसे git में कमिट कर सकते हैं, और हर बार बिल्कुल वही सेटिंग्स के साथ MinIO को रीस्टार्ट कर सकते हैं।

एक docker-compose.yml फ़ाइल बनाएँ:

services:
  minio:
    image: quay.io/minio/minio
    container_name: minio
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: password123
    volumes:
      - ./minio/data:/data
    command: server /data --console-address ":9001"संचालित द्वारा

यह संरचना docker run कमांड का प्रतिबिंब है, लेकिन सब कुछ नामित सेक्शनों में व्यवस्थित करती है। पोर्ट्स, environment variables, और वॉल्यूम के अपने-अपने ब्लॉक हैं।

वॉल्यूम मैपिंग उसी तरह काम करती है—./minio/data:/data आपकी वर्तमान फ़ोल्डर में एक डायरेक्टरी बनाता है और उसे कंटेनर से माउंट करता है। ./ का अर्थ है उसी स्थान के सापेक्ष जहाँ यह docker-compose.yml फ़ाइल मौजूद है।

अब आप MinIO इस तरह शुरू कर सकते हैं:

docker-compose up -dसंचालित द्वारा

docker compose के साथ MinIO चलाना

-d फ्लैग कंटेनर को बैकग्राउंड में चलाता है। आपका टर्मिनल MinIO लॉग से ब्लॉक नहीं होगा, और टर्मिनल बंद करने के बाद भी कंटेनर चलता रहेगा।

इसे इस तरह रोकें:

docker-compose downसंचालित द्वारा

डेवलपमेंट के लिए Compose बेहतर है क्योंकि आप हेल्थचेक, रिस्टार्ट पॉलिसी, और एक ही फ़ाइल में मल्टीपल सर्विसेज़ जोड़ सकते हैं। यदि आपको बाद में MinIO के साथ किसी डेटाबेस या अन्य सेवाएँ जोड़ने की ज़रूरत हो, तो आप बस services: के नीचे और एंट्रीज़ जोड़ दें।

MinIO तक पहुँचना और यह सत्यापित करना कि यह चल रहा है

अब जब MinIO चल रहा है, तो स्टोरेज के लिए उपयोग करने से पहले आप पुष्टि करना चाहेंगे कि यह सही तरह शुरू हुआ है।

अपनी सेटअप सत्यापित करने के दो तरीके हैं: विज़ुअल पुष्टि के लिए वेब कंसोल और कमांड-लाइन वेरिफिकेशन के लिए MinIO क्लाइंट।

MinIO वेब कंसोल का उपयोग

अपने ब्राउज़र में जाएँ और http://localhost:9001 खोलें।

आपको क्रेडेंशियल्स माँगती लॉगिन स्क्रीन दिखेगी:

MinIO वेब UI

आप उन क्रेडेंशियल्स से लॉगिन कर सकते हैं जो आपने environment variables के रूप में दिए थे—मेरे केस में admin/password123।

लॉगिन के बाद, आप MinIO डैशबोर्ड पर पहुँचेंगे। मुख्य पेज पर स्टोरेज उपयोग, बकेट्स की संख्या और सिस्टम हेल्थ दिखती है। बाईं साइडबार में बकेट बनाने, यूज़र्स मैनेज करने और मैट्रिक्स देखने के विकल्प हैं।

MinIO वेब UI के माध्यम से बकेट बनाना

सब कुछ काम कर रहा है यह जाँचने के लिए एक टेस्ट बकेट बनाएँ। साइडबार में "Buckets" पर क्लिक करें, फिर "Create Bucket" पर। इसे test-bucket जैसा नाम दें और क्रिएट पर क्लिक करें। यदि बकेट आपकी सूची में दिखता है, तो MinIO सही से चल रहा है और डेटा स्टोर कर रहा है।

MinIO वेब UI के माध्यम से बकेट बनाना

MinIO क्लाइंट (mc) का उपयोग

MinIO क्लाइंट एक कमांड-लाइन टूल है जो आपको AWS CLI की तरह MinIO के साथ इंटरैक्ट करने देता है।

इसे इंस्टॉल करने के लिए इनमें से कोई एक कमांड चलाएँ:

# macOS
brew install minio/stable/mc

# Linux
wget https://dl.min.io/client/mc/release/linux-amd64/mc
chmod +x mc
sudo mv mc /usr/local/bin/संचालित द्वारा

और अब इस कमांड से क्लाइंट को आपके लोकल MinIO इंस्टेंस से कनेक्ट करें:

mc alias set local http://localhost:9000 admin password123संचालित द्वारा

यह local नाम का एक एलियस बनाता है जो आपके MinIO सर्वर की ओर इशारा करता है। अब आप इसके खिलाफ कमांड चला सकते हैं।

अपने बकेट्स की सूची देखें:

mc ls localसंचालित द्वारा

बकेट्स की सूची

यदि आपने पहले टेस्ट बकेट बनाया था, तो वह आउटपुट में दिखेगा। यदि कमांड खाली लौटाता है या आपके बकेट्स दिखाता है, तो MinIO काम कर रहा है।

अब आप बकेट में एक टेस्ट फ़ाइल अपलोड कर सकते हैं:

echo "test" > test.txt
mc cp test.txt local/test-bucket/संचालित द्वारा

और फिर यह सत्यापित करें कि वह वहाँ है:

mc ls local/test-bucketसंचालित द्वारा

यदि आपको आउटपुट में test.txt दिखे, तो आपने सब कुछ ठीक से सेट कर लिया है।

किसी बकेट में फ़ाइलों की सूची

यदि चीज़ें काम नहीं कर रहीं, तो यहाँ कुछ त्वरित ट्रबलशूटिंग कदम हैं:

• docker ps से जाँचें कि कंटेनर चल रहा है या नहीं। यदि आपको minio नाम का कंटेनर नहीं दिखता, तो यह शुरू नहीं हुआ या क्रैश हो गया।

• docker logs minio से लॉग देखें। ऐसे एरर देखें जो पहले से उपयोग में पोर्ट्स या डेटा डायरेक्टरी पर परमिशन समस्याओं से संबंधित हों।

• यदि आप वेब कंसोल तक नहीं पहुँच पा रहे, तो docker port minio चलाकर सत्यापित करें कि पोर्ट्स ब्लॉक नहीं हैं। आपको 9000 और 9001 दोनों सही तरह से मैप्ड दिखने चाहिए।

• यदि आपको डेटा डायरेक्टरी पर परमिशन एरर मिल रहे हैं, तो एक्सेस समस्याएँ ठीक करने के लिए chmod -R 755 ~/minio/data चलाएँ।

परसिस्टेंट स्टोरेज और डेटा वॉल्यूम

कंटेनर डिफ़ॉल्ट रूप से क्षणिक होते हैं—जब आप कंटेनर हटाते हैं, तो उसके अंदर की हर चीज़ गायब हो जाती है।

MinIO ऑब्जेक्ट्स, मेटाडेटा और कॉन्फ़िगरेशन फ़ाइलें स्टोर करता है। यदि आप परसिस्टेंट स्टोरेज सही से सेट नहीं करते, तो कंटेनर रीस्टार्ट या हटाते ही आपका सारा डेटा खो जाएगा।

Docker के साथ लोकल वॉल्यूम का उपयोग

Docker वॉल्यूम और बाइंड माउंट आपका डेटा कंटेनर के बाहर सुरक्षित रखते हैं।

जब आप -v ~/minio/data:/data का उपयोग करते हैं या Docker Compose में वॉल्यूम मैप करते हैं, MinIO हर चीज़ आपकी होस्ट मशीन पर लिखता है। कंटेनर /data में फ़ाइलें पढ़ता और लिखता है, लेकिन ये फ़ाइलें वास्तव में आपकी होस्ट पर ~/minio/data में रहती हैं।

जब आप कंटेनर रोकते, हटाते, या यहाँ तक कि इमेज डिलीट करते हैं—आपका डेटा ~/minio/data में रहता है। उसी डायरेक्टरी की ओर इशारा करते हुए एक नया MinIO कंटेनर शुरू करें और आपके सभी बकेट्स, ऑब्जेक्ट्स, और सेटिंग्स बिल्कुल वैसे ही वापस आ जाते हैं जैसे आपने छोड़े थे।

यदि आप कोई वॉल्यूम मैप नहीं करते, तो MinIO कंटेनर की आंतरिक फाइलसिस्टम का उपयोग करता है। सब कुछ तब तक ठीक चलता है जब तक आप कंटेनर को रोक न दें। जब आप इसे फिर शुरू करते हैं, MinIO नए सिरे से शुरू होता है—कोई बकेट नहीं, कोई ऑब्जेक्ट नहीं, और कोई कॉन्फ़िगरेशन नहीं।

जिस compose उदाहरण को मैंने पहले दिखाया था, वह उसी स्थान पर जहाँ आपकी compose फ़ाइल है, एक minio/data फ़ोल्डर बनाता है:

MinIO डेटा फ़ोल्डर

आम स्टोरेज गलतियाँ

बिना वॉल्यूम के चलाना सबसे आम गलती है।

आप MinIO शुरू करते हैं, फ़ाइलें अपलोड करते हैं, बकेट बनाते हैं, और सब कुछ ठीक लगता है। फिर आप किसी अपडेट या कॉन्फ़िगरेशन बदलाव के लिए कंटेनर रीस्टार्ट करते हैं। आपका सारा डेटा गायब हो जाता है क्योंकि वह कंटेनर के अंदर स्टोर था, आपकी होस्ट पर नहीं।

किसी भी वास्तविक डेटा को MinIO में डालने से पहले हमेशा जाँचें कि आपके Docker कमांड या Compose फ़ाइल में वॉल्यूम मैपिंग है।

परमिशन संबंधी समस्याएँ तब होती हैं जब Docker आपकी माउंट की गई डायरेक्टरी में लिख नहीं पाता।

कंटेनर के अंदर MinIO प्रक्रिया एक विशेष यूज़र के रूप में चलती है। यदि उस यूज़र के पास होस्ट डायरेक्टरी पर लिखने की अनुमति नहीं है, तो MinIO स्टार्टअप पर क्रैश करेगा या ऑब्जेक्ट स्टोर करने की कोशिश में चुपचाप फेल होगा।

आप इसे सुनिश्चित करके ठीक कर सकते हैं कि आपकी डेटा डायरेक्टरी राइटेबल है:

chmod -R 755 ~/minio/dataसंचालित द्वारा

या कंटेनर को ऐसे यूज़र के साथ चलाएँ जो आपके होस्ट यूज़र से मेल खाता हो:

docker run --user $(id -u):$(id -g) ...संचालित द्वारा

संक्षेप में, एक बार अपने वॉल्यूम सही से सेट कर लें और फिर डेटा खोने की चिंता नहीं रहेगी।

Environment variables और बेसिक कॉन्फ़िगरेशन

MinIO स्टार्ट होने पर अपनी कॉन्फ़िगरेशन environment variables से पढ़ता है।

इसका मतलब है कि आप बिना कॉन्फ़िग फ़ाइलें एडिट किए या कंटेनर रीबिल्ड किए MinIO के व्यवहार को बदल सकते हैं। आप इन वेरिएबल्स को अपने docker run कमांड या Docker Compose फ़ाइल में सेट करते हैं।

एक्सेस कीज़ और क्रेडेंशियल्स

प्रमाणीकरण के लिए MinIO को दो environment variables चाहिए: MINIO_ROOT_USER और MINIO_ROOT_PASSWORD।

ये आपके MinIO इंस्टेंस पर फुल कंट्रोल वाला रूट एडमिन अकाउंट बनाते हैं। रूट यूज़र बकेट बना सकता है, अन्य यूज़र्स मैनेज कर सकता है, नीतियाँ सेट कर सकता है, और सभी स्टोर किए गए ऑब्जेक्ट्स तक पहुँच सकता है।

इन्हें docker run के दौरान इस तरह सेट करें:

-e "MINIO_ROOT_USER=admin" \
-e "MINIO_ROOT_PASSWORD=your-secure-password"संचालित द्वारा

या Docker Compose में:

environment:
  MINIO_ROOT_USER: admin
  MINIO_ROOT_PASSWORD: your-secure-passwordसंचालित द्वारा

प्रोडक्शन में डिफ़ॉल्ट क्रेडेंशियल्स का उपयोग न करें। इस लेख में उदाहरण के लिए admin और password123 का उपयोग किया गया है, लेकिन वास्तविक डिप्लॉयमेंट के लिए ये बहुत बुरे विकल्प हैं।

कम-से-कम 8 अक्षरों वाला मज़बूत पासवर्ड चुनें। बेहतर है कि रैंडमली जेनरेटेड क्रेडेंशियल्स का उपयोग करें और उन्हें पासवर्ड मैनेजर या सीक्रेट मैनेजमेंट सिस्टम में स्टोर करें।

Docker Compose फ़ाइलों में क्रेडेंशियल्स हार्डकोड न करें जिन्हें आप वर्ज़न कंट्रोल में कमिट करते हैं। इसके बजाय environment फ़ाइलों का उपयोग करें:

environment:
  MINIO_ROOT_USER: ${MINIO_ROOT_USER}
  MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD}संचालित द्वारा

फिर अपनी वास्तविक क्रेडेंशियल्स के साथ एक .env फ़ाइल बनाएँ और उसे .gitignore में जोड़ें।

पोर्ट कॉन्फ़िगरेशन और नेटवर्किंग

MinIO को सही तरह काम करने के लिए दो पोर्ट चाहिए।

• पोर्ट 9000 S3 API संभालता है। यहीं आपकी एप्लिकेशन ऑब्जेक्ट्स स्टोर और रिट्रीव करने के अनुरोध भेजती हैं। सभी S3-संगत क्लाइंट इसी पोर्ट से कनेक्ट होते हैं।
• पोर्ट 9001 वेब कंसोल सर्व करता है। यही ब्राउज़र इंटरफ़ेस है जहाँ आप GUI के जरिए MinIO मैनेज करते हैं।

इन पोर्ट्स को अपने Docker कमांड में मैप करें:

-p 9000:9000 -p 9001:9001संचालित द्वारा

पोर्ट कॉन्फ्लिक्ट तब होते हैं जब आपकी होस्ट पर 9000 या 9001 पहले से किसी अन्य सर्विस द्वारा उपयोग में हों।

कंटेनर शुरू करते समय आपको "bind: address already in use" जैसा एरर दिखेगा। इसे अलग होस्ट पोर्ट्स मैप करके ठीक करें:

-p 9090:9000 -p 9091:9001संचालित द्वारा

अब MinIO का API http://localhost:9090 पर है और कंसोल http://localhost:9091 पर। कंटेनर के अंदर अभी भी 9000 और 9001 ही उपयोग होते हैं, लेकिन बाहर से आप अलग पोर्ट्स के जरिए एक्सेस करते हैं।

MinIO शुरू करने से पहले किसी पोर्ट का उपयोग कौन कर रहा है, यह जाँचने में ये कमांड मदद करेंगे:

# Linux/macOS
lsof -i :9000
lsof -i :9001

# Windows
netstat -ano | findstr :9000
netstat -ano | findstr :9001संचालित द्वारा

कौन-सा पोर्ट उपयोग में है, यह जाँचना

यदि आप एक ही मशीन पर अनेक MinIO इंस्टेंस चला रहे हैं, तो प्रत्येक को यूनिक पोर्ट मैपिंग दें ताकि वे आपस में टकराएँ नहीं।

Docker के साथ डिस्ट्रीब्यूटेड मोड में MinIO चलाना

डिस्ट्रीब्यूटेड मोड, हाई-एवेलेबिलिटी और डेटा रिडंडेंसी के लिए कई सर्वर्स पर कई ड्राइव्स के साथ MinIO चलाता है।

डेवलपमेंट या टेस्टिंग के लिए इसकी ज़रूरत नहीं। ज़्यादातर उपयोग मामलों के लिए सिंगल-नोड मोड पर्याप्त है। जब तक आप ऐसा प्रोडक्शन डिप्लॉयमेंट प्लान नहीं कर रहे जिसमें सर्वर फेल होने पर भी ऑनलाइन रहना ज़रूरी है, तब तक इस सेक्शन को छोड़ दें।

कब डिस्ट्रीब्यूटेड MinIO समझदारी है

जब आपको फॉल्ट टॉलरेंस चाहिए, तब डिस्ट्रीब्यूटेड मोड का उपयोग करें।

डिस्ट्रीब्यूटेड सेटअप में यदि एक सर्वर डाउन हो जाए, तो भी MinIO चलता रहता है और आपका डेटा उपलब्ध रहता है। सिस्टम ऑब्जेक्ट्स को कई ड्राइव्स और सर्वर्स में बाँटने के लिए इरेज़र कोडिंग का उपयोग करता है, इसलिए आप ड्राइव्स या पूरे नोड्स खो दें तब भी डेटा नहीं खोएंगे।

बड़े पैमाने के स्टोरेज के लिए भी डिस्ट्रीब्यूटेड मोड चाहिए। यदि आप टेराबाइट्स या पेटाबाइट्स डेटा स्टोर कर रहे हैं, तो उसे कई मशीनों में फैलाने से एकल सर्वर की तुलना में बेहतर परफॉर्मेंस और अधिक क्षमता मिलती है।

लोकल डेवलपमेंट को इन सबकी ज़रूरत नहीं। डिस्ट्रीब्यूटेड मोड जटिलता बढ़ाता है—आपको कई मशीनें या VM, समन्वित नेटवर्किंग, और सावधानीपूर्वक ड्राइव कॉन्फ़िगरेशन चाहिए। अपने लैपटॉप पर S3 API टेस्ट करने या ऑब्जेक्ट स्टोरेज चलाने के लिए सिंगल-नोड मोड ही पर्याप्त है।

प्रोडक्शन एनवायरनमेंट्स में तब डिस्ट्रीब्यूटेड मोड उपयोग होता है जब डाउनटाइम स्वीकार्य नहीं और डेटा लॉस विनाशकारी होगा। जैसे बैकअप सिस्टम, डेटा लेक्स, या ऐसी एप्लिकेशन जहाँ यूज़र्स लगातार स्टोरेज उपलब्धता पर निर्भर करते हैं।

हाई-लेवल सेटअप ओवरव्यू

डिस्ट्रीब्यूटेड MinIO के लिए कम-से-कम चार ड्राइव्स की आवश्यकता होती है जो कई नोड्स में फैली हों।

हर नोड एक MinIO कंटेनर चलाता है, और सभी नोड्स को एक जैसे ड्राइव कॉन्फ़िगरेशन दिखने चाहिए। आप सिंगल-ड्राइव नोड्स को मल्टी-ड्राइव नोड्स के साथ मिक्स नहीं कर सकते या सेटअप के बाद ड्राइव्स की संख्या नहीं बदल सकते।

एक बेसिक डिस्ट्रीब्यूटेड सेटअप कुछ ऐसा दिखता है:

• MinIO इंस्टॉल वाले चार सर्वर (या VM)
• हर सर्वर पर MinIO के लिए समर्पित कई ड्राइव्स
• सभी नोड्स के बीच नेटवर्क कनेक्टिविटी
• हर नोड पर समान ड्राइव पाथ्स

आप एक ही Compose फ़ाइल में समन्वय संभाल सकते हैं, लेकिन चेतावनी देता हूँ—यह लंबी होगी। आपको सभी नोड्स परिभाषित करने, उनके ड्राइव पाथ्स सेट करने, और उन्हें साथ में शुरू करने की ज़रूरत होगी।

चार नोड्स और प्रत्येक पर दो ड्राइव्स के लिए एक संपूर्ण उदाहरण यहाँ है:

version: "3.9"

services:
  minio1:
    image: quay.io/minio/minio:latest
    hostname: minio1
    container_name: minio1
    command: server http://minio{1...4}/data{1...2} --console-address ":9001"
    ports:
      - "9001:9000"
      - "9091:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: password123
    volumes:
      - ./data/minio1/data1:/data1
      - ./data/minio1/data2:/data2
    networks:
      - minio

  minio2:
    image: quay.io/minio/minio:latest
    hostname: minio2
    container_name: minio2
    command: server http://minio{1...4}/data{1...2} --console-address ":9001"
    ports:
      - "9002:9000"
      - "9092:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: password123
    volumes:
      - ./data/minio2/data1:/data1
      - ./data/minio2/data2:/data2
    networks:
      - minio

  minio3:
    image: quay.io/minio/minio:latest
    hostname: minio3
    container_name: minio3
    command: server http://minio{1...4}/data{1...2} --console-address ":9001"
    ports:
      - "9003:9000"
      - "9093:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: password123
    volumes:
      - ./data/minio3/data1:/data1
      - ./data/minio3/data2:/data2
    networks:
      - minio

  minio4:
    image: quay.io/minio/minio:latest
    hostname: minio4
    container_name: minio4
    command: server http://minio{1...4}/data{1...2} --console-address ":9001"
    ports:
      - "9004:9000"
      - "9094:9001"
    environment:
      MINIO_ROOT_USER: admin
      MINIO_ROOT_PASSWORD: password123
    volumes:
      - ./data/minio4/data1:/data1
      - ./data/minio4/data2:/data2
    networks:
      - minio

networks:
  minio:
    driver: bridgeसंचालित द्वारा

यह {1...4} सिंटैक्स MinIO को चार नोड्स (minio1 से minio4) से दो-दो ड्राइव्स (data1 और data2) के साथ कनेक्ट करने को कहता है। हर नोड को अलग-अलग पोर्ट मैपिंग मिलती है ताकि आप उन्हें अलग-अलग एक्सेस कर सकें — नोड 1 9001/9091, नोड 2 9002/9092, और आगे भी इसी तरह उपयोग करता है।

यह minio-distributed नेटवर्क कंटेनरों को होस्टनेम के जरिये एक-दूसरे तक पहुँचने देता है। सभी नोड्स को एक जैसी क्रेडेंशियल्स उपयोग करनी होंगी और एक जैसा ड्राइव लेआउट दिखाई देना चाहिए।

क्लस्टर शुरू करने के लिए, पहले डेटा डायरेक्टरी बनाएं और फिर compose फ़ाइल चलाएं

mkdir -p data/minio{1..4}/data{1..2}
docker compose up -dसंचालित द्वारा

डिस्ट्रीब्यूटेड मोड में MinIO चलाना

बस इतना ही! अब आप वेब UI एक्सेस करने के लिए निम्न में से किसी भी URL पर जा सकते हैं:

• http://localhost:9091
• http://localhost:9092
• http://localhost:9093
• http://localhost:9094

लेकिन फिर से याद रखें, जब तक वास्तव में ज़रूरत न हो इसे न बनाएं — डिस्ट्रीब्यूटेड मोड उत्पादन वर्कलोड्स के लिए है, जहाँ अपटाइम और रिडंडेंसी अतिरिक्त जटिलता को सही ठहराते हैं।

इसके अलावा, एक पूर्ण प्रोडक्शन वातावरण के लिए आपको TLS, एकल कंसोल एंडपॉइंट, और बाहरी वॉल्यूम/डिस्क जैसी चीज़ें भी चाहिए होंगी।

Docker में MinIO चलाते समय आम समस्याएँ

अधिकांश MinIO Docker समस्याएँ गलत कॉन्फ़िगर किए गए वॉल्यूम, पोर्ट, या क्रेडेंशियल्स से आती हैं।

यहाँ वे समस्याएँ हैं जिनका आप वास्तव में सामना करेंगे और उन्हें तुरंत कैसे ठीक करें।

कंटेनर शुरू होता है लेकिन वेब UI पहुँच योग्य नहीं

आप docker ps चलाते हैं और कंटेनर रनिंग दिखता है, लेकिन http://localhost:9001 कुछ नहीं लौटाता या टाइम आउट हो जाता है।

इसे सुलझाने के लिए, पहले देखें कि कंसोल पोर्ट सही से मैप हुआ है या नहीं:

docker port minioसंचालित द्वारा

आपको 9001/tcp -> 0.0.0.0:9001 दिखना चाहिए। अगर 9001 पोर्ट सूची में नहीं है, तो आप इसे अपने docker run कमांड या Compose फ़ाइल में मैप करना भूल गए हैं।

MinIO के लॉग भी देखें:

docker logs minioसंचालित द्वारा

उस पंक्ति को देखें जिसमें "Console: http://..." लिखा हो — यह बताता है कि MinIO वास्तव में किस एड्रेस पर सुन रहा है। यदि अपेक्षित से अलग पोर्ट दिखे, तो आपका --console-address फ़्लैग गलत हो सकता है।

माउंटेड वॉल्यूम्स पर अनुमति (permissions) से जुड़ी त्रुटियाँ

MinIO स्टार्टअप पर क्रैश हो जाता है या लॉग में "permission denied" त्रुटियाँ दिखती हैं जब वह /data पर लिखने की कोशिश करता है।

MinIO प्रक्रिया कंटेनर के अंदर एक विशिष्ट उपयोगकर्ता के रूप में चलती है, और उस उपयोगकर्ता को आपकी माउंटेड डायरेक्टरी पर लिखने की अनुमति चाहिए। इसे ऐसे ठीक करें:

chmod -R 755 ~/minio/dataसंचालित द्वारा

या यदि आप Linux पर हैं, तो कंटेनर को अपने यूज़र ID के साथ चलाएँ:

docker run --user $(id -u):$(id -g) ...संचालित द्वारा

अन्य सेवाओं के साथ पोर्ट कॉन्फ्लिक्ट

कंटेनर शुरू करते समय "bind: address already in use" मिलता है।

इसका मतलब है कि कोई और सेवा पहले से 9000 या 9001 पोर्ट उपयोग कर रही है। पता करें कौन उपयोग कर रहा है:

# Linux/macOS
lsof -i :9000
lsof -i :9001

# Windows
netstat -ano | findstr :9000संचालित द्वारा

और फिर MinIO को अलग होस्ट पोर्ट्स पर मैप करें:

docker run -p 9090:9000 -p 9091:9001 ...संचालित द्वारा

अब API को localhost:9090 पर और कंसोल को localhost:9091 पर एक्सेस करें।

क्रेडेंशियल्स अपेक्षा के मुताबिक काम नहीं कर रहे

आपने MINIO_ROOT_USER और MINIO_ROOT_PASSWORD सेट किए हैं, लेकिन लॉगिन नहीं हो रहा, या कंटेनर शुरू नहीं हो रहा।

समाधान के लिए देखें कि आपने वास्तव में environment वेरिएबल्स पास किए थे या नहीं:

docker inspect minio | grep -A 5 Envसंचालित द्वारा

आउटपुट में MINIO_ROOT_USER और MINIO_ROOT_PASSWORD देखें। अगर ये गायब हैं, तो आप -e फ़्लैग्स या Compose फ़ाइल में environment: सेक्शन डालना भूल गए हैं।

MinIO में पासवर्ड कम से कम 8 अक्षरों का होना चाहिए। अगर आपका पासवर्ड छोटा है, तो कंटेनर उसे अस्वीकार कर सकता है या डिफ़ॉल्ट का उपयोग कर सकता है।

यदि आपने मौजूदा सेटअप पर क्रेडेंशियल्स बदले हैं, तो कंटेनर को पूरी तरह से बंद और हटाएँ, फिर नया शुरू करें:

docker stop minio
docker rm minio
docker run ...  # with new credentialsसंचालित द्वारा

पुरानी क्रेडेंशियल फ़ाइलें आपके डेटा डायरेक्टरी में बनी रह सकती हैं और कॉन्फ्लिक्ट का कारण बन सकती हैं।

Docker के साथ MinIO चलाने के सर्वोत्तम अभ्यास

इन अभ्यासों का पालन करें ताकि आम गलतियों से बचा जा सके और आपका MinIO सेटअप मेंटेन करने योग्य रहे।

• दोहराने योग्यपन के लिए Docker Compose का उपयोग करें। एक Compose फ़ाइल आपके सटीक कॉन्फ़िगरेशन — पोर्ट, वॉल्यूम, environment वेरिएबल्स, और कमांड्स — का दस्तावेज़ देती है। आप इसे वर्शन कंट्रोल में रख सकते हैं, टीम के साथ साझा कर सकते हैं, और अलग-अलग मशीनों पर एक जैसे सेटअप दोबारा बना सकते हैं। शेल हिस्ट्री से लंबे docker run कमांड चलाने से कॉन्फ़िगरेशन में विचलन और गलतियाँ होती हैं।

• हमेशा परसिस्टेंट स्टोरेज कॉन्फ़िगर करें। कोई भी वास्तविक डेटा स्टोर करने से पहले वॉल्यूम या बाइंड माउंट मैप करें। कंटेनर क्षणिक होते हैं — अगर आप यह कदम छोड़ते हैं, तो कंटेनर रीस्टार्ट पर सब कुछ खो देंगे। अपनी सेटअप को docker inspect minio से जाँचें और वॉल्यूम मैपिंग सही है यह सत्यापित करें।

• क्रेडेंशियल्स को कमांड हिस्ट्री से दूर रखें। पासवर्ड सीधे docker run कमांड्स में न डालें या उन्हें अपनी Compose फ़ाइलों में git पर कमिट न करें। Docker Compose के साथ environment फ़ाइलों (.env) का उपयोग करें, या रनटाइम पर environment वेरिएबल्स के जरिए क्रेडेंशियल्स पास करें। .env को तुरंत अपने .gitignore में जोड़ें।

• डेवलपमेंट के लिए केवल सिंगल-नोड मोड का उपयोग करें। डिस्ट्रीब्यूटेड मोड जटिल होता है और सेटअप में समय लेता है। आपको अपने लैपटॉप पर हाई अवेलेबिलिटी या इरेज़र कोडिंग की ज़रूरत नहीं होती। डिस्ट्रीब्यूटेड डिप्लॉयमेंट्स को प्रोडक्शन के लिए बचाकर रखें जहाँ डाउनटाइम वास्तव में मायने रखता है।

• स्टार्टअप के दौरान लॉग्स मॉनिटर करें। पहली बार MinIO शुरू करते समय docker logs -f minio चलाएँ। लॉग्स आपको API एंडपॉइंट, कंसोल URL, और कोई भी कॉन्फ़िगरेशन त्रुटियाँ दिखाते हैं। अगर कुछ गलत है, तो आप तुरंत देख लेंगे, बजाय इसके कि सोचते रहें कि कुछ काम क्यों नहीं कर रहा।

इन अभ्यासों का पालन करें और आपका MinIO सेटअप पहले दिन से ही मज़बूत रहेगा।

निष्कर्ष

Docker के साथ MinIO चलाने का मतलब है कि आप एक मिनट से भी कम समय में अपनी मशीन पर S3-संगत ऑब्जेक्ट स्टोरेज चला सकते हैं।

डेवलपमेंट, टेस्टिंग, और छोटे पैमाने की परियोजनाओं के लिए, Docker में सिंगल-नोड MinIO आपको हर वह चीज़ देता है जिसकी आपको ज़रूरत है। आपको पूरा S3 API अनुकूलन, प्रबंधन के लिए वेब कंसोल, और अपने डेटा पर पूर्ण नियंत्रण मिलता है — बिना क्लाउड सेवाओं पर निर्भर हुए या उस स्टोरेज के लिए भुगतान किए जिसे आप उपयोग नहीं करते।

बुनियादी बातों से शुरू करें: एक सरल docker run कमांड या परसिस्टेंट वॉल्यूम्स और सुरक्षित क्रेडेंशियल्स वाली Docker Compose फ़ाइल (दूसरा बेहतर है)। अपना सेटअप टेस्ट करें, सत्यापित करें कि यह काम करता है, और केवल तभी जटिलता जोड़ें जब वास्तव में ज़रूरत हो।

डिस्ट्रीब्यूटेड मोड, हाई अवेलेबिलिटी, और प्रोडक्शन-ग्रेड कॉन्फ़िगरेशन किसी कारण से मौजूद हैं — लेकिन वह कारण लोकल डेवलपमेंट नहीं है। उन सेटअप्स पर तब जाएँ जब आप प्रोडक्शन में डिप्लॉय कर रहे हों, जब डाउनटाइम आपको पैसे खर्च करवाता हो, या जब आप ऐसा डेटा स्टोर कर रहे हों जिसे खोया नहीं जा सकता। तब तक, चीज़ों को सरल रखें और इन्फ्रास्ट्रक्चर मैनेज करने के बजाय अपना एप्लिकेशन बनाने पर ध्यान दें।

जब आप अधिक जटिल Docker विषयों में गहराई से जाने के लिए तैयार हों, तो हमारा Docker और Kubernetes के साथ Containerization और Virtualization कोर्स देखें।