🧑🏾‍🤝‍🧑🏾 🗣️ 🚣🏽 कैसे शुरू से ही अपाचे इग्नाइट क्लस्टर को नहीं तोड़ना है 🎸 ⛽️ 👏🏿

नमस्ते! नीचे 20 जून को सेंट पीटर्सबर्ग में अपाचे इग्नाइट समुदाय रैली में भाषण के वीडियो का एक प्रतिलिपि है। आप यहां स्लाइड डाउनलोड कर सकते हैं ।

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

लॉन्च के लिए तैयारी - लॉगिंग कॉन्फ़िगर करें

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

स्वाभाविक रूप से, अपाचे इग्नाइट लॉगिंग डिफ़ॉल्ट रूप से सक्षम है। लेकिन बारीकियां हैं। सबसे पहले, अपाचे इग्नाइट stdout में थोड़ा लिखता है। डिफ़ॉल्ट रूप से, यह तथाकथित शांत मोड में शुरू होता है। stdout आपको केवल सबसे भयानक त्रुटियां दिखाई देंगी, और बाकी सब कुछ एक फ़ाइल में सहेजा जाएगा, जिस पर अपाचे इग्नाइट को बहुत शुरुआत में प्रदर्शित करता है (डिफ़ॉल्ट रूप से - ${IGNITE_HOME}/work/log )। आप इसे मिटाते नहीं हैं और लॉग को लंबे समय तक रखते हैं, यह बहुत उपयोगी हो सकता है।

डिफ़ॉल्ट स्टार्टअप पर stdout प्रज्वलित करें

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

 ignite.sh -v

और फिर सिस्टम शेष एप्लिकेशन लॉगिंग के साथ-साथ सभी घटनाओं के बारे में लिखना शुरू कर देगा।

लॉग की जाँच करें! बहुत बार उनमें आप अपनी समस्याओं का समाधान पा सकते हैं। यदि क्लस्टर ध्वस्त हो गया है, तो लॉग में बहुत बार आप "इस तरह के और इस तरह के और इस तरह के एक कॉन्फ़िगरेशन में इस तरह के बढ़ाएँ" जैसे संदेश देख सकते हैं। हम उसकी वजह से गिर गए। वह बहुत छोटा है। नेटवर्क बहुत अच्छा नहीं है। ”

क्लस्टर विधानसभा

बिन बुलाए मेहमान

पहली समस्या यह है कि कई चेहरे आपके क्लस्टर में बिन बुलाए मेहमान हैं। या आप खुद एक बिन बुलाए मेहमान बन जाते हैं: एक नया क्लस्टर शुरू करें और अचानक आप देखें कि पहले टोपोलॉजी स्नैपशॉट में एक नोड के बजाय आपके पास शुरू से ही दो सर्वर हैं। ऐसा कैसे? आपने केवल एक लॉन्च किया है।

एक संदेश जो इंगित करता है कि क्लस्टर में दो नोड हैं

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

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

बहुत सारे पते

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

तीन IP पतों की एक सूची लें। प्रत्येक के लिए, हम 10 पोर्टों की श्रेणी निर्धारित करते हैं। कुल में, 30 टीसीपी पते प्राप्त होते हैं। चूंकि अपाचे इग्नाइट को एक नया क्लस्टर बनाने से पहले मौजूदा क्लस्टर से कनेक्ट करने का प्रयास करना चाहिए, यह बदले में प्रत्येक आईपी की जांच करेगा। यह आपके लैपटॉप पर चोट नहीं कर सकता है, लेकिन पोर्ट स्कैनिंग संरक्षण अक्सर कुछ बादल वातावरण में शामिल होता है। यही है, जब कुछ आईपी पते पर एक निजी पोर्ट एक्सेस करते हैं, तो आपको कोई प्रतिक्रिया नहीं मिलेगी जब तक कि टाइमआउट पास नहीं हो जाता। डिफ़ॉल्ट रूप से, यह 10 सेकंड है। और यदि आपके पास 10 बंदरगाहों के 3 पते हैं, तो आपको प्रतीक्षा करने के लिए 3 * 10 * 10 = 300 सेकंड मिलते हैं - जो कनेक्ट होने में 5 मिनट लगते हैं।

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

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

सबसे आसान उपाय जावा मशीन के विकल्प को पास करना है

 -Djava.net.preferIPv4Stack=true

