Configurer les options du serveur web ASP.NET Core Kestrel

Le serveur web Kestrel a des options de configuration de contraintes qui sont particulièrement utiles dans les déploiements exposés à Internet. Pour configurer les options de configuration Kestrel, appelez ConfigureKestrel dans Program.cs :

var builder = WebApplication.CreateBuilder(args);

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

Définissez des contraintes sur la propriété KestrelServerOptions.Limits. Cette propriété conserve une instance de la classe KestrelServerLimits.

Limites générales

Délai d’expiration toujours actif

KeepAliveTimeout obtient ou définit le délai d’expiration Keep Alive :

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

Ce délai d’expiration n’est pas appliqué lorsqu’un débogueur est attaché au processus Kestrel.

Nombre maximale de connexions client

MaxConcurrentConnections obtient ou définit le nombre maximal de connexions ouvertes :

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

MaxConcurrentUpgradedConnections obtient ou définit le nombre maximal de connexions mises à niveau ouvertes :

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

Une connexion mise à niveau est une connexion qui a basculé du protocole HTTP vers un autre protocole, tel que WebSockets. Une fois mise à niveau, une connexion n’est pas prise en compte dans la limite MaxConcurrentConnections.

Taille maximale du corps de la requête

MaxRequestBodySize obtient ou définit la taille maximale autorisée pour le corps d’une demande, en octets.

Pour remplacer la limite dans une application ASP.NET Core MVC, nous vous recommandons d’utiliser l’attribut RequestSizeLimitAttribute sur une méthode d’action :

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

L’exemple suivant configure MaxRequestBodySize pour toutes les demandes :

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

L’exemple suivant configure MaxRequestBodySize pour une demande spécifique en utilisant IHttpMaxRequestBodySizeFeature dans un intergiciel personnalisé :

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

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

    // ...

    await next(context);
});

Si l’application tente de configurer la limite sur une demande après qu’elle a commencé à lire la demande, une exception est levée. Utilisez la propriété IHttpMaxRequestBodySizeFeature.IsReadOnly pour vérifier s’il est sûr de définir la propriété MaxRequestBodySize.

Lorsqu’une application s’exécute hors processus derrière le module ASP.NET Core, IIS définit la limite et la taille limite du corps de demande de Kestrel est désactivée.

Débit données minimal du corps de la requête

Kestrel vérifie à chaque seconde si les données arrivent au débit spécifié en octets/seconde. Si le débit est inférieur au minimum, la connexion expire. La période de grâce est la durée que Kestrel accorde au client pour augmenter son taux d’envoi jusqu’au minimum. Pendant cette période, le débit n’est pas vérifié. La période de grâce permet d’éviter la suppression des connexions qui, initialement, envoient des données à une vitesse réduite en raison de la lenteur du démarrage de TCP. Un débit minimal s’applique également à la réponse.

MinRequestBodyDataRate obtient ou définit le débit de données minimal du corps de demande en octets/seconde. MinResponseDataRate obtient ou définit le débit de données minimal de réponse en octets/seconde.

L’exemple suivant configure MinRequestBodyDataRate et MinResponseDataRate pour toutes les demandes :

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’exemple suivant configure MinRequestBodyDataRate et MinResponseDataRate pour une demande spécifique en utilisant IHttpMinRequestBodyDataRateFeature et IHttpMinResponseDataRateFeature dans un intergiciel personnalisé :

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’est pas présent dans HttpContext.Features pour les requêtes HTTP/2. La modification des limites de débit par demande n’est généralement pas prise en charge pour HTTP/2 en raison de la prise en charge du protocole pour le multiplexage des demandes. Toutefois, IHttpMinRequestBodyDataRateFeature est toujours présent dans HttpContext.Features pour les requêtes HTTP/2, car la limite de débit de lecture peut toujours être désactivée entièrement sur une base par demande en définissant IHttpMinResponseDataRateFeature.MinDataRate sur null même pour une requête HTTP/2. Les tentatives de lecture de IHttpMinRequestBodyDataRateFeature.MinDataRate ou les tentatives de définition de cet élément sur une valeur autre que null entraînent une exception NotSupportedException pour les requêtes HTTP/2.

