Hvordan produserer og konsumerer du meldinger i Kafka (grunnleggende bruk)?

Question

Accepted Answer

Grunnleggende Kafka-bruk innebærer **produksjon** av meldinger til et emne og **konsumering** av dem — typisk via et klientbibliotek (Java, Python, etc.). Å forstå den grunnleggende produsere/konsumere-flyten er det praktiske inngangspunktet til å bruke Kafka.

## Produksjon av meldinger

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

## Konsumering av meldinger

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

## Viktige praktiske poeng

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

Å forstå grunnleggende produsere/konsumere-bruk er verdifullt fordi det er det **praktiske inngangspunktet til å bruke Kafka**, så det er nødvendig praktisk kunnskap for å jobbe med Kafka.

Å vite hvordan man produserer og konsumerer meldinger er den grunnleggende ferdigheten for å bruke Kafka i applikasjoner.

Å forstå **produksjon av meldinger** — å knytte til en produsent og sende poster (nøkkel, verdi) til et emne, med **nøkkelen som bestemmer partisjonering og rekkefølge** — er den grunnleggende skrivoperasjonen.

Å forstå **konsumering av meldinger** — å knytte til en konsument med en **gruppe-ID**, abonnere på et emne, og behandle meldinger (med offsets bekreftet automatisk eller manuelt) — er den grunnleggende leseoperasjonen, hvor konsumentgruppen er hvordan konsumeringen skaleres.

Å forstå de **viktige praktiske punktene** — å bruke et klientbibliotek for ditt språk (Java, KafkaJS, Python, etc.), sette nøkler for rekkefølge og konfigurere acks for holdbarhet på produsenter, bruke gruppe-IDer og bekrefte offsets på konsumenter, håndtere **serialisering** (JSON, Avro, Protobuf, ofte med et skjemaregister for strukturert data), og håndtere feil, nye forsøk, og **idempotent behandling** (siden minst-en-gang-levering betyr mulige duplikater) — reflekterer de praktiske hensynene for reell Kafka-bruk.

Disse praktiske punktene (nøkler, grupper, serialisering, idempotens) forbinder den konseptuelle kunnskapen (partisjoner, konsumentgrupper, leveringssemantikk) til faktisk kode.

Ettersom produksjon og konsumering av meldinger er den grunnleggende praktiske ferdigheten for å bruke Kafka i applikasjoner, og siden forståelsen av den grunnleggende flyten og de praktiske punktene (nøkler, grupper, serialisering, idempotens) er nødvendig praktisk kunnskap, er forståelse av grunnleggende Kafka produsere/konsumere-bruk verdifullt, praktisk-relevant kunnskap — det praktiske inngangspunktet til å bruke Kafka, forbinde konsepter til kode, og nødvendig for alle som faktisk bygger applikasjoner med Kafka.