Konfigurera alternativ för ASP.NET Core-webbservern Kestrel

Webbservern Kestrel har konfigurationsalternativ för begränsningar som är särskilt användbara i Internetuppkopplade distributioner. Om du vill konfigurera Kestrel konfigurationsalternativ anropar du ConfigureKestrel :Program.cs

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    // ...
});

Ange begränsningar för egenskapen KestrelServerOptions.Limits . Den här egenskapen innehåller en instans av KestrelServerLimits klassen.

Allmänna gränser

Timeout för keep-alive

KeepAliveTimeout hämtar eller anger timeouten keep-alive:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
});

Den här tidsgränsen Kestrel tillämpas inte när ett felsökningsprogram är kopplat till processen.

Maximalt antal klientanslutningar

MaxConcurrentConnections hämtar eller anger det maximala antalet öppna anslutningar:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxConcurrentConnections = 100;
});

MaxConcurrentUpgradedConnections hämtar eller anger det maximala antalet öppna, uppgraderade anslutningar:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxConcurrentUpgradedConnections = 100;
});

En uppgraderad anslutning är en som har växlats från HTTP till ett annat protokoll, till exempel WebSockets. När en anslutning har uppgraderats räknas den inte mot MaxConcurrentConnections gränsen.

Maximal storlek på begärandetext

MaxRequestBodySize hämtar eller anger den maximala tillåtna storleken för alla begärandetexter i byte.

Den rekommenderade metoden för att åsidosätta gränsen i en ASP.NET Core MVC-app är att använda RequestSizeLimitAttribute attributet på en åtgärdsmetod:

[RequestSizeLimit(100_000_000)]
public IActionResult Get()

Följande exempel konfigurerar MaxRequestBodySize för alla begäranden:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxRequestBodySize = 100_000_000;
});

I följande exempel konfigureras MaxRequestBodySize för en specifik begäran med hjälp av IHttpMaxRequestBodySizeFeature i ett anpassat mellanprogram:

app.Use(async (context, next) =>
{
    var httpMaxRequestBodySizeFeature = context.Features.Get<IHttpMaxRequestBodySizeFeature>();

    if (httpMaxRequestBodySizeFeature is not null)
        httpMaxRequestBodySizeFeature.MaxRequestBodySize = 10 * 1024;

    // ...

    await next(context);
});

Om appen försöker konfigurera gränsen för en begäran när den har börjat läsa begäran utlöses ett undantag. Ange egenskapen IHttpMaxRequestBodySizeFeature.IsReadOnly för att kontrollera om det är säkert att ange egenskapen MaxRequestBodySize .

När en app körs i fel process bakom ASP.NET Core Module anger IIS gränsen och Kestrelstorleksgränsen för begärandetext inaktiveras.

Minsta datafrekvens för begärandetext

Kestrel kontrollerar varje sekund om data anländer till den angivna hastigheten i byte/sekund. Om priset sjunker under minimivärdet överskrids tidsgränsen för anslutningen. Respitperioden är den tid Kestrel som klienten kan öka sin sändningsfrekvens upp till minimum. Priset kontrolleras inte under den tiden. Respitperioden hjälper till att undvika att släppa anslutningar som ursprungligen skickar data i långsam takt på grund av långsam TCP-start. En minimifrekvens gäller även för svaret.

MinRequestBodyDataRate hämtar eller anger begärandetextens minsta datahastighet i byte/sekund. MinResponseDataRate hämtar eller anger svarsminimum i byte/sekund.

Följande exempel konfigurerar MinRequestBodyDataRate och MinResponseDataRate för alla begäranden:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MinRequestBodyDataRate = new MinDataRate(
        bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Limits.MinResponseDataRate = new MinDataRate(
        bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
});

I följande exempel konfigureras MinRequestBodyDataRate och MinResponseDataRate för en specifik begäran med och IHttpMinResponseDataRateFeatureIHttpMinRequestBodyDataRateFeature i ett anpassat mellanprogram:

