Tecnologia e Infraestrutura → Redis: soluções in-memory

Redis: soluções in-memory

1) Onde o Redis é apropriado

• Kesh (read-through/aside, TTL, SWR) e sessões.
• Contadores e quotas: rate limiting, antifrode, limites de campanha.
• Liderbords/classificações (ZSET), recomendações «top N».
• Filas/pneus de evento (Streams/PubSub), outbox/inbox, retraí.
• Idempotidade (chaves com TTL), de-dup webhooks.
• Geo (procurar os pontos mais próximos), Bitmap (bandeiras, DAU).
• Pseudônimos/tokens e caixas de autorização curtas.

2) Estruturas de dados e quando aplicá-los

String: valores/contadores ('INCRBY'), chaves idimpotentes.
Máquinas de perfis/configs, armazenamento de objetos ligeiros.
Lista: filas simples (mas sem replay/offset-semântica).
Set: elementos únicos, dedução.
ZSet: Triagem por arraial (liderbords, calendário TTL - Eventos adiados).
Stream: filas sustentáveis com grupos de consumidores, 'XREADGROUP '/replay - para webhooks, CDC, retrações.
Geo: 'GEOADD/GEORADIUS' - os próximos pontos/merchantes.
Bitmap/Bitfield: série de bandeiras (logins diários, DAU/WAU).
HyperLogLog: Exclusivo aproximado (UU) barato em memória.
Bloom/Cukoo (pods): Verificações rápidas de disponibilidade, reduzindo «MISS» para a origem.

• RedisJSON (JSON documentos), RediSearch (indexação/pesquisa), RedisBloom (estruturas prováveis), TimeSeries (métricas/agregações).

3) Chaves, TTL e políticas de memória

tenant:{t}:domain:{d}:{entity}:{id}:v{schema}    region={R}    currency={C}    lang={L}

Versionize ('vN') e inclua apenas medidas significativas (região/moeda/língua/tenante).
Isole os espaços de chaves per-tenant.

• Use a matriz TTL (segundos/minutos/hora), adicione um jitter (£10-20%) para evitar o estampede.
• Para chaves quentes - refresh-ahead e single-flight (um líder atualiza).

• 'allkeys-lru/lfu' é um kesh comum sem o vício TTL.
• 'volatil-lru/lfu' - apenas chaves com TTL.
• 'noevition' é uma falha de gravação em casos de congestionamento (mais seguro para filas/contadores críticos).
• Coloque sob o cenário e monitora sempre 'evicted _ keys'.

4) Transações, pipline e script

Pipline: Reduz o RPT, agrupe 10-100 comandos.
Transações (MULTI/EXEC): Não isolam a leitura, mas executam atômicamente o pacote.
Optimistic locking: 'WATCH key' → Verificação → 'MULTI/EXEC'.
Script Lua: lógica atômica do lado do servidor (rate limit, locks, composite-operação).

5) Filas e pneus: Lista vs Stream

Folha + 'BRPOP' é simples, mas não há consumer groups, offset/replay, fraca resistência a baixas.
Stream: 'XADD → XREADGROUP → XACK', retry-deadletter (desacompanhado em N minutos), particionamento por chave. Recomendado para webhooks PSP/KYC, pagamentos atrasados/notificações.

Filas prioritárias: vários striptease de prioridade, os consumidores «sugam» de alta prioridade.
Tarefas adiadas: ZSet onde score = timestamp; Periodicamente 'ZRANGEBYSCORE' n' now transferência para Stream.

6) Alta disponibilidade e escala

Replicação: master→replica (read-scale).
Sentinel: failover master automático 'a, detecção, URI cliente.
Redis Cluster: charding em 16384 slots, scale-out horizontal. As chaves que utilizam várias estruturas, enrole em tags de hash 'se'.

• Para kesha/sessão - cluster/réplica, 'cliente-side hasing' suportado por SDK.
• Para filas/striptease - Minimize as operações de cruzamento; particione as chaves de domínio.

7) Persistência: RDB, AOF e bacapes

RDB (imagens): mais rápido, mais econômico; Risco de perda dos últimos segundos/minutos.
AOF (diário): menos perdas; modos 'everysec/always'. Compactação AOF e readequação periódica.
Híbrido: RDB + AOF → recuperação rápida + perda moderada.
Backaps: snapshots e cópias de AOF no armazém de objetos; verifique a recuperação regularmente.

Para as filas críticas/idempotação, selecione AOF 'everysec' + replicação.

8) Segurança e Complacência

AUTH/ACL: rol per-app, proibição de comandos «perigosos» ('FLUSHALL', 'KEYS').
TLS por cliente-servidor e links entre nós; egress-IP fixo.
Segmentação de rede: redes privadas, SG/NACL; acesso apenas a partir dos serviços/neymspace necessários.
Os segredos não sejam logados; PAN/PII em Redis - apenas tokens/derivados.
Os comandos de chave: evite 'KEYS' - Use 'SCAN'.

9) Observabilidade e SLO

• Latency (P95/P99), `instantaneous_ops_per_sec`, `connected_clients`.
• Hit ratio, evicted_keys, expired_keys.
• Memory: used, fragmentation ratio, RSS, allocator stats.
• Replicação lag, AOF/RDB frequências e tamanhos, fork time.
• Streams: PEL (pending entries list), delivery latency, retry count.

