Üzembe helyezési elrendezés ASP.NET Core által üzemeltetett Blazor WebAssembly alkalmazásokhoz

Ez a cikk azt ismerteti, hogyan engedélyezheti az üzemeltetett Blazor WebAssembly központi telepítéseket olyan környezetekben, amelyek blokkolják a dinamikus csatolású függvénytár (DLL) fájlok letöltését és végrehajtását.

Megjegyzés:

Ez az útmutató olyan környezetekkel foglalkozik, amelyek megakadályozzák az ügyfelek DLL-ek letöltését és végrehajtását. A .NET 8-ban vagy újabb verziókban Blazor a Webcil fájlformátumot használja a probléma megoldásához. További információ: ASP.NET Core alkalmazások hosztolása és telepítése Blazor WebAssembly. A cikkben ismertetett kísérleti NuGet-csomagot használó többrészes kötegelés nem támogatott a Blazor .NET 8-as vagy újabb alkalmazásaihoz. A cikkben található útmutatás segítségével létrehozhat saját többrészes NuGet-csomagot a .NET 8-as vagy újabb verziójához.

Blazor WebAssembly Az alkalmazások működéséhez dinamikus csatolású kódtárak (DLL-ek) szükségesek, de egyes környezetek megakadályozzák az ügyfeleket a DLL-ek letöltésében és végrehajtásában. A biztonsági termékek gyakran képesek a hálózaton áthaladó fájlok tartalmának ellenőrzésére, valamint a DLL-fájlok blokkolására vagy karanténba helyezésére. Ez a cikk az alkalmazások engedélyezésének Blazor WebAssembly egyik módszerét ismerteti ezekben a környezetekben, ahol egy többrészes csomagfájl jön létre az alkalmazás DLL-jeiből, hogy a DLL-ek együtt tölthetők le a biztonsági korlátozások megkerülésével.

Az üzemeltetett Blazor WebAssembly alkalmazások a következő funkciókkal szabhatják testre a közzétett fájljaikat és az alkalmazás DLL-fájljainak csomagolását:

• JavaScript-inicializálók , amelyek lehetővé teszik a rendszerindítási Blazor folyamat testreszabását.
• MSBuild bővíthetőség a közzétett fájlok listájának átalakításához és a közzétételi bővítmények meghatározásáhozBlazor. Blazor A közzétételi bővítmények a közzétételi folyamat során definiált fájlok, amelyek alternatív ábrázolást biztosítanak a közzétett Blazor WebAssembly alkalmazások futtatásához szükséges fájlkészlethez. Ebben a cikkben egy Blazor közzétételi bővítményt hozunk létre, amely egy többrészes csomagot hoz létre az alkalmazás összes DLL-jével egyetlen fájlba csomagolva, így a DLL-ek együtt tölthetők le.

Az ebben a cikkben bemutatott megközelítés kiindulópontként szolgál a fejlesztők számára saját stratégiáik és egyéni betöltési folyamataik kidolgozásához.

Figyelmeztetés

A biztonsági korlátozások megkerülésére irányuló bármilyen megközelítést gondosan meg kell fontolni annak biztonsági vonatkozásai szempontjából. Javasoljuk, hogy a cikkben ismertetett megközelítés elfogadása előtt vizsgálja meg tovább a témát a szervezet hálózatbiztonsági szakembereivel. A megfontolandó alternatívák a következők:

• Engedélyezze a biztonsági berendezéseket és a biztonsági szoftvereket, hogy a hálózati ügyfelek pontosan az alkalmazáshoz szükséges Blazor WebAssembly fájlokat töltsék le és használják.
• Váltson az Blazor WebAssembly üzemeltetési modellről az Blazor Server üzemeltetési modellre, amely az alkalmazás összes C#-kódját karbantartja a kiszolgálón, és nem igényel DLL-eket az ügyfelekre. Blazor Server azt az előnyt is kínálja, hogy a C#-kód privát marad anélkül, hogy webes API-alkalmazásokat kellene használni a C#-kód adatvédelméhez Blazor WebAssembly az alkalmazásokkal.