app.Use(async (context, next) =>
{
    var httpMinRequestBodyDataRateFeature = context.Features
        .Get<IHttpMinRequestBodyDataRateFeature>();

    if (httpMinRequestBodyDataRateFeature is not null)
    {
        httpMinRequestBodyDataRateFeature.MinDataRate = new MinDataRate(
            bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
    }

    var httpMinResponseDataRateFeature = context.Features
        .Get<IHttpMinResponseDataRateFeature>();

    if (httpMinResponseDataRateFeature is not null)
    {
        httpMinResponseDataRateFeature.MinDataRate = new MinDataRate(
            bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
    }

    // ...

    await next(context);
});

IHttpMinResponseDataRateFeature finns inte i HttpContext.Features för HTTP/2-begäranden. Ändring av hastighetsgränser per begäran stöds vanligtvis inte för HTTP/2 på grund av protokollets stöd för multiplexering av begäranden. Finns dock IHttpMinRequestBodyDataRateFeature fortfarande i HttpContext.Features för HTTP/2-begäranden, eftersom läsfrekvensgränsen fortfarande kan inaktiveras helt per begäran genom att ange IHttpMinResponseDataRateFeature.MinDataRate till null, även för en HTTP/2-begäran. Försök att läsa IHttpMinRequestBodyDataRateFeature.MinDataRate eller försök att ange det till ett annat värde än null resulterar i en NotSupportedException för HTTP/2-begäranden.

Hastighetsbegränsningar för hela servern som konfigurerats via KestrelServerOptions.Limits gäller fortfarande för både HTTP/1.x- och HTTP/2-anslutningar.

Tidsgräns för begärandehuvuden

RequestHeadersTimeout hämtar eller anger den maximala tid som servern ägnar åt att ta emot begärandehuvuden:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.RequestHeadersTimeout = TimeSpan.FromMinutes(1);
});

Den här tidsgränsen Kestrel tillämpas inte när ett felsökningsprogram är kopplat till processen.

HTTP/2-gränser

Gränserna i det här avsnittet är inställda på KestrelServerLimits.Http2.

Maximalt antal strömmar per anslutning

MaxStreamsPerConnection begränsar antalet samtidiga begärandeströmmar per HTTP/2-anslutning. Överskottsströmmar nekas:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.MaxStreamsPerConnection = 100;
});

Rubriktabellstorlek

HeaderTableSize begränsar storleken på huvudkomprimeringstabellerna, i oktetter kan HPACK-kodaren och avkodaren på servern använda. HPACK-avkodaren dekomprimerar HTTP-huvuden för HTTP/2-anslutningar:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.HeaderTableSize = 4096;
});

Maximal ramstorlek

MaxFrameSize anger storleken på den största bildrutenyttolasten som tillåts tas emot i oktetter:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.MaxFrameSize = 16_384;
});

Maximal storlek för begärandehuvud

MaxRequestHeaderFieldSize anger storleken på den maximala tillåtna storleken för en fältsekvens för begäranderubriken. Den här gränsen gäller för både namn- och värdesekvenser i deras komprimerade och okomprimerade representationer:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.MaxRequestHeaderFieldSize = 8192;
});

Ursprunglig storlek på anslutningsfönstret

InitialConnectionWindowSize anger hur mycket begärandetextdata som servern är villig att ta emot och buffras i taget för alla begäranden (strömmar) per anslutning:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.InitialConnectionWindowSize = 131_072;
});

Begäranden begränsas också av InitialStreamWindowSize.

Storlek på startströmsfönster

InitialStreamWindowSize anger hur mycket begärandetextdata som servern är villig att ta emot och buffring åt gången per dataström:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.InitialStreamWindowSize = 98_304;
});

Begäranden begränsas också av InitialConnectionWindowSize.

HTTP/2 hålla pingkonfigurationen vid liv

Kestrel kan konfigureras för att skicka HTTP/2-pingar till anslutna klienter. HTTP/2-pingar har flera syften:

• Håll inaktiva anslutningar vid liv. Vissa klienter och proxyservrar stänger anslutningar som är inaktiva. HTTP/2-ping betraktas som aktivitet i en anslutning och förhindrar att anslutningen stängs som inaktiv.
• Stäng feltillståndsanslutningar. Anslutningar där klienten inte svarar på pingen keep alive under den konfigurerade tiden stängs av servern.

Det finns två konfigurationsalternativ relaterade till HTTP/2 keep alive pings:

