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

माइक्रोसर्विसेज आर्किटेक्चर में अपाचे काफ्का का उपयोग क्यों करें?

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

इवेंट-संचालित अनुप्रयोगों में काफ्का के लाभ

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

काफ्का नोड.जेएस एकीकरण की स्थापना

एक माइक्रोसर्विसेज वातावरण में Apache Kafka और Node.js को एकीकृत करने के लिए, आपको Kafka को एक संदेश ब्रोकर के रूप में स्थापित करना होगा और इसे अपनी Node.js सेवाओं से जोड़ना होगा। यहां चरण-दर-चरण मार्गदर्शिका दी गई है:

काफ्का और Node.js स्थापित करें

सबसे पहले, सुनिश्चित करें कि Apache Kafka और Node.js आपके सिस्टम पर स्थापित हैं। आप निम्नलिखित लेखों का पालन करके काफ्का और नोड.जेएस स्थापित कर सकते हैं:

• Node.js का परिचय
• अपाचे काफ्का के साथ शुरुआत करना
• अपाचे काफ्का को Node.js के साथ कैसे एकीकृत करें

काफ्का नोड.जेएस क्लाइंट लाइब्रेरी स्थापित करें

Node.js को Kafka से जोड़ने के लिए, आप Kafkajs लाइब्रेरी का उपयोग कर सकते हैं, जो Node.js के लिए एक लोकप्रिय Kafka क्लाइंट है।

npm install kafkajs

Node.js में एक काफ्का प्रोड्यूसर बनाएं

माइक्रोसर्विसेज आर्किटेक्चर में, एक काफ्का निर्माता काफ्का विषय पर संदेश भेजने के लिए जिम्मेदार होता है। नीचे Node.js में काफ्का निर्माता बनाने का एक सरल उदाहरण दिया गया है:

const { Kafka } = require('kafkajs');

const kafka = new Kafka({
  clientId: 'my-producer',
  brokers: ['localhost:9092']
});

const producer = kafka.producer();

const sendMessage = async () => {
  await producer.connect();
  await producer.send({
    topic: 'my-topic',
    messages: [
      { value: 'Hello Kafka' },
    ],
  });
  await producer.disconnect();
};

sendMessage().catch(console.error);

Node.js में एक काफ्का उपभोक्ता बनाएं

काफ्का उपभोक्ता का उपयोग काफ्का विषय से संदेशों को पढ़ने के लिए किया जाता है। यहां बताया गया है कि आप उपभोक्ता कैसे बना सकते हैं:

const { Kafka } = require('kafkajs');

const kafka = new Kafka({
  clientId: 'my-consumer',
  brokers: ['localhost:9092']
});

const consumer = kafka.consumer({ groupId: 'my-group' });

const runConsumer = async () => {
  await consumer.connect();
  await consumer.subscribe({ topic: 'my-topic', fromBeginning: true });

  await consumer.run({
    eachMessage: async ({ topic, partition, message }) => {
      console.log({
        partition,
        offset: message.offset,
        value: message.value.toString(),
      });
    },
  });
};

runConsumer().catch(console.error);

केस स्टडी

माइक्रोसर्विस आर्किटेक्चर में काफ्का और नोड.जेएस के एकीकरण को स्पष्ट करने के लिए, निम्नलिखित केस स्टडी पर विचार करें:

परिदृश्य

हमारे पास दो माइक्रोसर्विसेज हैं:

1. आदेश सेवा: ग्राहक के आदेश संभालती है।
2. उत्पाद सेवा: उत्पाद स्टॉक प्रबंधित करता है।

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

कार्यान्वयन

1. ऑर्डर सेवा: उत्पाद-अद्यतन विषय पर ऑर्डर ईवेंट प्रकाशित करता है।
2. इन्वेंटरी सेवा: उत्पाद-अपडेट विषय से संदेशों का उपभोग करता है और तदनुसार इन्वेंट्री को अपडेट करता है।

ऑर्डर सेवा निर्माता स्क्रिप्ट

ऑर्डर सेवा खरीद ऑर्डर को संभालने और स्टॉक को अपडेट करने के लिए उत्पाद सेवा को संदेश भेजने के लिए जिम्मेदार है। यहां बताया गया है कि आप काफ्का निर्माता के रूप में ऑर्डर सेवा को कैसे कार्यान्वित कर सकते हैं:

