Como você produz e consome mensagens no Kafka (uso básico)?

Question

Accepted Answer

O uso básico do Kafka envolve **produzir** mensagens para um tópico e **consumi-las** — tipicamente via uma biblioteca cliente (Java, Python, etc.). Entender o fluxo básico de produção/consumo é o ponto de entrada prático para usar Kafka.

## Produzindo mensagens

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

## Consumindo mensagens

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

## Pontos práticos-chave

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

## Por que isso importa

Entender o uso básico de produção/consumo é valioso porque é o **ponto de entrada prático para usar Kafka**, sendo portanto conhecimento prático necessário para trabalhar com Kafka.

Saber como produzir e consumir mensagens é a habilidade fundamental para usar Kafka em aplicações.

Entender **produzir mensagens** — conectar um produtor e enviar registros (chave, valor) para um tópico, com a **chave determinando particionamento e ordenação** — é a operação básica de escrita.

Entender **consumir mensagens** — conectar um consumidor com um **ID de grupo**, se inscrever em um tópico e processar mensagens (com offsets confirmados automaticamente ou manualmente) — é a operação básica de leitura, sendo o grupo de consumidores como o consumo é escalado.

Entender os **pontos práticos-chave** — usar uma biblioteca cliente para sua linguagem (Java, KafkaJS, Python, etc.), definir chaves para ordenação e configurar acks para durabilidade em produtores, usar IDs de grupo e confirmar offsets em consumidores, lidar com **serialização** (JSON, Avro, Protobuf, frequentemente com um registro de schema para dados estruturados) e lidar com erros, retentativas e **processamento idempotente** (já que entrega at-least-once significa possíveis duplicatas) — reflete as considerações práticas para uso real do Kafka.

Esses pontos práticos (chaves, grupos, serialização, idempotência) conectam o conhecimento conceitual (partições, grupos de consumidores, semântica de entrega) ao código real.

Já que produzir e consumir mensagens é a habilidade prática fundamental para usar Kafka em aplicações, e já que entender o fluxo básico e os pontos práticos (chaves, grupos, serialização, idempotência) é conhecimento prático necessário, entender o uso básico de produção/consumo do Kafka é conhecimento valioso e praticamente relevante — o ponto de entrada prático para usar Kafka, conectando conceitos a código, e necessário para qualquer um realmente construindo aplicações com Kafka.

Produzindo mensagens

Consumindo mensagens

Pontos práticos-chave

Por que isso importa

question.related