• KeepAlivePingDelay är en TimeSpan som konfigurerar pingintervallet. Servern skickar en keep alive-ping till klienten om den inte tar emot några bildrutor under den här tidsperioden. Keep alive-ping inaktiveras när det här alternativet är inställt på TimeSpan.MaxValue.
• KeepAlivePingTimeout är en TimeSpan som konfigurerar tidsgränsen för ping. Om servern inte tar emot några bildrutor, till exempel en svars-ping, stängs anslutningen under den här tidsgränsen. Timeouten Keep Alive inaktiveras när det här alternativet är inställt på TimeSpan.MaxValue.

Följande exempeluppsättningar KeepAlivePingDelay och KeepAlivePingTimeout:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.KeepAlivePingDelay = TimeSpan.FromSeconds(30);
    serverOptions.Limits.Http2.KeepAlivePingTimeout = TimeSpan.FromMinutes(1);
});

Andra alternativ

Synkront I/O

AllowSynchronousIO styr om synkron I/O tillåts för begäran och svaret.

Följande exempel aktiverar synkron I/O:

builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.AllowSynchronousIO = true;
});

Information om andra Kestrel alternativ och gränser finns i:

• KestrelServerOptions
• KestrelServerLimits
• ListenOptions

Beteende med felsökningsprogrammet kopplat

Följande timeout- och hastighetsgränsalternativ tillämpas inte när ett felsökningsprogram är kopplat till en Kestrel process:

• KestrelServerLimits.KeepAliveTimeout
• KestrelServerLimits.RequestHeadersTimeout
• KestrelServerLimits.MinRequestBodyDataRate
• KestrelServerLimits.MinResponseDataRate
• IConnectionTimeoutFeature
• IHttpMinRequestBodyDataRateFeature
• IHttpMinResponseDataRateFeature

Webbservern Kestrel har konfigurationsalternativ för begränsningar som är särskilt användbara i Internetuppkopplade distributioner.

Om du vill ange mer konfiguration efter att du har anropat ConfigureWebHostDefaultsanvänder du ConfigureKestrel:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.ConfigureKestrel(serverOptions =>
            {
                // Set properties and call methods on options
            })
            .UseStartup<Startup>();
        });

Ange begränsningar för Limits klassens KestrelServerOptions egenskap. Egenskapen Limits innehåller en instans av KestrelServerLimits klassen.

I följande exempel används Microsoft.AspNetCore.Server.Kestrel.Core namnområdet:

using Microsoft.AspNetCore.Server.Kestrel.Core;

Allmänna gränser

Timeout för keep-alive

KeepAliveTimeout

Hämtar eller anger tidsgränsen för att hålla vid liv. Standardvärdet är 2 minuter.

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxConcurrentConnections = 100;
    serverOptions.Limits.MaxConcurrentUpgradedConnections = 100;
    serverOptions.Limits.MaxRequestBodySize = 10 * 1024;
    serverOptions.Limits.MinRequestBodyDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Limits.MinResponseDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Listen(IPAddress.Loopback, 5000);
    serverOptions.Listen(IPAddress.Loopback, 5001, 
        listenOptions =>
        {
            listenOptions.UseHttps("testCert.pfx", 
                "testPassword");
        });
    serverOptions.Limits.KeepAliveTimeout = 
        TimeSpan.FromMinutes(2);
    serverOptions.Limits.RequestHeadersTimeout = 
        TimeSpan.FromMinutes(1);
})

Maximalt antal klientanslutningar

MaxConcurrentConnections
MaxConcurrentUpgradedConnections

Det maximala antalet samtidiga öppna TCP-anslutningar kan anges för hela appen med följande kod:

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxConcurrentConnections = 100;
    serverOptions.Limits.MaxConcurrentUpgradedConnections = 100;
    serverOptions.Limits.MaxRequestBodySize = 10 * 1024;
    serverOptions.Limits.MinRequestBodyDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Limits.MinResponseDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Listen(IPAddress.Loopback, 5000);
    serverOptions.Listen(IPAddress.Loopback, 5001, 
        listenOptions =>
        {
            listenOptions.UseHttps("testCert.pfx", 
                "testPassword");
        });
    serverOptions.Limits.KeepAliveTimeout = 
        TimeSpan.FromMinutes(2);
    serverOptions.Limits.RequestHeadersTimeout = 
        TimeSpan.FromMinutes(1);
})

