वास्तविक समय विश्लेषणात्मक प्रसंस्करण प्रणाली डिजाइन

Question

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

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

एक CSV फ़ाइल के लिए एक नमूना डेटा संरचना:

10: 30: 01, उपयोगकर्ता 1, ...
10: 30: 01, उपयोगकर्ता 1, ...
10:30:02 , उपयोगकर्ता 78, ...
10: 30: 02, उपयोगकर्ता 2, ...
10: 30: 03, उपयोगकर्ता 1, ...
10: 30: 04, उपयोगकर्ता 2, ...
। । ।

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

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

मैं कार्यान्वयन के लिए तूफान का उपयोग करना चाहता हूं, लेकिन मैं इस चर्चा को यथासंभव डिजाइन स्तर में छोड़ना पसंद करूंगा।

सिस्टम घटकों की एक सूची:

1. एक है जो आने वाली फाइलों हर मिनट पर नज़र रखता है काम।

2. एक कार्य जो फ़ाइल को पढ़ता है, इसे पार्स करता है और इसे अन्य सिस्टम घटकों और एल्गोरिदम के लिए उपलब्ध कराता है।

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

4. अन्य घटक भी हैं जो एक ही लेनदेन पर काम करते हैं, उनके लिए मैं अन्य कार्यों को बनाने की योजना बना रहा हूं जो प्रत्येक लेनदेन को प्राप्त करते हैं क्योंकि इसे पार्स किया जाता है (अन्य कार्यों के समानांतर में)।

मुझे # 3 के साथ आपकी मदद की ज़रूरत है।

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

आपकी मदद के लिए धन्यवाद

Answer 1

मैंने रेडिस के साथ काफी काम किया था। तो, मैं redis

का उपयोग कर # 3 की अपने विचार पर टिप्पणी करेंगे 10 कार्य

हर 5 मिनट के समाप्त हो जाना चाहिए के लिए 3 आवश्यकताओं

1. प्रति उपयोगकर्ता बफर

2. बफर है

1. बफर पी एर उपयोगकर्ता: रेडिस सिर्फ एक महत्वपूर्ण मूल्य स्टोर है। हालांकि यह datatypes की विस्तृत विविधता का समर्थन करता है, फिर भी वे हमेशा STRING कुंजी पर मैप किए गए मान होते हैं। इसलिए, आपको यह तय करना चाहिए कि उपयोगकर्ता को पहचानने के लिए विशिष्ट रूप से आपको प्रति उपयोगकर्ता बफर की आवश्यकता होती है। क्योंकि रेडिस में जब आप एक महत्वपूर्ण नए मान को ओवरराइड करते हैं तो आपको कभी भी कोई त्रुटि नहीं मिलेगी। एक समाधान लिखने से पहले अस्तित्व की जांच हो सकता है।

2. 10 कार्य के लिए बफर: आप स्पष्ट रूप से रेडिस में queue को कार्यान्वित कर सकते हैं। लेकिन इसके आकार को सीमित करना आपको छोड़ दिया गया है। पूर्व: लंबाई की जांच करने के लिए LPUSH और LTRIM या LLEN का उपयोग करके और यह तय करें कि आपकी प्रक्रिया को ट्रिगर करना है या नहीं। इस कतार से जुड़ी कुंजी आपके द्वारा भाग 1 में तय की जानी चाहिए।

3. बफर 5 मिनट: में समाप्त हो जाता है यह एक कठिन कार्य है। लाल रंग में अंतर्निहित डेटाटाइप के बावजूद प्रत्येक कुंजी में इसका मान expiry हो सकता है। लेकिन समाप्ति प्रक्रिया चुप है। आपको किसी भी कुंजी की समाप्ति पर अधिसूचित नहीं किया जाएगा। इसलिए, यदि आप इस संपत्ति का उपयोग करते हैं तो आप चुपचाप अपना बफर खो देंगे। इसके लिए एक काम है, एक सूचकांक है। मतलब, इंडेक्स उन चाबियों को टाइमस्टैम्प मैप करेगा, जिन्हें उस टाइमस्टैंप मूल्य पर समाप्त होने की आवश्यकता है। फिर पृष्ठभूमि में आप हर मिनट इंडेक्स पढ़ सकते हैं और रेडिस से बाहर [पढ़ने के बाद] कुंजी को मैन्युअल रूप से हटा सकते हैं और बफर डेटा के साथ अपनी वांछित प्रक्रिया को कॉल कर सकते हैं। ऐसी इंडेक्स रखने के लिए आप Sorted Sets देख सकते हैं। जहां टाइमस्टैम्प आपका score होगा और member सेट होगा [उस कुंजी में प्रति उपयोगकर्ता अद्वितीय कुंजी जो भाग 1 में तय की गई है जो एक कतार में नक्शा है] जिसे आप उस टाइमस्टैम्प पर हटाना चाहते हैं। एक कतार लागू करने के लिए

उपयोग Redis सूची: आपके द्वारा निर्दिष्ट टाइमस्टैम्प

कुल मिलाकर साथ पूरी तरह से तैयार सदस्यों को पढ़ने के लिए zrangebyscore कर सकते हैं।

यह सुनिश्चित करने के लिए LLEN का उपयोग करें कि आप अपनी 10 सीमा से अधिक नहीं हैं।

जब भी आप कोई नई सूची बनाते हैं तो सूचकांक [सॉर्टेड सेट] में Current Timestamp + 5 min के रूप में स्कोर के साथ प्रविष्टि करें और सूची की कुंजी के रूप में मूल्य दें।

जब एलएलईएन 10 तक पहुंचता है, तो पढ़ना याद रखें, फिर इंडेक्स [सॉर्टेड सेट] और डीबी से कुंजी हटाएं [कुंजी-> सूची हटाएं]। फिर डेटा के साथ अपनी प्रक्रिया को ट्रिगर करें।

प्रत्येक एक मिनट के लिए, वर्तमान टाइमस्टैम्प उत्पन्न करें, इंडेक्स पढ़ें और प्रत्येक कुंजी के लिए, डेटा पढ़ें, फिर डीबी से कुंजी हटाएं और अपनी प्रक्रिया को ट्रिगर करें।

यह इसे लागू करने का मेरा तरीका हो सकता है। [अपाचे Flume या काफ्का]

के लिए आपकी आवश्यकता # 3: [तूफान अंदर Esper बोल्ट वहाँ redis

Answer 2

में अपने डेटा मॉडल करने के लिए अपनी आवश्यकताओं को 1 & 2 के लिए कुछ अन्य बेहतर तरीका हो सकता है। इसे पूरा करने के लिए रेडिस में आपको एस्पेर लॉजिक को फिर से लिखना होगा।]