Opties configureren voor de ASP.NET Core-webserver Kestrel

De Kestrel webserver heeft beperkte configuratieopties die met name handig zijn in internetgerichte implementaties. Als u configuratieopties wilt configureren Kestrel , meldt u ConfigureKestrel het volgende aan Program.cs:

var builder = WebApplication.CreateBuilder(args);

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

Stel beperkingen in voor de KestrelServerOptions.Limits eigenschap. Deze eigenschap bevat een exemplaar van de KestrelServerLimits klasse.

Algemene limieten

Time-out van keep-alive

KeepAliveTimeout haalt de time-out voor keep-alive op of stelt deze in:

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

Deze time-out wordt niet afgedwongen wanneer een foutopsporingsprogramma is gekoppeld aan het Kestrel proces.

Maximum aantal clientverbindingen

MaxConcurrentConnections haalt het maximum aantal geopende verbindingen op of stelt deze in:

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

MaxConcurrentUpgradedConnections haalt het maximum aantal geopende, bijgewerkte verbindingen op of stelt deze in:

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

Een bijgewerkte verbinding is een verbinding die is overgeschakeld van HTTP naar een ander protocol, zoals WebSockets. Nadat een verbinding is bijgewerkt, wordt deze niet meegeteld voor de MaxConcurrentConnections limiet.

Maximale grootte van aanvraagbody

MaxRequestBodySize haalt of stelt de maximale toegestane grootte van elke aanvraagbody in bytes.

De aanbevolen methode om de limiet in een ASP.NET Core MVC-app te overschrijven, is door het RequestSizeLimitAttribute kenmerk voor een actiemethode te gebruiken:

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

In het volgende voorbeeld worden alle aanvragen geconfigureerd MaxRequestBodySize :

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

In het volgende voorbeeld wordt een specifieke aanvraag geconfigureerd MaxRequestBodySize die wordt gebruikt IHttpMaxRequestBodySizeFeature in een aangepaste middleware:

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

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

    // ...

    await next(context);
});

Als de app de limiet voor een aanvraag probeert te configureren nadat deze de aanvraag begint te lezen, wordt er een uitzondering gegenereerd. Ue de IHttpMaxRequestBodySizeFeature.IsReadOnly eigenschap om te controleren of het veilig is om de MaxRequestBodySize eigenschap in te stellen.

Wanneer een app niet meer wordt verwerkt achter de ASP.NET Core Module, stelt IIS de limiet in en Kestrelwordt de limiet voor de aanvraagbody uitgeschakeld.

Minimale snelheid van hoofdtekst van aanvraag

Kestrel controleert elke seconde of gegevens binnenkomen op de opgegeven snelheid in bytes/seconde. Als de snelheid lager is dan het minimum, treedt er een time-out op voor de verbinding. De respijtperiode is de tijdsduur Kestrel waarmee de client de verzendsnelheid tot het minimum kan verhogen. De snelheid wordt gedurende die tijd niet gecontroleerd. De respijtperiode helpt voorkomen dat verbindingen die in eerste instantie gegevens met een trage snelheid verzenden, worden verwijderd vanwege een trage TCP-start. Een minimumtarief is ook van toepassing op het antwoord.

MinRequestBodyDataRate haalt of stelt de minimale gegevenssnelheid van de aanvraagbody in bytes/seconde in. MinResponseDataRate haalt of stelt de minimale responsgegevenssnelheid in bytes/seconde in.

In het volgende voorbeeld worden alle aanvragen geconfigureerd MinRequestBodyDataRate en MinResponseDataRate voor alle aanvragen:

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

Het volgende voorbeeld configureert MinRequestBodyDataRate en MinResponseDataRate voor een specifieke aanvraag die gebruikmaakt van IHttpMinRequestBodyDataRateFeature en IHttpMinResponseDataRateFeature in een aangepaste middleware:

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 is niet aanwezig voor HttpContext.Features HTTP/2-aanvragen. Het wijzigen van frequentielimieten per aanvraag wordt doorgaans niet ondersteund voor HTTP/2 vanwege de ondersteuning van het protocol voor het aanvragen van multiplexing. IHttpMinRequestBodyDataRateFeature Er is echter nog steeds aanwezig HttpContext.Features voor HTTP/2-aanvragen, omdat de leessnelheidslimiet nog steeds volledig per aanvraag kan worden uitgeschakeld door in te nullstellen IHttpMinResponseDataRateFeature.MinDataRate op , zelfs voor een HTTP/2-aanvraag. Pogingen om deze te lezen IHttpMinRequestBodyDataRateFeature.MinDataRate of in te stellen op een andere waarde dan null resultaat in een NotSupportedException voor HTTP/2-aanvragen.

