Erlang 21 - 9. Distributed Applications

9 वितरित अनुप्रयोग




erlang

9 वितरित अनुप्रयोग

9.1 परिचय

कई एर्लैंग नोड्स के साथ एक वितरित प्रणाली में, वितरित तरीके से अनुप्रयोगों को नियंत्रित करना आवश्यक हो सकता है। यदि नोड, जहाँ एक निश्चित अनुप्रयोग चल रहा है, नीचे जाता है, तो अनुप्रयोग को दूसरे नोड पर पुनः आरंभ किया जाना है।

इस तरह के आवेदन को एक वितरित आवेदन कहा जाता है। ध्यान दें कि यह वितरित किए गए एप्लिकेशन का नियंत्रण है। सभी अनुप्रयोगों को इस अर्थ में वितरित किया जा सकता है कि वे, उदाहरण के लिए, अन्य नोड्स पर सेवाओं का उपयोग करें।

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

9.2 वितरित अनुप्रयोगों को निर्दिष्ट करना

वितरित अनुप्रयोगों को अनुप्रयोग नियंत्रक और वितरित अनुप्रयोग नियंत्रक प्रक्रिया, dist_ac दोनों द्वारा नियंत्रित किया dist_ac । ये दोनों प्रक्रियाएँ कर्नेल अनुप्रयोग का हिस्सा हैं। वितरित अनुप्रयोग इस प्रकार कर्नेल अनुप्रयोग को कॉन्फ़िगर करके, निम्न कॉन्फ़िगरेशन पैरामीटर का उपयोग करके निर्दिष्ट किया जाता है ( kernel(6) भी देखें):

distributed = [{Application, [Timeout,] NodeDesc}]

  • निर्दिष्ट करता है कि आवेदन कहां Application = atom() निष्पादित कर सकता है।
  • > NodeDesc = [Node | {Node,...,Node}] NodeDesc = [Node | {Node,...,Node}] प्राथमिकता क्रम में नोड नामों की एक सूची है। एक नलिका में नोड्स के बीच का क्रम अपरिभाषित है।
  • Timeout = integer() निर्दिष्ट करता है कि किसी अन्य नोड पर एप्लिकेशन को पुनरारंभ करने से पहले कितने मिलीसेकंड इंतजार करना होगा। यह 0 को डिफॉल्ट करता है।

ठीक से काम करने के लिए एप्लिकेशन नियंत्रण के वितरण के लिए, नोड्स जहां एक वितरित एप्लिकेशन चल सकता है, एक दूसरे से संपर्क करना चाहिए और आवेदन शुरू करने के लिए बातचीत करना चाहिए। यह कर्नेल में निम्नलिखित कॉन्फ़िगरेशन मापदंडों का उपयोग करके किया जाता है:

  • sync_nodes_mandatory = [Node] - निर्दिष्ट करता है कि किन नोड्स को शुरू किया जाना चाहिए ( sync_nodes_timeout द्वारा निर्दिष्ट टाइम-आउट के भीतर)।
  • sync_nodes_optional = [Node] - निर्दिष्ट करता है कि कौन सी अन्य नोड्स शुरू की जा सकती हैं ( sync_nodes_timeout द्वारा निर्दिष्ट टाइम-आउट के भीतर)।
  • sync_nodes_timeout = integer() | infinity sync_nodes_timeout = integer() | infinity - निर्दिष्ट करता है कि अन्य नोड्स के शुरू होने के लिए कितने मिलीसेकंड का इंतजार करना होगा।

जब शुरू किया जाता है, तो नोड को आने के लिए sync_nodes_mandatory और sync_nodes_optional द्वारा निर्दिष्ट सभी नोड्स का इंतजार होता है। जब सभी नोड्स ऊपर होते हैं, या जब सभी अनिवार्य नोड्स ऊपर होते हैं और sync_nodes_timeout द्वारा निर्दिष्ट समय समाप्त हो जाता है, तो सभी एप्लिकेशन शुरू होते हैं। यदि सभी अनिवार्य नोड्स ऊपर नहीं हैं, तो नोड समाप्त हो जाता है।

उदाहरण:

एक आवेदन myapp नोड [email protected] चलाने के लिए है। यदि यह नोड नीचे चला जाता है, तो myapp को [email protected] या [email protected] पुनः आरंभ किया [email protected] । सिस्टम कॉन्फ़िगरेशन फ़ाइल cp1.config [email protected] लिए निम्नानुसार देख सकते हैं:

[{kernel,
  [{distributed, [{myapp, 5000, [[email protected], {[email protected], [email protected]ave}]}]},
   {sync_nodes_mandatory, [[email protected], [email protected]]},
   {sync_nodes_timeout, 5000}
  ]
 }
].

