जावा, अपाचे काफ्का में एक विषय में संदेशों की संख्या कैसे प्राप्त करें

Question 1

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

Question 2

एक उपभोक्ता दृष्टिकोण से इसके लिए दिमाग में आने वाला एकमात्र तरीका वास्तव में संदेशों का उपभोग करना और फिर उन्हें गिनना है।

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

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

Question 3

यह जावा नहीं है, लेकिन उपयोगी हो सकता है

./bin/kafka-run-class.sh kafka.tools.GetOffsetShell 
  --broker-list <broker>:  <port> 
  --topic <topic-name> --time -1 --offsets 1 
  | awk -F  ":" '{sum += $3} END {print sum}'

Question 4

मैं वास्तव में इसका उपयोग अपने POC बेंचमार्किंग के लिए करता हूं। वह आइटम जो आप ConsumerOffsetChecker का उपयोग करना चाहते हैं। आप इसे नीचे की तरह बैश स्क्रिप्ट का उपयोग करके चला सकते हैं।

bin/kafka-run-class.sh kafka.tools.ConsumerOffsetChecker  --topic test --zookeeper localhost:2181 --group testgroup

और नीचे परिणाम है: जैसा कि आप लाल बॉक्स पर देख सकते हैं, 999 वर्तमान में विषय में संदेश की संख्या है।

अपडेट: ConsumerOffsetChecker को 0.10.0 के बाद से हटा दिया गया है, आप ConsumerGroupCommand का उपयोग शुरू करना चाह सकते हैं।

Question 5

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

$ kafka-run-class kafka.tools.GetOffsetShell \
  --broker-list host01:9092,host02:9092,host02:9092 --topic kt

तीन भागों में संदेशों की गिनती दिखाने वाले नमूना आउटपुट को प्रिंट करता है:

kt:2:6138
kt:1:6123
kt:0:6137

विषय के लिए विभाजन की संख्या के आधार पर लाइनों की संख्या कम या ज्यादा हो सकती है।

Question 6

चूंकि ConsumerOffsetCheckerअब समर्थित नहीं है, आप इस कमांड का उपयोग विषय के सभी संदेशों को जांचने के लिए कर सकते हैं:

bin/kafka-run-class.sh kafka.admin.ConsumerGroupCommand \
    --group my-group \
    --bootstrap-server localhost:9092 \
    --describe

LAGविषय विभाजन में संदेशों की गिनती कहाँ है:

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

kafkacat -b localhost:9092 -t sample-kafka-topic -p 0 -o -10 -e

Question 7

Https://prestodb.io/docs/current/connector/kafka-tutorial.html का उपयोग करें

फेसबुक द्वारा प्रदान किया गया एक सुपर एसक्यूएल इंजन, जो कई डेटा स्रोतों (कैसंड्रा, काफ्का, जेएमएक्स, रेडिस ...) से जुड़ता है।

PrestoDB वैकल्पिक श्रमिकों के साथ एक सर्वर के रूप में चल रहा है (अतिरिक्त श्रमिकों के बिना एक स्टैंडअलोन मोड है), फिर आप प्रश्नों को बनाने के लिए एक छोटे निष्पादन योग्य JAR (जिसे Presto CLI कहा जाता है) का उपयोग करते हैं।

एक बार जब आप प्रेस्टो सर्वर को अच्छी तरह से कॉन्फ़िगर कर लेते हैं, तो आप ट्रेडिशनल एसक्यूएल का उपयोग कर सकते हैं:

SELECT count(*) FROM TOPIC_NAME;

Question 8

अपाचे काफ्का कमांड को किसी विषय के सभी विभाजनों पर संयुक्त रूप से नियंत्रित संदेश प्राप्त करने के लिए:

kafka-run-class kafka.tools.ConsumerOffsetChecker 
    --topic test --zookeeper localhost:2181 
    --group test_group

प्रिंटों:

Group      Topic        Pid Offset          logSize         Lag             Owner
test_group test         0   11051           11053           2               none
test_group test         1   10810           10812           2               none
test_group test         2   11027           11028           1               none

कॉलम 6 बिना संभाला हुआ संदेश है। उन्हें इस तरह जोड़ें:

kafka-run-class kafka.tools.ConsumerOffsetChecker 
    --topic test --zookeeper localhost:2181 
    --group test_group 2>/dev/null | awk 'NR>1 {sum += $6} 
    END {print sum}'

awk पंक्तियों को पढ़ता है, हेडर लाइन को छोड़ देता है और 6 वें कॉलम को जोड़ता है और अंत में योग प्रिंट करता है।

प्रिंटों

Question 9

विषय के लिए संग्रहीत सभी संदेशों को प्राप्त करने के लिए आप उपभोक्ता को प्रत्येक विभाजन के लिए स्ट्रीम के आरंभ और अंत में ले जा सकते हैं और परिणाम प्राप्त कर सकते हैं

List<TopicPartition> partitions = consumer.partitionsFor(topic).stream()
        .map(p -> new TopicPartition(topic, p.partition()))
        .collect(Collectors.toList());
    consumer.assign(partitions); 
    consumer.seekToEnd(Collections.emptySet());
Map<TopicPartition, Long> endPartitions = partitions.stream()
        .collect(Collectors.toMap(Function.identity(), consumer::position));
    consumer.seekToBeginning(Collections.emptySet());
System.out.println(partitions.stream().mapToLong(p -> endPartitions.get(p) - consumer.position(p)).sum());

Question 10