Frequentielimieten voor de hele server die zijn geconfigureerd via KestrelServerOptions.Limits nog steeds van toepassing op zowel HTTP/1.x- als HTTP/2-verbindingen.

Time-out voor aanvraagheaders

RequestHeadersTimeout haalt of stelt de maximale tijd in die de server besteedt aan het ontvangen van aanvraagheaders:

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

Deze time-out wordt niet afgedwongen wanneer een foutopsporingsprogramma is gekoppeld aan het Kestrel proces.

HTTP/2-limieten

De limieten in deze sectie zijn ingesteld op KestrelServerLimits.Http2.

Maximum aantal streams per verbinding

MaxStreamsPerConnection beperkt het aantal gelijktijdige aanvraagstromen per HTTP/2-verbinding. Overtollige stromen worden geweigerd:

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

Grootte van kopteksttabel

HeaderTableSize beperkt de grootte van de headercompressietabellen, in octetten, de HPACK-encoder en -decoder op de server kunnen worden gebruikt. De HPACK-decoder ontcomprimeert HTTP-headers voor HTTP/2-verbindingen:

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

Maximale framegrootte

MaxFrameSize geeft de grootte aan van de grootste framelading die mag worden ontvangen, in octetten:

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

Maximale aanvraagheadergrootte

MaxRequestHeaderFieldSize geeft de grootte aan van de maximale toegestane grootte van een veldreeks voor de aanvraagheader. Deze limiet geldt voor zowel naam- als waardereeksen in de gecomprimeerde en niet-gecomprimeerde weergaven:

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

Oorspronkelijke verbindingsvenstergrootte

InitialConnectionWindowSize geeft aan hoeveel aanvraagbodygegevens de server bereid is om te ontvangen en bufferen per verbinding voor alle aanvragen (streams):

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

Aanvragen worden ook beperkt door InitialStreamWindowSize.

Grootte van eerste stroomvenster

InitialStreamWindowSize geeft aan hoeveel aanvraagbodygegevens de server wil ontvangen en bufferen per stream:

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

Aanvragen worden ook beperkt door InitialConnectionWindowSize.

HTTP/2 keep alive ping-configuratie

Kestrel kan worden geconfigureerd voor het verzenden van HTTP/2-pings naar verbonden clients. HTTP/2 pings dienen voor meerdere doeleinden:

• Houd niet-actieve verbindingen actief. Sommige clients en proxyservers sluiten verbindingen die niet actief zijn. HTTP/2-pings worden beschouwd als activiteit op een verbinding en voorkomen dat de verbinding wordt gesloten als niet-actief.
• Sluit beschadigde verbindingen. Verbindingen waarbij de client niet reageert op de keep alive ping in de geconfigureerde tijd, worden gesloten door de server.

Er zijn twee configuratieopties gerelateerd aan HTTP/2 keep alive pings:

• KeepAlivePingDelay is een TimeSpan functie waarmee het ping-interval wordt geconfigureerd. De server verzendt een keep alive ping naar de client als er gedurende deze periode geen frames worden ontvangen. Actieve pings worden uitgeschakeld wanneer deze optie is ingesteld op TimeSpan.MaxValue.
• KeepAlivePingTimeout is een TimeSpan die de time-out voor pings configureert. Als de server tijdens deze time-out geen frames ontvangt, zoals een reactie ping, wordt de verbinding gesloten. Time-out actief houden is uitgeschakeld wanneer deze optie is ingesteld op TimeSpan.MaxValue.

In het volgende voorbeeld wordt het volgende ingesteld KeepAlivePingDelay en KeepAlivePingTimeout:

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

Andere opties

Synchrone I/O

AllowSynchronousIO bepaalt of synchrone I/O is toegestaan voor de aanvraag en het antwoord.

In het volgende voorbeeld wordt synchrone I/O ingeschakeld:

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

Zie voor meer informatie over andere Kestrel opties en limieten:

• KestrelServerOptions
• KestrelServerLimits
• ListenOptions

Gedrag waarbij foutopsporingsprogramma is gekoppeld

De volgende time-out- en frequentielimietopties worden niet afgedwongen wanneer een foutopsporingsprogramma is gekoppeld aan een Kestrel proces:

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

De Kestrel webserver heeft beperkte configuratieopties die met name handig zijn in internetgerichte implementaties.

Als u na het aanroepen ConfigureWebHostDefaultsmeer configuratie wilt bieden, gebruikt u ConfigureKestrel:

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

