स्पार्क स्ट्रक्चर्ड स्ट्रीमिंग + काफ्का पर एक त्वरित नज़र

स्ट्रीम-प्रोसेसिंग कार्यों के लिए इस शक्तिशाली जोड़ी का उपयोग कैसे करें की मूल बातें सीखना

हाल ही में मैंने अपाचे काफ्का और अपाचे स्पार्क, डेटा इंजीनियरिंग दुनिया की दो अग्रणी तकनीकों के बारे में बहुत अध्ययन करना शुरू किया है।

मैंने पिछले कुछ महीनों में उनका उपयोग करके कई परियोजनाएँ बनाई हैं; “काफ्का, डेबेज़ियम और बेंटोएमएल के साथ मशीन लर्निंग स्ट्रीमिंग” एक उदाहरण है. मेरा ध्यान यह सीखना है कि इन आधुनिक प्रसिद्ध उपकरणों के साथ शक्तिशाली डेटा पाइपलाइन कैसे बनाई जाए और उनके फायदे और नुकसान का अंदाजा लगाया जाए।

पिछले महीनों में, मैंने पहले ही कवर कर लिया है कि दोनों उपकरणों का उपयोग करके ईटीएल पाइपलाइन कैसे बनाई जाती है, लेकिन कभी भी उन्हें एक साथ उपयोग नहीं किया जाता है, और यही वह अंतर है जिसे मैं आज भरूंगा।

हमारा लक्ष्य स्पार्क+काफ्का के साथ स्ट्रीमिंग एप्लिकेशन बनाने के पीछे के सामान्य विचार को सीखना और वास्तविक डेटा का उपयोग करके इसकी मुख्य अवधारणाओं पर एक त्वरित नज़र डालना है।

विचार सरल है - अपाचे काफ्का एक संदेश स्ट्रीमिंग उपकरण है, जहां निर्माता कतार के एक छोर पर संदेश लिखते हैं (जिसे ए कहा जाता है) विषय) उपभोक्ताओं द्वारा दूसरे पर पढ़ा जाना।

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

अपाचे स्पार्क एक वितरित मेमोरी-आधारित डेटा ट्रांसफ़ॉर्मेशन इंजन है।

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

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

इन दो तकनीकों को जोड़ें और स्ट्रीमिंग ईटीएल पाइपलाइन बनाने के लिए हमारे पास एक आदर्श मेल है।

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

यह डेटासेट स्ट्रीमिंग सिस्टम के लिए सटीक रूप से शास्त्रीय अनुप्रयोगों में से एक का प्रतिनिधित्व करता है - सेंसर का एक समूह जो फ़ील्ड से लगातार अपनी रीडिंग भेजता है।

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

इस प्रकार के बुनियादी ढांचे के साथ, सभी प्रकार के (तथाकथित) निर्माण करना संभव है वास्तविक समय घटना-संचालित सिस्टम, औसत गति में गिरावट के साथ वाहनों की संख्या अचानक बढ़ने पर ट्रैफिक जाम का पता लगाने और सचेत करने के लिए एक कार्यक्रम की तरह।

और यहीं अपाचे स्पार्क काम में आता है।

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

पर्यावरण की स्थापना

आपको बस docker और docker-compose की आवश्यकता है।

हम निम्नलिखित रिपॉजिटरी के आधार पर डॉकर-कंपोज़ फ़ाइल कॉन्फ़िगरेशन का उपयोग करेंगे: लिंक स्पार्क, लिंक काफ्का.

RSI ./src वॉल्यूम वह जगह है जहां हम अपनी स्क्रिप्ट डालने जा रहे हैं।

पर्यावरण शुरू करने के लिए, बस चलाएँ

डॉक-अप लिखें

इसमें सभी कोड उपलब्ध हैं गिटहब भंडार.

स्पार्क का अध्ययन शुरू करते समय जो चीजें मुझे सबसे ज्यादा पसंद आईं उनमें से एक थी इसके लिए लिखित कोड और मेरी सामान्य पायथन+पांडा स्क्रिप्ट के बीच समानता। पलायन करना बहुत आसान था.

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

जैसा कि कहा गया है, निम्नलिखित अनुभागों में, हम स्पार्क संरचित स्ट्रीमिंग की विशिष्टताओं को सीखने पर ध्यान केंद्रित करेंगे, अर्थात, इसमें कौन सी नई सुविधाएँ हैं।

हमारा पहला काम

आइए धीमी शुरुआत करें और एक खिलौना उदाहरण बनाएं