Kísérleti NuGet-csomag és mintaalkalmazás

A cikkben ismertetett megközelítést a kísérletiMicrosoft.AspNetCore.Components.WebAssembly.MultipartBundle csomag (NuGet.org) használja a .NET 6-os vagy újabb verzióit célzó alkalmazásokhoz. A csomag MSBuild-célokat tartalmaz a Blazor közzétételi kimenet testreszabásához, valamint egy JavaScript-inicializálót egy egyéni rendszerindító erőforrás-betöltő használatához, amelyek mindegyikét a cikk későbbi részében részletesen ismertetjük.

Figyelmeztetés

A kísérleti és előzetes verziójú funkciók visszajelzések gyűjtésére szolgálnak, és éles környezetben nem támogatottak.

A cikk későbbi részében a Betöltési folyamat testreszabása Blazor WebAssembly NuGet-csomagon keresztül szakasz három alszakaszával részletes magyarázatot ad a Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle csomag konfigurációjáról és kódjáról. A részletes magyarázatokat fontos megérteni, amikor saját stratégiát és egyéni betöltési folyamatot hoz létre az alkalmazásokhoz Blazor WebAssembly . Ha a közzétett, kísérleti, nem támogatott NuGet-csomagot testreszabás nélkül szeretné helyi bemutatóként használni, hajtsa végre a következő lépéseket:

1. Használjon meglévő üzemeltetett Blazor WebAssemblymegoldást, vagy hozzon létre egy új megoldást a projektsablonból Blazor WebAssembly a Visual Studio használatával, vagy adja át a beállítást-ho|--hosted a dotnet new parancsnak (dotnet new blazorwasm -ho). További információ: Eszközkészlet az ASP.NET Core számára Blazor.

2. A projektben Client adja hozzá a kísérleti Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle csomagot.

   Megjegyzés:

   A csomagok .NET-alkalmazásokhoz való hozzáadásáról a Csomagok telepítése és kezelésea csomaghasználati munkafolyamatban (NuGet-dokumentáció) című cikkben talál útmutatást. Ellenőrizze a megfelelő csomagverziókat a NuGet.org.

3. A projektben Server adjon hozzá egy végpontot a csomagfájl kiszolgálásához ().app.bundle A példakód a cikk A gazdakiszolgáló alkalmazásból származó csomag kiszolgálása című szakaszában található.

4. Tegye közzé az alkalmazást a kiadási konfigurációban.

A betöltési folyamat testreszabása Blazor WebAssembly NuGet-csomagon keresztül

Figyelmeztetés

Az ebben a szakaszban található útmutató három alszakaszával egy NuGet-csomag nulláról való felépítésére vonatkozik a saját stratégia és egyéni betöltési folyamat megvalósításához. A .NET 6 és 7 kísérletiMicrosoft.AspNetCore.Components.WebAssembly.MultipartBundle csomagja (NuGet.org) az ebben a szakaszban található útmutatáson alapul. Ha a megadott csomagot a többrészes csomagletöltési módszer helyi bemutatójában használja, nem kell követnie az ebben a szakaszban található útmutatást. A megadott csomag használatával kapcsolatos útmutatásért tekintse meg a Kísérleti NuGet-csomag és mintaalkalmazás szakaszt.

Blazor Az alkalmazás erőforrásai egy többrészes csomagfájlba vannak csomagolva, és a böngésző egy egyéni JavaScript (JS) inicializálóval tölti be. Az inicializálóval a csomagot JS használó alkalmazások esetében az alkalmazásnak csak a csomagfájlt kell kiszolgálnia, amikor a rendszer kéri. Ennek a megközelítésnek az összes többi aspektusát átláthatóan kezelik.

Az alapértelmezett közzétett Blazor alkalmazások betöltéséhez négy testreszabásra van szükség:

