Škálování služby SignalR s několika instancemi

Pro ASP.NET Core

Přidání několika koncových bodů z konfigurace

Nakonfigurujte klíč Azure:SignalR:ConnectionString nebo Azure:SignalR:ConnectionString: pro službu SignalR Service připojovací řetězec.

Pokud klíč začíná Azure:SignalR:ConnectionString:, měl by být ve formátu Azure:SignalR:ConnectionString:{Name}:{EndpointType}, kde Name a EndpointType jsou vlastnosti objektu ServiceEndpoint a jsou přístupné z kódu.

Pomocí následujících dotnet příkazů můžete přidat více připojovací řetězec instancí:

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>

Přidání několika koncových bodů z kódu

Třída ServiceEndpoint popisuje vlastnosti koncového bodu služby Azure SignalR. Při použití sady SDK služby Azure SignalR můžete nakonfigurovat více koncových bodů instance prostřednictvím:

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

Přizpůsobení směrovače koncových bodů

Ve výchozím nastavení sada SDK k vyzvednutí koncových bodů používá DefaultEndpointRouter .

Výchozí chování

1. Směrování požadavků klienta:

   Když klient /negotiate se serverem aplikace. Sada SDK ve výchozím nastavení náhodně vybere jeden koncový bod ze sady dostupných koncových bodů služby.

2. Směrování zpráv serveru:

   Při odesílání zprávy do konkrétního připojení a cílové připojení je směrováno na aktuální server, zpráva přejde přímo do daného připojeného koncového bodu. Jinak se zprávy vysílají do každého koncového bodu Azure SignalR.

Přizpůsobení algoritmu směrování

Vlastní směrovač můžete vytvořit, když máte speciální znalosti, abyste zjistili, na které koncové body mají zprávy přejít.

Následující příklad definuje vlastní směrovač, který směruje zprávy se skupinou začínající east- na koncový bod s názvem 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);
    }
}

Následující příklad přepíše výchozí chování vyjednávání a vybere koncový bod v závislosti na umístění aplikačního serveru.

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

Nezapomeňte zaregistrovat směrovač do kontejneru DI pomocí:

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

Pro ASP.NET

Přidání několika koncových bodů z konfigurace

Konfigurace s klíčem Azure:SignalR:ConnectionString nebo Azure:SignalR:ConnectionString: pro službu SignalR Service připojovací řetězec

Pokud klíč začíná Azure:SignalR:ConnectionString:, měl by být ve formátu Azure:SignalR:ConnectionString:{Name}:{EndpointType}, kde Name a EndpointType jsou vlastnosti objektu ServiceEndpoint a jsou přístupné z kódu.

Můžete přidat více instancí připojovací řetězec doweb.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>

Přidání několika koncových bodů z kódu

Třída ServiceEndpoint popisuje vlastnosti koncového bodu služby Azure SignalR. Při použití sady SDK služby Azure SignalR můžete nakonfigurovat více koncových bodů instance prostřednictvím:

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

Přizpůsobení směrovače

Jediný rozdíl mezi ASP.NET SignalR a ASP.NET Core SignalR je typ kontextu http pro GetNegotiateEndpoint. Pro ASP.NET SignalR se jedná o typ IOwinContext .

Následující kód je vlastní příklad vyjednávání pro 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
    }
}

Nezapomeňte zaregistrovat směrovač do kontejneru DI pomocí:

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

Metriky koncového bodu služby

Pokud chcete povolit pokročilý směrovač, sada SDK serveru SignalR poskytuje více metrik, které serveru pomáhají při inteligentních rozhodnutích. Vlastnosti jsou pod položkou ServiceEndpoint.EndpointMetrics.

Následující kód je příkladem přizpůsobení směrovače podle 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
    }
}

Dynamické škálovací body ServiceEndpoints

Ze sady SDK verze 1.5.0 nejprve povolujeme dynamické škálování ServiceEndpoints pro verzi ASP.NET Core. Proto nemusíte restartovat aplikační server, když potřebujete přidat nebo odebrat ServiceEndpoint. Vzhledem k tomu, že ASP.NET Core podporuje výchozí konfiguraci, jako je tomu appsettings.json u reloadOnChange: true, nemusíte měnit kód a podporuje ho příroda. A pokud chcete přidat vlastní konfiguraci a pracovat s opětovným načítáním za provozu, přečtěte si informace o konfiguraci v ASP.NET Core.

Pro rozšíření SignalR Functions

Konfigurace

Pokud chcete povolit více instancí služby SignalR, měli byste:

1. Použijte Persistent typ přenosu.

   Výchozí typ přenosu je Transient režim. Do souboru nebo nastavení aplikace v local.settings.json Azure byste měli přidat následující položku.

   {
       "AzureSignalRServiceTransportType":"Persistent"
   }
   

   Poznámka:

   Při přechodu z Transient režimu do režimu může dojít ke Persistent změně chování serializace JSON, protože v Transient režimu se Newtonsoft.Json knihovna používá k serializaci argumentů metod centra, ale v režimu Persistent se System.Text.Json knihovna používá jako výchozí. System.Text.Json má některé klíčové rozdíly ve výchozím chování s Newtonsoft.Json. Pokud chcete použít Newtonsoft.Json režim Persistent , můžete přidat položku konfigurace: "Azure:SignalR:HubProtocol":"NewtonsoftJson" v local.settings.json souboru nebo Azure__SignalR__HubProtocol=NewtonsoftJson na webu Azure Portal.

