kafka topic, partition विवरण (producer, consumer, replication- factor, offset)

हैलो, यह codeshow है।
इस बार में हम kafka में topic और partition के बारे में जानेंगे।
kafka का उपयोग करने के लिए, आपके पास topic होना चाहिए।
इस topic के आधार पर, producer संदेश publish,
consumer संदेशों की सदस्यता लेता है।
topic बनाने के लिए kafka चलाएं।
पर्यावरण सेटिंग्स के लिए कृपया पिछला वीडियो देखें।
kafka अभ्यास के लिए devcontainers चलाएं।
container चलने तक प्रतीक्षा करें।
जब container चलना समाप्त हो जाएगा, तो हम docker desktop खोलेंगे।
kafka container में shell निष्पादित करें।
topic देखने के लिए, kafka topics की list option का उपयोग करें।

kafka-topics --bootstrap-server kafka:9092 --list

मैंने पुष्टि की कि डिफ़ॉल्ट रूप से बनाए गए topic consumer offsets और schemas को छोड़कर कोई topic नहीं है।
kafka- topics कमांड के create option का उपयोग करके topic बनाएं।

kafka-topics --bootstrap-server kafka:9092 --create --topic hello --partitions 1 --replication-factor 1

मैंने kafka topics कमांड के साथ hello नाम से topic बनाया।
name option का उपयोग करके topic का नाम निर्दिष्ट किया गया है।
replication factor option partition डेटा की कितनी प्रतियां बनाने के लिए चयन करने का option है।
मैं प्रतिकृति factor मान को kafka नोड्स की संख्या के रूप में सेट करता हूं।
उच्च मान नोड्स के बीच विभाजन को कॉपी करने की लागत को वहन करते हैं, जो प्रदर्शन को प्रभावित करता है।
इसके बजाय, यदि मान छोटा है, तो kafka विफल होने पर डेटा खो सकता है।
आमतौर पर 3 या अधिक के मान की सिफारिश की जाती है।

संदर्भ के लिए, यदि आप create के समय kafka नोड्स की संख्या से अधिक replication factor डालते हैं तो एक त्रुटि उत्पन्न होती है।

kafka-topics --bootstrap-server kafka:9092 --create --topic error --partitions 1 --replication-factor 4

मैं दूसरे option के साथ partitions की व्याख्या करूँगा।
kafka में partition बहुत महत्वपूर्ण जानकारी है।
partitions option वह जानकारी है जो यह निर्धारित करती है कि कितने topic को विभाजित करना है।
यदि producer 100 topic को publish है और इस topic में केवल 1 partition है,
100 topic को 1 partition में रखा गया है।
यदि consumer 1 topic को संसाधित करने में 1 मिनट का समय लेता है।
100 topic को संसाधित करने में 100 मिनट लगेंगे।
यदि आप partition को 4 पर सेट करते हैं, तो topic 4 विभाजनों में से प्रत्येक में 25 से ढेर हो जाते हैं।
चूंकि एक partition में अधिकतम एक consumer हो सकता है,
अब आप 3 consumer को जोड़ सकते हैं जितने विभाजन की संख्या में वृद्धि हुई है।
प्रसंस्करण समय को 1/4 से 100 मिनट से 25 मिनट तक कम किया जा सकता है।

हम अब तक की सामग्री का अभ्यास shell के प्रयोग से करेंगे।
मैं hello topic पर producer और consumer का अभ्यास करूंगा।
kafka container में terminal चलाएँ।
producer को बाईं ओर और consumer को दाईं ओर रखें।
kafka console producer कमांड का उपयोग करके kafka से कनेक्ट करें।

kafka-console-producer --bootstrap-server kafka:9092 --topic hello 

producer kafka broker से जुड़ा है।

kafka console consumer कमांड का उपयोग करके kafka से कनेक्ट करें।
partition अनुक्रमिक रूप से सूचकांक 0 से बढ़ता है।
व्यवहार में, चूंकि partition का size 1 है, केवल partition 0 का उपयोग किया जा सकता है।
option के रूप में partition संख्या 0 दर्ज करें।

kafka-console-consumer --bootstrap-server kafka:9092 --topic hello --partition 0

producer के लिए hello message दर्ज करें।
आप consumer में hello की जांच कर सकते हैं।