• Egy MSBuild-feladat a közzétételi fájlok átalakításához.
• Egy MSBuild-célokkal rendelkező NuGet-csomag, amely a Blazor közzétételi folyamathoz kapcsolódik, átalakítja a kimenetet, és meghatároz egy vagy több Blazor közzétételi bővítményfájlt (ebben az esetben egyetlen csomagot).
• Inicializáló JS az erőforrás-betöltő visszahívásának frissítéséhez Blazor WebAssembly , hogy betöltse a csomagot, és biztosítsa az alkalmazás számára az egyes fájlokat.
• A gazdaalkalmazás Server segítője, amely biztosítja, hogy a csomag kérésre kiszolgálható legyen az ügyfelek számára.

MSBuild-feladat létrehozása a közzétett fájlok listájának testreszabásához és új kiterjesztések meghatározásához

Hozzon létre egy MSBuild-feladatot nyilvános C#-osztályként, amely importálható egy MSBuild-fordítás részeként, és amely interakcióba léphet a buildtel.

A C# osztályhoz a következőkre van szükség:

• Egy új osztálykönyvtár-projekt.
• A projekt célkerete.netstandard2.0
• Hivatkozások az MSBuild csomagokra:
  • Microsoft.Build.Framework
  • Microsoft.Build.Utilities.Core

Megjegyzés:

A cikkben szereplő példák NuGet-csomagja a Microsoft által biztosított csomagról kapta a nevét. Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle A saját NuGet-csomag elnevezésével és előállításával kapcsolatos útmutatásért tekintse meg a következő NuGet-cikkeket:

• Ajánlott eljárások a csomagkészítéshez
• Csomagazonosító előtagfoglalás

Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.Tasks/Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.Tasks.csproj:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <LangVersion>8.0</LangVersion>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Build.Framework" Version="{VERSION}" />
    <PackageReference Include="Microsoft.Build.Utilities.Core" Version="{VERSION}" />
  </ItemGroup>

</Project>

Határozza meg a {VERSION} helyőrzők legújabb csomagverzióit a következő címen: NuGet.org:

• Microsoft.Build.Framework
• Microsoft.Build.Utilities.Core

Az MSBuild-feladat létrehozásához hozzon létre egy nyilvános C#-osztályt, amely kiterjed Microsoft.Build.Utilities.Task (not System.Threading.Tasks.Task), és deklarál három tulajdonságot:

• PublishBlazorBootStaticWebAsset: Az alkalmazáshoz Blazor közzétenni kívánt fájlok listája.
• BundlePath: Az elérési út, ahová a köteg írva van.
• Extension: A buildbe beépítendő új közzétételi bővítmények.

Az alábbi példaosztály BundleBlazorAssets a további testreszabás kiindulópontja:

• A Execute metódusban a csomag a következő három fájltípusból jön létre:
  • JavaScript-fájlok (dotnet.js)
  • WebAssembly (Wasm) fájlok (dotnet.wasm)
  • Alkalmazás DLL-ek (.dll)
• Létrejön egy multipart/form-data csomag. Minden fájl hozzáadódik a csomaghoz a megfelelő leírásokkal együtt a Content-Disposition fejlécen és a Content-Type fejlécen keresztül.
• A csomag létrehozása után a csomag egy fájlba lesz írva.
• A build a bővítményhez van konfigurálva. Az alábbi kód létrehoz egy bővítményelemet, és hozzáadja a tulajdonsághoz Extension . Minden bővítményelem három adatot tartalmaz:
  • A kiterjesztésfájl elérési útja.
  • Az alkalmazás gyökeréhez Blazor WebAssembly viszonyított URL-cím elérési útja.
  • A kiterjesztés neve, amely egy adott kiterjesztés által létrehozott fájlokat csoportosítja.

Az előző célok teljesítése után létrejön az MSBuild feladat a Blazor közzétételi kimenet testreszabásához. Blazor gondoskodik a bővítmények összegyűjtéséről és arról, hogy a bővítmények a megfelelő helyre legyenek másolva a közzététel kimeneti mappájában (például bin\Release\net6.0\publish). A JavaScript-, Wasm- és DLL-fájlokra ugyanazok az optimalizálások (például tömörítés) vonatkoznak, mint Blazor a többi fájlra.

Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.Tasks/BundleBlazorAssets.cs:

using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;

namespace Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.Tasks
{
    public class BundleBlazorAssets : Task
    {
        [Required]
        public ITaskItem[]? PublishBlazorBootStaticWebAsset { get; set; }

        [Required]
        public string? BundlePath { get; set; }

        [Output]
        public ITaskItem[]? Extension { get; set; }

        public override bool Execute()
        {
            var bundle = new MultipartFormDataContent(
                "--0a7e8441d64b4bf89086b85e59523b7d");

            foreach (var asset in PublishBlazorBootStaticWebAsset)
            {
                var name = Path.GetFileName(asset.GetMetadata("RelativePath"));
                var fileContents = File.OpenRead(asset.ItemSpec);
                var content = new StreamContent(fileContents);
                var disposition = new ContentDispositionHeaderValue("form-data");
                disposition.Name = name;
                disposition.FileName = name;
                content.Headers.ContentDisposition = disposition;
                var contentType = Path.GetExtension(name) switch
                {
                    ".js" => "text/javascript",
                    ".wasm" => "application/wasm",
                    _ => "application/octet-stream"
                };
                content.Headers.ContentType = 
                    MediaTypeHeaderValue.Parse(contentType);
                bundle.Add(content);
            }

            using (var output = File.Open(BundlePath, FileMode.OpenOrCreate))
            {
                output.SetLength(0);
                bundle.CopyToAsync(output).ConfigureAwait(false).GetAwaiter()
                    .GetResult();
                output.Flush(true);
            }

            var bundleItem = new TaskItem(BundlePath);
            bundleItem.SetMetadata("RelativePath", "app.bundle");
            bundleItem.SetMetadata("ExtensionName", "multipart");

            Extension = new ITaskItem[] { bundleItem };

            return true;
        }
    }
}

NuGet-csomag létrehozása a közzétételi kimenet automatikus átalakításához

Hozzon létre egy NuGet-csomagot MSBuild-célokkal, amelyek automatikusan szerepelnek a csomagra való hivatkozáskor:

• Hozzon létre egy új Razor osztálytár (RCL) projektet.
• Hozzon létre egy célfájlt a NuGet-konvenciók szerint a csomag automatikus importálásához a felhasználási projektekben. Hozzon build\net6.0\{PACKAGE ID}.targetslétre például , ahol {PACKAGE ID} a csomag csomagazonosítója.
• Gyűjtse össze a kimenetet az MSBuild feladatot tartalmazó osztálytárból, és ellenőrizze, hogy a kimenet a megfelelő helyre van-e csomagolva.
• Adja hozzá a folyamathoz való csatoláshoz Blazor szükséges MSBuild-kódot, és hívja meg az MSBuild-feladatot a csomag létrehozásához.

Az ebben a szakaszban ismertetett megközelítés csak a csomagot használja a célok és a tartalom kézbesítésére, ami eltér a legtöbb olyan csomagtól, ahol a csomag könyvtári DLL-t tartalmaz.

Figyelmeztetés

Az ebben a szakaszban ismertetett mintacsomag bemutatja, hogyan szabhatja testre a közzétételi Blazor folyamatot. A NuGet-mintacsomag csak helyi bemutatóként használható. A csomag éles környezetben való használata nem támogatott.

Megjegyzés:

A cikkben szereplő példák NuGet-csomagja a Microsoft által biztosított csomagról kapta a nevét. Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle A saját NuGet-csomag elnevezésével és előállításával kapcsolatos útmutatásért tekintse meg a következő NuGet-cikkeket:

• Ajánlott eljárások a csomagkészítéshez
• Csomagazonosító előtagfoglalás

Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle/Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.csproj:

