Intergiciel (middleware) ASP.NET CoreASP.NET Core Middleware

Par Rick Anderson et Steve SmithBy Rick Anderson and Steve Smith

Un middleware est un logiciel qui est assemblé dans un pipeline d’application pour gérer les requêtes et les réponses.Middleware is software that's assembled into an app pipeline to handle requests and responses. Chaque composant :Each component:

  • Choisit de passer la requête au composant suivant dans le pipeline.Chooses whether to pass the request to the next component in the pipeline.
  • Peut travailler avant et après le composant suivant dans le pipeline.Can perform work before and after the next component in the pipeline.

Les délégués de requête sont utilisés pour créer le pipeline de requête.Request delegates are used to build the request pipeline. Les délégués de requête gèrent chaque requête HTTP.The request delegates handle each HTTP request.

Les délégués de requête sont configurés à l’aide des méthodes d’extension Run, Map et Use.Request delegates are configured using Run, Map, and Use extension methods. Chaque délégué de requête peut être spécifié inline comme méthode anonyme (appelée intergiciel inline) ou peut être défini dans une classe réutilisable.An individual request delegate can be specified in-line as an anonymous method (called in-line middleware), or it can be defined in a reusable class. Ces classes réutilisables et les méthodes anonymes inline sont des middlewares, également appelés composants de middleware.These reusable classes and in-line anonymous methods are middleware, also called middleware components. Chaque composant de middleware du pipeline de requête est chargé d’appeler le composant suivant du pipeline ou de court-circuiter le pipeline.Each middleware component in the request pipeline is responsible for invoking the next component in the pipeline or short-circuiting the pipeline. Lorsqu’un middleware effectue un court-circuit, on parle de middleware terminal, car il empêche tout autre middleware de traiter la requête.When a middleware short-circuits, it's called a terminal middleware because it prevents further middleware from processing the request.

Migrer des gestionnaires et des modules HTTP vers ASP.NET Core intergiciel explique la différence entre les pipelines de requêtes dans ASP.NET Core et ASP.NET 4.x, puis fournit d’autres exemples de middlewares.Migrer des gestionnaires et des modules HTTP vers ASP.NET Core intergiciel explains the difference between request pipelines in ASP.NET Core and ASP.NET 4.x and provides additional middleware samples.

Créer un pipeline de middleware avec IApplicationBuilderCreate a middleware pipeline with IApplicationBuilder

Le pipeline de requête ASP.NET Core est composé d’une séquence de délégués de requête, appelés l’un après l’autre.The ASP.NET Core request pipeline consists of a sequence of request delegates, called one after the other. Le diagramme suivant illustre le concept.The following diagram demonstrates the concept. Le thread d’exécution suit les flèches noires.The thread of execution follows the black arrows.

Modèle de traitement des requêtes montrant une requête qui arrive et qui est traitée par trois middlewares, puis la réponse qui quitte l’application.

Chaque délégué peut effectuer des opérations avant et après le délégué suivant.Each delegate can perform operations before and after the next delegate. Les délégués de gestion des exceptions doivent être appelés tôt dans le pipeline pour qu’ils puissent intercepter les exceptions qui se produisent dans les phases ultérieures du pipeline.Exception-handling delegates should be called early in the pipeline, so they can catch exceptions that occur in later stages of the pipeline.

L’application ASP.NET Core la plus simple possible définit un seul délégué de requête qui gère toutes les requêtes.The simplest possible ASP.NET Core app sets up a single request delegate that handles all requests. Ce cas ne fait pas appel à un pipeline de requête réel.This case doesn't include an actual request pipeline. À la place, une seule fonction anonyme est appelée en réponse à chaque requête HTTP.Instead, a single anonymous function is called in response to every HTTP request.

public class Startup
{
    public void Configure(IApplicationBuilder app)
    {
        app.Run(async context =>
        {
            await context.Response.WriteAsync("Hello, World!");
        });
    }
}

Le premier délégué Run termine le pipeline.The first Run delegate terminates the pipeline.

Chaînez plusieurs délégués de requête avec Use.Chain multiple request delegates together with Use. Le paramètre next représente le délégué suivant dans le pipeline.The next parameter represents the next delegate in the pipeline. Vous pouvez court-circuiter le pipeline en n’appelant pas le paramètre next.You can short-circuit the pipeline by not calling the next parameter. Vous pouvez généralement effectuer des actions à la fois avant et après le délégué suivant, comme illustré dans cet exemple :You can typically perform actions both before and after the next delegate, as the following example demonstrates:

