Configurare le opzioni per il server Web ASP.NET Core Kestrel

Il Kestrel server Web dispone di opzioni di configurazione dei vincoli particolarmente utili nelle distribuzioni con connessione Internet. Per configurare le opzioni di Kestrel configurazione, chiamare ConfigureKestrel in Program.cs:

var builder = WebApplication.CreateBuilder(args);

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

Impostare vincoli sulla KestrelServerOptions.Limits proprietà . Questa proprietà contiene un'istanza della KestrelServerLimits classe .

Limiti generali

Timeout keep-alive

KeepAliveTimeout ottiene o imposta il timeout keep-alive:

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

Questo timeout non viene applicato quando un debugger è collegato al Kestrel processo.

Numero massimo di connessioni client

MaxConcurrentConnections ottiene o imposta il numero massimo di connessioni aperte:

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

MaxConcurrentUpgradedConnections ottiene o imposta il numero massimo di connessioni aperte e aggiornate:

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

Una connessione aggiornata è una connessione che è stata passata da HTTP a un altro protocollo, ad esempio WebSocket. Dopo l'aggiornamento di una connessione, questa non viene conteggiata per il limite MaxConcurrentConnections.

Dimensione massima del corpo della richiesta

MaxRequestBodySize ottiene o imposta la dimensione massima consentita di qualsiasi corpo della richiesta in byte.

Il metodo consigliato per ignorare il limite in un'app ASP.NET Core MVC è l'uso dell'attributo RequestSizeLimitAttribute in un metodo di azione:

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

L'esempio seguente configura MaxRequestBodySize per tutte le richieste:

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

L'esempio seguente configura MaxRequestBodySize per una richiesta specifica usando IHttpMaxRequestBodySizeFeature in un middleware personalizzato:

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

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

    // ...

    await next(context);
});

Se l'app tenta di configurare il limite per una richiesta dopo l'avvio della lettura della richiesta, viene generata un'eccezione. Ue la IHttpMaxRequestBodySizeFeature.IsReadOnly proprietà per verificare se è sicuro impostare la MaxRequestBodySize proprietà.

Quando un'app esce out-of-process dietro il modulo core ASP.NET, IIS imposta il limite e Kestrelil limite di dimensioni del corpo della richiesta è disabilitato.

Velocità minima dei dati del corpo della richiesta

Kestrel controlla ogni secondo se i dati arrivano alla velocità specificata in byte al secondo. Se la frequenza scende al di sotto del valore minimo, si verifica il timeout della connessione. Il periodo di tolleranza è la quantità di tempo Kestrel che consente al client di aumentare la velocità di invio fino al minimo. La frequenza non viene controllata durante tale periodo. Il periodo di tolleranza consente di evitare l'eliminazione di connessioni che inizialmente inviano dati a una velocità lenta a causa del rallentamento dell'avvio TCP. Anche per la risposta è prevista una velocità minima.

MinRequestBodyDataRate ottiene o imposta la frequenza di dati minima del corpo della richiesta in byte al secondo. MinResponseDataRate ottiene o imposta la frequenza di dati minima della risposta in byte al secondo.

L'esempio seguente configura MinRequestBodyDataRate e MinResponseDataRate per tutte le richieste:

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

L'esempio seguente configura MinRequestBodyDataRate e MinResponseDataRate per una richiesta specifica usando IHttpMinRequestBodyDataRateFeature e IHttpMinResponseDataRateFeature in un middleware personalizzato:

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 non è presente in HttpContext.Features per le richieste HTTP/2. La modifica dei limiti di frequenza per ogni richiesta non è in genere supportata per HTTP/2 a causa del supporto del protocollo per la richiesta di multiplexing. Tuttavia, IHttpMinRequestBodyDataRateFeature è ancora presente per HttpContext.Features le richieste HTTP/2, perché il limite di velocità di lettura può comunque essere disabilitato interamente per ogni richiesta impostando IHttpMinResponseDataRateFeature.MinDataRate su null, anche per una richiesta HTTP/2. Tenta di leggere IHttpMinRequestBodyDataRateFeature.MinDataRate o tentare di impostarlo su un valore diverso dal null risultato per NotSupportedException le richieste HTTP/2.

