Merge pull request #300624 from ggailey777/bundles

[Functions] Extension bundles support with refactoring

Author: Stacyrch140

articles/azure-functions/TOC.yml

@@ -375,7 +375,8 @@
           href: functions-triggers-bindings.md
         - name: Register binding extensions
           href: functions-bindings-register.md
-          displayName: bundles, extension bundles
+        - name: Extension bundles
+          href: extension-bundles.md  
         - name: Binding expression patterns
           href: functions-bindings-expressions-patterns.md
         - name: Handle binding errors

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

@@ -21,7 +21,7 @@ Make sure to choose your Durable Functions development language at the top of th
 
 ## Python v2 programming model
 
-Durable Functions is supported in the new [Python v2 programming model](../functions-reference-python.md?pivots=python-mode-decorators). To use the v2 model, you must install the Durable Functions SDK, which is the PyPI package `azure-functions-durable`, version `1.2.2` or a later version. You must also check `host.json` to make sure your app is referencing [Extension Bundles](../functions-bindings-register.md#extension-bundles) version 4.x to use the v2 model with Durable Functions. 
+Durable Functions is supported in the new [Python v2 programming model](../functions-reference-python.md?pivots=python-mode-decorators). To use the v2 model, you must install the Durable Functions SDK, which is the PyPI package `azure-functions-durable`, version `1.2.2` or a later version. You must also check `host.json` to make sure your app is referencing [Extension Bundles](../extension-bundles.md) version 4.x to use the v2 model with Durable Functions. 
 
 You can provide feedback and suggestions in the [Durable Functions SDK for Python repo](https://github.com/Azure/azure-functions-durable-python/issues).
 ::: zone-end
@@ -53,12 +53,12 @@ When you write orchestrator functions, the orchestration trigger is defined by t
 ::: zone pivot="programming-language-python"  
 Azure Functions supports two programming models for Python. The way that you define an orchestration trigger depends on your chosen programming model.
 
-# [v2](#tab/python-v2)
+### [v2](#tab/python-v2)
 The Python v2 programming model lets you define an orchestration trigger using the `orchestration_trigger` decorator directly in your Python function code. 
 
 In the v2 model, the Durable Functions triggers and bindings are accessed from an instance of `DFApp`, which is a subclass of `FunctionApp` that additionally exports Durable Functions-specific decorators. 
 
-# [v1](#tab/python-v1)
+### [v1](#tab/python-v1)
 When you write orchestrator functions in the Python v1 programming model, the orchestration trigger is defined by the following JSON object in the `bindings` array of the *function.json* file:
 
 ```json
@@ -82,7 +82,7 @@ Internally, this trigger binding polls the configured durable store for new orch
 
 Here are some notes about the orchestration trigger:
 
-* **Single-threading** - A single dispatcher thread is used for all orchestrator function execution on a single host instance. For this reason, it's important to ensure that orchestrator function code is efficient and doesn't perform any I/O. It is also important to ensure that this thread does not do any async work except when awaiting on Durable Functions-specific task types.
+* **Single-threading** - A single dispatcher thread is used for all orchestrator function execution on a single host instance. For this reason, it's important to ensure that orchestrator function code is efficient and doesn't perform any I/O. It's also important to ensure that this thread doesn't do any async work except when awaiting on Durable Functions-specific task types.
 * **Poison-message handling** - There's no poison message support in orchestration triggers.
 * **Message visibility** - Orchestration trigger messages are dequeued and kept invisible for a configurable duration. The visibility of these messages is renewed automatically as long as the function app is running and healthy.
 * **Return values** - Return values are serialized to JSON and persisted to the orchestration history table in Azure Table storage. These return values can be queried by the orchestration client binding, described later.
@@ -101,16 +101,16 @@ Here are some notes about the orchestration trigger:
 The orchestration trigger binding supports both inputs and outputs. Here are some things to know about input and output handling:
 
 * **inputs** - Orchestration triggers can be invoked with inputs, which are accessed through the context input object. All inputs must be JSON-serializable.
-* **outputs** - Orchestration triggers support output values as well as inputs. The return value of the function is used to assign the output value and must be JSON-serializable.
+* **outputs** - Orchestration triggers support both output and input values. The return value of the function is used to assign the output value and must be JSON-serializable.
 
 ### Trigger sample
 
-The following example code shows what the simplest "Hello World" orchestrator function might look like. Note that this example orchestrator doesn't actually schedule any tasks.
+The following example code shows what the simplest "Hello World" orchestrator function might look like. This example orchestrator doesn't actually schedule any tasks.
 
 ::: zone pivot="programming-language-csharp"
-The specific attribute used to define the trigger depends on whether you are running your C# functions [in-process](../functions-dotnet-class-library.md) or in an [isolated worker process](../dotnet-isolated-process-guide.md).
+The specific attribute used to define the trigger depends on whether you're running your C# functions [in-process](../functions-dotnet-class-library.md) or in an [isolated worker process](../dotnet-isolated-process-guide.md).
 
-# [In-process](#tab/in-process)
+#### [In-process](#tab/in-process)
 
 ```csharp
 [FunctionName("HelloWorld")]
@@ -124,7 +124,7 @@ public static string Run([OrchestrationTrigger] IDurableOrchestrationContext con
 > [!NOTE]
 > The previous code is for Durable Functions 2.x. For Durable Functions 1.x, you must use `DurableOrchestrationContext` instead of `IDurableOrchestrationContext`. For more information about the differences between versions, see the [Durable Functions Versions](durable-functions-versions.md) article.
 
-# [Isolated process](#tab/isolated-process)
+#### [Isolated process](#tab/isolated-process)
 
 ```csharp
 [Function("HelloWorld")]
@@ -135,7 +135,7 @@ public static string Run([OrchestrationTrigger] TaskOrchestrationContext context
 ```
 
 > [!NOTE]
-> In both Durable functions in-proc and in .NET-isolated, the orchestration input can be extracted via `context.GetInput<T>()`. However, .NET-isolated also supports the input being supplied as a parameter, as shown above. The input binding will bind to the first parameter which has no binding attribute on it and is not a well-known type already covered by other input bindings (ie: `FunctionContext`).
+> In both Durable functions in-proc and in .NET-isolated, the orchestration input can be extracted via `context.GetInput<T>()`. However, .NET-isolated also supports the input being supplied as a parameter, as shown above. The input binds to the first parameter, which has no binding attribute on it and isn't a well-known type already covered by other input bindings, such as `FunctionContext`.
 
 ---
 
@@ -155,7 +155,7 @@ module.exports = df.orchestrator(function*(context) {
 > The `durable-functions` library takes care of calling the synchronous `context.done` method when the generator function exits.
 ::: zone-end  
 ::: zone pivot="programming-language-python" 
-# [v2](#tab/python-v2)
+### [v2](#tab/python-v2)
 
 ```python
 import azure.functions as func
@@ -169,7 +169,7 @@ def my_orchestrator(context):
     return result
 ```
 
-# [v1](#tab/python-v1)
+### [v1](#tab/python-v1)
 ```python
 import azure.durable_functions as df
 
@@ -204,7 +204,7 @@ public String helloWorldOrchestration(
 Most orchestrator functions call activity functions, so here is a "Hello World" example that demonstrates how to call an activity function:
 ::: zone-end
 ::: zone pivot="programming-language-csharp"
-# [In-process](#tab/in-process)
+### [In-process](#tab/in-process)
 
 ```csharp
 [FunctionName("HelloWorld")]
@@ -220,7 +220,7 @@ public static async Task<string> Run(
 > [!NOTE]
 > The previous code is for Durable Functions 2.x. For Durable Functions 1.x, you must use `DurableOrchestrationContext` instead of `IDurableOrchestrationContext`. For more information about the differences between versions, see the [Durable Functions versions](durable-functions-versions.md) article.
 
-# [Isolated process](#tab/isolated-process)
+### [Isolated process](#tab/isolated-process)
 
 ```csharp
 [Function("HelloWorld")]
@@ -287,10 +287,10 @@ The activity trigger is defined by the following JSON object in the `bindings` a
 ::: zone pivot="programming-language-python"  
 The way that you define an activity trigger depends on your chosen programming model.
 
-# [v2](#tab/python-v2)
+### [v2](#tab/python-v2)
 Using the `activity_trigger` decorator directly in your Python function code. 
 
-# [v1](#tab/python-v1)
+### [v1](#tab/python-v1)
 The activity trigger is defined by the following JSON object in the `bindings` array of *function.json*:
 
 ```json
@@ -323,15 +323,15 @@ Here are some notes about the activity trigger:
 The activity trigger binding supports both inputs and outputs, just like the orchestration trigger. Here are some things to know about input and output handling:
 
 * **inputs** - Activity triggers can be invoked with inputs from an orchestrator function. All inputs must be JSON-serializable.
-* **outputs** - Activity functions support output values as well as inputs. The return value of the function is used to assign the output value and must be JSON-serializable.
+* **outputs** - Activity functions support both output and input values. The return value of the function is used to assign the output value and must be JSON-serializable.
 * **metadata** - .NET activity functions can bind to a `string instanceId` parameter to get the instance ID of the calling orchestration.
 
 ### Trigger sample
 
 The following example code shows what a simple `SayHello` activity function might look like.
 
 ::: zone pivot="programming-language-csharp"
-# [In-process](#tab/in-process)
+### [In-process](#tab/in-process)
 
 ```csharp
 [FunctionName("SayHello")]
@@ -352,7 +352,7 @@ public static string SayHello([ActivityTrigger] string name)
 }
 ```
 
-# [Isolated process](#tab/isolated-process)
+### [Isolated process](#tab/isolated-process)
 
 In the .NET-isolated worker, only serializable types representing your input are supported for the `[ActivityTrigger]`.
 
@@ -374,7 +374,7 @@ module.exports = async function(context) {
 };
 ```
 
-JavaScript bindings can also be passed in as additional parameters, so the same function could be simplified as follows:
+JavaScript bindings can also be passed in as extra parameters, so the same function could be simplified as follows:
 
 ```javascript
 module.exports = async function(context, name) {
@@ -385,7 +385,7 @@ module.exports = async function(context, name) {
 ::: zone-end  
 ::: zone pivot="programming-language-python" 
 
-# [v2](#tab/python-v2)
+### [v2](#tab/python-v2)
 
 ```python
 import azure.functions as func
@@ -398,7 +398,7 @@ def my_activity(myInput: str):
     return "Hello " + myInput
 ```
 
-# [v1](#tab/python-v1)
+### [v1](#tab/python-v1)
 
 ```python
 def main(name: str) -> str:
@@ -429,7 +429,7 @@ public String sayHello(@DurableActivityTrigger(name = "name") String name) {
 You can use regular input and output bindings in addition to the activity trigger binding. 
 
 ::: zone pivot="programming-language-javascript" 
-For example, you can take the input to your activity binding, and send a message to an Event Hub using the Event Hubs output binding:
+For example, you can take the input to your activity binding, and send a message to an event hub using the Event Hubs output binding:
 
 ```json
 {
@@ -495,10 +495,10 @@ The durable client trigger is defined by the following JSON object in the `bindi
 ::: zone pivot="programming-language-python"  
 The way that you define a durable client trigger depends on your chosen programming model.
 
-# [v2](#tab/python-v2)
+### [v2](#tab/python-v2)
 Using the `durable_client_input` decorator directly in your Python function code. 
 
-# [v1](#tab/python-v1)
+### [v1](#tab/python-v1)
 The durable client trigger is defined by the following JSON object in the `bindings` array of *function.json*:
 
 ```json
@@ -536,7 +536,7 @@ Here's an example queue-triggered function that starts a "HelloWorld" orchestrat
 
 ::: zone pivot="programming-language-csharp"
 
-# [In-process](#tab/in-process)
+#### [In-process](#tab/in-process)
 
 ```csharp
 [FunctionName("QueueStart")]
@@ -552,7 +552,7 @@ public static Task Run(
 > [!NOTE]
 > The previous C# code is for Durable Functions 2.x. For Durable Functions 1.x, you must use `OrchestrationClient` attribute instead of the `DurableClient` attribute, and you must use the `DurableOrchestrationClient` parameter type instead of `IDurableOrchestrationClient`. For more information about the differences between versions, see the [Durable Functions Versions](durable-functions-versions.md) article.
 
-# [Isolated process](#tab/isolated-process)
+#### [Isolated process](#tab/isolated-process)
 
 ```csharp
 [Function("QueueStart")]
@@ -612,7 +612,7 @@ $InstanceId = Start-DurableOrchestration -FunctionName $FunctionName -Input $inp
 ::: zone-end  
 ::: zone pivot="programming-language-python" 
 
-# [v2](#tab/python-v2)
+#### [v2](#tab/python-v2)
 
 ```python
 import azure.functions as func
@@ -629,7 +629,7 @@ async def durable_trigger(req: func.HttpRequest, client):
     return response
 ```
 
-# [v1](#tab/python-v1)
+#### [v1](#tab/python-v1)
 
 **`function.json`**
 ```json
@@ -739,12 +739,12 @@ By default, the name of an entity is the name of the function.
 > Entity triggers aren't yet supported for Java.
 ::: zone-end  
 ::: zone pivot="programming-language-python"  
-The way that you define a entity trigger depends on your chosen programming model.
+The way that you define an entity trigger depends on your chosen programming model.
 
-# [v2](#tab/python-v2)
+#### [v2](#tab/python-v2)
 Using the `entity_trigger` decorator directly in your Python function code. 
 
-# [v1](#tab/python-v1)
+#### [v1](#tab/python-v1)
 The entity trigger is defined by the following JSON object in the `bindings` array of *function.json*:
 
 ```json
@@ -765,7 +765,7 @@ By default, the name of an entity is the name of the function.
 
 Here are some notes about the entity trigger:
 
-* **Single-threaded**: A single dispatcher thread is used to process operations for a particular entity. If multiple messages are sent to a single entity concurrently, the operations will be processed one-at-a-time.
+* **Single-threaded**: A single dispatcher thread is used to process operations for a particular entity. If multiple messages are sent to a single entity concurrently, the operations are processed one-at-a-time.
 * **Poison-message handling** - There's no poison message support in entity triggers.
 * **Message visibility** - Entity trigger messages are dequeued and kept invisible for a configurable duration. The visibility of these messages is renewed automatically as long as the function app is running and healthy.
 * **Return values** - Entity functions don't support return values. There are specific APIs that can be used to save state or pass values back to orchestrations.
@@ -805,12 +805,12 @@ The entity client is defined by the following JSON object in the `bindings` arra
 > In most cases, we recommend that you omit the optional properties and rely on the default behavior.
 ::: zone-end  
 ::: zone pivot="programming-language-python"  
-The way that you define a entity client depends on your chosen programming model.
+The way that you define an entity client depends on your chosen programming model.
 
-# [v2](#tab/python-v2)
+#### [v2](#tab/python-v2)
 Using the `durable_client_input` decorator directly in your Python function code. 
 
-# [v1](#tab/python-v1)
+#### [v1](#tab/python-v1)
 The entity client is defined by the following JSON object in the `bindings` array of *function.json*:
 
 ```json

articles/azure-functions/durable/durable-functions-extension-upgrade.md

@@ -33,7 +33,7 @@ If you're using the Netherite or MSSQL [storage providers](durable-functions-sto
 * [MSSQL, isolated worker](https://www.nuget.org/packages/Microsoft.Azure.Functions.Worker.Extensions.DurableTask.SqlServer)
 
 ## Upgrade the extension bundle 
-[Extension bundles](../functions-bindings-register.md#extension-bundles) provide an easy and convenient way for non-.NET function apps to reference and use various Azure Function triggers and bindings. For example, if you need to send a message to Event Hubs every time your function is triggered, you can use the Event Hubs extension to gain access to Event Hubs bindings. The Durable Functions extension is also included in each version of extension bundles. Extension bundles are automatically configured in host.json when creating a function app using any of the supported development tools. 
+[Extension bundles](../extension-bundles.md) provide an easy and convenient way for non-.NET function apps to reference and use various Azure Function triggers and bindings. For example, if you need to send a message to Event Hubs every time your function is triggered, you can use the Event Hubs extension to gain access to Event Hubs bindings. The Durable Functions extension is also included in each version of extension bundles. Extension bundles are automatically configured in host.json when creating a function app using any of the supported development tools. 
 
 Most non-.NET applications rely on extension bundles to gain access to various triggers and bindings. The [latest bundle release](https://github.com/Azure/azure-functions-extension-bundles) often contains the latest version of the Durable Functions extension with critical bug fixes and performance improvements. Therefore, it's important that your app uses the latest version of extension bundles. You can check your host.json file to see whether the version range you're using includes the latest extension bundle version.