Caching en Rust: Redis, Memcached y soluciones integradas de la A a la Z

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Introducción al caching en Rust

El caching es una de las herramientas clave para mejorar el rendimiento de las aplicaciones en Rust. Ya sea que esté creando un servidor web de alta carga, una base de datos o una aplicación de escritorio, un caching adecuado permite reducir el tiempo de respuesta, disminuir la carga en recursos externos y optimizar el uso de la memoria. En este artículo, analizaremos tres enfoques principales para el caching en el ecosistema Rust: el uso de sistemas externos (Redis y Memcached) y soluciones integradas como lru-rs y moka. Aprenderá cuándo elegir cada herramienta y obtendrá ejemplos de código listos para usar.

Sistemas de caching externos: Redis y Memcached

Caching con Redis en Rust

Redis es un popular almacén de datos en memoria que admite varias estructuras de datos (cadenas, listas, conjuntos, tablas hash). Para trabajar con Redis en Rust se utiliza la crate redis (o redis-rs).

Instalemos la dependencia en Cargo.toml:

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

Ejemplo de conexión y caching básico con Redis:

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

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

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

    // Guardamos el objeto en caché (serializamos a JSON)    let user = User {        id: 1,        name: "Alexey".into(),        email: "alex@example.com".into(),    };    let json = serde_json::to_string(&user).unwrap();    conn.set_ex("user:1", json, 3600).await?; // TTL = 1 hora

    // Leemos desde la caché    let cached: String = conn.get("user:1").await?;    let user_cached: User = serde_json::from_str(&cached).unwrap();    println!("Usuario obtenido: {:?}", user_cached);

    Ok(())}

Ventajas de Redis: soporte para estructuras de datos complejas, TTL, pub/sub, replicación, clustering. Desventajas: requiere un servidor separado, latencia de red.

Caching con Memcached en Rust

Memcached es un almacén en memoria más ligero y simple, orientado al almacenamiento de pares clave-valor. Para Rust se utiliza la crate memcache.

Agreguemos a Cargo.toml:

[dependencies]memcache = "0.19"tokio = { version = "1", features = ["full"] }

Ejemplo de trabajo con Memcached:

use memcache::Client;

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

    // Escritura con TTL (en segundos)    client.set("greeting", "¡Hola, mundo!", 300)?;

    // Lectura    let value: Option<String> = client.get("greeting")?;    if let Some(msg) = value {        println!("Desde la caché: {}", msg);    }

    // Incremento de contador    client.set("counter", "10", 0)?;    client.increment("counter", 5)?;    let counter: Option<u64> = client.get("counter")?;    println!("Contador: {:?}", counter);

    Ok(())}

Ventajas de Memcached: simplicidad, alta velocidad, consumo mínimo de memoria. Desventajas: no tiene estructuras de datos complejas, solo almacenamiento de cadenas/bytes.