निम्नलिखित चलाएँ (मान लिया kafka-console-consumer.shगया है कि पथ पर है):

kafka-console-consumer.sh  --from-beginning \
--bootstrap-server yourbroker:9092 --property print.key=true  \
--property print.value=false --property print.partition \
--topic yourtopic --timeout-ms 5000 | tail -n 10|grep "Processed a total of"

Question 11

कफ़्का 2.11-1.0.0 के जावा क्लाइंट का उपयोग करके, आप निम्न कार्य कर सकते हैं:

    KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
    consumer.subscribe(Collections.singletonList("test"));
    while(true) {
        ConsumerRecords<String, String> records = consumer.poll(100);
        for (ConsumerRecord<String, String> record : records) {
            System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());

            // after each message, query the number of messages of the topic
            Set<TopicPartition> partitions = consumer.assignment();
            Map<TopicPartition, Long> offsets = consumer.endOffsets(partitions);
            for(TopicPartition partition : offsets.keySet()) {
                System.out.printf("partition %s is at %d\n", partition.topic(), offsets.get(partition));
            }
        }
    }

आउटपुट कुछ इस प्रकार है:

offset = 10, key = null, value = un
partition test is at 13
offset = 11, key = null, value = deux
partition test is at 13
offset = 12, key = null, value = trois
partition test is at 13

Question 12

काफ्का प्रबंधक के अधिकांश हाल के संस्करणों में, एक कॉलम है जिसका शीर्षक है सुम्मी हाल के ऑफ़सेट्स ।

Question 13

मेरा भी यही सवाल था और यह मैं इसे कफल्कंसुमेर के कोटलिन में कैसे कर रहा हूं:

val messageCount = consumer.listTopics().entries.filter { it.key == topicName }
    .map {
        it.value.map { topicInfo -> TopicPartition(topicInfo.topic(), topicInfo.partition()) }
    }.map { consumer.endOffsets(it).values.sum() - consumer.beginningOffsets(it).values.sum()}
    .first()

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

आप अन्य कॉन्फ़िगरेशन (क्लीनअप पॉलिसी, रिटेंशन-एमएस, आदि) की वजह से अंतिम ऑफसेट पर भरोसा नहीं कर सकते हैं जो आपके विषय से पुराने संदेशों को हटाने का कारण बन सकते हैं। ऑफसेट केवल "आगे" आगे बढ़ते हैं, इसलिए यह भिखारी ऑफसेट है जो अंत ऑफसेट के करीब आगे बढ़ेगा (या अंततः उसी मूल्य पर, यदि विषय में अभी कोई संदेश नहीं है)।

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

Question 14

काफ्का डॉक्स के कुछ अंश

0.9.0.0 में पदावनति

Kafka-consumer-offset-checker.sh (kafka.tools.ConsumerOffsetChecker) को हटा दिया गया है। आगे बढ़ते हुए, कृपया इस कार्यक्षमता के लिए kafka-consumer-groups.sh (kafka.admin.ConsumerGroupCommand) का उपयोग करें।

मैं सर्वर और क्लाइंट दोनों के लिए एसएसएल सक्षम के साथ काफ्का दलाल चला रहा हूं। नीचे आदेश मैं का उपयोग करें

kafka-consumer-groups.sh --bootstrap-server Broker_IP:Port --list --command-config /tmp/ssl_config kafka-consumer-groups.sh --bootstrap-server Broker_IP:Port --command-config /tmp/ssl_config --describe --group group_name_x

जहाँ / tmp / ssl_config नीचे है

security.protocol=SSL
ssl.truststore.location=truststore_file_path.jks
ssl.truststore.password=truststore_password
ssl.keystore.location=keystore_file_path.jks
ssl.keystore.password=keystore_password
ssl.key.password=key_password

Question 15

यदि आपके पास सर्वर के JMX इंटरफ़ेस तक पहुंच है, तो प्रारंभ और अंत ऑफ़सेट यहां मौजूद हैं:

kafka.log:type=Log,name=LogStartOffset,topic=TOPICNAME,partition=PARTITIONNUMBER
kafka.log:type=Log,name=LogEndOffset,topic=TOPICNAME,partition=PARTITIONNUMBER

(आप को बदलने के लिए की जरूरत है TOPICNAMEऔर PARTITIONNUMBER)। ध्यान रखें कि आपको दिए गए विभाजन के प्रत्येक प्रतिक के लिए जाँच करने की आवश्यकता है, या आपको यह पता लगाने की आवश्यकता है कि दलालों में से कौन सा किसी दिए गए विभाजन के लिए नेता है (और यह समय के साथ बदल सकता है)।

वैकल्पिक रूप से, आप काफ्का उपभोक्ता विधियों का उपयोग कर सकते हैं beginningOffsetsऔर endOffsets।

Question 16

मैंने खुद यह कोशिश नहीं की है, लेकिन यह समझ में आता है।

आप kafka.tools.ConsumerOffsetChecker( स्रोत ) का उपयोग भी कर सकते हैं ।

Question 17

मैंने जो सबसे आसान तरीका पाया है, वह है Kafdrop REST API का उपयोग करना /topic/topicNameऔर कुंजी को निर्दिष्ट करना: "Accept"/ मान: "application/json"हैडर एक JSON प्रतिक्रिया प्राप्त करने के लिए।

यह यहाँ प्रलेखित है ।

Question 18

आप काफकटूल का उपयोग कर सकते हैं । कृपया इस लिंक को देखें -> http://www.kafkatool.com/download.html

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