Konfigurace možností pro ASP.NET Core Kestrel serveru

  • Článek
  • 4 min ke čtení

Webový server má možnosti konfigurace omezení, které jsou užitečné zejména v Kestrel nasazeních s přístupem k internetu.

Pokud chcete po zavolání poskytnout další ConfigureWebHostDefaults konfiguraci, použijte ConfigureKestrel :

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

Nastavte Limits omezení vlastnosti KestrelServerOptions třídy . Vlastnost Limits obsahuje instanci třídy KestrelServerLimits .

Následující příklady používají obor Microsoft.AspNetCore.Server.Kestrel.Core názvů :

using Microsoft.AspNetCore.Server.Kestrel.Core;

V příkladech uvedených dále v tomto článku jsou Kestrel možnosti nakonfigurovány v kódu jazyka C#. Kestrel Možnosti lze nastavit také pomocí zprostředkovatele konfigurace. Zprostředkovatel konfigurace souboru může například načíst Kestrel konfiguraci ze appsettings.json souboru appsettings.{Environment}.json nebo:

{
  "Kestrel": {
    "Limits": {
      "MaxConcurrentConnections": 100,
      "MaxConcurrentUpgradedConnections": 100
    },
    "DisableStringReuse": true
  }
}

Poznámka

KestrelServerOptions Konfigurace koncových bodů a se zprostředkovateli konfigurace nakonfigurují. Zbývající Kestrel konfigurace musí být nakonfigurovaná v kódu C#.

