implementace webového serveruHTTP.sys v ASP.NET Core

Note

Toto není nejnovější verze tohoto článku. Aktuální verzi najdete v verzi tohoto článku pro .NET 11.

Tom Dykstra a Chris Ross

HTTP.sys je webový server pro ASP.NET Core, který běží jenom na Windows. HTTP.sys je alternativou k Kestrel serveru a nabízí některé funkce, které Kestrel neposkytují. Tento článek vysvětluje, kdy použít HTTP.sys, jak ho nakonfigurovat a jak kontrolovat informace o požadavcích a TLS.

Important

HTTP.sys není kompatibilní s modulem ASP.NET Core a nejde ho použít se službou IIS ani službou IIS Express.

HTTP.sys podporuje následující funkce:

  • ověřování Windows
  • Sdílení portů
  • HTTPS s SNI
  • HTTP/2 přes TLS (Windows 10 nebo novější)
  • HTTP/3 přes TLS (Windows 11 nebo novější)
  • Přímý přenos souborů
  • Ukládání odpovědí do mezipaměti
  • WebSockets (Windows 8 nebo novější)
  • Přizpůsobitelné popisovače zabezpečení
  • Automatické vyhoštění fondu paměti

Operační systém musí být podporován cílovou verzí aplikace .NET. Podporované verze Windows najdete v tématu Instalace .NET na Windows. Dostupnost HTTP.sys ve starších verzích Windows neznamená podporu těchto verzí v aktuálních verzích ASP.NET Core. Jednotlivé funkce můžou mít další Windows požadavky, jak je popsáno v následujících částech.

Zobrazte nebo stáhněte ukázkový kód (postup stažení)

Kdy použít HTTP.sys

HTTP.sys je užitečná pro nasazení, kde:

  • Je potřeba zveřejnit server přímo na internetu bez použití služby IIS.

    HTTP.sys komunikuje přímo s internetem

  • Interní nasazení vyžaduje funkci, která není k dispozici v Kestrel. Další informace najdete v tématu Kestrel vs. HTTP.sys

    HTTP.sys komunikuje přímo s interní sítí

HTTP.sys je vyspělá technologie, která chrání před mnoha typy útoků a poskytuje robustnost, zabezpečení a škálovatelnost plnohodnotného webového serveru. Služba IIS sama běží jako naslouchací proces HTTP nad HTTP.sys.

Podpora HTTP/2

Protokol HTTP/2 je povolený pro ASP.NET Core aplikace, pokud jsou splněny následující základní požadavky:

Pokud se naváže připojení HTTP/2, vlastnost HttpRequest.Protocol bude obsahovat hodnotu HTTP/2.

Ve výchozím nastavení je protokol HTTP/2 povolený. Pokud není navázáno připojení HTTP/2, připojení se vrátí zpět na HTTP/1.1. Ve verzích Windows, které tuto možnost podporují, možnost disablehttp2 u vazby certifikátu SSL netsh http zakáže pro tuto vazbu HTTP/2. Dostupné možnosti najdete v části netsh http.

Podpora HTTP/3

Protokol HTTP/3 je povolený pro ASP.NET Core aplikace, pokud jsou splněny následující základní požadavky:

  • Windows Server 2022/Windows 11 nebo novější
  • Používá se https vazba adresy URL.
  • Klíč registru EnableHttp3 je nastavený.

Předchozí verze buildu Windows 11 mohou vyžadovat použití buildu Windows Insider.

Http/3 se zjistí jako upgrade z HTTP/1.1 nebo HTTP/2 prostřednictvím hlavičky alt-svc . To znamená, že první požadavek bude před přepnutím na HTTP/3 normálně používat HTTP/1.1 nebo HTTP/2. Http.Sys automaticky nepřidá hlavičku alt-svc , musí ji přidat aplikace. Následující kód je příklad middlewaru, který přidá hlavičku alt-svc odpovědi.

app.Use((context, next) =>
{
    context.Response.Headers.AltSvc = "h3=\":443\"";
    return next(context);
});

Umístěte uvedený kód na začátek kanálu požadavku.

Http.Sys také podporuje odesílání zprávy protokolu ALTSvc HTTP/2 místo hlavičky odpovědi, aby klient informoval, že je k dispozici HTTP/3. Viz klíč registru EnableAltSvc.

Note

To vyžaduje vazby netsh sslcert, které používají názvy hostitelů místo IP adres. Nahraďte ipporthostnameport v následujících příkazech netsh http add sslcert a nahraďte IP adresu názvem hostitele, například www.example.com. Existuje také známý problém, kdy použití hostnameport selže, pokud certstorename není zadaný parametr. Ve výchozím nastavení použijte certstorename=MY.

Ověřování v režimu jádra s protokolem Kerberos

HTTP.sys deleguje ověřování v režimu jádra pomocí ověřovacího protokolu Kerberos. Ověřování v uživatelském režimu se nepodporuje s protokolem Kerberos a HTTP.sys. Účet počítače se musí použít k dešifrování tokenu nebo lístku protokolu Kerberos, který je získán z služba Active Directory a zaslaný klientem serveru, aby ověřil totožnost uživatele. Zaregistrujte hlavní název služby (SPN) pro hostitele, ne uživatele aplikace.

