सबसे अच्छा पैटर्न अजगर, पिका और AMQP का उपयोग कर एक अतुल्यकालिक आरपीसी आवेदन डिजाइन करने के लिए क्या है?

Question

अपने आवेदन के निर्माता मॉड्यूल जो काम प्रस्तुत करना चाहते हैं एक छोटे समूह पर किया जा करने के लिए उपयोगकर्ताओं द्वारा चलाया जाता है। यह जेएसओएन फॉर्म में सदस्यता को RabbitMQ संदेश ब्रोकर के माध्यम से भेजता है।

मैं कई रणनीतियों की कोशिश की है, और सबसे अच्छा अब तक निम्नलिखित है, जो अभी भी पूरी तरह काम नहीं कर रहा है:

प्रत्येक क्लस्टर मशीन एक उपभोक्ता मॉड्यूल है, जो खुद AMQP कतार और मुद्दों पर एक का सदस्य बनता चलाता है ब्रोकर को बताने के लिए prefetch_count एक बार में कितने कार्य चला सकते हैं।

मैं इसे Pika AMQP लाइब्रेरी से SelectConnection का उपयोग करके काम करने में सक्षम था। उपभोक्ता और निर्माता दोनों चैनल दो चैनल शुरू करते हैं, जो प्रत्येक कतार से जुड़ा होता है। निर्माता चैनल [एक] पर चैनल पर अनुरोधों के लिए चैनल में प्रतिक्रिया के लिए और अनुरोधों प्रतीक्षा करता है [बी], और उपभोक्ता प्रतीक्षा करता है भेजता है [एक] और चैनल पर प्रतिसाद भेजें [बी]। ऐसा लगता है कि, जब उपभोक्ता कॉलबैक चलाता है जो प्रतिक्रिया की गणना करता है, तो यह ब्लॉक करता है, इसलिए प्रत्येक बार प्रत्येक उपभोक्ता में मेरे पास केवल एक ही कार्य निष्पादित होता है।

क्या मैं अंत में की जरूरत है:

1. उपभोक्ता [एक] अपने कार्यों सब्सक्राइब (5k हर बार के आसपास) क्लस्टर
2. दलाल प्रत्येक उपभोक्ता है, जहां एन के लिए एन संदेश/अनुरोध डिस्पैच करने के लिए समवर्ती कार्यों की संख्या यह
3. संभाल कर सकते हैं जब एक ही कार्य समाप्त हो गया है है, उपभोक्ता परिणाम
4. निर्माता, उत्तर प्राप्त करता है और गणना स्थिति अद्यतन, अंत में प्रिंट के साथ दलाल/निर्माता करने के लिए उत्तर कुछ रिपोर्ट

प्रतिबंध:

• किसी अन्य उपयोगकर्ता काम प्रस्तुत करते हैं, तो उसके कार्यों के सभी पिछले उपयोगकर्ता (मुझे लगता है कि इस कतार सिस्टम से स्वचालित रूप से सही है, लेकिन मैंने सोचा नहीं किया है के बाद पंक्ति में लग जाएँगे एक पिरोया पर्यावरण पर प्रभाव)
• कार्य एक आदेश प्रस्तुत किया जाना है, लेकिन क्रम में वे उत्तर दिया रहे हैं के बारे में महत्वपूर्ण नहीं है

उत्तर प्रदेश दिनांक

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

Answer 1

आपका सेटअप मेरे लिए अच्छा लगता है। और आप सही हैं, आप थ्रेड और श्रृंखला को शुरू करने के लिए कॉलबैक सेट कर सकते हैं, जब थ्रेड समाप्त हो जाता है जब थ्रेड चैनल बी

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

एक बार कार्यकर्ता अपने काम के साथ किया जाता है, तो यह परिणाम एक अलग परिणाम कतार पर वापस कर देगा और इसे मुख्य थ्रेड पर कॉलबैक जारी करेगा ताकि वह उपभोक्ता को वापस भेज सके।

आपको ध्यान रखना चाहिए और यह सुनिश्चित करना चाहिए कि कार्यकर्ता धागे एक दूसरे के साथ हस्तक्षेप नहीं कर रहे हैं यदि वे किसी भी साझा संसाधन का उपयोग कर रहे हैं, लेकिन यह एक अलग विषय है।

Answer 2

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

Answer 3

जैसा कि आपने देखा है, कॉलबैक चलाने पर आपकी प्रक्रिया अवरुद्ध होती है। आपके कॉलबैक के आधार पर इसका निपटारा करने के कई तरीके हैं।

अपने कॉलबैक आईओ बाध्य किया जाता है (की नेटवर्किंग या डिस्क आईओ बहुत कर रही है) आप या तो धागे या एक greenlet आधारित समाधान का उपयोग कर सकते हैं, इस तरह के रूप gevent, eventlet, या greenhouse। ध्यान रखें, हालांकि, पाइथन जीआईएल (ग्लोबल इंटरप्रेटर लॉक) द्वारा सीमित है, जिसका अर्थ है कि एक अजगर प्रक्रिया में केवल एक टुकड़ा पाइथन कोड चल रहा है। इसका मतलब यह है कि यदि आप पाइथन कोड के साथ बहुत अधिक गणना कर रहे हैं, तो ये समाधान आपके पास पहले से कहीं अधिक तेज़ नहीं होंगे।

एक और विकल्प multiprocessing का उपयोग करके अपने उपभोक्ता को कई प्रक्रियाओं के रूप में कार्यान्वित करना होगा। समानांतर काम करते समय मुझे मल्टीप्रोसेसिंग बहुत उपयोगी पाया गया है। आप इसे Queue का उपयोग कर कार्यान्वित कर सकते हैं, जिसमें माता-पिता उपभोक्ता होने और अपने बच्चों को खेती करने के लिए खेती कर रहे हैं, या बस कई प्रक्रियाओं को शुरू कर सकते हैं जो प्रत्येक स्वयं ही उपभोग करते हैं। मैं सुझाव दूंगा, जब तक कि आपका आवेदन अत्यधिक समवर्ती (श्रमिकों के 1000s) न हो, केवल कई श्रमिकों को शुरू करने के लिए, जिनमें से प्रत्येक अपने स्वयं के कनेक्शन से उपभोग करता है। इस तरह, आप एएमक्यूपी की स्वीकृति सुविधा का उपयोग कर सकते हैं, इसलिए यदि कोई उपभोक्ता अभी भी कार्य को संसाधित करते समय मर जाता है, तो संदेश को कतार में स्वचालित रूप से वापस भेजा जाता है और अनुरोध को खोने के बजाए किसी अन्य कार्यकर्ता द्वारा उठाया जाएगा।

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