Host and deploy ASP.NET Core Blazor
Note
This isn't the latest version of this article. For the current release, see the .NET 8 version of this article.
Warning
This version of ASP.NET Core is no longer supported. For more information, see .NET and .NET Core Support Policy. For the current release, see the .NET 8 version of this article.
Important
This information relates to a pre-release product that may be substantially modified before it's commercially released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
For the current release, see the .NET 8 version of this article.
This article explains how to host and deploy Blazor apps.
Publish the app
Apps are published for deployment in Release configuration.
Note
Publish a hosted Blazor WebAssembly solution from the Server project.
- Select the Publish {APPLICATION} command from the Build menu, where the
{APPLICATION}
placeholder the app's name. - Select the publish target. To publish locally, select Folder.
- Accept the default location in the Choose a folder field or specify a different location. Select the
Publish
button.
Publishing the app triggers a restore of the project's dependencies and builds the project before creating the assets for deployment. As part of the build process, unused methods and assemblies are removed to reduce app download size and load times.
Publish locations:
- Blazor Web App: By default, the app is published into the
/bin/Release/{TARGET FRAMEWORK}/publish
folder. Deploy the contents of thepublish
folder to the host. - Blazor WebAssembly: By default, the app is published into the
bin\Release\net8.0\browser-wasm\publish\
folder. To deploy the app as a static site, copy the contents of thewwwroot
folder to the static site host.
- Blazor Server: By default, the app is published into the
/bin/Release/{TARGET FRAMEWORK}/publish
folder. Deploy the contents of thepublish
folder to the host. - Blazor WebAssembly
- Standalone: By default, the app is published into the
/bin/Release/{TARGET FRAMEWORK}/publish/wwwroot
orbin\Release\{TARGET FRAMEWORK}\browser-wasm\publish
folder, depending on the version of the SDK used to publish the app. To deploy the app as a static site, copy the contents of thewwwroot
folder to the static site host. - Hosted: The client Blazor WebAssembly app is published into the
/bin/Release/{TARGET FRAMEWORK}/publish/wwwroot
folder of the server app, along with any other static web assets of the client app. Deploy the contents of thepublish
folder to the host.
- Standalone: By default, the app is published into the
The {TARGET FRAMEWORK}
in the preceding paths is the target framework (for example, net8.0
).
IIS
To host a Blazor app in IIS, see the following resources:
- IIS hosting
- Host and deploy ASP.NET Core server-side Blazor apps: Server apps running on IIS, including IIS with Azure Virtual Machines (VMs) running Windows OS and Azure App Service.
- Host and deploy ASP.NET Core Blazor WebAssembly: Includes additional guidance for Blazor WebAssembly apps hosted on IIS, including static site hosting, custom
web.config
files, URL rewriting, sub-apps, compression, and Azure Storage static file hosting. - IIS sub-application hosting
- Follow the guidance in the App base path section for the Blazor app prior to publishing the app. The examples use an app base path of
/CoolApp
and show how to obtain the base path from app settings or other configuration providers. - Follow the sub-application configuration guidance in Advanced configuration. The sub-app's folder path under the root site becomes the virtual path of the sub-app. For an app base path of
/CoolApp
, the Blazor app is placed in a folder namedCoolApp
under the root site and the sub-app takes on a virtual path of/CoolApp
.
- Follow the guidance in the App base path section for the Blazor app prior to publishing the app. The examples use an app base path of
Sharing an app pool among ASP.NET Core apps isn't supported, including for Blazor apps. Use one app pool per app when hosting with IIS, and avoid the use of IIS's virtual directories for hosting multiple apps.
One or more Blazor WebAssembly apps hosted by an ASP.NET Core app, known as a hosted Blazor WebAssembly solution, are supported for one app pool. However, we don't recommend or support assigning a single app pool to multiple hosted Blazor WebAssembly solutions or in sub-app hosting scenarios.
For more information on solutions, see Tooling for ASP.NET Core Blazor.
App base path
The app base path is the app's root URL path. Successful routing in Blazor apps requires framework configuration for any root URL path that isn't at the default app base path /
.
Consider the following ASP.NET Core app and Blazor sub-app:
- The ASP.NET Core app is named
MyApp
:- The app physically resides at
d:/MyApp
. - Requests are received at
https://www.contoso.com/{MYAPP RESOURCE}
.
- The app physically resides at
- A Blazor app named
CoolApp
is a sub-app ofMyApp
:- The sub-app physically resides at
d:/MyApp/CoolApp
. - Requests are received at
https://www.contoso.com/CoolApp/{COOLAPP RESOURCE}
.
- The sub-app physically resides at
Without specifying additional configuration for CoolApp
, the sub-app in this scenario has no knowledge of where it resides on the server. For example, the app can't construct correct relative URLs to its resources without knowing that it resides at the relative URL path /CoolApp/
. This scenario also applies in various hosting and reverse proxy scenarios when an app isn't hosted at a root URL path.
Background
An anchor tag's destination (href
) can be composed with either of two endpoints:
Absolute locations that include a scheme (defaults to the page's scheme if omitted), host, port, and path or just a forward slash (
/
) followed by the path.Examples:
https://example.com/a/b/c
or/a/b/c
Relative locations that contain just a path and do not start with a forward slash (
/
). These are resolved relative to the current document URL or the<base>
tag's value, if specified.Example:
a/b/c
The presence of a trailing slash (/
) in a configured app base path is significant to compute the base path for URLs of the app. For example, https://example.com/a
has a base path of https://example.com/
, while https://example.com/a/
with a trailing slash has a base path of https://example.com/a
.
There are three sources of links that pertain to Blazor in ASP.NET Core apps:
- URLs in Razor components (
.razor
) are typically relative. - URLs in scripts, such as the Blazor scripts (
blazor.*.js
), are relative to the document.
- URLs manually written in the
_Host.cshtml
file (Blazor Server), which if you are rendering inside different documents should always be absolute. - URLs in Razor components (
.razor
) are typically relative. - URLs in scripts, such as the Blazor scripts (
blazor.*.js
), are relative to the document.
If you're rendering a Blazor app from different documents (for example, /Admin/B/C/
and /Admin/D/E/
), you must take the app base path into account, or the base path is different when the app renders in each document and the resources are fetched from the wrong URLs.
There are two approaches to deal with the challenge of resolving relative links correctly:
- Map the resources dynamically using the document they were rendered on as the root.
- Set a consistent base path for the document and map the resources under that base path.
The first option is more complicated and isn't the most typical approach, as it makes navigation different for each document. Consider the following example for rendering a page /Something/Else
:
- Rendered under
/Admin/B/C/
, the page is rendered with a path of/Admin/B/C/Something/Else
. - Rendered under
/Admin/D/E/
, the page is rendered at the same path of/Admin/B/C/Something/Else
.
Under the first approach, routing offers IDynamicEndpointMetadata and MatcherPolicy, which in combination can be the basis for implementing a completely dynamic solution that determines at runtime about how requests are routed.
For the second option, which is the usual approach taken, the app sets the base path in the document and maps the server endpoints to paths under the base. The following guidance adopts this approach.
Server-side Blazor
Map the SignalR hub of a server-side Blazor app by passing the path to MapBlazorHub in the Program
file:
app.MapBlazorHub("base/path");
The benefit of using MapBlazorHub is that you can map patterns, such as "{tenant}"
and not just concrete paths.
You can also map the SignalR hub when the app is in a virtual folder with a branched middleware pipeline. In the following example, requests to /base/path/
are handled by Blazor's SignalR hub:
app.Map("/base/path/", subapp => {
subapp.UsePathBase("/base/path/");
subapp.UseRouting();
subapp.UseEndpoints(endpoints => endpoints.MapBlazorHub());
});
Configure the <base>
tag, per the guidance in the Configure the app base path section.
Hosted Blazor WebAssembly
If the app is a hosted Blazor WebAssembly app:
- In the in the Server project (
Program.cs
):- Adjust the path of UseBlazorFrameworkFiles (for example,
app.UseBlazorFrameworkFiles("/base/path");
). - Configure calls to UseStaticFiles (for example,
app.UseStaticFiles("/base/path");
).
- Adjust the path of UseBlazorFrameworkFiles (for example,
- In the Client project:
- Configure
<StaticWebAssetBasePath>
in the project file to match the path for serving static web assets (for example,<StaticWebAssetBasePath>base/path</StaticWebAssetBasePath>
). - Configure the
<base>
tag, per the guidance in the Configure the app base path section.
- Configure
For an example of hosting multiple Blazor WebAssembly apps in a hosted Blazor WebAssembly solution, see Multiple hosted ASP.NET Core Blazor WebAssembly apps, where approaches are explained for domain/port hosting and subpath hosting of multiple Blazor WebAssembly client apps.
Standalone Blazor WebAssembly
In a standalone Blazor WebAssembly app, only the <base>
tag is configured, per the guidance in the Configure the app base path section.
Configure the app base path
To provide configuration for the Blazor app's base path of https://www.contoso.com/CoolApp/
, set the app base path, which is also called the relative root path.
By configuring the app base path, a component that isn't in the root directory can construct URLs relative to the app's root path. Components at different levels of the directory structure can build links to other resources at locations throughout the app. The app base path is also used to intercept selected hyperlinks where the href
target of the link is within the app base path URI space. The Router component handles the internal navigation.
In many hosting scenarios, the relative URL path to the app is the root of the app. In these default cases, the app's relative URL base path is /
configured as <base href="/" />
in <head>
content.
In many hosting scenarios, the relative URL path to the app is the root of the app. In these default cases, the app's relative URL base path is the following in <head>
content:
- Blazor Server:
~/
configured as<base href="~/" />
. - Blazor WebAssembly:
/
configured as<base href="/" />
.
Note
In some hosting scenarios, such as GitHub Pages and IIS sub-apps, the app base path must be set to the server's relative URL path of the app.
In a server-side Blazor app, use either of the following approaches:
Option 1: Use the
<base>
tag to set the app's base path (location of<head>
content):<base href="/CoolApp/">
The trailing slash is required.
Option 2: Call UsePathBase first in the app's request processing pipeline (
Program.cs
) immediately after the WebApplicationBuilder is built (builder.Build()
) to configure the base path for any following middleware that interacts with the request path:app.UsePathBase("/CoolApp");
Calling UsePathBase is recommended when you also wish to run the Blazor Server app locally. For example, supply the launch URL in
Properties/launchSettings.json
:"launchUrl": "https://localhost:{PORT}/CoolApp",
The
{PORT}
placeholder in the preceding example is the port that matches the secure port in theapplicationUrl
configuration path. The following example shows the full launch profile for an app at port 7279:"BlazorSample": { "commandName": "Project", "dotnetRunMessages": true, "launchBrowser": true, "applicationUrl": "https://localhost:7279;http://localhost:5279", "launchUrl": "https://localhost:7279/CoolApp", "environmentVariables": { "ASPNETCORE_ENVIRONMENT": "Development" }
For more information on the
launchSettings.json
file, see Use multiple environments in ASP.NET Core. For additional information on Blazor app base paths and hosting, see<base href="/" />
or base-tag alternative for Blazor MVC integration (dotnet/aspnetcore #43191).
Standalone Blazor WebAssembly (
wwwroot/index.html
):<base href="/CoolApp/">
The trailing slash is required.
Hosted Blazor WebAssembly (Client project,
wwwroot/index.html
):<base href="/CoolApp/">
The trailing slash is required.
In the Server project, call UsePathBase first in the app's request processing pipeline (
Program.cs
) immediately after the WebApplicationBuilder is built (builder.Build()
) to configure the base path for any following middleware that interacts with the request path:app.UsePathBase("/CoolApp");
Note
When using WebApplication (see Migrate from ASP.NET Core 5.0 to 6.0), app.UseRouting
must be called after UsePathBase so that the Routing Middleware can observe the modified path before matching routes. Otherwise, routes are matched before the path is rewritten by UsePathBase as described in the Middleware Ordering and Routing articles.
Do not prefix links throughout the app with a forward slash. Either avoid the use of a path segment separator or use dot-slash (./
) relative path notation:
<a href="/account">
Incorrect: <a href="account">
Correct: <a href="./account">
Correct:
In Blazor WebAssembly web API requests with the HttpClient
service, confirm that JSON helpers (HttpClientJsonExtensions) do not prefix URLs with a forward slash (/
):
var rsp = await client.GetFromJsonAsync("/api/Account");
Incorrect: var rsp = await client.GetFromJsonAsync("api/Account");
Correct:
Do not prefix Navigation Manager relative links with a forward slash. Either avoid the use of a path segment separator or use dot-slash (./
) relative path notation (Navigation
is an injected NavigationManager):
Navigation.NavigateTo("/other");
Incorrect: Navigation.NavigateTo("other");
Correct: Navigation.NavigateTo("./other");
Correct:
In typical configurations for Azure/IIS hosting, additional configuration usually isn't required. In some non-IIS hosting and reverse proxy hosting scenarios, additional Static File Middleware configuration might be required:
- To serve static files correctly (for example,
app.UseStaticFiles("/CoolApp");
). - To serve the Blazor script (
_framework/blazor.*.js
). For more information, see ASP.NET Core Blazor static files.
For a Blazor WebAssembly app with a non-root relative URL path (for example, <base href="/CoolApp/">
), the app fails to find its resources when run locally. To overcome this problem during local development and testing, you can supply a path base argument that matches the href
value of the <base>
tag at runtime. Don't include a trailing slash. To pass the path base argument when running the app locally, execute the dotnet watch
(or dotnet run
) command from the app's directory with the --pathbase
option:
dotnet watch --pathbase=/{RELATIVE URL PATH (no trailing slash)}
For a Blazor WebAssembly app with a relative URL path of /CoolApp/
(<base href="/CoolApp/">
), the command is:
dotnet watch --pathbase=/CoolApp
If you prefer to configure the app's launch profile to specify the pathbase
automatically instead of manually with dotnet watch
(or dotnet run
), set the commandLineArgs
property in Properties/launchSettings.json
. The following also configures the launch URL (launchUrl
):
"commandLineArgs": "--pathbase=/{RELATIVE URL PATH (no trailing slash)}",
"launchUrl": "{RELATIVE URL PATH (no trailing slash)}",
Using CoolApp
as the example:
"commandLineArgs": "--pathbase=/CoolApp",
"launchUrl": "CoolApp",
Using either dotnet watch
(or dotnet run
) with the --pathbase
option or a launch profile configuration that sets the base path, the Blazor WebAssembly app responds locally at http://localhost:port/CoolApp
.
For more information on the launchSettings.json
file, see Use multiple environments in ASP.NET Core. For additional information on Blazor app base paths and hosting, see <base href="/" />
or base-tag alternative for Blazor MVC integration (dotnet/aspnetcore #43191).
Obtain the app base path from configuration
The following guidance explains how to obtain the path for the <base>
tag from an app settings file for different environments.
Add the app settings file to the app. The following example is for the Staging
environment (appsettings.Staging.json
):
{
"AppBasePath": "staging/"
}
In a server-side Blazor app, load the base path from configuration in <head>
content:
@inject IConfiguration Config
...
<head>
...
<base href="/@(Config.GetValue<string>("AppBasePath"))" />
...
</head>
Alternatively, a server-side app can obtain the value from configuration for UsePathBase. Place the following code first in the app's request processing pipeline (Program.cs
) immediately after the WebApplicationBuilder is built (builder.Build()
). The following example uses the configuration key AppBasePath
:
app.UsePathBase($"/{app.Configuration.GetValue<string>("AppBasePath")}");
In a client-side Blazor WebAssembly app:
Remove the
<base>
tag fromwwwroot/index.html
:- <base href="..." />
Supply the app base path via a
HeadContent
component in theApp
component (App.razor
):@inject IConfiguration Config ... <HeadContent> <base href="/@(Config.GetValue<string>("AppBasePath"))" /> </HeadContent>
If there's no configuration value to load, for example in non-staging environments, the preceding href
resolves to the root path /
.
The examples in this section focus on supplying the app base path from app settings, but the approach of reading the path from IConfiguration is valid for any configuration provider. For more information, see the following resources:
Blazor Server MapFallbackToPage
configuration
This section only applies to Blazor Server apps. MapFallbackToPage isn't supported in Blazor Web Apps and Blazor WebAssembly apps.
In scenarios where an app requires a separate area with custom resources and Razor components:
Create a folder within the app's
Pages
folder to hold the resources. For example, an administrator section of an app is created in a new folder namedAdmin
(Pages/Admin
).Create a root page (
_Host.cshtml
) for the area. For example, create aPages/Admin/_Host.cshtml
file from the app's main root page (Pages/_Host.cshtml
). Don't provide an@page
directive in the Admin_Host
page.Add a layout to the area's folder (for example,
Pages/Admin/_Layout.razor
). In the layout for the separate area, set the<base>
taghref
to match the area's folder (for example,<base href="/Admin/" />
). For demonstration purposes, add~/
to the static resources in the page. For example:~/css/bootstrap/bootstrap.min.css
~/css/site.css
~/BlazorSample.styles.css
(the example app's namespace isBlazorSample
)~/_framework/blazor.server.js
(Blazor script)
If the area should have its own static asset folder, add the folder and specify its location to Static File Middleware in
Program.cs
(for example,app.UseStaticFiles("/Admin/wwwroot")
).Razor components are added to the area's folder. At a minimum, add an
Index
component to the area folder with the correct@page
directive for the area. For example, add aPages/Admin/Index.razor
file based on the app's defaultPages/Index.razor
file. Indicate the Admin area as the route template at the top of the file (@page "/admin"
). Add additional components as needed. For example,Pages/Admin/Component1.razor
with an@page
directive and route template of@page "/admin/component1
.In
Program.cs
, call MapFallbackToPage for the area's request path immediately before the fallback root page path to the_Host
page:... app.UseRouting(); app.MapBlazorHub(); app.MapFallbackToPage("~/Admin/{*clientroutes:nonfile}", "/Admin/_Host"); app.MapFallbackToPage("/_Host"); app.Run();
Host multiple Blazor WebAssembly apps
For more information on hosting multiple Blazor WebAssembly apps in a hosted Blazor solution, see Multiple hosted ASP.NET Core Blazor WebAssembly apps.
Deployment
For deployment guidance, see the following topics: