Comment produire et consommer des messages dans Kafka (utilisation basique) ?

Question

Accepted Answer

L'utilisation basique de Kafka implique de **produire** des messages vers un sujet et de les **consommer** — généralement via une bibliothèque cliente (Java, Python, etc.). Comprendre le flux basique produce/consume est le point d'entrée pratique pour utiliser Kafka.

## Produire des messages

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

## Consommer des messages

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

## Points pratiques clés

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

## Pourquoi c'est important

Comprendre l'utilisation basique produce/consume est précieux car c'est le **point d'entrée pratique pour utiliser Kafka**, ce qui en fait une connaissance pratique nécessaire pour travailler avec Kafka.

Savoir comment produire et consommer des messages est la compétence fondamentale pour utiliser Kafka dans les applications.

Comprendre **produire des messages** — connecter un producteur et envoyer des enregistrements (clé, valeur) vers un sujet, avec la **clé déterminant le partitionnement et l'ordre** — est l'opération d'écriture basique.

Comprendre **consommer des messages** — connecter un consommateur avec un **ID de groupe**, s'abonner à un sujet et traiter les messages (avec les décalages validés automatiquement ou manuellement) — est l'opération de lecture basique, le groupe de consommateurs étant la façon dont la consommation s'adapte.

Comprendre les **points pratiques clés** — utiliser une bibliothèque cliente pour votre langage (Java, KafkaJS, Python, etc.), définir des clés pour l'ordre et configurer les accusés de réception pour la durabilité sur les producteurs, utiliser les ID de groupe et valider les décalages sur les consommateurs, gérer la **sérialisation** (JSON, Avro, Protobuf, souvent avec un registre de schéma pour les données structurées), et gérer les erreurs, les tentatives et le **traitement idempotent** (puisque la livraison au-moins-une-fois signifie des doublons possibles) — reflète les considérations pratiques pour l'utilisation réelle de Kafka.

Ces points pratiques (clés, groupes, sérialisation, idempotence) connectent la connaissance conceptuelle (partitions, groupes de consommateurs, sémantique de livraison) au code réel.

Comme produire et consommer des messages est la compétence pratique fondamentale pour utiliser Kafka dans les applications, et comme comprendre le flux basique et les points pratiques (clés, groupes, sérialisation, idempotence) est une connaissance pratique nécessaire, comprendre l'utilisation basique de Kafka produce/consume est une connaissance précieuse et pratiquement pertinente — le point d'entrée pratique pour utiliser Kafka, connectant les concepts au code, et nécessaire pour quiconque construit réellement des applications avec Kafka.