Créer une Instance de Cache
Déployez un cache haute performance en moins d'une minute.
Prérequis
- Un projet créé dans votre organisation
- Au moins un conteneur qui utilisera le cache
Guide Étape par Étape
1. Accéder au Cache
- Sélectionnez votre projet dans le sélecteur de projet
- Cliquez sur Cache dans la barre latérale
- Cliquez sur Nouveau Cache
2. Configuration de Base
Nom du Cache
Entrez un nom unique pour votre cache :
Valide : my-cache, session-store, api-cache
Invalide : My Cache, cache_prod, cache.main
Utilisez des lettres minuscules, des chiffres et des tirets. Le nom devient partie du nom d'hôte interne.
Version Valkey
Sélectionnez la version Valkey :
| Version | Recommandation |
|---|---|
| 9.0 | Version actuellement supportée |
Actuellement, seule Valkey 9.0 est disponible. Les futures versions seront ajoutées après validation.
3. Configuration du Cluster
Configurez le nombre de shards pour votre cluster de cache :
| Shards | Description |
|---|---|
| 1 | Shard unique, usage développement |
| 2-3 | Petits clusters de production |
| 4-6 | Grands clusters de production |
Le nombre de shards ne peut pas être modifié après la création de l'instance. Changer le nombre de shards nécessite de migrer les données vers une nouvelle instance. Le stockage, contrairement à la taille du cluster, peut toujours être augmenté par la suite.
La classe de stockage (standard ou performance) ne peut pas être modifiée après la création de l'instance. Choisissez la classe de stockage dont vous avez besoin maintenant.
- Commencez avec 1 shard pour le développement
- Utilisez 3 shards pour les charges de production
- Maximum 6 shards par instance de cache
- Chaque shard est un primaire indépendant sans réplicas ni basculement automatique
4. Configuration du Calcul
Sélectionnez une classe de calcul selon vos besoins. Chaque classe a un ratio CPU:RAM fixe, et vous configurez les ressources à l'aide de curseurs.
| Classe | Ratio CPU:RAM | CPU Max | RAM Max | Description |
|---|---|---|---|---|
| Eco | 1:2 | 3 cores | 6 Go | Développement et tests |
| Standard | 1:4 | 15 cores | 58 Go | Production générale |
| Production | 1:4 | 6 cores | 28 Go | Production critique avec ressources dédiées |
Dans chaque classe, 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
Exemple avec la classe Standard (ratio 1:4) :
- 1 vCPU → 4 Go RAM
- 2 vCPU → 8 Go RAM
- 4 vCPU → 16 Go RAM
Commencez avec Eco et des ressources minimales. Vous pouvez augmenter la taille plus tard sans perte de données.
5. Configuration du Stockage
Chaque shard Valkey utilise un volume persistant avec des snapshots RDB périodiques.
- Taille du stockage : par défaut
1Gipar shard (ou10Gilorsque la persistance est explicitement activée). Choisissez une taille plus grande si votre jeu de données le nécessite. - Classe de stockage :
standard(5 000 IOPS) ouperformance(15 000 IOPS) — par défautstandard - Le stockage peut être augmenté ultérieurement sans interruption, mais ne peut pas être réduit
La classe de stockage ne peut pas être modifiée après la création. Choisissez la classe adaptée à vos besoins en I/O dès maintenant.
6. Configuration de Sécurité (Optionnel)
Authentification
Activez l'authentification par mot de passe pour votre cache :
- Activez Authentification
- Définissez un mot de passe fort (minimum 8 caractères)
- Requis si vous activez l'accès public
- Le mot de passe peut être modifié après la création
Accès Public
Activez l'accès externe à votre cache :
- Activez Accès Public
- Ajoutez les plages CIDR à la liste autorisée, avec une note optionnelle par entrée pour identifier son usage
- Seules les IPs listées peuvent se connecter depuis l'extérieur de votre projet
- L'authentification doit être activée pour utiliser l'accès public
- Configurez toujours la liste d'IPs autorisées
- N'exposez jamais votre cache sans restrictions d'IP
- Les connexions publiques ne sont pas chiffrées — TLS n'est pas disponible pour Valkey
7. Créer le Cache
- Vérifiez votre configuration
- Cliquez sur Créer
- Attendez le provisionnement (~15 secondes)
Après la Création
Voir les Détails de Connexion
- Allez sur votre instance de cache
- Cliquez sur l'onglet Connexion
- Consultez :
- Hôte
- Port
- Mot de passe
- Chaîne de connexion
Format de la Chaîne de Connexion
Le format utilise le DNS interne {service-name}.{namespace} :
redis://default:[email protected]:6379
Le namespace est automatiquement assigné à votre projet. Vous trouverez la chaîne de connexion complète dans l'onglet Connexion du cache.
Tester la Connexion
Depuis un conteneur du même projet :
# Avec redis-cli (remplacez par votre nom d'hôte réel)
redis-cli -h my-cache.my-project-abc123 -a VOTRE_MOT_DE_PASSE
# Test avec PING
127.0.0.1:6379> PING
PONG
Exemples de Connexion
Node.js (ioredis)
const Redis = require('ioredis');
const redis = new Redis({
host: 'my-cache.my-project-abc123', // {service-name}.{namespace}
port: 6379,
password: process.env.REDIS_PASSWORD,
retryDelayOnFailover: 100,
maxRetriesPerRequest: 3
});
// Tester la connexion
redis.ping().then(console.log); // PONG
// Opérations de base
await redis.set('key', 'value');
const value = await redis.get('key');
Node.js (redis)
import { createClient } from 'redis';
const client = createClient({
url: process.env.REDIS_URL
// redis://default:MOT_DE_PASSE@host:6379
});
await client.connect();
await client.set('key', 'value');
const value = await client.get('key');
Python (redis-py)
import redis
import os
r = redis.Redis(
host='my-cache.my-project-abc123', # {service-name}.{namespace}
port=6379,
password=os.environ['REDIS_PASSWORD'],
decode_responses=True
)
# Tester la connexion
print(r.ping()) # True
# Opérations de base
r.set('key', 'value')
value = r.get('key')
Go (go-redis)
import (
"context"
"os"
"github.com/redis/go-redis/v9"
)
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "my-cache.my-project-abc123:6379", // {service-name}.{namespace}
Password: os.Getenv("REDIS_PASSWORD"),
DB: 0,
})
// Tester la connexion
pong, err := rdb.Ping(ctx).Result()
// Opérations de base
err = rdb.Set(ctx, "key", "value", 0).Err()
val, err := rdb.Get(ctx, "key").Result()
PHP (predis)
<?php
require 'vendor/autoload.php';
$client = new Predis\Client([
'scheme' => 'tcp',
'host' => 'my-cache.my-project-abc123', // {service-name}.{namespace}
'port' => 6379,
'password' => getenv('REDIS_PASSWORD'),
]);
// Tester la connexion
echo $client->ping(); // PONG
// Opérations de base
$client->set('key', 'value');
$value = $client->get('key');
Ruby (redis-rb)
require 'redis'
redis = Redis.new(
host: 'my-cache.my-project-abc123', # {service-name}.{namespace}
port: 6379,
password: ENV['REDIS_PASSWORD']
)
# Tester la connexion
redis.ping # => "PONG"
# Opérations de base
redis.set('key', 'value')
value = redis.get('key')
Configurer Votre Application
Variable d'Environnement
Ajoutez l'URL de connexion à votre conteneur (format : {service-name}.{namespace}) :
REDIS_URL=redis://default:[email protected]:6379
Ou des variables séparées :
REDIS_HOST=my-cache.my-project-abc123
REDIS_PORT=6379
REDIS_PASSWORD=votre-mot-de-passe
Intégration Framework
Sessions Express.js
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const Redis = require('ioredis');
const redisClient = new Redis(process.env.REDIS_URL);
app.use(session({
store: new RedisStore({ client: redisClient }),
secret: 'votre-secret',
resave: false,
saveUninitialized: false,
cookie: { secure: true, maxAge: 86400000 }
}));
Cache Django
# settings.py
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.redis.RedisCache',
'LOCATION': os.environ['REDIS_URL'],
}
}
Cache Laravel
// .env
CACHE_DRIVER=redis
REDIS_HOST=my-cache.my-project-abc123
REDIS_PASSWORD=votre-mot-de-passe
REDIS_PORT=6379
// config/database.php
'redis' => [
'client' => 'predis',
'default' => [
'host' => env('REDIS_HOST'),
'password' => env('REDIS_PASSWORD'),
'port' => env('REDIS_PORT'),
'database' => 0,
],
],
Cache Rails
# config/environments/production.rb
config.cache_store = :redis_cache_store, {
url: ENV['REDIS_URL'],
pool_size: 5,
pool_timeout: 5
}
Pooling de Connexions
Pourquoi Utiliser le Pooling ?
- Réduit la surcharge de connexion
- Améliore les performances
- Gère les échecs de connexion avec élégance
ioredis avec Pool
const Redis = require('ioredis');
// ioredis gère le pooling en interne
const redis = new Redis({
host: 'my-cache.my-project-abc123', // {service-name}.{namespace}
port: 6379,
password: process.env.REDIS_PASSWORD,
lazyConnect: true,
maxRetriesPerRequest: 3,
retryStrategy(times) {
return Math.min(times * 50, 2000);
}
});
Python avec Pool de Connexions
import redis
pool = redis.ConnectionPool(
host='my-cache.my-project-abc123', # {service-name}.{namespace}
port=6379,
password=os.environ['REDIS_PASSWORD'],
max_connections=10
)
r = redis.Redis(connection_pool=pool)
Dépannage
Connexion Refusée
- Vérifiez que le cache est en cours d'exécution
- Vérifiez le nom d'hôte et le port
- Assurez-vous que le conteneur est dans le même projet
Échec d'Authentification
NOAUTH Authentication required
- Vérifiez que le mot de passe est correct
- Copiez le mot de passe depuis l'onglet Connexion
Timeout de Connexion
- Vérifiez la connectivité réseau
- Vérifiez que le cache n'est pas surchargé
- Vérifiez les problèmes de pare-feu
Mémoire Pleine
OOM command not allowed when used memory > 'maxmemory'
- Passez à une instance plus grande
- Revoyez les politiques d'expiration
- Vérifiez les fuites mémoire
# Vérifier l'utilisation mémoire
redis-cli -h host -a password INFO memory
Bonnes Pratiques
1. Utiliser des Variables d'Environnement
Ne jamais coder en dur les mots de passe :
// Bon
const password = process.env.REDIS_PASSWORD;
// Mauvais
const password = 'mon-mot-de-passe-secret';
2. Gérer les Erreurs de Connexion
redis.on('error', (err) => {
console.error('Erreur Redis :', err);
});
redis.on('connect', () => {
console.log('Connecté à Redis');
});
3. Définir des Timeouts Raisonnables
const redis = new Redis({
connectTimeout: 5000,
commandTimeout: 5000,
...
});
4. Utiliser les Pipelines pour Commandes Multiples
// Lent - commandes individuelles
await redis.set('key1', 'value1');
await redis.set('key2', 'value2');
await redis.set('key3', 'value3');
// Rapide - pipeliné
const pipeline = redis.pipeline();
pipeline.set('key1', 'value1');
pipeline.set('key2', 'value2');
pipeline.set('key3', 'value3');
await pipeline.exec();