Redpanda: Kafka sem ZooKeeper e com performance superior

1. Introdução ao Redpanda e sua proposta de valor

O Apache Kafka revolucionou o processamento de streams de dados, mas sua arquitetura tradicional carrega uma complexidade operacional significativa. Gerenciar um cluster Kafka exige administrar um conjunto separado de nós ZooKeeper para coordenação, eleição de líderes e armazenamento de metadados. Essa dupla camada aumenta a latência, o consumo de recursos e a superfície de falhas.

O Redpanda surge como uma alternativa direta ao Kafka, mantendo compatibilidade total com a API Kafka, mas eliminando o ZooKeeper por completo. Escrito em C++ (enquanto o Kafka é em Java/Scala), o Redpanda oferece uma arquitetura simplificada, performance superior e latência drasticamente reduzida. Sua proposta de valor é clara: fazer streaming de eventos com a simplicidade de um banco de dados moderno e a velocidade de um sistema de mensageria de próxima geração.

2. Arquitetura simplificada: sem ZooKeeper, com Raft

A principal inovação do Redpanda está na substituição do ZooKeeper pelo algoritmo de consenso Raft, implementado diretamente em cada nó do cluster. Enquanto o Kafka precisa de um ensemble externo de servidores ZooKeeper para gerenciar metadados, controlar eleições de líder e manter o estado do cluster, o Redpanda incorpora toda essa lógica no próprio motor de streaming.

Cada nó Redpanda executa um serviço Raft interno que gerencia a replicação de partições e a coordenação distribuída. Os metadados — como configurações de tópicos, permissões e informações de partições — são armazenados em partições Raft internas, replicadas entre os nós. Isso elimina a necessidade de um cluster separado, reduzindo a latência de operações de metadados de centenas de milissegundos para microssegundos.

A estrutura de nós é auto-suficiente: cada nó sabe exatamente qual é o estado do cluster, quem é o líder de cada partição e como rotear requisições. Em caso de falha de um nó, a eleição de um novo líder é feita via Raft em milissegundos, sem depender de um serviço externo.

# Exemplo: Arquitetura comparativa simplificada
# Kafka tradicional: 3 brokers + 3 ZooKeeper nodes = 6 processos
# Redpanda: 3 brokers (cada um com Raft embutido) = 3 processos

3. Performance e otimizações de hardware

O Redpanda foi projetado desde o início para explorar ao máximo o hardware moderno. Seu motor em C++ utiliza polling em modo batch com suporte a io_uring, uma interface de I/O assíncrona do kernel Linux que reduz drasticamente as chamadas de sistema e o overhead de contexto.

Enquanto o Kafka depende de garbage collection da JVM, que pode causar pausas imprevisíveis (STW — Stop The World), o Redpanda gerencia memória manualmente em C++, eliminando completamente essas pausas. Isso resulta em latências consistentes de milissegundos, mesmo sob carga pesada.

O Redpanda também faz uso intensivo de operações de hardware moderno:
- SSD NVMe: utiliza filas de submissão e conclusão paralelas para maximizar throughput de disco.
- CPU moderno: explora instruções SIMD para aceleração de serialização/desserialização e compressão.
- Redução de cópias de memória (zero-copy): dados são movidos diretamente do disco para a rede, sem cópias intermediárias.

# Comparação de latência típica (p99) em cenário de produção
# Kafka tradicional com ZooKeeper: 10-50ms
# Redpanda: 1-5ms (com hardware equivalente)

4. Compatibilidade com o ecossistema Kafka

Um dos maiores trunfos do Redpanda é sua compatibilidade total com a API Kafka. Produtores e consumidores escritos para Kafka funcionam com Redpanda sem qualquer alteração de código. Bibliotecas como kafka-python, confluent-kafka (librdkafka), kafka-go e franz-go são suportadas nativamente.

O Redpanda também implementa as APIs de Kafka Connect e Kafka Streams, permitindo que pipelines de integração e processamento de streams existentes sejam migrados sem retrabalho. Ferramentas de administração como kafka-topics, kafka-console-producer e kafka-console-consumer funcionam diretamente contra um cluster Redpanda.

Para migração de clusters Kafka existentes, o Redpanda oferece ferramentas como o rpk (Redpanda Keeper) com comandos para espelhar dados de um cluster Kafka para um cluster Redpanda, permitindo migrações incrementais e com zero downtime.