तब जावा और अपाचे इग्नाइट आईपीवी 6 का उपयोग नहीं करेंगे। यह समूहों के ढहने के साथ समस्याओं का एक महत्वपूर्ण हिस्सा हल करता है।

कोड बेस की तैयारी - हम सही ढंग से क्रमबद्ध करते हैं

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

अपाचे इग्नाइट धारावाहिकीकरण के लिए तीन तंत्रों का उपयोग करता है:

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

BinaryMarshaller को BinaryMarshaller और डी- BinaryMarshaller करने में सक्षम होगा जिनके पास फ़ील्ड और सरल तरीकों के अलावा कुछ भी नहीं है। लेकिन अगर आपके पास readObject() और readObject() माध्यम से कस्टम readObject() , यदि आप Externalizable उपयोग करते हैं, तो BinaryMarshaller सामना नहीं करेगा। वह देखेगा कि आपकी वस्तु को गैर-क्षणिक क्षेत्रों की सामान्य रिकॉर्डिंग द्वारा क्रमबद्ध नहीं किया जा सकता है और वह छोड़ देगा - यह OptimizedMarshaller वापस आ जाएगी।

अपाचे इग्नाइट के साथ ऐसी वस्तुओं के दोस्त बनाने के लिए, आपको Binarylizable इंटरफ़ेस को लागू करने की Binarylizable है। वह बहुत सरल है।

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