Det finns en separat gräns för anslutningar som har uppgraderats från HTTP eller HTTPS till ett annat protokoll (till exempel på en WebSockets-begäran). När en anslutning har uppgraderats räknas den inte mot MaxConcurrentConnections gränsen.

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxConcurrentConnections = 100;
    serverOptions.Limits.MaxConcurrentUpgradedConnections = 100;
    serverOptions.Limits.MaxRequestBodySize = 10 * 1024;
    serverOptions.Limits.MinRequestBodyDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Limits.MinResponseDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Listen(IPAddress.Loopback, 5000);
    serverOptions.Listen(IPAddress.Loopback, 5001, 
        listenOptions =>
        {
            listenOptions.UseHttps("testCert.pfx", 
                "testPassword");
        });
    serverOptions.Limits.KeepAliveTimeout = 
        TimeSpan.FromMinutes(2);
    serverOptions.Limits.RequestHeadersTimeout = 
        TimeSpan.FromMinutes(1);
})

Det maximala antalet anslutningar är obegränsat (null) som standard.

Maximal storlek på begärandetext

MaxRequestBodySize

Standardstorleken för begärandetexten är 30 000 000 byte, vilket är cirka 28,6 MB.

Den rekommenderade metoden för att åsidosätta gränsen i en ASP.NET Core MVC-app är att använda RequestSizeLimitAttribute attributet på en åtgärdsmetod:

[RequestSizeLimit(100000000)]
public IActionResult MyActionMethod()

I följande exempel visas hur du konfigurerar villkoret för appen för varje begäran:

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxConcurrentConnections = 100;
    serverOptions.Limits.MaxConcurrentUpgradedConnections = 100;
    serverOptions.Limits.MaxRequestBodySize = 10 * 1024;
    serverOptions.Limits.MinRequestBodyDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Limits.MinResponseDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Listen(IPAddress.Loopback, 5000);
    serverOptions.Listen(IPAddress.Loopback, 5001, 
        listenOptions =>
        {
            listenOptions.UseHttps("testCert.pfx", 
                "testPassword");
        });
    serverOptions.Limits.KeepAliveTimeout = 
        TimeSpan.FromMinutes(2);
    serverOptions.Limits.RequestHeadersTimeout = 
        TimeSpan.FromMinutes(1);
})

Åsidosätt inställningen för en specifik begäran i mellanprogram:

