Introdução ao Apache Kafka para streaming de dados

1. Fundamentos do Apache Kafka

O Apache Kafka é uma plataforma de streaming de dados distribuída que revolucionou a forma como sistemas lidam com fluxos de informações em tempo real. Diferente de sistemas de mensageria tradicionais, o Kafka foi projetado para processar grandes volumes de dados com alta taxa de transferência e baixa latência.

O conceito central do Kafka é o streaming de dados — a capacidade de publicar, assinar, armazenar e processar fluxos contínuos de registros. Isso difere de sistemas de mensageria convencionais, onde mensagens são removidas após o consumo.

Criado originalmente no LinkedIn em 2011 para rastrear logs e métricas de sua infraestrutura em crescimento, o Kafka foi doado à Apache Software Foundation e rapidamente se tornou um dos projetos open-source mais influentes do ecossistema de Big Data.

Casos de uso típicos incluem:
- Coleta centralizada de logs de sistemas distribuídos
- Métricas de monitoramento e dashboards em tempo real
- Pipelines de dados entre bancos de dados, data lakes e sistemas analíticos
- Processamento de eventos em arquiteturas orientadas a eventos
- Sincronização de dados entre microsserviços

2. Arquitetura Core do Kafka

A arquitetura do Kafka é construída sobre conceitos simples, porém poderosos:

Tópicos, partições e offsets: Um tópico é uma categoria ou feed de mensagens. Cada tópico é dividido em partições, que são logs ordenados e imutáveis. Cada mensagem em uma partição recebe um offset — um identificador incremental único que permite aos consumidores rastrear sua posição de leitura.

Produtores e consumidores: Produtores publicam mensagens em tópicos, podendo especificar a partição de destino (por chave ou round-robin). Consumidores assinam tópicos e processam mensagens, mantendo o controle do offset atual. Consumidores podem se organizar em grupos de consumo, onde cada partição é processada por apenas um consumidor do grupo.

Brokers e clusters: Um broker é um servidor Kafka individual. Múltiplos brokers formam um cluster, proporcionando escalabilidade horizontal e tolerância a falhas. As partições são distribuídas entre os brokers, e cada partição pode ser replicada em múltiplos brokers para garantir durabilidade.

3. Mecanismos de Persistência e Entrega

O Kafka armazena mensagens em logs commitados no disco dos brokers, utilizando o sistema de arquivos do sistema operacional. Essa abordagem permite alta taxa de transferência através de acesso sequencial a disco.

Garantias de entrega:
- At-most-once: Mensagens podem ser perdidas, mas nunca reenviadas (máximo desempenho)
- At-least-once: Mensagens nunca são perdidas, mas podem ser duplicadas (padrão na maioria dos casos)
- Exactly-once: Mensagens são entregues exatamente uma vez, combinando idempotência e transações

Políticas de retenção: Mensagens podem ser mantidas por tempo configurado (retention.ms) ou por tamanho total (retention.bytes). A compactação de log permite manter apenas a versão mais recente de cada chave, útil para cenários de tabelas de mudanças.

4. Configuração Básica de um Cluster

Para configurar um cluster Kafka local, você pode utilizar o modo KRaft (sem ZooKeeper) ou o modo tradicional com ZooKeeper. Abaixo, um exemplo mínimo usando KRaft:

# Gerar um UUID para o cluster
KAFKA_CLUSTER_ID=$(./bin/kafka-storage.sh random-uuid)

# Formatar o diretório de logs
./bin/kafka-storage.sh format -t $KAFKA_CLUSTER_ID -c config/kraft/server.properties

# Iniciar o broker
./bin/kafka-server-start.sh config/kraft/server.properties

Parâmetros essenciais no server.properties:

# Número padrão de partições para novos tópicos
num.partitions=3

# Fator de replicação padrão
default.replication.factor=3

# Tempo de retenção de mensagens (7 dias)
log.retention.hours=168

# Tamanho máximo de uma mensagem (1 MB)
message.max.bytes=1048576

