Celery: फ़ीचर: बीट को समवर्ती आमंत्रणों से बचना चाहिए

को निर्मित 17 नव॰ 2010  ·  48टिप्पणियाँ  ·  स्रोत: celery/celery

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

सेलेरीबीट को या तो अनजाने संगामिति को रोकने के लिए एक तंत्र प्रदान करना चाहिए, या दस्तावेज़ीकरण को सर्वोत्तम अभ्यास दृष्टिकोण का सुझाव देना चाहिए।

Celerybeat

सबसे उपयोगी टिप्पणी

@ अंकुर 11 सिंगल-बीट सुनिश्चित करता है कि सेलेरी बीट का केवल एक उदाहरण चल रहा है, लेकिन इंस्टेंस के बीच शेड्यूल स्थिति को सिंक्रनाइज़ नहीं करता है।

यदि मैंने हर 15 मिनट में चलने के लिए आवधिक कार्य के साथ डिफ़ॉल्ट शेड्यूलर का उपयोग किया है, और पिछली बार कार्य चलने के 14 मिनट बाद सिंगल-बीट के साथ एक विफलता थी, तो कार्य नई सेलेरी बीट के 15 मिनट बाद तक नहीं चलेगा उदाहरण शुरू हुआ, जिसके परिणामस्वरूप 29 मिनट का अंतराल हुआ।

उदाहरणों के बीच शेड्यूल स्थिति साझा करने के लिए मुझे वैकल्पिक शेड्यूलर का उपयोग करने की आवश्यकता है। django-celery-बीट सेलेरी डॉक्स में उल्लिखित विकल्प है, लेकिन मेरी प्राथमिकता शेड्यूल सिंकिंग के लिए रेडिस को बैकएंड के रूप में उपयोग करना था, क्योंकि मैं पहले से ही रेडिस को अपने सेलेरी बैकएंड के रूप में उपयोग कर रहा था।

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

हमारे कार्यान्वयन में रेडबीट के साथ शेड्यूलर के रूप में (उदाहरण exec celery beat --scheduler=redbeat.RedBeatScheduler --app=myproject.celery:app ) के साथ, पर्यवेक्षक द्वारा सभी उदाहरणों पर सेलेरी बीट शुरू किया गया है। दुर्भाग्य से मैं काम से संबंधित कोड साझा नहीं कर सकता, लेकिन मुझे सामान्य रूप से कार्यान्वयन के बारे में किसी भी अतिरिक्त प्रश्न का उत्तर देने में खुशी हो रही है।

सभी 48 टिप्पणियाँ

इसे kombu.pidbox का उपयोग करके हल किया जा सकता है, इस प्रकार celeryd पता लगाता है कि एक ही नाम के साथ एक नोड पहले से चल रहा है। चूंकि celerybeat केंद्रीकृत है

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

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

हमारे पास एक समस्या थी जहां celerybeat चलने वाला बॉक्स बिना किसी अच्छे फॉलबैक के ऑफ़लाइन हो गया और इसकी जगह लेने के लिए एक नया celerybeat इंस्टेंस शुरू किया गया। celerybeat चलाने के लिए अनुशंसित HA तरीका क्या है?

क्या kombu.pidbox दृष्टिकोण हमें celerybeat कई उदाहरणों को चलाने की अनुमति देता है जो कि सो जाएगा यदि यह पता चला है कि एक उदाहरण पहले से ही निश्चित नोड नाम के साथ चल रहा था और सक्रिय को बढ़ावा देने के लिए मतदान कर रहा था यदि वह उदाहरण नीचे चला जाता है?

कई सक्रिय इंस्टेंस चलाना दिलचस्प लगता है - शेड्यूल साझा करने के अलावा और क्या लाभ हो सकते हैं?

+1

+1

यह कुछ ऐसा है जो बड़ी तैनाती के लिए एक वास्तविक चिंता का विषय है, शेड्यूलिंग का लचीलापन महत्वपूर्ण है।

