Valkey géré : un cache compatible Redis, mesuré

Une base Valkey de 1 Go et une Nano dans le même réseau privé. Une lecture SQLite de 214 ms tombe à 0,17 ms une fois en cache, un GET coûte 0,1 ms en TLS, et la base pleine refuse les écritures jusqu'au passage à allkeys-lru. Mesures, clients et limites.

Une application lit d'abord un bloc mémoire marqué d'un éclair, par un chemin court ; une base lente avec une horloge n'est consultée qu'au bout d'un chemin pointillé

Valkey est la suite libre de Redis 7.2, sous licence BSD, maintenue depuis 2024 sous l'égide de la Linux Foundation. Il parle le même protocole et accepte les mêmes commandes : les clients Redis s'y connectent sans changement.

FFxF propose Valkey 8.1 parmi ses bases gérées. Cet article mesure ce qu'un cache Valkey fait gagner à une application, à partir d'un essai fait le 3 novembre 2026 : une base Valkey de 1 Go et une VM Nano dans le même réseau privé, une lecture lente de plus de 200 ms, puis la même lecture servie par le cache. Le montage de la base elle-même (TLS, sauvegardes, restauration) est décrit dans Bases de données gérées à Montréal, en démonstration. Les mots de passe sont masqués.

1. Le montage

Un réseau privé 10.66.0.0/24, une base Valkey de la plus petite taille (1 Go, 0,020 CAD l'heure) et une Nano Debian 13 en IPv6 seulement (0,014 CAD l'heure) reliée au même réseau. La base, par l'API :

bash
curl -s -X POST https://api.ffxf.net/v1/databases \
     -H "Authorization: Bearer $FFXF_TOKEN" \
     -H "Idempotency-Key: $(uuidgen)" \
     -H "Content-Type: application/json" \
     -d '{"name": "cache", "vpc": 43, "engine": "valkey", "size_gb": 1}'

Commandée à 11:06:31, elle était active à 11:12:59, et son certificat Let's Encrypt en place une minute plus tard. La chaîne de connexion vient de GET /v1/databases/33/credentials ; elle part dans un fichier lisible par l'utilisateur seul, sur la VM :

bash
rediss://default:••••••••@private-awfgnu7jfj.db.ffxf.cloud:6379

Sur la VM, les outils viennent des paquets Debian : apt install valkey-tools redis-tools python3-redis nodejs npm (valkey-cli 8.1.1, redis-cli 8.0.2, redis-py 6.1.0, Node 20).

2. TLS et mot de passe obligatoires

La base n'accepte que des connexions chiffrées et authentifiées :

bash
$ valkey-cli -h private-awfgnu7jfj.db.ffxf.cloud PING
Error: Connection reset by peer

$ valkey-cli -h private-awfgnu7jfj.db.ffxf.cloud --tls PING
NOAUTH Authentication required.

$ REDISCLI_AUTH=•••••••• valkey-cli -h private-awfgnu7jfj.db.ffxf.cloud --tls PING
PONG

Le certificat est reconnu par le magasin du système, sans fichier à télécharger :

bash
subject=CN=awfgnu7jfj.db.ffxf.cloud
issuer=C=US, O=Let's Encrypt, CN=YR2
Protocol: TLSv1.3
Verify return code: 0 (ok)

REDISCLI_AUTH évite de passer le mot de passe avec -a, qui le laisse dans l'historique et dans la liste des processus. Sur une VM en IPv6 seulement, un détail : le résolveur DNS64 rend aussi une adresse 64:ff9b::a42:2 pour le nom privé, qui ne mène nulle part. Les clients testés plus bas ont pris l'adresse IPv4 privée (10.66.0.2) sans réglage, mais si un client s'attarde à la connexion, c'est la première chose à vérifier.

3. La latence brute, sur le réseau privé

valkey-benchmark, lancé depuis la Nano, en TLS, avec des valeurs de 64 octets et 100 000 requêtes par essai. -c est le nombre de connexions, -P le nombre de commandes envoyées d'un coup (pipeline) :

bash
valkey-benchmark -h private-awfgnu7jfj.db.ffxf.cloud --tls -a "$REDISCLI_AUTH" \
    -t set,get -n 100000 -d 64 -c 1 -P 1 --csv