करने वाली पहली चीज़ एक काफ्का विषय बनाना है जहां से हमारा स्पार्क जॉब संदेशों का उपभोग करेगा।

यह द्वारा किया जाता है काफ्का कंटेनर टर्मिनल तक पहुँचना और क्रियान्वित करना:

kafka-topics.sh --create --bootstrap-server localhost:9092 --topic test_topic

इस विषय पर संदेश लिखने वाले निर्माता का अनुकरण करने के लिए, आइए इसका उपयोग करें काफ्का-कंसोल-निर्माता। कंटेनर के अंदर भी:

kafka-console-producer.sh --बूटस्ट्रैप-सर्वर लोकलहोस्ट:9092 --topic test_topic --property "parse.key=true" --property "key.separator=:"

अब से, टर्मिनल में टाइप की गई प्रत्येक पंक्ति परीक्षण विषय पर एक संदेश के रूप में भेजी जाएगी। संदेश की कुंजी और मान (कुंजी:मान) को अलग करने के लिए ":" वर्ण का उपयोग किया जाता है।

आइए इस विषय का उपभोग करने के लिए एक स्पार्क जॉब बनाएं।

कोड को अंदर डालना होगा /src/स्ट्रीमिंग फ़ोल्डर (कुछ विशेष नहीं, केवल वह फ़ोल्डर जिसे मैंने चुना है)।

ध्यान देने वाली मुख्य बात यह है कि हम विशेषताओं का उपयोग कर रहे हैं रीडस्ट्रीम और राइटस्ट्रीम, सामान्य पढ़ने-लिखने के बजाय। यह मुख्य पहलू है जो स्पार्क हमारे काम को एक स्ट्रीमिंग एप्लिकेशन के रूप में मानता है।

काफ्का से जुड़ने के लिए सर्वर और विषय निर्दिष्ट करना आवश्यक है। विकल्प स्टार्टिंगऑफ़सेट्स=“जल्द से जल्द'' स्पार्क को विषय को शुरू से पढ़ने के लिए कहता है। इसके अलावा, क्योंकि काफ्का अपने संदेशों को संग्रहीत करता है बाइनरी प्रपत्र, उन्हें डिकोड करने की आवश्यकता है स्ट्रिंग.

अन्य विकल्पों पर और विचार किया जाएगा।

अब, स्पार्क कंटेनर तक पहुँचें और कार्य चलाएँ।

स्पार्क-सबमिट --पैकेज org.apache.spark:spark-sql-kafka-0-10_2.12:3.3.0 /src/streaming/read_test_stream.py

कॉन्फ़िगरेशन के कुछ सेकंड के बाद, यह विषय का उपभोग करना शुरू कर देगा।

स्पार्क स्ट्रीमिंग में काम करता है माइक्रो-बैचिंग मोड, और इसीलिए जब यह संदेशों का उपभोग करता है तो हम "बैच" जानकारी देखते हैं।

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

मैं सुपर फास्ट टाइपर नहीं हूं, इसलिए वर्तमान बैच में नए शामिल करने से पहले स्पार्क संदेश को संसाधित करता है।

और वह हमारा पहला स्ट्रीमिंग कार्य था!

मुझे आशा है कि आपको यह अहसास हो गया होगा: स्ट्रीम प्रोसेसिंग जॉब को कोड करना कठिन नहीं है, लेकिन कुछ गड़बड़ियां हैं।

काफ्का स्ट्रीम में डेटा लिखना

अब सेंसर डेटा के साथ खेलना शुरू करने का समय आ गया है।

आप डाउनलोड कर सकते हैं ज़िप अगस्त 2022 से फ़ाइल करें और इसे इसमें निकालें /डेटा आयतन। डेटा मूल रूप से JSON में है और लगभग 23Gb स्थान लेता है। डिस्क स्थान और पढ़ने के समय को अनुकूलित करने के लिए पहली चीज़ इसे लकड़ी की छत में परिवर्तित करना है।

ऐसा करने के लिए स्पार्क जॉब्स GitHub रिपॉजिटरी में विस्तृत हैं, आपको बस उन्हें निष्पादित करना है:

स्पार्क-सबमिट /src/transform_json_to_parquet.pyस्पार्क-सबमिट /src/join_parquet_files.py

आपकी मशीन के आधार पर, निष्पादन में कुछ समय लग सकता है। लेकिन इससे फ़ायदा होता है, अंतिम पैराक्वेट फ़ाइल का आकार ~1जीबी (20x से अधिक छोटा) है और पढ़ने में बहुत तेज़ है।

