क्लस्टर

Question

में वितरित लेनदेन और/या डेटा साझा करने के लिए जावा समाधान जावा सर्वर अनुप्रयोग को क्लस्टरिंग/वितरित करने के लिए सबसे अच्छे दृष्टिकोण क्या हैं? मैं एक ऐसे दृष्टिकोण की तलाश में हूं जो आपको अधिक एप्लिकेशन सर्वर, और अधिक डेटाबेस सर्वर जोड़कर क्षैतिज पैमाने पर स्केल करने की अनुमति देता है।

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

इस "पढ़ें" "सर्वश्रेष्ठ" समाधान आपको एक एकल नोड के लिए जावा एप्लिकेशन लिखने की अनुमति देगा और उम्मीद है कि साझा डेटा को एक्सेस/लॉक करने के अधिकांश विवरण "छुपाएं"।

एक वितरित वातावरण में साझा डेटा तक पहुंचने के लिए कई लेन-देन हमेशा सबसे कठिन समस्या आते हैं। ऐसा लगता है कि समवर्ती लेनदेन के लिए 2 आम दृष्टिकोण हैं।

1. Explicit locks (जो बहुत ही त्रुटि है प्रवण और धीमी गति से एक वितरित प्रणाली में एक से अधिक नोड्स भर में समन्वय करने के लिए)
2. Software transactional memory (एसटीएम) उर्फ ​​आशावादी संगामिति जहां एक सौदे एक के दौरान वापस लुढ़का हुआ है प्रतिबद्ध अगर यह पता चलता है कि साझा राज्य बदल गया है (और लेनदेन बाद में पुनः प्रयास किया जा सकता है)। कौन सा दृष्टिकोण स्केल बेहतर है और वितरित सिस्टम में ट्रेड-ऑफ क्या हैं?

मैं स्केलिंग समाधान (और सामान्य अनुप्रयोगों कि कैसे पैमाने पर करने के तरीके का उदाहरण में) जैसे शोध किया गया है:

1. Terracotta - प्रदान करता है "पारदर्शी" स्केलिंग के लिए जावा स्मृति मॉडल का विस्तार करके जावा की समवर्ती लॉकिंग तंत्र (सिंक्रनाइज़, रीेंट्रंट रीडवाइट लॉक) का उपयोग करके वितरित साझा मेमोरी शामिल करें।
2. Google App Engine Java - आपको जावा (या पायथन) अनुप्रयोगों को लिखने की अनुमति देता है जो "क्लाउड" सर्वरों के बीच वितरित किए जाएंगे, जहां आप वितरित करते हैं कि कौन सा सर्वर लेनदेन को संभालता है और आप अपने लगातार डेटा को स्टोर करने के लिए बिगटेबल का उपयोग करते हैं (सुनिश्चित नहीं है कि आप साझा किए गए लेन-देन कैसे करते हैं प्रभावी ढंग से स्केल करने में सक्षम होने के लिए डेटा या लॉक विवादों को संभाल लें)
3. Darkstar MMO Server - डार्कस्टार सूर्य का ओपन सोर्स एमएमओ (बड़े पैमाने पर मल्टीप्लेयर ऑनलाइन) गेम सर्वर है जो वे एक थ्रेड ट्रांजैक्शनल तरीके से लेनदेन को स्केल करते हैं, जो किसी दिए गए लेनदेन को केवल एक निश्चित राशि के लिए चलाने की इजाजत देता है और काम करना और यदि यह लंबे समय तक चलता है तो यह रोलबैक होगा (सॉफ़्टवेयर ट्रांजैक्शनल मेमोरी की तरह)। वे स्केलिंग के लिए supporting a multi-node server setup में शोध कर रहे हैं।
4. Hibernate's optimistic locking - अगर आप हाइबरनेट उपयोग कर रहे हैं आप software transactional memory प्रकार व्यवहार
5. Apache CouchDB कई रीडर/राइटर डीबी के लिए "पैमाने" एक जाल विन्यास में स्वाभाविक रूप से माना जाता है कि समर्थन करने के लिए उनके आशावादी संगामिति समर्थन उपयोग कर सकते हैं। (क्या आप लॉकिंग डेटा को प्रबंधित करने या लेनदेन अलगाव सुनिश्चित करने का एक अच्छा उदाहरण है?):
6. JCache - सामान्य प्रश्नों के परिणामों को कैश करके "पढ़ने" भारी ऐप्स स्केलिंग, जिसे आप Google एपेंगिन में memcached तक पहुंचने और अन्य बार पढ़ने वाले डेटा को कैश करने के लिए उपयोग कर सकते हैं।

