Vue d'Ensemble du Cache
Cache de données ultra-rapide avec Valkey, l'alternative open-source à Redis.

Qu'est-ce que Valkey ?
Valkey est un magasin clé-valeur open-source et haute performance, compatible avec Redis. SailOps fournit des instances Valkey entièrement gérées pour :
- Stockage de sessions - Gestion rapide des sessions utilisateur
- Mise en cache - Réduire la charge de la base de données
- Limitation de débit - Protéger vos APIs
- Fonctionnalités temps réel - Messagerie Pub/Sub
- Files d'attente - Traitement de tâches en arrière-plan
Versions Supportées
| Version | Statut |
|---|---|
| Valkey 9.0 | ✓ Supportée |
Actuellement, seule Valkey 9.0 est disponible. Les futures versions seront ajoutées après validation pour la production.
Fonctionnalités Clés
Compatibilité Redis
Valkey est entièrement compatible avec Redis :
- Mêmes commandes et protocoles
- Utilisez les clients et bibliothèques Redis existants
- Aucune modification de code nécessaire pour la migration
- Toutes les structures de données Redis supportées
Haute Performance
Optimisé pour la vitesse :
- Latence inférieure à la milliseconde
- 100 000+ opérations par seconde
- Stockage de données en mémoire
- Options de persistance disponibles
Service Géré
SailOps s'occupe des opérations :
- Provisionnement automatique
- Surveillance et métriques
- Gestion du stockage persistant
- Mises à jour de sécurité
Mode Cluster
Les instances Valkey fonctionnent en mode cluster :
- 1 à 6 shards primaires configurables par instance
- Sharding automatique des données entre les shards
- Chaque shard gère les lectures et écritures pour ses clés assignées
- Pas de réplicas ni de basculement automatique
Cas d'Usage
Stockage de Sessions
Stockez les sessions utilisateur pour les applications web :
// Stocker la session
await redis.set(`session:${userId}`, JSON.stringify(session), 'EX', 3600);
// Récupérer la session
const session = await redis.get(`session:${userId}`);
Cache de Réponses API
Mettez en cache les réponses API coûteuses :
async function getUser(userId) {
// Vérifier d'abord le cache
const cached = await redis.get(`user:${userId}`);
if (cached) return JSON.parse(cached);
// Récupérer depuis la base de données
const user = await db.query('SELECT * FROM users WHERE id = $1', [userId]);
// Mettre en cache pendant 5 minutes
await redis.set(`user:${userId}`, JSON.stringify(user), 'EX', 300);
return user;
}
Limitation de Débit
Protégez vos APIs contre les abus :
async function checkRateLimit(ip) {
const key = `ratelimit:${ip}`;
const current = await redis.incr(key);
if (current === 1) {
await redis.expire(key, 60); // Réinitialiser chaque minute
}
return current <= 100; // 100 requêtes par minute
}
Fonctionnalités Temps Réel
Pub/Sub pour la messagerie en temps réel :
// Éditeur
await redis.publish('notifications', JSON.stringify({
userId: 123,
message: 'Nouveau message reçu'
}));
// Abonné
redis.subscribe('notifications', (message) => {
const notification = JSON.parse(message);
notifyUser(notification.userId, notification.message);
});
Files de Tâches
Traitement de tâches en arrière-plan :
// Ajouter une tâche à la file
await redis.lpush('jobs:email', JSON.stringify({
to: '[email protected]',
subject: 'Bienvenue !',
body: 'Merci pour votre inscription...'
}));
// Traiter les tâches
while (true) {
const job = await redis.brpop('jobs:email', 0);
await sendEmail(JSON.parse(job[1]));
}
Structures de Données
Valkey supporte des structures de données riches :
Chaînes (Strings)
Stockage clé-valeur basique :
SET mykey "Hello"
GET mykey
INCR counter
Listes
Collections ordonnées :
LPUSH mylist "World"
LPUSH mylist "Hello"
LRANGE mylist 0 -1
Ensembles (Sets)
Collections d'éléments uniques :
SADD myset "Hello"
SADD myset "World"
SMEMBERS myset
Tables de Hachage (Hashes)
Paires champ-valeur :
HSET user:1 name "John" email "[email protected]"
HGET user:1 name
HGETALL user:1
Ensembles Triés (Sorted Sets)
Éléments scorés et classés :
ZADD leaderboard 100 "player1"
ZADD leaderboard 200 "player2"
ZRANGE leaderboard 0 -1 WITHSCORES
Architecture
Classes de Calcul
Les instances de cache utilisent des classes de calcul avec un ratio CPU:RAM fixe. Vous configurez les ressources à l'aide de curseurs dans les limites de la classe.
| Classe | Ratio CPU:RAM | CPU Max | RAM Max | Cas d'Utilisation |
|---|---|---|---|---|
| Eco | 1:2 | 3 cores | 6 Go | Développement, tests, budgets limités |
| Standard | 1:4 | 15 cores | 58 Go | Caches de production généraux |
| Production | 1:4 | 6 cores | 28 Go | Charges sensibles nécessitant des ressources dédiées |
Allocation des Ressources
Dans chaque classe de calcul, vous configurez les ressources à l'aide de curseurs :
- CPU : Ajustez par incréments (varie selon la classe)
- Mémoire : Calculée automatiquement selon le ratio CPU:RAM
Classe Eco (ratio 1:2)
| CPU | Mémoire | Cas d'Utilisation |
|---|---|---|
| 0.5 vCPU | 1 Go | Développement, tests |
| 1 vCPU | 2 Go | Petites applications |
| 2 vCPU | 4 Go | Charges moyennes |
| 3 vCPU | 6 Go | Caches de développement plus grands |
Classe Standard (ratio 1:4)
| CPU | Mémoire | Cas d'Utilisation |
|---|---|---|
| 1 vCPU | 4 Go | Petits caches de production |
| 2 vCPU | 8 Go | Production générale |
| 4 vCPU | 16 Go | Applications à fort trafic |
| 8-15 vCPU | 32-58 Go | Production à grande échelle |
Classe Production (ratio 1:4)
| CPU | Mémoire | Cas d'Utilisation |
|---|---|---|
| 1 vCPU | 4 Go | Petits caches critiques |
| 2 vCPU | 8 Go | Caches critiques moyens |
| 4 vCPU | 16 Go | Charges haute performance |
| 6 vCPU | 28 Go | Caching entreprise |
- Commencez avec Eco pour le développement et les tests
- Utilisez Standard pour la plupart des caches de production
- Choisissez Production pour des garanties de performance dédiées
Classes de Stockage
Choisissez une classe de stockage selon vos besoins en I/O :
| Classe | IOPS Max | Cas d'Utilisation |
|---|---|---|
| standard | 5 000 | Charges générales, développement |
| performance | 15 000 | Fort I/O, charges d'écriture intensives |
Tout le stockage utilise des SSD NVMe. Le stockage peut être augmenté à tout moment sans interruption.
Stockage
Chaque shard primaire Valkey utilise un volume persistant avec des snapshots RDB périodiques. Le stockage reste alloué et facturable lorsque l'instance est arrêtée.
- Stockage par défaut :
1Gipar shard lorsque la persistance n'est pas explicitement activée,10Gilorsqu'elle est activée sans taille spécifique - Classe de stockage :
standard(5 000 IOPS) ouperformance(15 000 IOPS) — choisie à la création et non modifiable - Le stockage peut être augmenté après la création mais ne peut pas être réduit
La planification et la restauration de sauvegardes gérées ne sont pas disponibles pour Valkey. Les snapshots RDB sur le volume persistant de l'instance ne remplacent pas une sauvegarde externe.
Sécurité
Accès Réseau
Par défaut, les instances de cache sont accessibles uniquement depuis :
- Les conteneurs du même projet
- Le réseau interne du projet
Accès Public (Optionnel)
Vous pouvez activer l'accès public pour les connexions externes :
- Allez dans les paramètres de votre instance de cache
- Activez Accès Public
- Configurez la Liste d'IPs autorisées pour restreindre l'accès
Lorsque activé :
- Une gateway dédiée est créée pour votre cache
- Le port 6379 est exposé
- Seules les IPs autorisées peuvent se connecter
- L'authentification par mot de passe est requise pour l'accès public
Configurez toujours la liste d'IPs autorisées lors de l'activation de l'accès public. N'exposez jamais votre cache sans restrictions d'IP. Les connexions publiques ne sont pas chiffrées — TLS n'est pas disponible pour Valkey.
Authentification
L'authentification par mot de passe est optionnelle pour les connexions internes mais requise lorsque l'accès public est activé.
Exemple de connexion (format DNS interne : {service-name}.{namespace}) :
const redis = new Redis({
host: 'my-cache.my-project-abc123', // {service-name}.{namespace}
port: 6379,
password: 'votre-mot-de-passe' // Optionnel pour interne, requis pour public
});
TLS
TLS n'est pas supporté pour les instances Valkey. Les connexions utilisent du TCP non chiffré. Gardez les charges sensibles sur des réseaux privés.
Surveillance
Métriques Intégrées
- Utilisation mémoire
- Nombre de connexions
- Opérations par seconde
- Ratio hits/miss du cache
- Latence des commandes
Voir les Métriques
- Allez sur votre instance de cache
- Cliquez sur l'onglet Observability
- Sélectionnez la période
- Consultez les graphiques de performance
Tarification
Les instances de cache sont facturées à l'heure selon :
- La classe de calcul et les ressources sélectionnées par shard
- Le nombre de shards primaires
- L'utilisation du stockage
Voir Tarification pour les détails.
Bonnes Pratiques
1. Définir des Durées d'Expiration
Toujours définir un TTL pour les données en cache :
// Bon - expire dans 1 heure
await redis.set('key', 'value', 'EX', 3600);
// Mauvais - n'expire jamais, remplit la mémoire
await redis.set('key', 'value');
2. Utiliser les Structures de Données Appropriées
Choisissez la bonne structure pour votre cas d'usage :
| Cas d'Usage | Structure |
|---|---|
| Valeurs simples | Strings |
| Cache d'objets | Hashes |
| Éléments uniques | Sets |
| Classements | Sorted Sets |
| Files d'attente | Lists |
3. Surveiller l'Utilisation Mémoire
Configurez des alertes pour une utilisation mémoire > 80%.
4. Utiliser le Pooling de Connexions
Ne créez pas de nouvelles connexions pour chaque requête.