Kafka-இல் செய்திகளை எவ்வாறு உற்பத்தி செய்து நுகரமுடியும் (அடிப்படை பயன்பாடு)?

Question

Accepted Answer

Kafka-ன் அடிப்படை பயன்பாடு ஒரு topic-க்கு செய்திகளை **உற்பத்தி** செய்வது மற்றும் அவற்றை **நுகருவது** — பொதுவாக ஒரு client library (Java, Python, முதலியவை) மூலம். அடிப்படை produce/consume flow-ஐ புரிந்துகொள்வது Kafka-ஐ பயன்படுத்துவதற்கான நடைமுறை நுழைவு புள்ளி.

## செய்திகளை உற்பத்தி செய்வது

```js
// using a Kafka client (e.g. KafkaJS for Node)
const producer = kafka.producer();
await producer.connect();
await producer.send({
  topic: 'orders',
  messages: [
    { key: 'user-123', value: JSON.stringify({ orderId: 1, amount: 100 }) },
    // key determines the partition (same key → same partition → ordering)
  ],
});
// → publishes the message to the 'orders' topic
```

## செய்திகளை நுகருவது

```js
const consumer = kafka.consumer({ groupId: 'order-processors' });   // a consumer GROUP
await consumer.connect();
await consumer.subscribe({ topic: 'orders', fromBeginning: false });
await consumer.run({
  eachMessage: async ({ topic, partition, message }) => {
    const data = JSON.parse(message.value.toString());
    // process the message...
    // offset is auto-committed (or commit manually for control)
  },
});
```

## முக்கியமான நடைமுறை புள்ளிகள்

```text
✓ Use a client LIBRARY for your language (Java, KafkaJS, confluent-kafka-python, etc.)
✓ Producers: set a KEY for ordering/partitioning; configure acks for durability
✓ Consumers: use a GROUP ID; the group distributes partitions; commit offsets
✓ Handle SERIALIZATION (JSON, Avro, Protobuf) — often a schema registry for structured data
✓ Handle errors, retries; process idempotently (at-least-once → possible duplicates)
```

## ஏன் இது முக்கியமாக இருக்கிறது

অடிப்படை produce/consume பயன்பாடு புரிந்துகொள்வது மதிப்புமிக்கது, ஏனெனில் இது **Kafka-ஐ பயன்படுத்துவதற்கான நடைமுறை நுழைவு புள்ளி**, எனவே Kafka-உடன் பணிபுரிய அவசியமான hands-on அறிவு.

செய்திகளை உற்பத்தி செய்து நுகரக் கூடிய வழியை அறிந்துகொள்வது Kafka-ஐ பயன்படுத்துவதற்கான அடிப்படை திறமை.

**செய்திகளை உற்பத்தி செய்வதை** புரிந்துகொள்வது — ஒரு producer-ஐ இணைத்து records (key, value)-ஐ topic-க்கு அனுப்புவது, **key வகிப்பிலாக்கத்தை மற்றும் வரிசையை நிர்ணயிக்கிறது** — அது அடிப்படை write செயல்பாடு.

**செய்திகளை நுகருவதை** புரிந்துகொள்வது — ஒரு consumer-ஐ **group ID** உடன் இணைத்து, topic-க்கு சந்தா செய்து, செய்திகளை (offsets தானாக அல்லது கைமுறையாக commit செய்யப்பட்டு) செயலாக்குவது — அது அடிப்படை read செயல்பாடு, consumer group என்பது எவ்வாறு நுகரப்பு அளவுத்திறன் பெறப்படுகிறது.

**முக்கியமான நடைமுறை புள்ளிகளை** புரிந்துகொள்வது — உங்கள் ভাষைக்கான client library பயன்படுத்துவது (Java, KafkaJS, Python, முதலியவை), ordering-க்கு keys பயன்படுத்துவது மற்றும் producers-இல் durability-க்கு acks கட்டமைப்பது, consumers-இல் group IDs பயன்படுத்துவது மற்றும் offsets commit செய்வது, **serialization**-ஐ கையாள்வது (JSON, Avro, Protobuf, பெரும்பாலும் structured data-க்கு schema registry உடன்), மற்றும் errors, retries, மற்றும் **idempotent processing**-ஐ கையாள்வது (at-least-once delivery என்பது சாத்தியமான duplicates என்று பொருள்படுத்துகிறது) — இது real Kafka பயன்பாட்டிற்கான நடைமுறை கருத்தாய்வுகளை பிரதிபலிக்கிறது.

இந்த நடைமுறை புள்ளிகள் (keys, groups, serialization, idempotency) கருத்தியல் அறிவை (partitions, consumer groups, delivery semantics) உண்மையான code-க்கு இணைக்கிறது.

செய்திகளை உற்பத்தி செய்து நுகருவது Kafka-ஐ பயன்பாட்டில் பயன்படுத்துவதற்கான அடிப்படை நடைமுறை திறமை என்பதால், மற்றும் அடிப்படை flow மற்றும் நடைமுறை புள்ளிகள் (keys, groups, serialization, idempotency)-ஐ புரிந்துகொள்வது அவசியமான hands-on அறிவு என்பதால், Kafka produce/consume பயன்பாட்டை புரிந்துகொள்வது மதிப்புமிக்கது, நடைமுறை-சம்பந்தமான அறிவு — Kafka-ஐ பயன்படுத்துவதற்கான நடைமுறை நுழைவு புள்ளி, கருத்தாய்வுகளை code-க்கு இணைக்கிறது, மற்றும் Kafka உடன் உண்மையாக பயன்பாட்டை உருவாக்குபவர்களுக்கு அவசியமாகிறது.