Stel beperkingen in voor de Limits eigenschap van de KestrelServerOptions klasse. De Limits eigenschap bevat een exemplaar van de KestrelServerLimits klasse.

In de volgende voorbeelden wordt de Microsoft.AspNetCore.Server.Kestrel.Core naamruimte gebruikt:

using Microsoft.AspNetCore.Server.Kestrel.Core;

Algemene limieten

Time-out van keep-alive

KeepAliveTimeout

Hiermee haalt u de time-out voor keep-alive op of stelt u deze in. De standaardwaarde is 2 minuten.

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

Maximum aantal clientverbindingen

MaxConcurrentConnections
MaxConcurrentUpgradedConnections

Het maximum aantal gelijktijdige open TCP-verbindingen kan worden ingesteld voor de hele app met de volgende code:

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

Er is een afzonderlijke limiet voor verbindingen die zijn bijgewerkt van HTTP of HTTPS naar een ander protocol (bijvoorbeeld op een WebSockets-aanvraag). Nadat een verbinding is bijgewerkt, wordt deze niet meegeteld voor de MaxConcurrentConnections limiet.

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

Het maximum aantal verbindingen is standaard onbeperkt (null).

Maximale grootte van aanvraagbody

MaxRequestBodySize

De standaard maximale grootte van de aanvraagbody is 30.000.000 bytes, wat ongeveer 28,6 MB is.

De aanbevolen methode om de limiet in een ASP.NET Core MVC-app te overschrijven, is door het RequestSizeLimitAttribute kenmerk voor een actiemethode te gebruiken:

[RequestSizeLimit(100000000)]
public IActionResult MyActionMethod()

In het volgende voorbeeld ziet u hoe u de beperking voor de app configureert voor elke aanvraag:

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

Overschrijf de instelling voor een specifieke aanvraag in middleware:

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

Er wordt een uitzondering gegenereerd als de app de limiet voor een aanvraag configureert nadat de app de aanvraag heeft gelezen. Er is een IsReadOnly eigenschap die aangeeft of de eigenschap de MaxRequestBodySize status Alleen-lezen heeft, wat betekent dat deze te laat is om de limiet te configureren.

Wanneer een app niet meer wordt verwerkt achter de ASP.NET Core-module, Kestrelwordt de limiet voor de aanvraagbody-grootte uitgeschakeld. IIS stelt de limiet al in.

Minimale snelheid van hoofdtekst van aanvraag

MinRequestBodyDataRate
MinResponseDataRate

Kestrel controleert elke seconde of gegevens binnenkomen op de opgegeven snelheid in bytes/seconde. Als de snelheid lager is dan het minimum, treedt er een time-out op voor de verbinding. De respijtperiode is de tijdsduur Kestrel waarmee de client de verzendsnelheid tot het minimum kan verhogen. De snelheid wordt gedurende die tijd niet gecontroleerd. De respijtperiode helpt voorkomen dat verbindingen die in eerste instantie gegevens met een trage snelheid verzenden, worden verwijderd vanwege een trage TCP-start.

De standaard minimumfrequentie is 240 bytes/seconde met een respijtperiode van 5 seconden.

Een minimumtarief is ook van toepassing op het antwoord. De code voor het instellen van de aanvraaglimiet en de antwoordlimiet is hetzelfde, behalve voor het hebben RequestBody of Response in de eigenschap en interfacenamen.

Hier volgt een voorbeeld van het configureren van de minimale gegevenssnelheden in 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);
})

Overschrijf de minimale frequentielimieten per aanvraag in middleware:

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

De IHttpMinResponseDataRateFeature verwijzing in het vorige voorbeeld is niet aanwezig voor HttpContext.Features HTTP/2-aanvragen. Het wijzigen van frequentielimieten per aanvraag wordt doorgaans niet ondersteund voor HTTP/2 vanwege de ondersteuning van het protocol voor het aanvragen van multiplexing. Het IHttpMinRequestBodyDataRateFeature is echter nog steeds aanwezig HttpContext.Features voor HTTP/2-aanvragen, omdat de leessnelheidslimiet nog steeds volledig kan worden uitgeschakeld per aanvraag door in te stellen IHttpMinResponseDataRateFeature.MinDataRate op null zelfs voor een HTTP/2-aanvraag. Als u deze probeert te lezen IHttpMinRequestBodyDataRateFeature.MinDataRate of probeert in te stellen op een andere waarde dan wordt null een NotSupportedException HTTP/2-aanvraag gegenereerd.

Frequentielimieten voor de hele server die zijn geconfigureerd via KestrelServerOptions.Limits nog steeds van toepassing op zowel HTTP/1.x- als HTTP/2-verbindingen.

