Caching in Rust: Redis, Memcached und integrierte Lösungen

Caching in Rust: Redis und andere Tools zur Beschleunigung von Anwendungen

Caching ist einer der Schlüsselmechanismen zur Leistungsoptimierung. In Rust, mit seinem Fokus auf Geschwindigkeit und Sicherheit, kann die Wahl des richtigen Caching-Tools einen erheblichen Leistungsschub bringen. In diesem Artikel betrachten wir beliebte Bibliotheken: redis-rs (mit Verbindungspool), moka (In-Memory-Cache) und cached (Funktionsdekoratoren).

1. Redis: Externer Cache mit redis-rs und deadpool

Redis ist der am weitesten verbreitete externe Cache. Für die Arbeit damit in Rust wird die Crate redis-rs verwendet. Für Produktionslasten wird empfohlen, einen Verbindungspool über deadpool-redis einzubinden.

Installation

[dependencies]redis = { version = "0.25", features = ["tokio-comp"] }deadpool-redis = "0.14"tokio = { version = "1", features = ["full"] }serde = { version = "1", features = ["derive"] }serde_json = "1"

Beispiel: Grundlegende Arbeit mit Redis

use redis::AsyncCommands;use deadpool_redis::{Config, Runtime};

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    // Erstellen eines Verbindungspools    let cfg = Config::from_url("redis://127.0.0.1:6379");    let pool = cfg.create_pool(Some(Runtime::Tokio1))?;

    // Eine Verbindung aus dem Pool holen    let mut conn = pool.get().await?;

    // Wert mit TTL von 60 Sekunden setzen    conn.set_ex("user:42", "{\\"name\\":\\"Alice\\",\\"role\\":\\"admin\\"}", 60).await?;

    // Lesen    let value: String = conn.get("user:42").await?;    println!("Erhalten: {}", value);

    // Löschen    conn.del("user:42").await?;

    Ok(())}

Serialisierung von Strukturen

use serde::{Serialize, Deserialize};

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

async fn cache_user(conn: &mut redis::aio::Connection, user: &User) -> redis::RedisResult<()> {    let key = format!("user:{}", user.id);    let json = serde_json::to_string(user).unwrap();    conn.set_ex(key, json, 300).await}

async fn get_cached_user(conn: &mut redis::aio::Connection, id: u64) -> Option<User> {    let key = format!("user:{}", id);    let result: Option<String> = conn.get(key).await.ok()?;    result.and_then(|json| serde_json::from_str(&json).ok())}

2. Moka: Schneller In-Memory-Cache

Moka ist ein leistungsstarker In-Memory-Cache, inspiriert von Caffeine (Java). Unterstützt TTL, Größenbeschränkung und asynchrone Aktualisierung.

Installation

[dependencies]moka = { version = "0.12", features = ["future"] }tokio = { version = "1", features = ["full"] }

Beispiel: Cache mit einer Begrenzung von 1000 Elementen und TTL von 10 Minuten

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

#[tokio::main]async fn main() {    let cache: Cache<String, String> = Cache::builder()        .max_capacity(1000)        .time_to_live(Duration::from_secs(600))        .build();

    // Einfügen    cache.insert("key1".to_string(), "value1".to_string()).await;

    // Lesen    if let Some(v) = cache.get(&"key1".to_string()).await {        println!("Gefunden: {}", v);    }

    // Löschen    cache.invalidate(&"key1".to_string()).await;}

Automatische Aktualisierung nach TTL-Ablauf

let cache: Cache<String, String> = Cache::builder()    .time_to_live(Duration::from_secs(60))    .time_to_idle(Duration::from_secs(30)) // TTL-Reset beim Lesen    .build();

3. Cached: Dekoratoren für Funktionen

Die Crate cached ermöglicht das Caching von Funktionsergebnissen mittels Attributen. Unterstützt verschiedene Backends, einschließlich Redis und In-Memory.

Installation

[dependencies]cach