Caché en C++: Redis y otros

Caché en C++: Redis y otras herramientas populares

En aplicaciones C++ de alta carga, la velocidad de acceso a los datos es crítica. El almacenamiento en caché permite reducir el tiempo de respuesta del servidor entre 10 y 100 veces, disminuyendo la carga en las bases de datos y las API externas. En este artículo, analizaremos las principales bibliotecas para trabajar con caché en C++: desde el clásico Redis hasta los motores integrados LevelDB y RocksDB.

1. Redis y bibliotecas cliente para C++

Redis es el almacén key-value en memoria más popular, que admite estructuras de datos complejas (listas, conjuntos, hashes). Para C++ existen dos clientes principales:

hiredis — una biblioteca C minimalista (oficial), que se integra fácilmente en C++ a través de envoltorios.
redis-plus-plus — una biblioteca C++17 moderna con cobertura completa de comandos de Redis, soporte para pool de conexiones, pipeline y transacciones.

Ejemplo con hiredis (síncrono)

#include <hiredis/hiredis.h>#include <iostream>

int main() {    redisContext *c = redisConnect("127.0.0.1", 6379);    if (c == nullptr || c->err) {        std::cerr << "Connection error: " << c->errstr << std::endl;        return 1;    }

    redisReply *reply = (redisReply*)redisCommand(c, "SET key hello");    freeReplyObject(reply);

    reply = (redisReply*)redisCommand(c, "GET key");    if (reply->type == REDIS_REPLY_STRING) {        std::cout << "GET key: " << reply->str << std::endl;    }    freeReplyObject(reply);    redisFree(c);    return 0;}

Ejemplo con redis-plus-plus (asíncrono + pool)

#include <sw/redis++/redis++.h>#include <iostream>

int main() {    sw::redis::Redis redis("tcp://127.0.0.1:6379");

    // Establecer con TTL (5 segundos)    redis.setex("user:42", 5, "John Doe");

    // Obtener    auto val = redis.get("user:42");    if (val) {        std::cout << "Cached user: " << *val << std::endl;    } else {        std::cout << "Key expired or not found" << std::endl;    }    return 0;}

Ventajas de Redis: alta velocidad (microsegundos), rico conjunto de comandos, replicación, agrupación en clústeres. Desventajas: consume memoria RAM, requiere un servidor separado.

2. Memcached y libmemcached

Memcached es el caché distribuido más simple, que almacena datos solo en la memoria RAM. Para C++ se utiliza la biblioteca libmemcached (o su envoltorio C++ libmemcachedutil).

Ejemplo con libmemcached

#include <libmemcached/memcached.h>#include <iostream>#include <cstring>

int main() {    memcached_st *memc = memcached_create(nullptr);    memcached_server_add(memc, "127.0.0.1", 11211);

    const char *key = "session_token";    const char *value = "abc123";    memcached_return_t rc = memcached_set(memc, key, strlen(key),                                          value, strlen(value),                                          0, 0); // 0 - sin compresión, 0 - TTL

    if (rc == MEMCACHED_SUCCESS) {        size_t value_length;        uint32_t flags;        char *result = memcached_get(memc, key, strlen(key),                                     &value_length, &flags, &rc);        if (rc == MEMCACHED_SUCCESS) {            std::cout << "Get: " << result << std::endl;            free(result);        }    }    memcached_free(memc);    return 0;}

Cuándo elegir Memcached: si necesita un almacenamiento en caché simple sin estructuras de datos complejas y el máximo rendimiento es importante. Redis gana en funcionalidad, Memcached en simplicidad.