टेराकोटा स्केलिंग का समर्थन करने के लिए मौजूदा सर्वर एप्लिकेशन को "आसानी से" संशोधित कर सकता है (@Root ऑब्जेक्ट्स और @ ऑटो लॉक रीड/लिखें विधियों को परिभाषित करने के बाद)। समस्या वास्तव में एक वितरित अनुप्रयोग से सबसे अधिक प्रदर्शन प्राप्त करने के लिए है, वितरित सिस्टम के लिए अनुकूलन वास्तव में एक विचार के बाद नहीं है कि आपको इसे ज्ञान के साथ डिजाइन करना होगा कि ऑब्जेक्ट एक्सेस संभावित रूप से नेटवर्क I/O द्वारा अवरोधित किया जा सकता है।

ठीक से पैमाने पर करने के लिए ऐसा लगता है जैसे कि यह हमेशा विभाजन डेटा और लोड संतुलन लेनदेन करने के लिए नीचे आता है इस तरह कि किसी दिए गए "निष्पादन इकाई" (सीपीयू कोर -> धागा -> वितरित अनुप्रयोग नोड -> डीबी मास्टर नोड)

ऐसा लगता है कि क्लस्टरिंग द्वारा किसी ऐप स्केल को सही तरीके से बनाने के लिए आपको अपने डेटा एक्सेस पढ़ने/लिखने के संदर्भ में अपने लेन-देन को विभाजित करने में सक्षम होना चाहिए। लोग अपने एप्लिकेशन डेटा (ओरेकल, Google बिगटेबल, माईएसक्यूएल, डाटा वेयरहाउसिंग) को वितरित करने के लिए किस समाधान के साथ आते हैं, और आम तौर पर आप विभाजन डेटा का प्रबंधन कैसे करते हैं (कई लिखने वाले स्वामी, कई और पढ़ें डीबी आदि)।

अपने डेटा दृढ़ता परत को स्केल करने के मामले में कई पाठकों/कई लेखकों को आपके डेटा को विभाजित करने के मामले में किस तरह का कॉन्फ़िगरेशन स्केल करता है (आमतौर पर मैं किसी दिए गए उपयोगकर्ता (या जो भी मूल इकाई) के आधार पर अपना डेटा विभाजित करता हूं आमतौर पर आपकी "रूट" ऑब्जेक्ट इकाई होती है) एक मास्टर डीबी के स्वामित्व में)

Answer 1

अच्छी तरह से एक ही स्थान पर सभी संभावनाओं को सारांशित करने के लिए धन्यवाद।

हालांकि एक तकनीक गायब है। यह MapReduce-Hadoop है। यदि MapReduce प्रतिमान में समस्या को फिट करना संभव है, तो यह शायद सबसे व्यापक रूप से उपलब्ध समाधान है। मुझे यह भी आश्चर्य है कि अभिनेता फ्रेमवर्क पैटर्न (जेटलांग, किलिम, आदि) को क्लस्टर में बढ़ाया जा सकता है या नहीं।

Answer 2

एरलांग के Mnesia को न भूलें।

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

Answer 3

• Coherence, और GigaSpaces को न भूलें।

Answer 4

शायद उन slides सहायक होंगे। हमारे अनुभव से मैं ओरेकल (टैंगोसोल) कोऑरेंस और गीगास्पेस को सबसे शक्तिशाली डेटा और प्रसंस्करण वितरण ढांचे के रूप में अनुशंसा करता हूं। समस्या की सटीक प्रकृति के आधार पर, उनमें से एक चमक सकता है। टेराकोटा भी कुछ समस्याओं के लिए काफी लागू है।

Answer 5

सोचा मैं एक महान जावा क्लस्टरिंग/वितरित मंच मिल गया है, इस-

