Merge branch 'main' into release-aio-2603

Author: v-alje

articles/api-management/private-endpoint.md

@@ -5,7 +5,7 @@ ms.service: azure-api-management
 author: dlepow
 ms.author: danlep
 ms.topic: how-to
-ms.date: 11/17/2025
+ms.date: 03/17/2026
 ms.custom:
   - build-2025
   - sfi-image-nochange
@@ -32,7 +32,9 @@ You can configure an inbound [private endpoint](../private-link/private-endpoint
 * Only the API Management instance's **Gateway endpoint** supports inbound Private Link connections. 
 * Each API Management instance supports at most 100 Private Link connections.
 * Connections aren't supported on the [self-hosted gateway](self-hosted-gateway-overview.md) or on a [workspace gateway](workspaces-overview.md#workspace-gateway). 
-* In the classic API Management tiers, private endpoints aren't supported in instances injected in an internal or external virtual network.
+* In the classic API Management tiers, private endpoints aren't supported in instances injected in an internal or external virtual network. 
+    > [!NOTE]
+    > In the Standard v2 and Premium v2 tiers, private endpoints are supported in instances with any supported virtual network configuration when fronted with [Azure Front Door Premium](../frontdoor/standard-premium/how-to-enable-private-link-apim.md).
 
 ## Typical scenarios
 
@@ -43,9 +45,6 @@ Supported configurations include:
 * Pass client requests through a firewall and configure rules to route requests privately to the API Management gateway.
 * Configure Azure Front Door (or Azure Front Door with Azure Application Gateway) to receive external traffic and then route traffic privately to the API Management gateway. For example, see [Connect Azure Front Door Premium to an Azure API Management with Private Link](../frontdoor/standard-premium/how-to-enable-private-link-apim.md).
 
-    > [!NOTE]
-    > Currently, routing traffic privately from Azure Front Door to an API Management Premium v2 instance isn't supported.
-
 ## Prerequisites
 
 - An existing API Management instance. [Create one if you haven't already](get-started-create-service-instance.md). 

articles/application-gateway/ipv6-application-gateway-portal.md

@@ -388,4 +388,4 @@ az deployment group create \
 
 ## Security notice
 
-This solution is classified as **Microsoft Confidential**. Please ensure you follow your organization’s security and data handling best practices when deploying and managing this solution.
+Please ensure you follow your organization’s security and data handling best practices when deploying and managing this solution.

articles/application-gateway/mutual-authentication-arm-template.md

@@ -240,6 +240,32 @@ module.exports = df.orchestrator(function*(context){
 });
 ```
 
+<br>
+<details>
+<summary><b>Node.js programming model v4 apps (including TypeScript)</b></summary>
+
+Use the same replay check pattern in your orchestration function:
+
+```typescript
+import * as df from "durable-functions";
+
+df.app.orchestration("FunctionChain", function* (context) {
+    if (!context.df.isReplaying) context.log("Calling F1.");
+    yield context.df.callActivity("F1");
+    if (!context.df.isReplaying) context.log("Calling F2.");
+    yield context.df.callActivity("F2");
+    if (!context.df.isReplaying) context.log("Calling F3.");
+    yield context.df.callActivity("F3");
+    context.log("Done!");
+});
+```
+
+> [!NOTE]
+> The `isReplaying` check suppresses duplicate logs caused by orchestrator replay. It doesn't suppress duplicate logs caused by full re-execution (for example, host restarts, long local debugging sessions, or queue message visibility timeouts). In those cases, you might still see repeated log lines with the same orchestration instance ID.
+
+</details>
+<br>
+
 # [Python](#tab/python)
 
 ```python
@@ -377,6 +403,25 @@ module.exports = df.orchestrator(function*(context){
 });
 ```
 
+<details>
+<summary><b>Node.js programming model v4 apps (including TypeScript)</b></summary>
+
+```typescript
+import * as df from "durable-functions";
+
+df.app.orchestration("FunctionChain", function* (context) {
+    if (!context.df.isReplaying) context.log("Calling F1.");
+    yield context.df.callActivity("F1");
+    if (!context.df.isReplaying) context.log("Calling F2.");
+    yield context.df.callActivity("F2");
+    if (!context.df.isReplaying) context.log("Calling F3.");
+    yield context.df.callActivity("F3");
+    context.log("Done!");
+});
+```
+
+</details>
+
 # [Python](#tab/python)
 
 ```python
@@ -484,6 +529,25 @@ module.exports = df.orchestrator(function*(context) {
 });
 ```
 
+<details>
+<summary><b>Node.js programming model v4 apps (including TypeScript)</b></summary>
+
+```typescript
+import * as df from "durable-functions";
+
+df.app.orchestration("SetStatusTest", function* (context) {
+    // ...do work...
+
+    // update the status of the orchestration with some arbitrary data
+    const customStatus = { completionPercentage: 90.0, status: "Updating database records" };
+    context.df.setCustomStatus(customStatus);
+
+    // ...do more work...
+});
+```
+
+</details>
+
 # [Python](#tab/python)
 
 ```python

articles/azure-functions/durable/durable-functions-diagnostics.md

@@ -92,10 +92,55 @@ 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>
+
+```csharp
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.DurableTask;
+
+namespace SampleApp;
+
+public static class BackupSiteContent
+{
+    [Function("E2_BackupSiteContent")]
+    public static async Task<long> Run(
+        [OrchestrationTrigger] TaskOrchestrationContext context)
+    {
+        string rootDirectory = context.GetInput<string>()?.Trim();
+        if (string.IsNullOrEmpty(rootDirectory))
+        {
+            rootDirectory = Directory.GetParent(typeof(BackupSiteContent).Assembly.Location)!.FullName;
+        }
+
+        string[] files = await context.CallActivityAsync<string[]>("E2_GetFileList", rootDirectory);
+
+        Task<long>[] tasks = files
+            .Select(file => context.CallActivityAsync<long>("E2_CopyFileToBlob", file))
+            .ToArray();
+
+        long[] results = await Task.WhenAll(tasks);
+        return results.Sum();
+    }
+}
+```
+
+</details>
+
+<br>
+
 # [JavaScript](#tab/javascript)
 
 <details>
@@ -321,6 +366,40 @@ The helper activity functions are regular functions that use the `activityTrigge
 
 [!code-csharp[Main](~/samples-durable-functions/samples/precompiled/BackupSiteContent.cs?range=44-54)]
 
+<br>
+
+<details>
+<summary><b>Isolated model</b></summary>
+
+```csharp
+using System.IO;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Logging;
+
+namespace SampleApp;
+
+public static class BackupSiteContent
+{
+    [Function("E2_GetFileList")]
+    public static string[] GetFileList(
+        [ActivityTrigger] string rootDirectory,
+        FunctionContext executionContext)
+    {
+        ILogger logger = executionContext.GetLogger("E2_GetFileList");
+        logger.LogInformation("Searching for files under '{RootDirectory}'...", rootDirectory);
+
+        string[] files = Directory.GetFiles(rootDirectory, "*", SearchOption.AllDirectories);
+        logger.LogInformation("Found {FileCount} file(s) under {RootDirectory}.", files.Length, rootDirectory);
+
+        return files;
+    }
+}
+```
+
+</details>
+
+<br>
+
 # [JavaScript](#tab/javascript)
 
 <details>
@@ -385,6 +464,60 @@ Java sample coming soon.
 
 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>
+
+```csharp
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Azure.Storage.Blobs;
+using Microsoft.Azure.Functions.Worker;
+using Microsoft.Extensions.Logging;
+
+namespace SampleApp;
+
+public static class BackupSiteContent
+{
+    [Function("E2_CopyFileToBlob")]
+    public static async Task<long> CopyFileToBlob(
+        [ActivityTrigger] string filePath,
+        FunctionContext executionContext)
+    {
+        ILogger logger = executionContext.GetLogger("E2_CopyFileToBlob");
+        long byteCount = new FileInfo(filePath).Length;
+
+        string blobPath = filePath
+            .Substring(Path.GetPathRoot(filePath)!.Length)
+            .Replace('\\', '/');
+        string outputLocation = $"backups/{blobPath}";
+
+        string? connectionString = Environment.GetEnvironmentVariable("AzureWebJobsStorage");
+        if (string.IsNullOrEmpty(connectionString))
+        {
+            throw new InvalidOperationException("AzureWebJobsStorage is not configured.");
+        }
+
+        BlobContainerClient containerClient = new(connectionString, "backups");
+        await containerClient.CreateIfNotExistsAsync();
+        BlobClient blobClient = containerClient.GetBlobClient(blobPath);
+
+        logger.LogInformation("Copying '{FilePath}' to '{OutputLocation}'. Total bytes = {ByteCount}.", filePath, outputLocation, byteCount);
+
+        await using Stream source = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+        await blobClient.UploadAsync(source, overwrite: true);
+
+        return byteCount;
+    }
+}
+```
+
+</details>
+
+<br>
+
 # [JavaScript](#tab/javascript)
 
 <details>

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

@@ -37,7 +37,7 @@ To complete this quickstart, you need:
 
 * An Azure subscription. To use Durable Functions, you must have an Azure Storage account.
 
-* [.NET Core SDK](https://dotnet.microsoft.com/download) version 3.1 or later installed.
+* [.NET SDK](https://dotnet.microsoft.com/download) version 8.0 or later installed.
 
 * An HTTP test tool that keeps your data secure. For more information, see [HTTP test tools](../functions-develop-local.md#http-test-tools).
 
@@ -70,6 +70,16 @@ In Visual Studio Code, create a local Azure Functions project.
 
 Visual Studio Code installs Azure Functions Core Tools if it's required to create the project. It also creates a function app project in a folder. This project contains the [host.json](../functions-host-json.md) and [local.settings.json](../functions-develop-local.md#local-settings-file) configuration files.
 
+If you don't see **C#** in the language list or if only *function.json* is generated, verify the following prerequisites and then create the project again in a new empty folder:
+
+* The latest [Azure Functions Core Tools](../functions-run-local.md) is installed.
+* A supported [.NET SDK](https://dotnet.microsoft.com/download) is installed.
+* The [C# extension](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp) is installed in Visual Studio Code.
+
+These checks usually resolve cases where Visual Studio Code scaffolds only metadata instead of generating the C# project files.
+
+For more troubleshooting steps, see the [Azure Functions Core Tools reference](../functions-core-tools-reference.md).
+
 Another file, *HelloOrchestration.cs*, contains the basic building blocks of a Durable Functions app:
 
 | Method | Description |
@@ -100,7 +110,7 @@ You can use other storage options for your Durable Functions app. For more infor
 
 ## Test the function locally
 
-Azure Functions Core Tools gives you the capability to run an Azure Functions project on your local development computer. You're prompted to install these tools the first time you start a function in Visual Studio Code.
+Azure Functions Core Tools gives you the capability to run an Azure Functions project on your local development computer. You're prompted to install these tools the first time you start a function in Visual Studio.
 
 1. In Visual Studio Code, set a breakpoint in the `SayHello` activity function code, and then select F5 to start the function app project. The terminal panel displays output from Core Tools.
 
@@ -228,7 +238,7 @@ For more information about these functions, see [Durable Functions types and fea
 
 Azure Functions Core Tools gives you the capability to run an Azure Functions project on your local development computer. You're prompted to install these tools the first time you start a function in Visual Studio Code.
 
-1. In Visual Studio Code, set a breakpoint in the `SayHello` activity function code, and then select F5. If you're prompted, accept the request from Visual Studio to download and install Azure Functions Core (command-line) tools. You might also need to enable a firewall exception so that the tools can handle HTTP requests.
+1. In Visual Studio, set a breakpoint in the `SayHello` activity function code, and then select F5. If you're prompted, accept the request from Visual Studio to download and install Azure Functions Core (command-line) tools. You might also need to enable a firewall exception so that the tools can handle HTTP requests.
 
    > [!NOTE]
    > For more information about debugging, see [Durable Functions diagnostics](durable-functions-diagnostics.md#debugging).