public class Startup
{
    public void Configure(IApplicationBuilder app)
    {
        app.Use(async (context, next) =>
        {
            // Do work that doesn't write to the Response.
            await next.Invoke();
            // Do logging or other work that doesn't write to the Response.
        });

        app.Run(async context =>
        {
            await context.Response.WriteAsync("Hello from 2nd delegate.");
        });
    }
}

Quand un délégué ne passe pas une requête au délégué suivant, on parle alors de court-circuit du pipeline de requête.When a delegate doesn't pass a request to the next delegate, it's called short-circuiting the request pipeline. Un court-circuit est souvent souhaitable car il évite le travail inutile.Short-circuiting is often desirable because it avoids unnecessary work. Par exemple, le middleware Fichier statique peut agir en tant que middleware terminal en traitant une requête pour un fichier statique et en court-circuitant le reste du pipeline.For example, Static File Middleware can act as a terminal middleware by processing a request for a static file and short-circuiting the rest of the pipeline. Le middleware ajouté au pipeline avant de le middleware qui met fin à la poursuite du traitement traite tout de même le code après les instructions next.Invoke.Middleware added to the pipeline before the middleware that terminates further processing still processes code after their next.Invoke statements. Toutefois, consultez l’avertissement suivant à propos de la tentative d’écriture sur une réponse qui a déjà été envoyée.However, see the following warning about attempting to write to a response that has already been sent.

Avertissement

N’appelez pas next.Invoke une fois que la réponse a été envoyée au client.Don't call next.Invoke after the response has been sent to the client. Les changements apportés à HttpResponse après le démarrage de la réponse lèvent une exception.Changes to HttpResponse after the response has started throw an exception. Par exemple, les changements comme la définition des en-têtes et du code d’état lèvent une exception.For example, changes such as setting headers and a status code throw an exception. Écrire dans le corps de la réponse après avoir appelé next :Writing to the response body after calling next:

  • Peut entraîner une violation de protocole.May cause a protocol violation. Par exemple, écrire plus que le Content-Length indiqué.For example, writing more than the stated Content-Length.
  • Peut altérer le format du corps.May corrupt the body format. Par exemple, l’écriture d’un pied de page HTML dans un fichier CSS.For example, writing an HTML footer to a CSS file.

HasStarted est un indice utile pour indiquer si les en-têtes ont été envoyés ou si le corps a fait l’objet d’écritures.HasStarted is a useful hint to indicate if headers have been sent or the body has been written to.

TrierOrder

L’ordre dans lequel les composants de middleware sont ajoutés dans la méthode Startup.Configure définit l’ordre dans lequel ils sont appelés sur les requêtes et l’ordre inverse pour la réponse.The order that middleware components are added in the Startup.Configure method defines the order in which the middleware components are invoked on requests and the reverse order for the response. L’ordre est critique pour la sécurité, les performances et le fonctionnement.The order is critical for security, performance, and functionality.