चेकआउट http://www.hazelcast.com

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

Answer 6

ओरेकल जुटना और सुझाव अन्य समाधान का एक बहुत डेटा को साझा करने के लिए अच्छे हैं, तब तक आप केवल ताला लगा और एसटीएम तरीके एक वितरित वातावरण में राज्य उत्परिवर्तन का प्रबंधन करने के रूप में उद्धृत किया; वे राज्य प्रबंधन को स्केल करने के लिए आम तौर पर बहुत खराब तरीके हैं। एक अलग साइट पर, मैंने हाल ही में निम्नलिखित को पोस्ट किया है (उदाहरण के लिए) अनुक्रम काउंटर:

यदि आप काउंटर देख रहे हैं, तो कोहेरेंस एंट्रीप्रोसेसर जैसे कुछ का उपयोग करके आसानी से "एक बार और केवल" किसी भी तरह के monotonically बढ़ते अनुक्रमों के लिए "व्यवहार और एचए"; यहां संपूर्ण कार्यान्वयन है:

public class SequenceCounterProcessor 
     extends AbstractProcessor 
    { 
    public Object process(InvocableMap.Entry entry) 
     { 
     long l = entry.isPresent() ? (Long) entry.getValue() + 1 : 0; 
     entry.setValue(l); 
     return l; 
     } 
    } 

युप। बस। स्वचालित और निर्बाध एचए, गतिशील स्केल-आउट लोच, एक बार-और-केवल-एक बार व्यवहार, आदि हो गया।

EntryProcessor है कि हम एक तरफ 2005

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

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

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

ऊपर करने के लिए कुछ अनुकूलन अनुकूलित क्रमबद्धता के लिए ExternalizableLite & PortableObject इंटरफेस जोड़ने शामिल है, और सीधे डेटा का "तैयार नेटवर्क" फ़ॉर्म के बाद जाकर की बॉक्सिंग लंबे क्रमबद्धता से परहेज:

public Object process(InvocableMap.Entry entry) 
    { 
    try 
     { 
     BinaryEntry binentry = (BinaryEntry) entry; 
     long l = entry.isPresent() ? binentry.getBinaryValue() 
       .getBufferInput().readLong() + 1 : 0L; 
     BinaryWriteBuffer buf = new BinaryWriteBuffer(8); 
     buf.getBufferOutput().writeLong(l); 
     binentry.updateBinaryValue(buf.toBinary()); 
     return l; 
     } 
    catch (IOException e) 
     { 
     throw new RuntimeException(e); 
     } 
    } 

और चूंकि यह स्टेटलेस है, क्यों एक सिंगलटन उदाहरण जाने के लिए तैयार नहीं है?

public static final SequenceCounterProcessor INSTANCE = 
     new SequenceCounterProcessor(); 

नेटवर्क पर कहीं से भी उपयोग करना कोड की एक पंक्ति के रूप में सरल है:

long l = (Long) sequences.invoke(x, SequenceCounterProcessor.INSTANCE); 

कहाँ "x" किसी भी वस्तु या नाम है कि विशेष अनुक्रम काउंटर आप उपयोग करना चाहते की पहचान करता है । http://coherence.oracle.com/

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

इसके अलावा, किसी भी तर्क का आह्वान करने या किसी भी डेटा को पारदर्शी रूप से किसी भी कोहेरेंस नोड से एक्सेस करने की क्षमता के अलावा, आप उस तर्क में से किसी भी तर्क का आह्वान कर सकते हैं या किसी भी डेटा को नेटवर्क पर किसी भी प्रक्रिया से पारदर्शी रूप से एक्सेस कर सकते हैं (निश्चित रूप से प्रमाणीकरण और प्रमाणीकरण के अधीन)। तो यह कोड किसी भी कोहेरेंस क्लस्टर नोड या किसी भी (जावा/सी/सी ++/सी #/.NET) क्लाइंट से काम करेगा:

पूर्ण प्रकटीकरण के लिए, मैं ओरेकल में काम करता हूं। इस पोस्ट में व्यक्त राय और विचार मेरे हैं, और मेरे नियोक्ता के विचारों या विचारों को जरूरी नहीं दर्शाते हैं।