ASP.NET Core Blazor gazdagépe és üzembe helyezése

Ez a cikk bemutatja, hogyan üzemeltethet és helyezhet üzembe Blazor alkalmazásokat.

Az alkalmazás közzététele

Az alkalmazásokat kiadási konfigurációban publikálják az üzembe helyezésre.

dotnet publish -c Release

Az alkalmazás közzététele aktiválja a projekt függőségeinek visszaállítását, és létrehozza a projekt az üzembe helyezéshez szükséges eszközök létrehozása előtt. A buildelési folyamat részeként a nem használt metódusok és szerelvények el lesznek távolítva az alkalmazás letöltési méretének és betöltési idejének csökkentése érdekében.

Közzétételi helyek:

IIS

Ha egy Blazor-alkalmazást szeretne üzemeltetni az IIS-ben, tekintse meg a következő erőforrásokat:

• IIS-üzemeltetés
  • Az ASP.NET Core-alkalmazás közzététele az IIS-hez
  • ASP.NET Core üzemeltetése Windows-on IIS-sel
• ASP.NET Core kiszolgálóoldali Blazor-alkalmazások: IIS-en futó kiszolgálóalkalmazások, beleértve a Windows operációs rendszert és az Azure App Service-t futtató Azure-beli virtuális gépekkel rendelkező IIS-t is.
• Tárhely és üzembe helyezés ASP.NET Core Blazor WebAssembly: További útmutatást tartalmaz az IIS-en üzemeltetett Blazor WebAssembly alkalmazások esetében, beleértve a statikus webhely-üzemeltetést, az egyéni web.config fájlokat, az URL-újraírást, az alalkalmazásokat, a tömörítést és az Azure Storage statikus fájltárolását.
• IIS-alalkalmazás üzemeltetése
  • Az alkalmazás közzététele előtt kövesse az alkalmazás alapelérési szakaszában található útmutatást a Blazor alkalmazáshoz. A példák egy /CoolApp alkalmazásbázis-elérési útját használják, és bemutatják, hogyan beszerezni az alap elérési utat az alkalmazásbeállításokból vagy más konfigurációszolgáltatóktól.
  • Kövesse az alalkalmazás konfigurációs útmutatóját Speciális konfiguráció. Az alalkalmazás gyökérwebhely alatti mappa elérési útja lesz az alalkalmazás virtuális elérési útja. A /CoolAppalkalmazásbázis-elérési útja esetén a Blazor alkalmazás egy CoolApp nevű mappába kerül a gyökérwebhely alatt, és az alalkalmazás egy virtuális /CoolAppelérési utat vesz fel.

Az alkalmazáskészlet megosztása ASP.NET Core-alkalmazások között nem támogatott, beleértve Blazor alkalmazásokat is. Alkalmazásonként egy alkalmazáskészletet használjon az IIS-vel való üzemeltetéskor, és kerülje az IIS virtuális könyvtárainak használatát több alkalmazás üzemeltetéséhez.

Alkalmazás alap elérési útja

Az alkalmazás alap elérési útja az alkalmazás gyökér URL-címe. Az Blazor alkalmazások sikeres útválasztásához keretrendszerkonfigurációra van szükség minden olyan gyökér URL-útvonalhoz, amely nem az alapértelmezett alkalmazás alapelérési útján van /.

Fontolja meg a következő ASP.NET Core-alkalmazást és Blazor alalkalmazást:

• A ASP.NET Core-alkalmazás neve MyApp:
  • Az alkalmazás fizikailag a d:/MyAppcímen található.
  • A kérelmek a https://www.contoso.com/{MYAPP RESOURCE}számú helyen érkeznek.
• A Blazor nevű CoolApp-alkalmazás a MyAppalalkalmazása:
  • Az alalkalmazás fizikailag a d:/MyApp/CoolApptalálható.
  • A kérelmek a https://www.contoso.com/CoolApp/{COOLAPP RESOURCE}számú helyen érkeznek.