La méthode Startup.Configure suivante ajoute des composants middleware utiles pour les scénarios d’application courants :The following Startup.Configure method adds middleware components for common app scenarios:

  1. Gestion des erreurs/exceptionsException/error handling
    • Quand l’application s’exécute dans l’environnement de développement :When the app runs in the Development environment:
      • Le middleware Page d’exceptions du développeur (UseDeveloperExceptionPage) signale des erreurs de runtime de l’application.Developer Exception Page Middleware (UseDeveloperExceptionPage) reports app runtime errors.
      • L’intergiciel (middleware) de page d’erreur de base de données signale des erreurs d’exécution.Database Error Page Middleware reports database runtime errors.
    • Quand l’application s’exécute dans l’environnement de production :When the app runs in the Production environment:
      • Le middleware Gestionnaire d'exceptions (UseExceptionHandler) intercepte des exceptions levées dans les middlewares suivants.Exception Handler Middleware (UseExceptionHandler) catches exceptions thrown in the following middlewares.
      • Le middleware Protocole HSTS (HTTP Strict Transport Security) (UseHsts) ajoute l’en-tête Strict-Transport-Security.HTTP Strict Transport Security Protocol (HSTS) Middleware (UseHsts) adds the Strict-Transport-Security header.
  2. Le middleware Redirection HTTPS (UseHttpsRedirection) redirige les requêtes HTTP vers HTTPS.HTTPS Redirection Middleware (UseHttpsRedirection) redirects HTTP requests to HTTPS.
  3. Le middleware Fichier statique (UseStaticFiles) retourne des fichiers statiques et court-circuite tout traitement supplémentaire de la requête.Static File Middleware (UseStaticFiles) returns static files and short-circuits further request processing.
  4. Le middleware Stratégie des cookies (UseCookiePolicy) met l’application en conformité avec les réglementation du RGPD (Règlement général sur la protection des données).Cookie Policy Middleware (UseCookiePolicy) conforms the app to the EU General Data Protection Regulation (GDPR) regulations.
  5. Le middleware de routage (UseRouting) pour acheminer les demandes.Routing Middleware (UseRouting) to route requests.
  6. Le middleware Authentification (UseAuthentication) tente d’authentifier l’utilisateur avant qu’il ne soit autorisé à accéder aux ressources sécurisées.Authentication Middleware (UseAuthentication) attempts to authenticate the user before they're allowed access to secure resources.
  7. L’intergiciel (UseAuthorization) d’autorisation autorise un utilisateur à accéder à des ressources sécurisées.Authorization Middleware (UseAuthorization) authorizes a user to access secure resources.
  8. Le middleware Session (UseSession) établit et maintient l’état de la session.Session Middleware (UseSession) establishes and maintains session state. Si l’application utilise l’état de session, appelez le middleware après le middleware Stratégie des cookies et avant le middleware MVC.If the app uses session state, call Session Middleware after Cookie Policy Middleware and before MVC Middleware.
  9. Intergiciel (middleware) de routage des points de terminaison (UseEndpoints avec MapRazorPages) pour ajouter des points de terminaison Razor Pages au pipeline de requête.Endpoint Routing Middleware (UseEndpoints with MapRazorPages) to add Razor Pages endpoints to the request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseCookiePolicy();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();
    app.UseSession();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
    });
}

Dans l’exemple de code précédent, chaque méthode d’extension d’intergiciel (middleware) est exposée sur IApplicationBuilder à travers l’espace de noms Microsoft.AspNetCore.Builder.In the preceding example code, each middleware extension method is exposed on IApplicationBuilder through the Microsoft.AspNetCore.Builder namespace.

UseExceptionHandler est le premier composant d’intergiciel ajouté au pipeline.UseExceptionHandler is the first middleware component added to the pipeline. Par conséquent, le middleware Gestion des exceptions intercepte toutes les exceptions qui se produisent dans les appels ultérieurs.Therefore, the Exception Handler Middleware catches any exceptions that occur in later calls.

Le middleware Fichier statique est appelé tôt dans le pipeline pour qu’il puisse gérer les requêtes et procéder au court-circuit sans passer par les composants restants.Static File Middleware is called early in the pipeline so that it can handle requests and short-circuit without going through the remaining components. Le middleware Fichier statique ne fournit aucune vérification d’autorisation.The Static File Middleware provides no authorization checks. Tous les fichiers pris en charge par l’intergiciel (middleware) de fichiers statiques, y compris ceux qui se trouvent sous wwwroot, sont disponibles publiquement.Any files served by Static File Middleware, including those under wwwroot, are publicly available. Pour obtenir une approche permettant de sécuriser les fichiers statiques, consultez Fichiers statiques dans ASP.NET Core.For an approach to secure static files, see Fichiers statiques dans ASP.NET Core.

Si la requête n’est pas gérée par le middleware Fichier statique, elle est transmise au middleware Authentification (UseAuthentication), qui effectue l’authentification.If the request isn't handled by the Static File Middleware, it's passed on to the Authentication Middleware (UseAuthentication), which performs authentication. Le middleware Authentification ne court-circuite pas les requêtes non authentifiées.Authentication doesn't short-circuit unauthenticated requests. Même s’il authentifie les requêtes, l’autorisation (et le refus) interviennent uniquement après que MVC a sélectionné une page Razor/un contrôleur MVC et une action spécifiques.Although Authentication Middleware authenticates requests, authorization (and rejection) occurs only after MVC selects a specific Razor Page or MVC controller and action.

