0Pricing
C# Academy · Leçon

Mise à l’échelle avec un relais Redis

Mettez SignalR à l’échelle sur plusieurs serveurs avec un relais Redis afin de synchroniser les messages entre les instances.

Mise à l’échelle avec un relais Redis est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Le problème des serveurs multiples

Lorsque SignalR s’exécute sur un seul serveur, les clients et le serveur partagent la mémoire des connexions et des groupes. Si vous passez à deux serveurs ou plus, chaque serveur ne connaît que ses propres connexions : un message envoyé sur le serveur A n’atteint jamais les clients connectés au serveur B.

Qu’est-ce qu’un bus intermédiaire ?

Un bus intermédiaire est un bus de messages partagé entre les instances de serveur SignalR. Lorsqu’un serveur veut envoyer un message, il le publie sur le bus intermédiaire ; tous les serveurs le reçoivent et le transmettent à leurs connexions locales.

Ajout du bus intermédiaire Redis

Installez le package Microsoft.AspNetCore.SignalR.StackExchangeRedis et appelez AddStackExchangeRedis() après AddSignalR().

// dotnet add package Microsoft.AspNetCore.SignalR.StackExchangeRedis

builder.Services.AddSignalR()
    .AddStackExchangeRedis("localhost:6379", options =>
    {
        options.Configuration.ChannelPrefix =
            RedisChannel.Literal("myapp"); // namespace your channels
    });

// Or from config:
// .AddStackExchangeRedis(builder.Configuration.GetConnectionString("Redis")!);

Fonctionnement de la publication et de l’abonnement Redis pour SignalR

Chaque serveur SignalR s’abonne aux canaux Redis. Lorsque le serveur A publie un message destiné à un groupe ou à un utilisateur, Redis le transmet à tous les abonnés (serveurs B, C, etc.), qui le transmettent ensuite à leurs connexions locales.

// Server A: client sends message
// Hub on Server A calls:
await Clients.Group("room-42").ReceiveMessage(user, msg);

// Internally SignalR publishes to Redis:
// PUBLISH signalr/myapp/group/room-42 <serialized message>

// Redis delivers to Server B and C
// Both servers find connections in "room-42" and push to them

Options de configuration

Affinez la connexion Redis pour la production : TLS, mot de passe, résilience de la connexion et préfixe des canaux de publication et d’abonnement.

builder.Services.AddSignalR()
    .AddStackExchangeRedis(opts =>
    {
        opts.Configuration = ConfigurationOptions.Parse(
            builder.Configuration["Redis:ConnectionString"]!);
        opts.Configuration.Password      = builder.Configuration["Redis:Password"];
        opts.Configuration.Ssl           = true;
        opts.Configuration.AbortOnConnectFail = false;
        opts.Configuration.ConnectRetry  = 3;
    });

Azure SignalR Service

Pour une mise à l’échelle entièrement gérée, utilisez Azure SignalR Service. Il fait office de bus intermédiaire et de gestionnaire de connexions : vos serveurs d’application deviennent sans état et ne gèrent pas eux-mêmes les connexions WebSocket.

// dotnet add package Microsoft.Azure.SignalR

builder.Services.AddSignalR()
    .AddAzureSignalR(builder.Configuration["Azure:SignalR:ConnectionString"]!);

// That's it — Azure manages all connections and backplane
// Your server scales to zero when not needed

Sessions persistantes (solution de repli pour les transports autres que WebSocket)

Lorsque vous utilisez les événements envoyés par le serveur ou l’interrogation longue (et non WebSockets), le même client doit toujours contacter le même serveur : on parle de sessions persistantes. Configurez ce comportement dans votre répartiteur de charge ou votre proxy inverse.

# Nginx: sticky session config (IP hash)
upstream signalr_servers {
    ip_hash; # ensures same client hits same server
    server server1:5000;
    server server2:5000;
    server server3:5000;
}

# Or use cookie-based sticky sessions:
# sticky cookie srv_id expires=1h;

# WebSockets don't need sticky sessions —
# the connection is long-lived on one server

Groupes sur plusieurs serveurs