Un aller-retour coûte environ un dixième de milliseconde, chiffrement compris. Le serveur, lui, ne compte presque rien : GET /v1/databases/33/queries donnait 400 004 GET pour 158,9 ms de temps total, moins d'une microseconde chacun. Le reste est le réseau, le TLS et le client. D'où l'intérêt du pipeline : seize commandes envoyées d'un coup coûtent à peine plus qu'une seule. Avec 50 connexions, le client sur un seul vCPU devient la limite ; ces chiffres sont un plancher.

4. Une lecture lente, avec et sans cache

L'application de test est un script Python. Sa donnée « lente » est un tableau de bord par produit, calculé dans SQLite sur 2 millions de ventes (63 Mo, sans index sur le produit) : nombre de ventes, quantités, chiffre d'affaires, prix moyen et meilleur jour. Chaque calcul parcourt la table deux fois, environ 210 ms. Le cache suit le modèle le plus courant (cache-aside) : lire Valkey, sinon calculer et ranger le résultat cinq minutes.

python
import json, os, redis

r = redis.Redis.from_url(os.environ["VALKEY_URL"])   # rediss:// : TLS vérifié

def stats_avec_cache(produit):
    cle = f"stats:produit:{produit}"
    v = r.get(cle)
    if v is not None:
        return json.loads(v)
    res = stats_sans_cache(produit)                   # la requête SQLite de 210 ms
    r.set(cle, json.dumps(res), ex=300)
    return res

Les lectures suivent une distribution réaliste : 80 % portent sur 100 produits populaires, le reste sur l'ensemble des 1 000. Un seul fil d'exécution, chaque appel chronométré :

Cache rempli, la lecture médiane passe de 214 ms à 0,17 ms, et le débit d'un seul fil de 5 à 5 375 lectures par seconde. La passe qui part d'un cache vide montre la réalité d'un démarrage : 647 absences sur 5 000 lectures, soit 87 % de lectures servies par Valkey, mais un p95 encore lent, parce que ces 13 % paient le calcul complet. Le débit d'ensemble y reste à 34 lectures par seconde : c'est le calcul qui le fixe, pas le cache.

Deux remarques. Les 0,17 ms d'une lecture servie par le cache, contre 0,095 ms pour un GET de valkey-benchmark, sont le coût de Python et du décodage JSON. Et quatre fils au lieu d'un, sur une Nano à un vCPU, donnent moins (2 958 lectures par seconde) : le verrou global de Python et le processeur unique limitent, pas Valkey.

5. Les clients Redis habituels

Valkey se présente avec les deux versions dans INFO server, celle du protocole Redis qu'il reprend et la sienne :

bash
redis_version:7.2.4
valkey_version:8.1.1

redis-cli 8.0.2 et redis-py 6.1.0 s'y connectent avec la même adresse rediss://. Côté Node, ioredis 6.0.0 lit la clé rangée par le script Python :

javascript
const Redis = require("ioredis");
const r = new Redis(process.env.VALKEY_URL);   // rediss:// active le TLS

(async () => {
  console.log(await r.ping());
  console.log(await r.get("stats:produit:7"), await r.ttl("stats:produit:7"));
  await r.quit();
})();
bash
PONG
[2027,6092,606107.55,99.25,"2026-08-10"] 68

redis-py vérifie le certificat et le nom : la même adresse écrite avec l'IP privée au lieu du nom est refusée (certificate is not valid for '10.66.0.2'). Utilisez toujours le nom fourni.

6. Mémoire et éviction