app.Run(async (context) =>
{
    context.Features.Get<IHttpMaxRequestBodySizeFeature>()
        .MaxRequestBodySize = 10 * 1024;

    var minRequestRateFeature =
        context.Features.Get<IHttpMinRequestBodyDataRateFeature>();
    var minResponseRateFeature =
        context.Features.Get<IHttpMinResponseDataRateFeature>();

    if (minRequestRateFeature != null)
    {
        minRequestRateFeature.MinDataRate = new MinDataRate(
            bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
    }

    if (minResponseRateFeature != null)
    {
        minResponseRateFeature.MinDataRate = new MinDataRate(
            bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
    }

Ett undantag utlöses om appen konfigurerar gränsen för en begäran när appen har börjat läsa begäran. Det finns en IsReadOnly egenskap som anger om MaxRequestBodySize egenskapen är i skrivskyddat tillstånd, vilket innebär att det är för sent att konfigurera gränsen.

När en app har slut på processen bakom ASP.NET Core ModuleKestrel inaktiveras storleksgränsen för begärandetext. IIS anger redan gränsen.

Minsta datafrekvens för begärandetext

MinRequestBodyDataRate
MinResponseDataRate

Kestrel kontrollerar varje sekund om data anländer till den angivna hastigheten i byte/sekund. Om priset sjunker under minimivärdet överskrids tidsgränsen för anslutningen. Respitperioden är den tid Kestrel som klienten kan öka sin sändningsfrekvens upp till minimum. Priset kontrolleras inte under den tiden. Respitperioden hjälper till att undvika att släppa anslutningar som ursprungligen skickar data i långsam takt på grund av långsam TCP-start.

Standardvärdet är 240 byte/sekund med en respitperiod på 5 sekunder.

En minimifrekvens gäller även för svaret. Koden för att ange begärandegränsen och svarsgränsen är densamma förutom att ha RequestBody eller Response i egenskaps- och gränssnittsnamnen.

Här är ett exempel som visar hur du konfigurerar de lägsta datahastigheterna i Program.cs:

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxConcurrentConnections = 100;
    serverOptions.Limits.MaxConcurrentUpgradedConnections = 100;
    serverOptions.Limits.MaxRequestBodySize = 10 * 1024;
    serverOptions.Limits.MinRequestBodyDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Limits.MinResponseDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Listen(IPAddress.Loopback, 5000);
    serverOptions.Listen(IPAddress.Loopback, 5001, 
        listenOptions =>
        {
            listenOptions.UseHttps("testCert.pfx", 
                "testPassword");
        });
    serverOptions.Limits.KeepAliveTimeout = 
        TimeSpan.FromMinutes(2);
    serverOptions.Limits.RequestHeadersTimeout = 
        TimeSpan.FromMinutes(1);
})

Åsidosätt de lägsta hastighetsgränserna per begäran i mellanprogram:

app.Run(async (context) =>
{
    context.Features.Get<IHttpMaxRequestBodySizeFeature>()
        .MaxRequestBodySize = 10 * 1024;

    var minRequestRateFeature =
        context.Features.Get<IHttpMinRequestBodyDataRateFeature>();
    var minResponseRateFeature =
        context.Features.Get<IHttpMinResponseDataRateFeature>();

    if (minRequestRateFeature != null)
    {
        minRequestRateFeature.MinDataRate = new MinDataRate(
            bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
    }

    if (minResponseRateFeature != null)
    {
        minResponseRateFeature.MinDataRate = new MinDataRate(
            bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
    }

Referensen IHttpMinResponseDataRateFeature i föregående exempel finns inte i HttpContext.Features för HTTP/2-begäranden. Ändring av hastighetsgränser per begäran stöds vanligtvis inte för HTTP/2 på grund av protokollets stöd för multiplexering av begäranden. Det finns dock IHttpMinRequestBodyDataRateFeature fortfarande HttpContext.Features för HTTP/2-begäranden, eftersom läsfrekvensgränsen fortfarande kan inaktiveras helt per begäran genom att ställa in IHttpMinResponseDataRateFeature.MinDataRate till null även för en HTTP/2-begäran. Försök att läsa IHttpMinRequestBodyDataRateFeature.MinDataRate eller försöka ställa in det på ett annat värde än null resulterar i att ett NotSupportedException utlöses med en HTTP/2-begäran.

Hastighetsbegränsningar för hela servern som konfigurerats via KestrelServerOptions.Limits gäller fortfarande för både HTTP/1.x- och HTTP/2-anslutningar.

Tidsgräns för begärandehuvuden

RequestHeadersTimeout

Hämtar eller anger den maximala tid som servern ägnar åt att ta emot begärandehuvuden. Standardvärdet är 30 sekunder.

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxConcurrentConnections = 100;
    serverOptions.Limits.MaxConcurrentUpgradedConnections = 100;
    serverOptions.Limits.MaxRequestBodySize = 10 * 1024;
    serverOptions.Limits.MinRequestBodyDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Limits.MinResponseDataRate =
        new MinDataRate(bytesPerSecond: 100, 
            gracePeriod: TimeSpan.FromSeconds(10));
    serverOptions.Listen(IPAddress.Loopback, 5000);
    serverOptions.Listen(IPAddress.Loopback, 5001, 
        listenOptions =>
        {
            listenOptions.UseHttps("testCert.pfx", 
                "testPassword");
        });
    serverOptions.Limits.KeepAliveTimeout = 
        TimeSpan.FromMinutes(2);
    serverOptions.Limits.RequestHeadersTimeout = 
        TimeSpan.FromMinutes(1);
})

HTTP/2-gränser

Gränserna i det här avsnittet är inställda på KestrelServerLimits.Http2.

Maximalt antal strömmar per anslutning

MaxStreamsPerConnection

Begränsar antalet samtidiga begärandeströmmar per HTTP/2-anslutning. Överskottsströmmar nekas.

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.MaxStreamsPerConnection = 100;
});

Standardvärdet är 100.

Rubriktabellstorlek

HeaderTableSize

HPACK-avkodaren dekomprimerar HTTP-huvuden för HTTP/2-anslutningar. HeaderTableSize begränsar storleken på den rubrikkomprimeringstabell som HPACK-avkodaren använder. Värdet anges i oktetter och måste vara större än noll (0).

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.HeaderTableSize = 4096;
});

