सिद्धांत से अभ्यास करने के लिए MongoDB। MongoDB क्लस्टर इंस्टॉलेशन गाइड

अच्छे दिन, प्रिय पाठकों। इस पोस्ट में, मैं mongoDB विकास के कई उदाहरणों का वर्णन करना चाहूंगा, उनके बीच अंतर, उनके काम के सिद्धांत। हालाँकि, मैं सबसे अधिक आप के साथ साझा करने के व्यावहारिक अनुभव के साथ साझा करना चाहूंगा। यदि इस पोस्ट की योजना थी, तो यह सबसे अधिक संभावना होगी:

1. परिचय। स्केलिंग के बारे में संक्षेप में
2. MongoDB स्कैन और उनके विवरण के कुछ उदाहरण
3. शेयरिंग mongoDB

अंक 1 और 2 सैद्धांतिक हैं, और नंबर 3 का दावा है कि मोंगोडीबी क्लस्टर को बढ़ाने के लिए एक व्यावहारिक गाइड है और उन लोगों के लिए सबसे उपयुक्त है जो पहली बार इसके साथ सामना कर रहे हैं।

1. परिचय। स्केलिंग के बारे में थोड़ा सा

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

• सैद्धांतिक रूप से अनंत स्केलिंग (मशीनों को आप जितना चाहें उतना डाला जा सकता है)
• ग्रेटर डेटा सुरक्षा (केवल प्रतिकृति का उपयोग करते समय) - मशीनें विभिन्न डेटा केंद्रों में स्थित हो सकती हैं (यदि उनमें से कोई दुर्घटनाग्रस्त हो जाती है, तो बाकी रह जाती हैं)

2. mongoDB स्कैन के कुछ उदाहरण

२.१ सबसे सरल योजना, बिना शार्टिंग के

इस योजना में, सब कुछ सरल है - एक ऐसा एप्लिकेशन है जो ड्राइवर के माध्यम से मोंगॉड के साथ संचार करता है। mongod मुख्य mongoDB प्रक्रिया है जिसका कार्य अनुरोध प्राप्त करना, उन्हें संसाधित करना और उन्हें निष्पादित करना है। मोंगोड में डेटा तथाकथित चंक्स (चंक्स) में संग्रहीत किया जाता है। प्रत्येक चंक में एक "चंक्साइज़" आकार है, जो डिफ़ॉल्ट रूप से 64 एमबी है। शारीरिक रूप से, चंक को dbName.n फ़ाइलों में संग्रहीत किया जाता है, जहाँ n सीरियल नंबर है, जो 0. से शुरू होता है। जब आकार 64 एमबी (या अन्य चंक्साइज़) तक पहुँचता है, तो चंक को आधा कर दिया जाता है, यह 2 छोटे विखंडू में बदल जाता है - 32 एमबी प्रत्येक, ये 2 चंक्स तब तक भरना शुरू करते हैं। हिस्सा आकार में पहुँच जाता है, फिर बंटवारा फिर से होता है, आदि। DbName.0 की फ़ाइल का आकार 64 एमबी है, dbName.1 128 एमबी है, dbName.2 256 है, आदि। 2Gb तक। चंक्स की संख्या और आकार बढ़ने पर, ये फाइलें भर जाती हैं और जब पहली फ़ाइल होती है - dbName.5, जिसका आकार 2 Gb होता है, आकार में वृद्धि रुक ​​जाती है और mongoDB बस उसी आकार की फाइलें बनाता है। यह भी ध्यान दिया जाना चाहिए कि mongoDB केवल इन फ़ाइलों को आवश्यक रूप से नहीं बनाता है, बल्कि उन्हें अग्रिम में बनाता है, ताकि जब वास्तव में किसी फ़ाइल को डेटा लिखना आवश्यक हो जाए, तो फ़ाइल बनाने में समय बर्बाद न करें। इसलिए, अपेक्षाकृत कम मात्रा में वास्तविक डेटा के साथ, आप पा सकते हैं कि हार्ड डिस्क स्थान पर शालीनता से कब्जा कर लिया गया है।
यह योजना स्थानीय परीक्षण के लिए सबसे अधिक बार लागू होती है।

2.2 प्रतिकृति के बिना शारदोवन्नाया योजना

