Konfigurowanie opcji serwera internetowego ASP.NET Core Kestrel

Serwer Kestrel internetowy ma opcje konfiguracji ograniczeń, które są szczególnie przydatne we wdrożeniach dostępnych z Internetu. Aby skonfigurować Kestrel opcje konfiguracji, wywołaj metodę ConfigureKestrel w pliku Program.cs:

var builder = WebApplication.CreateBuilder(args);

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

Ustaw ograniczenia dla KestrelServerOptions.Limits właściwości . Ta właściwość zawiera wystąpienie KestrelServerLimits klasy .

Ogólne limity

Limit czasu utrzymania aktywności

KeepAliveTimeoutpobiera lub ustawia limit czasu utrzymania aktywności:

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

Ten limit czasu nie jest wymuszany, gdy debuger jest dołączony do Kestrel procesu.

Maksymalna liczba połączeń klientów

MaxConcurrentConnections pobiera lub ustawia maksymalną liczbę otwartych połączeń:

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

MaxConcurrentUpgradedConnections pobiera lub ustawia maksymalną liczbę otwartych, uaktualnionych połączeń:

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

Uaktualnione połączenie to połączenie, które zostało przełączone z protokołu HTTP do innego protokołu, takiego jak WebSockets. Po uaktualnieniu połączenia nie jest uwzględniany MaxConcurrentConnections limit.

Maksymalny rozmiar treści żądania

MaxRequestBodySize pobiera lub ustawia maksymalny dozwolony rozmiar dowolnej treści żądania w bajtach.

Zalecanym podejściem do zastąpienia limitu w aplikacji ASP.NET Core MVC jest użycie atrybutu RequestSizeLimitAttribute w metodzie akcji:

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

Poniższy przykład umożliwia skonfigurowanie MaxRequestBodySize wszystkich żądań:

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

Poniższy przykład umożliwia skonfigurowanie MaxRequestBodySize dla określonego żądania przy użyciu IHttpMaxRequestBodySizeFeature niestandardowego oprogramowania pośredniczącego:

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

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

    // ...

    await next(context);
});

Jeśli aplikacja próbuje skonfigurować limit żądania po rozpoczęciu odczytywania żądania, zgłaszany jest wyjątek. Ue właściwość IHttpMaxRequestBodySizeFeature.IsReadOnly , aby sprawdzić, czy właściwość jest bezpieczna MaxRequestBodySize .

Gdy aplikacja kończy się poza procesem za modułem ASP.NET Core, usługi IIS ustawiają limit i Kestrellimit rozmiaru treści żądania jest wyłączony.

Minimalna szybkość danych treści żądania

Kestrel sprawdza co sekundę, czy dane docierają do określonej stawki w bajtach/sekundach. Jeśli szybkość spadnie poniżej minimum, przekroczono limit czasu połączenia. Okres prolongaty to czas Kestrel , przez który klient może zwiększyć szybkość wysyłania do minimum. Stawka nie jest sprawdzana w tym czasie. Okres prolongaty pomaga uniknąć porzucania połączeń, które początkowo wysyłają dane z powodu powolnego uruchamiania protokołu TCP. Minimalna stawka ma również zastosowanie do odpowiedzi.

MinRequestBodyDataRate pobiera lub ustawia minimalną szybkość danych treści żądania w bajtach/sekundach. MinResponseDataRate pobiera lub ustawia minimalną szybkość danych odpowiedzi w bajtach/sekundach.

Poniższy przykład konfiguruje MinRequestBodyDataRate i MinResponseDataRate dla wszystkich żądań:

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

Poniższy przykład konfiguruje MinRequestBodyDataRate i MinResponseDataRate dla określonego żądania przy użyciu IHttpMinRequestBodyDataRateFeature oprogramowania pośredniczącego i IHttpMinResponseDataRateFeature w niestandardowym programie pośredniczącym:

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 nie jest obecny dla HttpContext.Features żądań HTTP/2. Modyfikowanie limitów szybkości dla poszczególnych żądań nie jest ogólnie obsługiwane dla protokołu HTTP/2 z powodu obsługi żądań multipleksowania protokołu. Jednak nadal występuje w HttpContext.Features żądaniach HTTP/2, IHttpMinRequestBodyDataRateFeature ponieważ limit szybkości odczytu można nadal wyłączyć całkowicie dla poszczególnych żądań, ustawiając IHttpMinResponseDataRateFeature.MinDataRatenullwartość , nawet w przypadku żądania HTTP/2. Próbuje odczytać IHttpMinRequestBodyDataRateFeature.MinDataRate lub spróbować ustawić ją na wartość inną niż null wynik NotSupportedException dla żądań HTTP/2.

