Apache Kafka: Mensageria Distribuída e Stream Processing em Produção

O que é Apache Kafka?

O Apache Kafka é uma plataforma distribuída de streaming de eventos, originalmente desenvolvida pelo LinkedIn e posteriormente open-source pela Apache Foundation. Diferente de sistemas de mensageria tradicionais como RabbitMQ, o Kafka foi projetado desde o início para lidar com volumes massivos de dados em tempo real, combinando armazenamento durável, alta taxa de transferência e baixa latência.

Hoje o Kafka é utilizado por mais de 80% das empresas Fortune 100 para alimentar pipelines de dados críticos, sistemas de monitoramento, agregação de logs, rastreamento de atividades e arquiteturas orientadas a eventos.

Conceitos Fundamentais

Antes de mergulhar no código, é essencial entender os pilares do Kafka:

Topic: Um canal nomeado onde os eventos são publicados. Funciona como uma categoria ou feed de mensagens.
Partition: Cada tópico é dividido em partições, que permitem paralelismo e escalabilidade horizontal. Mensagens dentro de uma partição são ordenadas.
Producer: Aplicação que publica eventos em um tópico.
Consumer: Aplicação que assina um ou mais tópicos e processa os eventos.
Consumer Group: Grupo de consumers que dividem o processamento das partições — cada partição é lida por apenas um consumer do grupo.
Broker: Servidor Kafka individual. Um cluster é formado por múltiplos brokers.
Offset: Identificador único e sequencial de cada mensagem dentro de uma partição.

Arquitetura Distribuída

O Kafka não é apenas um barramento de mensagens — é um sistema de armazenamento distribuído com replicação integrada. Cada tópico pode ser configurado com um fator de replicação (ex.: 3), garantindo que os dados sobrevivam à falha de até N-1 brokers.

# Topologia típica de cluster Kafka
# 3 Brokers × 3 Partições × Fator de Replicação 3

Broker 1 → Partição 0 (líder), Partição 1 (réplica), Partição 2 (réplica)
Broker 2 → Partição 1 (líder), Partição 0 (réplica), Partição 2 (réplica)
Broker 3 → Partição 2 (líder), Partição 0 (réplica), Partição 1 (réplica)

O ZooKeeper (ou o novo KRaft a partir do Kafka 2.8+) gerencia o consenso do cluster, eleição de líderes e metadados. Com o KRaft, o Kafka se torna auto-suficiente, eliminando a dependência externa do ZooKeeper.

Mãos ao Código: Producer em Python

Vamos criar um producer simples usando a biblioteca confluent-kafka, a mais performática para Python:

from confluent_kafka import Producer
import json

conf = {
    'bootstrap.servers': 'localhost:9092',
    'client.id': 'meu-producer'
}

producer = Producer(conf)

def delivery_report(err, msg):
    if err is not None:
        print(f'Erro ao entregar: {err}')
    else:
        print(f'Mensagem entregue: {msg.topic()} [{msg.partition()}] @ offset {msg.offset()}')

# Enviando 10 eventos
for i in range(10):
    evento = {'id': i, 'usuario': f'user_{i}', 'acao': 'login', 'timestamp': '2026-05-28T10:00:00Z'}
    producer.produce(
        topic='eventos-usuario',
        key=str(i),
        value=json.dumps(evento).encode('utf-8'),
        callback=delivery_report
    )

producer.flush()

Consumer em Python

Do lado do consumo, criamos um subscriber que processa os eventos em tempo real:

from confluent_kafka import Consumer, KafkaError

conf = {
    'bootstrap.servers': 'localhost:9092',
    'group.id': 'grupo-analytics',
    'auto.offset.reset': 'earliest'
}

consumer = Consumer(conf)
consumer.subscribe(['eventos-usuario'])

try:
    while True:
        msg = consumer.poll(timeout=1.0)
        if msg is None:
            continue
        if msg.error():
            if msg.error().code() == KafkaError._PARTITION_EOF:
                continue
            print(f'Erro: {msg.error()}')
            break
        print(f'Recebido: {msg.value().decode("utf-8")}')
finally:
    consumer.close()

Kafka Streams e ksqlDB

Além do modelo producer-consumer tradicional, o Kafka oferece duas camadas poderosas de processamento:

Kafka Streams: Biblioteca Java para transformações stateful (joins, agregações, janelas temporais) dentro da própria aplicação. Ideal para pipelines de processamento em tempo real.
ksqlDB: Motor de streaming SQL que permite criar pipelines com consultas SQL declarativas. Exemplo: SELECT usuario, COUNT(*) FROM eventos_usuario WINDOW TUMBLING (SIZE 1 MINUTE) GROUP BY usuario EMIT CHANGES;

Casos de Uso Reais

Rastreamento de Logs Centralizado: Agregar logs de dezenas de microsserviços em um único tópico para consumo por ferramentas como Elasticsearch e Grafana.
Event Sourcing e CQRS: O Kafka é o armazenamento de eventos ideal para padrões Event Sourcing — cada mudança de estado é um evento imutável no log.
Pipelines de Dados em Tempo Real: Conectar fontes (PostgreSQL via Debezium) a destinos (data lakes, warehouses) com replicação change-data-capture.
Monitoramento e Métricas: Coletar métricas de infraestrutura e aplicações em tempo real para dashboards operacionais.
Arquitetura Orientada a Eventos: Substituir chamadas síncronas REST por eventos assíncronos, desacoplando serviços e aumentando resiliência.

Boas Práticas em Produção

Particionamento Inteligente: Escolha uma chave de partição que distribua os dados uniformemente — evite chaves com cardinalidade baixa.
Monitoramento: Acompanhe métricas como lag do consumer, taxa de produção/consumo e espaço em disco com Prometheus + Grafana.
Tamanho de Mensagem: Configure max.message.bytes no broker e max.request.size no producer para mensagens grandes.
Idempotência: Habilite enable.idempotence=true no producer para garantir que mensagens não sejam duplicadas em cenários de retry.
Schemas com Schema Registry: Use o Confluent Schema Registry com Avro ou Protobuf para evolução segura de schemas entre producers e consumers.

Conclusão

O Apache Kafka é muito mais que um sistema de mensageria — é a espinha dorsal de arquiteturas modernas orientadas a eventos, processamento em tempo real e integração de dados em escala. Dominar seus conceitos e boas práticas é essencial para qualquer desenvolvedor que trabalhe com sistemas distribuídos.

Comece pequeno: suba um cluster com Docker Compose, escreva seu primeiro producer e consumer, e explore o ecossistema ksqlDB e Kafka Connect. Em pouco tempo você estará construindo pipelines de dados que processam milhões de eventos por segundo.

Entrar em contato

Entre em contato