Hoe produceer en consumeer je berichten in Kafka (basisgebruik)?

Question

Accepted Answer

Basisgebruik van Kafka omvat het **produceren** van berichten naar een topic en het **consumeren** ervan — meestal via een clientbibliotheek (Java, Python, enz.). Het begrijpen van de basisproduceer-/consumeerstroom is het praktische ingangspoint voor het gebruik van Kafka.

## Produceren van berichten

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

## Consumeren van berichten

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

## Belangrijkste praktische punten

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

## Waarom het belangrijk is

Het begrijpen van basisgebruik voor produceren/consumeren is waardevol omdat het het **praktische ingangspoint voor het gebruik van Kafka** is, dus het is noodzakelijke praktische kennis voor het werken met Kafka.

Weten hoe je berichten produceert en consumeert, is de fundamentele vaardigheid voor het gebruik van Kafka in applicaties.

Het begrijpen van **berichten produceren** — het verbinden van een producer en het verzenden van records (key, value) naar een topic, waarbij de **key de partitionering en volgorde bepaalt** — is de basisschrijfbewerking.

Het begrijpen van **berichten consumeren** — het verbinden van een consumer met een **group ID**, het abonneren op een topic en het verwerken van berichten (met offsets die automatisch of handmatig worden vastgelegd) — is de basisleesbewerking, waarbij de consumergroep bepaalt hoe het verbruik wordt geschaald.

Het begrijpen van de **belangrijkste praktische punten** — het gebruik van een clientbibliotheek voor je taal (Java, KafkaJS, Python, enz.), het instellen van keys voor ordening en het configureren van acks voor duurzaamheid op producers, het gebruik van group IDs en het vastleggen van offsets op consumers, het verwerken van **serialisatie** (JSON, Avro, Protobuf, vaak met een schemaregister voor gestructureerde gegevens), en het verwerken van fouten, herhalingen en **idempotente verwerking** (aangezien at-least-once delivery mogelijke duplicaten betekent) — weerspiegelt de praktische overwegingen voor werkelijk Kafka-gebruik.

Deze praktische punten (keys, groups, serialisatie, idempotentie) verbinden de conceptuele kennis (partities, consumergroepen, leveringssemantieken) met daadwerkelijke code.

Aangezien het produceren en consumeren van berichten de fundamentele praktische vaardigheid is voor het gebruik van Kafka in applicaties, en aangezien het begrijpen van de basisstroom en de praktische punten (keys, groups, serialisatie, idempotentie) noodzakelijke praktische kennis is, is het begrijpen van basisgebruik van Kafka voor produceren/consumeren waardevol, praktisch relevant — het praktische ingangspoint voor het gebruik van Kafka, het verbinden van concepten met code, en noodzakelijk voor iedereen die daadwerkelijk applicaties met Kafka bouwt.