तो, क्या कई consumer एक partition से जुड़ सकते हैं?
चलिए एक अतिरिक्त terminal चलाते हैं और consumer जोड़ते हैं।

kafka-console-consumer --bootstrap-server kafka:9092 --topic hello --partition 0

consumer बिना किसी समस्या के जुड़ता है।

तो क्या होता है जब आप producer के रूप में एक संदेश publish?
दो परिदृश्य हैं।

1. consumer के क्रम में एक बार संदेश क्रमिक रूप से वितरित किए जाते हैं।
   इसे round robin पद्धति कहते हैं।
2. सभी संदेश सभी consumer तक पहुंचाए जाते हैं।
   नाम है broadcasting।

ऑपरेशन की जांच करने के लिए producer के रूप में संदेश hello1 दर्ज करें।
दोनों consumer पर एक hello1 संदेश प्रकट होता है।
producer के रूप में फिर से hello2 संदेश दर्ज करें।
दोनों consumer पर एक hello2 संदेश प्रकट होता है।
kafka में, एक ही partition से जुड़े सभी consumer broadcasting के माध्यम से संदेश प्राप्त करते हैं।

संदर्भ के लिए, एक अन्य message broker , rabbit mq , कई worker को एक queue से जोड़ सकता है।
और round robin के साथ, worker क्रमिक रूप से संदेश प्राप्त करते हैं।
यह हिस्सा kafka से अलग तरीके से काम करता है, इसलिए जिन लोगों ने पहले rabbit mq का अनुभव किया है वे भ्रमित हो सकते हैं।
rabbit mq एक queue में worker के size को बढ़ाकर थ्रूपुट बढ़ाता है,
kafka एक topic के partition size को बढ़ाकर थ्रूपुट बढ़ाता है।

इस अभ्यास में, हम partition की संख्या में परिवर्तन करेंगे।
आइए partition की संख्या 1 से बढ़ाकर 2 करें।
ctrl c दबाकर producer से बाहर निकलें।
kafka topics कमांड के alter option का उपयोग करके partition size को 2 तक बढ़ाएँ।

kafka-topics --bootstrap-server kafka:9092 --alter --partitions 2 --topic hello

kafka topics के describe विकल्प के साथ विभाजन जानकारी की जाँच करें।

kafka-topics --bootstrap-server kafka:9092 --topic hello --describe

संदर्भ के लिए, आप AKHQ की topic स्क्रीन पर 2 का बढ़ा हुआ partition size भी देख सकते हैं।
producer को फिर से निष्पादित करें और consumer को नए जोड़े गए partition # 1 में जोड़ें।

kafka-console-producer --bootstrap-server kafka:9092 --topic hello 

मौजूदा partition 0 से जुड़े consumer को समाप्त करें, और consumer को नए partition 1 से जोड़ें।

kafka-console-consumer --bootstrap-server kafka:9092 --topic hello --partition 0
kafka-console-consumer --bootstrap-server kafka:9092 --topic hello --partition 1

producer के साथ संदेशों की एक यादृच्छिक संख्या बनाएँ।
दो consumer हैं, लेकिन topic विभाजित है और केवल एक consumer को वितरित किया गया है।

यह sticky partition cache तरीका है जब kafka काम करता है जब कोई key नहीं होती है।
यदि कोई key नहीं है, तो पहले भेजे गए partition संख्या को cache है और topic को केवल इस partition के लिए अग्रेषित किया जाता है।
यदि कोई key नहीं है, तो partition को बढ़ाना अर्थहीन है क्योंकि केवल एक partition का उपयोग किया जाता है।
दूसरे शब्दों में, key महत्वपूर्ण जानकारी है जो partition को निर्धारित करती है जिसमें kafka में topic संग्रहीत किए जाएंगे।
हम key जोड़ेंगे ताकि topic को अच्छी तरह से विभाजित किया जा सके और partition के बीच संग्रहीत किया जा सके।

producer के लिए property option जोड़ें और इसे फिर से चलाएँ।

kafka-console-producer --bootstrap-server kafka:9092 --topic hello --property "key.separator=-" --property "parse.key=true"

चलिए producer के रूप में एक यादृच्छिक मान डालते हैं।
अब आप देख सकते हैं कि topic partition में विभाजित है और सहेजा गया है।
विशेष रूप से, आप जांच सकते हैं कि वही key consumer के माध्यम से उसी partition में publish है।

