Merge pull request #307638 from mattchenderson/aspire-ga

Updating Aspire docs for GA

Author: v-shils

articles/azure-functions/TOC.yml

@@ -297,7 +297,7 @@
     - name: Isolated worker model
       displayName: .NET isolated
       href: dotnet-isolated-process-guide.md
-    - name: .NET Aspire integration (Preview)
+    - name: Aspire integration
       href: dotnet-aspire-integration.md
     - name: Legacy models
       items:

articles/azure-functions/dotnet-aspire-integration.md

@@ -3,28 +3,25 @@ title: Guide for Using Azure Functions with Aspire
 description: Learn how to use Azure Functions with Aspire, which simplifies authoring of distributed applications in the cloud.
 ms.service: azure-functions
 ms.topic: conceptual
-ms.date: 04/21/2025
+ms.date: 10/31/2025
 ---
 
-# Azure Functions with Aspire (preview)
+# Azure Functions with Aspire
 
 [Aspire](/dotnet/aspire/get-started/aspire-overview) is an opinionated stack that simplifies development of distributed applications in the cloud. The integration of Aspire with Azure Functions enables you to develop, debug, and orchestrate an Azure Functions .NET project as part of the Aspire app host.
 
-> [!IMPORTANT]
-> The integration of Aspire with Azure Functions is currently in preview and is subject to change.
-
 ## Prerequisites
 
 Set up your development environment for using Azure Functions with Aspire:
 
