Comparando as principais soluções do mercado
Redis vs DragonflyDB
Analise o DragonflyDB como alternativa moderna ao Redis, com arquitetura multi-thread, snapshots sem copy-on-write e benchmarks de throughput.
Nesta aula você vai
- Compreender a arquitetura multi-thread e shared-nothing do DragonflyDB
- Comparar performance, compatibilidade e modelo de licenciamento
- Avaliar trade-offs de adoção em ambientes de produção
Redis vs DragonflyDB
Objetivos
Nesta aula você vai:
- Conhecer a proposta de valor do DragonflyDB no ecossistema de cache
- Entender inovações arquiteturais: multi-thread real, snapshots sem COW
- Comparar com Redis em performance, compatibilidade e maturidade operacional
Conteúdo
O desafiante multithread
Se Redis é o veterano experiente que domina a cena com maestria single-thread, o DragonflyDB é o jovem prodígio que pergunta: "E se usássemos todos os núcleos do processador desde o primeiro dia?"
Lançado em 2022 pela DragonflyDB Inc., o Dragonfly se posiciona como drop-in replacement do Redis e Memcached, prometendo até 25x mais throughput em hardware moderno com múltiplos cores — mantendo compatibilidade com o protocolo RESP.
Arquitetura: por que multi-thread importa
Redis processa comandos em um único thread principal (com I/O threads auxiliares desde a versão 6.0). Em servidores com 64 ou 128 cores, a maior parte do CPU fica ociosa durante workloads intensos.
DragonflyDB adota arquitetura shared-nothing por shard interno:
┌─────────────────────────────────────────────────────┐
│ DragonflyDB │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Thread 1 │ │ Thread 2 │ │ Thread N │ ... │
│ │ Shard A │ │ Shard B │ │ Shard N │ │
│ │ (chaves) │ │ (chaves) │ │ (chaves) │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ ▲ Sem locks globais — cada shard isolado │
└─────────────────────────────────────────────────────┘
Cada thread gerencia um subconjunto de chaves, eliminando contenção de locks globais que aflige outros bancos multi-thread.
Snapshots sem copy-on-write
Um dos maiores vilões da latência P99 no Redis é o BGSAVE: o fork() cria um processo filho que compartilha memória via copy-on-write. Sob escrita intensa durante o snapshot, o COW dispara uso de memória e pode causar picos de latência.
DragonflyDB usa snapshotting sem COW, serializando estado de forma incremental sem duplicar a memória inteira:
| Aspecto | Redis BGSAVE | DragonflyDB Snapshot |
|---|---|---|
| Mecanismo | fork() + COW | Serialização incremental |
| Pico de memória | Até 2x durante escrita intensa | Sem duplicação |
| Impacto P99 | Pode degradar significativamente | Mínimo |
| Tempo de snapshot | Proporcional ao dataset | Otimizado para datasets grandes |
Compatibilidade com Redis
DragonflyDB implementa o protocolo RESP e suporta a maioria dos comandos Redis:
# Conectar com redis-cli — funciona diretamente
redis-cli -h dragonfly.local -p 6379
# Comandos básicos
SET produto:1001 "Camiseta Azul"
GET produto:1001
# Hashes
HSET usuario:42 nome "Carlos" email "carlos@exemplo.com"
HGETALL usuario:42
# Sorted Sets (leaderboard)
ZADD ranking:2024 1500 "jogador:ana" 1420 "jogador:bruno"
ZREVRANGE ranking:2024 0 9 WITHSCORES
# Verificar versão
INFO server
Comandos não suportados ou parcialmente implementados devem ser verificados na documentação atual — módulos Redis, alguns comandos de cluster e funcionalidades muito recentes podem faltar.
Benchmark comparativo
Teste representativo com redis-benchmark (funciona com DragonflyDB):
# Redis
redis-benchmark -h redis.local -p 6379 -t set,get -n 1000000 -c 100 -d 256 -q
# DragonflyDB
redis-benchmark -h dragonfly.local -p 6379 -t set,get -n 1000000 -c 100 -d 256 -q
Resultados ilustrativos em servidor 32 cores / 128 GB RAM:
| Métrica | Redis 7.2 | DragonflyDB 1.x |
|---|---|---|
| SET ops/s | ~180.000 | ~1.200.000 |
| GET ops/s | ~220.000 | ~1.500.000 |
| P50 latência | ~0,4 ms | ~0,1 ms |
| P99 latência | ~2,5 ms | ~0,8 ms |
| Uso CPU | ~1 core (100%) | ~24 cores (75%) |
Ganhos reais dependem de hardware, tamanho de valores e mix de comandos. Sempre benchmark no seu ambiente.
Tabela comparativa geral
| Aspecto | Redis | DragonflyDB |
|---|---|---|
| Modelo de threading | Single-thread (+ I/O threads) | Multi-thread nativo |
| Protocolo | RESP | RESP (compatível) |
| Persistência | RDB + AOF | Snapshot + opções |
| Replicação | Master-replica | Em evolução |
| Redis Cluster | Sim | Não (sharding interno) |
| Módulos Redis | Sim | Não |
| Licença | RSALv2/SSPL (7.4+) | BSL 1.1 (converte para Apache 2.0) |
| Maturidade | 15+ anos | ~3 anos |
| Ecossistema | Enorme | Crescendo |
Licenciamento: ponto de atenção
DragonflyDB usa Business Source License (BSL) 1.1: código aberto, mas com restrição de uso comercial como serviço hospedado concorrente. Após período definido (geralmente 2 anos), converte para Apache 2.0.
Compare com Redis (RSALv2/SSPL) e Valkey (BSD). Se licença é critério decisivo, avalie cuidadosamente cada opção com seu departamento jurídico.
Quando escolher DragonflyDB
- Servidor com muitos cores subutilizados pelo Redis
- Workload de GET/SET intenso com valores médios (100 B – 10 KB)
- Necessidade de snapshots frequentes sem degradar P99
- Migração simples de Redis sem alterar clientes
Quando permanecer com Redis (ou Valkey)
- Dependência de módulos Redis (RedisJSON, RediSearch)
- Arquitetura Redis Cluster multi-nó madura em produção
- Necessidade de Redis Streams com consumer groups em escala
- Equipe com 15 anos de expertise operacional em Redis
- Requisito de licença BSD/permissiva imediata (Valkey)
Operação e observabilidade
# DragonflyDB — métricas essenciais
redis-cli INFO stats
redis-cli INFO memory
redis-cli DBSIZE
# Monitorar latência em tempo real
redis-cli --latency -h dragonfly.local
# Histórico de latência (percentis)
redis-cli --latency-history -h dragonfly.local -i 1
DragonflyDB expõe métricas compatíveis com o ecossistema Redis (INFO, SLOWLOG), facilitando integração com Prometheus via redis_exporter.
Resumo
- DragonflyDB é alternativa multi-thread ao Redis com compatibilidade RESP
- Arquitetura shared-nothing por shard elimina gargalo single-thread
- Snapshots sem COW protegem a latência P99 em datasets grandes
- Avalie maturidade, licença BSL e suporte a módulos antes de migrar
Para refletir
Em um servidor de 64 cores onde Redis usa 1 core a 100% e os outros 63 ficam ociosos, qual seria o impacto no custo de infraestrutura de migrar para DragonflyDB versus escalar horizontalmente com Redis Cluster?