[email protected] और [email protected] लिए सिस्टम कॉन्फ़िगरेशन फ़ाइलें समान हैं, अनिवार्य नोड्स की सूची को छोड़कर, जो कि [email protected] और [[email protected], [email protected]] लिए [[email protected], [email protected]] [email protected] [email protected]

ध्यान दें

सभी शामिल नोड्स में distributed और sync_nodes_timeout लिए समान मान होना चाहिए। अन्यथा सिस्टम व्यवहार अपरिभाषित है।

9.3 शुरू और वितरित अनुप्रयोगों को रोकना

जब सभी शामिल (अनिवार्य) नोड्स शुरू कर दिए गए हैं, तो वितरित एप्लिकेशन को इन सभी नोड्स पर application:start(Application) कॉल करके शुरू किया जा सकता है

एक बूट स्क्रिप्ट ( Releases देखें) का उपयोग किया जा सकता है जो स्वचालित रूप से एप्लिकेशन शुरू करता है।

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

Module:start(normal, StartArgs)

उदाहरण:

पिछले अनुभाग से उदाहरण को जारी रखते हुए, तीन नोड्स शुरू किए गए हैं, सिस्टम कॉन्फ़िगरेशन फ़ाइल को निर्दिष्ट करते हुए:

> erl -sname cp1 -config cp1
> erl -sname cp2 -config cp2
> erl -sname cp3 -config cp3

जब सभी नोड्स चालू होते हैं, तो myapp शुरू किया जा सकता है। यह कॉलिंग application:start(myapp) द्वारा प्राप्त किया जाता application:start(myapp) तीनों नोड्स पर application:start(myapp) । इसे तब cp1 पर शुरू किया cp1 , जैसा कि निम्न आकृति में दिखाया गया है:

चित्र 9.1: अनुप्रयोग myapp - स्थिति 1

इसी तरह, एप्लिकेशन को कॉल करके रोका जाना चाहिए application:stop(Application) सभी शामिल नोड्स पर application:stop(Application)

9.4 असफलता

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

एप्लिकेशन को नए नोड पर सामान्य तरीके से शुरू किया जाता है, अर्थात, एप्लिकेशन मास्टर कॉलिंग द्वारा:

Module:start(normal, StartArgs)

एक अपवाद है अगर आवेदन में start_phases कुंजी परिभाषित है (देखें Included Applications )। इसके बाद कॉल करके आवेदन शुरू किया जाता है:

Module:start({failover, Node}, StartArgs)

यहाँ Node को समाप्त नोड कहा जाता है।

उदाहरण:

यदि cp1 नीचे जाता है, तो सिस्टम यह जांचता है कि अन्य नोड्स, cp2 या cp3 cp2 पास कम से कम रनिंग एप्लिकेशन हैं, लेकिन cp1 को पुनः आरंभ करने के लिए 5 सेकंड प्रतीक्षा करता है। अगर cp1 पुनरारंभ नहीं होता है और cp2 cp3 से कम अनुप्रयोग चलाता है, तो cp2 को cp2 पर पुनः आरंभ किया cp2

चित्र 9.2: अनुप्रयोग myapp - स्थिति 2

मान लीजिए कि अब cp2 भी नीचे चला गया है और 5 सेकंड के भीतर पुनरारंभ नहीं होता है। myapp अब cp3 पर cp3

चित्र 9.3: अनुप्रयोग myapp - स्थिति 3

9.5 अधिग्रहण

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

एप्लिकेशन मास्टर कॉलिंग द्वारा शुरू किया गया है:

Module:start({takeover, Node}, StartArgs)

यहाँ Node पुराना नोड है।

उदाहरण:

यदि myapp cp3 पर चल रहा है, और यदि cp2 अब पुनरारंभ होता है, तो यह myapp पुनरारंभ नहीं करता है, क्योंकि cp2 और cp3 नोड्स के बीच का क्रम अपरिभाषित है।

चित्र 9.4: अनुप्रयोग myapp - स्थिति 4

हालाँकि, अगर cp1 भी पुनरारंभ होता है, तो फ़ंक्शन application:takeover/2 cp1 को cp1 ले जाता है, क्योंकि cp1 में इस एप्लिकेशन के लिए cp3 से अधिक प्राथमिकता है। इस मामले में, आवेदन शुरू करने के लिए cp1 पर Module:start({takeover, [email protected]}, StartArgs) निष्पादित किया cp1 है।

चित्र 9.5: अनुप्रयोग myapp - स्थिति 5