Ridimensionare il servizio SignalR con più istanze

Per ASP.NET Core

Aggiungere più endpoint dalla configurazione

Configurare con la chiave Azure:SignalR:ConnectionString o Azure:SignalR:ConnectionString: per la stringa di connessione del servizio SignalR.

Se la chiave inizia con Azure:SignalR:ConnectionString:, deve essere nel formato Azure:SignalR:ConnectionString:{Name}:{EndpointType}, dove Name e EndpointType sono proprietà dell'oggetto ServiceEndpoint e sono accessibili dal codice.

È possibile aggiungere più stringhe di connessione dell'istanza usando i comandi dotnet seguenti:

dotnet user-secrets set Azure:SignalR:ConnectionString:east-region-a <ConnectionString1>
dotnet user-secrets set Azure:SignalR:ConnectionString:east-region-b:primary <ConnectionString2>
dotnet user-secrets set Azure:SignalR:ConnectionString:backup:secondary <ConnectionString3>

Aggiungere più endpoint dal codice

Una classe ServiceEndpoint descrive le proprietà di un endpoint del servizio Azure SignalR. È possibile configurare più endpoint di istanza quando si usa Azure SignalR Service SDK tramite:

services.AddSignalR()
        .AddAzureSignalR(options =>
        {
            options.Endpoints = new ServiceEndpoint[]
            {
                // Note: this is just a demonstration of how to set options.Endpoints
                // Having ConnectionStrings explicitly set inside the code is not encouraged
                // You can fetch it from a safe place such as Azure KeyVault
                new ServiceEndpoint("<ConnectionString0>"),
                new ServiceEndpoint("<ConnectionString1>", type: EndpointType.Primary, name: "east-region-a"),
                new ServiceEndpoint("<ConnectionString2>", type: EndpointType.Primary, name: "east-region-b"),
                new ServiceEndpoint("<ConnectionString3>", type: EndpointType.Secondary, name: "backup"),
            };
        });

Personalizzare il router endpoint

Per impostazione predefinita, l'SDK usa DefaultEndpointRouter per prelevare gli endpoint.

Comportamento predefinito

1. Routing delle richieste client:

   Quando il client /negotiate con il server app. Per impostazione predefinita, l'SDK seleziona in modo casuale un endpoint dal set di endpoint di servizio disponibili.

2. Routing dei messaggi del server:

   Quando si invia un messaggio a una connessione specifica e la connessione di destinazione viene instradata al server corrente, il messaggio passa direttamente all'endpoint connesso. In caso contrario, i messaggi vengono trasmessi a ogni endpoint di Azure SignalR.

Personalizzare l'algoritmo di routing

È possibile creare un router personalizzato quando si hanno conoscenze speciali per identificare gli endpoint a cui devono essere inviati i messaggi.

L'esempio seguente definisce un router personalizzato che instrada i messaggi con un gruppo che inizia con east- dall'endpoint denominato east:

private class CustomRouter : EndpointRouterDecorator
{
    public override IEnumerable<ServiceEndpoint> GetEndpointsForGroup(string groupName, IEnumerable<ServiceEndpoint> endpoints)
    {
        // Override the group broadcast behavior, if the group name starts with "east-", only send messages to endpoints inside east
        if (groupName.StartsWith("east-"))
        {
            return endpoints.Where(e => e.Name.StartsWith("east-"));
        }

        return base.GetEndpointsForGroup(groupName, endpoints);
    }
}

Nell'esempio seguente viene eseguito l'override del comportamento di negoziazione predefinito e viene selezionato l'endpoint a seconda del percorso del server app.

private class CustomRouter : EndpointRouterDecorator
{    public override ServiceEndpoint GetNegotiateEndpoint(HttpContext context, IEnumerable<ServiceEndpoint> endpoints)
    {
        // Override the negotiate behavior to get the endpoint from query string
        var endpointName = context.Request.Query["endpoint"];
        if (endpointName.Count == 0)
        {
            context.Response.StatusCode = 400;
            var response = Encoding.UTF8.GetBytes("Invalid request");
            context.Response.Body.Write(response, 0, response.Length);
            return null;
        }

        return endpoints.FirstOrDefault(s => s.Name == endpointName && s.Online) // Get the endpoint with name matching the incoming request
               ?? base.GetNegotiateEndpoint(context, endpoints); // Or fallback to the default behavior to randomly select one from primary endpoints, or fallback to secondary when no primary ones are online
    }
}

Non dimenticare di registrare il router nel contenitore di inserimento delle dipendenze usando:

