Mise en cache en C++ : Redis et autres

Mise en cache en C++ : Redis et autres outils populaires

Dans les applications C++ à forte charge, la vitesse d'accès aux données est critique. La mise en cache permet de réduire le temps de réponse du serveur de 10 à 100 fois, diminuant la charge sur les bases de données et les API externes. Dans cet article, nous passerons en revue les principales bibliothèques pour travailler avec le cache en C++ : du classique Redis aux moteurs embarqués LevelDB et RocksDB.

1. Redis et les bibliothèques clientes pour C++

Redis est le magasin de clés-valeurs en mémoire le plus populaire, prenant en charge des structures de données complexes (listes, ensembles, hachages). Pour C++, il existe deux clients principaux :

hiredis — une bibliothèque C minimaliste (officielle), facilement intégrable en C++ via des wrappers.
redis-plus-plus — une bibliothèque C++17 moderne avec une couverture complète des commandes Redis, prise en charge du pool de connexions, du pipeline et des transactions.

Exemple avec hiredis (synchrone)

#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;}

Exemple avec redis-plus-plus (asynchrone + pool)

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

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

    // Définition avec TTL (5 secondes)    redis.setex("user:42", 5, "John Doe");

    // Récupération    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;}

Avantages de Redis : haute vitesse (microsecondes), riche ensemble de commandes, réplication, clustering. Inconvénients : consomme de la RAM, nécessite un serveur dédié.

2. Memcached et libmemcached

Memcached est un cache distribué très simple, stockant les données uniquement en mémoire vive. Pour C++, on utilise la bibliothèque libmemcached (ou son wrapper C++ libmemcachedutil).

Exemple avec 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 - sans compression, 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;}

Quand choisir Memcached : si vous avez besoin d'une mise en cache simple sans structures de données complexes, et que la performance maximale est importante. Redis l'emporte en fonctionnalités, Memcached en simplicité.