Aller au contenu principal

Vue d'Ensemble du Cache

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

Liste des Caches

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​

VersionStatut
Valkey 9.0✓ Supportée
Version

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.

ClasseRatio CPU:RAMCPU MaxRAM MaxCas d'Utilisation
Eco1:23 cores6 GoDéveloppement, tests, budgets limités
Standard1:415 cores58 GoCaches de production généraux
Production1:46 cores28 GoCharges 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)​

CPUMémoireCas d'Utilisation
0.5 vCPU1 GoDéveloppement, tests
1 vCPU2 GoPetites applications
2 vCPU4 GoCharges moyennes
3 vCPU6 GoCaches de développement plus grands

Classe Standard (ratio 1:4)​

CPUMémoireCas d'Utilisation
1 vCPU4 GoPetits caches de production
2 vCPU8 GoProduction générale
4 vCPU16 GoApplications à fort trafic
8-15 vCPU32-58 GoProduction à grande échelle

Classe Production (ratio 1:4)​

CPUMémoireCas d'Utilisation
1 vCPU4 GoPetits caches critiques
2 vCPU8 GoCaches critiques moyens
4 vCPU16 GoCharges haute performance
6 vCPU28 GoCaching entreprise
Choisir une Classe de Calcul
  • 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 :

ClasseIOPS MaxCas d'Utilisation
standard5 000Charges générales, développement
performance15 000Fort 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 : 1Gi par shard lorsque la persistance n'est pas explicitement activée, 10Gi lorsqu'elle est activée sans taille spécifique
  • Classe de stockage : standard (5 000 IOPS) ou performance (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
Sauvegardes

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 :

  1. Allez dans les paramètres de votre instance de cache
  2. Activez Accès Public
  3. 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
Sécurité

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​

  1. Allez sur votre instance de cache
  2. Cliquez sur l'onglet Observability
  3. Sélectionnez la période
  4. 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'UsageStructure
Valeurs simplesStrings
Cache d'objetsHashes
Éléments uniquesSets
ClassementsSorted Sets
Files d'attenteLists

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.

Prochaines Étapes​