Limity szybkości dla całego serwera skonfigurowane za pośrednictwem KestrelServerOptions.Limits nadal mają zastosowanie zarówno do połączeń HTTP/1.x, jak i HTTP/2.

Limit czasu nagłówków żądań

RequestHeadersTimeout pobiera lub ustawia maksymalny czas, jaki serwer poświęca na odbieranie nagłówków żądań:

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

Ten limit czasu nie jest wymuszany, gdy debuger jest dołączony do Kestrel procesu.

Limity HTTP/2

Limity w tej sekcji są ustawione na .KestrelServerLimits.Http2

Maksymalna liczba strumieni na połączenie

MaxStreamsPerConnection ogranicza liczbę współbieżnych strumieni żądań na połączenie HTTP/2. Nadmiarowe strumienie są odrzucane:

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

Rozmiar tabeli nagłówka

HeaderTableSize ogranicza rozmiar tabel kompresji nagłówka, w oktetach, koder HPACK i dekoder na serwerze może używać. Dekoder HPACK dekompresuje nagłówki HTTP dla połączeń HTTP/2:

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

Maksymalny rozmiar ramki

MaxFrameSize wskazuje rozmiar największego ładunku ramki, który może zostać odebrany, w oktetach:

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

Maksymalny rozmiar nagłówka żądania

MaxRequestHeaderFieldSize wskazuje rozmiar maksymalnego dozwolonego rozmiaru sekwencji pól nagłówka żądania. Ten limit dotyczy zarówno sekwencji nazw, jak i wartości w skompresowanych i nieskompresowanych reprezentacjach:

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

Początkowy rozmiar okna połączenia

InitialConnectionWindowSize wskazuje, ile danych treści żądania serwer chce odbierać i buforować w czasie zagregowanym we wszystkich żądaniach (strumieniach) na połączenie:

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

Żądania są również ograniczone przez InitialStreamWindowSize.

Rozmiar okna początkowego strumienia

InitialStreamWindowSize wskazuje ilość danych treści żądania, które serwer chce odbierać i buforować w danym momencie na strumień:

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

Żądania są również ograniczone przez InitialConnectionWindowSize.

Konfiguracja polecenia ping http/2

Kestrel Można skonfigurować do wysyłania poleceń ping HTTP/2 do połączonych klientów. Polecenia ping HTTP/2 obsługują wiele celów:

• Zachowaj bezczynność połączeń. Niektórzy klienci i serwery proxy zamykają połączenia bezczynne. Polecenia ping HTTP/2 są traktowane jako działanie w połączeniu i uniemożliwiają zamknięcie połączenia jako bezczynne.
• Zamknij połączenia w złej kondycji. Połączenie, w których klient nie odpowiada na polecenie ping w skonfigurowanym czasie, są zamykane przez serwer.

Istnieją dwie opcje konfiguracji związane z poleceniami ping http/2:

• KeepAlivePingDelay to element TimeSpan , który konfiguruje interwał ping. Serwer wysyła do klienta polecenie ping keep alive, jeśli nie otrzyma żadnych ramek przez ten okres czasu. Zachowaj aktywne polecenia ping są wyłączone, gdy ta opcja jest ustawiona na TimeSpan.MaxValue.
• KeepAlivePingTimeout to element TimeSpan , który konfiguruje limit czasu ping. Jeśli serwer nie otrzyma żadnych ramek, takich jak polecenie ping odpowiedzi, podczas tego limitu czasu połączenie zostanie zamknięte. Zachowaj przy życiu limit czasu jest wyłączony, gdy ta opcja jest ustawiona na TimeSpan.MaxValuewartość .

Następujące przykładowe zestawy KeepAlivePingDelay i KeepAlivePingTimeout:

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

Inne opcje

Synchroniczne operacje we/wy

AllowSynchronousIO określa, czy synchroniczne operacje we/wy są dozwolone dla żądania i odpowiedzi.

Ostrzeżenie

Duża liczba blokowania synchronicznych operacji we/wy może prowadzić do głodu puli wątków, co sprawia, że aplikacja nie odpowiada. Włącz AllowSynchronousIO tylko w przypadku korzystania z biblioteki, która nie obsługuje asynchronicznych operacji we/wy.

Poniższy przykład umożliwia synchroniczne operacje we/wy:

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

Aby uzyskać informacje o innych Kestrel opcjach i limitach, zobacz:

• KestrelServerOptions
• KestrelServerLimits
• ListenOptions

Zachowanie z dołączonym debugerem

Niektóre limity czasu i limity szybkości nie są wymuszane, gdy debuger jest dołączony do Kestrel procesu. Aby uzyskać więcej informacji, zobacz Zachowanie z dołączonym debugerem.