Standardvärdet är 4096.

Maximal ramstorlek

MaxFrameSize

Anger den maximala tillåtna storleken på en HTTP/2-anslutningsramsnyttolast som tas emot eller skickas av servern. Värdet anges i oktetter och måste vara mellan 2^14 (16 384) och 2^24-1 (16 777 215).

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.MaxFrameSize = 16384;
});

Standardvärdet är 2^14 (16 384).

Maximal storlek för begärandehuvud

MaxRequestHeaderFieldSize

Anger den maximala tillåtna storleken i oktetter med värden för begärandehuvud. Den här gränsen gäller både namn och värde i deras komprimerade och okomprimerade representationer. Värdet måste vara större än noll (0).

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.MaxRequestHeaderFieldSize = 8192;
});

Standardvärdet är 8 192.

Ursprunglig storlek på anslutningsfönstret

InitialConnectionWindowSize

Anger maximalt antal brödtextdata för begäranden i byte som servern buffrar på en gång, aggregerade över alla begäranden (strömmar) per anslutning. Begäranden begränsas också av Http2.InitialStreamWindowSize. Värdet måste vara större än eller lika med 65 535 och mindre än 2^31 (2 147 483 648).

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.InitialConnectionWindowSize = 131072;
});

Standardvärdet är 128 KB (131 072).

Storlek på startströmsfönster

InitialStreamWindowSize

Anger maximalt antal brödtextdata för begäran i byte som servern buffrar samtidigt per begäran (ström). Begäranden begränsas också av InitialConnectionWindowSize. Värdet måste vara större än eller lika med 65 535 och mindre än 2^31 (2 147 483 648).

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.InitialStreamWindowSize = 98304;
});

Standardvärdet är 96 KB (98 304).

HTTP/2 hålla pingkonfigurationen vid liv

Kestrel kan konfigureras för att skicka HTTP/2-pingar till anslutna klienter. HTTP/2-pingar har flera syften:

• Håll inaktiva anslutningar vid liv. Vissa klienter och proxyservrar stänger anslutningar som är inaktiva. HTTP/2-ping betraktas som aktivitet i en anslutning och förhindrar att anslutningen stängs som inaktiv.
• Stäng feltillståndsanslutningar. Anslutningar där klienten inte svarar på pingen keep alive under den konfigurerade tiden stängs av servern.

Det finns två konfigurationsalternativ relaterade till HTTP/2 keep alive pings:

• KeepAlivePingDelay är en TimeSpan som konfigurerar pingintervallet. Servern skickar en keep alive-ping till klienten om den inte tar emot några bildrutor under den här tidsperioden. Keep alive-ping inaktiveras när det här alternativet är inställt på TimeSpan.MaxValue. Standardvärdet är TimeSpan.MaxValue.
• KeepAlivePingTimeout är en TimeSpan som konfigurerar tidsgränsen för ping. Om servern inte tar emot några bildrutor, till exempel en svars-ping, stängs anslutningen under den här tidsgränsen. Timeouten Keep Alive inaktiveras när det här alternativet är inställt på TimeSpan.MaxValue. Standardvärdet är 20 sekunder.

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.KeepAlivePingDelay = TimeSpan.FromSeconds(30);
    serverOptions.Limits.Http2.KeepAlivePingTimeout = TimeSpan.FromSeconds(60);
});

Andra alternativ

Synkront I/O

AllowSynchronousIO styr om synkron I/O tillåts för begäran och svaret. Standardvärdet är false.

Följande exempel aktiverar synkron I/O:

webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.AllowSynchronousIO = true;
})

Information om andra Kestrel alternativ och gränser finns i:

• KestrelServerOptions
• KestrelServerLimits
• ListenOptions