<Project Sdk="Microsoft.NET.Sdk.Razor">

  <PropertyGroup>
    <NoWarn>NU5100</NoWarn>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <Description>
      Sample demonstration package showing how to customize the Blazor publish 
      process. Using this package in production is not supported!
    </Description>
    <IsPackable>true</IsPackable>
    <IsShipping>true</IsShipping>
    <IncludeBuildOutput>false</IncludeBuildOutput>
  </PropertyGroup>

  <ItemGroup>
    <None Update="build\**" 
          Pack="true" 
          PackagePath="%(Identity)" />
    <Content Include="_._" 
             Pack="true" 
             PackagePath="lib\net6.0\_._" />
  </ItemGroup>

  <Target Name="GetTasksOutputDlls" 
          BeforeTargets="CoreCompile">
    <MSBuild Projects="..\Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.Tasks\Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.Tasks.csproj" 
             Targets="Publish;PublishItemsOutputGroup" 
             Properties="Configuration=Release">
      <Output TaskParameter="TargetOutputs" 
              ItemName="_TasksProjectOutputs" />
    </MSBuild>
    <ItemGroup>
      <Content Include="@(_TasksProjectOutputs)" 
               Condition="'%(_TasksProjectOutputs.Extension)' == '.dll'" 
               Pack="true" 
               PackagePath="tasks\%(_TasksProjectOutputs.TargetPath)" 
               KeepMetadata="Pack;PackagePath" />
    </ItemGroup>
  </Target>

</Project>

Megjegyzés:

Az <NoWarn>NU5100</NoWarn> előző példában szereplő tulajdonság letiltja a tasks mappában elhelyezett szerelvényekre vonatkozó figyelmeztetést. További információ: NuGet figyelmeztetés NU5100.

Adjon hozzá egy .targets fájlt az MSBuild-feladat buildelési folyamathoz való csatlakoztatásához. Ebben a fájlban a következő célok teljesülnek:

• Importálja a feladatot a buildelési folyamatba. Vegye figyelembe, hogy a DLL elérési útja a fájl végső helyéhez viszonyítva van a csomagban.
• A ComputeBlazorExtensionsDependsOn tulajdonság csatolja az egyéni célt a Blazor WebAssembly folyamathoz.
• Rögzítse a tulajdonságot Extension a feladat kimenetén, és adja hozzá BlazorPublishExtension a bővítmény megismeréséhez Blazor . A feladat meghívása a célban létrehozza a csomagot. A közzétett fájlok listáját az elemcsoportban található Blazor WebAssembly folyamat PublishBlazorBootStaticWebAsset biztosítja. A csomag elérési útja a ( IntermediateOutputPath általában a mappán obj belül) használatával van meghatározva. Végül a csomag automatikusan a közzététel kimeneti mappájának megfelelő helyére másolódik (például bin\Release\net6.0\publish).

A csomagra való hivatkozáskor a közzététel során létrehoz egy csomagot a fájlokból Blazor .

Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle/build/net6.0/Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.targets:

<Project>
  <UsingTask 
    TaskName="Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.Tasks.BundleBlazorAssets" 
    AssemblyFile="$(MSBuildThisProjectFileDirectory)..\..\tasks\Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.Tasks.dll" />

  <PropertyGroup>
    <ComputeBlazorExtensionsDependsOn>
      $(ComputeBlazorExtensionsDependsOn);_BundleBlazorDlls
    </ComputeBlazorExtensionsDependsOn>
  </PropertyGroup>

  <Target Name="_BundleBlazorDlls">
    <BundleBlazorAssets
      PublishBlazorBootStaticWebAsset="@(PublishBlazorBootStaticWebAsset)"
      BundlePath="$(IntermediateOutputPath)bundle.multipart">
      <Output TaskParameter="Extension" 
              ItemName="BlazorPublishExtension"/>
    </BundleBlazorAssets>
  </Target>

</Project>

Automatikus rendszerindítás Blazor a csomagból

A NuGet-csomag JavaScript (JS) inicializálókat használ, hogy az egyes DLL-fájlok használata helyett automatikusan elindítsa az Blazor WebAssembly alkalmazást a csomagból. JSAz inicializálók a Blazor módosítására és a csomag használatára szolgálnak.

Inicializáló létrehozásához JS adjon hozzá egy JS fájlt a névvel {NAME}.lib.module.js a wwwroot csomagprojekt mappájához, ahol a {NAME} helyőrző a csomagazonosító. A Microsoft-csomag fájljának neve Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.lib.module.jspéldául . Az exportált függvények beforeWebAssemblyStart és afterWebAssemblyStarted a betöltés kezelése.

