Apache HBase क्षेत्र विभाजन और विलय

यह ब्लॉग पोस्ट Cloudera के साथ विलय से पहले Hortonworks.com पर प्रकाशित हुआ था। कुछ लिंक, संसाधन या संदर्भ अब सटीक नहीं हो सकते हैं।

इस पोस्ट के लिए, हम HBase के मुख्य क्षेत्रों में से एक में एक तकनीकी गहरी-गोता लगाते हैं। विशेष रूप से, हम देखेंगे कि कैसे Apache HBase क्षेत्रों के माध्यम से लोड वितरित करता है, और क्षेत्र विभाजन का प्रबंधन करता है। HBase तालिकाओं में डेटा की पंक्तियों को संग्रहीत करता है। तालिकाओं को "क्षेत्रों" नामक पंक्तियों के टुकड़ों में विभाजित किया जाता है। उन क्षेत्रों को क्लस्टर में वितरित किया जाता है, होस्टेड किया जाता है और रीजनसर्वर प्रक्रिया द्वारा क्लाइंट प्रक्रियाओं के लिए उपलब्ध कराया जाता है। एक क्षेत्र कुंजी स्थान के भीतर एक सतत श्रेणी है, जिसका अर्थ है कि तालिका में सभी पंक्तियां जो क्षेत्र की प्रारंभ कुंजी और अंत कुंजी के बीच क्रमबद्ध होती हैं, उसी क्षेत्र में संग्रहीत होती हैं। क्षेत्र गैर-अतिव्यापी हैं, यानी एक पंक्ति कुंजी किसी भी समय बिल्कुल एक क्षेत्र से संबंधित है। एक क्षेत्र को किसी भी समय केवल एक क्षेत्र सर्वर द्वारा परोसा जाता है, इस प्रकार HBase एक पंक्ति में मजबूत स्थिरता की गारंटी देता है#। साथ में -रूट- और .मेटा। क्षेत्र, एक तालिका के क्षेत्र प्रभावी रूप से एक तालिका के भीतर एक पंक्ति का पता लगाने के उद्देश्य से एक 3 स्तरीय बी-ट्री बनाते हैं।

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

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

पूर्व-विभाजन

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

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

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

$ hbase org.apache.hadoop.hbase.util.RegionSplitter test_table HexStringSplit -c 10 -f f1

जहां -c 10, क्षेत्रों की अनुरोधित संख्या को 10 के रूप में निर्दिष्ट करता है, और -f उन कॉलम परिवारों को निर्दिष्ट करता है जिन्हें आप तालिका में ":" से अलग करते हैं। टूल 10 क्षेत्रों के साथ “test_table” नाम की एक टेबल बनाएगा:

13/01/18 18:49:32 DEBUG hbase.HRegionInfo: Current INFO from scan results = {NAME => 'test_table,,1358563771069.acc1ad1b7962564fc3a43e5907e8db33.', STARTKEY => '', ENDKEY => '19999999', ENCODED => acc1ad1b7962564fc3a43e5907e8db33,}
13/01/18 18:49:32 DEBUG hbase.HRegionInfo: Current INFO from scan results = {NAME => 'test_table,19999999,1358563771096.37ec12df6bd0078f5573565af415c91b.', STARTKEY => '19999999', ENDKEY => '33333332', ENCODED => 37ec12df6bd0078f5573565af415c91b,}
...

यदि आपके पास विभाजित बिंदु हैं, तो आप वांछित विभाजन बिंदुओं वाली तालिका बनाने के लिए HBase शेल का उपयोग भी कर सकते हैं।

hbase(main):015:0> create 'test_table', 'f1', SPLITS=> ['a', 'b', 'c']

या

$ echo -e  "anbnc" >/tmp/splits
hbase(main):015:0> create 'test_table', 'f1', SPLITSFILE=>'/tmp/splits'

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

स्वतः विभाजन

भले ही पूर्व-विभाजन का उपयोग किया गया हो या नहीं, एक बार जब कोई क्षेत्र एक निश्चित सीमा तक पहुंच जाता है, तो यह स्वतः ही दो क्षेत्रों में विभाजित हो जाता है। यदि आप HBase 0.94 (जो HDP-1.2 के साथ आता है) का उपयोग कर रहे हैं, तो आप कॉन्फ़िगर कर सकते हैं कि HBase किसी क्षेत्र को विभाजित करने का निर्णय कब लेता है, और यह प्लग करने योग्य RegionSplitPolicy API के माध्यम से विभाजन बिंदुओं की गणना कैसे करता है। कुछ पूर्वनिर्धारित क्षेत्र विभाजन नीतियां हैं:ConstantSizeRegionSplitPolicy, InnovationToUpperBoundRegionSplitPolicy, और KeyPrefixRegionSplitPolicy।