Les limites de débit à l’échelle du serveur configurées par le biais de KestrelServerOptions.Limits s’appliquent encore aux connexions HTTP/1.x et HTTP/2.

Délai d’expiration des en-têtes de requête

RequestHeadersTimeout obtient ou définit la durée maximale passée par le serveur à recevoir des en-têtes de demande :

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

Ce délai d’expiration n’est pas appliqué lorsqu’un débogueur est attaché au processus Kestrel.

Limites HTTP/2

Les limites de cette section sont définies sur KestrelServerLimits.Http2.

Flux de données maximal par connexion

MaxStreamsPerConnection limite le nombre de flux de requête simultanée par connexion HTTP/2. Les flux de données excédentaires sont refusés :

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

Taille de la table d’en-tête

HeaderTableSize limite la taille des tables de compression d’en-tête, en octets, que l’encodeur et le décodeur HPACK sur le serveur peuvent utiliser. Le décodeur HPACK décompresse les en-têtes HTTP pour les connexions HTTP/2 :

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

Taille de trame maximale

MaxFrameSize indique la taille de la plus grande charge utile de trame autorisée à être reçue, en octets :

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

Taille maximale d’en-tête de requête

MaxRequestHeaderFieldSize indique la taille de la taille maximale autorisée d’une séquence de champs d’en-tête de demande. Cette limite s’applique aux séquences de noms et de valeurs dans leurs représentations compressées et non compressées :

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

Taille de fenêtre de connexion initiale

InitialConnectionWindowSize indique la quantité de données de corps de demande que le serveur est prêt à recevoir et à mettre en mémoire tampon à la fois, agrégée entre toutes les demandes (flux) par connexion :

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

Les requêtes sont également limitées par InitialStreamWindowSize.

Taille de la fenêtre de flux initiale

InitialStreamWindowSize indique la quantité de données de corps de demande que le serveur est prêt à recevoir et à mettre en mémoire tampon à la fois par flux :

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

Les requêtes sont également limitées par InitialConnectionWindowSize.

Configuration des requêtes ping Keep Alive HTTP/2

Kestrel peut être configuré pour envoyer des requêtes ping HTTP/2 aux clients connectés. Les requêtes ping HTTP/2 ont plusieurs objectifs :

• Maintenir actives les connexions inactives. Certains clients et serveurs proxy ferment les connexions inactives. Les requêtes ping HTTP/2 sont considérées comme une activité sur une connexion et empêchent la fermeture de la connexion pour cause d’inactivité.
• Fermez les connexions non saines. Les connexions où le client ne répond pas au ping Keep Alive dans le temps configuré sont fermées par le serveur.

Il existe deux options de configuration associées aux requêtes ping Keep Alive HTTP/2 :

• KeepAlivePingDelay est un TimeSpan qui configure l’intervalle de ping. Le serveur envoie une requête ping Keep Alive au client s’il ne reçoit aucune trame pendant cette période. Les requêtes ping Keep Alive sont désactivées quand cette option est définie sur TimeSpan.MaxValue.
• KeepAlivePingTimeout est un TimeSpan qui configure le délai d’expiration des requêtes ping. Si le serveur ne reçoit aucune trame, telle qu’une réponse ping, pendant ce délai d’expiration, la connexion est fermée. Le délai d’expiration Keep Alive est désactivé quand cette option est définie sur TimeSpan.MaxValue.

L’exemple suivant définit KeepAlivePingDelay et KeepAlivePingTimeout :

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

Autres options

E/S synchrone

AllowSynchronousIO contrôle si une E/S synchrone est autorisée pour la demande et la réponse.

L’exemple suivant active une E/S synchrone :

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

Pour obtenir des informations sur les autres options et limites de Kestrel, consultez :

• KestrelServerOptions
• KestrelServerLimits
• ListenOptions

Comportement avec le débogueur attaché

Certains délais d’expiration et limites de débit ne sont pas appliqués lorsqu’un débogueur est attaché à un processus Kestrel. Pour plus d’informations, consultez Comportement avec le débogueur attaché.

Le serveur web Kestrel a des options de configuration de contraintes qui sont particulièrement utiles dans les déploiements exposés à Internet.

Pour fournir une configuration supplémentaire après l’appel de ConfigureWebHostDefaults, utilisez ConfigureKestrel :

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