इस योजना में, नए तत्व दिखाई देते हैं। सर्किट को छायांकित कहा जाता है। शार्ल्ड स्कीम का एक महत्वपूर्ण अंतर यह है कि इसका डेटा सिर्फ़ विखंडू में नहीं लिखा जाता है, जो तब आधे हिस्से में बंट जाता है, लेकिन किसी दिए गए क्षेत्र की एक निश्चित सीमा पर गिर जाता है - शार्क कुंजी। सबसे पहले, केवल एक हिस्सा बनाया जाता है और मूल्यों की सीमा होती है जो सीमा में निहित है (-one, + ∞):



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

{“name”: “Max”, “age”: 23, “id”: 23} {“name”: “John”, “age”: 28, “id”: 15} {“name”: “Nick”, “age”: 19, “id”:56} {“name”: “Carl”, “age”: 19, “id”: 78} 

मान लीजिए कि चंक्साइज़ आकार पहले ही पहुंच चुका है। इस मामले में, Mongos इस तरह की सीमा को विभाजित करेगा (-, 45); (45, +)। हमें 2 विखंडू मिलते हैं।



जब नए दस्तावेज़ दिखाई देते हैं, तो उन्हें एक शंक में दर्ज किया जाएगा, जो कि शर्डके रेंज से मेल खाता है। चकबंदी तक पहुंचने पर, जुदाई फिर से हो जाएगी और सीमा संकीर्ण और इसी तरह होगी। सभी विखंडू शार्क पर रखे गए हैं।
यह ध्यान रखना महत्वपूर्ण है कि जब कोई चंक अविभाज्य सीमा तक पहुँचता है, उदाहरण के लिए (४४, ४५), तो विभाजन नहीं होगा और ठुड्डी चौके से ऊपर बढ़ेगी। इसलिए, आपको सावधानी से शार्द की का चयन करना चाहिए ताकि यह यथासंभव यादृच्छिक हो। उदाहरण के लिए, यदि। यदि हमें ग्रह पर सभी लोगों के साथ डेटाबेस में भरने की आवश्यकता है, तो सफल शार्प कुंजी विकल्प एक फोन नंबर, कर पहचान संख्या, ज़िप कोड, असफल - नाम, निवास का शहर होगा।
आरेख में हम कॉन्फिग सर्वर को देख सकते हैं, मोंगॉड से इसका अंतर यह है कि यह क्लाइंट रिक्वेस्ट को प्रोसेस नहीं करता है, बल्कि मेटाडेटा का रिपॉजिटरी है - यह सभी चंक-एस के फिजिकल एड्रेस को जानता है, कौन सा चंक है, कौन सा शार्प दिखना है और इस की कौन सी रेंज है एक और शार्क। वह एक विशेष रूप से निर्दिष्ट जगह में सभी डेटा संग्रहीत करता है - कॉन्फ़िगरेशन डेटाबेस।
इस योजना में, एक अनुरोध राउटर - मोंगोस भी है, निम्नलिखित कार्य इसे सौंपे गए हैं:

1. कॉन्फ़िगरेशन सर्वर पर संग्रहीत डेटा कैशिंग
2. ड्राइवर से अनुरोधों को पढ़ना और लिखना रूटिंग - अनुप्रयोगों से आवश्यक शार्क के अनुरोधों को रूट करना, मोंगोस को ठीक से पता है कि यह या वह हिस्सा कहां स्थित है
3. पृष्ठभूमि प्रक्रिया "बैलेंसर" शुरू करना

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

2.3 प्रतिकृति सेट के साथ साझा योजना

इस योजना में, शार्किंग के अलावा, शार्क प्रतिकृति मौजूद है। इस बारे में कुछ शब्द। सभी लिखते हैं, हटाते हैं, अपडेट संचालन मास्टर (प्राथमिक) में जाते हैं, और फिर उन्हें एक विशेष ओप्लोग संग्रह में लिखा जाता है, जहां से वे एसिंक्रोनस रूप से प्रतिकृतियां जाते हैं - उत्तर 1 और उत्तर 2 (द्वितीयक)। इस प्रकार, डेटा का दोहराव होता है। इसकी आवश्यकता क्यों है?