पहला 0.94 से पहले HBase संस्करणों के लिए डिफ़ॉल्ट और केवल विभाजित नीति है। यह उन क्षेत्रों को विभाजित करता है जब क्षेत्र में किसी एक स्टोर (स्तंभ-परिवार के अनुरूप) के लिए कुल डेटा आकार कॉन्फ़िगर किए गए "hbase.hregion.max.filesize" से बड़ा हो जाता है, जिसका डिफ़ॉल्ट मान 10GB है। यह विभाजन नीति उन मामलों में आदर्श है, जहां आप पूर्व-विभाजन कर चुके हैं, और प्रति क्षेत्र सर्वर की कम संख्या प्राप्त करने में रुचि रखते हैं।

HBase 0.94 और ट्रंक के लिए डिफॉल्ट स्प्लिट पॉलिसी इंक्रीजिंग टूअपरबाउंड रीजनस्प्लिट पॉलिसी है, जो एक ही क्षेत्र सर्वर में होस्ट किए गए क्षेत्रों की संख्या के आधार पर अधिक आक्रामक विभाजन करती है। विभाजन नीति न्यूनतम (R^2 * "hbase.hregion.memstore.flush.size", "hbase.hregion.max.filesize") के आधार पर अधिकतम स्टोर फ़ाइल आकार का उपयोग करती है, जहां R उसी के क्षेत्रों की संख्या है एक ही रीजनसर्वर पर होस्ट की गई तालिका। तो उदाहरण के लिए, 128 एमबी के डिफ़ॉल्ट मेमस्टोर फ्लश आकार और 10 जीबी के डिफ़ॉल्ट अधिकतम स्टोर आकार के साथ, क्षेत्र सर्वर पर पहला क्षेत्र 128 एमबी पर पहले फ्लश के ठीक बाद विभाजित हो जाएगा। जैसे-जैसे क्षेत्र सर्वर में होस्ट किए गए क्षेत्रों की संख्या बढ़ती है, यह बढ़ते हुए विभाजन आकारों का उपयोग करेगा:512MB, 1152MB, 2GB, 3.2GB, 4.6GB, 6.2GB, आदि। 9 क्षेत्रों तक पहुंचने के बाद, विभाजित आकार कॉन्फ़िगर किए गए "hbase" से आगे निकल जाएगा .hregion.max.filesize", तब से 10GB स्प्लिट साइज का उपयोग किया जाएगा। इन दोनों एल्गोरिदम के लिए, बंटवारे के समय की परवाह किए बिना, उपयोग किया जाने वाला विभाजन बिंदु वह पंक्ति है जो सबसे बड़े स्टोर में सबसे बड़ी स्टोर फ़ाइल के लिए "ब्लॉक इंडेक्स" में मध्य बिंदु से मेल खाती है।

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

आप कॉन्फ़िगरेशन "hbase.regionserver.region.split.policy" सेट करके या टेबल डिस्क्रिप्टर को कॉन्फ़िगर करके उपयोग की जाने वाली डिफ़ॉल्ट विभाजन नीति को कॉन्फ़िगर कर सकते हैं। आप बहादुर आत्माओं के लिए, आप अपनी खुद की कस्टम विभाजन नीति भी लागू कर सकते हैं, और तालिका निर्माण के समय या मौजूदा तालिका को संशोधित करके इसे प्लग इन कर सकते हैं:

HTableDescriptor tableDesc = new HTableDescriptor("example-table");
tableDesc.setValue(HTableDescriptor.SPLIT_POLICY, AwesomeSplitPolicy.class.getName());
//add columns etc
admin.createTable(tableDesc);

यदि आप पूर्व-विभाजन कर रहे हैं, और क्षेत्र विभाजन को मैन्युअल रूप से प्रबंधित करना चाहते हैं, तो आप "hbase.hregion.max.filesize" को एक उच्च संख्या पर सेट करके और विभाजन नीति को ConstantSizeRegionSplitPolicy पर सेट करके क्षेत्र विभाजन को अक्षम भी कर सकते हैं। हालाँकि, आपको 100GB जैसे सुरक्षा मूल्य का उपयोग करना चाहिए, ताकि क्षेत्र किसी क्षेत्र सर्वर की क्षमताओं से आगे न बढ़ें। आप स्वचालित विभाजन को अक्षम करने पर विचार कर सकते हैं और पूर्व-विभाजन से क्षेत्रों के प्रारंभिक सेट पर भरोसा कर सकते हैं, उदाहरण के लिए, यदि आप अपने प्रमुख उपसर्गों के लिए समान हैश का उपयोग कर रहे हैं, और आप यह सुनिश्चित कर सकते हैं कि प्रत्येक क्षेत्र के साथ-साथ उसके आकार को पढ़ने/लिखने का भार भी हो तालिका में सभी क्षेत्रों में एक समान है।

