👩🏼‍🤝‍👨🏾 💲 🏤 अपाचे प्रज्वलित + अपाचे स्पार्क डेटा फ्रेम्स: एक साथ और अधिक मज़ा 🌊 😐 🛁

नमस्कार, हेब्र! मेरा नाम निकोलाई इज़िकोव है, मैं ओपन सोर्स सॉल्यूशंस डेवलपमेंट टीम में Sberbank Technologies के लिए काम करता हूं। जावा में 15 साल के व्यावसायिक विकास के पीछे। मैं अपाचे इग्नाइट कमिटेटर और अपाचे काफ्का योगदानकर्ता हूं।

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

अपाचे स्पार्क क्या कर सकता है

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

अपाचे स्पार्क में विभिन्न स्टोरेज सिस्टम से जुड़ने या डेटा प्राप्त करने के लिए एक समृद्ध एपीआई है। उत्पाद की सुविधाओं में से एक विभिन्न स्रोतों से प्राप्त डेटा के लिए एक सार्वभौमिक SQL जैसा क्वेरी इंजन है। यदि आपके पास जानकारी के कई स्रोत हैं, तो आप उन्हें संयोजित करना चाहते हैं और कुछ परिणाम प्राप्त करना चाहते हैं, अपाचे स्पार्क वह है जो आपको चाहिए।

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

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

अपाचे स्पार्क के साथ अपाचे स्पार्क को एकीकृत करने के लिए हमने क्या विशेषताएं लागू की हैं

Apache से डेटा पढ़ना SQL टेबल को इग्नोर करता है।
अपाचे के लिए डेटा लिखना SQL तालिकाओं को प्रज्वलित करें।
इग्नाइटेस्पार्कसिशन के अंदर इग्नाइटसाइट्स - "हाथ से" पंजीकृत किए बिना सभी मौजूदा इग्नाइट एसक्यूएल तालिकाओं का उपयोग करने की क्षमता।
एसक्यूएल ऑप्टिमाइज़ेशन - इग्नाइट के अंदर एसक्यूएल स्टेटमेंट्स को निष्पादित करने की क्षमता।

अपाचे स्पार्क अपाचे इग्नाइट एसक्यूएल टेबल से डेटा पढ़ सकते हैं और उन्हें ऐसी तालिका के रूप में लिख सकते हैं। Spark में बनने वाले किसी भी DataFrame को Apache Ignite SQL टेबल के रूप में सहेजा जा सकता है।

अपाचे इग्नाइट आपको "हाथ से" पंजीकृत किए बिना स्पार्क सत्र में सभी मौजूदा इग्नाइट एसक्यूएल तालिकाओं का उपयोग करने की अनुमति देता है - मानक स्पार्कसैशन एक्सटेंशन के अंदर इग्नाइटेक्टिक्स का उपयोग करते हुए - इग्नाइटेस्पार्कसेशन।

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

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

यहाँ क्या विशेषता है? किसी कारण के लिए मुझे पता नहीं है, स्पार्क में निर्देशिका एक आंतरिक एपीआई है, अर्थात्। एक बाहरी व्यक्ति नहीं आ सकता है और अपनी खुद की कैटलॉग कार्यान्वयन बना सकता है। और, चूंकि स्पार्क हडोप से बाहर आया था, यह केवल हाइव का समर्थन करता है। और आपको बाकी सब कुछ अपने हाथों से रजिस्टर करना होगा। उपयोगकर्ता अक्सर पूछते हैं कि आप इसे कैसे प्राप्त कर सकते हैं और तुरंत SQL प्रश्न बना सकते हैं। मैंने एक निर्देशिका लागू की जो आपको ~ और sms ~ पर रजिस्टर किए बिना इग्नाइट टेबल को ब्राउज़ करने और एक्सेस करने की अनुमति देती है, और शुरू में स्पार्क समुदाय में इस पैच का प्रस्ताव रखा, जिसके लिए मुझे एक जवाब मिला: इस तरह के पैच कुछ आंतरिक कारणों के लिए दिलचस्प नहीं है। और उन्होंने आंतरिक एपीआई नहीं दिया।

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

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

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

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

यह कैसे काम करता है

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

डेटा फ़्रेम प्रज्वलित करें

हम कोड की ओर मुड़ते हैं: SQL टेबल से डेटा कैसे पढ़ें? स्पार्क के मामले में, सब कुछ काफी सरल और अच्छा है: हम कहते हैं कि हम कुछ डेटा की गणना करना चाहते हैं, हम प्रारूप को इंगित करते हैं - यह एक निश्चित निरंतर है। इसके अलावा, हमारे पास कई विकल्प हैं - क्लाइंट नोड के लिए कॉन्फ़िगरेशन फ़ाइल का पथ, जो डेटा पढ़ते समय शुरू होता है। हम संकेत देते हैं कि हम किस तालिका को लोड करने के लिए स्पार्क को पढ़ना और बताना चाहते हैं। हमें डेटा मिलता है और हम वह कर सकते हैं जो हम चाहते हैं।