-- Install the [.NET 9 SDK](https://dotnet.microsoft.com/download/dotnet/9.0) and [Aspire 9.0 or later](/dotnet/aspire/fundamentals/setup-tooling). Although the .NET 9 SDK is required, Aspire 9.0 supports the .NET 8 and .NET 9 frameworks.
-- If you use Visual Studio, update to version 17.12 or later. You must also have the latest version of the Azure Functions tools for Visual Studio. To check for updates:
+- [Install the Aspire Prerequisites](/dotnet/aspire/fundamentals/setup-tooling#install-aspire-prerequisites).
+    - Full support for the Azure Functions integration requires Aspire 13.1 or later. Aspire 13.0 also includes a preview version of `Aspire.Hosting.Azure.Functions` which acts as a release candidate with go-live support.
+- Install the [Azure Functions Core Tools](./functions-run-local.md).
+
+If you use Visual Studio, update to version 17.12 or later. You must also have the latest version of the Azure Functions tools for Visual Studio. To check for updates:
   1. Go to **Tools** > **Options**.
   1. Under **Projects and Solutions**, select **Azure Functions**.
   1. Select **Check for updates** and install updates as prompted.
-  
-> [!NOTE]
-> The Azure Functions integration with Aspire doesn't yet support .NET 10 Preview.
 
 ## Solution structure
 
@@ -176,11 +173,18 @@ For details on the connection formats that each binding supports, and the permis
 
 ## Hosting the application
 
-By default, when you publish an Azure Functions project to Azure, it's deployed to Azure Container Apps.
+Aspire supports two different ways to host your Functions project in Azure:
+
+- [Publish as a container app (default)](#publish-as-a-container-app)
+- [Publish as a function app](#publish-as-a-function-app) using preview App Service integration
 
-During the preview period, the container app resources don't support event-driven scaling. Azure Functions support is not available for apps deployed in this mode. If you need to open a support ticket, select the Azure Container Apps resource type.
+In both cases, your project is deployed as a container. Aspire takes care of building the container image for you and pushing it to Azure Container Registry.
 
-### Access keys
+### Publish as a container app
+
+By default, when you publish an Aspire project to Azure, it's deployed to Azure Container Apps. The system sets up scaling rules for your Functions project using [KEDA](https://keda.sh/). When using Azure Container Apps, additional setup is needed for function keys. See [Access keys on Azure Container Apps](#access-keys-on-azure-container-apps) for more information.
+
+#### Access keys on Azure Container Apps
 
 Several Azure Functions scenarios use access keys to provide a basic mitigation against unwanted access. For example, HTTP trigger functions by default require an access key to be invoked, though this requirement can be disabled using the [`AuthLevel` property](./functions-bindings-http-webhook-trigger.md#attributes). See [Work with access keys in Azure Functions](./function-keys-how-to.md) for scenarios which may require a key.
 
@@ -329,12 +333,60 @@ This example uses a default key vault created by the extension method. It result
 
 To use these keys from clients, you need to retrieve them from the key vault.
 
+### Publish as a function app
+
+> [!NOTE]
+> Publishing as a function app requires the Aspire Azure App Service integration, which is currently in preview.
+
+You can configure Aspire to deploy to a function app using the [Aspire Azure App Service integration](/dotnet/aspire/azure/azure-app-service-integration). Because Aspire publishes the Functions project as a container, the hosting plan for your function app must support deploying containerized applications.
+
+To publish your Aspire Functions project as a function app, follow these steps:
+
+1. Add a reference to the [Aspire.Hosting.Azure.AppService] NuGet package in your app host project.
+1. In the `AppHost.cs` file, call `AddAzureAppServiceEnvironment()` on your `IDistributedApplicationBuilder` instance to create an App Service plan. Note that despite the name, this does not provision an App Service Environment resource. 
+1. On the Functions project resource, call `.WithExternalHttpEndpoints()`. This is required for deploying with the Aspire Azure App Service integration.
+1. On the Functions project resource, call `.PublishAsAzureAppServiceWebsite((infra, app) => app.Kind = "functionapp,linux")` to publish that project to the plan.
+
+> [!IMPORTANT]
+> Make sure that you set the `app.Kind` property to `"functionapp,linux"`. This setting ensures the resource is created as a function app, which affects experiences for working with your application.
+
+The following example shows a minimal `AppHost.cs` file for an app host project that publishes a Functions project as a function app:
+
+```csharp
+var builder = DistributedApplication.CreateBuilder(args);
+builder.AddAzureAppServiceEnvironment("functions-env");
+builder.AddAzureFunctionsProject<Projects.MyFunctionsProject>("MyFunctionsProject")
+    .WithExternalHttpEndpoints()
+    .PublishAsAzureAppServiceWebsite((infra, app) => app.Kind = "functionapp,linux");
+```
+
+By default, this configuration creates a Premium V3 plan. When using a dedicated App Service plan SKU, scaling isn't event-based. Instead, scaling is managed through the App Service plan settings. If you want to change the SKU, you can do so through the `ConfigureInfrastructure` method on the environment resource. The following example shows how you can set up an Elastic Premium plan:
+
+```csharp
+using Azure.Provisioning.AppService;
+
+var builder = DistributedApplication.CreateBuilder(args);
+builder.AddAzureAppServiceEnvironment("functions-env");
+    .ConfigureInfrastructure(infra =>
+    {
+        var plan = infra.GetProvisionableResources().OfType<AppServicePlan>().First();
+        plan.Sku = new AppServiceSkuDescription
+        {
+           Name = "EP1",
+           Tier = "ElasticPremium"
+        };
+    });
+builder.AddAzureFunctionsProject<Projects.MyFunctionsProject>("MyFunctionsProject")
+    .WithExternalHttpEndpoints()
+    .PublishAsAzureAppServiceWebsite((infra, app) => app.Kind = "functionapp,linux");
+```
+
+When you configure the plan to use an Elastic Premium SKU, you can only publish Functions projects to that plan. If your app host project includes other web apps, you should use a dedicated App Service plan SKU.
+
 ## Considerations and best practices
 
 Consider the following points when you're evaluating the integration of Azure Functions with Aspire:
 
-- Support for the integration is currently in preview.
-
 - Trigger and binding configuration through Aspire is currently limited to specific integrations. For details, see [Connection configuration with Aspire](#connection-configuration-with-aspire) in this article.
 
 - Your function project's `Program.cs` file should use the `IHostApplicationBuilder` version of [host instance startup](./dotnet-isolated-process-guide.md#start-up-and-configuration). `IHostApplicationBuilder` allows you to call `builder.AddServiceDefaults()` to add [Aspire service defaults](/dotnet/aspire/fundamentals/service-defaults) to your Functions project.
@@ -354,6 +406,7 @@ Consider the following points when you're evaluating the integration of Azure Fu
 [Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore]: https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore/
 
 [Aspire.Hosting.Azure.Functions]: https://www.nuget.org/packages/Aspire.Hosting.Azure.Functions
+[Aspire.Hosting.Azure.AppService]: https://www.nuget.org/packages/Aspire.Hosting.Azure.AppService
 
 [Storage Account Contributor]: ../role-based-access-control/built-in-roles.md#storage-account-contributor
 [Storage Blob Data Owner]: ../role-based-access-control/built-in-roles.md#storage-blob-data-owner

articles/azure-functions/dotnet-isolated-process-guide.md

@@ -921,11 +921,11 @@ host.Run();
 
 ### Application Insights
 
-You can configure your isolated process application to emit logs directly to [Application Insights](/azure/azure-monitor/app/app-insights-overview?tabs=net). This behavior replaces the default behavior of [relaying logs through the host](./configure-monitoring.md#custom-application-logs). Unless you are using [Aspire](#aspire-preview), configuring direct Application Insights integration is recommended because it gives you control over how those logs are emitted. 
+You can configure your isolated process application to emit logs directly to [Application Insights](/azure/azure-monitor/app/app-insights-overview?tabs=net). This behavior replaces the default behavior of [relaying logs through the host](./configure-monitoring.md#custom-application-logs). Unless you are using [Aspire](#aspire), configuring direct Application Insights integration is recommended because it gives you control over how those logs are emitted. 
 
 Application Insights integration is not enabled by default in all setup experiences. Some templates will create Functions projects with the necessary packages and startup code commented out. If you want to use Application Insights integration, you can uncomment these lines in `Program.cs` and the project's `.csproj` file. The instructions in the rest of this section also describe how to enable the integration.
 
-If your project is part of an [Aspire orchestration](#aspire-preview), it uses OpenTelemetry for monitoring instead. You should not enable direct Application Insights integration within Aspire projects. Instead, configure the Azure Monitor OpenTelemetry exporter as part of the [service defaults project](/dotnet/aspire/fundamentals/service-defaults#opentelemetry-configuration). If your Functions project uses Application Insights integration in an Aspire context, the application will error on startup.
+If your project is part of an [Aspire orchestration](#aspire), it uses OpenTelemetry for monitoring instead. You should not enable direct Application Insights integration within Aspire projects. Instead, configure the Azure Monitor OpenTelemetry exporter as part of the [service defaults project](/dotnet/aspire/fundamentals/service-defaults#opentelemetry-configuration). If your Functions project uses Application Insights integration in an Aspire context, the application will error on startup.
 
 #### Install packages
 
@@ -1218,9 +1218,9 @@ There are a few requirements for running .NET functions in the isolated worker m
 
 When you create your function app in Azure using the methods in the previous section, these required settings are added for you. When you create these resources [by using ARM templates or Bicep files for automation](functions-infrastructure-as-code.md), you must make sure to set them in the template. 
 
-## <a name = "net-aspire-preview"></a>Aspire (Preview)
+## <a name = "net-aspire-preview"></a>Aspire
 
-[Aspire](/dotnet/aspire/get-started/aspire-overview) is an opinionated stack that simplifies development of distributed applications in the cloud. You can enlist .NET 8 and .NET 9 isolated worker model projects in Aspire 9.0 orchestrations using preview support. See [Azure Functions with Aspire (Preview)](./dotnet-aspire-integration.md) for more information.
+[Aspire](/dotnet/aspire/get-started/aspire-overview) is an opinionated stack that simplifies development of distributed applications in the cloud. You can enlist isolated worker model projects in Aspire 13 orchestrations. See [Azure Functions with Aspire](./dotnet-aspire-integration.md) for more information.
 
 ## Debugging
 
@@ -1326,7 +1326,7 @@ Azure Functions currently can be used with the following "Preview" or "Go-live"
 | Windows          | .NET 10 Preview 5<sup>1,2</sup> |
 
 1. Apps targeting .NET 10 must use [version 2.0.5 or later of `Microsoft.Azure.Functions.Worker.Sdk`][Microsoft.Azure.Functions.Worker.Sdk]. You should also update to [version 2.50.0-preview1 or later of `Microsoft.Azure.Functions.Worker`][Microsoft.Azure.Functions.Worker], which updates dependencies to align with .NET 10. When using Visual Studio, you also need to use [Visual Studio 2026 Insiders][vs-insiders] and [update the Functions tools and templates](#considerations-for-using-net-preview-versions) to version 4.114.0 or later.
-2. For the latest information about support for .NET 10 in public Azure, see this [tracking thread on GitHub](https://github.com/Azure/azure-functions-dotnet-worker/issues/3152).
+2. For the latest information about support for .NET 10 in global Azure, see this [tracking thread on GitHub](https://github.com/Azure/azure-functions-dotnet-worker/issues/3152).
 3. You can't run .NET 10 apps on Linux in the Consumption plan. To run on Linux, you should instead use the [Flex Consumption plan](./flex-consumption-plan.md).
 
 See [Supported versions][supported-versions] for a list of generally available releases that you can use.