Caché en Rust: Redis, Memcached y soluciones integradas

Introducción: ¿Por qué usar Caché en Rust?

Rust es un lenguaje de programación de sistemas valorado por su rendimiento y seguridad de memoria. Sin embargo, incluso los programas más rápidos pueden ralentizarse con operaciones repetidas de E/S, cálculos complejos o consultas frecuentes a bases de datos. El almacenamiento en caché te permite guardar los resultados de operaciones costosas y devolverlos al instante, lo cual es crítico para servicios web de alta carga, motores de videojuegos y sistemas en tiempo real.

En este artículo, veremos tres enfoques para el almacenamiento en caché en Rust: sistemas externos (Redis, Memcached) y soluciones integradas (lru-rs, moka). Aprenderás cómo integrarlos en el código, qué problemas resuelve cada herramienta y cómo elegir la mejor opción para tu proyecto.

1. Caché Externo: Redis y Memcached

Los sistemas de caché externos operan como servicios separados a los que la aplicación accede a través de la red. Son ideales para sistemas distribuidos donde múltiples procesos o servidores necesitan compartir un caché común.

1.1. Redis a través de la Crate redis

Redis es el almacén en memoria más popular, que admite estructuras de datos complejas (listas, conjuntos, hashes). La crate redis se utiliza para conectar con Redis en Rust.

Instalación: añadir a Cargo.toml:

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

Ejemplo de caché básico de cadenas:

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

    // Escribir en caché por 60 segundos    let _: () = con.set_ex("user:42", "Alice", 60).await?;    // Leer    let val: Option = con.get("user:42").await?;    println!("Valor en caché: {:?}", val);    Ok(())}

Redis es excelente para almacenar en caché sesiones, respuestas de API y colas de tareas. Su desventaja es la necesidad de instalar y mantener un servidor separado.

1.2. Memcached a través de la Crate memcache

Memcached es una alternativa más ligera a Redis, enfocada en el almacenamiento simple de clave-valor. La crate memcache proporciona APIs tanto síncronas como asíncronas.

Ejemplo con la crate memcache:

use memcache::{Client, MemcacheError};

fn main() -> Result<(), MemcacheError> {    let client = Client::connect("memcache://127.0.0.1:11211")?;    client.set("counter", 100, 30)?; // TTL = 30 segundos    let val: Option = client.get("counter")?;    println!("Valor: {:?}", val);    Ok(())}

Memcached es más rápido que Redis para operaciones simples de get/set, pero no admite estructuras de datos complejas. Elígelo si solo necesitas "clave-valor" con una sobrecarga mínima.

2. Librerías de Caché Integradas

Para aplicaciones de un solo proceso (utilidades CLI, programas de escritorio, servidores de juegos), el caché externo es excesivo. Las soluciones integradas funcionan en la memoria del proceso, no requieren red y son extremadamente rápidas.

2.1. lru-rs — Caché LRU Simple

La crate lru implementa un caché con desalojo por uso menos reciente (Least Recently Used). Es ideal para almacenar en caché resultados de análisis sintáctico, configuraciones u objetos pequeños.

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

fn main() {    let mut cache: LruCache = LruCache::new(NonZeroUsize::new(3).unwrap());    cache.put("a", 1);    cache.put("b", 2);    cache.put("c", 3);    cache.put("d", 4); // "a" será desalojado porque el caché está lleno

    println!("{:?}", cache.get(&"a")); // None    println!("{:?}", cache.get(&"d")); // Some(4)}

Ventajas: minimalista, tiempo de ejecución predecible, seguro para hilos cuando se usa