services.AddSingleton(typeof(IEndpointRouter), typeof(CustomRouter));
services.AddSignalR()
        .AddAzureSignalR(
            options =>
            {
                options.Endpoints = new ServiceEndpoint[]
                {
                    new ServiceEndpoint(name: "east", connectionString: "<connectionString1>"),
                    new ServiceEndpoint(name: "west", connectionString: "<connectionString2>"),
                    new ServiceEndpoint("<connectionString3>")
                };
            });

Per ASP.NET

Aggiungere più endpoint dalla configurazione

Configurazione con chiave Azure:SignalR:ConnectionString o Azure:SignalR:ConnectionString: per la stringa di connessione del servizio SignalR.

Se la chiave inizia con Azure:SignalR:ConnectionString:, deve essere nel formato Azure:SignalR:ConnectionString:{Name}:{EndpointType}, dove Name e EndpointType sono proprietà dell'oggetto ServiceEndpoint e sono accessibili dal codice.

È possibile aggiungere più stringhe di connessione dell'istanza a web.config:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <connectionStrings>
    <add name="Azure:SignalR:ConnectionString" connectionString="<ConnectionString1>"/>
    <add name="Azure:SignalR:ConnectionString:en-us" connectionString="<ConnectionString2>"/>
    <add name="Azure:SignalR:ConnectionString:zh-cn:secondary" connectionString="<ConnectionString3>"/>
    <add name="Azure:SignalR:ConnectionString:Backup:secondary" connectionString="<ConnectionString4>"/>
  </connectionStrings>
  ...
</configuration>

Aggiungere più endpoint dal codice

Una classe ServiceEndpoint descrive le proprietà di un endpoint del servizio Azure SignalR. È possibile configurare più endpoint di istanza quando si usa Azure SignalR Service SDK tramite:

app.MapAzureSignalR(
    this.GetType().FullName,
    options => {
            options.Endpoints = new ServiceEndpoint[]
            {
                // Note: this is just a demonstration of how to set options. Endpoints
                // Having ConnectionStrings explicitly set inside the code is not encouraged.
                // You can fetch it from a safe place such as Azure KeyVault
                new ServiceEndpoint("<ConnectionString1>"),
                new ServiceEndpoint("<ConnectionString2>"),
                new ServiceEndpoint("<ConnectionString3>"),
            }
        });

Personalizzare un router

L'unica differenza tra ASP.NET SignalR e ASP.NET Core SignalR è il tipo di contesto http per GetNegotiateEndpoint. Per ASP.NET SignalR, è di tipo IOwinContext.

Il codice seguente è un esempio di negoziazione personalizzato per ASP.NET SignalR:

private class CustomRouter : EndpointRouterDecorator
{
    public override ServiceEndpoint GetNegotiateEndpoint(IOwinContext context, IEnumerable<ServiceEndpoint> endpoints)
    {
        // Override the negotiate behavior to get the endpoint from query string
        var endpointName = context.Request.Query["endpoint"];
        if (string.IsNullOrEmpty(endpointName))
        {
            context.Response.StatusCode = 400;
            context.Response.Write("Invalid request.");
            return null;
        }

        return endpoints.FirstOrDefault(s => s.Name == endpointName && s.Online) // Get the endpoint with name matching the incoming request
               ?? base.GetNegotiateEndpoint(context, endpoints); // Or fallback to the default behavior to randomly select one from primary endpoints, or fallback to secondary when no primary ones are online
    }
}

Non dimenticare di registrare il router nel contenitore di inserimento delle dipendenze usando:

var hub = new HubConfiguration();
var router = new CustomRouter();
hub.Resolver.Register(typeof(IEndpointRouter), () => router);
app.MapAzureSignalR(GetType().FullName, hub, options => {
    options.Endpoints = new ServiceEndpoint[]
                {
                    new ServiceEndpoint(name: "east", connectionString: "<connectionString1>"),
                    new ServiceEndpoint(name: "west", connectionString: "<connectionString2>"),
                    new ServiceEndpoint("<connectionString3>")
                };
});

Metriche degli endpoint di servizio

Per abilitare un router avanzato, SignalR SERVER SDK fornisce più metriche per consentire al server di prendere decisioni intelligenti. Le proprietà sono in ServiceEndpoint.EndpointMetrics.

Il codice seguente è un esempio di personalizzazione di un router in base a ClientConnectionCount.