A CoolApptovábbi konfigurációjának megadása nélkül az ebben a forgatókönyvben szereplő alalkalmazás nem ismeri a kiszolgálón található helyeket. Az alkalmazás például nem tud helyes relatív URL-eket létrehozni az erőforrásaihoz anélkül, hogy ismerné, hogy az a relatív URL-útvonal /CoolApp/-n található. Ez a forgatókönyv különböző üzemeltetési és fordított proxyforgatókönyvekre is vonatkozik, ha egy alkalmazás nem gyökér URL-elérési úton van üzemeltetve.

Háttér

A horgonycímkék célhelye (href) két végpontból állhat:

• Abszolút helyek, amelyek sémát tartalmaznak (kihagyás esetén alapértelmezés szerint az oldal sémája), gazdagép, port és elérési út, vagy csak egy perjel (/), amelyet az elérési út követ.

  Példák: https://example.com/a/b/c vagy /a/b/c

• Relatív helyek, amelyek csak egy elérési utat tartalmaznak, és nem perjellel kezdődnek (/). Ezek feloldása az aktuális dokumentum URL-címéhez vagy a <base> címke értékéhez képest történik, ha meg van adva.

  Példa: a/b/c

A záró perjel (/) jelenléte egy konfigurált alkalmazás alapútvonalán jelentős az alkalmazás URL-címeinek alapútvonalának kiszámításához. A https://example.com/a például https://example.com/alapútvonalával rendelkezik, a záró perjellel rendelkező https://example.com/a/ pedig https://example.com/aalapútvonallal rendelkezik.

Az ASP.NET Core-alkalmazásokban Blazor kapcsolódó hivatkozások forrásai:

Ha Blazor alkalmazást jelenít meg különböző dokumentumokból (például /Admin/B/C/ és /Admin/D/E/), figyelembe kell vennie az alkalmazás alapelérési útvonalát, vagy az alap elérési út eltérő, ha az alkalmazás minden dokumentumban renderel, és az erőforrásokat nem a megfelelő URL-címekről kéri le.

A relatív kapcsolatok helyes megoldásának két megközelítése van:

• Az erőforrások dinamikus leképezése a gyökérként megjelenített dokumentum használatával.
• Állítson be egy konzisztens alapelérési útvonalat a dokumentumhoz, és képezje le az erőforrásokat az alapútvonal alatt.

Az első lehetőség bonyolultabb, és nem a legjellemzőbb megközelítés, mivel az egyes dokumentumokhoz eltérővé teszi a navigációt. Tekintse meg az alábbi példát egy lap /Something/Elsemegjelenítéséhez:

• A /Admin/B/C/alatt megjelenített oldal a /Admin/B/C/Something/Elseelérési úttal jelenik meg.
• A alatt renderelt lap az azonos elérési útján jelenik meg .

Az első megközelítésben az útválasztás IDynamicEndpointMetadata és MatcherPolicykínál, ami együttesen alapul szolgálhat egy teljesen dinamikus megoldás megvalósításához, amely futásidőben meghatározza, hogyan történik a kérések átirányítása.

A második lehetőségnél, amely a szokásos módszer, az alkalmazás beállítja a dokumentum alap elérési útját, és leképezi a kiszolgálóvégpontokat az alap alatti útvonalakra. Az alábbi útmutató ezt a megközelítést alkalmazza.

Kiszolgáló-oldali Blazor

Leképezze a kiszolgálóoldali SignalR alkalmazás Blazor csomópontját a MapBlazorHub fájlban lévő Program elérési út megadásával:

app.MapBlazorHub("base/path");

A MapBlazorHub használatának az az előnye, hogy mintázatokat képezhet le, például "{tenant}" és nem csak konkrét útvonalakat.

Akkor is megfeleltetheti a SignalR központot, ha az alkalmazás egy elágaztatott köztes szoftverfolyamatvirtuális mappában található. Az alábbi példában a /base/path/ kéréseit BlazorSignalR központ kezeli:

