Cliente Redis em Rust: guia completo da biblioteca redis-rs

Biblioteca redis-rs: Cliente Rust para Redis

redis-rs é a principal biblioteca, madura e mais popular para trabalhar com Redis a partir da linguagem Rust. Ela oferece tanto uma API síncrona quanto assíncrona (baseada em tokio ou async-std), com suporte a clusterização, pipelines, Pub/Sub, transações e scripts Lua. A biblioteca se destaca pela alta performance, segurança de tipos e ergonomia características do ecossistema Rust.

Instalação e Conexão

Adicione a dependência no Cargo.toml:

[dependencies]
redis = { version = "0.25", features = ["tokio-comp"] }  # para async com tokio
# ou
redis = "0.25"  # apenas modo síncrono

Conexão básica ao Redis (versão síncrona):

use redis::Commands;

fn main() -> redis::RedisResult<()> {
    let client = redis::Client::open("redis://127.0.0.1:6379/")?;
    let mut con = client.get_connection()?;

    // Definir e obter valor
    con.set("chave", "valor")?;
    let val: String = con.get("chave")?;
    println!("Obtido: {}", val);

    Ok(())
}

Principais Funcionalidades

1. Comandos Tipados

A biblioteca converte automaticamente tipos Rust para tipos Redis e vice-versa. Suporta strings, números, tuplas, vetores e tipos personalizados através das traits FromRedisValue / ToRedisArgs.

use redis::Commands;

let mut con = client.get_connection()?;
let count: i32 = con.incr("contador", 2)?;  // incremento atômico
let existe: bool = con.exists("inexistente")?;
let membros: Vec<String> = con.smembers("chave_conjunto")?;

2. Pipelines

Pipelines permitem enviar múltiplos comandos em uma única requisição de rede, acelerando significativamente operações em lote.

use redis::Pipeline;

let mut pipe = Pipeline::new();
pipe.cmd("SET").arg("a").arg(1).ignore();
pipe.cmd("SET").arg("b").arg(2).ignore();
pipe.cmd("GET").arg("a");
let resultado: i32 = pipe.query(&mut con)?;
println!("Valor de a: {}", resultado);

3. Modo Assíncrono (async/await)

Para aplicações de alta carga, utilize a API assíncrona baseada em tokio ou async-std.

use redis::AsyncCommands;

#[tokio::main]
async fn main() -> redis::RedisResult<()> {
    let client = redis::Client::open("redis://127.0.0.1:6379/")?;
    let mut con = client.get_multiplexed_async_connection().await?;

    con.set("chave_async", "valor_async").await?;
    let val: String = con.get("chave_async").await?;
    println!("Async: {}", val);

    Ok(())
}

4. Pub/Sub (Publicador/Assinante)

Implementação do padrão Pub/Sub para troca de mensagens em tempo real.

use redis::{AsyncCommands, RedisResult};

#[tokio::main]
async fn main() -> RedisResult<()> {
    let client = redis::Client::open("redis://127.0.0.1:6379/")?;

    // Assinante
    let mut pubsub = client.get_async_connection().await?.into_pubsub();
    pubsub.subscribe("noticias").await?;

    loop {
        let msg = pubsub.next_message().await?;
        println!("Recebido: {:?}", msg.get_payload::<String>()?);
    }
}

5. Transações (MULTI/EXEC)

Agrupamento de comandos em uma transação atômica.

use redis::Commands;

let mut con = client.get_connection()?;
redis::transaction(&mut con, &["chave1", "chave2"], |con, pipe| {
    pipe.cmd("SET").arg("chave1").arg(42).ignore();
    pipe.cmd("INCR").arg("chave2");
    pipe.query(con)
})?;

6. Clusterização

Para trabalhar com Redis Cluster, utilize redis::cluster::ClusterClient:

use redis::cluster::ClusterClient;

let nodes = vec!["redis://127.0.0.1:7000", "redis://127.0.0.1:7001"];
let mut client = ClusterClient::open(nodes)?;
let mut con = client.get_connection()?;

let valor: String = con.get("chave_cluster")?;
println!("Valor do cluster: {}", valor);

Considerações Finais

A redis-rs é a escolha ideal para qualquer projeto Rust que precise de integração com Redis. Sua combinação de segurança, performance e flexibilidade a torna indispensável no ecossistema. Comece hoje mesmo e explore todo o potencial do Redis com Rust!