private class CustomRouter : EndpointRouterDecorator
{
    public override ServiceEndpoint GetNegotiateEndpoint(HttpContext context, IEnumerable<ServiceEndpoint> endpoints)
    {
        return endpoints.OrderBy(x => x.EndpointMetrics.ClientConnectionCount).FirstOrDefault(x => x.Online) // Get the available endpoint with minimal clients load
               ?? base.GetNegotiateEndpoint(context, endpoints); // Or fallback to the default behavior to randomly select one from primary endpoints, or fallback to secondary when no primary ones are online
    }
}

Scalabilità dinamica ServiceEndpoints

A partire dall'SDK versione 1.5.0, è possibile abilitare ServiceEndpoints con scalabilità dinamica per ASP.NET versione Core. Non è quindi necessario riavviare il server app quando è necessario aggiungere/rimuovere un ServiceEndpoint. Poiché ASP.NET Core supporta una configurazione predefinita come appsettings.json con reloadOnChange: true, non è necessario modificare il codice ed è supportato per natura. Se si vuole aggiungere una configurazione personalizzata e usare il ricaricamento rapido, vedere Configurazione in ASP.NET Core.

Per le estensioni di Funzioni SignalR

Impostazione

Per abilitare più istanze del servizio SignalR, è necessario:

1. Usare il tipo di trasporto Persistent.

   Il tipo di trasporto predefinito è modalità Transient. È necessario aggiungere la voce seguente al file local.settings.json o all'impostazione dell'applicazione in Azure.

   {
       "AzureSignalRServiceTransportType":"Persistent"
   }
   

   Nota

   Quando si passa dalla modalità Transient alla modalità Persistent, potrebbe verificarsi una modifica del comportamento di serializzazione JSON, perché in modalità Transient viene usata la libreria Newtonsoft.Json per serializzare gli argomenti dei metodi hub, tuttavia, in modalità Persistent, la libreria System.Text.Json viene usata come predefinita. System.Text.Json presenta alcune differenze principali nel comportamento predefinito con Newtonsoft.Json. Se si vuole usare Newtonsoft.Json in modalità Persistent, è possibile aggiungere un elemento di configurazione: "Azure:SignalR:HubProtocol":"NewtonsoftJson" nel file local.settings.json o Azure__SignalR__HubProtocol=NewtonsoftJson nel portale di Azure.

