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

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

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

Caching ist einer der Schlüsselmechanismen zur Leistungsoptimierung moderner Anwendungen. Im Rust-Ökosystem, bekannt für seine Geschwindigkeit und Speichersicherheit, kann die Wahl des richtigen Caching-Tools die Effizienz eines Programms erheblich beeinflussen. In diesem Artikel betrachten wir drei Hauptansätze: die externen Systeme Redis und Memcached sowie integrierte Lösungen, die in der Standardbibliothek und beliebten Crates verfügbar sind.

Warum in Rust cachen?

Rust ist bereits von sich aus sehr schnell, aber bei der Arbeit mit Datenbanken, externen APIs oder komplexen Berechnungen ermöglicht Caching:

Reduzierung der Latenz (latency) bei wiederholten Anfragen
Verringerung der Last auf Datenbanken und externe Dienste
Einsparung von Rechenressourcen und CPU-Zeit

1. Integrierte Lösungen: HashMap und LRU-Cache

Der einfachste Weg zum Caching in Rust ist die Verwendung von HashMap aus der Standardbibliothek. Für Multithread-Anwendungen wird ein Mutex<HashMap> oder RwLock<HashMap>-Wrapper benötigt. Dieser Ansatz hat jedoch keine Verdrängungsstrategie (eviction policy), was zu unbegrenztem Speicherwachstum führen kann.

Beispiel eines einfachen Caches mit HashMap

use std::collections::HashMap;use std::sync::Mutex;

struct SimpleCache {    store: Mutex<HashMap<String, String>>,}

impl SimpleCache {    fn new() -> Self {        SimpleCache {            store: Mutex::new(HashMap::new()),        }    }

    fn get(&self, key: &str) -> Option<String> {        self.store.lock().unwrap().get(key).cloned()    }

    fn set(&self, key: String, value: String) {        self.store.lock().unwrap().insert(key, value);    }}

LRU-Cache mit der Crate `lru`

Um die Cache-Größe zu begrenzen und alte Einträge automatisch zu verdrängen, verwenden Sie die Crate lru. Sie implementiert den Algorithmus Least Recently Used und entfernt die am seltensten verwendeten Elemente.

use lru::LruCache;use std::num::NonZeroUsize;

fn main() {    let mut cache = LruCache::new(NonZeroUsize::new(3).unwrap());    cache.put("apple", 10);    cache.put("banana", 20);    cache.put("cherry", 30);    cache.put("date", 40); // "apple" wird verdrängt

    println!("{:?}", cache.get(&"apple")); // None    println!("{:?}", cache.get(&"date"));  // Some(40)}

Vorteile: keine Netzwerklatenz, Einfachheit, vollständige Kontrolle. Nachteile: Der Cache lebt nur innerhalb eines einzelnen Prozesses, keine Persistenz.

2. Caching mit Redis über `redis-rs`

Redis ist ein In-Memory-Schlüssel-Wert-Speicher, der häufig als verteilter Cache verwendet wird. In Rust wird für die Arbeit mit Redis die Crate redis (oder redis-rs) verwendet.

Verbindung und grundlegende Arbeit

use redis::Commands;

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

    // Setzen eines Werts mit TTL (Lebensdauer)    con.set_ex("user:42", "{\\"name\\": \\"Alice\\"}", 60)?;

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

    // Prüfen auf Existenz    let exists: bool = con.exists("user:42")?;    println!("Exists: {}", exists);

    Ok(())}