Az JS inicializálók:

• Állapítsa meg, hogy a közzétételi bővítmény elérhető-e, ha ellenőrzi extensions.multiparta kiterjesztés nevét (ExtensionName), amely az MSBuild létrehozása feladat a közzétett fájlok listájának testreszabásához és új kiterjesztések meghatározásához szakaszban megadott kiterjesztés neve.
• Töltse le a csomagot, és elemezze a tartalmat egy erőforrástérképre a létrehozott objektum URL-címek használatával.
• Frissítse a rendszerindító erőforrás-betöltőt (options.loadBootResource) egy egyéni függvénnyel, amely az objektumok URL-címeivel oldja fel az erőforrásokat.
• Az alkalmazás elindítása után vonja vissza az objektum URL-címeit a függvény memóriájának afterWebAssemblyStarted felszabadításához.

Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle/wwwroot/Microsoft.AspNetCore.Components.WebAssembly.MultipartBundle.lib.module.js:

const resources = new Map();

export async function beforeWebAssemblyStart(options, extensions) {
  if (!extensions || !extensions.multipart) {
    return;
  }

  try {
    const integrity = extensions.multipart['app.bundle'];
    const bundleResponse = 
      await fetch('app.bundle', { integrity: integrity, cache: 'no-cache' });
    const bundleFromData = await bundleResponse.formData();
    for (let value of bundleFromData.values()) {
      resources.set(value, URL.createObjectURL(value));
    }
    options.loadBootResource = function (type, name, defaultUri, integrity) {
      return resources.get(name) ?? null;
    }
  } catch (error) {
    console.log(error);
  }
}

export async function afterWebAssemblyStarted(blazor) {
  for (const [_, url] of resources) {
    URL.revokeObjectURL(url);
  }
}

A csomag kiszolgálása a gazdakiszolgálói alkalmazásból

Biztonsági korlátozások miatt a ASP.NET Core nem szolgálja ki a fájlt app.bundle . A kérelemfeldolgozási segítőnek ki kell szolgálnia a fájlt, amikor az ügyfelek kérik.

Megjegyzés:

Mivel a rendszer átláthatóan alkalmazza a közzétételi bővítményeket, mint az alkalmazás fájljaira, a app.bundle.gzapp.bundle.br tömörített és tömörített eszközfájlok közzétételkor automatikusan létrejönnek.

Helyezze a C#-kódot Program.cs a Server projektbe közvetlenül a tartalékfájlt (index.html) értékre app.MapFallbackToFile("index.html"); állító sor elé, hogy válaszoljon a csomagfájlra vonatkozó kérésre (például: app.bundle

app.MapGet("app.bundle", (HttpContext context) =>
{
    string? contentEncoding = null;
    var contentType = 
        "multipart/form-data; boundary=\"--0a7e8441d64b4bf89086b85e59523b7d\"";
    var fileName = "app.bundle";

    var acceptEncodings = context.Request.Headers.AcceptEncoding;

    if (Microsoft.Net.Http.Headers.StringWithQualityHeaderValue
        .StringWithQualityHeaderValue
        .TryParseList(acceptEncodings, out var encodings))
    {
        if (encodings.Any(e => e.Value == "br"))
        {
            contentEncoding = "br";
            fileName += ".br";
        }
        else if (encodings.Any(e => e.Value == "gzip"))
        {
            contentEncoding = "gzip";
            fileName += ".gz";
        }
    }

    if (contentEncoding != null)
    {
        context.Response.Headers.ContentEncoding = contentEncoding;
    }

    return Results.File(
        app.Environment.WebRootFileProvider.GetFileInfo(fileName)
            .CreateReadStream(), contentType);
});

A tartalomtípus megegyezik a buildelési feladatban korábban meghatározott típussal. A végpont ellenőrzi a böngésző által elfogadott tartalomkódolásokat, és az optimális fájlt, a Brotli (.br) vagy a Gzip (.gz) fájlt szolgálja ki.