Mise en cache en Rust : Redis et autres outils

Mise en cache en Rust : Redis et autres solutions efficaces

Dans le développement moderne à forte charge en Rust, la mise en cache joue un rôle clé. Elle permet de réduire la charge sur les bases de données, d'accélérer les réponses API et d'optimiser le travail avec des calculs coûteux. Dans cet article, nous examinerons les principales bibliothèques de mise en cache dans l'écosystème Rust : du puissant Redis aux solutions légères en mémoire.

1. Redis via la crate `redis-rs`

redis-rs est la bibliothèque principale et la plus mature pour travailler avec Redis en Rust. Elle prend en charge les opérations asynchrones (via tokio ou async-std), le clustering, pub/sub et tous les types de données Redis populaires.

Installation

[dependencies]redis = { version = "0.25", features = ["tokio-comp"] }tokio = { version = "1", features = ["full"] }

Exemple de base : mise en cache de chaînes

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

    // Définir le cache avec TTL de 60 secondes    let _: () = con.set_ex("user:123", "{\\"name\\":\\"Alice\\"}", 60).await?;

    // Récupérer la valeur    let cached: String = con.get("user:123").await?;    println!("Données mises en cache : {}", cached);

    // Vérifier l'existence de la clé    let exists: bool = con.exists("user:123").await?;    println!("La clé existe : {}", exists);

    Ok(())}

Sérialisation de structures complexes

Pour mettre en cache des structures de données, utilisez serde avec redis :

use serde::{Serialize, Deserialize};use redis::AsyncCommands;

#[derive(Debug, Serialize, Deserialize)]struct User {    id: u32,    name: String,    email: String,}

async fn cache_user(con: &mut redis::aio::MultiplexedConnection, user: &User) {    let json = serde_json::to_string(user).unwrap();    let _: () = con.set_ex(format!("user:{}", user.id), json, 300).await.unwrap();}

async fn get_cached_user(con: &mut redis::aio::MultiplexedConnection, id: u32) -> Option<User> {    let json: Option<String> = con.get(format!("user:{}", id)).await.unwrap();    json.and_then(|data| serde_json::from_str(&data).ok())}

2. Mise en cache en mémoire : la crate `moka`

Moka est une bibliothèque haute performance pour la mise en cache en mémoire, inspirée de Caffeine (Java). Elle est idéale pour les scénarios où un serveur externe n'est pas nécessaire et où une vitesse maximale est requise.

Fonctionnalités de moka :

Éviction automatique basée sur le temps (TTL, TTI) et la taille
Synchronisation asynchrone (rafraîchissement en arrière-plan)
Sécurité pour une utilisation multi-thread (Arc + RwLock)
Prise en charge des politiques de poids (cache pondéré)

Exemple : cache avec TTL et limite de taille

use moka::sync::Cache;use std::time::Duration;

fn main() {    // Créer un cache de 1000 éléments avec TTL de 10 minutes    let cache: Cache<String, String> = Cache::builder()        .max_capacity(1000)        .time_to_live(Duration::from_secs(600))        .build();

    // Insertion et récupération    cache.insert("key1".to_string(), "value1".to_string());    if let Some(v) = cache.get("key1") {        println!("Valeur : {}", v);    }}

Variante asynchrone (moka::future::Cache)

use moka::future::Cache;

#[tokio::main]async fn main() {    let cache: Cache<u64, String> = Cache::new(10_000);

    // Insertion asynchrone    cache.insert(42, "Hello async".to_string()).await;

    // Récupération asynchrone    if let Some(val) = cache.get(&42).await {        println!("{}", val);    }}