जबरन विभाजन

HBase क्लाइंट को क्लाइंट साइड से ऑनलाइन टेबल को विभाजित करने के लिए बाध्य करने में सक्षम बनाता है। उदाहरण के लिए, HBase शेल का उपयोग तालिका के सभी क्षेत्रों को विभाजित करने के लिए किया जा सकता है, या एक क्षेत्र को विभाजित करने के लिए वैकल्पिक रूप से एक विभाजन बिंदु की आपूर्ति करके किया जा सकता है।

hbase(main):024:0> split 'b07d0034cbe72cb040ae9cf66300a10c', 'b'
0 row(s) in 0.1620 seconds

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

क्षेत्र विभाजन कैसे लागू किया जाता है

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

हालांकि क्षेत्र को विभाजित करना रीजनसर्वर पर लिया गया एक स्थानीय निर्णय है, विभाजन प्रक्रिया को स्वयं कई अभिनेताओं के साथ समन्वय करना चाहिए। रीजनसर्वर विभाजन से पहले और बाद में मास्टर को सूचित करता है, .META को अपडेट करता है। तालिका ताकि ग्राहक नए बेटी क्षेत्रों की खोज कर सकें, और एचडीएफएस में निर्देशिका संरचना और डेटा फ़ाइलों को पुनर्व्यवस्थित कर सकें। स्प्लिट एक मल्टी टास्क प्रोसेस है। किसी त्रुटि की स्थिति में रोलबैक को सक्षम करने के लिए, RegionServer निष्पादन स्थिति के बारे में एक इन-मेमोरी जर्नल रखता है। विभाजन को निष्पादित करने के लिए रीजनसर्वर द्वारा उठाए गए कदम चित्र 1 द्वारा दर्शाए गए हैं। प्रत्येक चरण को उसके चरण संख्या के साथ लेबल किया गया है। रीजनसर्वर या मास्टर की कार्रवाइयां लाल रंग में दिखाई जाती हैं, जबकि क्लाइंट की कार्रवाइयां हरे रंग में दिखाई जाती हैं।

