तूफान काफ्का स्पॉट

Question

पर ट्यूपल प्रतिकृतियों की अधिकतम संख्या हम कफका स्पॉट के साथ तूफान का उपयोग कर रहे हैं। जब हम संदेशों को विफल करते हैं, तो हम उन्हें फिर से खेलना चाहते हैं, लेकिन कुछ मामलों में खराब डेटा या कोड त्रुटियों से संदेश हमेशा बोल्ट को विफल कर देते हैं, इसलिए हम एक अनंत रीप्ले चक्र में शामिल हो जाएंगे। जाहिर है जब हम उन्हें पाते हैं तो हम त्रुटियों को ठीक कर रहे हैं, लेकिन हमारी टोपोलॉजी आमतौर पर गलती सहनशील होना चाहेंगे। एन एन से अधिक बार फिर से चलाने के बाद हम कैसे एक एप() एक tuple कर सकते हैं?

काफ्का का तूफ़ान के लिए कोड के माध्यम से देख रहे हैं, मुझे लगता है कि यह एक घातीय backoff टाइमर और comments on the PR राज्य के साथ पुन: प्रयास करने के लिए डिज़ाइन किया गया था:

"टोंटी पुन: प्रयास चक्र समाप्त नहीं करता है (यह मेरा दृढ़ विश्वास है कि ऐसा नहीं करना चाहिए, क्योंकि यह reqeust को रोकने में विफलता के बारे में संदर्भ की रिपोर्ट नहीं कर सकता है), यह केवल retries में देरी को संभालने में संभालता है। टोपोलॉजी में एक बोल्ट अभी भी असफल होने के बजाय() को रोकने के लिए अंततः कॉल() को कॉल करने की उम्मीद है साईकिल।"

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

बोल्ट में ऐसा करने का सही तरीका क्या है? मुझे टुपल में कोई भी राज्य नहीं दिखता है जो खुलासा करता है कि इसे कितनी बार फिर से चलाया गया है।

Answer 1

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

यदि आप बोल्ट का उपयोग करना चाहते हैं, तो आप निम्न कार्य कर सकते हैं (जिसमें KafkaSpout या इसके उप-वर्ग में कुछ बदलावों की भी आवश्यकता है)।

• प्रत्येक टपल (शायद, वहाँ पहले से ही एक अद्वितीय ID उपलब्ध है के लिए एक अतिरिक्त विशेषता के रूप में निरुपित एक अद्वितीय आईडी, अन्यथा, आप एक "जवाबी आईडी" या बस पूरे टपल, यानी, सभी विशेषताओं को लागू कर सकता है, प्रत्येक ट्यूपल की पहचान करने के लिए)।
• आईडी पर KafkaSpout के बाद fieldsGrouping के माध्यम से एक बोल्ट डालें (यह सुनिश्चित करने के लिए कि एक टुपल जिसे दोहराया जाता है, उसी बोल्ट इंस्टेंस पर स्ट्रीम किया जाता है)।
• अपने बोल्ट के भीतर, HashMap<ID,Counter> का उपयोग करें जो सभी tuples को बफर करता है और (पुनः प्रयास) की संख्या की गणना करता है। यदि काउंटर आपके थ्रेसहोल्ड वैल्यू से छोटा है, तो इनपुट ट्यूपल को अग्रेषित करें ताकि इसे वास्तविक टोपोलॉजी द्वारा संसाधित किया जा सके (बेशक, आपको उचित रूप से ट्यूबल एंकर करना होगा)। यदि गिनती आपके थ्रेसहोल्ड से बड़ी है, तो चक्र को तोड़ने के लिए टुपल को एक करें और HashMap से अपनी प्रविष्टि को हटा दें (आप सभी असफल टुपल्स को भी लॉग करना चाहते हैं)।
• HashMap से सफलतापूर्वक संसाधित tuples को निकालने के लिए, हर बार एक टपल KafkaSpout में acked है आप बोल्ट को टपल आईडी अग्रेषित करने के लिए इतना है कि यह HashMap से टपल निकाल सकते हैं की जरूरत है। बस अपने KafkaSpout सबक्लास के लिए दूसरी आउटपुट स्ट्रीम घोषित करें और Spout.ack(...) ओवरराइट करें (बेशक आपको पर कॉल करने की आवश्यकता है ताकि KafkaSpout एएसी भी मिल सके)।

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

दोनों दृष्टिकोणों का नुकसान होता है, कि प्रत्येक नकली ट्यूपल के परिणामस्वरूप आपके नए परिचय बोल्ट (इस प्रकार, नेटवर्क यातायात में वृद्धि) के लिए एक अतिरिक्त संदेश होता है। दूसरे दृष्टिकोण के लिए, ऐसा लगता है कि आपको केवल बोल्ट के लिए "एएके" संदेश भेजने की आवश्यकता है जो पहले विफल हुआ था। हालांकि, आप नहीं जानते कि कौन से tuples विफल हो गया था और जो नहीं। यदि आप इस नेटवर्क ओवरहेड से छुटकारा पाने के लिए चाहते हैं, तो आप KafkaSpout में विफल कर सकते हैं जो विफल संदेशों की आईडी को बफर करता है। इस प्रकार, यदि आप एक विफल ट्यूपल सफलतापूर्वक पुनः चलाया गया था तो आप केवल "एएके" संदेश भेज सकते हैं। बेशक, यह तीसरा दृष्टिकोण तर्क को और भी जटिल बनाने के लिए बनाता है।

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

Answer 2

मूल रूप से यह इस तरह काम करता है:

1. आप टोपोलोजी वे उत्पादन ग्रेड होना चाहिए (यह है गुणवत्ता का एक निश्चित स्तर की उम्मीद है, और कम tuples की संख्या) को तैनात है।
2. यदि कोई टुपल विफल रहता है, तो जांचें कि ट्यूपल वास्तव में मान्य है या नहीं।
3. यदि कोई टुपल मान्य है (उदाहरण के लिए डालने में विफल रहा क्योंकि बाहरी डेटाबेस से कनेक्ट करना संभव नहीं है, या ऐसा कुछ है) तो इसका उत्तर दें।
4. यदि कोई टुपल मिस-गठित होता है और इसे कभी भी संभाला नहीं जा सकता है (उदाहरण के लिए एक डेटाबेस आईडी जो टेक्स्ट है और डेटाबेस एक पूर्णांक की अपेक्षा कर रहा है) यह ack होना चाहिए, आप कभी भी ऐसी चीज़ को ठीक करने या इसे सम्मिलित करने में सक्षम नहीं होंगे डेटाबेस।
5. नए प्रकार के अपवाद, लॉग इन होना चाहिए (साथ ही साथ ट्यूपल सामग्री भी)। आपको इन लॉगों को जांचना चाहिए और भविष्य में tuples को सत्यापित करने के लिए नियम उत्पन्न करना चाहिए। और अंत में भविष्य में उन्हें सही ढंग से संसाधित करने के लिए कोड जोड़ें (ईटीएल)।
6. सबकुछ लॉग न करें, अन्यथा आपकी लॉग फाइलें बड़ी होंगी, आप लॉग ऑन करने के लिए बहुत चुनिंदा रहें। लॉग फ़ाइलों की सामग्री उपयोगी होनी चाहिए और बकवास का ढेर नहीं होना चाहिए।
7. ऐसा करते रहें, और अंत में आप केवल सभी मामलों को कवर करेंगे।

Answer 3

हम भी इसी तरह के डेटा का सामना करते हैं जहां बोल्ट असीमित रूप से असफल होने के कारण हमारे पास खराब डेटा आ रहा है।

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

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

Answer 4

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

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

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