L’appartenance aux groupes est gérée par le bus intermédiaire. Ajouter une connexion à un groupe sur le serveur A permet au serveur B de le savoir via Redis, sans que le code de l’application ait besoin de le gérer.

// This works correctly across servers:
public async Task JoinRoom(string room)
{
    // Adds to Redis-backed group
    await Groups.AddToGroupAsync(Context.ConnectionId, room);

    // Clients.Group sends via Redis to all servers
    await Clients.Group(room).UserJoined(Context.User!.Identity!.Name!);
}
// No code changes needed — the Redis backplane handles distribution

Surveillance de la publication et de l’abonnement Redis

Surveillez les canaux Redis pour vérifier le trafic SignalR et diagnostiquer les problèmes. Utilisez redis-cli SUBSCRIBE ou Redis Insights pour observer le flux des messages.

# redis-cli: monitor all SignalR channels
redis-cli PSUBSCRIBE "myapp*"

# Check active channel subscribers
redis-cli PUBSUB CHANNELS "myapp*"

# Check number of subscribers per channel
redis-cli PUBSUB NUMSUB "myapp/all"

Gestion des défaillances de Redis

Si Redis devient indisponible, SignalR passe en mode local uniquement : les messages ne traversent plus les serveurs. Configurez des stratégies de nouvelle tentative et des alertes pour surveiller la connectivité Redis.

builder.Services.AddSignalR()
    .AddStackExchangeRedis(opts =>
    {
        opts.Configuration = ConfigurationOptions.Parse(redisConn);
        opts.Configuration.AbortOnConnectFail = false; // don't crash app
        opts.Configuration.ConnectRetry       = 5;
        opts.Configuration.ReconnectRetryPolicy =
            new ExponentialRetry(5000, maxDeltaBackoffMilliseconds: 60000);
    });

Cas concret : architecture de discussion mise à l’échelle

En production, exécutez au moins trois instances de serveur SignalR derrière un répartiteur de charge, avec Redis (ou Azure SignalR Service) comme bus intermédiaire. Tout l’état est stocké dans Redis ; les serveurs sont sans état et peuvent être remplacés à tout moment.

// Architecture:
// [Browser] -> [Load Balancer (any server, WebSocket)] ->
//   [SignalR Server 1] -+
//   [SignalR Server 2] -+-> [Redis Pub/Sub] -> all servers
//   [SignalR Server 3] -+

// Server code is identical on all instances:
builder.Services.AddSignalR().AddStackExchangeRedis(redisConn);
app.MapHub<ChatHub>("/hubs/chat");
// Scale replicas: kubectl scale deployment chat --replicas=3

Vérification rapide

Quel problème un bus intermédiaire SignalR permet-il de résoudre ?

Récapitulatif : mise à l’échelle avec le bus intermédiaire Redis

À retenir :

  • Sans bus intermédiaire, les messages d’un serveur n’atteignent pas les clients des autres serveurs
  • AddStackExchangeRedis() ajoute de manière transparente un bus intermédiaire Redis fondé sur la publication et l’abonnement
  • Azure SignalR Service fournit une solution de bus intermédiaire sans serveur et entièrement gérée
  • Les sessions persistantes sont nécessaires pour les transports autres que WebSocket (SSE, interrogation longue)
  • L’appartenance aux groupes est synchronisée entre les serveurs via le bus intermédiaire
  • Configurez AbortOnConnectFail=false et des stratégies de nouvelle tentative pour assurer la résilience de Redis

Questions Fréquemment Posées

La leçon « Mise à l’échelle avec un relais Redis » est-elle gratuite ?

Oui — le texte complet de « Mise à l’échelle avec un relais Redis » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Mise à l’échelle avec un relais Redis » ?

Mettez SignalR à l’échelle sur plusieurs serveurs avec un relais Redis afin de synchroniser les messages entre les instances. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Mise à l’échelle avec un relais Redis » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Hubs et connexions SignalR
  2. Groupes, utilisateurs et gestion des connexions
  3. Hubs fortement typés
  4. Mise à l’échelle avec un relais Redis
← Retour à C# Academy