Scalabilità con Redis Backplane
Faccia scalare SignalR su più server usando un backplane Redis per sincronizzare i messaggi tra le istanze.
Scalabilità con Redis Backplane è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.
Il problema dei server multipli
Quando SignalR viene eseguito su un singolo server, client e server condividono la memoria per connessioni e gruppi. Se si scala a due o più server, ciascun server conosce solo le proprie connessioni: un messaggio inviato sul server A non raggiunge mai i client connessi al server B.
Che cos'è un backplane?
Un backplane è un bus di messaggi condiviso tra le istanze del server SignalR. Quando un server deve inviare un messaggio, lo pubblica nel backplane; tutti i server lo ricevono e lo inoltrano alle proprie connessioni locali.
Aggiunta del backplane Redis
Installi il pacchetto Microsoft.AspNetCore.SignalR.StackExchangeRedis e chiami AddStackExchangeRedis() dopo 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")!);Funzionamento di Redis Pub/Sub per SignalR
Ogni server SignalR si iscrive ai canali Redis. Quando il server A pubblica un messaggio per un gruppo o un utente, Redis lo distribuisce a tutti i sottoscrittori (server B, C…), che lo inoltrano quindi alle proprie connessioni locali.
// 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 themOpzioni di configurazione
Ottimizzi la connessione Redis per la produzione: TLS, password, resilienza della connessione e prefisso del canale pub/sub.
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
Per una scalabilità completamente gestita, utilizzi Azure SignalR Service. Funge da backplane e gestore delle connessioni: i server dell'applicazione diventano stateless e non gestiscono direttamente le connessioni 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 neededSessioni sticky (fallback per trasporti non WebSocket)
Quando si utilizzano Server-Sent Events o Long Polling (non WebSockets), lo stesso client deve sempre raggiungere lo stesso server: si parla di sticky sessions. Configuri questa funzionalità nel bilanciatore del carico o nel proxy inverso.
# 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 serverGruppi su più server
L'appartenenza ai gruppi viene gestita dal backplane. Aggiungere una connessione a un gruppo sul server A permette al server B di conoscerla tramite Redis, senza che ciò sia visibile al codice dell'applicazione.
// 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 distributionMonitoraggio di Redis Pub/Sub
Monitori i canali Redis per verificare il traffico SignalR e diagnosticare i problemi. Utilizzi redis-cli SUBSCRIBE o Redis Insights per osservare il flusso dei messaggi.
# 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"Gestione dei guasti di Redis
Se Redis diventa non disponibile, SignalR passa alla modalità solo locale: i messaggi non attraversano i server. Configuri criteri di ritentativo e avvisi per la connettività a 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);
});Caso reale: architettura di chat scalabile
In produzione, esegua almeno 3 istanze del server SignalR dietro un bilanciatore del carico, con Redis (o Azure SignalR Service) come backplane. Tutto lo stato risiede in Redis; i server sono stateless e possono essere sostituiti o rimossi.
// 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=3Verifica rapida
Quale problema risolve un backplane SignalR?
Riepilogo: scalabilità con il backplane Redis
Concetti chiave:
- Senza un backplane, i messaggi provenienti da un server non raggiungono i client sugli altri server
- AddStackExchangeRedis() aggiunge in modo trasparente un backplane Redis pub/sub
- Azure SignalR Service fornisce un'alternativa serverless e completamente gestita al backplane
- Le sessioni sticky sono necessarie per i trasporti non WebSocket (SSE, Long Polling)
- L'appartenenza ai gruppi viene sincronizzata tra i server tramite il backplane
- Configuri AbortOnConnectFail=false e criteri di ritentativo per garantire la resilienza di Redis
Domande Frequenti
La lezione «Scalabilità con Redis Backplane» è gratuita?
Sì — il testo completo di «Scalabilità con Redis Backplane» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.
Cosa imparerò in «Scalabilità con Redis Backplane»?
Faccia scalare SignalR su più server usando un backplane Redis per sincronizzare i messaggi tra le istanze. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare C# Academy?
Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Scalabilità con Redis Backplane»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione C# Academy?
Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Hub e connessioni SignalR
- Gruppi, utenti e gestione delle connessioni
- Hub fortemente tipizzati
- Scalabilità con Redis Backplane