L’exemple suivant montre un ordre de middlewares où les requêtes pour les fichiers statiques sont gérées par le middleware Fichier statique avant le middleware Compression de la réponse.The following example demonstrates a middleware order where requests for static files are handled by Static File Middleware before Response Compression Middleware. Les fichiers statiques ne sont pas compressés avec cet ordre de middlewares.Static files aren't compressed with this middleware order. Les réponses Razor Pages peuvent être compressées.The Razor Pages responses can be compressed.

public void Configure(IApplicationBuilder app)
{
    // Static files aren't compressed by Static File Middleware.
    app.UseStaticFiles();

    app.UseResponseCompression();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();
    });
}
  1. Gestion des erreurs/exceptionsException/error handling
    • Quand l’application s’exécute dans l’environnement de développement :When the app runs in the Development environment:
      • Le middleware Page d’exceptions du développeur (UseDeveloperExceptionPage) signale des erreurs de runtime de l’application.Developer Exception Page Middleware (UseDeveloperExceptionPage) reports app runtime errors.
      • Le middleware Page d’erreur de base de données (Microsoft.AspNetCore.Builder.DatabaseErrorPageExtensions.UseDatabaseErrorPage) signale des erreurs de runtime de la base de données.Database Error Page Middleware (Microsoft.AspNetCore.Builder.DatabaseErrorPageExtensions.UseDatabaseErrorPage) reports database runtime errors.
    • Quand l’application s’exécute dans l’environnement de production :When the app runs in the Production environment:
      • Le middleware Gestionnaire d'exceptions (UseExceptionHandler) intercepte des exceptions levées dans les middlewares suivants.Exception Handler Middleware (UseExceptionHandler) catches exceptions thrown in the following middlewares.
      • Le middleware Protocole HSTS (HTTP Strict Transport Security) (UseHsts) ajoute l’en-tête Strict-Transport-Security.HTTP Strict Transport Security Protocol (HSTS) Middleware (UseHsts) adds the Strict-Transport-Security header.
  2. Le middleware Redirection HTTPS (UseHttpsRedirection) redirige les requêtes HTTP vers HTTPS.HTTPS Redirection Middleware (UseHttpsRedirection) redirects HTTP requests to HTTPS.
  3. Le middleware Fichier statique (UseStaticFiles) retourne des fichiers statiques et court-circuite tout traitement supplémentaire de la requête.Static File Middleware (UseStaticFiles) returns static files and short-circuits further request processing.
  4. Le middleware Stratégie des cookies (UseCookiePolicy) met l’application en conformité avec les réglementation du RGPD (Règlement général sur la protection des données).Cookie Policy Middleware (UseCookiePolicy) conforms the app to the EU General Data Protection Regulation (GDPR) regulations.
  5. Le middleware Authentification (UseAuthentication) tente d’authentifier l’utilisateur avant qu’il ne soit autorisé à accéder aux ressources sécurisées.Authentication Middleware (UseAuthentication) attempts to authenticate the user before they're allowed access to secure resources.
  6. Le middleware Session (UseSession) établit et maintient l’état de la session.Session Middleware (UseSession) establishes and maintains session state. Si l’application utilise l’état de session, appelez le middleware après le middleware Stratégie des cookies et avant le middleware MVC.If the app uses session state, call Session Middleware after Cookie Policy Middleware and before MVC Middleware.
  7. MVC (UseMvc) pour ajouter MVC au pipeline de requête.MVC (UseMvc) to add MVC to the request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseDatabaseErrorPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseCookiePolicy();
    app.UseAuthentication();
    app.UseSession();
    app.UseMvc();
}

Dans l’exemple de code précédent, chaque méthode d’extension d’intergiciel (middleware) est exposée sur IApplicationBuilder à travers l’espace de noms Microsoft.AspNetCore.Builder.In the preceding example code, each middleware extension method is exposed on IApplicationBuilder through the Microsoft.AspNetCore.Builder namespace.

UseExceptionHandler est le premier composant d’intergiciel ajouté au pipeline.UseExceptionHandler is the first middleware component added to the pipeline. Par conséquent, le middleware Gestion des exceptions intercepte toutes les exceptions qui se produisent dans les appels ultérieurs.Therefore, the Exception Handler Middleware catches any exceptions that occur in later calls.

