Client Redis pour Rust : présentation de la bibliothèque redis-rs

Client Redis pour Rust : la bibliothèque redis-rs

La bibliothèque redis-rs est le client principal et le plus populaire pour travailler avec Redis dans l'écosystème Rust. Elle fournit un ensemble complet de fonctions pour interagir avec Redis : des commandes simples GET/SET aux transactions complexes, pipelines et Pub/Sub. Grâce à la prise en charge des modes synchrone et asynchrone (async/await), redis-rs convient à tous les projets, des scripts aux serveurs web à forte charge.

La bibliothèque est écrite en Rust pur, utilise une gestion sécurisée de la mémoire et la sécurité des types, ce qui minimise les erreurs d'exécution. Tous les types de données Redis populaires sont pris en charge : chaînes, listes, ensembles, hachages, ensembles triés, bitmaps, HyperLogLog et flux.

Installation et connexion

Ajoutez la dépendance dans le fichier Cargo.toml :

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

Pour une utilisation synchrone, il suffit d'utiliser redis = "0.27". Pour une utilisation asynchrone, choisissez l'un des exécuteurs : tokio-comp (par défaut) ou async-std-comp.

Utilisation de base (mode synchrone)

Exemple de connexion à un Redis local et d'exécution de commandes 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!("Valeur récupérée : {}", value);

    // Travail avec les hachages    con.hset("user:1", "name", "Alice")?;    con.hset("user:1", "age", "30")?;    let name: String = con.hget("user:1", "name")?;    println!("Nom d'utilisateur : {}", name);

    Ok(())}

Notez la désérialisation automatique : vous spécifiez le type dans lequel convertir le résultat (String, i32, Vec<String>, etc.), et la bibliothèque fait tout le travail.

Mode asynchrone avec Tokio

Pour les applications hautes performances, utilisez l'API asynchrone :

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

    // Définition avec TTL (durée de vie de la clé)    con.set_ex("temp_key", "valeur temporaire", 60).await?;    let val: Option<String> = con.get("temp_key").await?;    println!("Valeur : {:?}", val);

    // Travail avec les listes    con.lpush("queue", "task1").await?;    con.lpush("queue", "task2").await?;    let tasks: Vec<String> = con.lrange("queue", 0, -1).await?;    println!("Tâches dans la file d'attente : {:?}", tasks);

    Ok(())}

Le client asynchrone utilise des connexions multiplexées (un seul socket TCP pour plusieurs requêtes), ce qui améliore considérablement les performances.

Fonctionnalités avancées

Pipelines (traitement en pipeline)

Permettent d'envoyer plusieurs commandes en un seul appel réseau, accélérant les opérations par lots :

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!("Compteurs : {}, {}", val1, val2);    Ok(())}

Pub/Sub (éditeur-abonné)

Exemple d'abonnement à des canaux :

use redis::pubsub::PubSubCommands;

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