• Operações Redis P99 ≤ 5-10 ms.
• Evictions ≤ 1 %/hora (espaço de kesh).
• Stream delivery P99 ≤ 500 мс, retry rate < 2%.

10) FinOps e planejamento de recursos

Memória estrada: Mede $/GB-mi RAM vs economia de pedidos de origin/BD.
Ative a compressão de valores> 1-2 KB (veja CPU).
LFU pode dar o melhor hit a um volume menor.
Para imagens/blobs maiores - não Redis: use CDN + armazenamento de objetos.

11) Pattern para iGaming/fintech

11. 1 Rate limiting (janela deslizante, Lua)

Ideia: 'INCRBY' na chave da janela + TTL; Lua atômano verifica o limite e aumenta.

lua
-- KEYS[1]=key ARGV[1]=limit ARGV[2]=ttlSec ARGV[3]=inc local cur = redis. call('INCRBY', KEYS[1], ARGV[3])
if cur == tonumber(ARGV[3]) then redis. call('EXPIRE', KEYS[1], ARGV[2]) end if cur > tonumber(ARGV[1]) then return {0, cur} else return {1, cur} end

11. 2 Idempotidade das solicitações

Chave de 'idemp:

11. 3 Liderbordes

`ZINCRBY leaderboard:game:{g} score user:{u}` → `ZREVRANGE... WITHSCORES`.
Para o top N por região/tenante, são Zset ou prefixados individuais.

11. 4 Fila de webhooks PSP

'XADD psp: webhooks...' → grupo de consumidores 'XGROUP CREATE psp: webhooks g1 $'.
Retraias de mensagens «dependentes» através da digitalização PEL ('XPENDING' n' XCLAIM ').

11. 5 Pagamentos atrasados

ZSet 'payout: du' (score = epoch) → o worker transfere periodicamente os itens prontos para Stream 'payout: exec' com dedução.

11. 6 Contadores antifrode

Combinação de 'PFADD' (exclusivo) + 'INCR' (intensidade) + geo/ASN-rótulos; Triggers para verificação manual.

12) Trabalhar com memória e desempenho

Poulas de conexões de clientes; reduza o RPT (keep-alive).
Prefira as pipas para o pacote de comando.
Acompanhe o big keys ('MEMORY USAGE', 'SCAN') para fracionar os objetos.
Hash com um pequeno número de campos é mais econômico do que muitas chaves individuais.
Ative o io-threads (read-heavy) se o perfil for confirmado pelos testes.
Evite os frequentes 'FLUSHDB/ALL' na venda; controle através de prefixos e 'UNLINK' para remoção segura.

13) Multi-tenente e isolamento

Cluster/instância individual ou logical DB per-tenant (se a carga for pequena).
Quotas de chave/memória separadas LCA.
Prefixados em chaves e métricas em namespace.

14) Locking e coerência

SET key val NX PX = ttl - mutex simples.
Redlock: use com cuidado; para transações críticas distribuídas, é melhor basear-se em «origem da verdade» (BD/ledger) e operações idumpotentes.
Prefira operações atômicas e Lua em vez de bloqueios «longos».

15) Anti-pattern

Armazenamento de blobs/imagens maiores - superaquecimento de RAM e redes.
Invariantes financeiros (saldo) apenas em Redis.
'KEYs' e' digitalização do mundo 'em venda.
Falta de TTL/jitter - dogpile para o fim.
Política de 'allkeys-' em filas críticas → perda de dados por pressão.
Misturar filas, kesha e sessões em uma única instância, sem quotas ou prioridades.
Script Lua que funcionam com as chaves de slots diferentes no Cluster.

16) Folha de cheque de implementação

1. Defina os papéis: kesh/sessão, filas/striptease, contadores/limites - espalhe por instâncias/clusters.
2. Selecione maxmemory-policy sob a tarefa; defina os limites e o monitoramento de evictions.
3. Nayming chaves, versões de circuitos, matriz TTL + jitter; single-flight para chaves top.
4. Para as filas, Streams (grupos, retais, DLQ), Zset + transferência.
5. HA: Replicação + Sentinel ou Redis Cluster; verifique o cliente failover.
6. Personalidade: RDB/AOF sob o cenário; bacapes regulares e teste de recuperação.
7. Segurança: LCA, TLS, redes privadas, proibição de equipes perigosas.
8. Observabilidade latency, ops/sec, memory, evictions, replication lag, stream PEL.
9. FinOps: perfis de memória, chaves grandes, compressão, LFU; evite o Redis para os grandes blobs.
10. Documentação de pattern (rate-limit, idempotidade, liderbords) e testes de carga.

Resultado

Redis é uma «faca suíça multifuncional» de velocidade: kesh, filas, contadores, liderbords, geo e estruturas prováveis. Sua força está na escolha correta de estruturas de dados, disciplina de TTL/deficiência, atômica cirurgias, bem como em uma elaborada P/persistência e observabilidade. Use o Redis onde os milissegundos são importantes e RPS alto, enquanto deixa os invariantes críticos (dinheiro, contabilidade) «fonte da verdade» - de modo que a plataforma permaneça rápida e confiável.