2. Configurare più voci degli endpoint del servizio SignalR nella configurazione.

   Viene usato un oggetto ServiceEndpoint per rappresentare un'istanza del servizio SignalR. È possibile definire un endpoint di servizio con il relativo <EndpointName> e <EndpointType> nella chiave di immissione e la stringa di connessione nel valore della voce. Le chiavi sono nel formato seguente:

   Azure:SignalR:Endpoints:<EndpointName>:<EndpointType>
   

   <EndpointType> è facoltativo e il valore predefinito è primary. Vedere gli esempi seguenti:

   {
       "Azure:SignalR:Endpoints:EastUs":"<ConnectionString>",
   
       "Azure:SignalR:Endpoints:EastUs2:Secondary":"<ConnectionString>",
   
       "Azure:SignalR:Endpoints:WestUs:Primary":"<ConnectionString>"
   }
   

   Nota

   • Quando si configurano gli endpoint di Azure SignalR nel servizio app nel portale di Azure, non dimenticare di sostituire ":" con "__", il doppio carattere di sottolineatura nelle chiavi. Per sapere perché, vedere Variabili di ambiente.

   • La stringa di connessione configurata con la chiave {ConnectionStringSetting} (l'impostazione predefinita è "AzureSignalRConnectionString") viene riconosciuta anche come endpoint di servizio primario con nome vuoto. Questo stile di configurazione non è tuttavia consigliato per più endpoint.

Routing

Comportamento predefinito

Per impostazione predefinita, l'associazione di funzioni usa DefaultEndpointRouter per prelevare gli endpoint.

• Routing client: selezionare in modo casuale un endpoint dagli endpoint online primari. Se tutti gli endpoint primari sono offline, selezionare in modo casuale un endpoint online secondario. Se la selezione ha esito negativo, viene generata un'eccezione.

• Routing dei messaggi del server: vengono restituiti tutti gli endpoint di servizio.

Personalizzazione

C# modello in-process

Di seguito sono riportati i passaggi necessari:

1. Implementare un router personalizzato. È possibile sfruttare le informazioni fornite da ServiceEndpoint per prendere decisioni di routing. Vedere la guida qui: customize-route-algorithm. Si noti che il trigger Http è necessario nella funzione di negoziazione quando è necessario HttpContext nel metodo di negoziazione personalizzato.

2. Registrare il router nel contenitore di inserimento delle dipendenze.

using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Azure.SignalR;
using Microsoft.Extensions.DependencyInjection;

[assembly: FunctionsStartup(typeof(SimpleChatV3.Startup))]
namespace SimpleChatV3
{
    public class Startup : FunctionsStartup
    {
        public override void Configure(IFunctionsHostBuilder builder)
        {
            builder.Services.AddSingleton<IEndpointRouter, CustomizedRouter>();
        }
    }
}

C# modello processo isolato

Per le funzioni in esecuzione in un modello di processo isolato, è supportato specificare gli endpoint di destinazione in ogni richiesta. Si useranno nuovi tipi di associazione per ottenere informazioni sull'endpoint.

Routing del client

L'associazione SignalRConnectionInfo seleziona un endpoint in base alla regola di gestione predefinita. Se si vuole personalizzare la regola di gestione, è consigliabile usare l'associazione SignalRNegotiation anziché l'associazione SignalRConnectionInfo.

Le proprietà di configurazione dell'associazione SignalRNegotiation sono uguali a SignalRConnectionInfo. Ecco un esempio di filefunction.json :

{
    "type": "signalRNegotiation",
    "name": "negotiationContext",
    "hubName": "<HubName>",
    "direction": "in"
}

È anche possibile aggiungere altri dati di associazione, ad esempio userId, idToken e claimTypeList, proprio come SignalRConnectionInfo.

L'oggetto ottenuto dall'associazione SignalRNegotiation è nel formato seguente:

{
    "endpoints": [
        {
            "endpointType": "Primary",
            "name": "<EndpointName>",
            "endpoint": "https://****.service.signalr.net",
            "online": true,
            "connectionInfo": {
                "url": "<client-access-url>",
                "accessToken": "<client-access-token>"
            }
        },
        {
            "...": "..."
        }
    ]
}

Ecco un esempio di utilizzo di JavaScript per l'associazione SignalRNegotiation:

module.exports = function (context, req, negotiationContext) {
    var userId = req.query.userId;
    if (userId.startsWith("east-")) {
        //return the first endpoint whose name starts with "east-" and status is online.
        context.res.body = negotiationContext.endpoints.find(endpoint => endpoint.name.startsWith("east-") && endpoint.online).connectionInfo;
    }
    else {
        //return the first online endpoint
        context.res.body = negotiationContext.endpoints.filter(endpoint => endpoint.online)[0].connectionInfo;
    }
}

Routing dei messaggi

Per collaborare, il routing di messaggi o azioni richiede due tipi di associazione. In generale, prima di tutto è necessario un nuovo tipo di associazione di input SignalREndpoints per ottenere tutte le informazioni sull'endpoint disponibili. Si filtrano quindi gli endpoint e si ottiene una matrice contenente tutti gli endpoint a cui si vuole inviare. Infine, si specificano gli endpoint di destinazione nell'associazione di output SignalR.

Ecco le proprietà di configurazione dell'associazione SignalREndpoints nel file functions.json:

{
      "type": "signalREndpoints",
      "direction": "in",
      "name": "endpoints",
      "hubName": "<HubName>"
}

L'oggetto ottenuto da SignalREndpoints è una matrice di endpoint ognuno dei quali è rappresentato come oggetto JSON con lo schema seguente:

{
    "endpointType": "<EndpointType>",
    "name": "<EndpointName>",
    "endpoint": "https://****.service.signalr.net",
    "online": true
}

Dopo aver visualizzato la matrice di endpoint di destinazione, aggiungere una proprietà endpoints all'oggetto di associazione di output. Questo è un esempio JavaScript:

module.exports = function (context, req, endpoints) {
    var targetEndpoints = endpoints.filter(endpoint => endpoint.name.startsWith("east-"));
    context.bindings.signalRMessages = [{
        "target": "chat",
        "arguments": ["hello-world"],
        "endpoints": targetEndpoints,
    }];
    context.done();
}

Per SDK .NET Management

Aggiungere più endpoint dalla configurazione

Configurare con la chiave Azure:SignalR:Endpoints per la stringa di connessione del servizio SignalR. La chiave deve essere nel formato Azure:SignalR:Endpoints:{Name}:{EndpointType}, dove Name e EndpointType sono proprietà dell'oggetto ServiceEndpoint e sono accessibili dal codice.

È possibile aggiungere più stringhe di connessione dell'istanza usando i comandi dotnet seguenti:

dotnet user-secrets set Azure:SignalR:Endpoints:east-region-a <ConnectionString1>
dotnet user-secrets set Azure:SignalR:Endpoints:east-region-b:primary <ConnectionString2>
dotnet user-secrets set Azure:SignalR:Endpoints:backup:secondary <ConnectionString3>

Aggiungere più endpoint dal codice

Una classe ServiceEndpoint descrive le proprietà di un endpoint del servizio Azure SignalR. È possibile configurare più endpoint di istanza quando si usa Azure SignalR Management SDK tramite:

var serviceManager = new ServiceManagerBuilder()
                    .WithOptions(option =>
                    {
                        options.Endpoints = new ServiceEndpoint[]
                        {
                            // Note: this is just a demonstration of how to set options.Endpoints
                            // Having ConnectionStrings explicitly set inside the code is not encouraged
                            // You can fetch it from a safe place such as Azure KeyVault
                            new ServiceEndpoint("<ConnectionString0>"),
                            new ServiceEndpoint("<ConnectionString1>", type: EndpointType.Primary, name: "east-region-a"),
                            new ServiceEndpoint("<ConnectionString2>", type: EndpointType.Primary, name: "east-region-b"),
                            new ServiceEndpoint("<ConnectionString3>", type: EndpointType.Secondary, name: "backup"),
                        };
                    })
                    .BuildServiceManager();

Personalizzare il router endpoint

Per impostazione predefinita, l'SDK usa DefaultEndpointRouter per prelevare gli endpoint.

Comportamento predefinito

• Routing delle richieste client:

  Quando il client /negotiate con il server app. Per impostazione predefinita, l'SDK seleziona in modo casuale un endpoint dal set di endpoint di servizio disponibili.

• Routing dei messaggi del server:

  Quando si invia un messaggio a una connessione specifica e la connessione di destinazione viene instradata al server corrente, il messaggio passa direttamente all'endpoint connesso. In caso contrario, i messaggi vengono trasmessi a ogni endpoint di Azure SignalR.

Personalizzare l'algoritmo di routing

È possibile creare un router personalizzato quando si hanno conoscenze speciali per identificare gli endpoint a cui devono essere inviati i messaggi.

L'esempio seguente definisce un router personalizzato che instrada i messaggi con un gruppo che inizia con east- dall'endpoint denominato east:

private class CustomRouter : EndpointRouterDecorator
{
    public override IEnumerable<ServiceEndpoint> GetEndpointsForGroup(string groupName, IEnumerable<ServiceEndpoint> endpoints)
    {
        // Override the group broadcast behavior, if the group name starts with "east-", only send messages to endpoints inside east
        if (groupName.StartsWith("east-"))
        {
            return endpoints.Where(e => e.Name.StartsWith("east-"));
        }

        return base.GetEndpointsForGroup(groupName, endpoints);
    }
}

Nell'esempio seguente viene eseguito l'override del comportamento di negoziazione predefinito e viene selezionato l'endpoint a seconda del percorso del server app.

private class CustomRouter : EndpointRouterDecorator
{    public override ServiceEndpoint GetNegotiateEndpoint(HttpContext context, IEnumerable<ServiceEndpoint> endpoints)
    {
        // Override the negotiate behavior to get the endpoint from query string
        var endpointName = context.Request.Query["endpoint"];
        if (endpointName.Count == 0)
        {
            context.Response.StatusCode = 400;
            var response = Encoding.UTF8.GetBytes("Invalid request");
            context.Response.Body.Write(response, 0, response.Length);
            return null;
        }

        return endpoints.FirstOrDefault(s => s.Name == endpointName && s.Online) // Get the endpoint with name matching the incoming request
               ?? base.GetNegotiateEndpoint(context, endpoints); // Or fallback to the default behavior to randomly select one from primary endpoints, or fallback to secondary when no primary ones are online
    }
}

Non dimenticare di registrare il router nel contenitore di inserimento delle dipendenze usando:

var serviceManager = new ServiceManagerBuilder()
                    .WithOptions(option =>
                    {
                        options.Endpoints = new ServiceEndpoint[]
                        {
                            // Note: this is just a demonstration of how to set options.Endpoints
                            // Having ConnectionStrings explicitly set inside the code is not encouraged
                            // You can fetch it from a safe place such as Azure KeyVault
                            new ServiceEndpoint("<ConnectionString0>"),
                            new ServiceEndpoint("<ConnectionString1>", type: EndpointType.Primary, name: "east-region-a"),
                            new ServiceEndpoint("<ConnectionString2>", type: EndpointType.Primary, name: "east-region-b"),
                            new ServiceEndpoint("<ConnectionString3>", type: EndpointType.Secondary, name: "backup"),
                        };
                    })
                    .WithRouter(new CustomRouter())
                    .BuildServiceManager();