TreeMap.writeObject() कार्यान्वयन TreeMap.writeObject()

 private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { // Write out the Comparator and any hidden stuff s.defaultWriteObject(); // Write out size (number of Mappings) s.writeInt(size); // Write out keys and values (alternating) for (Iterator<Map.Entry<K,V>> i = entrySet().iterator(); i.hasNext(); ) { Map.Entry<K,V> e = i.next(); s.writeObject(e.getKey()); s.writeObject(e.getValue()); } }

writeBinary() और readBinary() Binarylizable काम से बिल्कुल उसी तरह से: Binarylizable खुद को एक रेगुलर Binarylizable में लपेटता है और इसे Binarylizable में लिखता है। यह विधि लिखना आसान है, और यह उत्पादकता को बहुत बढ़ाएगा।

BinaryTreeMap.writeBinary() कार्यान्वयन

 public void writeBinary(BinaryWriter writer) throws BinaryObjectException { BinaryRawWriter rewriter = writer. rewrite (); rawWriter.writeObject(map.comparator()); int size = map.size(); rawWriter.writeInt(size); for (Map.Entry<Object, Object> entry : ((TreeMap<Object, Object>)map).entrySet()) { rawWriter.writeObject(entry.getKey()); rawWriter.writeObject(entry.getValue()); } }

कम्प्यूट ग्रिड में लॉन्च

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

क्या समस्या है?

 Foo foo = …; Bar bar = ...; ignite.compute().broadcast( () -> doStuffWithFooAndBar(foo, bar) );

और अगर ऐसा है तो?

 Foo foo = …; Bar bar = ...; ignite.compute().broadcast(new IgniteRunnable() { @Override public void run() { doStuffWithFooAndBar(foo, bar); } });

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

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

निम्न उदाहरण। लैम्ब्डा फिर से, लेकिन जो अपाचे इग्नाइट एपीआई को थोड़ा उपयोग करता है।

कंप्यूट क्लोजर के अंदर इग्नाइट का उपयोग करना गलत है

 ignite.compute().broadcast(() -> { IgniteCache foo = ignite.cache("foo"); String sql = "where id = 42"; SqlQuery qry = new SqlQuery("Foo", sql).setLocal(true); return foo.query(qry); });

मूल संस्करण में, यह कैश लेता है और स्थानीय रूप से इसमें किसी प्रकार की SQL क्वेरी बनाता है। यह एक ऐसा पैटर्न है जब आपको एक कार्य भेजने की आवश्यकता होती है जो केवल दूरस्थ नोड पर स्थानीय डेटा के साथ काम करता है।

यहाँ क्या समस्या है? लैम्ब्डा फिर से लिंक को कैप्चर करता है, लेकिन अब ऑब्जेक्ट पर नहीं, बल्कि उस नोड पर स्थानीय इग्नाइट पर जिसके साथ हम इसे भेजते हैं। और यह काम भी करता है, क्योंकि इग्नाइट ऑब्जेक्ट में एक readResolve() विधि होती है, जो नेटवर्क पर आने वाले इग्नाइट को एक स्थानीय एक नोड के साथ नेटवर्क पर बदलने की अनुमति देती है, जहां हमने इसे भेजा था। लेकिन यह भी कभी-कभी अवांछनीय परिणामों की ओर जाता है।

मूल रूप से, आप बस नेटवर्क पर अधिक डेटा स्थानांतरित कर रहे हैं जितना आप चाहते हैं। यदि आपको कुछ कोड से प्राप्त करने की आवश्यकता है जिसे आप अपाचे इग्नाइट या इसके कुछ इंटरफेस के लॉन्च को नियंत्रित नहीं करते हैं, तो सबसे सरल है Ignintion.localIgnite() विधि का उपयोग करना। आप इसे किसी भी धागे से कॉल कर सकते हैं जिसे Apache इग्नाइट ने बनाया है और किसी स्थानीय ऑब्जेक्ट का लिंक प्राप्त कर सकते हैं। यदि आपके पास लैम्ब्डा, सेवाएं, कुछ भी हैं, और आप समझते हैं कि आपको यहां इग्नाइट की आवश्यकता है, तो मैं इस विधि की सलाह देता हूं।

हम localIgnite() - localIgnite() माध्यम से सही ढंग से बंद करने के अंदर इग्नाइट का उपयोग करते हैं

 ignite.compute().broadcast(() -> { IgniteCache foo = Ignition.localIgnite().cache("foo"); String sql = "where id = 42"; SqlQuery qry = new SqlQuery("Foo", sql).setLocal(true); return foo.query(qry); });

और इस भाग में अंतिम उदाहरण। अपाचे इग्नाइट में एक सेवा ग्रिड है जिसका उपयोग सीधे एक क्लस्टर में माइक्रोसर्विस को तैनात करने के लिए किया जा सकता है, और अपाचे इग्नाइट को सही संख्या में उदाहरणों को ऑनलाइन रखने में मदद करेगा। मान लीजिए इस सेवा में हमें अपाचे इग्नाइट का लिंक भी चाहिए। इसे कैसे प्राप्त करें? हम localIgnite() उपयोग कर सकते हैं, लेकिन फिर इस लिंक को मैन्युअल रूप से फ़ील्ड में सहेजना होगा।

सेवा क्षेत्र गलत तरीके से प्रज्वलित करता है - इसे निर्माता के तर्क के रूप में लेता है

 MyService s = new MyService(ignite) ignite.services().deployClusterSingleton("svc", s); ... public class MyService implements Service { private Ignite ignite; public MyService(Ignite ignite) { this.ignite = ignite; } ... }

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

सेवा @IgniteInstanceResource का उपयोग @IgniteInstanceResource

 public class MyService implements Service { @IgniteInstanceResource private Ignite ignite; public MyService() { } ... }

डेटा लिखना और पढ़ना

बेसलाइन के लिए देखना

अब हमारे पास अपाचे इग्नाइट क्लस्टर और तैयार कोड है।

आइए इस परिदृश्य की कल्पना करें:

एक REPLICATED कैश - सभी नोड्स पर डेटा की प्रतियां उपलब्ध हैं;
मूल दृढ़ता जारी है - डिस्क पर लिखें।

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

इसका कारण आधारभूत टोपोलॉजी है - कई नोड्स जो उन पर दृढ़ता डेटा संग्रहीत करते हैं। अन्य सभी नोड्स में लगातार डेटा नहीं होगा।

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

 control.sh --baseline

आप देख सकते हैं कि कौन से नोड्स वहां सूचीबद्ध हैं। वही स्क्रिप्ट आधार रेखा को उसकी वर्तमान स्थिति में अपडेट कर सकती है।

control.sh उदाहरण

डाटा कॉलोलेशन

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

 public class Person { @QuerySqlField public Long id; @QuerySqlField public Long orgId; } public class Organization { @QuerySqlField private Long id; }

जांच

 SELECT * FROM Person as p JOIN Organization as o ON p.orgId = o.id

सारा डेटा वापस नहीं करेगा। क्या गलत है?

व्यक्ति ( Person ) आईडी द्वारा संगठन ( Organization ) को संदर्भित करता है। यह एक क्लासिक विदेशी कुंजी है। लेकिन अगर हम दो तालिकाओं को संयोजित करने और ऐसी एसक्यूएल क्वेरी भेजने की कोशिश करते हैं, तो क्लस्टर में कई नोड्स के साथ हम सभी डेटा प्राप्त नहीं करेंगे।

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

सही परिणाम प्राप्त करने के लिए, हमें डेटा (कॉलोकेशन) को एक साथ रखना होगा। यही है, व्यक्ति और संगठन के सही संयोजन के लिए, दोनों तालिकाओं के डेटा को एक ही नोड पर संग्रहीत किया जाना चाहिए।

यह कैसे करना है? सबसे आसान समाधान एक आत्मीयता कुंजी घोषित करना है। यह एक मूल्य है जो यह निर्धारित करता है कि किस नोड पर, किस विभाजन में, किस समूह में यह या वह मान स्थित होगा। यदि हम Person में संगठन आईडी को एक आत्मीयता की कुंजी के रूप में घोषित करते हैं, तो इसका मतलब यह होगा कि इस संगठन आईडी वाले लोगों को समान आईडी वाले संगठन के समान नोड पर होना चाहिए।

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

आइए विचार करें कि आत्मीयता की चाबियाँ कैसे काम करें। हम कैसे समझते हैं कि ऐसी और ऐसी आईडी, ऐसा और ऐसा क्षेत्र आत्मीयता का निर्धारण करने के लिए उपयुक्त है? यदि हम कहते हैं कि एक ही orgId सभी लोग एक साथ संग्रहीत किए जाएंगे, तो orgId एक अविभाज्य समूह है। हम इसे कई नोड्स के बीच वितरित नहीं कर सकते। यदि डेटाबेस में 10 संगठन हैं, तो 10 अविभाज्य समूह होंगे जिन्हें 10 नोड्स पर रखा जा सकता है। यदि क्लस्टर में अधिक नोड्स हैं, तो सभी "अतिरिक्त" नोड बिना समूहों के रहेंगे। रनटाइम में परिभाषित करना बहुत मुश्किल है, इसलिए इसके बारे में पहले से सोचें।

यदि आपके पास एक बड़ा संगठन है और 9 छोटे हैं, तो समूहों का आकार अलग होगा। लेकिन अपाचे इग्नाइट, आत्मीयता समूहों में रिकॉर्ड की संख्या को नहीं देखता है जब यह उन्हें नोड्स में वितरित करता है। इसलिए, वह एक समूह को एक नोड पर नहीं डालेगा, लेकिन किसी अन्य को वितरण के स्तर को बनाने के लिए 9 अन्य को दूसरे पर डाल देगा। बल्कि, वह उन्हें 5 और 5, (या 6 और 4, या 7 और 3) भी डाल देगा।

डेटा को समान रूप से कैसे वितरित किया जाए? हमारे पास हो सकता है

K कुंजी;
विभिन्न प्रकार की आत्मीयता कुंजी;
पी विभाजन, अर्थात्, डेटा के बड़े समूह जो अपाचे इग्नाइट नोड्स के बीच वितरित करेंगे;
एन नोड्स।

फिर यह आवश्यक है कि शर्त

 K >> A >> P >> N

जहाँ >> "बहुत अधिक" है और डेटा अपेक्षाकृत समान रूप से वितरित किया जाएगा।

वैसे, डिफ़ॉल्ट P = 1024 है।

सबसे अधिक संभावना है कि आप एक समान वितरण में सफल नहीं होंगे। अपाचे इग्नाइट 1.x से 1.9 में यह मामला था। इसे FairAffinityFunction कहा जाता था और यह बहुत अच्छी तरह से काम नहीं करता था - इससे नोड्स के बीच बहुत अधिक ट्रैफ़िक होता था। अब एल्गोरिदम को RendezvousAffinityFunction कहा जाता है। यह बिल्कुल ईमानदार वितरण नहीं देता है, नोड्स के बीच त्रुटि प्लस या माइनस 5-10% होगी।

नई अपाचे के लिए चेकलिस्ट उपयोगकर्ताओं को प्रज्वलित करें

सेट, पढ़ें, स्टोर लॉग
मल्टीकास्ट बंद करें, केवल उन पते और बंदरगाहों को लिखें जो आप उपयोग करते हैं
IPv6 को अक्षम करें
BinaryMarshaller लिए अपनी कक्षाएं तैयार करें
अपने आधार रेखा का ध्यान रखें
आत्मीयता सहयोग स्थापित करें

कैसे शुरू से ही अपाचे इग्नाइट क्लस्टर को नहीं तोड़ना है