Cliente Redis para Rust: descripción general de la biblioteca redis-rs

Cliente Redis para Rust: biblioteca redis-rs

La biblioteca redis-rs es el cliente principal y más popular para trabajar con Redis en el ecosistema Rust. Proporciona un conjunto completo de funciones para interactuar con Redis: desde comandos simples GET/SET hasta transacciones complejas, pipelines y Pub/Sub. Gracias al soporte tanto de modo síncrono como asíncrono (async/await), redis-rs es adecuado para cualquier proyecto, desde scripts hasta servidores web de alta carga.

La biblioteca está escrita en Rust puro, utiliza gestión segura de memoria y seguridad de tipos, lo que minimiza los errores en tiempo de ejecución. Se admiten todos los tipos de datos populares de Redis: cadenas, listas, conjuntos, hashes, conjuntos ordenados, mapas de bits, HyperLogLog y flujos.

Instalación y configuración

Agregue la dependencia al archivo Cargo.toml:

[dependencies]redis = { version = "0.27", features = ["tokio-comp"] }

Para uso síncrono, simplemente use redis = "0.27". Para uso asíncrono, elija uno de los ejecutores: tokio-comp (por defecto) o async-std-comp.

Uso básico (modo síncrono)

Ejemplo de conexión a Redis local y ejecución de comandos simples:

use redis::Commands;

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

    con.set("my_key", "hello world")?;    let value: String = con.get("my_key")?;    println!("Valor obtenido: {}", value);

    // Trabajar con hashes    con.hset("user:1", "name", "Alice")?;    con.hset("user:1", "age", "30")?;    let name: String = con.hget("user:1", "name")?;    println!("Nombre de usuario: {}", name);

    Ok(())}

Observe la deserialización automática: usted especifica el tipo en el que desea convertir el resultado (String, i32, Vec<String>, etc.), y la biblioteca lo hace todo por sí misma.

Modo asíncrono con Tokio

Para aplicaciones de alto rendimiento, use la API asíncrona:

use redis::AsyncCommands;use tokio;

#[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?;

    // Establecer con TTL (tiempo de vida de la clave)    con.set_ex("temp_key", "valor temporal", 60).await?;    let val: Option<String> = con.get("temp_key").await?;    println!("Valor: {:?}", val);

    // Trabajar con listas    con.lpush("queue", "task1").await?;    con.lpush("queue", "task2").await?;    let tasks: Vec<String> = con.lrange("queue", 0, -1).await?;    println!("Tareas en la cola: {:?}", tasks);

    Ok(())}

El cliente asíncrono utiliza conexiones multiplexadas (un solo socket TCP para múltiples solicitudes), lo que aumenta significativamente el rendimiento.

Funcionalidades avanzadas

Pipelines (procesamiento en tubería)

Permiten enviar múltiples comandos en una sola llamada de red, acelerando las operaciones por lotes:

use redis::pipe;

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

    let (val1, val2): (i32, i32) = redis::pipe()        .cmd("INCR").arg("counter_a").ignore()        .cmd("INCR").arg("counter_b").ignore()        .cmd("GET").arg("counter_a").query(&mut con)?        .cmd("GET").arg("counter_b").query(&mut con)?;

    println!("Contadores: {}, {}", val1, val2);    Ok(())}

Pub/Sub (publicador-suscriptor)

Ejemplo de suscripción a canales:

use redis::pubsub::PubSubCommands;

fn main() -> redis::RedisResult<()> {