Time-out voor aanvraagheaders

RequestHeadersTimeout

Hiermee haalt of stelt u de maximale tijd in die de server besteedt aan het ontvangen van aanvraagheaders. De standaardwaarde is 30 seconden.

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

De limieten in deze sectie zijn ingesteld op KestrelServerLimits.Http2.

Maximum aantal streams per verbinding

MaxStreamsPerConnection

Hiermee beperkt u het aantal gelijktijdige aanvraagstromen per HTTP/2-verbinding. Overtollige streams worden geweigerd.

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

De standaardwaarde is 100.

Grootte van kopteksttabel

HeaderTableSize

De HPACK-decoder ontcomprimeert HTTP-headers voor HTTP/2-verbindingen. HeaderTableSize beperkt de grootte van de headercompressietabel die door de HPACK-decoder wordt gebruikt. De waarde wordt opgegeven in octetten en moet groter zijn dan nul (0).

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

De standaardwaarde is 4096.

Maximale framegrootte

MaxFrameSize

Geeft de maximale toegestane grootte aan van een nettolading van het HTTP/2-verbindingsframe die is ontvangen of verzonden door de server. De waarde is opgegeven in octetten en moet tussen 2^14 (16.384) en 2^24-1 (16.777.215) zijn.

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

De standaardwaarde is 2^14 (16.384).

Maximale aanvraagheadergrootte

MaxRequestHeaderFieldSize

Geeft de maximaal toegestane grootte in octetten van aanvraagheaderwaarden aan. Deze limiet geldt voor zowel de naam als de waarde in de gecomprimeerde en niet-gecomprimeerde weergaven. De waarde moet groter zijn dan nul (0).

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

De standaardwaarde is 8.192.

Oorspronkelijke verbindingsvenstergrootte

InitialConnectionWindowSize

Geeft de maximale aanvraagbodygegevens in bytes aan die de serverbuffers tegelijk bevatten, geaggregeerd voor alle aanvragen (streams) per verbinding. Aanvragen worden ook beperkt door Http2.InitialStreamWindowSize. De waarde moet groter dan of gelijk zijn aan 65.535 en kleiner dan 2^31 (2.147.483.648).

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

De standaardwaarde is 128 KB (131.072).

Grootte van eerste stroomvenster

InitialStreamWindowSize

Geeft de maximale hoofdtekstgegevens van de aanvraag in bytes aan die de serverbuffers tegelijk per aanvraag (stream) bevatten. Aanvragen worden ook beperkt door InitialConnectionWindowSize. De waarde moet groter dan of gelijk zijn aan 65.535 en kleiner dan 2^31 (2.147.483.648).

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

De standaardwaarde is 96 KB (98.304).

HTTP/2 keep alive ping-configuratie

Kestrel kan worden geconfigureerd voor het verzenden van HTTP/2-pings naar verbonden clients. HTTP/2 pings dienen voor meerdere doeleinden:

• Houd niet-actieve verbindingen actief. Sommige clients en proxyservers sluiten verbindingen die niet actief zijn. HTTP/2-pings worden beschouwd als activiteit op een verbinding en voorkomen dat de verbinding wordt gesloten als niet-actief.
• Sluit beschadigde verbindingen. Verbindingen waarbij de client niet reageert op de keep alive ping in de geconfigureerde tijd, worden gesloten door de server.

Er zijn twee configuratieopties gerelateerd aan HTTP/2 keep alive pings:

• KeepAlivePingDelay is een TimeSpan functie waarmee het ping-interval wordt geconfigureerd. De server verzendt een keep alive ping naar de client als er gedurende deze periode geen frames worden ontvangen. Actieve pings worden uitgeschakeld wanneer deze optie is ingesteld op TimeSpan.MaxValue. De standaardwaarde is TimeSpan.MaxValue.
• KeepAlivePingTimeout is een TimeSpan die de time-out voor pings configureert. Als de server tijdens deze time-out geen frames ontvangt, zoals een reactie ping, wordt de verbinding gesloten. Time-out actief houden is uitgeschakeld wanneer deze optie is ingesteld op TimeSpan.MaxValue. De standaardwaarde is 20 seconden.

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

Andere opties

Synchrone I/O

AllowSynchronousIO bepaalt of synchrone I/O is toegestaan voor de aanvraag en het antwoord. De standaardwaarde is false.

In het volgende voorbeeld wordt synchrone I/O ingeschakeld:

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

Zie voor meer informatie over andere Kestrel opties en limieten:

• KestrelServerOptions
• KestrelServerLimits
• ListenOptions