हमें अपने संदेश प्राप्त करने के लिए काफ्का विषय भी बनाना होगा:

kafka-topics.sh --create --प्रतिकृति-कारक 1 --बूटस्ट्रैप-सर्वर लोकलहोस्ट:9092 --विषय ट्रैफ़िक_सेंसर

वैकल्पिक रूप से, यदि आप आने वाले संदेशों को प्रदर्शित करना चाहते हैं, तो कंसोल उपभोक्ता स्थापित करना संभव है।

काफ्का-कंसोल-उपभोक्ता.sh --विषय ट्रैफिक_सेंसर --बूटस्ट्रैप-सर्वर लोकलहोस्ट:9092

काफ्का विषय पर डेटा लिखना आसान है, लेकिन इसमें कुछ विवरण हैं।

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

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

काफ्का में संदेश कुंजियाँ बहुत महत्वपूर्ण हैं, लेकिन वे हमारे परीक्षणों में उपयोगी नहीं होंगी, इसलिए सभी संदेशों में समान होंगी।

जैसा कि पहले उल्लेख किया गया है, यह डेटासेट बहुत बड़ा है, इसलिए मैंने डाले गए संदेशों की संख्या 500,000 तक सीमित कर दी है।

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

कार्य निष्पादित करना:

स्पार्क-सबमिट --पैकेज org.apache.spark:spark-sql-kafka-0-10_2.12:3.3.0 /src/streaming/insert_traffic_topic.py

बाईं ओर, स्पार्क जॉब फ़ाइल को पढ़ता है, दाईं ओर, a काफ्का-कंसोल-उपभोक्ता आने वाले संदेशों को प्रदर्शित करता है.

हमारा ट्रैफ़िक विषय भर चुका है और संसाधित होने के लिए लगभग तैयार है।

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

इस गतिशील व्यवहार का अनुकरण करने के लिए, नीचे दी गई स्क्रिप्ट हर 1 सेकंड में विषय पर 2.5 पंक्ति लिखती है।

आउटपुट मोड - प्रकार के अनुसार वाहनों की संख्या की गणना करना

आगे बढ़ते हुए, आइए प्रकार के आधार पर वाहनों की संख्या गिनने का कार्य बनाएँ।

कॉलम "Classificação" (वर्गीकरण) में पता लगाया गया वाहन प्रकार शामिल है।

जैसा कि हम विषय से पढ़ रहे हैं, हमें JSON बाइनरी स्ट्रिंग्स को वापस स्तंभ प्रारूप में बदलने की आवश्यकता है।

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

तो अब संबोधित करने का समय आ गया है आउटपुटमोड() विकल्प।

स्ट्रीम एप्लिकेशन का आउटपुट मोड निर्दिष्ट करता है कि नया डेटा आने पर हम परिणामों की गणना (पुनः) कैसे करना और लिखना चाहते हैं।

यह तीन अलग-अलग मान ग्रहण कर सकता है:

• जोड़ना: आउटपुट में केवल नए रिकॉर्ड जोड़ें।
• पूर्ण: प्रत्येक नए रिकॉर्ड के लिए पूर्ण परिणाम की पुनः गणना करें।
• अपडेट: परिवर्तित रिकार्ड अद्यतन करें।

लिखे गए आवेदन के आधार पर ये मोड समझ में आ सकते हैं या नहीं। उदाहरण के लिए, यदि कोई समूहीकरण या छँटाई की जाती है तो "पूर्ण" मोड का कोई मतलब नहीं हो सकता है।

आइए कार्य को "पूर्ण" मोड में निष्पादित करें और परिणामों को देखें।

स्पार्क-सबमिट --पैकेज org.apache.spark:spark-sql-kafka-0-10_2.12:3.3.0 /src/streaming/group_by_vehicle_type.py

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

हालाँकि, यह दृष्टिकोण इष्टतम नहीं हो सकता है यदि समूहों की संख्या बहुत बड़ी है या व्यक्तिगत परिवर्तन समग्र परिणाम को प्रभावित नहीं करते हैं।

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

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

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

टम्बलिंग टाइम विंडो - समय अंतराल का उपयोग करके एकत्रीकरण

स्ट्रीमिंग सिस्टम में, संदेशों में उनसे संबंधित दो अलग-अलग टाइमस्टैम्प होते हैं: ईवेंट समय - वह समय जब संदेश बनाया गया था, हमारे मामले में सेंसर का पढ़ने का समय, और प्रसंस्करण समय - जब संदेश प्रोसेसिंग एजेंट द्वारा पढ़ा जाता है, हमारे मामले में जब यह स्पार्क तक पहुंचता है.

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

