Hvordan producerer og consumer man beskeder i Kafka (grundlæggende brug)?

Question

Accepted Answer

Grundlæggende Kafka-brug involverer **producering** af beskeder til et emne og **consumption** af dem — typisk via et klientbibliotek (Java, Python osv.). Forståelsen af det grundlæggende produce/consume-flow er det praktiske indgangspunkt til at bruge Kafka.

## Producering af beskeder

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

## Consumption af beskeder

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

## Vigtige praktiske 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)
```

## Hvorfor det betyder noget

Forståelse af grundlæggende produce/consume-brug er værdifuld, fordi det er det **praktiske indgangspunkt til at bruge Kafka**, så det er nødvendig praktisk viden for at arbejde med Kafka.

At vide, hvordan man producerer og consumer beskeder, er den grundlæggende færdighed for at bruge Kafka i applikationer.

Forståelse af **producering af beskeder** — tilslutning af en producer og afsendelse af records (key, value) til et emne, hvor **key'et bestemmer partitionering og rækkefølge** — er den grundlæggende skriveoperation.

Forståelse af **consumption af beskeder** — tilslutning af en consumer med et **group ID**, abonnement på et emne og behandling af beskeder (med offsets der forpligtes automatisk eller manuelt) — er den grundlæggende læseoperation, hvor consumer group'en er hvordan consumption skaleres.

Forståelse af de **vigtige praktiske punkter** — brug af et klientbibliotek til dit sprog (Java, KafkaJS, Python osv.), indstilling af keys til rækkefølge og konfigurering af acks for holdbarhed på producere, brug af group ID'er og forpligtelse af offsets på consumere, håndtering af **serialisering** (JSON, Avro, Protobuf, ofte med et schema registry for strukturerede data), og håndtering af fejl, genopforsøg og **idempotent behandling** (da at-least-once delivery betyder mulige dubletter) — afspejler de praktiske hensyn til rigtig Kafka-brug.

Disse praktiske punkter (keys, groups, serialisering, idempotency) forbinder den begrebsmæssige viden (partitioner, consumer groups, delivery semantik) til faktisk kode.

Da producering og consumption af beskeder er den grundlæggende praktiske færdighed for at bruge Kafka i applikationer, og da forståelse af det grundlæggende flow og de praktiske punkter (keys, groups, serialisering, idempotency) er nødvendig praktisk viden, er forståelse af grundlæggende Kafka produce/consume-brug værdifuld, praktisk relevant viden — det praktiske indgangspunkt til at bruge Kafka, forbinde koncepter til kode, og nødvendig for alle, der faktisk bygger applikationer med Kafka.