Povolit posílení zabezpečení prostřednictvím tokenu vázání kanálu (CBT)

Kanálově vázané tokeny (CBT) připojují Windows ověřování k podkladovému kanálu TLS, což pomáhá zmírnit útoky typu NTLM relay a útoky man-in-the-middle.

Nakonfigurujte posílení CBT pomocí nástroje HttpAuthenticationHardeningLevel. HttpAuthenticationHardeningLevel Dostupné hodnoty jsou:

Value Behavior
Legacy Nevynucuje ověření vazby kanálu ani nevystavuje pro aplikaci bajty CBT.
Medium (výchozí) Ověřuje CBT, když je klienti dodávají, ale umožňuje jejich nepřítomnost. Zpřístupňuje aplikaci bajty CBT.
Strict Vyžaduje CBT u autentizovaných požadavků a odmítne žádosti bez nich. Zpřístupňuje aplikaci bajty CBT.

Následující příklad se rozhodne použít posílení zabezpečení Strict:

builder.WebHost.UseHttpSys(options =>
{
    options.HttpAuthenticationHardeningLevel =
        HttpAuthenticationHardeningLevel.Strict;
});

Pokud HTTP.sys nemůže použít Strict posílení zabezpečení, spuštění serveru selže s chybou HttpSysException. Při Legacy nebo Medium se zaznamená selhání použití nastavení a spuštění pokračuje. Samotná nakonfigurovaná hodnota nezaručuje, že operační systém nastavení použil.

Warning

Strict hardening může způsobit selhání Windows authentication u klientů nebo proxy serverů, které nedodají platnou CBT. Před povolením v produkčním prostředí otestujte ve vašem prostředí kompatibilitu klienta a ukončení protokolu TLS.

Při připojování k existující frontě požadavků nakonfigurujte posílení zabezpečení na naslouchací službě, která vlastní skupinu adres URL. Aplikace, která se připojuje, nepoužije konfiguraci skupiny adres URL.

Přístup k bajtům CBT najdete v tématu Získání tokenů vazby kanálu.

Opt in to CBT hardening for HTTPS endpoints that use Windows authentication by setting the Microsoft.AspNetCore.Server.HttpSys.EnableCBTHardening AppContext switch to true. Tento přepínač vybere střední posílení zabezpečení, které ověří dodané CBT, ale umožňuje jejich nepřítomnost.

Povolte přepínač v souboru projektu runtimeconfig.template.json :

{
  "configProperties": {
    "Microsoft.AspNetCore.Server.HttpSys.EnableCBTHardening": true
  }
}

Případně můžete přepínač nastavit programově před sestavením hostitele v souboru Program:

AppContext.SetSwitch("Microsoft.AspNetCore.Server.HttpSys.EnableCBTHardening", true);

Warning

Posílení CBT je ve výchozím nastavení vypnuté. Povolení může způsobit selhání ověřování Windows pro klienty nebo proxy servery, které nepodporují vázání kanálu. Před povolením v produkčním prostředí důkladně otestujte.

Podpora ukládání odpovědí v režimu jádra do vyrovnávací paměti

V některých scénářích můžou velké objemy malých zápisů s vysokou latencí způsobit významný dopad na HTTP.sysvýkon . Nedostatek Pipe vyrovnávací paměti v implementaci HTTP.sys způsobuje tento dopad. Pro zlepšení výkonu v těchto scénářích je zahrnuta podpora ukládání odpovědí do HTTP.sysvyrovnávací paměti . Povolte ukládání do vyrovnávací paměti nastavením EnableKernelResponseBuffering na true. Ukládání odpovědí do vyrovnávací paměti by měla být povolena aplikací, která provádí synchronní vstupně-výstupní operace nebo asynchronní vstupně-výstupní operace s maximálně jedním nevyřízeným zápisem najednou. V těchto scénářích může ukládání odpovědí do vyrovnávací paměti výrazně zlepšit propustnost u připojení s vysokou latencí.

Aplikace, které používají asynchronní vstupně-výstupní operace a které můžou mít najednou více než jeden zápis, by tento příznak neměly používat. Povolením tohoto příznaku může dojít k vyššímu využití procesoru a paměti protokolem HTTP.Sys.

Jak používat HTTP.sys

Konfigurace aplikace ASP.NET Core tak, aby používala HTTP.sys

Při sestavování hostitele zavolejte rozšiřující metodu UseHttpSys a určete požadované HttpSysOptions. Následující příklad nastaví možnosti na výchozí hodnoty:

using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.HttpSys;

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.UseHttpSys(options =>
{
    options.AllowSynchronousIO = false;
    options.Authentication.Schemes = AuthenticationSchemes.None;
    options.Authentication.AllowAnonymous = true;
    options.MaxConnections = null;
    options.MaxRequestBodySize = 30_000_000;
    options.UrlPrefixes.Add("http://localhost:5005");
});

builder.Services.AddRazorPages();

var app = builder.Build();

Další konfigurace HTTP.sys se zpracovává prostřednictvím nastavení registru.

Další informace o možnostech HTTP.sys naleznete v tématu HttpSysOptions.

Přizpůsobení popisovačů zabezpečení

Fronta požadavků ve HTTP.sys je struktura na úrovni jádra, která dočasně ukládá příchozí požadavky HTTP, dokud nebude vaše aplikace připravená je zpracovat. Správa přístupu k frontě žádostí pomocí RequestQueueSecurityDescriptor. Nastavte ji na GenericSecurityDescriptor instanci při konfiguraci HTTP.sys serveru.

Přizpůsobením popisovače zabezpečení můžete povolit nebo odepřít přístup ke frontě žádostí konkrétním uživatelům nebo skupinám. To je užitečné ve scénářích, kdy chcete omezit nebo delegovat HTTP.sys zpracování požadavků na úrovni operačního systému.

Následující kód například umožňuje přístup všem ověřeným uživatelům, ale odmítá hosty.

using System.Security.AccessControl;
using System.Security.Principal;
using Microsoft.AspNetCore.Server.HttpSys;

// Create a new security descriptor
var securityDescriptor = new CommonSecurityDescriptor(isContainer: false, isDS: false, sddlForm: string.Empty);

// Create a discretionary access control list (DACL)
var dacl = new DiscretionaryAcl(isContainer: false, isDS: false, capacity: 2);
dacl.AddAccess(
    AccessControlType.Allow,
    new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null),
    -1,
    InheritanceFlags.None,
    PropagationFlags.None
);
dacl.AddAccess(
    AccessControlType.Deny,
    new SecurityIdentifier(WellKnownSidType.BuiltinGuestsSid, null),
    -1,
    InheritanceFlags.None,
    PropagationFlags.None
);

// Assign the DACL to the security descriptor
securityDescriptor.DiscretionaryAcl = dacl;

// Configure HTTP.sys options
var builder = WebApplication.CreateBuilder();
builder.WebHost.UseHttpSys(options =>
{
    options.RequestQueueSecurityDescriptor = securityDescriptor;
});

Tato RequestQueueSecurityDescriptor vlastnost se vztahuje pouze při vytváření nové fronty požadavků. Tato vlastnost nemá vliv na existující fronty požadavků. Když je AttachRequestQueueMode, otevře existující frontu, takže možnosti na úrovni fronty, jako jsou RequestQueueSecurityDescriptor a RequestQueueLimit, neplatí. V režimu Attach musí být nastavení skupiny URL, jako jsou časové limity a posílení zabezpečení ověřování, nakonfigurováno naslouchacím procesem, který vlastní skupinu URL, a UrlPrefixes se používá pouze k výpočtu PathBase. CreateOrAttach stále konfiguruje vlastní skupinu adres URL a zaregistruje ji UrlPrefixes, i když už fronta existuje. Nastavení předpon, které již zaregistroval jiný naslouchací proces, zůstává řízeno tímto naslouchacím procesem.

MaxRequestBodySize

Maximální povolená velikost libovolného textu požadavku v bajtech. Pokud je nastavená hodnota null, maximální velikost textu požadavku je neomezená. Tento limit nemá žádný vliv na upgradovaná připojení, která jsou vždy neomezená.

Doporučená metoda přepsání limitu v aplikaci ASP.NET Core MVC pro jednu položku IActionResult je použít atribut RequestSizeLimitAttribute na metodě akce:

[RequestSizeLimit(100000000)]
public IActionResult MyActionMethod()

Pokud se aplikace pokusí nakonfigurovat limit požadavku poté, co aplikace začne číst požadavek, vyvolá se výjimka. IsReadOnly Vlastnost lze použít k označení, jestli MaxRequestBodySize je vlastnost ve stavu jen pro čtení, což znamená, že je příliš pozdě na konfiguraci limitu.

Pokud má aplikace přepsat MaxRequestBodySize pro jednotlivé žádosti, použijte: IHttpMaxRequestBodySizeFeature

app.Use((context, next) =>
{
    context.Features.GetRequiredFeature<IHttpMaxRequestBodySizeFeature>()
                                             .MaxRequestBodySize = 10 * 1024;

    var server = context.RequestServices
        .GetRequiredService<IServer>();
    var serverAddressesFeature = server.Features
                                 .GetRequiredFeature<IServerAddressesFeature>();

    var addresses = string.Join(", ", serverAddressesFeature.Addresses);

    var loggerFactory = context.RequestServices
        .GetRequiredService<ILoggerFactory>();
    var logger = loggerFactory.CreateLogger("Sample");

    logger.LogInformation("Addresses: {addresses}", addresses);

    return next(context);
});

Pokud používáte Visual Studio, ujistěte se, že aplikace není nakonfigurovaná tak, aby spouštěla službu IIS nebo IIS Express.

V Visual Studio je výchozím spouštěcím profilem služba IIS Express. Pokud chcete projekt spustit jako konzolovou aplikaci, ručně změňte vybraný profil, jak je znázorněno na následujícím snímku obrazovky:

Výběr profilu konzolové aplikace

Konfigurace Windows Server

  1. Určete porty, které se mají otevřít pro aplikaci, a pomocí Windows Firewall nebo příkazu PowerShell New-NetFirewallRule otevřete porty firewallu, k předání provozu k HTTP.sys. V následujících příkazech a konfiguraci aplikace se používá port 443.

  2. Při nasazování na virtuální počítač Azure otevřete porty ve skupině zabezpečení. V následujících příkazech a konfiguraci aplikace se používá port 443.

  3. V případě potřeby získejte a nainstalujte certifikáty X.509.

    Na Windows vytvořte certifikáty podepsané svým držitelem pomocí rutiny New-SelfSignedCertificate PowerShellu. Nepodporovaný příklad najdete v tématu UpdateIISExpressSSLForChrome.ps1.

    Nainstalujte certifikáty podepsané sami sebou nebo certifikáty podepsané certifikační autoritou do úložiště místního počítače>osobní serveru.

  4. Pokud je aplikace nasazení závislé na rozhraní/frameworku, nainstalujte odpovídající ASP.NET Core Runtime a .NET Runtime z .NET stahování. Sada .NET SDK není na serveru nutná. ASP.NET Core necílí na .NET Framework. Informace o obsahu instalačního programu najdete v tématu Volba správného runtime.

    Pokud se jedná o samostatné nasazení, aplikace zahrnuje modul runtime ve svém nasazení. Instalace frameworku na serveru není nutná.

  5. Nakonfigurujte adresy URL a porty v aplikaci.

    Ve výchozím nastavení se ASP.NET Core váže na http://localhost:5000. Pokud chcete nakonfigurovat předpony adres URL a porty, patří mezi ně tyto možnosti:

    • UseUrls
    • urls Argument příkazového řádku
    • ASPNETCORE_URLS proměnná prostředí
    • UrlPrefixes

    Následující příklad kódu ukazuje, jak použít UrlPrefixes s místní IP adresou 10.0.0.4 serveru na portu 443:

    var builder = WebApplication.CreateBuilder(args);
    
    builder.WebHost.UseHttpSys(options =>
    {
        options.UrlPrefixes.Add("https://10.0.0.4:443");
    });
    
    builder.Services.AddRazorPages();
    
    var app = builder.Build();
    

    Výhodou UrlPrefixes je, že se okamžitě vygeneruje chybová zpráva pro nesprávně formátované předpony.

    Nastavení v UrlPrefixes přepisuje nastaveníUseUrls/urls/ASPNETCORE_URLS. Proto je výhodou UseUrls, urls a proměnné prostředí ASPNETCORE_URLS, že je jednodušší přepínat mezi Kestrel a HTTP.sys.

    HTTP.sys rozpoznává dva typy zástupných znaků v předponách adresy URL:

    • * je slabá vazba, označovaná také jako záložní vazba. Pokud je http://*:5000předpona adresy URL a něco jiného je vázané na port 5000, tato vazba se nepoužije.
    • + je silné vazby. Pokud je http://+:5000předpona adresy URL, použije se tato vazba před jinými vazbami portu 5000.

    Další informace naleznete v tématu UrlPrefix Strings.

    Warning

    Vazby nejvyšší úrovně se zástupnými znaky (http://*:80/ a http://+:80) by se neměly používat. Vazby zástupných znaků na nejvyšší úrovni vytvářejí zranitelnosti zabezpečení aplikací. Týká se to silných i slabých zástupných znaků. Místo zástupných znaků použijte explicitní názvy hostitelů nebo IP adresy. Přiřazení zástupného znaku subdomény (například *.mysub.com) nepředstavuje bezpečnostní riziko, pokud řídíte celou nadřazenou doménu (na rozdíl od *.com, které je ohrožené). Další informace viz RFC 9110: Oddíl 7.2: Host a :authority.

    Většina konfigurací pro aplikace a kontejnery definuje jenom port pro naslouchání, jako je port 80, aniž by bylo nutné zadat další omezení, jako je hostitel nebo cesta. HTTP_PORTS a HTTPS_PORTS jsou konfigurační klíče, které určují porty pro naslouchání pro servery Kestrel a HTTP.sys. Klíče můžete zadat jako proměnné prostředí definované s předponami DOTNET_ nebo ASPNETCORE_, případně je nastavit přímo pomocí jiného způsobu konfigurace, například v souboru appsettings.json. Každá konfigurace je seznam hodnot portů oddělený středníkem, jak je znázorněno v následujícím příkladu:

    ASPNETCORE_HTTP_PORTS=80;8080
    ASPNETCORE_HTTPS_PORTS=443;8081
    

    Konfigurace v příkladu je zkratka pro následující specifikaci, která definuje schéma (HTTP nebo HTTPS) a libovolného hostitele nebo IP adresy:

    ASPNETCORE_URLS=http://*:80/;http://*:8080/;https://*:443/;https://*:8081/
    

    Konfigurační klíče HTTP_PORTS a HTTPS_PORTS mají nižší prioritu. Pokud jsou jiné adresy URL nebo hodnoty nastavené přímo v kódu, můžou přepsat konfigurační klíče. Nakonfigurujte certifikáty samostatně pomocí mechaniky specifické pro server pro HTTPS.

    Note

    Nezaměňujte konfigurační klíč HTTPS_PORTS a proměnnou prostředí ASPNETCORE_HTTPS_PORTS, které nastavují porty pro konfiguraci koncového bodu Kestrel/HTTP.sys, s konfiguračním klíčem HTTPS_PORT a proměnnou prostředí ASPNETCORE_HTTPS_PORT, které nastavují port pro middleware pro přesměrování na HTTPS.

    Tyto konfigurační klíče odpovídají zástupným vazbám nejvyšší úrovně. Jsou praktické pro scenáře vývoje a využití kontejnerů, ale na počítači, který může zároveň hostovat jiné služby, se zástupným znakům vyhněte.

  6. Předregistrujte předpony URL adresy na serveru.

    Integrovaný nástroj pro konfiguraci HTTP.sys je netsh.exe. netsh.exe slouží k rezervaci předpon adres URL a přiřazení certifikátů X.509. Nástroj vyžaduje oprávnění správce.

    Pomocí nástroje netsh.exe zaregistrujte adresy URL aplikace:

    netsh http add urlacl url=<URL> user=<USER>
    
    • <URL>: Plně kvalifikovaná adresa URL (Uniform Resource Locator). Nepoužívejte vazbu se zástupným znakem. Použijte platný název hostitele nebo místní IP adresu. Adresa URL musí obsahovat koncové lomítko.
    • <USER>: Určuje název uživatele nebo skupiny uživatelů.

    V následujícím příkladu je 10.0.0.4místní IP adresa serveru:

    netsh http add urlacl url=https://10.0.0.4:443/ user=Users
    

    Při registraci adresy URL nástroj odpoví URL reservation successfully added.

    Pokud chcete odstranit registrovanou adresu URL, použijte příkaz delete urlacl :

    netsh http delete urlacl url=<URL>
    
  7. Zaregistrujte certifikáty X.509 na serveru.

    Pomocí nástroje netsh.exe zaregistrujte certifikáty pro aplikaci:

    netsh http add sslcert ipport=<IP>:<PORT> certhash=<THUMBPRINT> appid="{<GUID>}"
    
    • <IP>: Určuje místní IP adresu vazby. Nepoužívejte vazbu se zástupným znakem. Použijte platnou IP adresu.
    • <PORT>: Určuje port pro vázání.
    • <THUMBPRINT>: Kryptografický otisk certifikátu X.509.
    • <GUID>: Identifikátor GUID vygenerovaný vývojářem, který představuje aplikaci pro informační účely.

    Pro referenční účely uložte identifikátor GUID v aplikaci jako značku balíčku:

    • Ve Visual Studio:
      • Otevřete vlastnosti projektu aplikace tak, že kliknete pravým tlačítkem na aplikaci v Průzkumník řešení a vyberete Properties.
      • Vyberte kartu Balíček.
      • Do pole Značky zadejte identifikátor GUID, který jste vytvořili.
    • Pokud nepoužíváte Visual Studio:
      • Otevřete soubor projektu aplikace.

      • <PackageTags> Přidejte vlastnost do nového nebo existujícího <PropertyGroup> identifikátoru GUID, který jste vytvořili:

        <PropertyGroup>
          <PackageTags>00001111-aaaa-2222-bbbb-3333cccc4444</PackageTags>
        </PropertyGroup>
        

    V následujícím příkladu:

    • Místní IP adresa serveru je 10.0.0.4.
    • Online generátor náhodných identifikátorů GUID poskytuje hodnotu appid.
    netsh http add sslcert
        ipport=10.0.0.4:443
        certhash=b66ee04419d4ee37464ab8785ff02449980eae10
        appid="{00001111-aaaa-2222-bbbb-3333cccc4444}"
    

    Při registraci certifikátu nástroj odpoví SSL Certificate successfully added.

    Pokud chcete odstranit registraci certifikátu, použijte příkaz delete sslcert :

    netsh http delete sslcert ipport=<IP>:<PORT>
    

    Referenční dokumentace pro netsh.exe:

  8. Spustit aplikaci.

    Spusťte aplikaci pod identitou oprávněnou k použití rezervace adresy URL. Oprávnění správce se vyžadují ke konfiguraci rezervací adres URL a vazeb certifikátů, ale nejsou nutná ke spuštění aplikace, jejíž identita má potřebná oprávnění k oboru názvů. Vazba na místní IP adresu nebo port 443 sama o sobě nevyžaduje zvýšení oprávnění procesu aplikace. Další informace najdete v tématu Rezervace oblastí názvů, registrace a směrování.

    Aplikace odpoví na veřejnou IP adresu serveru. V tomto příkladu je server dostupný z internetu na své veřejné IP adrese 104.214.79.47.

    V tomto příkladu se používá vývojový certifikát. Stránka se po vynechání upozornění nedůvěryhodného certifikátu prohlížeče bezpečně načte.

    Okno prohlížeče zobrazující načtenou indexovou stránku aplikace

Scénáře týkající se proxy serveru a nástroje pro vyrovnávání zatížení

U aplikací hostovaných HTTP.sys, které pracují s požadavky z internetu nebo podnikové sítě, může být při hostování za proxy servery a nástroji pro vyrovnávání zatížení potřeba další konfigurace. Další informace najdete v tématu Konfigurování ASP.NET Core pro práci se servery proxy a nástroji pro vyrovnávání zatížení.

Při zpracování požadavku s hlavičkou Content-Length i hlavičkou Transfer-Encoding , jejíž konečné kódování je chunked, HTTP.sys odebere Content-Length ze záhlaví požadavků v aplikaci a ukončí připojení po reakci ve výchozím nastavení. Proxy by neměly posílat konfliktní rámování požadavků. Toto chování pomáhá zabránit pašování požadavků; Neznamená to, že každý takový požadavek se před dosažením aplikace odmítne.

Kontrola TLS a vlastností požadavku

HTTP.sys zpřístupňuje funkce požadavku pro kontrolu informací protokolu TLS. Dostupnost závisí na požadavku, Windows verzi a konfiguraci HTTP.sys.

Získání vyjednané sady šifer TLS

ITlsHandshakeFeature zpřístupňuje vyjednanou sadu šifer prostřednictvím své vlastnosti NegotiatedCipherSuite pro HTTP.sys. Tato funkce není k dispozici pro požadavek bez TLS. Vlastnost může být null v případě, že Windows dotaz nepodporuje nebo provedení dotazu selže.

var handshake = context.Features.Get<ITlsHandshakeFeature>();
if (handshake?.NegotiatedCipherSuite is { } cipherSuite)
{
    logger.LogInformation("Negotiated TLS cipher suite: {CipherSuite}", cipherSuite);
}
else
{
    logger.LogInformation("The negotiated TLS cipher suite isn't available.");
}

Přečtení TLS ClientHello

Pomocí TryGetTlsClientHello načtěte nezpracované bajty TLS ClientHello na vyžádání. Konfigurace služby HTTPS musí povolit HTTP_SERVICE_CONFIG_SSL_FLAG_ENABLE_CACHE_CLIENT_HELLO. Konfigurace ASP.NET Core pro použití HTTP.sys nepovoluje tento nativní příznak. Viz HttpSetServiceConfiguration a HTTP_SERVICE_CONFIG_ID.

Nejprve zavolejte metodu s prázdným rozsahem, abyste získali požadovanou velikost vyrovnávací paměti, a pak přidělte vyrovnávací paměť a zkuste to znovu:

var feature = context.Features.GetRequiredFeature<IHttpSysRequestPropertyFeature>();
_ = feature.TryGetTlsClientHello(Span<byte>.Empty, out var requiredSize);

var pooled = requiredSize <= 1024 ? ArrayPool<byte>.Shared.Rent(requiredSize) : null;
var buffer = pooled ?? new byte[requiredSize];
try
{
    if (!feature.TryGetTlsClientHello(buffer, out var bytesReturned))
    {
        throw new InvalidOperationException(
            $"The TLS ClientHello buffer must be resized to {bytesReturned} bytes.");
    }

    logger.LogInformation("Retrieved {ByteCount} TLS ClientHello bytes.", bytesReturned);
}
finally
{
    if (pooled is not null)
    {
        ArrayPool<byte>.Shared.Return(pooled);
    }
}

Dotazování jiných vlastností nativních požadavků

TryGetRequestProperty HttpQueryRequestProperty zpřístupňuje pro libovolné vlastnosti nativního požadavku.

  • propertyId identifikuje hodnotu z nativního HTTP_REQUEST_PROPERTY výčtu.
  • qualifier obsahuje volitelné bajty specifické pro vlastnost. Prázdné rozpětí se předává Windows jako null pointer.
  • output přijímá nativní bajty. Volající je musí interpretovat pomocí odpovídající nativní datové struktury.
  • bytesReturned obsahuje bajty napsané při úspěchu. Při selhání kvůli nedostatečné velikosti vyrovnávací paměti závisí hlášení požadované velikosti na nativní vlastnosti. U vlastností s pevnou velikostí přidělte vyrovnávací paměť o velikosti odpovídající nativní struktuře místo předpokladu, že dotaz prázdné vyrovnávací paměti hlásí požadovanou velikost.

Následující příklad dotazuje vlastnost TLS ClientHello prostřednictvím rozhraní API pro obecné účely. Vyžaduje stejnou nativní konfiguraci ukládání do mezipaměti ClientHello jako TryGetTlsClientHello:

const int HttpRequestPropertyTlsClientHello = 11;
var feature = context.Features.GetRequiredFeature<IHttpSysRequestPropertyFeature>();
_ = feature.TryGetRequestProperty(
    HttpRequestPropertyTlsClientHello, qualifier: default, output: default,
    out var requiredSize);
var buffer = new byte[requiredSize];

if (!feature.TryGetRequestProperty(
    HttpRequestPropertyTlsClientHello, qualifier: default, output: buffer,
    out var bytesReturned))
{
    throw new InvalidOperationException(
        $"The request property buffer must be resized to {bytesReturned} bytes.");
}

logger.LogInformation("Retrieved {ByteCount} native request property bytes.", bytesReturned);

Získání tokenů vazeb kanálu

TryGetChannelBindingBytes poskytuje přístup k bajtům vazby kanálu TLS:

var tls = context.Features.Get<ITlsConnectionFeature>();
if (tls is not null &&
    tls.TryGetChannelBindingBytes(ChannelBindingKind.Endpoint, out var token))
{
    logger.LogInformation("TLS endpoint binding contains {ByteCount} bytes.", token.Length);
}
else
{
    logger.LogInformation("TLS endpoint channel binding isn't available.");
}

HTTP.sys podporuje ChannelBindingKind.Endpoint, odpovídající vazbě tls-server-end-point definované RFC 5929. Jiné druhy vazeb vrátí false. Nedostupný token také vrátí false. Vystavení CBT vyžaduje Medium nebo Strictposílení zabezpečení ověřování , které má být použito HTTP.sys.

Načítání bajtů CBT sama neověřuje požadavek ani vynucuje Strict posílení zabezpečení. Vrácené bajty obsahují strukturu Windows SEC_CHANNEL_BINDINGS a její data vazby, nejen hodnotu hash certifikátu.

Získání podrobných informací o načasování pomocí IHttpSysRequestTimingFeature

IHttpSysRequestTimingFeature poskytuje podrobné informace o načasování požadavků:

  • Časové razítka se získávají pomocí QueryPerformanceCounter.
  • Frekvenci časového razítka lze získat prostřednictvím QueryPerformanceFrequency.
  • Index časování lze přetypovat na HttpSysRequestTimingType , abyste věděli, co časování představuje.
  • Hodnota může být 0, pokud není pro aktuální požadavek k dispozici časování.
  • Vyžaduje Windows 10 verze 2004, Windows Server 2022 nebo novější.
using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.HttpSys;

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.UseHttpSys();

var app = builder.Build();

app.Use((context, next) =>
{
    var feature = context.Features.GetRequiredFeature<IHttpSysRequestTimingFeature>();
    
    var loggerFactory = context.RequestServices.GetRequiredService<ILoggerFactory>();
    var logger = loggerFactory.CreateLogger("Sample");

    var timestamps = feature.Timestamps;

    for (var i = 0; i < timestamps.Length; i++)
    {
        var timestamp = timestamps[i];
        var timingType = (HttpSysRequestTimingType)i;

        logger.LogInformation("Timestamp {timingType}: {timestamp}",
                                          timingType, timestamp);
    }

    return next(context);
});

app.MapGet("/", () => Results.Ok());

app.Run();

IHttpSysRequestTimingFeature.TryGetTimestamp načte časové razítko pro zadaný typ časování:

using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.HttpSys;
var builder = WebApplication.CreateBuilder(args);

builder.WebHost.UseHttpSys();

var app = builder.Build();

app.Use((context, next) =>
{
    var feature = context.Features.GetRequiredFeature<IHttpSysRequestTimingFeature>();

    var loggerFactory = context.RequestServices.GetRequiredService<ILoggerFactory>();
    var logger = loggerFactory.CreateLogger("Sample");

    var timingType = HttpSysRequestTimingType.RequestRoutingEnd;

    if (feature.TryGetTimestamp(timingType, out var timestamp))
    {
        logger.LogInformation("Timestamp {timingType}: {timestamp}",
                                          timingType, timestamp);
    }
    else
    {
        logger.LogInformation("Timestamp {timingType}: not available for the "
                                           + "current request",    timingType);
    }

    return next(context);
});

app.MapGet("/", () => Results.Ok());

app.Run();

IHttpSysRequestTimingFeature.TryGetElapsedTime poskytuje uplynulý čas mezi dvěma zadanými časy:

using Microsoft.AspNetCore.Http.Features;
using Microsoft.AspNetCore.Server.HttpSys;

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.UseHttpSys();

var app = builder.Build();

app.Use((context, next) =>
{
    var feature = context.Features.GetRequiredFeature<IHttpSysRequestTimingFeature>();

    var loggerFactory = context.RequestServices.GetRequiredService<ILoggerFactory>();
    var logger = loggerFactory.CreateLogger("Sample");

    var startingTimingType = HttpSysRequestTimingType.RequestRoutingStart;
    var endingTimingType = HttpSysRequestTimingType.RequestRoutingEnd;

    if (feature.TryGetElapsedTime(startingTimingType, endingTimingType, out var elapsed))
    {
        logger.LogInformation(
            "Elapsed time {startingTimingType} to {endingTimingType}: {elapsed}",
            startingTimingType,
            endingTimingType,
            elapsed);
    }
    else
    {
        logger.LogInformation(
            "Elapsed time {startingTimingType} to {endingTimingType}:"
            + " not available for the current request.",
            startingTimingType,
            endingTimingType);
    }

    return next(context);
});

app.MapGet("/", () => Results.Ok());

app.Run();

Pokročilé funkce HTTP/2 pro podporu gRPC

Další funkce HTTP/2 v HTTP.sys podporují gRPC, včetně podpory pro přívěsky odpovědi a odesílání reset rámců.

Požadavky na spuštění gRPC s HTTP.sys:

  • Windows 11 Build 22000 nebo novější, Windows Server 2022 Build 20348 nebo novější.
  • Připojení TLS 1.2 nebo novější

Trailers

Přívěšky HTTP se podobají hlavičkám HTTP, s výjimkou toho, že se odešlou po odeslání textu odpovědi. Pro IIS a HTTP.sys jsou podporovány pouze přívěsky odpovědí HTTP/2.

if (httpContext.Response.SupportsTrailers())
{
    httpContext.Response.DeclareTrailer("trailername");	

    // Write body
    httpContext.Response.WriteAsync("Hello world");

    httpContext.Response.AppendTrailer("trailername", "TrailerValue");
}

V předchozím ukázkovém kódu:

  • SupportsTrailers zajišťuje, aby byly pro odpověď podporovány trailery.
  • DeclareTrailer přidá daný název traileru do hlavičky odpovědi Trailer. Deklarování přívěsů odpovědí je volitelné, ale doporučuje se. Pokud je DeclareTrailer voláno, musí to být před odesláním hlaviček odpovědi.
  • AppendTrailer připojí koncovou hlavičku.

Reset

Resetování umožňuje serveru resetovat požadavek HTTP/2 se zadaným kódem chyby. Žádost o resetování se považuje za přerušenou.

var resetFeature = httpContext.Features.Get<IHttpResetFeature>();
resetFeature.Reset(errorCode: 2);

Reset v předchozím příkladu kódu určuje INTERNAL_ERROR kód chyby. Další informace o kódech chyb HTTP/2 najdete v části specifikace HTTP/2 kódů chyb.

Tracing

Informace o tom, jak získat trasování z HTTP.sys, najdete v tématu "Scénáře spravovatelnosti HTTP.sys".

Automatické vyřazení z fondu paměti

Fondy paměti používané službou Kestrel, IIS a HTTP.sys automaticky vyřazují bloky paměti, když je aplikace v nečinnosti nebo při nízkém zatížení. Funkce se spustí automaticky a nemusí být povolená ani nakonfigurovaná ručně.

Ve verzích .NET starších než 10 zůstává paměť přidělená fondem vyhrazena, i když se nepoužívá. Tato funkce automatického vyřazení snižuje celkové využití paměti a pomáhá aplikacím reagovat v různých úlohách.

Použití metrik fondu paměti

Výchozí fond paměti používaný implementacemi serveru ASP.NET Core zahrnuje metriky, které lze použít k monitorování a analýze vzorců využití paměti. Metriky jsou pod názvem "Microsoft.AspNetCore.MemoryPool".

Informace o metrikách a jejich použití najdete v tématu ASP.NET Core metriky.

Správa fondů paměti

Kromě efektivního používání fondů paměti vyřazením nepotřebných bloků paměti poskytuje ASP.NET Core integrovanou IMemoryPoolFactory a implementaci. Zpřístupňuje implementaci vaší aplikaci prostřednictvím injektáže závislostí.

Následující příklad kódu ukazuje jednoduchou službu na pozadí, která k vytvoření fondů paměti používá integrovanou továrnu na fondy paměti. Tyto fondy využívají funkci automatického vyřazení:

public class MyBackgroundService : BackgroundService
{
    private readonly MemoryPool<byte> _memoryPool;

    public MyBackgroundService(IMemoryPoolFactory<byte> factory)
    {
        _memoryPool = factory.Create();
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                await Task.Delay(20, stoppingToken);
                // do work that needs memory
                // consider checking _memoryPool.MaxBufferSize
                var rented = _memoryPool.Rent(100);
                rented.Dispose();
            }
            catch (OperationCanceledException)
            {
                return;
            }
        }
    }
}

Pokud chcete použít vlastní továrnu pro vytváření paměťových fondů, vytvořte třídu, která implementuje IMemoryPoolFactory, a zaregistrujte ji pomocí injektáže závislostí, jak je znázorněno v následujícím příkladu. Fondy paměti vytvořené tímto způsobem nevyužívají funkci automatického vyřazení, pokud ve vlastní továrně neimplementujete podobnou logiku vyřazení:

services.AddSingleton<IMemoryPoolFactory<byte>,
CustomMemoryPoolFactory>();

public class CustomMemoryPoolFactory : IMemoryPoolFactory<byte>
{
    public MemoryPool<byte> Create()
    {
        // Return a custom MemoryPool implementation
        // or the default, as is shown here.
        return MemoryPool<byte>.Shared;
    }
}

Pokud používáte fond paměti, mějte na paměti MaxBufferSize fondu.

Note

Odkazy na referenční zdroj .NET v dokumentaci obvykle otevřou výchozí větev úložiště, která představuje aktuální vývoj další verze .NET. Pokud chcete vybrat tag pro konkrétní vydání, použijte rozevírací seznam pro přepnutí větví nebo tagů.