// orderService.js
const express = require('express');
const { Kafka } = require('kafkajs');

// Kafka producer configuration
const kafka = new Kafka({
  clientId: 'order-service',
  brokers: ['localhost:9092'],
});

const producer = kafka.producer();

// Initialize Express app
const app = express();
app.use(express.json());

const placeOrder = async (orderId, productId, quantity) => {
  await producer.connect();
  const orderEvent = {
    orderId,
    productId,
    quantity,
    eventType: 'ORDER_PLACED',
    timestamp: Date.now(),
  };
  await producer.send({
    topic: 'product-updates',
    messages: [{ value: JSON.stringify(orderEvent) }],
  });
  await producer.disconnect();
  console.log(`Order placed: ${orderId} for product: ${productId}`);
};

// API endpoint to place an order
app.post('/order', async (req, res) => {
  const { orderId, productId, quantity } = req.body;

  if (!orderId || !productId || !quantity) {
    return res.status(400).json({ error: 'Missing orderId, productId, or quantity' });
  }

  try {
    await placeOrder(orderId, productId, quantity);
    res.status(200).json({ message: `Order ${orderId} placed successfully.` });
  } catch (error) {
    console.error('Error placing order:', error);
    res.status(500).json({ error: 'Failed to place order' });
  }
});

// Start the server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Order Service API running on port ${PORT}`);
});

उत्पाद सेवा उपभोक्ता स्क्रिप्ट

उत्पाद सेवा उत्पाद-अपडेट काफ्का विषय से संदेशों का उपभोग करती है और तदनुसार उत्पाद स्टॉक को अपडेट करती है। यहाँ कार्यान्वयन है:

// productService.js
const express = require('express');
const { Kafka } = require('kafkajs');

// Kafka consumer configuration
const kafka = new Kafka({
  clientId: 'product-service',
  brokers: ['localhost:9092'],
});

const consumer = kafka.consumer({ groupId: 'product-group' });

// Initialize Express app
const app = express();
app.use(express.json());

const updateStock = async () => {
  await consumer.connect();
  await consumer.subscribe({ topic: 'product-updates', fromBeginning: true });

  await consumer.run({
    eachMessage: async ({ topic, partition, message }) => {
      const orderEvent = JSON.parse(message.value.toString());
      console.log(`Received order: ${orderEvent.orderId}, Product: ${orderEvent.productId}, Quantity: ${orderEvent.quantity}`);

      // Simulate stock update
      console.log(`Updating stock for product: ${orderEvent.productId}`);
      // logic to update stock
    },
  });
};

// Start the Product Service to listen for messages
updateStock().catch(console.error);

// Start the server
const PORT = process.env.PORT || 3001;
app.listen(PORT, () => {
  console.log(`Product Service API running on port ${PORT}`);
});

पहले उत्पाद सेवा शुरू करें, क्योंकि इसे आने वाले संदेशों को सुनने की जरूरत है:

node productService.js

उत्पाद सेवा पोर्ट 3001 (या निर्दिष्ट होने पर अन्य पोर्ट) पर सुनना शुरू कर देगी।

इस आदेश के साथ ऑर्डर सेवा प्रारंभ करें:

node orderService.js

ऑर्डर सेवा पोर्ट 3000 (या निर्दिष्ट होने पर अन्य पोर्ट) पर उपलब्ध होगी।

आप ऑर्डर सेवा एपीआई पर एक POST अनुरोध भेजकर ऑर्डर दे सकते हैं:

curl -X POST http://localhost:3000/order \
-H "Content-Type: application/json" \
-d '{
  "orderId": "order-789",
  "productId": "product-123",
  "quantity": 5
}'

जब कोई ऑर्डर दिया जाता है, तो ऑर्डर सेवा एक काफ्का संदेश भेजेगी, और उत्पाद सेवा स्टॉक को अपडेट करने के लिए उस संदेश का उपभोग करेगी:

Received order: order-789, Product: product-123, Quantity: 5
Updating stock for product: product-123

निष्कर्ष

अपने माइक्रोसर्विसेज आर्किटेक्चर में Apache Kafka और Node.js को एकीकृत करने से आप अत्यधिक स्केलेबल और लचीले इवेंट-संचालित एप्लिकेशन बना सकते हैं।

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