Redis e Chave-Valor

Use o Redis para caches, contadores de limite de taxa, pub/sub e estado de sessão efêmero ao lado do seu banco de dados SQL principal.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

use redis::AsyncCommands;
 
let client = redis::Client::open(redis_url)?;
let mut conn = client.get_multiplexed_async_connection().await?;
let _: () = conn.set_ex("user:1:session", session_id, 3600).await?;
let cached: Option<String> = conn.get("user:1:profile").await?;

Quando usar isso: Chaves "quentes" com muitas leituras, expiração baseada em TTL, locks distribuídos ou pub/sub entre instâncias - não como fonte primária de verdade para dinheiro.

Exemplo de Trabalho

use redis::AsyncCommands;
use serde::{Deserialize, Serialize};
 
#[derive(Serialize, Deserialize)]
struct Profile { name: String }
 
async fn cached_profile(
    conn: &mut redis::aio::MultiplexedConnection,
    user_id: u64,
    loader: impl FnOnce() -> Profile,
) -> redis::RedisResult<Profile> {
    let key = format!("profile:{user_id}");
    if let Ok(json) = conn.get::<_, String>(&key).await {
        if let Ok(p) = serde_json::from_str(&json) {
            return Ok(p);
        }
    }
    let profile = loader();
    let _: () = conn.set_ex(&key, serde_json::to_string(&profile).unwrap(), 300).await?;
    Ok(profile)
}

O que isso demonstra:

• Conexão assíncrona multiplexada do crate redis.
• Cache-aside: obtém JSON, em caso de falha carrega e set_ex com TTL.
• Serde JSON como convenção de codificação de valor.
• Nomenclatura de chaves com namespaces de dois pontos.

Mergulho Profundo

Como Funciona

• O Redis é em memória com persistência opcional (RDB/AOF).
• Chaves TTL expiram automaticamente - ideal para sessões e caches.
• Servidor single-threaded - evite valores enormes e tempestades de chaves "quentes".

Padrões Comuns

Notas de Rust

// fred ou deadpool-redis para pooling de conexão em escala

Armadilhas

• Cache como fonte de verdade - Perda de dados em flush perde registros financeiros. Correção: SQL autoritativo; apenas cache Redis.
• Sem TTL - As chaves crescem até OOM. Correção: Sempre defina TTL nas entradas de cache.
• Thundering herd - Stampede de falha de cache em chave "quente". Correção: Lock de voo único ou stale-while-revalidate.
• Grandes blobs JSON - Bloqueia o thread único do Redis. Correção: Mantenha os valores pequenos; divida ou use SQL para payloads grandes.
• Confiabilidade do Pub/sub - Dispare e esqueça, sem persistência. Correção: Use Redis Streams ou um message broker para tarefas.

Alternativas

FAQs

Relacionados

• Pooling de Conexão - Pools Redis
• Noções Básicas de Bancos de Dados - Divisão SQL + cache
• Limite de Taxa e Prevenção de Abuso - Contadores Redis
• Autenticação e Sessões - Armazenamento de sessão
• Melhores Práticas de Banco de Dados - Disciplina de cache

Versões da Stack: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4 e Polars 0.46+.