+9999;)
क्या kombu.pidbox समाधान का उपयोग करने में कुछ गड़बड़ है? शार्डिंग और फैंसी फीचर्स के बिना भी यह बहुत अच्छा और बहुत आसान होगा। अभी मुझे मैन्युअल रूप से किसी अन्य होस्ट पर सेलेरीबीट प्रारंभ करने की आवश्यकता है।

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

तकनीकी रूप से यह दूसरे धागे का उपयोग कर सकता है, लेकिन यह प्रदर्शन को नीचे खींच सकता है और इस सुविधा के लिए बहुत अधिक ओवरहेड है।

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

इसमें लॉक पर 2 सेकंड का टाइमआउट भी हो सकता है, और हर सेकंड लॉक को अपडेट कर सकता है। फिर इसका मतलब है कि अगर लॉक होता है तो एक नए इंस्टेंस को 2 सेकंड तक इंतजार करना होगा।

कतार घोषित करके amqp में एक लॉक बनाया जा सकता है, उदाहरण के लिए `queue_declare('celerybeat.lock', तर्क = {'x-expire': 2000}``

+1

मुझे यह देखना अच्छा लगेगा

+1

+1

+1 भी

+1

क्या किसी ने वास्तव में kombu.pidbox समाधान या किसी अन्य तंत्र को लागू किया है जो इस समस्या को हल करता है? अगर ऐसा है तो कृपया इसे शेयर करें। बहुत सारे लोग अभी भी सोच रहे हैं कि सबसे अच्छा अभ्यास क्या है।

क्या इस वजह से कोई पूरी तरह से अजवाइन से दूर हो गया है? मुझे यह जानने में भी दिलचस्पी होगी।

संपादित करें:

मुझे यह सार (https://gist.github.com/winhamwr/2719812) एक Google चर्चा के माध्यम से मिला (https://www.google.co.in/search?q=celerybeat+lock&aq=f&oq=celerybeat+lock&aqs= chrome.0.57j62l3.2125j0&sourceid=chrome&ie=UTF-8)।

मैं यह भी सोच रहा हूं कि क्या किसी ने सीधे सेलेरीबीट के लिए साझा पिडफाइल का उपयोग किया है, शायद एडब्ल्यूएस पर ईबीएस के साथ या शायद एस 3 बाल्टी में ... celerybeat --pidfile=/path/to/shared/volume

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

@mlavin यह काम कर सकता है, लेकिन केवल ब्रोकर ट्रांसपोर्ट के लिए जो प्रसारण का समर्थन करता है

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

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

मैंने पाया है कि अक्सर जो लोग इस समस्या से प्रभावित होते हैं वे वे होते हैं जो डिमोनाइजेशन में -B विकल्प का उपयोग करते हैं
स्क्रिप्ट और फिर उस सेटअप को दूसरे होस्ट पर डुप्लिकेट करता है।

तो मुझे लगता है कि यह कष्टप्रद है, लेकिन मुझे नहीं लगता कि यह महत्वपूर्ण है। अगर कोई वास्तव में समाधान चाहता है तो वे इसमें योगदान कर सकते हैं, या इसे लागू करने के लिए मुझे किराए पर दे सकते हैं/दान कर सकते हैं।

अन्य नोड (नोड्स) पर फॉलबैक के साथ सिंगल बीट प्रक्रिया के लिए यूडब्ल्यूएसजीआई का उपयोग कर सकते हैं

+1, हम समान अमेज़ॅन ईसी 2 इंस्टेंस लॉन्च करते हैं और आवधिक कार्यों को करना अच्छा होगा जो केवल एक नोड में निष्पादित होते हैं। इस बीच मैं सुझाव के लिए यूडब्ल्यूएसजीआई धन्यवाद का उपयोग करने की कोशिश करूंगा।

+1

+1

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

@junaidch मुझे नहीं लगता कि आपको इस वजह से अजवाइन

अजवाइन में कुछ अंतर्निहित कार्यक्षमता होना अच्छा होगा क्योंकि यह एक तरह का वर्कअराउंड है, लेकिन फिर भी यह उत्पादन में ठीक है।

धन्यवाद @23doors।

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

मैं उप-वर्गीकरण अनुशंसा की जांच करूंगा। यह एक क्लीनर दृष्टिकोण हो सकता है।

सुझावों के लिए धन्यवाद!

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

@ingmar हमने इसी कारण से यह https://github.com/ybrs/single-beat लिखा था, पिछली बार जब मैंने जाँच की थी कि मैंने आपकी टिप्पणी नहीं देखी। हमने ओपनसोर्स के रूप में भी जारी किया कुछ अन्य के लिए उपयोगी हो सकता है। कमोबेश यही काम करता है।

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

आशा है कि यह किसी और के लिए उपयोगी हो सकता है।

+1

+1

मैं कॉन्सल कुंजी-मानों का उपयोग लॉक नियंत्रक के रूप में करने पर विचार कर रहा हूं, क्या किसी ने इस दृष्टिकोण की कोशिश की है? इसलिए जब एक इंस्टेंस काम कर रहा होता है, तब तक दूसरे "सो" जाते हैं जब तक कि लॉक को अपडेट नहीं किया जाता है, तब कौंसुल चुनाव तंत्र यह तय करेगा कि टाइमस्टैम्प्ड की वैल्यू को अपडेट करने वाला कौन होगा। जो कोई भी लॉक को अपडेट करता है वही काम करता है।

@ingmar इसके लिए धन्यवाद! मैं इसे अपने कार्यकर्ता क्लस्टर पर एक शॉट देने जा रहा हूं।

+10 वर्तमान कार्यान्वयन के रूप में विफलता का एक एकल बिंदु है जो इस बात से दूर जाता है कि हम पहली जगह में एक वितरित कतार का उपयोग क्यों करते हैं

+1

+1

ऐसा लगता है कि यह v5.0.0 में होने जा रहा है https://github.com/celery/celery/milestones/v5.0.0

+1

इसे बंद करना, मौजूदा संसाधनों की तरह इसे पूरा होने में 10 साल लगेंगे।

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

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

यह मुद्दा अब छह साल से खुला है, और भले ही इसका अक्सर अनुरोध किया जाता है, और अनगिनत कंपनियां इस पर निर्भर हैं, किसी ने भी इसे लागू करने के लिए भुगतान करने की पेशकश नहीं की है।

यह वास्तव में उन मुद्दों में से एक था जो मुझे लगा कि कंपनियों के लिए प्रायोजित करना दिलचस्प होगा। यह माना जाता है कि कंपनियों के लिए किसी भी सुविधा, बग फिक्स, या यहां तक ​​​​कि उत्पादन समस्या को हल करने में मदद के लिए भुगतान करने की पेशकश करना आम बात नहीं है। मैं शायद उन्हें एक तरफ गिन सकता हूं (आप कमाल हैं), इसलिए अब मुझे पता है कि यह विचार कितना भोला था :)

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

@ask मेला काफी। यह सच है कि वितरित क्रोन एक बड़ी जटिल समस्या है, जैसा कि आप दूसरे सूत्र में कहते हैं। और यह कुछ ऐसा लगता है जो सेलेरी के बाहर रहना चाहिए।

अपने तर्क को विस्तार से समझाने के लिए समय निकालने के लिए धन्यवाद।

@ask मैं सोच रहा था कि क्या क्लस्टर में सभी नोड्स में साझा किए गए NFS वॉल्यूम के अंदर celerybeat-schedule फ़ाइल ( celery.beat.PersistentScheduler द्वारा प्रयुक्त) का पता लगाकर इस समस्या को रोका जा सकता है?

PersistentScheduler वर्ग डेटाबेस मॉड्यूल के रूप में shelve का उपयोग करता है, इसलिए celerybeat-schedule फ़ाइल के समवर्ती लेखन को डिज़ाइन द्वारा रोका जाना चाहिए। यह shelve दस्तावेज़ीकरण का एक अंश है:

शेल्व मॉड्यूल शेल्व्ड ऑब्जेक्ट्स के लिए समवर्ती पढ़ने/लिखने का समर्थन नहीं करता है। (एक साथ कई पढ़ने की पहुंच सुरक्षित है।) जब किसी प्रोग्राम में लिखने के लिए एक शेल्फ खुला होता है, तो किसी अन्य प्रोग्राम में इसे पढ़ने या लिखने के लिए खुला नहीं होना चाहिए।

मान लें कि हम सेलेरी बीट इस तरह शुरू करते हैं:

celery -A project-name beat -l info -s /nfs_shared_volume/celerybeat-schedule

जहां /nfs_shared_volume साझा वॉल्यूम है (उदाहरण के लिए, एडब्ल्यूएस लोचदार फाइल सिस्टम द्वारा प्रबंधित), क्या हम उम्मीद कर सकते हैं कि क्लस्टर में प्रत्येक नोड पर एक सेलेरी बीट प्रक्रिया चलने पर भी शेड्यूल गड़बड़ नहीं होगा?

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

@ ze-phyr-us मुझे लगता है कि आप सही हैं, और मैंने shelve डॉक्स की गलत व्याख्या की। फिर भी, मैं सोच रहा हूँ कि क्या Scheduler बैकएंड शेड्यूल पर परमाणु संचालन सुनिश्चित करता है, यह मानकर समस्या हल हो जाएगी? @ask समस्या को हल करने के लिए django-celery-beat पैकेज परमाणुता का समर्थन करता है? मैंने देखा कि यह कुछ अपडेट करने के लिए लेनदेन का उपयोग करता है।

किसी अन्य के लिए जो एक वितरित / ऑटो-स्केलिंग अनुकूल सेलेरी बीट की खोज करते हुए यहां समाप्त होता है, और रेडिस को बैकएंड के रूप में उपयोग करने में प्रसन्नता होती है; मैंने ऊपर वर्णित बीटकॉप और सिंगल-बीट दोनों की कोशिश की, लेकिन अंततः रेडबीट को चुना।

नमस्ते @ddevlin
मुझे इसी तरह की समस्या हो रही है, सिंगल-बीट का उपयोग करते समय आपको किन समस्याओं का सामना करना पड़ा? इसके अलावा यदि यह बहुत अधिक नहीं है, तो क्या आप कृपया कार्यान्वयन नमूना साझा कर सकते हैं कि आपने एकाधिक सर्वरों के लिए रेडबीट को कैसे कॉन्फ़िगर किया है।

@ अंकुर 11 सिंगल-बीट सुनिश्चित करता है कि सेलेरी बीट का केवल एक उदाहरण चल रहा है, लेकिन इंस्टेंस के बीच शेड्यूल स्थिति को सिंक्रनाइज़ नहीं करता है।

यदि मैंने हर 15 मिनट में चलने के लिए आवधिक कार्य के साथ डिफ़ॉल्ट शेड्यूलर का उपयोग किया है, और पिछली बार कार्य चलने के 14 मिनट बाद सिंगल-बीट के साथ एक विफलता थी, तो कार्य नई सेलेरी बीट के 15 मिनट बाद तक नहीं चलेगा उदाहरण शुरू हुआ, जिसके परिणामस्वरूप 29 मिनट का अंतराल हुआ।

उदाहरणों के बीच शेड्यूल स्थिति साझा करने के लिए मुझे वैकल्पिक शेड्यूलर का उपयोग करने की आवश्यकता है। django-celery-बीट सेलेरी डॉक्स में उल्लिखित विकल्प है, लेकिन मेरी प्राथमिकता शेड्यूल सिंकिंग के लिए रेडिस को बैकएंड के रूप में उपयोग करना था, क्योंकि मैं पहले से ही रेडिस को अपने सेलेरी बैकएंड के रूप में उपयोग कर रहा था।

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

हमारे कार्यान्वयन में रेडबीट के साथ शेड्यूलर के रूप में (उदाहरण exec celery beat --scheduler=redbeat.RedBeatScheduler --app=myproject.celery:app ) के साथ, पर्यवेक्षक द्वारा सभी उदाहरणों पर सेलेरी बीट शुरू किया गया है। दुर्भाग्य से मैं काम से संबंधित कोड साझा नहीं कर सकता, लेकिन मुझे सामान्य रूप से कार्यान्वयन के बारे में किसी भी अतिरिक्त प्रश्न का उत्तर देने में खुशी हो रही है।

@mikeschaekermann आप एक्सेस को लॉक करने के लिए अपने सेलेरी बीट को/उपयोग/बिन/झुंड के साथ लपेटने का प्रयास कर सकते हैं ...

flock /nfs/lock.file celery beat ...

मान लें कि आप अपने एनएफएस लॉक कार्यान्वयन पर भरोसा करते हैं :)

यह सुनिश्चित करेगा कि केवल एक ही वास्तव में चलता है और अन्य लॉकर के मरने तक अवरुद्ध हो जाते हैं।

@mikeschaekermann आप एक्सेस को लॉक करने के लिए अपने सेलेरी बीट को/उपयोग/बिन/झुंड के साथ लपेटने का प्रयास कर सकते हैं ...

झुंड /nfs/lock.file अजवाइन हरा ...

मान लें कि आप अपने एनएफएस लॉक कार्यान्वयन पर भरोसा करते हैं :)

यह सुनिश्चित करेगा कि केवल एक ही वास्तव में चलता है और अन्य लॉकर के मरने तक अवरुद्ध हो जाते हैं।

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

मैं Postgres में एक सलाहकार लॉक का उपयोग कर समाप्त हुआ। मैंने एक Django प्रबंधन कमांड बनाया है जो django_pglocks मॉड्यूल का उपयोग करता है और एक सबप्रोसेस में सेलेरी बीट चलाता है।

मैं Postgres में एक सलाहकार लॉक का उपयोग कर समाप्त हुआ। मैंने एक Django प्रबंधन कमांड बनाया है जो django_pglocks मॉड्यूल का उपयोग करता है और एक सबप्रोसेस में सेलेरी बीट चलाता है।

ऐसा लगता है कि यह उन्हीं मुद्दों के लिए अतिसंवेदनशील हो सकता है जिन्हें मैंने NFS का उपयोग करते हुए देखा था। यदि लॉक रखने वाला क्लाइंट Postgres सर्वर से कनेक्शन खो देता है, या यदि Postgres सर्वर पुनरारंभ हो जाता है तो क्या होगा?

@ swt2c अर्घ, बेशक आप सही कह रहे हैं! किसी तरह जिंदा रहने की जरूरत है।

अभी मैं कर रहा हूँ:

def _pre_exec():
    prctl.set_pdeathsig(signal.SIGTERM)

with advisory_lock(LOCK_ID) as acquired:
            assert acquired
            logging.info("Lock acquired: %s", acquired)
            p = subprocess.Popen(
                celery,
                shell=False,
                close_fds=True,
                preexec_fn=_pre_exec,
            )
            sys.exit(p.wait())

advisor_lock रिकर्सन का समर्थन करता है, लेकिन मुझे नहीं पता कि यह वास्तव में डीबी की जांच कर रहा है या नहीं:

In [8]:  with advisory_lock('foo') as acquired:
   ...:     print acquired
   ...:     while True:
   ...:        with advisory_lock('foo') as acquired:
   ...:           print acquired
   ...:        time.sleep(1)
   ...:       

# Yes, it does:

True
True
True
<shutdown the instsance>
InterfaceError: cursor already closed

तो ... मैं लॉक/मतदान को उप-पुनः प्राप्त करने के लिए इसे संशोधित कर सकता हूं और विफल होने पर हरा सकता हूं। पारस्परिक बहिष्कार की गारंटी नहीं देता है, लेकिन यह मेरे उद्देश्यों के लिए काफी अच्छा हो सकता है।

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

मैं डीबी में शेड्यूल को बीट स्टोर भी कर रहा हूं, लेकिन यह परीक्षण नहीं किया है कि डीबी नीचे जाने पर क्या बीट करता है।

@ddevlin मुझे आपकी टिप्पणी देखकर खुशी हुई क्योंकि यही वह समाधान था जिसे मैं भी लागू करने की सोच रहा था।

हालांकि, अगर आप इस तर्क को साझा कर सकते हैं कि कैसे पर्यवेक्षक redbeat-1 redbeat-2 नीचे चला जाता है, तो यह एक बड़ी मदद होगी।

यह supervisor बारे में मेरी समझ की कमी के कारण हो सकता है, लेकिन ऐसा लगता है कि autorestart=True केवल उन कार्यक्रमों के लिए प्रभावी है जो कम से कम एक बार RUNNING स्थिति में आते हैं।

मेरी समस्या है:

  1. मेरे पास मेरे पर्यवेक्षक में दो programcelery beat साथ redbeat.RedBeatScheduler
  2. प्रारंभिक पर्यवेक्षक, एक beat ( beat-1 ) को ताला लग जाता है और चलता है, जबकि दूसरा ( beat-2 ) एक दो बार शुरू करने की कोशिश करता है और FATAL में प्रवेश करता है Seems we're already running? त्रुटि के साथ)।
  3. आदर्श रूप से, यदि beat-1 रुक जाता है, तो मैं चाहता हूं कि पर्यवेक्षक beat-2
  4. हालांकि, ऐसा नहीं होता है क्योंकि यह RUNNING स्थिति में कभी भी शुरू नहीं हुआ था। यानी अगर मैं beat-1 रोक दूं तो वह रुक जाता है और फिर कुछ नहीं होता।

मेरे सिर के ऊपर से, समाधान के लिए होगा एक cron है कि एक कर रखता है supervisorctl restart all हर 5 सेकंड या तो, लेकिन सिर्फ तुम कैसे प्राप्त करने में सक्षम थे पर अपने विचारों को प्राप्त करना चाहता था पर्यवेक्षक के साथ कि अतिरेक।

हाय @harisibrahimkv , आपकी समस्या यह है कि आप एक ही मेजबान पर अजवाइन की धड़कन के दो समान उदाहरण शुरू कर रहे हैं; मैं आप देख रहे हैं उम्मीद ERROR: Pidfile (celerybeat.pid) already exists. के लिए अपने लॉग में beat-2 ? मैं देख सकता हूं कि एक ही मेजबान पर चलने वाले सेलेरी बीट के दो उदाहरण उनके बीच फेलओवर के परीक्षण के लिए उपयोगी होंगे, लेकिन वास्तविक अतिरेक के लिए आप शायद कई मेजबानों पर सेलेरी बीट चलाना चाहते हैं।

एक ही होस्ट पर कई इंस्टेंस चलाने के लिए, पर्यवेक्षक उन्हें --pidfile तर्क के साथ शुरू करें और उन्हें अलग पिडफाइल दें: जैसे

# beat-1 
celery beat --scheduler=redbeat.RedBeatScheduler --pidfile="beat-1.pid" ...
# beat-2
celery beat --scheduler=redbeat.RedBeatScheduler --pidfile="beat-2.pid" ...

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

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

@ddevlin मेरे पास वापस आने और इंटरनेट को इतनी शानदार जगह बनाने के लिए बहुत-बहुत धन्यवाद! ईमानदारी से इसकी सराहना करते हैं! (मेरे पूरे परिवार को आपके उत्तर के बारे में बता रहा था: डी)

  1. pidfile बिट ने काम किया और दूसरे के रुकने पर beat-2 को कार्य करते हुए देखकर मैं बहुत खुश था। बीट के समय को CELERYBEAT_MAX_LOOP_INTERVAL = 25 (सेलेरी 3.x पर) के साथ कॉन्फ़िगर कर सकता है।

  2. हां, वास्तविक अतिरेक के लिए, हम इस सेटअप को अलग-अलग उदाहरणों पर पूरी तरह से रखने की योजना बना रहे हैं। आप जिस सेटअप का उपयोग कर रहे थे, उसे समझाने के लिए धन्यवाद। अब उस पर काम करने जा रहे हैं। "एक ही उदाहरण पर एक से अधिक होस्ट" सेटअप, जैसा कि आपने ठीक ही समझा था, शुरुआत में यह सत्यापित करना था कि विफलता की अवधारणा इस पर्यवेक्षक सेटअप के साथ काम करती है या नहीं।

हार्दिक धन्यवाद,
भारतीय उपमहाद्वीप के सबसे दक्षिणी सिरे पर एक छोटे से गाँव से। :)

क्या यह पृष्ठ उपयोगी था?
0 / 5 - 0 रेटिंग्स