Hur producerar och konsumerar du meddelanden i Kafka (grundläggande användning)?

Question

Accepted Answer

Grundläggande Kafka-användning innebär att **producera** meddelanden till ett ämne (topic) och **konsumera** dem — vanligtvis via ett klientbibliotek (Java, Python, etc.). Att förstå det grundläggande produce/consume-flödet är den praktiska startpunkten för att använda Kafka.

## Producera meddelanden

```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
```

## Konsumera meddelanden

```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)
  },
});
```

## Viktiga praktiska punkter

```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)
```

## Varför det är viktigt

Att förstå grundläggande produce/consume-användning är värdefullt eftersom det är den **praktiska startpunkten för att använda Kafka**, så det är nödvändig praktisk kunskap för att arbeta med Kafka.

Att kunna producera och konsumera meddelanden är den grundläggande färdigheten för att använda Kafka i applikationer.

Att förstå **producering av meddelanden** — att ansluta en producent och skicka poster (nyckel, värde) till ett ämne, där **nyckeln bestämmer partitionering och ordning** — är den grundläggande skrivoperationen.

Att förstå **konsumering av meddelanden** — att ansluta en konsument med ett **grupp-ID**, prenumerera på ett ämne och bearbeta meddelanden (med offsets som bekräftas automatiskt eller manuellt) — är den grundläggande läsoperationen, där konsumentgruppen är hur konsumtionen skalas.

Att förstå de **viktiga praktiska punkterna** — att använda ett klientbibliotek för ditt språk (Java, KafkaJS, Python, etc.), ställa in nycklar för ordning och konfigurera acks för hållbarhet på producenter, använda grupp-ID och bekräfta offsets på konsumenter, hantera **serialisering** (JSON, Avro, Protobuf, ofta med ett schemaregister för strukturerad data) och hantera fel, återförsök och **idempotent bearbetning** (eftersom at-least-once delivery innebär möjliga dubbletter) — reflekterar de praktiska övervägandena för verklig Kafka-användning.

Dessa praktiska punkter (nycklar, grupper, serialisering, idempotens) förbinder den konceptuella kunskapen (partitioner, konsumentgrupper, leveranssemantik) med faktisk kod.

Since producering och konsumering av meddelanden är den grundläggande praktiska färdigheten för att använda Kafka i applikationer, och eftersom att förstå det grundläggande flödet och de praktiska punkterna (nycklar, grupper, serialisering, idempotens) är nödvändig praktisk kunskap, är förståelse för grundläggande Kafka produce/consume-användning värdefullt, praktiskt relevant kunskap — den praktiska startpunkten för att använda Kafka, koppla koncept till kod, och nödvändig för alla som faktiskt bygger applikationer med Kafka.