Go (Golang) में Kafka के साथ काम: segmentio/kafka-go लाइब्रेरी

Go (Golang) में segmentio/kafka-go लाइब्रेरी के साथ Kafka का उपयोग

Apache Kafka एक डिस्ट्रीब्यूटेड डेटा स्ट्रीमिंग प्लेटफॉर्म है, जो हाई-लोड मैसेजिंग सिस्टम के लिए डी-फैक्टो स्टैंडर्ड बन गया है। Go (Golang) में डेवलपमेंट करते समय, Kafka के साथ इंटरैक्ट करने के लिए सबसे लोकप्रिय और विश्वसनीय लाइब्रेरी segmentio/kafka-go है। इस आर्टिकल में हम विस्तार से जानेंगे कि इस लाइब्रेरी को कैसे इंस्टॉल करें, कॉन्फ़िगर करें और प्रोड्यूसर तथा कंज्यूमर बनाने के लिए उपयोग करें।

segmentio/kafka-go क्यों चुनें?

बाजार में Kafka के लिए कई Go लाइब्रेरी मौजूद हैं (जैसे Sarama और Confluent Go Client)। segmentio/kafka-go निम्नलिखित फायदों के कारण अलग है:

• शुद्ध Go — इसमें C डिपेंडेंसी की जरूरत नहीं है (Confluent के विपरीत), जिससे बिल्ड और डिप्लॉय आसान हो जाता है।
• Kafka Protocol v2 सपोर्ट — एफिशिएंट कंप्रेशन, बैचिंग और ट्रांजेक्शन सपोर्ट।
• सरल API — प्रोड्यूसर, कंज्यूमर और टॉपिक एडमिनिस्ट्रेशन के लिए इंट्यूटिव इंटरफेस।
• सक्रिय कम्युनिटी — नियमित अपडेट और अच्छा डॉक्यूमेंटेशन।

लाइब्रेरी इंस्टॉल करना

शुरू करने के लिए, अपने प्रोजेक्ट में go get के जरिए लाइब्रेरी जोड़ें:

go get github.com/segmentio/kafka-go

सुनिश्चित करें कि आपका Kafka इंस्टेंस चल रहा है (लोकली या Docker के जरिए)। Docker Compose के लिए न्यूनतम कॉन्फ़िगरेशन:

version: '3'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:latest
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
  kafka:
    image: confluentinc/cp-kafka:latest
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092

प्रोड्यूसर (Producer) बनाना

प्रोड्यूसर Kafka टॉपिक में मैसेज भेजता है। एक बेसिक उदाहरण देखें:

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/segmentio/kafka-go"
)

func main() {
    // प्रोड्यूसर कॉन्फ़िगरेशन
    writer := &kafka.Writer{
        Addr:     kafka.TCP("localhost:9092"),
        Topic:    "test-topic",
        Balancer: &kafka.LeastBytes{}, // मैसेज साइज के आधार पर बैलेंसिंग
        BatchSize: 10,                 // 10 मैसेज का बैच भेजें
        BatchTimeout: 100 * time.Millisecond,
    }
    defer writer.Close()

    // मैसेज भेजना
    err := writer.WriteMessages(context.Background(),
        kafka.Message{
            Key:   []byte("key-1"),
            Value: []byte("Hello, Kafka from Go!"),
        },
    )
    if err != nil {
        log.Fatal("मैसेज भेजने में त्रुटि:", err)
    }

    fmt.Println("मैसेज सफलतापूर्वक भेजा गया")
}

kafka.Writer के मुख्य पैरामीटर:

• Addr — Kafka ब्रोकर का पता।
• Topic — टॉपिक का नाम।
• Balancer — पार्टीशन में मैसेज बांटने की रणनीति (LeastBytes, RoundRobin, Hash)।
• BatchSize और BatchTimeout — परफॉरमेंस ऑप्टिमाइजेशन के लिए।

कंज्यूमर (Consumer) बनाना

कंज्यूमर टॉपिक से मैसेज पढ़ता है। मैन्युअल offset मैनेजमेंट के साथ एक सरल उदाहरण:

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/segmentio/kafka-go"
)

func main() {
    // रीडर (कंज्यूमर) कॉन्फ़िगरेशन
    reader := kafka.NewReader(kafka.ReaderConfig{
        Brokers:   []string{"localhost:9092"},
        Topic:     "test-topic",
        GroupID:   "my-consumer-group",
        MinBytes:  10, // न्यूनतम बैच साइज
        MaxBytes:  10e6, // 10 MB
        StartOffset: kafka.FirstOffset, // सबसे पहले मैसेज से शुरू करें
    })
    defer reader.Close()

    fmt.Println("टॉपिक test-topic से मैसेज पढ़े जा रहे हैं")
    for {
        msg, err := reader.ReadMessage(context.Background())
        if err != nil {
            log.Fatal("मैसेज पढ़ने में त्रुटि:", err)
        }
        fmt.Printf("मैसेज प्राप्त: key=%s, value=%s\n", string(msg.Key), string(msg.Value))
    }
}

कंज्यूमर के मुख्य पैरामीटर:

• GroupID — कंज्यूमर ग्रुप का नाम, जो पार्टीशन को बांटने में मदद करता है।
• MinBytes और MaxBytes — बैच साइज को कंट्रोल करते हैं।
• StartOffset — पढ़ने की शुरुआत (FirstOffset या LastOffset)।

निष्कर्ष

segmentio/kafka-go लाइब्रेरी Go में Kafka के साथ काम करने का एक शक्तिशाली और सरल तरीका प्रदान करती है। इसके क्लीन API, Kafka Protocol v2 सपोर्ट और नो-डिपेंडेंसी डिज़ाइन के कारण यह प्रोडक्शन-ग्रेड एप्लिकेशन के लिए आदर्श है। अब आप अपने Go प्रोजेक्ट्स में Kafka को आसानी से इंटीग्रेट कर सकते हैं!