# Produtor Python funcionando com Redpanda (API Kafka)
from kafka import KafkaProducer
producer = KafkaProducer(bootstrap_servers='localhost:9092')
producer.send('meu-topico', b'Mensagem de teste')
producer.flush()

5. Casos de uso e cenários ideais

O Redpanda brilha em cenários onde latência ultrabaixa e simplicidade operacional são críticas:

  • Streaming financeiro: sistemas de trading e pagamentos que exigem latência abaixo de 5ms e consistência forte.
  • IoT e edge computing: ambientes com recursos limitados onde rodar um cluster Kafka + ZooKeeper seria inviável. Um único nó Redpanda pode substituir um cluster completo.
  • Monitoramento de infraestrutura: pipelines de métricas e logs que precisam processar milhões de eventos por segundo com latência previsível.
  • Substituição de Kafka em nuvem: redução de custos operacionais ao eliminar a necessidade de gerenciar ZooKeeper e ao usar menos recursos de CPU/memória.

6. Comparação prática: Redpanda vs. Kafka tradicional

Em testes de throughput, o Redpanda frequentemente supera o Kafka em 2x a 5x no mesmo hardware, especialmente em cenários com mensagens pequenas (alta taxa de operações por segundo). A latência p99 é consistentemente mais baixa, sem os picos causados pelo GC do Kafka.

Na facilidade de operação, a diferença é dramática: um cluster Redpanda de 3 nós é configurado com um único arquivo YAML e iniciado com um comando. Não há necessidade de configurar ZooKeeper, ajustar zookeeper.connect, gerenciar sessões de timeout ou lidar com a sincronização de metadados entre os dois sistemas.

Em custos operacionais, o Redpanda reduz a contagem de processos (menos VMs/containers), consome menos memória (sem JVM heap overhead) e tem licenciamento Apache 2.0, sem custos de licença para uso comercial.

# Comparação de recursos típicos (cluster de 3 nós, 16 GB RAM cada)
# Kafka: 3 brokers (12 GB heap cada) + 3 ZooKeeper (4 GB heap cada) = ~48 GB RAM
# Redpanda: 3 nós (8 GB RAM cada) = 24 GB RAM

7. Primeiros passos com Redpanda

Iniciar com Redpanda é extremamente simples. O modo mais rápido é usar Docker:

# Iniciar um nó Redpanda único
docker run -d --name redpanda-1 --rm \
  -p 9092:9092 \
  docker.redpanda.com/redpandadata/redpanda:latest \
  redpanda start \
  --overprovisioned \
  --smp 1 \
  --memory 1G \
  --reserve-memory 0M \
  --node-id 0 \
  --check=false

Após iniciar, use o rpk (Redpanda CLI) para criar um tópico:

# Criar tópico
rpk topic create meu-topico --partitions 3 --replicas 1

Agora, um produtor e consumidor em Python:

# produtor.py
from kafka import KafkaProducer
producer = KafkaProducer(bootstrap_servers='localhost:9092')
for i in range(10):
    producer.send('meu-topico', f'Mensagem {i}'.encode())
producer.flush()
print("Produzido 10 mensagens")

# consumidor.py
from kafka import KafkaConsumer
consumer = KafkaConsumer('meu-topico', bootstrap_servers='localhost:9092',
                         auto_offset_reset='earliest')
for msg in consumer:
    print(f"Recebido: {msg.value.decode()}")

8. Considerações finais e tendências futuras

O Redpanda não é apenas um "Kafka sem ZooKeeper" — é uma reimaginação completa da arquitetura de streaming de eventos. Para novas implementações, especialmente onde simplicidade e performance são prioridades, o Redpanda é frequentemente a escolha superior. Em migrações de clusters Kafka existentes, a compatibilidade de API torna a transição suave, embora seja necessário avaliar o custo-benefício da migração.

O roadmap do Redpanda inclui funcionalidades como Tiered Storage (armazenamento em camadas com object storage), modo serverless (Redpanda Cloud) e melhorias contínuas em compressão e replicação. O projeto tem ganhado adoção significativa em empresas como Citi, Verizon e Discord, sinalizando que o mercado de mensageria está evoluindo.

Para quem busca uma plataforma de streaming moderna, com baixa latência, operação simplificada e compatibilidade com o ecossistema Kafka, o Redpanda representa o estado da arte em 2025.

Referências