key separator option का उपयोग करते हुए, डैश से पहले की key और उसके बाद का value publish है।
a key है और b value है।
संदर्भ के लिए, पूर्व में, केवल hello value बिना key के publish था।

यदि डैश से पहले के मान समान हैं, key समान है।
महत्वपूर्ण बात यह है कि एक ही key हमेशा एक ही partition में संग्रहीत होती है।
हालाँकि, यदि key भिन्न हैं, तो वे एक ही partition या भिन्न partition में संग्रहित की जाती हैं।
इस भाग को समझने के लिए, आइए देखें कि kafka में key को कैसे संभालना है।
kafka hash key और kafka नोड्स की संख्या के रूप में शेष की गणना करता है, और partition संख्या के रूप में परिणाम मान निर्धारित करता है।
चूंकि अब दो partition हैं, केवल 0 और 1 partition संख्या के रूप में प्रकट हो सकते हैं।
संदर्भ के लिए, hash एल्गोरिथम murmur2 hash का उपयोग करता है।

partition के बारे में समझने के लिए एक महत्वपूर्ण बिंदु यह है कि kafka केवल partition के आधार पर topic के क्रम की गारंटी देता है।
अर्थात, उन topic को publish समय जिनका क्रम महत्वपूर्ण है, उन्हें एक ही partition में रखें।
मैंने जाँच की कि key मान हमेशा एक ही partition में संग्रहीत होता है,
topic के लिए जहां क्रम महत्वपूर्ण है, उसी key का उपयोग करना सुनिश्चित करें!

अगला, मैं partition के offset की व्याख्या करूँगा।
kafka मौजूदा message queue से इस मायने में अलग है कि यह consume के बाद queue से संदेशों को नहीं हटाता है।

विभाजन सरणियों के समान हैं।
partition में topic को एक सरणी के तत्वों की तरह क्रम में संग्रहित किया जाता है।
जैसे आप अनुक्रमणिका द्वारा किसी सरणी मान तक पहुँचते हैं, आप offset के माध्यम से partition के किसी विशिष्ट अनुक्रमणिका से consume कर सकते हैं।
संदर्भ के लिए, प्रत्येक partition में अंतिम offset होता है।
इसलिए, यदि कोई नया consumer offset option के बिना जुड़ा हुआ है, तो वह अंतिम offset से consume है।
हालाँकि, यदि offset option दिया गया है, तो offset जानकारी पहले consume है।

एक अभ्यास के रूप में, हम terminal को दो कमांड जारी करेंगे।

1. consumer को offset 0 से निष्पादित करने की आज्ञा दें।
2. offset कमांड के बिना consumer को निष्पादित करने की आज्ञा।

kafka-console-consumer --bootstrap-server kafka:9092 --topic hello --partition 1 --offset 0
kafka-console-consumer --bootstrap-server kafka:9092 --topic hello --partition 1 

यदि आप offset इंडेक्स 0 option देते हैं, तो आप जाँच सकते हैं कि इसे फिर से शुरू से ही निष्पादित किया गया है।
यदि offset option मौजूद नहीं है, offset विकल्प नवीनतम के लिए डिफॉल्ट करता है।
केवल नए publish topic का consume।

अंत में, partition पर एक महत्वपूर्ण बाधा के रूप में,
आप partition size के लिए छोटा मान नहीं रख सकते हैं।
partition size के लिए केवल बड़े मान दर्ज किए जा सकते हैं।
मैं partition को 2 से 1 तक कम करने के लिए alter कमांड दूंगा।

kafka-topics --bootstrap-server kafka:9092 --alter --partitions 1 --topic hello

आप एक त्रुटि संदेश देख सकते हैं जो आपको partition option को 2 से अधिक मान पर सेट करने के लिए कह रहा है।

यह kafka के topic और partition की व्याख्या को समाप्त करता है।
अगली बार, हम देखेंगे कि consumer groups का उपयोग कैसे करें।
संदर्भ के लिए, consumer सीधे partition का consume के बजाय,
व्यवहार में consumer groups का अधिक प्रयोग होता है।
इन consumer groups, इस वर्ग को बेहतर ढंग से समझने के लिए
मेरे पास partition सीखने का समय था।

सब्सक्राइब और लाइक नोटिफिकेशन सेटिंग्स कंटेंट क्रिएटर्स के लिए बहुत मददगार हैं।

धन्यवाद