Mise en cache en Rust : Redis, Memcached et solutions intégrées

Mise en cache en Rust : Redis, Memcached et solutions intégrées

La mise en cache est l'un des mécanismes clés pour optimiser les performances des applications web et des systèmes à forte charge. Dans l'écosystème Rust, plusieurs bibliothèques puissantes sont disponibles pour organiser la mise en cache : des solutions distribuées (Redis, Memcached) aux caches in-memory légers (moka, cached). Dans cet article, nous analyserons en détail chacune d'elles, fournirons des exemples de code et comparerons leurs performances.

1. Redis via la crate redis-rs

redis-rs est le client principal et le plus mature pour Redis en Rust. Il prend en charge toutes les fonctionnalités essentielles : chaînes, listes, hachages, pub/sub, transactions et clustering.

Installation

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

Exemple : mise en cache de base avec Redis

use redis::{AsyncCommands, Client};use std::time::Duration;

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

    // Définit une clé avec un TTL de 60 secondes    con.set_ex("user:1:profile", "{\\"name\\":\\"Alice\\"}", 60).await?;

    // Lit la valeur    let data: Option<String> = con.get("user:1:profile").await?;    println!("Obtenu : {:?}", data);

    // Incrémente un compteur    let count: i64 = con.incr("page_views", 1).await?;    println!("Vues de la page : {}", count);

    Ok(())}

Caractéristiques importantes :

• Asynchrone : redis-rs prend en charge les modes synchrone et asynchrone (tokio/async-std).
• Pipeline : regroupement de commandes pour réduire la latence.
• Clustering : prise en charge de Redis Cluster via redis::cluster.

2. Memcached via la crate memcached-rs

Memcached est un magasin distribué léger de type « clé-valeur ». Pour Rust, il existe la crate memcached-rs (ou memcache).

Exemple d'utilisation

use memcache::Client;

fn main() -> memcache::MemcacheResult<()> {    let client = Client::connect("memcache://127.0.0.1:11211")?;

    // Écriture avec TTL    client.set("session:token_abc", "user_data", 30)?;

    // Lecture    let value: Option<String> = client.get("session:token_abc")?;    println!("Depuis Memcached : {:?}", value);

    // Suppression    client.delete("session:token_abc")?;

    Ok(())}

Quand choisir Memcached plutôt que Redis :

• Si vous avez besoin uniquement d'une mise en cache simple (clé-valeur).
• Si une latence minimale est importante (Memcached est plus rapide que Redis pour les opérations simples).
• Si vous n'avez pas besoin des structures de données de Redis (listes, hachages, sets).

3. Caches in-memory intégrés : moka et cached

Pour la mise en cache au sein d'un seul processus (sans serveur externe), les crates moka et cached sont parfaitement adaptées.

3.1 Moka — un cache haute performance

moka est un cache asynchrone, thread-safe avec prise en charge du TTL, de la taille maximale et des politiques d'éviction (LRU, LFU).

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

#[tokio::main]async fn main() {    let cache: Cache<String, String> = Cache::builder()        .max_capacity(10_000)          // maximum 10 000 entrées        .time_to_live(Duration::from_secs(300)) // TTL 5 minutes        .build();

    // Insertion    cache.insert("key1".to_string(), "value1".to_string()).await;

    // Récupération    if let Some(value) = cache.get(&"key1".to_string()).await {        p