Použijte jeden z následujících přístupů:

  • Konfigurace Kestrel v Startup.ConfigureServices nástroji :

    1. Vloží instanci IConfiguration do Startup třídy . Následující příklad předpokládá, že injektovaná konfigurace je přiřazena k Configuration vlastnosti .

    2. V Startup.ConfigureServices souboru Kestrel načtěte oddíl konfigurace Kestrel do konfigurace nástroje :

      using Microsoft.Extensions.Configuration

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        services.Configure<KestrelServerOptions>(
            Configuration.GetSection("Kestrel"));
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        ...
    }
}

  • Konfigurace Kestrel při sestavování hostitele:

    V Program.cs souboru Kestrel načtěte oddíl konfigurace Kestrel do konfigurace nástroje :

    // using Microsoft.Extensions.DependencyInjection;

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureServices((context, services) =>
        {
            services.Configure<KestrelServerOptions>(
                context.Configuration.GetSection("Kestrel"));
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

Oba výše uvedené přístupy fungují s libovolným poskytovatelem konfigurace.

Obecná omezení

Časový limit pro keep-alive

KeepAliveTimeout

Získá nebo nastaví časový limit udržovat. Výchozí hodnota je 2 minuty.

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

Maximální počet připojení klientů

MaxConcurrentConnections
MaxConcurrentUpgradedConnections

Maximální počet souběžných otevřených připojení TCP je možné nastavit pro celou aplikaci s následujícím kódem:

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

Pro připojení upgradovaná z HTTP nebo HTTPS na jiný protokol (například u požadavku WebSockets) existuje samostatné omezení. Po upgradu se připojení do tohoto limitu MaxConcurrentConnections nezapočítá.

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

Maximální počet připojení je ve výchozím nastavení neomezený (null).

Maximální velikost textu požadavku

MaxRequestBodySize

Výchozí maximální velikost textu požadavku je 30 000 000 bajtů, což je přibližně 28,6 MB.

Doporučený přístup k přepsání limitu v aplikaci ASP.NET Core MVC je použití atributu RequestSizeLimitAttribute v metodě akce:

[RequestSizeLimit(100000000)]
public IActionResult MyActionMethod()

Následující příklad ukazuje, jak nakonfigurovat omezení pro aplikaci při každém požadavku:

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

Přepište nastavení pro konkrétní požadavek v middlewaru:

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

Pokud aplikace nakonfiguruje limit požadavku poté, co aplikace začala požadavek číst, vyvolá se výjimka. Existuje vlastnost, která označuje, jestli je vlastnost ve stavu jen pro čtení, což znamená, že je příliš IsReadOnly MaxRequestBodySize pozdě na konfiguraci limitu.

Pokud je aplikace mimo proces za limitem ASP.NET Core,je limit velikosti textu požadavku Kestrel zakázán. Služba IIS už tento limit nastavuje.

Minimální přenosová rychlost textu požadavku

MinRequestBodyDataRate
MinResponseDataRate

Kestrel kontroluje každou sekundu, pokud data přicházejí zadanou rychlostí v bajtech za sekundu. Pokud rychlost klesne pod minimum, dojde k časovému limitu připojení. Období odkladu je doba, po kterou může klient zvýšit svou rychlost odesílání Kestrel až na minimum. Během této doby se sazba nekontrolovala. Období odkladu pomáhá zabránit zahazování připojení, která zpočátku odesílají data pomalou rychlostí kvůli pomalému spuštění protokolu TCP.

Výchozí minimální frekvence je 240 bajtů za sekundu s obdobím odkladu 5 sekund.

Minimální sazba platí také pro odpověď. Kód pro nastavení limitu požadavků a limitu odpovědi je stejný s výjimkou kódu nebo v RequestBody Response názvech vlastností a rozhraní.

Tady je příklad, který ukazuje, jak nakonfigurovat minimální přenosovou rychlost v Program.cs nástroji :

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

Přepsání minimálních limitů přenosové rychlosti na požadavek v middlewaru:

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

Odkazovaný IHttpMinResponseDataRateFeature v předchozí ukázce se v pro požadavky HttpContext.Features HTTP/2 neukazuje. Změna omezení rychlosti pro každý požadavek se obecně nepodporuje pro HTTP/2 kvůli podpoře multiplexingu požadavků protokolem. Pro požadavky HTTP/2 však stále existuje , protože limit frekvence čtení je stále možné zcela zakázat pro každý požadavek nastavením i na požadavek IHttpMinRequestBodyDataRateFeature HttpContext.Features IHttpMinResponseDataRateFeature.MinDataRate null HTTP/2. Při pokusu o čtení nebo pokusu o nastavení na jinou hodnotu než se vyvolá požadavek IHttpMinRequestBodyDataRateFeature.MinDataRate null NotSupportedException HTTP/2.

Omezení přenosové rychlosti na úrovni serveru nakonfigurovaná prostřednictvím stále platí pro připojení KestrelServerOptions.Limits HTTP/1.x i HTTP/2.

Časový limit hlaviček požadavků

RequestHeadersTimeout

Získá nebo nastaví maximální dobu, po kterou server stráví přijímáním hlaviček požadavků. Výchozí hodnota je 30 sekund.

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

Omezení HTTP/2

Omezení v této části jsou nastavená na KestrelServerLimits.Http2 .

Maximální počet datových proudů na připojení

MaxStreamsPerConnection

Omezuje počet souběžných streamů požadavků na připojení HTTP/2. Nadbytečné datové proudy se zamítnou.

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

Výchozí hodnota je 100.

Velikost tabulky záhlaví

HeaderTableSize

Dekodér HPACK dekomprimuje hlavičky HTTP pro připojení HTTP/2. HeaderTableSize omezuje velikost tabulky komprese hlaviček, kterou dekodér HPACK používá. Hodnota je zadaná v oktech a musí být větší než nula (0).

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

Výchozí hodnota je 4096.

Maximální velikost rámce

MaxFrameSize

Určuje maximální povolenou velikost datové části rámce připojení HTTP/2 přijaté nebo odeslané serverem. Hodnota se poskytuje v oktetech a musí být mezi 2^14 (16 384) a 2^24-1 (16 777 215).

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

Výchozí hodnota je 2^14 (16 384).

Maximální velikost hlavičky požadavku

MaxRequestHeaderFieldSize

Určuje maximální povolenou velikost v oktetech hodnot hlavičky požadavku. Toto omezení platí pro název i hodnotu v komprimovaných i nekomprimovaných reprezentacích. Hodnota musí být větší než nula (0).

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

Výchozí hodnota je 8 192.

Velikost počátečního okna připojení

InitialConnectionWindowSize

Určuje maximální objem dat textu požadavku v bajtech, které server do vyrovnávací paměti najednou agreguje napříč všemi požadavky (datovými proudy) na připojení. Požadavky jsou také omezeny pomocí Http2.InitialStreamWindowSize . Hodnota musí být větší nebo rovna 65 535 a menší než 2^31 (2 147 483 648).

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

Výchozí hodnota je 128 kB (131 072).

Velikost okna počátečního streamu

InitialStreamWindowSize

Určuje maximální velikost dat textu požadavku v bajtech, které server na požadavek (stream) do vyrovnávací paměti zasáizuje najednou. Požadavky jsou také omezeny pomocí InitialConnectionWindowSize . Hodnota musí být větší nebo rovna 65 535 a menší než 2^31 (2 147 483 648).

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

Výchozí hodnota je 96 kB (98 304).

Konfigurace příkazu ping http/2 keep alive

Kestrel lze nakonfigurovat tak, aby odesílala http/2 ping připojeným klientům. Příkaz ping HTTP/2 slouží k několika účelům:

  • Udržujte nečinná připojení v režimu alive. Někteří klienti a proxy servery ukončeí nečinná připojení. Příkaz ping HTTP/2 se považuje za aktivitu připojení a brání uzavření připojení jako nečinné.
  • Ukončete připojení, která není v pořádku. Server zavře připojení, u kterých klient nereaguje na příkaz ping pro udržovaný v nakonfigurované době.

Existují dvě možnosti konfigurace související s příkazem ping http/2 keep alive:

  • KeepAlivePingDelay je , TimeSpan který konfiguruje interval příkazu ping. Pokud server v tomto časovém období neobdrží žádné snímky, odešle klientovi příkaz ping pro udržový příkaz ping. Pokud je tato možnost nastavená na hodnotu , příkaz ping pro udržované připojení je TimeSpan.MaxValue zakázaný. Výchozí hodnota je TimeSpan.MaxValue.
  • KeepAlivePingTimeout je , TimeSpan který konfiguruje časový limit příkazu ping. Pokud server během tohoto časového limitu neobdrží žádné snímky, například příkaz ping odpovědi, připojení se zavře. Pokud je tato možnost nastavená na hodnotu , je časový limit funkce Keep Alive TimeSpan.MaxValue zakázaný. Výchozí hodnota je 20 sekund.
webBuilder.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.Http2.KeepAlivePingDelay = TimeSpan.FromSeconds(30);
    serverOptions.Limits.Http2.KeepAlivePingTimeout = TimeSpan.FromSeconds(60);
});

Další možnosti

Synchronní vstupně-výstupní operace

AllowSynchronousIO určuje, jestli je pro požadavek a odpověď povolen synchronní vstupně-výstupní operace. Výchozí hodnota je false.

Upozornění

Velký počet blokující synchronních vstupně-výstupních operací může vést k tomu, že fond vláken přestane reagovat. Tuto možnost AllowSynchronousIO povolte pouze v případě, že používáte knihovnu, která nepodporuje asynchronní V/V operace.

Následující příklad povolí synchronní vstupně-výstupní operace:

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

Další informace o dalších Kestrel možnostech a omezeních najdete v těchto tématu: