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

Question

IT Interview Practice · 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.

Produksjon av meldinger

Konsumering av meldinger

Viktige praktiske poeng

Hvorfor det er viktig

Relaterte spørsmål