2. Nakonfigurujte několik položek koncových bodů služby SignalR v konfiguraci.

   Objekt používáme ServiceEndpoint k reprezentaci instance služby SignalR. Koncový bod služby můžete definovat pomocí jejího <EndpointName> a <EndpointType> vstupního klíče a připojovací řetězec v hodnotě položky. Klíče jsou v následujícím formátu:

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

   <EndpointType> je nepovinný a výchozí hodnota primaryje . Projděte si následující ukázky:

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

   Poznámka:

   • Při konfiguraci koncových bodů Azure SignalR ve službě App Service na webu Azure Portal nezapomeňte nahradit ":" "__"dvojitým podtržítkem v klíčích. Z důvodů se podívejte na proměnné prostředí.

   • Připojovací řetězec nakonfigurovaný s klíčem {ConnectionStringSetting} (výchozí hodnota je AzureSignalRConnectionString) se také rozpozná jako primární koncový bod služby s prázdným názvem. Tento styl konfigurace se ale nedoporučuje pro více koncových bodů.

Směrování

Výchozí chování

Vazba funkcí ve výchozím nastavení používá k vyzvednutí koncových bodů defaultEndpointRouter .

• Směrování klientů: Náhodně vyberte jeden koncový bod z primárních online koncových bodů. Pokud jsou všechny primární koncové body offline, náhodně vyberte jeden sekundární online koncový bod. Pokud se výběr znovu nezdaří, vyvolá se výjimka.

• Směrování zpráv serveru: Vrátí se všechny koncové body služby.

Vlastní nastavení

Model v procesu jazyka C#

Postup je následující:

1. Implementujte přizpůsobený směrovač. K rozhodování o směrování můžete využít informace, které ServiceEndpoint jsou k dispozici. Průvodce najdete tady: customize-route-algorithm. Upozorňujeme, že trigger HTTP se vyžaduje ve funkci vyjednávání, pokud potřebujete HttpContext vlastní metodu vyjednávání.

2. Zaregistrujte směrovač do kontejneru DI.

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

Model izolovaného procesu

Pro funkce spuštěné v izolovaném modelu procesu podporujeme zadávání cílových koncových bodů v jednotlivých žádostech. K získání informací o koncovém bodu použijete nové typy vazeb.

Směrování z klienta

Vazba SignalRConnectionInfo vybere jeden koncový bod podle výchozího pravidla směrování. Pokud chcete přizpůsobit pravidlo směrování, měli byste místo vazby SignalRConnectionInfo použít SignalRNegotiation vazbu.

SignalRNegotiation vlastnosti konfigurace vazby jsou stejné jako SignalRConnectionInfovlastnosti . Tady je function.json ukázka souboru:

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

Můžete také přidat další data vazby, například userIdidToken , a claimTypeList stejně jako SignalRConnectionInfo.

Objekt, který získáte z SignalRNegotiation vazby, je v následujícím formátu:

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

Tady je ukázka použití JavaScriptu vazby 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;
    }
}

Směrování zpráv

Směrování zpráv nebo akcí potřebuje ke spolupráci dva typy vazeb. Obecně platí, že nejprve potřebujete nový typ SignalREndpoints vstupní vazby, abyste získali všechny dostupné informace o koncovém bodu. Potom vyfiltrujete koncové body a získáte pole obsahující všechny koncové body, na které chcete odeslat. Nakonec zadáte cílové koncové body ve SignalR výstupní vazbě.

Tady jsou vlastnosti konfigurace vazby SignalREndpoints v functions.json souboru:

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

Objekt, ze SignalREndpoints kterého získáte, je pole koncových bodů, z nichž každý je reprezentován jako objekt JSON s následujícím schématem:

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

Po získání pole cílového koncového bodu přidejte do výstupního endpoints objektu vazby vlastnost. Toto je příklad JavaScriptu:

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

Sada SDK pro správu

Přidání několika koncových bodů z konfigurace

Nakonfigurujte klíč Azure:SignalR:Endpoints pro službu SignalR Service připojovací řetězec. Klíč by měl být ve formátu Azure:SignalR:Endpoints:{Name}:{EndpointType}, kde Name a EndpointType jsou vlastnosti objektu ServiceEndpoint a jsou přístupné z kódu.

Pomocí následujících dotnet příkazů můžete přidat více připojovací řetězec instancí:

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>

Přidání několika koncových bodů z kódu

Třída ServiceEndpoint popisuje vlastnosti koncového bodu služby Azure SignalR. Při použití sady SDK pro správu Azure SignalR můžete nakonfigurovat více koncových bodů instance prostřednictvím:

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

Přizpůsobení směrovače koncových bodů

Ve výchozím nastavení sada SDK k vyzvednutí koncových bodů používá DefaultEndpointRouter .

Výchozí chování

• Směrování požadavků klienta:

  Když klient /negotiate se serverem aplikace. Sada SDK ve výchozím nastavení náhodně vybere jeden koncový bod ze sady dostupných koncových bodů služby.

• Směrování zpráv serveru:

  Při odesílání zprávy do konkrétního připojení a cílové připojení je směrováno na aktuální server, zpráva přejde přímo do daného připojeného koncového bodu. Jinak se zprávy vysílají do každého koncového bodu Azure SignalR.

Přizpůsobení algoritmu směrování

Vlastní směrovač můžete vytvořit, když máte speciální znalosti, abyste zjistili, na které koncové body mají zprávy přejít.

Následující příklad definuje vlastní směrovač, který směruje zprávy se skupinou začínající east- na koncový bod s názvem 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);
    }
}

Následující příklad přepíše výchozí chování vyjednávání a vybere koncový bod v závislosti na umístění aplikačního serveru.

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

Nezapomeňte zaregistrovat směrovač do kontejneru DI pomocí:

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