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 :
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 :
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 :
$ 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 :
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) :
valkey-benchmark -h private-awfgnu7jfj.db.ffxf.cloud --tls -a "$REDISCLI_AUTH" \
-t set,get -n 100000 -d 64 -c 1 -P 1 --csv
| Essai | GET par seconde | GET p50 | GET p95 | SET par seconde | SET p50 |
|---|---|---|---|---|---|
| 1 connexion, sans pipeline | 9 088 | 0,095 ms | 0,143 ms | 8 455 | 0,103 ms |
| 1 connexion, pipeline de 16 | 130 208 | 0,111 ms | 0,159 ms | 110 011 | 0,135 ms |
| 50 connexions, sans pipeline | 53 362 | 0,495 ms | 0,823 ms | 53 163 | 0,599 ms |
| 50 connexions, pipeline de 16 | 523 560 | 1,023 ms | 1,383 ms | 296 736 | 2,151 ms |
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.
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é :
| Passe | Lectures | p50 | p95 | p99 | Débit |
|---|---|---|---|---|---|
| Sans cache | 300 | 214,02 ms | 236,02 ms | 266,89 ms | 5 lectures/s |
| Cache vide au départ | 5 000 | 0,24 ms | 227,20 ms | 247,19 ms | 34 lectures/s |
| Cache rempli | 5 000 | 0,17 ms | 0,25 ms | 0,36 ms | 5 375 lectures/s |
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 :
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 :
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();
})();
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 :
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.
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,BGSAVErépondentNOPERM.CONFIG GETetINFOrestent lisibles. FLUSHALLest 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 passedefaulthors 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.