Merge branch 'main' into release-aio-2603

Author: v-alje

articles/app-service/tutorial-nodejs-mongodb-app.md

@@ -25,7 +25,7 @@ ms.custom:
 
 # Tutorial: Deploy a Node.js + MongoDB web app to Azure
 
-This tutorial shows how to create a secure Node.js app in [Azure App Service](overview.md) that's connected to an [Azure Cosmos DB for MongoDB](/azure/cosmos-db/mongodb/mongodb-introduction) database. Azure App Service provides a highly scalable, self-patching web hosting service using the Linux operating system. When you're finished, you have an Express.js app running on Azure App Service on Linux.
+This tutorial shows how to create a secure Node.js app in [Azure App Service](overview.md) that's connected to an [Azure DocumentDB](https://learn.microsoft.com/azure/documentdb/) database. Azure App Service provides a highly scalable, self-patching web hosting service using the Linux operating system. When you're finished, you have an Express.js app running on Azure App Service on Linux.
 
 :::image type="content" source="./media/tutorial-nodejs-mongodb-app/azure-portal-browse-app-2.png" alt-text="Screenshot of Node.js application storing data in Cosmos DB.":::
 
@@ -125,7 +125,7 @@ Having issues? Check the [Troubleshooting section](#troubleshooting).
 
 ## Create App Service and Azure Cosmos DB
 
-In this step, you create the Azure resources. The steps used in this tutorial create a set of secure-by-default resources that include App Service and Azure Cosmos DB for MongoDB. For the creation process, you specify:
+In this step, you create the Azure resources. The steps used in this tutorial create a set of secure-by-default resources that include App Service and Azure DocumentDB. For the creation process, you specify:
 
 - The **Name** for the web app. It's part of the DNS name for your app.
 - The **Region** to run the app physically in the world. It's also part of the DNS name for your app.
@@ -171,7 +171,7 @@ Sign in to the [Azure portal](https://portal.azure.com/) and follow these steps
         - **Virtual network** → Integrated with the App Service app and isolates back-end network traffic.
         - **Private endpoint** → Access endpoint for the database resource in the virtual network.
         - **Network interface** → Represents a private IP address for the private endpoint.
-        - **Azure Cosmos DB for MongoDB** → Accessible only from behind the private endpoint. A database and a user are created for you on the server.
+        - **Azure DocumentDB** → Accessible only from behind the private endpoint. A database and a user are created for you on the server.
         - **Private DNS zone** → Enables DNS resolution of the Azure Cosmos DB server in the virtual network.
 
     :::column-end:::

articles/application-gateway/media/tutorial-ingress-controller-add-on-new/tutorial-ingress-controller-add-on-new.png

@@ -385,8 +385,8 @@ For the legacy cloning script, version 1.0.11 is the new version of the migratio
 ### Public IP retention script
 
 After you successfully migrate the configuration and thoroughly test your new V2 gateway, this step focuses on redirecting live traffic.
-
-We provide an Azure PowerShell script that *retains the public IP address from V1*. Here are important considerations for the script:
+> [!NOTE]
+> The IP migration script does not support public IP address resources that have name beginning with a numeric character. 
 
 - The script reserves the Basic public IP from V1, converts it to Standard, and attaches it to the V2 gateway. This action effectively redirects all incoming traffic to the V2 gateway.
 - This IP swap operation typically results in a brief *downtime of approximately one to five minutes*. Plan accordingly.

articles/application-gateway/migrate-v1-v2.md

@@ -57,6 +57,27 @@ Deploying a new AKS cluster with the AGIC add-on enabled without specifying an e
 az aks create -n myCluster -g myResourceGroup --network-plugin azure --enable-managed-identity -a ingress-appgw --appgw-name myApplicationGateway --appgw-subnet-cidr "10.225.0.0/16" --generate-ssh-keys
 ```
 
+## Enable the add-on for the existing AKS cluster
+
+You already have an existing AKS cluster and will enable the AGIC add-on. The add-on can be enabled either through the Azure portal or by using the Azure CLI.
+
+# [Azure Portal](#tab/azure-portal)
+
+In this page in the screenshot, you can create it simply by selecting the checkbox. If you want to specify a subnet prefix, select *Create new* and configure it manually.
+
+:::image type="content" source="media/tutorial-ingress-controller-add-on-new/tutorial-ingress-controller-add-on-new.png" alt-text="Screenshot of enabling AGIC addon by Portal." lightbox="media/tutorial-ingress-controller-add-on-new/tutorial-ingress-controller-add-on-new.png":::
+
+# [Azure CLI](#tab/azure-cli)
+
+You can give the name of the application gateway as well as subnet CIDR by the command.
+appgw-subnet-cidr should be in the address prefixes in your virtual network. Please change *10.0.250.0/24* to your preferred application gateway subnet CIDR. This must always be within the address space range of your virtual network.
+
+```azurecli
+$ az aks enable-addons --resource-group ${RG_NAME} --name ${CLUSTER_NAME} --addons ingress-appgw --appgw-subnet-cidr "10.0.250.0/24"
+```
+
+In most cases, enabling the add-on automatically assigns the required permissions. However, depending on the environment, the permissions may not be granted automatically. In such cases, you should verify the permissions and assign them manually if necessary.
+
 > [!NOTE] 
 > Please ensure the identity used by AGIC has the proper permissions. A list of permissions needed by the identity can be found here: [Configure Infrastructure - Permissions](configuration-infrastructure.md#permissions). If a custom role is not defined with the required permissions, you may use the _Network Contributor_ role.
 

articles/application-gateway/tutorial-ingress-controller-add-on-new.md

@@ -270,7 +270,7 @@
       href: /security/benchmark/azure/baselines/functions-security-baseline?toc=/azure/azure-functions/toc.json&bc=/azure/azure-functions/breadcrumb/toc.json
   - name: Reliability
     items:
-    - name: Availability zones and disaster recovery
+    - name: Reliability in Azure Functions
       displayName: availability zones, high-availability, zone redundancy, disaster recovery
       href: /azure/reliability/reliability-functions?toc=/azure/azure-functions/toc.json&bc=/azure/azure-functions/breadcrumb/toc.json
     - name: Zone redundancy

articles/azure-functions/TOC.yml

@@ -83,6 +83,9 @@ public static async Task Run(
 > - The exception message typically identifies which activity functions or sub-orchestrations caused the failure. To access more detailed error information, inspect the [`FailureDetails`](/dotnet/api/microsoft.durabletask.taskfailuredetails) property.  
 > - By default, `FailureDetails` includes the **error type**, **error message**, **stack trace**, and any **nested inner exceptions** (each represented as a recursive `FailureDetails` object). To include additional exception properties in the failure output, see [Include Custom Exception Properties for FailureDetails (.NET Isolated)](#include-custom-exception-properties-for-failuredetails-net-isolated).  
 
+> [!IMPORTANT]
+> **Migration note (in-process to isolated):** In the in-process model, `FunctionFailedException.InnerException` contains the original exception object thrown by the activity, which you can cast and inspect directly. In the isolated worker model, `TaskFailedException` does **not** contain the original exception as an `InnerException`. Instead, error details are available only through the [`FailureDetails`](/dotnet/api/microsoft.durabletask.taskfailuredetails) property, which provides string-based properties (`ErrorType`, `ErrorMessage`, `StackTrace`). You can't cast or access the original exception object directly. Use [`FailureDetails.IsCausedBy<T>()`](/dotnet/api/microsoft.durabletask.taskfailuredetails.iscausedby) to check the original exception type.
+
 </details>
 <br>
 <details>
@@ -438,6 +441,102 @@ If the **CreditAccount** activity fails, the orchestrator catches the exception
 
 ::: zone pivot="durable-functions"
 
+## Errors with multiple activity calls (fan-out/fan-in)
+
+# [C#](#tab/csharp)
+
+When you use `Task.WhenAll` to run multiple activity calls in parallel (fan-out/fan-in pattern) and one or more activities fail, `await` throws only the first exception. To access all failures, inspect the `Exception` property on the `Task` returned by `Task.WhenAll`.
+
+<details>
+<summary><b>Isolated worker model</b></summary>
+
+```csharp
+var tasks = new[]
+{
+    context.CallActivityAsync("Activity1", input1),
+    context.CallActivityAsync("Activity2", input2),
+    context.CallActivityAsync("Activity3", input3),
+};
+
+var allTask = Task.WhenAll(tasks);
+try
+{
+    await allTask;
+}
+catch (TaskFailedException)
+{
+    // 'await' rethrows only the first exception. To inspect all failures,
+    // check allTask.Exception, which is an AggregateException.
+    if (allTask.Exception != null)
+    {
+        foreach (var inner in allTask.Exception.InnerExceptions)
+        {
+            if (inner is TaskFailedException taskFailed)
+            {
+                // Use taskFailed.FailureDetails to inspect error details
+                var errorType = taskFailed.FailureDetails.ErrorType;
+                var errorMessage = taskFailed.FailureDetails.ErrorMessage;
+            }
+        }
+    }
+}
+```
+
+</details>
+<br>
+<details>
+<summary><b>In-process model</b></summary>
+
+```csharp
+var tasks = new[]
+{
+    context.CallActivityAsync("Activity1", input1),
+    context.CallActivityAsync("Activity2", input2),
+    context.CallActivityAsync("Activity3", input3),
+};
+
+var allTask = Task.WhenAll(tasks);
+try
+{
+    await allTask;
+}
+catch (FunctionFailedException)
+{
+    // 'await' rethrows only the first exception. To inspect all failures,
+    // check allTask.Exception, which is an AggregateException.
+    if (allTask.Exception != null)
+    {
+        foreach (var inner in allTask.Exception.InnerExceptions)
+        {
+            if (inner is FunctionFailedException funcFailed)
+            {
+                // Use funcFailed.InnerException to access the original exception
+            }
+        }
+    }
+}
+```
+
+</details>
+
+# [JavaScript](#tab/javascript)
+
+In JavaScript, when you use `context.df.Task.all` to run multiple activity calls in parallel, the first failure causes the task to complete with an error. Wrap the call in a try/catch block to handle the error.
+
+# [Python](#tab/python)
+
+In Python, when you use `context.task_all` to run multiple activity calls in parallel, the first failure causes the task to complete with an error. Wrap the call in a try/except block to handle the error.
+
+# [PowerShell](#tab/powershell)
+
+In PowerShell, use `Wait-DurableTask` with multiple tasks. If any task fails, the error is raised.
+
+# [Java](#tab/java)
+
+In Java, when you use `ctx.allOf` to run multiple activity calls in parallel, the first failure causes the task to complete with an error. Use a try/catch block to handle the error.
+
+---
+
 ## Errors in entity functions
 Exception handling in entity functions depends on the Durable Functions hosting model:
 
@@ -1229,7 +1328,7 @@ def orchestrator_function(context: df.DurableOrchestrationContext):
     activity_task = context.call_activity('FlakyFunction')
     timeout_task = context.create_timer(deadline)
 
-    winner = yield context.task_any(activity_task, timeout_task)
+    winner = yield context.task_any([activity_task, timeout_task])
     if winner == activity_task:
         timeout_task.cancel()
         return True

articles/azure-functions/durable/durable-functions-error-handling.md

@@ -90,17 +90,6 @@ This orchestrator function does the following:
 
 Here is the code that implements the orchestrator function:
 
-[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=16-42)]
-
-> [!NOTE]
-> The sample linked in the prerequisites (`samples/precompiled`) uses the in-process model. The following **Isolated model** sections show equivalent code for the .NET isolated worker model.
-
-Notice the `await Task.WhenAll(tasks);` line. The code doesn't await the individual calls to `E2_CopyFileToBlob`, so they run in parallel. When the orchestrator passes the task array to `Task.WhenAll`, it returns a task that doesn't complete until all copy operations complete. If you're familiar with the Task Parallel Library (TPL) in .NET, this pattern is familiar. The difference is that these tasks could be running on multiple virtual machines concurrently, and the Durable Functions extension ensures that the end-to-end execution is resilient to process recycling.
-
-After the orchestrator awaits `Task.WhenAll`, all function calls are complete and return values. Each call to `E2_CopyFileToBlob` returns the number of bytes uploaded. Calculate the total by adding the return values.
-
-<br>
-
 <details>
 <summary><b>Isolated model</b></summary>
 
@@ -137,6 +126,22 @@ public static class BackupSiteContent
 }
 ```
 
+Notice the `await Task.WhenAll(tasks);` line. The code doesn't await the individual calls to `E2_CopyFileToBlob`, so they run in parallel. When the orchestrator passes the task array to `Task.WhenAll`, it returns a task that doesn't complete until all copy operations complete. If you're familiar with the Task Parallel Library (TPL) in .NET, this pattern is familiar. The difference is that these tasks could be running on multiple virtual machines concurrently, and the Durable Functions extension ensures that the end-to-end execution is resilient to process recycling.
+
+After the orchestrator awaits `Task.WhenAll`, all function calls are complete and return values. Each call to `E2_CopyFileToBlob` returns the number of bytes uploaded. Calculate the total by adding the return values.
+
+</details>
+
+<br>
+
+<details>
+<summary><b>In-process model</b></summary>
+
+[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=16-42)]
+
+> [!NOTE]
+> The [in-process model sample](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs) uses deprecated in-process packages. The preceding code shows the recommended .NET isolated worker model.
+
 </details>
 
 <br>
@@ -364,10 +369,6 @@ The helper activity functions are regular functions that use the `activityTrigge
 
 # [C#](#tab/csharp)
 
-[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=44-54)]
-
-<br>
-
 <details>
 <summary><b>Isolated model</b></summary>
 
@@ -400,6 +401,15 @@ public static class BackupSiteContent
 
 <br>
 
+<details>
+<summary><b>In-process model</b></summary>
+
+[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=44-54)]
+
+</details>
+
+<br>
+
 # [JavaScript](#tab/javascript)
 
 <details>
@@ -457,18 +467,12 @@ Java sample coming soon.
 
 # [C#](#tab/csharp)
 
-[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=56-81)]
-
-> [!NOTE]
-> To run the sample code, install the `Microsoft.Azure.WebJobs.Extensions.Storage` NuGet package.
-
-The function uses Azure Functions binding features like the [`Binder` parameter](../functions-dotnet-class-library.md#binding-at-runtime). You don't need those details for this walkthrough.
-
-<br>
-
 <details>
 <summary><b>Isolated model</b></summary>
 
+> [!NOTE]
+> To run the sample code, install the `Azure.Storage.Blobs` NuGet package.
+
 ```csharp
 using System;
 using System.IO;
@@ -518,6 +522,18 @@ public static class BackupSiteContent
 
 <br>
 
+<details>
+<summary><b>In-process model</b></summary>
+
+[!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=56-81)]
+
+> [!NOTE]
+> The in-process model sample requires the `Microsoft.Azure.WebJobs.Extensions.Storage` NuGet package and uses Azure Functions binding features like the [`Binder` parameter](../functions-dotnet-class-library.md#binding-at-runtime).
+
+</details>
+
+<br>
+
 # [JavaScript](#tab/javascript)
 
 <details>

articles/azure-functions/durable/durable-functions-fan-in-fan-out.md

@@ -194,6 +194,9 @@ public HttpResponseMessage httpStart(
 
 ---
 
+> [!TIP]
+> If you have multiple HTTP-triggered starter functions in the same function app, configure a unique `route` for each function to avoid route conflicts. Using a parameterized route like `orchestrators/{functionName}` (as shown in several of the preceding examples) lets a single HTTP starter function start any orchestrator by name, which is often the simplest approach.
+
 Starting an orchestrator function by using the HTTP-trigger functions shown previously can be done using any HTTP client. The following cURL command starts an orchestrator function named `DoWork`:
 
 ```bash

articles/azure-functions/durable/durable-functions-http-features.md

@@ -24,6 +24,9 @@ This article gives you an overview of orchestrator functions and how they can he
 
 For information about the types of functions available in a Durable Functions app, see [Durable Task programming model](programming-model-overview.md).
 
+> [!TIP]
+> If you use C# with the .NET isolated worker model, you can write orchestrations using either a **function-based** approach (static methods with `[Function]` attributes) or a **class-based** approach (classes that inherit from `TaskOrchestrator<TInput, TOutput>`). The class-based approach requires the [Microsoft.DurableTask.Generators](https://www.nuget.org/packages/Microsoft.DurableTask.Generators) source generator package and provides strongly typed invocations. For more information, see [Class-based activities and orchestrations](durable-functions-dotnet-isolated-overview.md#source-generator-and-class-based-activities-and-orchestrations). The C# code examples in this article show both approaches.
+
 ::: zone-end
 
 ::: zone pivot="durable-task-sdks"
@@ -116,6 +119,36 @@ public static async Task<List<string>> Run(
 
 <br>
 
+<details>
+<summary><b>Class-based model (isolated worker)</b></summary>
+
+The class-based approach uses a source generator and requires the [Microsoft.DurableTask.Generators](https://www.nuget.org/packages/Microsoft.DurableTask.Generators) NuGet package.
+
+```csharp
+using Microsoft.DurableTask;
+
+[DurableTask]
+public class HelloCities : TaskOrchestrator<object?, List<string>>
+{
+    public override async Task<List<string>> RunAsync(
+        TaskOrchestrationContext context, object? input)
+    {
+        var outputs = new List<string>();
+
+        outputs.Add(await context.CallActivityAsync<string>("SayHello", "Tokyo"));
+        outputs.Add(await context.CallActivityAsync<string>("SayHello", "Seattle"));
+        outputs.Add(await context.CallActivityAsync<string>("SayHello", "London"));
+
+        // Return ["Hello Tokyo!", "Hello Seattle!", "Hello London!"].
+        return outputs;
+    }
+}
+```
+
+</details>
+
+<br>
+
 <details>
 <summary><b>In-process model</b></summary>