Le middleware Fichier statique est appelé tôt dans le pipeline pour qu’il puisse gérer les requêtes et procéder au court-circuit sans passer par les composants restants.Static File Middleware is called early in the pipeline so that it can handle requests and short-circuit without going through the remaining components. Le middleware Fichier statique ne fournit aucune vérification d’autorisation.The Static File Middleware provides no authorization checks. Tous les fichiers pris en charge par l’intergiciel (middleware) de fichiers statiques, y compris ceux qui se trouvent sous wwwroot, sont disponibles publiquement.Any files served by Static File Middleware, including those under wwwroot, are publicly available. Pour obtenir une approche permettant de sécuriser les fichiers statiques, consultez Fichiers statiques dans ASP.NET Core.For an approach to secure static files, see Fichiers statiques dans ASP.NET Core.

Si la requête n’est pas gérée par le middleware Fichier statique, elle est transmise au middleware Authentification (UseAuthentication), qui effectue l’authentification.If the request isn't handled by the Static File Middleware, it's passed on to the Authentication Middleware (UseAuthentication), which performs authentication. Le middleware Authentification ne court-circuite pas les requêtes non authentifiées.Authentication doesn't short-circuit unauthenticated requests. Même s’il authentifie les requêtes, l’autorisation (et le refus) interviennent uniquement après que MVC a sélectionné une page Razor/un contrôleur MVC et une action spécifiques.Although Authentication Middleware authenticates requests, authorization (and rejection) occurs only after MVC selects a specific Razor Page or MVC controller and action.

L’exemple suivant montre un ordre de middlewares où les requêtes pour les fichiers statiques sont gérées par le middleware Fichier statique avant le middleware Compression de la réponse.The following example demonstrates a middleware order where requests for static files are handled by Static File Middleware before Response Compression Middleware. Les fichiers statiques ne sont pas compressés avec cet ordre de middlewares.Static files aren't compressed with this middleware order. Les réponses MVC de UseMvcWithDefaultRoute peuvent être compressées.The MVC responses from UseMvcWithDefaultRoute can be compressed.

public void Configure(IApplicationBuilder app)
{
    // Static files aren't compressed by Static File Middleware.
    app.UseStaticFiles();

    app.UseResponseCompression();

    app.UseMvcWithDefaultRoute();
}

Use, Run et MapUse, Run, and Map