app.Map("/base/path/", subapp => {
    subapp.UsePathBase("/base/path/");
    subapp.UseRouting();
    subapp.UseEndpoints(endpoints => endpoints.MapBlazorHub());
});

Konfigurálja a <base> címkét az Az alkalmazás alapelérési útvonalának konfigurálása szakaszban található útmutató szerint.

Önálló Blazor WebAssembly

Önálló Blazor WebAssembly-alkalmazásokban csak a <base> címke van konfigurálva, az Az alkalmazás alapelérési útvonalának konfigurálása szakaszban található útmutató szerint.

Az alkalmazás alapútvonalának konfigurálása

A Blazor alkalmazás alapútvonalának https://www.contoso.com/CoolApp/konfigurálásához állítsa be az alkalmazás alapelérési útvonalát (<base>), amelyet relatív gyökérútvonalnak is nevezünk.

Az alkalmazás alap elérési útjának konfigurálásával a gyökérkönyvtárban nem szereplő összetevők az alkalmazás gyökérútvonalához képest hozhatnak létre URL-címeket. A címtárstruktúra különböző szintjein lévő összetevők hivatkozásokat hozhatnak létre más erőforrásokhoz az alkalmazás különböző pontjain. Az alkalmazás alap elérési útja olyan kijelölt hivatkozások elfogására is használható, ahol a hivatkozás href célhelye az alkalmazás alap elérési útjának URI-területén belül van. A Router összetevő kezeli a belső navigációt.

Helyezze a <base> címkét <head> jelölésbe (<head> tartalom helye) az olyan attribútumértékekkel rendelkező elemek elé, amelyek URL-ek, például az <link> elemek href attribútumai.

