Aller au contenu principal

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​

  1. Sélectionnez votre projet dans le sélecteur de projet
  2. Cliquez sur Cache dans la barre latérale
  3. 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
Nommage

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 :

VersionRecommandation
9.0Version actuellement supportée
Version

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 :

ShardsDescription
1Shard unique, usage développement
2-3Petits clusters de production
4-6Grands clusters de production
La taille du cluster est permanente

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 est permanente

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.

Dimensionnement du Cluster
  • 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.

ClasseRatio CPU:RAMCPU MaxRAM MaxDescription
Eco1:23 cores6 GoDéveloppement et tests
Standard1:415 cores58 GoProduction générale
Production1:46 cores28 GoProduction 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
Conseil de Dimensionnement

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 1Gi par shard (ou 10Gi lorsque 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) ou performance (15 000 IOPS) — par défaut standard
  • Le stockage peut être augmenté ultérieurement sans interruption, mais ne peut pas être réduit
La classe de stockage est permanente

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 :

  1. Activez Accès Public
  2. Ajoutez les plages CIDR à la liste autorisée, avec une note optionnelle par entrée pour identifier son usage
  3. Seules les IPs listées peuvent se connecter depuis l'extérieur de votre projet
Prérequis Accès Public
  • 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​

  1. Vérifiez votre configuration
  2. Cliquez sur Créer
  3. Attendez le provisionnement (~15 secondes)

Après la Création​

Voir les Détails de Connexion​

  1. Allez sur votre instance de cache
  2. Cliquez sur l'onglet Connexion
  3. 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();

Prochaines Étapes​