• अतिरेक डेटा सुरक्षा सुनिश्चित करता है - जब मास्टर क्रैश हो जाता है, तो प्रतिकृतियों के बीच एक वोट होता है और उनमें से एक मास्टर बन जाता है
• मास्टर और प्रतिकृतियां अलग-अलग डेटा केंद्रों में स्थित हो सकते हैं - यह तब उपयोगी हो सकता है जब सर्वर शारीरिक रूप से क्षतिग्रस्त हो (डेटा सेंटर में आग)
• डेटा को अधिक कुशलता से पढ़ने के लिए प्रतिकृतियों का उपयोग किया जा सकता है। उदाहरण के लिए, एक एप्लिकेशन है जिसमें यूरोप और संयुक्त राज्य अमेरिका में एक ग्राहक दर्शक हैं। प्रतिकृतियों में से एक को संयुक्त राज्य में रखा जा सकता है और कॉन्फ़िगर किया जा सकता है ताकि संयुक्त राज्य अमेरिका के ग्राहक उससे डेटा पढ़ें। यह ध्यान देने योग्य है कि प्रतिकृतियों पर दस्तावेजों में देरी हो रही है और प्रतिकृति पर एक नए रिकॉर्ड किए गए दस्तावेज़ को तुरंत ढूंढना संभव नहीं है। इसलिए, यह आइटम केवल एक लाभ है यदि एप्लिकेशन तर्क प्रतिकृतियों से पढ़ने की अनुमति देता है।

प्रतिकृति सेट के साथ एक योजना अक्सर गंभीर उत्पादन अनुप्रयोगों में होती है जहां डेटा अखंडता महत्वपूर्ण होती है या बड़ी संख्या में रीडिंग होती है और एप्लिकेशन तर्क प्रतिकृति से पढ़ने की अनुमति देता है।
हम इस योजना पर अधिक विस्तार से ध्यान नहीं देंगे, क्योंकि वह एक अलग पद समर्पित कर सकती है।

3. शेयरिंग

तो चलिए शुरू करते हैं। हम यह सब स्थानीय रूप से लिनक्स ubuntu 12.0 पर तैनात करेंगे। यह सब करने के लिए, हमें mongoDB स्थापित करने की आवश्यकता है, मेरे पास संस्करण 2.4.9 है।
हम स्कीम नंबर 2 को बदल देंगे, केवल हम इसे उन तत्वों से हटा देंगे जिनका विशुद्ध रूप से सैद्धांतिक महत्व है:



आइए हम सभी के लिए परिचित खोल खोलते हैं , अधिमानतः एक साथ कई टैब, क्योंकि mongos, mongod, config सर्वर सभी अलग-अलग प्रक्रियाएं हैं। आइटम पर आगे:

1. 2 खाली निर्देशिका बनाएं जिसमें डेटा संग्रहीत किया जाएगा:
   

    > sudo mkdir /data/instance1 > sudo mkdir /data/instance2 

   
   मंगोल आदेशों के 2 उदाहरण उठाएँ:
   

    > sudo mongod --dbpath /data/instance1 --port 27000 //   

   
   और निम्नलिखित टर्मिनल में:
   

    > sudo mongod --dbpath /data/instance2 --port 27001 //  

   
   --Dbpath पैरामीटर उस पथ को निर्दिष्ट करता है जहां .0, .1, .2 और .ns फाइलें संग्रहीत की जाएंगी। फ़ाइलों में .0, .1, .2 इत्यादि। इस उदाहरण का डेटा बाइनरी रूप में संग्रहीत है, और .ns फ़ाइल में डेटाबेस को नेविगेट करने के लिए आवश्यक नामस्थान है। --पोर्ट - पोर्ट जिस पर डेटाबेस ऑब्जेक्ट उपलब्ध होगा।
   पहले पैराग्राफ के बाद, हमारे पास दो उदाहरण हैं:
   
   
2. एक खाली निर्देशिका बनाएं जिसमें सर्वर कॉन्फिग डेटा संग्रहीत किया जाएगा:
   

    > sudo mkdir /data/config 

   
   कॉन्फ़िगर सर्वर उठाएँ, कमांड
   

    > sudo mongod --configsvr --dbpath /data/config --port 27002 

   
   --Configsvr पैरामीटर इंगित करता है कि नया उदाहरण कॉन्फ़िगरेशन सर्वर होगा, --dbpath वह पथ है जहां डेटा संग्रहीत किया जाएगा। दूसरे बिंदु के बाद, चित्र इस तरह दिखता है (मैं इस तथ्य पर आपका ध्यान आकर्षित करूंगा कि अभी तक इन संस्थाओं को एक दूसरे के बारे में कुछ भी नहीं पता है):
   
   