Définissez des contraintes sur la propriété Limits de la classe KestrelServerOptions. La propriété Limits conserve une instance de la classe KestrelServerLimits.

Les exemples suivants utilisent l’espace de noms Microsoft.AspNetCore.Server.Kestrel.Core :

using Microsoft.AspNetCore.Server.Kestrel.Core;

Limites générales

Délai d’expiration toujours actif

KeepAliveTimeout

Obtient ou définit le délai d’expiration toujours actif. La valeur par défaut est de 2 minutes.

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

Nombre maximale de connexions client

MaxConcurrentConnections
MaxConcurrentUpgradedConnections

Le nombre maximal de connexions TCP ouvertes simultanées peut être défini pour l’application entière avec le code suivant :

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

Il existe une limite distincte pour les connexions qui ont été mises à niveau à partir de HTTP ou HTTPS vers un autre protocole (par exemple, sur une demande WebSocket). Une fois mise à niveau, une connexion n’est pas prise en compte dans la limite MaxConcurrentConnections.

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

Le nombre maximal de connexions est illimité (null) par défaut.

Taille maximale du corps de la requête

MaxRequestBodySize

La taille maximale par défaut du corps de la requête est de 30 000 000 octets, soit environ 28,6 Mo.

Pour remplacer la limite dans une application ASP.NET Core MVC, nous vous recommandons d’utiliser l’attribut RequestSizeLimitAttribute sur une méthode d’action :

[RequestSizeLimit(100000000)]
public IActionResult MyActionMethod()

L’exemple suivant qui montre comment configurer la contrainte pour l’application sur chaque demande :

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

Remplacez le paramètre sur une demande spécifique dans l’intergiciel :

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

Une exception est levée si l’application configure la limite sur une requête une fois que l’application a commencé à la lire. Il existe une propriété IsReadOnly qui indique si la propriété MaxRequestBodySize est en lecture seule ; si tel est le cas, il est trop tard pour configurer la limite.

Lorsqu’une application s’exécute hors processus derrière le module ASP.NET Core, la taille limite du corps de demande de Kestrel est désactivée. IIS définit déjà cette limite.

Débit données minimal du corps de la requête

MinRequestBodyDataRate
MinResponseDataRate

Kestrel vérifie à chaque seconde si les données arrivent au débit spécifié en octets/seconde. Si le débit est inférieur au minimum, la connexion expire. La période de grâce est la durée que Kestrel accorde au client pour augmenter son taux d’envoi jusqu’au minimum. Pendant cette période, le débit n’est pas vérifié. La période de grâce permet d’éviter la suppression des connexions qui, initialement, envoient des données à une vitesse réduite en raison de la lenteur du démarrage de TCP.

Le débit minimal par défaut est de 240 octets/s, avec une période de grâce de 5 secondes.

Un débit minimal s’applique également à la réponse. Le code pour définir les limites de demande et de réponse est identique à l’exception de RequestBody ou Response dans les noms de propriété et d’interface.

Voici un exemple qui montre comment configurer les débits de données minimaux dans 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);
})

Remplacez les limites de débit minimal par demande dans l’intergiciel :

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

Le IHttpMinResponseDataRateFeature référencé dans l’exemple précédent n’est pas présent dans HttpContext.Features pour les requêtes HTTP/2. La modification des limites de débit par demande n’est généralement pas prise en charge pour HTTP/2 en raison de la prise en charge du protocole pour le multiplexage des demandes. Toutefois, le IHttpMinRequestBodyDataRateFeature est toujours présent HttpContext.Features pour les requêtes HTTP/2, car la limite de débit de lecture peut toujours être désactivée entièrement sur une base par demande en définissant IHttpMinResponseDataRateFeature.MinDataRate sur null même pour une requête HTTP/2. Une tentative de lecture de IHttpMinRequestBodyDataRateFeature.MinDataRate ou une tentative de définition sur une valeur autre que null entraîne une levée de NotSupportedException selon une requête HTTP/2.

Les limites de débit à l’échelle du serveur configurées par le biais de KestrelServerOptions.Limits s’appliquent encore aux connexions HTTP/1.x et HTTP/2.

Délai d’expiration des en-têtes de requête

