Nota
O acesso a esta página requer autorização. Podes tentar iniciar sessão ou mudar de diretório.
O acesso a esta página requer autorização. Podes tentar mudar de diretório.
Observação
Esta não é a versão mais recente deste artigo. Para a versão atual, consulte a versão .NET 10 deste artigo.
Advertência
Esta versão do ASP.NET Core não é mais suportada. Para obter mais informações, consulte a Política de suporte do .NET e do .NET Core. Para a versão atual, consulte a versão .NET 10 deste artigo.
O Kestrel servidor Web tem opções de configuração de restrição que são especialmente úteis em implantações voltadas para a Internet. Para configurar Kestrel as opções de configuração, chame ConfigureKestrel :Program.cs
var builder = WebApplication.CreateBuilder(args);
builder.WebHost.ConfigureKestrel(serverOptions =>
{
// ...
});
Defina restrições na KestrelServerOptions.Limits propriedade. Esta propriedade contém uma instância da KestrelServerLimits classe.
Limites gerais
Tempo limite de manter-vivo
KeepAliveTimeout Obtém ou define o tempo limite de keep-alive:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
});
Esse tempo limite não é imposto quando um depurador é anexado Kestrel ao processo.
Máximo de conexões de cliente
MaxConcurrentConnections Obtém ou define o número máximo de conexões abertas:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.MaxConcurrentConnections = 100;
});
MaxConcurrentUpgradedConnections Obtém ou define o número máximo de conexões abertas e atualizadas:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.MaxConcurrentUpgradedConnections = 100;
});
Uma conexão atualizada é aquela que foi trocada de HTTP para outro protocolo, como WebSockets. Depois que uma conexão é atualizada, ela não é contada para o MaxConcurrentConnections limite.
Tamanho máximo do corpo do pedido
MaxRequestBodySize Obtém ou define o tamanho máximo permitido de qualquer corpo de solicitação em bytes.
A abordagem recomendada para substituir o limite em um aplicativo ASP.NET Core MVC é usar o RequestSizeLimitAttribute atributo em um método de ação:
[RequestSizeLimit(100_000_000)]
public IActionResult Get()
O exemplo a seguir configura para todas as MaxRequestBodySize solicitações:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.MaxRequestBodySize = 100_000_000;
});
O exemplo a MaxRequestBodySize seguir configura para uma solicitação específica usando IHttpMaxRequestBodySizeFeature em um middleware personalizado:
app.Use(async (context, next) =>
{
var httpMaxRequestBodySizeFeature = context.Features.Get<IHttpMaxRequestBodySizeFeature>();
if (httpMaxRequestBodySizeFeature is not null)
httpMaxRequestBodySizeFeature.MaxRequestBodySize = 10 * 1024;
// ...
await next(context);
});
Se o aplicativo tentar configurar o limite em uma solicitação depois de começar a ler a solicitação, uma exceção será lançada. Ue a IHttpMaxRequestBodySizeFeature.IsReadOnly propriedade para verificar se é seguro definir a MaxRequestBodySize propriedade.
Quando um aplicativo é executado fora do processo atrás do ASP.NET Módulo Principal, o IIS define o limite e Kestrelo limite de tamanho do corpo da solicitação é desabilitado.
Taxa mínima de dados do corpo do pedido
Kestrel verifica a cada segundo se os dados estão chegando à taxa especificada em bytes/segundo. Se a taxa cair abaixo do mínimo, a conexão será expirada. O período de carência é a quantidade de tempo Kestrel que permite ao cliente aumentar a sua taxa de envio até ao mínimo. A taxa não é verificada durante esse período. O período de carência ajuda a evitar a queda de conexões que inicialmente estão enviando dados em uma taxa lenta devido ao início lento do TCP. Uma taxa mínima também se aplica à resposta.
MinRequestBodyDataRate Obtém ou define a taxa mínima de dados do corpo da solicitação em bytes/segundo. MinResponseDataRate Obtém ou define a taxa mínima de dados de resposta em bytes/segundo.
O exemplo a seguir configura e MinRequestBodyDataRate para todas as MinResponseDataRate solicitações:
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));
});
O exemplo a MinRequestBodyDataRate seguir configura e MinResponseDataRate para uma solicitação específica usando IHttpMinRequestBodyDataRateFeature e IHttpMinResponseDataRateFeature em um middleware personalizado:
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 não está presente para HttpContext.Features solicitações HTTP/2. A modificação de limites de taxa por solicitação geralmente não é suportada para HTTP/2 devido ao suporte do protocolo para multiplexação de solicitação. No entanto, ainda está presente para IHttpMinRequestBodyDataRateFeature solicitações HTTP/2, porque o limite de taxa de leitura ainda pode ser HttpContext.Features por solicitação, definindo IHttpMinResponseDataRateFeature.MinDataRate como null, mesmo para uma solicitação HTTP/2. Tentativas de leitura IHttpMinRequestBodyDataRateFeature.MinDataRate ou tentativas de defini-lo para um valor diferente de null resultar em um NotSupportedException para solicitações HTTP/2.
Os limites de taxa em todo o servidor configurados via KestrelServerOptions.Limits ainda se aplicam a conexões HTTP/1.x e HTTP/2.
Tempo limite de cabeçalhos de solicitação
RequestHeadersTimeout Obtém ou define a quantidade máxima de tempo que o servidor gasta recebendo cabeçalhos de solicitação:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.RequestHeadersTimeout = TimeSpan.FromMinutes(1);
});
Esse tempo limite não é imposto quando um depurador é anexado Kestrel ao processo.
Limites HTTP/2
Os limites nesta secção são definidos em KestrelServerLimits.Http2.
Máximo de fluxos por ligação
MaxStreamsPerConnection limita o número de fluxos de solicitação simultâneos por conexão HTTP/2. Os fluxos excedentários são recusados:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.MaxStreamsPerConnection = 100;
});
Tamanho da tabela de cabeçalho
HeaderTableSize limita o tamanho das tabelas de compressão de cabeçalho, em octetos, o codificador e decodificador HPACK no servidor pode usar. O decodificador HPACK descompacta cabeçalhos HTTP para conexões HTTP/2:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.HeaderTableSize = 4096;
});
Tamanho máximo do quadro
MaxFrameSize Indica o tamanho da maior carga útil do quadro que pode ser recebida, em octetos:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.MaxFrameSize = 16_384;
});
Tamanho máximo do cabeçalho da solicitação
MaxRequestHeaderFieldSize Indica o tamanho do tamanho máximo permitido de uma sequência de campos de cabeçalho de solicitação. Este limite aplica-se a sequências de nome e valor nas suas representações comprimidas e não comprimidas:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.MaxRequestHeaderFieldSize = 8192;
});
Tamanho da janela de conexão inicial
InitialConnectionWindowSize Indica a quantidade de dados do corpo da solicitação que o servidor está disposto a receber e armazenar em buffer de cada vez agregados em todas as solicitações (fluxos) por conexão:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.InitialConnectionWindowSize = 131_072;
});
Os pedidos também são limitados por InitialStreamWindowSize.
Tamanho da janela de fluxo inicial
InitialStreamWindowSize Indica a quantidade de dados do corpo da solicitação que o servidor está disposto a receber e armazenar em buffer de cada vez por fluxo:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.InitialStreamWindowSize = 98_304;
});
Os pedidos também são limitados por InitialConnectionWindowSize.
HTTP/2 manter a configuração de ping ativa
Kestrel pode ser configurado para enviar pings HTTP/2 para clientes conectados. Os pings HTTP/2 servem múltiplos propósitos:
- Mantenha as conexões ociosas vivas. Alguns clientes e servidores proxy fecham conexões que estão ociosas. Os pings HTTP/2 são considerados como atividade em uma conexão e impedem que a conexão seja fechada como ociosa.
- Feche conexões não íntegras. As conexões em que o cliente não responde ao ping de manutenção ativa no tempo configurado são fechadas pelo servidor.
Há duas opções de configuração relacionadas a HTTP/2 manter pings vivos:
- KeepAlivePingDelay é um TimeSpan que configura o intervalo de ping. O servidor envia um ping de manutenção ativa para o cliente se ele não receber nenhum quadro para esse período de tempo. Os pings Manter ativos são desativados quando esta opção está definida como TimeSpan.MaxValue.
- KeepAlivePingTimeout é um TimeSpan que configura o tempo limite de ping. Se o servidor não receber nenhum quadro, como um ping de resposta, durante esse tempo limite, a conexão será fechada. Manter tempo limite ativo é desativado quando esta opção é definida como TimeSpan.MaxValue.
Os seguintes exemplos são definidos KeepAlivePingDelay e KeepAlivePingTimeout:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.KeepAlivePingDelay = TimeSpan.FromSeconds(30);
serverOptions.Limits.Http2.KeepAlivePingTimeout = TimeSpan.FromMinutes(1);
});
Outras opções
E/S Síncrona
AllowSynchronousIO controla se a E/S síncrona é permitida para a solicitação e a resposta.
Advertência
Um grande número de operações de E/S síncronas de bloqueio pode levar à fome do pool de threads, o que faz com que o aplicativo não responda. Habilite AllowSynchronousIO apenas ao usar uma biblioteca que não ofereça suporte a E/S assíncronas.
O exemplo a seguir habilita E/S síncronas:
builder.WebHost.ConfigureKestrel(serverOptions =>
{
serverOptions.AllowSynchronousIO = true;
});
Para obter informações sobre outras Kestrel opções e limites, consulte:
Comportamento com o depurador anexado
As seguintes opções de limite de tempo limite e taxa não são impostas quando um depurador é anexado a um Kestrel processo:
O Kestrel servidor Web tem opções de configuração de restrição que são especialmente úteis em implantações voltadas para a Internet.
Para fornecer mais configuração após a chamada ConfigureWebHostDefaults, use ConfigureKestrel:
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.ConfigureKestrel(serverOptions =>
{
// Set properties and call methods on options
})
.UseStartup<Startup>();
});
Defina restrições na Limits propriedade da KestrelServerOptions classe. A Limits propriedade contém uma instância da KestrelServerLimits classe.
Os exemplos a seguir usam o Microsoft.AspNetCore.Server.Kestrel.Core namespace:
using Microsoft.AspNetCore.Server.Kestrel.Core;
Observação
KestrelServerOptions e a configuração do ponto final é configurável a partir de provedores de configuração. A configuração restante Kestrel deve ser configurada em código C#.
Limites gerais
Tempo limite de manter-vivo
Obtém ou define o tempo limite de keep-alive. O padrão é de 2 minutos.
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);
})
Máximo de conexões de cliente
MaxConcurrentConnections
MaxConcurrentUpgradedConnections
O número máximo de conexões TCP abertas simultâneas pode ser definido para todo o aplicativo com o seguinte código:
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);
})
Há um limite separado para conexões que foram atualizadas de HTTP ou HTTPS para outro protocolo (por exemplo, em uma solicitação WebSockets). Depois que uma conexão é atualizada, ela não é contada para o MaxConcurrentConnections limite.
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);
})
O número máximo de conexões é ilimitado (nulo) por padrão.
Tamanho máximo do corpo do pedido
O tamanho máximo padrão do corpo da solicitação é de 30.000.000 bytes, o que equivale a aproximadamente 28,6 MB.
A abordagem recomendada para substituir o limite em um aplicativo ASP.NET Core MVC é usar o RequestSizeLimitAttribute atributo em um método de ação:
[RequestSizeLimit(100000000)]
public IActionResult MyActionMethod()
O exemplo a seguir mostra como configurar a restrição para o aplicativo em cada solicitação:
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);
})
Substitua a configuração em uma solicitação específica no 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));
}
Uma exceção será lançada se o aplicativo configurar o limite em uma solicitação depois que o aplicativo começar a ler a solicitação. Há uma IsReadOnly propriedade que indica se a MaxRequestBodySize propriedade está em estado somente leitura, o que significa que é tarde demais para configurar o limite.
Quando um aplicativo é executado fora do processo atrás do ASP.NET Core Module, Kestrelo limite de tamanho do corpo da solicitação é desativado. O IIS já define o limite.
Taxa mínima de dados do corpo do pedido
MinRequestBodyDataRate
MinResponseDataRate
Kestrel verifica a cada segundo se os dados estão chegando à taxa especificada em bytes/segundo. Se a taxa cair abaixo do mínimo, a conexão será expirada. O período de carência é a quantidade de tempo Kestrel que permite ao cliente aumentar a sua taxa de envio até ao mínimo. A taxa não é verificada durante esse período. O período de carência ajuda a evitar a queda de conexões que inicialmente estão enviando dados em uma taxa lenta devido ao início lento do TCP.
A taxa mínima padrão é de 240 bytes/segundo com um período de carência de 5 segundos.
Uma taxa mínima também se aplica à resposta. O código para definir o limite de solicitação e o limite de resposta é o mesmo, exceto para ter RequestBody ou Response nos nomes de propriedade e interface.
Aqui está um exemplo que mostra como configurar as taxas mínimas de dados em 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);
})
Substitua os limites de taxa mínima por solicitação no 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));
}
O IHttpMinResponseDataRateFeature referenciado no exemplo anterior não está presente em HttpContext.Features solicitações HTTP/2. A modificação de limites de taxa por solicitação geralmente não é suportada para HTTP/2 devido ao suporte do protocolo para multiplexação de solicitação. No entanto, o IHttpMinRequestBodyDataRateFeature ainda está presente HttpContext.Features para solicitações HTTP/2, porque o limite de taxa de leitura ainda pode ser desativado inteiramente por solicitação, definindo IHttpMinResponseDataRateFeature.MinDataRate até mesmo para null uma solicitação HTTP/2. Tentar ler IHttpMinRequestBodyDataRateFeature.MinDataRate ou tentar defini-lo para um valor diferente resultará null em um NotSupportedException lançamento dado a uma solicitação HTTP/2.
Os limites de taxa em todo o servidor configurados via KestrelServerOptions.Limits ainda se aplicam a conexões HTTP/1.x e HTTP/2.
Tempo limite de cabeçalhos de solicitação
Obtém ou define a quantidade máxima de tempo que o servidor gasta recebendo cabeçalhos de solicitação. O padrão é de 30 segundos.
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);
})
Limites HTTP/2
Os limites nesta secção são definidos em KestrelServerLimits.Http2.
Máximo de fluxos por ligação
Limita o número de fluxos de solicitação simultâneos por conexão HTTP/2. Os fluxos em excesso são recusados.
webBuilder.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.MaxStreamsPerConnection = 100;
});
O valor padrão é 100.
Tamanho da tabela de cabeçalho
O decodificador HPACK descompacta cabeçalhos HTTP para conexões HTTP/2.
HeaderTableSize limita o tamanho da tabela de compressão de cabeçalho que o descodificador HPACK utiliza. O valor é fornecido em octetos e deve ser maior que zero (0).
webBuilder.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.HeaderTableSize = 4096;
});
O valor padrão é 4096.
Tamanho máximo do quadro
Indica o tamanho máximo permitido de uma carga útil de quadro de conexão HTTP/2 recebida ou enviada pelo servidor. O valor é fornecido em octetos e deve estar entre 2^14 (16.384) e 2^24-1 (16.777.215).
webBuilder.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.MaxFrameSize = 16384;
});
O valor padrão é 2^14 (16.384).
Tamanho máximo do cabeçalho da solicitação
Indica o tamanho máximo permitido em octetos de valores de cabeçalho de solicitação. Esse limite se aplica ao nome e ao valor em suas representações compactadas e não compactadas. O valor deve ser maior que zero (0).
webBuilder.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.MaxRequestHeaderFieldSize = 8192;
});
O valor padrão é 8.192.
Tamanho da janela de conexão inicial
Indica o máximo de dados do corpo da solicitação em bytes que o servidor armazena em buffer de uma só vez, agregados em todas as solicitações (fluxos) por conexão. Os pedidos também são limitados por Http2.InitialStreamWindowSize. O valor deve ser maior ou igual a 65.535 e menor que 2^31 (2.147.483.648).
webBuilder.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.InitialConnectionWindowSize = 131072;
});
O valor padrão é 128 KB (131.072).
Tamanho da janela de fluxo inicial
Indica o máximo de dados do corpo da solicitação em bytes que o servidor armazena em buffer de uma vez por solicitação (fluxo). Os pedidos também são limitados por InitialConnectionWindowSize. O valor deve ser maior ou igual a 65.535 e menor que 2^31 (2.147.483.648).
webBuilder.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.InitialStreamWindowSize = 98304;
});
O valor padrão é 96 KB (98.304).
HTTP/2 manter a configuração de ping ativa
Kestrel pode ser configurado para enviar pings HTTP/2 para clientes conectados. Os pings HTTP/2 servem múltiplos propósitos:
- Mantenha as conexões ociosas vivas. Alguns clientes e servidores proxy fecham conexões que estão ociosas. Os pings HTTP/2 são considerados como atividade em uma conexão e impedem que a conexão seja fechada como ociosa.
- Feche conexões não íntegras. As conexões em que o cliente não responde ao ping de manutenção ativa no tempo configurado são fechadas pelo servidor.
Há duas opções de configuração relacionadas a HTTP/2 manter pings vivos:
- KeepAlivePingDelay é um TimeSpan que configura o intervalo de ping. O servidor envia um ping de manutenção ativa para o cliente se ele não receber nenhum quadro para esse período de tempo. Os pings Manter ativos são desativados quando esta opção está definida como TimeSpan.MaxValue. O valor predefinido é TimeSpan.MaxValue.
- KeepAlivePingTimeout é um TimeSpan que configura o tempo limite de ping. Se o servidor não receber nenhum quadro, como um ping de resposta, durante esse tempo limite, a conexão será fechada. Manter tempo limite ativo é desativado quando esta opção é definida como TimeSpan.MaxValue. O valor padrão é 20 segundos.
webBuilder.ConfigureKestrel(serverOptions =>
{
serverOptions.Limits.Http2.KeepAlivePingDelay = TimeSpan.FromSeconds(30);
serverOptions.Limits.Http2.KeepAlivePingTimeout = TimeSpan.FromSeconds(60);
});
Outras opções
E/S Síncrona
AllowSynchronousIO controla se a E/S síncrona é permitida para a solicitação e a resposta. O valor predefinido é false.
Advertência
Um grande número de operações de E/S síncronas de bloqueio pode levar à fome do pool de threads, o que faz com que o aplicativo não responda. Habilite AllowSynchronousIO apenas ao usar uma biblioteca que não ofereça suporte a E/S assíncronas.
O exemplo a seguir habilita E/S síncronas:
webBuilder.ConfigureKestrel(serverOptions =>
{
serverOptions.AllowSynchronousIO = true;
})
Para obter informações sobre outras Kestrel opções e limites, consulte:
Colabore connosco no GitHub
A fonte deste conteúdo pode ser encontrada no GitHub, onde também pode criar e rever issues e pull requests. Para mais informações, consulte o nosso guia para colaboradores.