Sur une base de 1 Go, Valkey reçoit 567 Mo pour les données (maxmemory 594 542 592 octets, aussi donné par data_memory.max_bytes dans l'API) ; le reste fait tourner le système et les instantanés. La politique par défaut est noeviction. Remplie avec des valeurs de 10 Ko, la base a refusé les écritures à 57 483 clés :

bash
Error from server: OOM command not allowed when used memory > 'maxmemory'.
used_memory_human:566.59M
evicted_keys:0

CONFIG SET est refusé (NOPERM) : la politique se change par l'API ou par la console. Huit valeurs sont acceptées, celles de Valkey : noeviction, allkeys-lru, allkeys-lfu, allkeys-random, volatile-lru, volatile-lfu, volatile-random et volatile-ttl.

bash
curl -s -X PATCH https://api.ffxf.net/v1/databases/33 \
     -H "Authorization: Bearer $FFXF_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"eviction_policy": "allkeys-lru"}'

Demandée à 11:27:24, allkeys-lru était visible dans CONFIG GET maxmemory-policy quatre secondes plus tard. 30 000 écritures de 10 Ko de plus ont alors toutes réussi, et Valkey a retiré 29 918 clés anciennes pour les loger. Pour un cache pur, allkeys-lru ou allkeys-lfu conviennent. Si la même base garde aussi des données qui ne doivent pas disparaître (sessions, files d'attente), mettez un TTL aux seules clés de cache et choisissez une politique volatile-*. Avec noeviction, prévoyez que l'application attrape l'erreur OOM et serve la donnée sans la ranger.

7. Persistance

Un cache peut se reconstruire, mais Valkey sert aussi pour des sessions ou des compteurs. La base a le journal AOF actif (appendonly yes, appendfsync everysec) : chaque écriture est sur disque dans la seconde. Hors site, un instantané est pris chaque heure s'il y a eu des écritures, gardé 24 heures, puis un par jour sur 7 jours. Le premier a été pris à la création, et son essai de restauration a réussi quelques secondes plus tard (backups.last_restore_test.ok: true). Une restauration crée une nouvelle base à partir du dernier instantané pris avant la minute choisie : pour Valkey, la précision est à l'heure, pas à la minute comme pour PostgreSQL.

8. Les limites à connaître

  • Pas de commandes d'administration : CONFIG SET, ACL LIST, MONITOR, BGSAVE répondent NOPERM. CONFIG GET et INFO restent lisibles.
  • FLUSHALL est permis pour l'administrateur (essayé) comme, d'après la documentation, pour les autres utilisateurs : donnez à chaque application son utilisateur, et gardez le mot de passe default hors du code.
  • Une seule machine : nous n'avons vu ni réplique ni mode cluster dans l'API. Un redémarrage pour une mise à jour mineure, dans votre créneau de maintenance, coupe la base une minute ou deux.
  • Un vCPU sur 1 et 2 Go, io-threads 1, maxclients 1000, 16 bases numérotées sans accès par base.
  • Réseau privé d'abord : l'accès public est coupé à la création, et un cache placé loin de l'application perd l'essentiel de son intérêt.

9. Prix et coût de l'essai

Valkey coûte comme les autres moteurs : 0,020 CAD l'heure pour 1 Go (≈ 14,60 CAD par mois), 0,030 CAD pour 2 Go, 0,055 CAD pour 4 Go, sauvegardes comprises. La base et la Nano ont vécu 21 minutes, facturées une heure chacune : 0,034 CAD pour l'essai complet. Toutes les routes de l'API sont dans le guide des bases de données.

Une base PostgreSQL reliée à trois copies, une sauvegarde, une restauration à une minute précise et un fork, chacune marquée d'une empreinte vérifiée

PostgreSQL géré : sauvegarde, restauration, fork

Une base PostgreSQL gérée de 1 Go, 5 millions de lignes, une mise à jour sans WHERE. Sauvegarde en 30 secondes, restauration à la minute en six minutes, fork copié en 35 secondes, et des empreintes identiques à chaque fois.

Lire l'article 8 min de lecture

Une base de données reliée par un lien chiffré à une machine du réseau privé, ses sauvegardes hors site et une flèche de retour dans le temps

Bases de données gérées à Montréal, en démonstration

Les bases gérées sont ouvertes à tous. Une base PostgreSQL suivie de bout en bout : créée en cinq minutes, jointe en TLS vérifié depuis le réseau privé, une suppression rattrapée à la minute près, un fork et un passage à 2 Go, avec les sorties réelles.

Lire l'article 8 min de lecture

Support & discussions

Questions techniques, retours d'incidents ou discussions d'infrastructure, l'équipe est présente sur Discord, Telegram, X, Instagram, Reddit et IRC.