My most recent project has a few microservices in it and I wanted to report their job status to the UI. Since the microservices will be isolated from public access, I ended up creating an additional SignalR hub on my gateway app, which acts as the public entry point.

How does it work?

Each microservice in the isolated network has its own SignalR hub. Since a web client cannot connect to them, you just create a gateway hub in the gateway app using the library Microsoft.AspNetCore.SignalR.Client. Your Multiplexer class will then connect to each microservice’s hub and upon receiving a message from a microservice, will broadcast it using the gateway hub. Any web client will then just need to connect to the gateway hub to get real-time data from any of the microservice hubs.

Your gateway hub can be empty (though mine had some logging and a single method to get previous data):

public sealed class GatewayHub : Hub
{

}

Creating the multiplexer

The multiplexer is what handles the message relaying. It expects a collection of RelayedHubs which represent the microservices. Each RelayedHub has the microservice’s URL and the SignalR hub methods that will be broadcast.

public sealed record RelayedHub(string Url, HashSet<string> Methods);

public sealed class SignalRMultiplexer : BackgroundService
{
    /// <summary>
    /// <see cref="GatewayHub"/> context
    /// </summary>
    private readonly IHubContext<GatewayHub> _hubContext;

    /// <summary>
    /// The SignalR hubs that are being relayed by this <see cref="SignalRMultiplexer"/>
    /// </summary>
    private readonly HashSet<RelayedHub> _relayedHubs;

On your app startup, you can then connect to each of the relayed hubs:

private async Task ConnectHubs()
{
    foreach (var hub in _relayedHubs)
    {
        var exists = Connections.TryGetValue(hub, out var existingConnection);
        if (!exists || existingConnection == null)
        {
            var newConnection = BuildConnection(hub);
            Connections.AddOrUpdate(hub, newConnection, (_, _) => newConnection);
        }

        var connection = Connections[hub];

        // No action needed if already connected/connecting
        if (connection.State != HubConnectionState.Disconnected) continue;

        await Connect(connection, hub, isReconnect: false);
        _logger.LogInformation($"Hub connected: {hub.Url}");
    }
}

When you build your connection, you need to make sure to define what will happen when you receive a message from a relayed hub. In the example below, connection.On is what relays the message to the gateway hub.

private HubConnection BuildConnection(RelayedHub hub)
{
    var connectionBuilder = new HubConnectionBuilder()
        .WithUrl(hub.Url, options => { options.Transports = HttpTransportType.WebSockets; });

    var connection = connectionBuilder.Build();

    connection.Closed += async (e) =>
    {
        await connection.StartAsync();
    };

    // Setup listeners for the messages that will be relayed
    foreach (var method in hub.Methods)
    {
        connection.On<object>(method, async payload =>
        {
            // Relay the message
            await _hubContext.Clients.All.SendAsync(method, payload);
        });
    }

    return connection;
}

You can see my full implementation here. Some differences about the full implementation:

• Runs in a hosted service
• Has configurable retry policies and reconnection logic if a hub disconnects
• Exposes the last message sent for each relayed hub

Gotchas

I am used to writing SignalR clients in Javascript, so one place I got stuck was not realizing that the .NET client receives strongly-typed objects, not just strings.

I assumed that the gateway hub would just be receiving strings (eg, a serialized version of whatever was sent from the relayed hubs).

connection.On<string>(method, async payload =>
{
    // Relay the message
    await _hubContext.Clients.All.SendAsync(method, payload);
});

By specifying the expected type was a string, it was resulting in the connection.On method never being invoked since objects were actually being sent. So I instead changed it to:

connection.On<object>(method, async payload =>
{
    // Relay the message
    await _hubContext.Clients.All.SendAsync(method, payload);
});

By using object, it can encompass all types and the multiplexer’s intermediary responsibility won’t also need to include serialization/deserialization – it should just be a relay. In my case, the deserialization was handled in the Javascript client.