Redis: O padrão da indústria

Recursos avançados do Redis

Explore Lua Scripts, Transactions, Pipelines, Pub/Sub, Streams e módulos do Redis.

Avançado 50 min 35 pontos Leitura 0%

Nesta aula você vai

  • Aplicar scripts Lua para atomicidade multi-comando sem race conditions
  • Utilizar pipelines e transactions (MULTI/EXEC) com consciência de limitações
  • Conhecer Pub/Sub, Streams, ACL, TLS e módulos para arquiteturas exigentes

Recursos avançados do Redis

Objetivos

Nesta aula você vai:

  • Executar lógica atômica no servidor com Lua e entender por que isso importa
  • Otimizar throughput com pipelines sem confundir com transações ACID
  • Avaliar recursos enterprise: ACL, TLS, módulos e padrões Pub/Sub vs Streams

Introdução

Além de GET e SET, o Redis oferece um conjunto de recursos que separam deploys amadores de arquiteturas maduras: scripts Lua que rodam atomicamente, pipelines que amortizam latência de rede, ACL para least privilege, e Streams para mensageria com semântica mais rica que Pub/Sub. Esta aula percorre esses mecanismos com olhar crítico — cada um resolve problemas reais e introduz novas restrições.

Conteúdo

Scripts Lua — atomicidade no servidor

Redis garante que um script Lua executa sem interleaving de outros comandos. Ideal para read-modify-write:

EVAL "local c = redis.call('GET', KEYS[1]); if not c then c = 0 end; c = c + 1; redis.call('SET', KEYS[1], c); return c" 1 contador:visitas

Boas práticas:

  • Pré-carregar com SCRIPT LOAD → EVALSHA (menos banda)
  • Scripts devem ser determinísticos — sem TIME, RANDOMKEY em cluster sem cuidado
  • Evite loops longos — bloqueiam o event loop single-threaded
  • Redis 7+ oferece Functions persistidas (alternativa a scripts ad-hoc)

Pipelines vs MULTI/EXEC

Pipeline: cliente envia vários comandos sem esperar resposta entre eles; servidor processa em sequência. Não é transação — outro cliente pode intercalar entre seus comandos pipelined.

# Conceito via redis-cli (modo não interativo)
echo -e "INCR a\nINCR b\nINCR c" | redis-cli --pipe

MULTI/EXEC: bloco transacional otimista:

MULTI
INCR estoque:sku-1
DECR estoque:sku-2
EXEC

WATCH chave aborta EXEC se chave mudou — padrão optimistic locking. Não é isolamento SERIALIZABLE como SQL; é suficiente para muitos counters e transferências simples.

Mecanismo Atomicidade Uso
Pipeline Não Throughput, batch
MULTI/EXEC Bloco isolado Sequência sem lógica condicional complexa
Lua Script inteiro Lógica condicional atômica

Pub/Sub e limitações

Fire-and-forget broadcast:

SUBSCRIBE alerts:prod
PUBLISH alerts:prod '{"level":"warn","msg":"cpu high"}'

Limitações críticas:

  • Assinante offline perde mensagens
  • Sem ACK nem replay
  • Não persiste histórico

Para notificações em tempo real onde perda é aceitável (dashboard live), Pub/Sub brilha. Para workflows críticos, use Streams ou broker dedicado (Kafka).

Redis Streams aprofundado

XADD events MAXLEN ~ 10000 * type "order.created" id "ord-99"
XREADGROUP GROUP processors consumer-1 BLOCK 5000 COUNT 10 STREAMS events >
XACK events processors 1690000000000-0
XPENDING events processors

MAXLEN ~ faz trimming aproximado — controla memória. Consumer groups permitem escala horizontal de workers com pending entries reprocessáveis.

Segurança: ACL e TLS

Redis exposto sem proteção é vetor clássico de ataque. ACL (Redis 6+):

ACL SETUSER app-readonly on >senha-forte ~cache:* +@read -@write
ACL LIST

TLS na porta e requirepass/ACL em rede não confiável. Em cloud managed, combine security groups privados + auth token.

Módulos populares

Módulo Função
RedisJSON Documentos JSON com path queries
RediSearch Índice full-text e secundário
RedisBloom Bloom filter, Cuckoo, Top-K
RedisTimeSeries Séries temporais compactas

Módulos adicionam comandos nativos — avalie dependência de vendor e suporte no provedor managed escolhido.

Memory optimization avançada

  • MEMORY DOCTOR — diagnóstico heurístico
  • MEMORY USAGE chave — bytes por chave
  • Compressão de valores na aplicação vs HASH com campos menores
  • CLIENT KILL / CLIENT LIST — conexões vazando memória

Exemplos práticos

Rate limit atômico com Lua (janela fixa simplificada):

EVAL "
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local ttl = tonumber(ARGV[2])
local current = tonumber(redis.call('GET', key) or '0')
if current + 1 > limit then
  return 0
else
  redis.call('INCR', key)
  if current == 0 then redis.call('EXPIRE', key, ttl) end
  return 1
end
" 1 ratelimit:api-key-xyz 100 60

Retorno 1 = permitido; 0 = bloqueado.

Verificar scripts em execução e slowlog:

SCRIPT EXISTS <sha>
SLOWLOG GET 5

Resumo

  • Lua e Functions executam lógica atômica no servidor — preferível a múltiplos round-trips com race condition.
  • Pipeline melhora throughput; MULTI/EXEC agrupa comandos; não confunda os dois.
  • Pub/Sub é volátil; Streams oferece persistência, grupos e ACK para pipelines sérios.
  • ACL, TLS e rede privada são obrigatórios em produção exposta.
  • Módulos estendem Redis para JSON, busca e séries temporais — com custo operacional adicional.