Configurez le pipeline HTTP avec Use, Run et Map.Configure the HTTP pipeline using Use, Run, and Map. La méthode Use peut court-circuiter le pipeline (autrement dit, si elle n’appelle pas un délégué de requête next).The Use method can short-circuit the pipeline (that is, if it doesn't call a next request delegate). Run est une convention, et certains composants d’intergiciel peuvent exposer des méthodes Run[Middleware] qui s’exécutent à la fin du pipeline.Run is a convention, and some middleware components may expose Run[Middleware] methods that run at the end of the pipeline.

Les extensions Map sont utilisées comme convention pour créer une branche dans le pipeline.Map extensions are used as a convention for branching the pipeline. Map crée une branche dans le pipeline de requête en fonction des correspondances du chemin de requête donné.Map branches the request pipeline based on matches of the given request path. Si le chemin de requête commence par le chemin donné, la branche est exécutée.If the request path starts with the given path, the branch is executed.

public class Startup
{
    private static void HandleMapTest1(IApplicationBuilder app)
    {
        app.Run(async context =>
        {
            await context.Response.WriteAsync("Map Test 1");
        });
    }

    private static void HandleMapTest2(IApplicationBuilder app)
    {
        app.Run(async context =>
        {
            await context.Response.WriteAsync("Map Test 2");
        });
    }

    public void Configure(IApplicationBuilder app)
    {
        app.Map("/map1", HandleMapTest1);

        app.Map("/map2", HandleMapTest2);

        app.Run(async context =>
        {
            await context.Response.WriteAsync("Hello from non-Map delegate. <p>");
        });
    }
}

Le tableau suivant présente les requêtes et les réponses de http://localhost:1234 avec le code précédent.The following table shows the requests and responses from http://localhost:1234 using the previous code.

DemandeRequest RéponseResponse
localhost:1234localhost:1234 Hello from non-Map delegate.Hello from non-Map delegate.
localhost:1234/map1localhost:1234/map1 Map Test 1Map Test 1
localhost:1234/map2localhost:1234/map2 Map Test 2Map Test 2
localhost:1234/map3localhost:1234/map3 Hello from non-Map delegate.Hello from non-Map delegate.

Quand Map est utilisé, les segments de chemin mis en correspondance sont supprimés de HttpRequest.Path et ajoutés à HttpRequest.PathBase pour chaque requête.When Map is used, the matched path segments are removed from HttpRequest.Path and appended to HttpRequest.PathBase for each request.

MapWhen crée une branche dans le pipeline de requête en fonction du résultat du prédicat donné.MapWhen branches the request pipeline based on the result of the given predicate. Un prédicat de type Func<HttpContext, bool> peut être utilisé pour mapper les requêtes à une nouvelle branche du pipeline.Any predicate of type Func<HttpContext, bool> can be used to map requests to a new branch of the pipeline. Dans l’exemple suivant, un prédicat est utilisé pour détecter la présence d’une variable de chaîne de requête branch :In the following example, a predicate is used to detect the presence of a query string variable branch:

public class Startup
{
    private static void HandleBranch(IApplicationBuilder app)
    {
        app.Run(async context =>
        {
            var branchVer = context.Request.Query["branch"];
            await context.Response.WriteAsync($"Branch used = {branchVer}");
        });
    }

    public void Configure(IApplicationBuilder app)
    {
        app.MapWhen(context => context.Request.Query.ContainsKey("branch"),
                               HandleBranch);

        app.Run(async context =>
        {
            await context.Response.WriteAsync("Hello from non-Map delegate. <p>");
        });
    }
}

Le tableau suivant présente les requêtes et les réponses de http://localhost:1234 avec le code précédent.The following table shows the requests and responses from http://localhost:1234 using the previous code.

DemandeRequest RéponseResponse
localhost:1234localhost:1234 Hello from non-Map delegate.Hello from non-Map delegate.
localhost:1234/?branch=masterlocalhost:1234/?branch=master Branch used = masterBranch used = master

Map prend en charge l’imbrication, par exemple :Map supports nesting, for example:

app.Map("/level1", level1App => {
    level1App.Map("/level2a", level2AApp => {
        // "/level1/level2a" processing
    });
    level1App.Map("/level2b", level2BApp => {
        // "/level1/level2b" processing
    });
});

Map peut également faire correspondre plusieurs segments à la fois :Map can also match multiple segments at once:

public class Startup
{
    private static void HandleMultiSeg(IApplicationBuilder app)
    {
        app.Run(async context =>
        {
            await context.Response.WriteAsync("Map multiple segments.");
        });
    }

    public void Configure(IApplicationBuilder app)
    {
        app.Map("/map1/seg1", HandleMultiSeg);

        app.Run(async context =>
        {
            await context.Response.WriteAsync("Hello from non-Map delegate.");
        });
    }
}

Intergiciels (middleware) intégrésBuilt-in middleware

ASP.NET Core est fourni avec les composants de middleware suivant.ASP.NET Core ships with the following middleware components. La colonne Ordre fournit des notes sur l’emplacement du middleware dans le pipeline de traitement de la requête et sur les conditions dans lesquelles le middleware peut mettre fin au traitement de la requête.The Order column provides notes on middleware placement in the request processing pipeline and under what conditions the middleware may terminate request processing. Lorsqu’un middleware court-circuite le pipeline de traitement de la requête et empêche tout middleware en aval de traiter une requête, on parle de middleware terminal.When a middleware short-circuits the request processing pipeline and prevents further downstream middleware from processing a request, it's called a terminal middleware. Pour plus d’informations sur le court-circuit, consultez la section Créer un pipeline de middlewares avec IApplicationBuilder.For more information on short-circuiting, see the Create a middleware pipeline with IApplicationBuilder section.

Intergiciel (middleware)Middleware DescriptionDescription TrierOrder
AuthentificationAuthentication Prend en charge l’authentification.Provides authentication support. Avant que HttpContext.User ne soit nécessaire.Before HttpContext.User is needed. Terminal pour les rappels OAuth.Terminal for OAuth callbacks.
Stratégie de cookiesCookie Policy Effectue le suivi de consentement des utilisateurs pour le stockage des informations personnelles et applique des normes minimales pour les champs de cookie, comme secure et SameSite.Tracks consent from users for storing personal information and enforces minimum standards for cookie fields, such as secure and SameSite. Avant le middleware qui émet les cookies.Before middleware that issues cookies. Exemples : authentification, session, MVC (TempData).Examples: Authentication, Session, MVC (TempData).
CORSCORS Configure le partage des ressources cross-origin (CORS).Configures Cross-Origin Resource Sharing. Avant les composants qui utilisent CORS.Before components that use CORS.
DiagnosticsDiagnostics Plusieurs intergiciels distincts qui fournissent une page d’exception de développeur, la gestion des exceptions, les pages de codes d’État et la page Web par défaut pour les nouvelles applications.Several separate middlewares that provide a developer exception page, exception handling, status code pages, and the default web page for new apps. Avant les composants qui génèrent des erreurs.Before components that generate errors. Terminal pour les exceptions ou service de la page Web par défaut pour les nouvelles applications.Terminal for exceptions or serving the default web page for new apps.
En-têtes transférésForwarded Headers Transfère les en-têtes en proxy vers la requête actuelle.Forwards proxied headers onto the current request. Avant les composants qui consomment les champs mis à jour.Before components that consume the updated fields. Exemples : schéma, hôte, IP du client, méthode.Examples: scheme, host, client IP, method.
Contrôle d’intégritéHealth Check Contrôle l’intégrité d’une application ASP.NET Core et de ses dépendances, notamment la disponibilité de la base de données.Checks the health of an ASP.NET Core app and its dependencies, such as checking database availability. Terminal si une requête correspond à un point de terminaison de contrôle d’intégrité.Terminal if a request matches a health check endpoint.
Remplacement de la méthode HTTPHTTP Method Override Autorise une requête POST entrante à remplacer la méthode.Allows an incoming POST request to override the method. Avant les composants qui consomment la méthode mise à jour.Before components that consume the updated method.
Redirection HTTPSHTTPS Redirection Redirige toutes les requêtes HTTP vers HTTPS.Redirect all HTTP requests to HTTPS. Avant les composants qui consomment l’URL.Before components that consume the URL.
HSTS (HTTP Strict Transport Security)HTTP Strict Transport Security (HSTS) Middleware d’amélioration de la sécurité qui ajoute un en-tête de réponse spécial.Security enhancement middleware that adds a special response header. Avant l’envoi des réponses et après les composants qui modifient les requêtes.Before responses are sent and after components that modify requests. Exemples : en-têtes transférés, réécriture d’URL.Examples: Forwarded Headers, URL Rewriting.
MVCMVC Traite les requêtes avec MVC/Razor Pages.Processes requests with MVC/Razor Pages. Terminal si une requête correspond à un itinéraire.Terminal if a request matches a route.
OWINOWIN Interopérabilité avec le middleware, les serveurs et les applications OWIN.Interop with OWIN-based apps, servers, and middleware. Terminal si le middleware OWIN traite entièrement la requête.Terminal if the OWIN Middleware fully processes the request.
Mise en cache des réponsesResponse Caching Prend en charge la mise en cache des réponses.Provides support for caching responses. Avant les composants qui nécessitent la mise en cache.Before components that require caching.
Compression des réponsesResponse Compression Prend en charge la compression des réponses.Provides support for compressing responses. Avant les composants qui nécessitent la compression.Before components that require compression.
Localisation des requêtesRequest Localization Prend en charge la localisation.Provides localization support. Avant la localisation des composants sensibles.Before localization sensitive components.
Routage du point de terminaisonEndpoint Routing Définit et contraint des routes de requête.Defines and constrains request routes. Terminal pour les routes correspondantes.Terminal for matching routes.
SessionSession Prend en charge la gestion des sessions utilisateur.Provides support for managing user sessions. Avant les composants qui nécessitent la session.Before components that require Session.
Fichiers statiquesStatic Files Prend en charge le traitement des fichiers statiques et l’exploration des répertoires.Provides support for serving static files and directory browsing. Terminal si une requête correspond à un fichier.Terminal if a request matches a file.
Réécriture d’URLURL Rewrite Prend en charge la réécriture d’URL et la redirection des requêtes.Provides support for rewriting URLs and redirecting requests. Avant les composants qui consomment l’URL.Before components that consume the URL.
WebSocketsWebSockets Autorise le protocole WebSockets.Enables the WebSockets protocol. Avant les composants qui sont nécessaires pour accepter les requêtes WebSocket.Before components that are required to accept WebSocket requests.

Ressources supplémentairesAdditional resources