RequestHeadersTimeout

Obtient ou définit le temps maximal passé par le serveur à recevoir des en-têtes de requête. La valeur par défaut est de 30 secondes.

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

Les limites de cette section sont définies sur KestrelServerLimits.Http2.

Flux de données maximal par connexion

MaxStreamsPerConnection

Limite le nombre de flux de demande simultanés par connexion HTTP/2. Les flux de données excédentaires sont refusés.

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

La valeur par défaut est 100.

Taille de la table d’en-tête

HeaderTableSize

Le décodeur HPACK décompresse les en-têtes HTTP pour les connexions HTTP/2. HeaderTableSize limite la taille de la table de compression d’en-tête que le décodeur HPACK utilise. La valeur est fournie en octets et doit être supérieure à zéro (0).

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

La valeur par défaut est 4096.

Taille de trame maximale

MaxFrameSize

Indique la taille maximale autorisée d’une charge utile de trame de connexion HTTP/2 reçue ou envoyée par le serveur. La valeur est fournie en octets et doit être comprise entre 2^14 (16,384) et 2^24-1 (16,777,215).

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

La valeur par défaut est 2^14 (16,384).

Taille maximale d’en-tête de requête

MaxRequestHeaderFieldSize

Indique la taille maximale autorisée en octets des valeurs d’en-tête de demande. Cette limite s’applique au nom et à la valeur dans leurs représentations compressée et non compressée. La valeur doit être supérieure à zéro (0).

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

La valeur par défaut est 8 192.

Taille de fenêtre de connexion initiale

InitialConnectionWindowSize

Indique la quantité maximale de données de corps de demande, en octets, que le serveur met en mémoire tampon à un moment donné, agrégée entre toutes les demandes (flux) par connexion. Les requêtes sont également limitées par Http2.InitialStreamWindowSize. La valeur doit être supérieure ou égale à 65 535 et inférieure à 2^31 (2 147 483 648).

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

La valeur par défaut est 128 Ko (131 072).

Taille de la fenêtre de flux initiale

InitialStreamWindowSize

Indique la quantité maximale de données de corps de demande, en octets, que le serveur met en mémoire tampon à un moment donné par demande (flux). Les requêtes sont également limitées par InitialConnectionWindowSize. La valeur doit être supérieure ou égale à 65 535 et inférieure à 2^31 (2 147 483 648).

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

La valeur par défaut est 96 Ko (98 304).

Configuration des requêtes ping Keep Alive HTTP/2

Kestrel peut être configuré pour envoyer des requêtes ping HTTP/2 aux clients connectés. Les requêtes ping HTTP/2 ont plusieurs objectifs :

• Maintenir actives les connexions inactives. Certains clients et serveurs proxy ferment les connexions inactives. Les requêtes ping HTTP/2 sont considérées comme une activité sur une connexion et empêchent la fermeture de la connexion pour cause d’inactivité.
• Fermez les connexions non saines. Les connexions où le client ne répond pas au ping Keep Alive dans le temps configuré sont fermées par le serveur.

Il existe deux options de configuration associées aux requêtes ping Keep Alive HTTP/2 :

• KeepAlivePingDelay est un TimeSpan qui configure l’intervalle de ping. Le serveur envoie une requête ping Keep Alive au client s’il ne reçoit aucune trame pendant cette période. Les requêtes ping Keep Alive sont désactivées quand cette option est définie sur TimeSpan.MaxValue. La valeur par défaut est TimeSpan.MaxValue.
• KeepAlivePingTimeout est un TimeSpan qui configure le délai d’expiration des requêtes ping. Si le serveur ne reçoit aucune trame, telle qu’une réponse ping, pendant ce délai d’expiration, la connexion est fermée. Le délai d’expiration Keep Alive est désactivé quand cette option est définie sur TimeSpan.MaxValue. La valeur par défaut est 20 secondes.

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

Autres options

E/S synchrone

AllowSynchronousIO contrôle si une E/S synchrone est autorisée pour la demande et la réponse. La valeur par défaut est false.

L’exemple suivant active une E/S synchrone :

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

Pour obtenir des informations sur les autres options et limites de Kestrel, consultez :

• KestrelServerOptions
• KestrelServerLimits
• ListenOptions