0Pricing
C# Academy · Lektion

Skalierung mit Redis-Backplane

Skalieren Sie SignalR über mehrere Server mit einer Redis-Backplane, um Nachrichten zwischen Instanzen zu synchronisieren.

Skalierung mit Redis-Backplane ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Das Problem mit mehreren Servern

Wenn SignalR auf einem einzelnen Server ausgeführt wird, teilen sich Clients und Server den Speicher für Verbindungen und Gruppen. Bei der Skalierung auf zwei oder mehr Server kennt jeder Server nur seine eigenen Verbindungen – eine auf Server A gesendete Nachricht erreicht die mit Server B verbundenen Clients nie.

Was ist ein Backplane?

Ein Backplane ist ein gemeinsam genutzter Nachrichtenbus zwischen SignalR-Serverinstanzen. Wenn ein Server eine Nachricht senden möchte, veröffentlicht er sie im Backplane. Alle Server empfangen sie und leiten sie an ihre lokalen Verbindungen weiter.

Das Redis-Backplane hinzufügen

Installieren Sie das Paket Microsoft.AspNetCore.SignalR.StackExchangeRedis und rufen Sie nach AddSignalR() AddStackExchangeRedis() auf.

// 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")!);

So funktioniert Redis Pub/Sub für SignalR

Jeder SignalR-Server abonniert Redis-Kanäle. Wenn Server A eine Nachricht für eine Gruppe oder einen Benutzer veröffentlicht, stellt Redis sie allen Abonnenten (Server B, C …) zu, die sie anschließend an ihre lokalen Verbindungen weiterleiten.

// 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

Konfigurationsoptionen

Stimmen Sie die Redis-Verbindung für den Produktionseinsatz genau ab: TLS, Passwort, Verbindungsstabilität und Präfix des Pub/Sub-Kanals.

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

Für eine vollständig verwaltete Skalierung verwenden Sie Azure SignalR Service. Der Dienst fungiert als Backplane und Verbindungsmanager – Ihre Anwendungsserver werden zustandslos und halten selbst keine WebSocket-Verbindungen.

// 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

Sticky Sessions (Fallback für Transporte ohne WebSockets)

Bei Server-Sent Events oder Long Polling (nicht bei WebSockets) muss derselbe Client immer denselben Server erreichen – dies wird als Sticky Sessions bezeichnet. Konfigurieren Sie dies in Ihrem Load Balancer oder Reverse Proxy.

# 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

Gruppen über mehrere Server hinweg

Die Gruppenmitgliedschaft wird vom Backplane verwaltet. Wenn eine Verbindung auf Server A einer Gruppe hinzugefügt wird, erfährt Server B dies über Redis – für den Anwendungscode geschieht dies transparent.

// 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

Redis Pub/Sub überwachen

Überwachen Sie die Redis-Kanäle, um den SignalR-Datenverkehr zu überprüfen und Probleme zu diagnostizieren. Verwenden Sie redis-cli SUBSCRIBE oder Redis Insights, um den Nachrichtenfluss zu beobachten.

# 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"

Redis-Ausfälle behandeln

Wenn Redis nicht verfügbar ist, wechselt SignalR in den lokalen Modus – Nachrichten werden nicht zwischen Servern übertragen. Konfigurieren Sie Wiederholungsrichtlinien und Benachrichtigungen für die Redis-Konnektivität.

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);
    });

Praxisbeispiel: Skalierbare Chat-Architektur

Betreiben Sie in der Produktion mindestens drei SignalR-Serverinstanzen hinter einem Load Balancer, mit Redis (oder Azure SignalR Service) als Backplane. Der gesamte Zustand liegt in Redis; die Server sind zustandslos und können jederzeit ersetzt werden.

// 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

Kurze Überprüfung

Welches Problem löst ein SignalR-Backplane?

Zusammenfassung: Skalierung mit einem Redis-Backplane

Wichtigste Erkenntnisse:

  • Ohne Backplane erreichen Nachrichten von einem Server keine Clients auf anderen Servern
  • AddStackExchangeRedis() fügt transparent ein Redis-Pub/Sub-Backplane hinzu
  • Azure SignalR Service bietet eine vollständig verwaltete, serverlose Backplane-Alternative
  • Für Transporte ohne WebSockets (SSE, Long Polling) sind Sticky Sessions erforderlich
  • Die Gruppenmitgliedschaft wird über das Backplane zwischen den Servern synchronisiert
  • Konfigurieren Sie AbortOnConnectFail=false und Wiederholungsrichtlinien für eine stabile Redis-Verbindung

Häufig gestellte Fragen

Ist die Lektion „Skalierung mit Redis-Backplane“ kostenlos?

Ja — der vollständige Text von „Skalierung mit Redis-Backplane“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Skalierung mit Redis-Backplane“?

Skalieren Sie SignalR über mehrere Server mit einer Redis-Backplane, um Nachrichten zwischen Instanzen zu synchronisieren. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Skalierung mit Redis-Backplane“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. SignalR-Hubs und Verbindungen
  2. Gruppen, Benutzer und Verbindungsverwaltung
  3. Typsichere Hubs
  4. Skalierung mit Redis-Backplane
← Zurück zu C# Academy