• Kiszolgálóoldali Blazor alkalmazásokban használja az alábbi módszerek:

  • 1. lehetőség: Az <base> címkével állítsa be az alkalmazás alap elérési útját (<head> tartalom helyét):

    <base href="/CoolApp/">
    

    A záró perjel megadása kötelező.

  • 2. lehetőség: Hívja meg először a UsePathBase elemeket közvetlenül a Program.cs létrehozása (WebApplicationBuilder) után az alkalmazás kérésfeldolgozási folyamatában (builder.Build()), hogy konfigurálja az alapelérési útvonalat minden következő köztes szoftver számára, amely a kérésútvonallal lép interakcióba.

    app.UsePathBase("/CoolApp");
    

    A UsePathBase hívása akkor ajánlott, ha a Blazor Server alkalmazást helyileg is futtatni szeretné. Adja meg például az indítási URL-címet a Properties/launchSettings.json:

    "launchUrl": "https://localhost:{PORT}/CoolApp",
    

    Az előző példában szereplő {PORT} helyőrző az a port, amely megfelel a applicationUrl konfigurációs útvonal biztonságos portjának. Az alábbi példa egy alkalmazás teljes indítási profilját mutatja be a 7279-ös porton:

    "BlazorSample": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "https://localhost:7279;http://localhost:5279",
      "launchUrl": "https://localhost:7279/CoolApp",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
    }
    

    A(z) launchSettings.json fájlról további információkért lásd: Több környezet használata az ASP.NET Core-ban. További információért az Blazor alkalmazás alapelérési útvonalairól és üzemeltetéséről lásd: ,<base href="/" /> vagy az alapcímke alternatíváját a Blazor MVC-integrációhoz (dotnet/aspnetcore #43191).

• Önálló Blazor WebAssembly (wwwroot/index.html):

  <base href="/CoolApp/">
  

  A záró perjel megadása kötelező.

Ne adj előre perjelet a hivatkozások elé az alkalmazásban. Kerülje az elérési útszegmens-elválasztó használatát, vagy használjon pont perjelet (./) relatív elérési út jelölését:

• ❌ helytelen: <a href="/account">
• ✔️ Helyes: <a href="account">
• ✔️ Helyes: <a href="./account">

A Blazor WebAssembly webes API-kéréseiben a HttpClient szolgáltatásesetében győződjön meg arról, hogy a JSON-segítők (HttpClientJsonExtensions) nem használjanak előtérbe helyezett perjellel (/) ellátott URL-eket.

• ❌ helytelen: var rsp = await client.GetFromJsonAsync("/api/Account");
• ✔️ Helyes: var rsp = await client.GetFromJsonAsync("api/Account");

Ne tegyen perjelet Navigation Manager relatív hivatkozások elé. Kerülje az elérési útszegmens-elválasztó használatát, vagy használjon pont perjelet (./) relatív elérési út jelölését (Navigation injektált NavigationManager):

• ❌ helytelen: Navigation.NavigateTo("/other");
• ✔️ Helyes: Navigation.NavigateTo("other");
• ✔️ Helyes: Navigation.NavigateTo("./other");

Az Azure/IIS-üzemeltetés tipikus konfigurációiban általában nincs szükség további konfigurációra. Egyes nem IIS-alapú üzemeltetési és fordított proxy-üzemeltetési forgatókönyvekben további statikus fájl köztes szoftverkonfigurációra lehet szükség:

• Statikus fájlok megfelelő kiszolgálása (például app.UseStaticFiles("/CoolApp");).
• A Blazor szkript (_framework/blazor.*.js) kiszolgálása. További információkért lásd: ASP.NET Core Blazor statikus fájlok.

Nem gyökérszintű relatív URL-elérési úttal (például Blazor WebAssembly) rendelkező <base href="/CoolApp/">-alkalmazások esetében az alkalmazás nem találja az erőforrásait helyifuttatásakor. A helyi fejlesztés és tesztelés során felmerülő probléma megoldásához megadhat egy elérési út alapja argumentumot, amely megfelel a href címke futásidejű <base> értékének. Ne tartalmazzon záró perjelet. Az útvonal alapargumentumának az alkalmazás helyi futtatásakor való átadásához hajtsa végre az dotnet watch (vagy dotnet run) parancsot az alkalmazás könyvtárából a --pathbase beállítással:

dotnet watch --pathbase=/{RELATIVE URL PATH (no trailing slash)}

A Blazor WebAssembly (/CoolApp/) relatív URL-címével rendelkező <base href="/CoolApp/">-alkalmazások esetében a parancs a következő:

dotnet watch --pathbase=/CoolApp

Ha inkább azt szeretné, hogy az alkalmazás indítási profilja automatikusan határozza meg a pathbase ahelyett, hogy manuálisan a dotnet watch (vagy dotnet run) segítségével tenné, akkor állítsa be a commandLineArgs tulajdonságot a Properties/launchSettings.json-ben. Az alábbiak a indítási URL-címet (launchUrl) is konfigurálják:

"commandLineArgs": "--pathbase=/{RELATIVE URL PATH (no trailing slash)}",
"launchUrl": "{RELATIVE URL PATH (no trailing slash)}",

Példaként használja a CoolApp:

"commandLineArgs": "--pathbase=/CoolApp",
"launchUrl": "CoolApp",

Az dotnet watch (vagy dotnet run), valamint az --pathbase opció használata, vagy az indítási profil konfigurációja, amely az alapelérési útvonalat állítja be, lehetővé teszi, hogy a Blazor WebAssembly alkalmazás helyileg válaszoljon http://localhost:port/CoolApp.

A(z) launchSettings.json fájlról további információkért lásd: Több környezet használata az ASP.NET Core-ban. További információért az Blazor alkalmazás alapelérési útvonalairól és üzemeltetéséről lásd: ,<base href="/" /> vagy az alapcímke alternatíváját a Blazor MVC-integrációhoz (dotnet/aspnetcore #43191).

Az alkalmazás alapútvonalának beszerzése a konfigurációból

Az alábbi útmutató bemutatja, hogyan szerezheti be a <base> címke elérési útját egy alkalmazásbeállítási fájlból különböző környezetekhez.

Adja hozzá az alkalmazásbeállításokat az alkalmazáshoz. Az alábbi példa a Staging környezetre (appsettings.Staging.json):

{
  "AppBasePath": "staging/"
}

Kiszolgálóoldali Blazor alkalmazásban töltse be az alap elérési utat a konfigurációból <head> tartalom:

@inject IConfiguration Config

...

<head>
    ...
    <base href="/@(Config.GetValue<string>("AppBasePath"))" />
    ...
</head>

app.UsePathBase($"/{app.Configuration.GetValue<string>("AppBasePath")}");

Ha nincs betöltendő konfigurációs érték, például a nem átmeneti környezetekben, az előző href a gyökérútvonalra értelmeződik /.

Az ebben a szakaszban szereplő példák az alkalmazás alapútvonalának az alkalmazásbeállításokból való megadására összpontosítanak, de az elérési út IConfiguration olvasásának megközelítése bármely konfigurációszolgáltatóra érvényes. További információ:

• ASP.NET Core Blazor konfiguráció
• Konfiguráció az ASP.NET Core-ban

Blazor Server MapFallbackToPage konfiguráció

Ez a szakasz csak Blazor Server alkalmazásokra vonatkozik. A(z) MapFallbackToPage nem támogatott a Blazor Web Appés Blazor WebAssembly alkalmazásokban.

Olyan helyzetekben, amikor egy alkalmazáshoz külön terület szükséges egyéni erőforrásokkal és Razor összetevőkkel:

• Hozzon létre egy mappát az alkalmazás Pages mappájában az erőforrások tárolásához. Egy alkalmazás rendszergazdai szakasza például egy új, Admin (Pages/Admin) nevű mappában jön létre.

• Hozzon létre egy gyökérlapot (_Host.cshtml) a területhez. Hozzon létre például egy Pages/Admin/_Host.cshtml fájlt az alkalmazás fő gyökéroldaláról (Pages/_Host.cshtml). Ne adjon meg @page irányelvet az adminisztrációs _Host oldalon.

• Adjon hozzá egy elrendezést a terület mappájához (például Pages/Admin/_Layout.razor). A különálló terület elrendezésében állítsa be a <base> címke href értékét a terület mappájával megegyezőre (például <base href="/Admin/" />). Bemutató céljából adja hozzá a ~/-t az oldal statikus erőforrásaihoz. Például:

  • ~/css/bootstrap/bootstrap.min.css
  • ~/css/site.css
  • ~/BlazorSample.styles.css (a példaalkalmazás névtere BlazorSample)
  • ~/_framework/blazor.server.js (Blazor szkript)

• Ha a területnek saját statikus eszközmappával kell rendelkeznie, adja hozzá a mappát, és adja meg a helyét a Static File Middleware-ben Program.cs (például app.UseStaticFiles("/Admin/wwwroot")).

• Razor összetevők a terület mappájába kerülnek. Minimum adjon hozzá egy Index összetevőt a területmappához a terület megfelelő @page irányelvével. Adjon hozzá például egy Pages/Admin/Index.razor fájlt az alkalmazás alapértelmezett Pages/Index.razor fájlja alapján. Jelölje meg a rendszergazdai területet útvonalsablonként a fájl tetején (@page "/admin"). Szükség szerint adjon hozzá további összetevőket. Például Pages/Admin/Component1.razor@page irányelvvel és @page "/admin/component1útvonalsablonjával.

• Program.csesetén a terület kérési útvonalának hívása a MapFallbackToPage használatával történjen, közvetlenül a tartalék gyökér oldal útvonala előtt, a _Host lapra:

  ...
  app.UseRouting();
  
  app.MapBlazorHub();
  app.MapFallbackToPage("~/Admin/{*clientroutes:nonfile}", "/Admin/_Host");
  app.MapFallbackToPage("/_Host");
  
  app.Run();
  

Telepítés

Az üzembe helyezéssel kapcsolatos útmutatásért tekintse meg az alábbi témaköröket:

• Hosztolás és üzembe helyezés ASP.NET Core Blazor WebAssembly
• Gazdagép és üzembe helyezés ASP.NET Core kiszolgálóoldali Blazor-alkalmazások