spark.read .format(FORMAT_IGNITE) .option(OPTION_CONFIG_FILE, TEST_CONFIG_FILE) .option(OPTION_TABLE, "person") .load()

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

 tbl.write. format(FORMAT_IGNITE). option(OPTION_CONFIG_FILE, CFG_PATH). option(OPTION_TABLE, tableName). option(OPTION_CREATE_TABLE_PRIMARY_KEY_FIELDS, pk). save

अब देखते हैं कि यह सब कैसे काम करता है।

LoadDataExample.scala

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

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

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

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

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

इग्नाइटेस्पार्कसैंस और इग्नाइटसाइट्स

आइए देखें कि यह कैसे काम करता है।

CatalogExample.scala

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

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

IgniteOptimization

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

 SQL Query: SELECT   city_id,   count(*) FROM   person p GROUP BY city_id HAVING count(*) > 1

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

 == Analyzed Logical Plan == city_id: bigint, count(1): bigint Project [city_id#19L, count(1)#52L] +- Filter (count(1)#54L > cast(1 as bigint))  +- Aggregate [city_id#19L], [city_id#19L, count(1) AS count(1)#52L, count(1) AS count(1)#54L] +- SubqueryAlias p    +- SubqueryAlias person       +- Relation[NAME#11,BIRTH_DATE#12,IS_RESIDENT#13,SALARY#14,PENSION#15,ACCOUNT#16,AGE#17,ID#18L,CITY_ID#19L]         IgniteSQLRelation[table=PERSON]

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

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

 == Optimized Logical Plan == Relation[CITY_ID#19L,COUNT(1)#52L]   IgniteSQLAccumulatorRelation(     columns=[CITY_ID, COUNT(1)], qry=SELECT CITY_ID, COUNT(1) FROM PERSON GROUP BY city_id HAVING count(1) > 1)

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

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

JOIN के साथ एक और उदाहरण:

 SQL Query - SELECT jt1.id as id1, jt1.val1, jt2.id as id2, jt2.val2 FROM jt1 JOIN jt2 ON jt1.val1 = jt2.val2

हमारे पास दो टेबल हैं। हम एक साथ मूल्य से चिपकते हैं और उन सभी से चयन करते हैं - आईडी, मान। स्पार्क ऐसी योजना पेश करता है:

 == Analyzed Logical Plan == id1: bigint, val1: string, id2: bigint, val2: string Project [id#4L AS id1#84L, val1#3, id#6L AS id2#85L, val2#5] +- Join Inner, (val1#3 = val2#5) :- SubqueryAlias jt1 : +- Relation[VAL1#3,ID#4L] IgniteSQLRelation[table=JT1] +- SubqueryAlias jt2    +- Relation[VAL2#5,ID#6L] IgniteSQLRelation[table=JT2]

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

 == Optimized Logical Plan == Relation[ID#84L,VAL1#3,ID#85L,VAL2#5] IgniteSQLAccumulatorRelation(columns=[ID, VAL1, ID, VAL2], qry= SELECT JT1.ID AS id1, JT1.VAL1, JT2.ID AS id2, JT2.VAL2 FROM JT1 JOIN JT2 ON JT1.val1 = JT2.val2 WHERE JT1.val1 IS NOT NULL AND JT2.val2 IS NOT NULL)

मैं आपको एक उदाहरण दिखाऊंगा।

OptimizationExample.scala

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

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

अपाचे प्रज्वलित विकास

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

इस एकीकरण पर क्या सुधार किया जा सकता है? अगर आपकी ऐसी इच्छा है तो मैं कैसे मदद कर सकता हूं? नीचे सूचीबद्ध करें। तारांकन जटिलता का संकेत देते हैं।

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

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

यदि आप अपाचे इग्नाइट समुदाय में शामिल होना चाहते हैं, तो यहां कुछ उपयोगी लिंक दिए गए हैं:

यहां शुरू करें - https://ignite.apache.org/community/resources.html
यहाँ स्रोत - https://github.com/apache/ignite/
यहां डॉक्स - https://apacheignite.readme.io/docs
यहाँ कीड़े - https://issues.apache.org/jira/browse/IGNITE
आप यहाँ लिख सकते हैं - dev@ignite.apache.org, user@ignite.apache.org

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

यदि आप जावा या C ++ जानते हैं, तो आप काम की तलाश कर रहे हैं और ओपन सोर्स (Apache Ignite, Apache Kafka, Tarantool, आदि) विकसित करना चाहते हैं: यहाँ लिखें: join-open-source@sberbank.ru।

अपाचे प्रज्वलित + अपाचे स्पार्क डेटा फ्रेम्स: एक साथ और अधिक मज़ा