5. Produção e Consumo de Mensagens

Vamos criar um produtor e consumidor simples em Python usando a biblioteca kafka-python:

Produtor:

from kafka import KafkaProducer
import json

producer = KafkaProducer(
    bootstrap_servers=['localhost:9092'],
    value_serializer=lambda v: json.dumps(v).encode('utf-8'),
    acks='all'  # Garantia de entrega at-least-once
)

# Enviar mensagens com chave para garantir ordenação por partição
for i in range(10):
    future = producer.send(
        'topic-exemplo',
        key=f'user-{i % 3}'.encode('utf-8'),
        value={'id': i, 'nome': f'Evento {i}', 'timestamp': i * 1000}
    )
    record_metadata = future.get(timeout=10)
    print(f"Enviado para partição {record_metadata.partition}")

producer.flush()

Consumidor em grupo:

from kafka import KafkaConsumer
import json

consumer = KafkaConsumer(
    'topic-exemplo',
    bootstrap_servers=['localhost:9092'],
    group_id='grupo-processamento-1',
    auto_offset_reset='earliest',
    enable_auto_commit=True,
    value_deserializer=lambda m: json.loads(m.decode('utf-8'))
)

print("Aguardando mensagens...")
for message in consumer:
    print(f"Partição: {message.partition} | "
          f"Offset: {message.offset} | "
          f"Chave: {message.key.decode('utf-8') if message.key else 'N/A'} | "
          f"Valor: {message.value}")

6. Padrões de Integração e Ecossistema

Kafka Connect permite conectar sistemas externos sem escrever código personalizado. Conectores para bancos de dados (Debezium), S3, Elasticsearch e muitos outros estão disponíveis.

Kafka Streams é uma biblioteca Java para processamento stateful de streams, suportando junções, agregações e janelas temporais. Diferente do Apache Flink ou Spark Streaming, o Kafka Streams executa como uma aplicação embarcada, sem cluster externo.

Comparação com RabbitMQ: Enquanto RabbitMQ é excelente para roteamento flexível de mensagens com exchanges e bindings, o Kafka é superior em persistência, replay de mensagens, throughput e retenção de longo prazo. Kafka é a escolha natural para pipelines de dados, enquanto RabbitMQ atende melhor a cenários de tarefas assíncronas com roteamento complexo.

7. Monitoramento e Boas Práticas

Métricas-chave a monitorar:
- Consumer lag: Diferença entre o último offset produzido e o último offset consumido
- Throughput: Taxa de mensagens por segundo por broker
- Taxa de erros: Erros de rede, timeouts e líderes indisponíveis

Estratégias de particionamento:
- Use chaves de partição que distribuem dados uniformemente
- Para dados ordenados, use chaves que garantem mesma partição
- Monitore o tamanho das partições para evitar partições "quentes"

Segurança:
- Autenticação SSL/TLS para criptografia em trânsito
- SASL/SCRAM ou SASL/Kerberos para autenticação
- ACLs para controle de acesso granulado a tópicos e grupos

8. Limitações e Alternativas no Cenário Atual

Desafios do Kafka:
- Latência em cenários de baixa taxa de mensagens (overhead de operações em lote)
- Complexidade operacional para clusters grandes e multi-região
- Necessidade de tuning cuidadoso para cenários de baixa latência

Alternativas:
- Apache Pulsar: Oferece arquitetura de armazenamento e computação separadas, melhor isolamento de tenants e suporte nativo a mensagens com filas
- Redpanda: Compatível com API Kafka, mas sem JVM, oferecendo menor latência e menor consumo de recursos

No contexto de Data Engineering, o Kafka se consolidou como a espinha dorsal de pipelines de dados modernos, sendo peça fundamental em arquiteturas Lambda, Kappa e Data Mesh. Sua capacidade de atuar como barramento de eventos centralizado e imutável o torna indispensável para organizações que buscam processamento de dados em tempo real e confiável.

Referências