I limiti di velocità a livello di server configurati tramite KestrelServerOptions.Limits vengono tuttavia applicati alle connessioni HTTP/1.x e HTTP/2.

Timeout delle intestazioni delle richieste

RequestHeadersTimeout ottiene o imposta la quantità massima di tempo trascorso dal server per la ricezione delle intestazioni della richiesta:

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

Questo timeout non viene applicato quando un debugger è collegato al Kestrel processo.

Limiti HTTP/2

I limiti in questa sezione vengono impostati su KestrelServerLimits.Http2.

Numero massimo di flussi per connessione

MaxStreamsPerConnection limita il numero di flussi di richieste simultanee per ogni connessione HTTP/2. I flussi in eccesso vengono rifiutati:

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

Dimensioni della tabella delle intestazioni

HeaderTableSize limita le dimensioni delle tabelle di compressione delle intestazioni, in ottetti, il codificatore HPACK e il decodificatore nel server possono usare. Il decodificatore HPACK decomprime le intestazioni HTTP per le connessioni HTTP/2:

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

Dimensione massima del frame

MaxFrameSize indica le dimensioni del payload del frame più grande che può essere ricevuto, in ottetti:

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

Dimensioni massime dell'intestazione della richiesta

MaxRequestHeaderFieldSize indica le dimensioni massime consentite di una sequenza di campi dell'intestazione della richiesta. Questo limite si applica alle sequenze nome e valore nelle relative rappresentazioni compresse e non compresse:

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

Dimensioni della finestra di connessione iniziali

InitialConnectionWindowSize indica la quantità di dati del corpo della richiesta che il server è disposto a ricevere e memorizzare nel buffer alla volta aggregati in tutte le richieste (flussi) per ogni connessione:

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

Le richieste sono anche limitate da InitialStreamWindowSize.

Dimensioni della finestra di flusso iniziali

InitialStreamWindowSize indica la quantità di dati del corpo della richiesta che il server è disposto a ricevere e memorizzare nel buffer alla volta per ogni flusso:

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

Le richieste sono anche limitate da InitialConnectionWindowSize.

Configurazione ping keep-alive HTTP/2

Kestrel può essere configurato per inviare ping HTTP/2 ai client connessi. I ping HTTP/2 servono a più scopi:

• Mantenere attive le connessioni inattive. Alcuni client e server proxy chiudono le connessioni inattive. I ping HTTP/2 vengono considerati come attività in una connessione e impediscono la chiusura della connessione come inattiva.
• Chiudere le connessioni non integre. Le connessioni in cui il client non risponde al ping keep-alive nel tempo configurato vengono chiuse dal server.

Esistono due opzioni di configurazione correlate ai ping keep-alive HTTP/2:

• KeepAlivePingDelay è un oggetto TimeSpan che configura l'intervallo di ping. Il server invia un ping keep-alive al client se non riceve fotogrammi per questo periodo di tempo. I ping keep-alive vengono disabilitati quando questa opzione è impostata su TimeSpan.MaxValue.
• KeepAlivePingTimeout è un oggetto TimeSpan che configura il timeout del ping. Se il server non riceve fotogrammi, ad esempio un ping di risposta, durante questo timeout la connessione viene chiusa. Il timeout Keep alive è disabilitato quando questa opzione è impostata su TimeSpan.MaxValue.

Nell'esempio seguente vengono impostati KeepAlivePingDelay e KeepAlivePingTimeout:

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

Altre opzioni

I/O sincrono

AllowSynchronousIO controlla se l'I/O sincrono è consentito per la richiesta e la risposta.

Avviso

Un numero elevato di operazioni di I/O sincrone bloccanti può causare la fame del pool di thread, che rende l'app non risponde. Abilitare AllowSynchronousIO solo quando si usa una libreria che non supporta l'I/O asincrona.

L'esempio seguente abilita l'I/O sincrono:

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

Per informazioni su altre Kestrel opzioni e limiti, vedere:

• KestrelServerOptions
• KestrelServerLimits
• ListenOptions

Comportamento con debugger collegato

Alcuni timeout e limiti di frequenza non vengono applicati quando un debugger è collegato a un Kestrel processo. Per altre informazioni, vedere Comportamento con debugger collegato.