1. क्षेत्र सर्वर स्थानीय रूप से क्षेत्र को विभाजित करने का निर्णय लेता है, और विभाजन तैयार करता है। पहले चरण के रूप में, यह ज़ूकीपर में /hbase/region-in-transition/region-name के तहत स्प्लिटिंग अवस्था में एक znode बनाता है।
2. मास्टर इस ज़नोड के बारे में सीखता है, क्योंकि उसके पास मूल क्षेत्र-इन-ट्रांज़िशन ज़्नोड के लिए एक द्रष्टा है।
3. रीजनसर्वर एचडीएफएस में पैरेंट के क्षेत्र निर्देशिका के तहत ".splits" नामक एक उप-निर्देशिका बनाता है।
4. RegionServer पैरेंट क्षेत्र को बंद कर देता है, कैश को फ्लश करने के लिए बाध्य करता है और इस क्षेत्र को अपने स्थानीय डेटा संरचनाओं में ऑफ़लाइन के रूप में चिह्नित करता है। इस बिंदु पर, मूल क्षेत्र में आने वाले क्लाइंट अनुरोध NotServingRegionException को फेंक देंगे। क्लाइंट कुछ बैकऑफ़ के साथ पुनः प्रयास करेगा।
5. क्षेत्र सर्वर बेटी क्षेत्रों ए और बी के लिए .splits निर्देशिका के तहत क्षेत्र निर्देशिका बनाता है, और आवश्यक डेटा संरचना बनाता है। फिर यह स्टोर फ़ाइलों को विभाजित करता है, इस अर्थ में कि यह मूल क्षेत्र में प्रति स्टोर फ़ाइल में दो संदर्भ फ़ाइलें बनाता है। वे संदर्भ फ़ाइलें मूल क्षेत्रों की फ़ाइलों को इंगित करेंगी।
6. रीजनसर्वर एचडीएफएस में वास्तविक क्षेत्र निर्देशिका बनाता है, और प्रत्येक बेटी के लिए संदर्भ फाइलों को स्थानांतरित करता है।
7. RegionServer .META को एक पुट अनुरोध भेजता है। तालिका, और माता-पिता को .META में ऑफ़लाइन के रूप में सेट करता है। तालिका और बेटी क्षेत्रों के बारे में जानकारी जोड़ता है। इस समय, .META में व्यक्तिगत प्रविष्टियाँ नहीं होंगी। बेटियों के लिए। यदि वे .META को स्कैन करते हैं, तो ग्राहक देखेंगे कि मूल क्षेत्र विभाजित हो गया है, लेकिन जब तक वे .META में दिखाई नहीं देंगे, तब तक उन्हें बेटियों के बारे में पता नहीं चलेगा। साथ ही, यदि इसे .META पर रखा जाए। सफल होता है, माता-पिता को प्रभावी ढंग से विभाजित किया जाएगा। यदि इस RPC के सफल होने से पहले RegionServer विफल हो जाता है, तो मास्टर और क्षेत्र को खोलने वाला अगला क्षेत्र सर्वर क्षेत्र विभाजन के बारे में गंदी स्थिति को साफ कर देगा। मेटा के बाद। अद्यतन, हालांकि, क्षेत्र विभाजन को मास्टर द्वारा आगे बढ़ाया जाएगा।
8. रीजनसर्वर बेटियों को समानांतर में लिखता है स्वीकार करने के लिए खोलता है।
9. RegionServer बेटियों A और B को .META में जोड़ता है। एक साथ जानकारी के साथ कि यह क्षेत्रों को होस्ट करता है। इस बिंदु के बाद, ग्राहक नए क्षेत्रों की खोज कर सकते हैं, और नए क्षेत्र के लिए अनुरोध जारी कर सकते हैं। ग्राहक .META को कैश करते हैं। स्थानीय रूप से प्रविष्टियां, लेकिन जब वे क्षेत्र सर्वर या .META. से अनुरोध करते हैं, तो उनका कैश अमान्य कर दिया जाएगा, और वे .META..
10 से नए क्षेत्रों के बारे में जानेंगे। रीजनसर्वर ज़ूकीपर में znode /hbase/region-in-transition/region-name को स्टेट SPLIT में अपडेट करता है, ताकि मास्टर इसके बारे में जान सके। बैलेंसर स्वतंत्र रूप से बेटी क्षेत्रों को अन्य क्षेत्र सर्वरों को फिर से असाइन कर सकता है यदि वह ऐसा चुनता है।
11. विभाजन के बाद, मेटा और एचडीएफएस में अभी भी मूल क्षेत्र के संदर्भ होंगे। उन संदर्भों को हटा दिया जाएगा जब बेटी क्षेत्रों में संघनन डेटा फ़ाइलों को फिर से लिखता है। मास्टर में कचरा संग्रह कार्य समय-समय पर जांचता है कि क्या बेटी क्षेत्र अभी भी माता-पिता की फाइलों को संदर्भित करता है। यदि नहीं, तो मूल क्षेत्र हटा दिया जाएगा।

क्षेत्र विलय

क्षेत्र विभाजन के विपरीत, इस बिंदु पर HBase विलय क्षेत्रों के लिए प्रयोग करने योग्य उपकरण प्रदान नहीं करता है। यद्यपि HMerge, और Merge टूल हैं, वे सामान्य उपयोग के लिए बहुत उपयुक्त नहीं हैं। वर्तमान में ऑनलाइन टेबल और ऑटो-मर्जिंग कार्यक्षमता के लिए कोई समर्थन नहीं है। हालाँकि, OnlineMerge जैसे मुद्दों के साथ, मास्टर ने स्वचालित क्षेत्र विलय शुरू किया, तालिका संचालन के लिए ZK- आधारित रीड / राइट लॉक, हम क्षेत्र के विभाजन को स्थिर करने और क्षेत्र विलय के लिए बेहतर समर्थन को सक्षम करने के लिए काम कर रहे हैं। बने रहें!

निष्कर्ष

जैसा कि आप देख सकते हैं, अंडर-द-हुड HBase क्षेत्रों के विभाजन को प्रबंधित करने और क्षेत्रों के माध्यम से स्वचालित शार्डिंग करने के लिए बहुत सारी हाउसकीपिंग करता है। हालाँकि, HBase क्षेत्र प्रबंधन के लिए आवश्यक उपकरण भी प्रदान करता है, ताकि आप विभाजन प्रक्रिया का प्रबंधन कर सकें। आप यह भी ठीक से नियंत्रित कर सकते हैं कि क्षेत्र विभाजन कब और कैसे हो रहा है एक RegionSplitPolicy के माध्यम से।

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