3. मोंगोस, टीम उठाएं
   

    > sudo mongos --configdb 127.0.0.1:27002 --port 27100 

   
   इस कमांड के अनुसार, मूंगोस पोर्ट 27100 पर उगता है, इनपुट के लिए इसे अपने मेजबानों के साथ सर्वर कॉन्फ़िगरेशन की सूची को स्थानांतरित करने की आवश्यकता होती है, जो इसे एक्सेस करेगा। यदि हमने मोंगो को बढ़ाते समय एक पोर्ट निर्दिष्ट नहीं किया है, तो यह डिफ़ॉल्ट 27017 का उपयोग करता है (यदि यह व्यस्त नहीं है)। Mongos बढ़ाने के बाद:
   
   
4. Mongos से कनेक्ट करें, उस पोर्ट को इंगित करें जिस पर हमने इसे उठाया था, कमांड
   

    > mongo --port 27100 

   
   उसके बाद हमें मिलता है:
   
   
5. अंतिम चरण बना हुआ है - क्लस्टर में हमारी शार्क जोड़ें
   

    > sh.addShard("127.0.0.1:27000") > sh.addShard("127.0.0.1:27001") 

   
   इन 2 आदेशों को मोंगोस पर निष्पादित किया जाना चाहिए, जो कनेक्शन चरण 4 में खोला गया था । db.printShardingStatus () कमांड का उपयोग करके , आप शार्डिंग स्थिति देख सकते हैं। सुनिश्चित करें कि शार्क को जोड़ा जाता है, टर्मिनल में हमें कुछ इस तरह देखना चाहिए:
   
   

    --- Sharding Status --- sharding version: { "_id" : 1, "version" : 3, "minCompatibleVersion" : 3, "currentVersion" : 4, "clusterId" : ObjectId("53317aefca1ba9ba232b949e") } shards: { "_id" : "shard0000", "host" : "127.0.0.1:27000" } { "_id" : "shard0001", "host" : "127.0.0.1:27001" } databases: { "_id" : "admin", "partitioned" : false, "primary" : "config" } { "_id" : "test", "partitioned" : false, "primary" : "shard0000" } 

   
   
   हमारे पास अंतिम तस्वीर है:
   
   

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

 > use admin > sh.enableSharding("bank") 

Db.printShardingStatus () कमांड फिर से चलाएँ। आउटपुट कुछ इस तरह होना चाहिए:

 databases: { "_id" : "admin", "partitioned" : false, "primary" : "config" } { "_id" : "test", "partitioned" : false, "primary" : "shard0000" } { "_id" : "bank", "partitioned" : true, "primary" : "shard0000" } 

जैसा कि आप देख सकते हैं, सच विभाजन के विपरीत दिखाई दिया, इसलिए हम सही रास्ते पर हैं।

अब हमारे डेटाबेस के साथ काम करते हैं:

 > use bank //   bank (  ,   ) > db.tickets.insert({name: “Max”, amount: Math.random()*100}) //     tickets (  ,      ) > for (var i=0; i<2100000; i++) { db.tickets.insert({name: “Max”, amount: Math.random()*100}) } //     javascript > db.tickets.ensureIndex({amount: 1}) // ,       shard Key > db.tickets.stats() //,    .  ,   sharded   false,       primaryShard > use admin //  ,     tickets.         (primary)  > db.runCommand({shardCollection: "bank.tickets", key: {amount: 1}}) //  ,    - shard key  . 

अंतिम आदेश के बाद, हमें कुछ इस तरह से देखना चाहिए:

 { "collectionsharded" : "bank.tickets", "ok" : 1 } 

इस सब के बाद, sh.status (true) या db.printShardingStatus () कमांड को यह सुनिश्चित करने के लिए निष्पादित करें कि सब कुछ काम किया है और, यदि सब कुछ सही ढंग से किया गया है, तो हमें निम्नलिखित चित्र देखना चाहिए:



जैसा कि आप देख सकते हैं, डेटा असमान रूप से वितरित किया जाता है, लेकिन यदि आप थोड़ा इंतजार करते हैं और db.printShardingStatus () कमांड को दोहराते हैं , तो चित्र एक समान वितरण की ओर बदल जाता है:





और अंतिम तस्वीर:



जैसा कि हमने देखा, पहला हिस्सा प्राथमिक शर्ड पर सहेजा जाता है, और फिर दूसरे शर्ड पर तब तक माइग्रेट किया जाता है जब तक कि संख्या बराबर न हो जाए, और उनकी रेंज भी बदल सकती है।

भविष्य में मैं mongoDB में मेमोरी के संगठन और प्रतिकृति के बारे में बात करना चाहूंगा। आपका ध्यान देने के लिए धन्यवाद।