उदाहरण के लिए, हर 5 मिनट में गिनें कि पिछले 5 मिनट में कितने वाहनों का पता चला।

नीचे दिया गया कोड इसे दर्शाता है:

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

इवेंट-टाइम प्रोसेसिंग एक जटिल विषय है। इससे निपटने के दौरान कुछ भी हो सकता है, जैसे संदेश खो जाना, बहुत देर से आना, या ख़राब हो जाना। मुद्दों को कम करने के लिए स्पार्क के पास कई तंत्र हैं, जैसे वॉटरमार्क, जिस पर हम ध्यान केंद्रित नहीं करेंगे।

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

स्लाइडिंग टाइम विंडो - समय अंतराल पर लचीलापन

स्लाइडिंग टाइम विंडो टम्बलिंग विंडो का लचीलापन है। गैर-अतिव्यापी अंतराल बनाने के बजाय, वे यह परिभाषित करने की अनुमति देते हैं कि प्रत्येक अंतराल कितनी बार बनाया जाएगा।

उदाहरण के लिए, हर 5 मिनट में गिनें कि पिछले 30 मिनट में कितने वाहनों का पता चला।

उसके कारण, घटनाएँ कई अंतरालों से संबंधित हो सकती हैं और आवश्यकतानुसार कई बार गिनी जा सकती हैं।

एक स्लाइडिंग विंडो को परिभाषित करने के लिए, बस अपडेट अंतराल को पास करें खिड़की() समारोह।

चलिए आउटपुट देखते हैं.

जैसा कि हम देख सकते हैं, हमारे पास प्रत्येक 30 मिनट में 5 मिनट की विंडो बनाई जा रही है।

यह लचीलापन अधिक विशिष्ट व्यावसायिक नियमों और अधिक जटिल ट्रिगर्स को परिभाषित करने के लिए काफी उपयोगी हो सकता है। उदाहरण के लिए, हमारा ट्रैफिक जाम डिटेक्टर पिछले 5 मिनट के बारे में हर 10 सेकंड में प्रतिक्रिया भेज सकता है और जब कार की औसत गति 20 किमी/घंटा से कम हो जाती है तो अलर्ट बना सकता है।

यह स्पार्क स्ट्रक्चर्ड स्ट्रीमिंग की मुख्य अवधारणाओं पर एक त्वरित नज़र थी और उन्हें काफ्का के साथ कैसे लागू किया जा सकता है।

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

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

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

फिर, यह एक त्वरित नज़र थी, और यदि आप गहराई से जानना चाहते हैं तो मैं नीचे कुछ संदर्भ छोड़ दूँगा।

आशा है मैंने किसी तरह मदद की होगी, पढ़ने के लिए धन्यवाद! 🙂

इसमें सभी कोड उपलब्ध हैं गिटहब भंडार.
उपयोग किया गया डेटा - कॉन्टैगेंस वॉल्यूमेट्रिकस डी राडारेस, मुक्त डेटा, ब्राज़ीलियाई गवर्नर।

[1] फ़ीचर डीप डाइव: अपाचे स्पार्क स्ट्रक्चर्ड स्ट्रीमिंग में वॉटरमार्किंग - डेटाब्रिक्स ब्लॉग पर मैक्स फिशर
[2] चेम्बर्स, बी., और ज़हरिया, एम. (2018)। स्पार्क: निश्चित मार्गदर्शिका: बड़े डेटा प्रोसेसिंग को सरल बनाया गया। "ओ'रेली मीडिया, इंक।"
[3] अपाचे काफ्का के साथ वास्तविक समय रसद, शिपिंग और परिवहन- काई वेहनेर
[4] नेटफ्लिक्स स्टूडियो और फाइनेंस वर्ल्ड में अपाचे काफ्का की प्रस्तुति - संगम ब्लॉग
[5] स्पार्क स्ट्रीमिंग और काफ्का - https://sparkbyexamples.com/

स्पार्क स्ट्रक्चर्ड स्ट्रीमिंग पर एक त्वरित नजर + काफ्का स्रोत से पुनर्प्रकाशित https://towardsdatascience.com/a-fast-look-at-spark-structured-streaming-kafka-f0ff64107325?source=rss—-7f60cf5620c9—4 https:/ के माध्यम से /towardsdatascience.com/feed

<!–

->