- For more information, see the [LUIS reference documentation](/rest/api/cognitiveservices-luis/authoring/features?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true).

-Set your app's version settings using the LUIS portal by selecting **Manage** from the top navigation menu, in the **Application Settings** page. You can also use the [Update Version Settings API](/rest/api/cognitiveservices-luis/authoring/versions/update?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true). See the [Reference](../luis-reference-application-settings.md) documentation for more information.

-Training is nondeterministic: utterance prediction can vary slightly across versions or apps. You can remove nondeterministic training by updating the [version settings](/rest/api/cognitiveservices-luis/authoring/settings/update?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) API with the UseAllTrainingData name/value pair to use all training data.

-|Authoring|[V2](https://go.microsoft.com/fwlink/?linkid=2092087)<br>[preview V3](/rest/api/cognitiveservices-luis/authoring/operation-groups)|

-|Prediction|[V2](https://go.microsoft.com/fwlink/?linkid=2092356)<br>[V3](/rest/api/cognitiveservices-luis/runtime/operation-groups?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true)|

-To edit your LUIS app programmatically, use the [Authoring API](https://go.microsoft.com/fwlink/?linkid=2092087). See [Call LUIS authoring API](get-started-get-model-rest-apis.md) and [Build a LUIS app programmatically using Node.js](luis-tutorial-node-import-utterances-csv.md) for examples of how to call the Authoring API. The Authoring API requires that you use an [authoring key](luis-how-to-azure-subscription.md) rather than an endpoint key. Programmatic authoring allows up to 1,000,000 calls per month and five transactions per second. For more info on the keys you use with LUIS, see [Manage keys](luis-how-to-azure-subscription.md).

-Designate a single main app. Any utterances that are suggested for review should be added to the main app, then moved back to all the other apps. This is either a full export of the app, or loading the labeled utterances from the main app to the other apps. Loading can be done from either the [LUIS](./luis-reference-regions.md?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) website or the authoring API for a [single utterance](/rest/api/cognitiveservices-luis/authoring/examples/add) or for a [batch](/rest/api/cognitiveservices-luis/authoring/examples/batch?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true).

-* [Add application](/rest/api/cognitiveservices-luis/authoring/apps/add?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) - start with an empty app and create intents, utterances, and entities.

-* [Add prebuilt application](/rest/api/cognitiveservices-luis/authoring/apps/add-custom-prebuilt-domain?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) - start with a prebuilt domain, including intents, utterances, and entities.

-1. Send an HTTP POST [request for training](/rest/api/cognitiveservices-luis/authoring/train/train-version?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true).

-2. Request the [training status](/rest/api/cognitiveservices-luis/authoring/train/get-status?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) with an HTTP GET request.

-Use the [Version settings API](/rest/api/cognitiveservices-luis/authoring/settings/update?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) with the UseAllTrainingData set to *true* to turn off deterministic training.

-LUIS uses [Bing Spell Check API V7](../../cognitive-services/bing-spell-check/overview.md) to correct spelling errors in the utterance. LUIS needs the key associated with that service. Create the key, then add the key as a querystring parameter at the [endpoint](https://go.microsoft.com/fwlink/?linkid=2092356).

-If you need the returned prebuilt datetimeV2 to adjust for daylight savings time, you should use the querystring parameter with a +/- value in minutes for the [endpoint](https://go.microsoft.com/fwlink/?linkid=2092356) query.

-If you want to disable non-deterministic training for those LUIS app versions that you're building for the purpose of testing, use the [Version settings API](/rest/api/cognitiveservices-luis/authoring/versions?view=rest-cognitiveservices-luis-authoring-v3.0-preview&preserve-view=true) with the `UseAllTrainingData` setting set to `true`.

-* [Published package API](/rest/api/cognitiveservices-luis/authoring/apps/package-published-application-as-gzip?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true)

-* [Not-published, trained-only package API](/rest/api/cognitiveservices-luis/authoring/apps/package-trained-application-as-gzip?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true)

-For a full description of available tags, such as `latest` used in the preceding command, see [LUIS](https://go.microsoft.com/fwlink/?linkid=2043204) on Docker Hub.

-The app running in the container can't be altered. In order to change the app in the container, you need to change the app in the LUIS service using the [LUIS](https://www.luis.ai) portal or use the LUIS [authoring APIs](/rest/api/cognitiveservices-luis/authoring/operation-groups?view=rest-cognitiveservices-luis-authoring-v3.0-preview&preserve-view=true). Then train and/or publish, then download a new package and run the container again.

-[download-published-package]: /rest/api/cognitiveservices-luis/authoring/apps/package-published-application-as-gzip?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true

-[download-versioned-package]: /rest/api/cognitiveservices-luis/authoring/apps/package-trained-application-as-gzip?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true

-The LUIS prediction endpoint URL is where you submit LUIS queries after the [LUIS app](#application-app) is authored and published. The endpoint URL contains the region or custom subdomain of the published app as well as the app ID. You can find the endpoint on the **[Azure resources](luis-how-to-azure-subscription.md)** page of your app, or you can get the endpoint URL from the [Get App Info](/rest/api/cognitiveservices-luis/authoring/apps/get?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) API.

-You can use the [v3.0-preview LUIS Programmatic APIs](/rest/api/cognitiveservices-luis/authoring/apps?view=rest-cognitiveservices-luis-authoring-v3.0-preview&preserve-view=true) to manage authoring resources.

-You can use the [v3.0-preview LUIS Endpoint API](/rest/api/cognitiveservices-luis/runtime/operation-groups?view=rest-cognitiveservices-luis-runtime-v3.0&preserve-view=true) to manage prediction resources.

-1. Use the token to request the LUIS runtime resources across subscriptions. Use the API to [get the LUIS Azure account](/rest/api/cognitiveservices-luis/authoring/azure-accounts/get-assigned?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) that your user account has access to.

-1. Assign the token to the LUIS resource by using the [Assign a LUIS Azure accounts to an application](/rest/api/cognitiveservices-luis/authoring/azure-accounts/assign-to-app?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) API.

-1. Use the token to request the LUIS runtime resources across subscriptions. Use the [Get LUIS Azure accounts API](/rest/api/cognitiveservices-luis/authoring/azure-accounts/get-assigned?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true), which your user account has access to.

-1. Assign the token to the LUIS resource by using the [Unassign a LUIS Azure account from an application](/rest/api/cognitiveservices-luis/authoring/azure-accounts/remove-from-app?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) API.

-* [Importing applications](/rest/api/cognitiveservices-luis/authoring/versions/import?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true)

-* [Exporting applications](/rest/api/cognitiveservices-luis/authoring/versions/export?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true)

-These settings are stored in the [exported](/rest/api/cognitiveservices-luis/authoring/versions/export?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&tabs=HTTP&preserve-view=true) app and updated with the REST APIs or LUIS portal.

-> * Make sure to set `log=false` for [V3 APIs](/rest/api/cognitiveservices-luis/runtime/prediction/get-slot-prediction?view=rest-cognitiveservices-luis-runtime-v3.0&tabs=HTTP&preserve-view=true) to disable active learning. By default this value is `false`, to ensure that data does not leave the boundaries of the runtime region.

-The [authoring](https://go.microsoft.com/fwlink/?linkid=2092087) and [endpoint](https://go.microsoft.com/fwlink/?linkid=2092356) APIs return HTTP response codes. While response messages include information specific to a request, the HTTP response status code is general.

-The following table lists some of the most common HTTP response status codes for the [authoring](https://go.microsoft.com/fwlink/?linkid=2092087) and [endpoint](https://go.microsoft.com/fwlink/?linkid=2092356) APIs:

-* REST API [authoring](/rest/api/cognitiveservices-luis/authoring/operation-groups?view=rest-cognitiveservices-luis-authoring-v3.0-preview&preserve-view=true) and [endpoint](/rest/api/cognitiveservices-luis/runtime/operation-groups?view=rest-cognitiveservices-luis-runtime-v3.0&preserve-view=true) documentation

-Once the entities and intents have been defined in the LUIS app, you can add the utterances. The following code uses the [Utterances_AddBatch](/rest/api/cognitiveservices-luis/authoring/examples/batch?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) API, which allows you to add up to 100 utterances at a time. Copy or [download](https://github.com/Azure-Samples/cognitive-services-language-understanding/blob/master/examples/build-app-programmatically-csv/_upload.js) it, and save it into `_upload.js`.

-Language Understanding Intelligent Service (LUIS) preserves customer content to operate the service, but the LUIS user has full control over viewing, exporting, and deleting their data. This can be done through the LUIS web [portal](luis-reference-regions.md) or the [LUIS Authoring (also known as Programmatic) APIs](/rest/api/cognitiveservices-luis/authoring/operation-groups?view=rest-cognitiveservices-luis-authoring-v3.0-preview&preserve-view=true).

-| **APIs** | [Link](/rest/api/cognitiveservices-luis/authoring/azure-accounts/remove-from-app?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) | [Link](/rest/api/cognitiveservices-luis/authoring/apps/delete?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) | [Link](/rest/api/cognitiveservices-luis/authoring/examples/delete?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) | [Link](/rest/api/cognitiveservices-luis/authoring/versions/delete-unlabelled-utterance?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) |

-| **APIs** | [Link](/rest/api/cognitiveservices-luis/authoring/azure-accounts/list-user-luis-accounts?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) | [Link](/rest/api/cognitiveservices-luis/authoring/versions/export?view=rest-cognitiveservices-luis-authoring-v2.0&tabs=HTTP&preserve-view=true) | [Link](/rest/api/cognitiveservices-luis/authoring/examples/list?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) | [Link](/rest/api/cognitiveservices-luis/authoring/apps/download-query-logs?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) |

-create an [Explicit List](/rest/api/cognitiveservices-luis/authoring/model/add-explicit-list-item?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true) through the authoring API to allow the exception when:

-To fix this exception to the pattern, add `the man from la mancha` as an explicit list match for the {subject} entity using the [authoring API for explicit list](/rest/api/cognitiveservices-luis/authoring/model/add-explicit-list-item?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true).

- * [LUIS Programmatic v3.0-preview](/rest/api/cognitiveservices-luis/authoring/operation-groups?view=rest-cognitiveservices-luis-authoring-v3.0-preview&preserve-view=true)

- * [LUIS Programmatic v2.0 APIs](/rest/api/cognitiveservices-luis/authoring/operation-groups?view=rest-cognitiveservices-luis-authoring-v2.0&preserve-view=true)

- * [LUIS Endpoint APIs v3.0](/rest/api/cognitiveservices-luis/runtime/operation-groups?view=rest-cognitiveservices-luis-runtime-v3.0&preserve-view=true)

- * [LUIS Programmatic v3.0-preview](/rest/api/cognitiveservices-luis/authoring/operation-groups?view=rest-cognitiveservices-luis-authoring-v3.0-preview&preserve-view=true)

- * [LUIS Programmatic v2.0 APIs](/rest/api/cognitiveservices-luis/authoring/operation-groups?view=rest-cognitiveservices-luis-authoring-v2.0&preserve-view=true)

- * [Delete application](/rest/api/cognitiveservices-luis/authoring/apps/delete?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true)

- * [Publish an application](/rest/api/cognitiveservices-luis/authoring/apps/publish?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true)

- * [Update application settings](/rest/api/cognitiveservices-luis/authoring/apps/update-settings?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true)

- * [Assign a LUIS azure accounts to an application](/rest/api/cognitiveservices-luis/authoring/azure-accounts/assign-to-app?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true)

- * [Remove an assigned LUIS azure accounts from an application](/rest/api/cognitiveservices-luis/authoring/azure-accounts/remove-from-app?view=rest-cognitiveservices-luis-authoring-v3.0-preview&tabs=HTTP&preserve-view=true)

-[endpoint-apis]: https://go.microsoft.com/fwlink/?linkid=2092356

-|[Prediction](https://go.microsoft.com/fwlink/?linkid=865445) operations with storage (Transactions Per Second)|2|10|

-|[Prediction](https://go.microsoft.com/fwlink/?linkid=865445) operations without storage (Transactions Per Second)|2|20|

-* [REST API reference documentation (prediction)](/rest/api/customvision/prediction/operation-groups?view=rest-customvision-prediction-v3.1)

-> This document demonstrates use of the .NET client library for C# to submit an image to the Prediction API. For more information and examples, see the [Prediction API reference](/rest/api/customvision/prediction/operation-groups?view=rest-customvision-prediction-v3.1).

-* [Prebuilt API](/rest/api/cognitiveservices/questionanswering/question-answering/get-answers-from-text) - Use the prebuilt runtime API to answer specified question using text provided by users.

-* [Custom authoring API](/rest/api/cognitiveservices/questionanswering/question-answering-projects) - Create a knowledge base to answer questions.

-* [Custom runtime API](/rest/api/cognitiveservices/questionanswering/question-answering/get-answers) - Query and knowledge base to generate an answer.

- * [Question answering projects](/rest/api/cognitiveservices/questionanswering/question-answering-projects)

- * [Question Answering Projects](/rest/api/cognitiveservices/questionanswering/question-answering-projects/export)

- * [question answering projects](/rest/api/cognitiveservices/questionanswering/question-answering-projects)

- * [question answering projects](/rest/api/cognitiveservices/questionanswering/question-answering-projects)

-When a project has hierarchical relationships (either added manually or via extraction) and the previous response was an answer related to other question answer pairs, for the next query we give slight preference to all the children question answer pairs, sibling question answer pairs, and grandchildren question answer pairs in that order. Along with any query, the [custom question answering REST API](/rest/api/cognitiveservices/questionanswering/question-answering/get-answers) expects a `context` object with the property `previousQnAId`, which denotes the last top answer. Based on this previous `QnAID`, all the related `QnAs` are boosted.

-> Authoring functionality is available via the REST API and [Authoring SDK (preview)](/dotnet/api/overview/azure/ai.language.questionanswering-readme). This article provides examples of using the REST API with cURL. For full documentation of all parameters and functionality available consult the [REST API reference content](/rest/api/cognitiveservices/questionanswering/question-answering-projects).

-Learn more about the [custom question answering Get Answers REST API](/rest/api/cognitiveservices/questionanswering/question-answering/get-answers)

-You can also trigger a refresh programmatically using the REST API. See the **[Update Sources](/rest/api/cognitiveservices/questionanswering/question-answering-projects/update-sources)** reference documentation for parameters and a sample request.

-* [Update Sources API reference](/rest/api/cognitiveservices/questionanswering/question-answering-projects/update-sources)

-* [Authoring API reference](/rest/api/cognitiveservices/questionanswering/question-answering-projects)

-* [Runtime API reference](/rest/api/cognitiveservices/questionanswering/question-answering)

-## List message files

-```http

-GET https://YOUR_RESOURCE_NAME.openai.azure.com/openai/threads/{thread_id}/messages/{message_id}/files?api-version=2024-05-01-preview

-```

-Returns a list of message files.

-|Parameter| Type | Required | Description |

-|||||

-|`thread_id` | string | Required | The ID of the thread that the message and files belong to. |

-|`message_id`| string | Required | The ID of the message that the files belong to. |

-**Query Parameters**

-|Name | Type | Required | Description |

-| | | | |

-| `limit` | integer | Optional - Defaults to 20 |A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.|

-| `order` | string | Optional - Defaults to desc |Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.|

-| `after` | string | Optional | A cursor for use in pagination. after is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list.|

-| `before` | string | Optional | A cursor for use in pagination. before is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list.|

-### Returns

-A list of [message file](#message-file-object) objects

-### Example list message files request

-# [Python 1.x](#tab/python)

-```python

-from openai import AzureOpenAI

-

-client = AzureOpenAI(

- api_key=os.getenv("AZURE_OPENAI_API_KEY"),

- api_version="2024-05-01-preview",

- azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")

- )

-message_files = client.beta.threads.messages.files.list(

- thread_id="thread_abc123",

- message_id="msg_abc123"

-)

-print(message_files)

-```

-# [REST](#tab/rest)

-```console

-curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/threads/{thread_id}/messages/files?api-version=2024-05-01-preview \

- -H "api-key: $AZURE_OPENAI_API_KEY" \

- -H 'Content-Type: application/json'

-```

-

-## Retrieve message file

-GET https://YOUR_RESOURCE_NAME.openai.azure.com/openai/threads/{thread_id}/messages/{message_id}/files/{file_id}?api-version=2024-05-01-preview

-Retrieves a message file.

-|`thread_id` | string | Required | The ID of the thread, which the message and file belongs to. |

-|`message_id`| string | Required | The ID of the message that the file belongs to. |

-|`file_id` | string | Required | The ID of the file being retrieved. |

-**Returns**

-The [message file](#message-file-object) object.

-### Example retrieve message file request

-message_files = client.beta.threads.messages.files.retrieve(

- thread_id="thread_abc123",

- message_id="msg_abc123",

- file_id="assistant-abc123"

-print(message_files)

-curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/threads/{thread_id}/messages/{message_id}/files/{file_id}?api-version=2024-05-01-preview

- -H 'Content-Type: application/json'

-## Modify message

-POST https://YOUR_RESOURCE_NAME.openai.azure.com/openai/threads/{thread_id}/messages/{message_id}?api-version=2024-05-01-preview

-Modifies a message.

-**Request body**

-|Parameter| Type | Required | Description |

-|||||

-| metadata | map| Optional | Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format. Keys can be a maximum of 64 characters long and values can be a maximum of 512 characters long.|

-The modified [message](#message-object) object.

-

-message = client.beta.threads.messages.update(

- metadata={

- "modified": "true",

- "user": "abc123",

- },

-print(message)

-curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/threads/{thread_id}/messages/{message_id}?api-version=2024-05-01-preview

-``` \

- -H 'Content-Type: application/json' \

- -d '{

- "metadata": {

- "modified": "true",

- "user": "abc123"

- }

- }'

-

-## Message file object

-A list of files attached to a message.

-|Name | Type | Description |

-| | | |

-| `id`| string | The identifier, which can be referenced in API endpoints.|

-|`object`|string| The object type, which is always `thread.message.file`.|

-|`created_at`|integer | The Unix timestamp (in seconds) for when the message file was created.|

-|`message_id`| string | The ID of the message that the File is attached to.|

-## Create assistant file

-```http

-POST https://YOUR_RESOURCE_NAME.openai.azure.com/openai/assistants/{assistant_id}/files?api-version=2024-05-01-preview

-```

-Create an assistant file by attaching a `File` to an `assistant`.

-**Path parameters**

-|Parameter| Type | Required | Description |

-|||||

-|`assistant_id`| string | Required | The ID of the assistant that the file should be attached to. |

-**Request body**

-| Name | Type | Required | Description |

-||||

-| file_id | string | Required | A File ID (with purpose="assistants") that the assistant should use. Useful for tools like code_interpreter that can access files. |

-### Returns

-An [assistant file](#assistant-file-object) object.

-### Example create assistant file request

-# [Python 1.x](#tab/python)

-```python

-from openai import AzureOpenAI

-

-client = AzureOpenAI(

- api_key=os.getenv("AZURE_OPENAI_API_KEY"),

- api_version="2024-05-01-preview",

- azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")

- )

-assistant_file = client.beta.assistants.files.create(

- assistant_id="asst_abc123",

- file_id="assistant-abc123"

-)

-print(assistant_file)

-```

-# [REST](#tab/rest)

-```console

-curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/assistants/{assistant_id}/files?api-version=2024-05-01-preview \

- -H "api-key: $AZURE_OPENAI_API_KEY" \

- -H 'Content-Type: application/json' \

- -d '{

- "file_id": "assistant-abc123"

- }'

-```

-## List assistant files

-```http

-GET https://YOUR_RESOURCE_NAME.openai.azure.com/openai/assistants/{assistant_id}/files?api-version=2024-05-01-preview

-```

-Returns a list of assistant files.

-**Path parameters**

-|Parameter| Type | Required | Description |

-|||||

-| assistant_id | string | Required | The ID of the assistant the file belongs to. |

-**Query parameters**

-|Parameter| Type | Required | Description |

-|||||

-| `limit` | integer | Optional | A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.|

-| `order` | string | Optional - Defaults to desc | Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.|

-| `after` | string | Optional | A cursor for use in pagination. `after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo in order to fetch the next page of the list. |

-|`before`| string | Optional | A cursor for use in pagination. `before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include before=obj_foo in order to fetch the previous page of the list. |

-### Returns

-A list of [assistant file](#assistant-file-object) objects

-### Example list assistant files

-# [Python 1.x](#tab/python)

-```python

-from openai import AzureOpenAI

-

-client = AzureOpenAI(

- api_key=os.getenv("AZURE_OPENAI_API_KEY"),

- api_version="2024-05-01-preview",

- azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")

- )

-assistant_files = client.beta.assistants.files.list(

- assistant_id="asst_abc123"

-)

-print(assistant_files)

-```

-# [REST](#tab/rest)

-```console

-curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/assistants/{assistant-id}/files?api-version=2024-05-01-preview \

- -H "api-key: $AZURE_OPENAI_API_KEY" \

- -H 'Content-Type: application/json'

-```

-## Retrieve assistant file

-```http

-GET https://YOUR_RESOURCE_NAME.openai.azure.com/openai/assistants/{assistant_id}/files/{file-id}?api-version=2024-05-01-preview

-```

-Retrieves an Assistant file.

-**Path parameters**

-|Parameter| Type | Required | Description |

-||||

-| assistant_id | string | Required | The ID of the assistant the file belongs to. |

-|file_id| string | Required | The ID of the file we're getting |

-### Returns

-The [assistant file](#assistant-file-object) object matching the specified ID

-### Example retrieve assistant file

-# [Python 1.x](#tab/python)

-```python

-client = AzureOpenAI(

- api_key=os.getenv("AZURE_OPENAI_API_KEY"),

- api_version="2024-05-01-preview",

- azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")

- )

-assistant_file = client.beta.assistants.files.retrieve(

- assistant_id="asst_abc123",

- file_id="assistant-abc123"

-)

-print(assistant_file)

-```

-# [REST](#tab/rest)

-```console

-curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/assistants/{assistant-id}/files/{file-id}?api-version=2024-05-01-preview \

- -H "api-key: $AZURE_OPENAI_API_KEY" \

- -H 'Content-Type: application/json'

-```

-## Delete assistant file

-```http

-DELETE https://YOUR_RESOURCE_NAME.openai.azure.com/openai/assistants/{assistant_id}/files/{file-id}?api-version=2024-05-01-preview

-```

-Delete an assistant file.

-**Path parameters**

-|Parameter| Type | Required | Description |

-|||||

-| `assistant_id` | string | Required | The ID of the assistant the file belongs to. |

-| `file_id` | string | Required | The ID of the file to delete |

-**Returns**

-File deletion status

-### Example delete assistant file

-# [Python 1.x](#tab/python)

-```python

-client = AzureOpenAI(

- api_key=os.getenv("AZURE_OPENAI_API_KEY"),

- api_version="2024-05-01-preview",

- azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")

- )

-deleted_assistant_file = client.beta.assistants.files.delete(

- assistant_id="asst_abc123",

- file_id="assistant-abc123"

-)

-print(deleted_assistant_file)

-```

-# [REST](#tab/rest)

-```console

-curl https://YOUR_RESOURCE_NAME.openai.azure.com/openai/assistants/{assistant_id}/files/{file-id}?api-version=2024-05-01-preview

-``` \

- -H "api-key: $AZURE_OPENAI_API_KEY" \

- -H 'Content-Type: application/json' \

- -X DELETE

-```

-## Assistant file object

-| Field | Type | Description |

-||||

-| `id`| string | The identifier, which can be referenced in API endpoints.|

-|`object`| string | The object type, which is always `assistant.file` |

-|`created_at` | integer | The Unix timestamp (in seconds) for when the assistant file was created.|

-|`assistant_id` | string | The assistant ID that the file is attached to. |

-| Model | Max tokens for system message | Max tokens for model response |

-|--|--|--|

-| GPT-35-0301 | 400 | 1500 |

-| GPT-35-0613-16K | 1000 | 3200 |

-| GPT-4-0613-8K | 400 | 1500 |

-| GPT-4-0613-32K | 2000 | 6400 |

-The table above shows the maximum number of tokens that can be used for the [system message](#system-message) and the model response. Additionally, the following also consume tokens:

-|Authoring/Subscription key|[Azure portal](https://azure.microsoft.com/free/cognitive-services/)|These keys are used to access the [QnA Maker management service APIs](/rest/api/cognitiveservices/qnamaker4.0/knowledgebase). These APIs let you edit the questions and answers in your knowledge base, and publish your knowledge base. These keys are created when you create a new QnA Maker service.<br><br>Find these keys on the **Azure AI services** resource on the **Keys and Endpoint** page.|

-While there is some support for synonyms in the English language, use case-insensitive word alterations via the [Alterations API](/rest/api/cognitiveservices/qnamaker/alterations/replace) to add synonyms to keywords that take different forms. Synonyms are added at the QnA Maker service-level and **shared by all knowledge bases in the service**.

-To improve the confidence score of a particular response to a user query, you can add the user query to the knowledge base as an alternate question on that response. You can also use case-insensitive [word alterations](/rest/api/cognitiveservices/qnamaker/alterations/replace) to add synonyms to keywords in your KB.

-If your knowledge base doesn't find an answer, it returns the _default answer_. This answer is configurable on the **Settings** page in the QnA Maker portal or in the [APIs](/rest/api/cognitiveservices/qnamaker/knowledgebase/update#request-body).

-|KB answer when no answer is determined|`No good match found in KB.` - When the [GenerateAnswer API](/rest/api/cognitiveservices/qnamakerruntime/runtime/generateanswer) finds no matching answer to the question, the `DefaultAnswer` setting of the App service is returned. All knowledge bases in the same QnA Maker resource share the same default answer text.<br>You can manage the setting in the Azure portal, via the App service, or with the REST APIs for [getting](/rest/api/appservice/webapps/listapplicationsettings) or [updating](/rest/api/appservice/webapps/updateapplicationsettings) the setting.|

-|Follow-up prompt instruction text|When using a follow-up prompt in a conversation flow, you may not need an answer in the QnA pair because you want the user to select from the follow-up prompts. In this case, set specific text by setting the default answer text, which is returned with each prediction for follow-up prompts. The text is meant to display as instructional text to the selection of follow-up prompts. An example for this default answer text is `Please select from the following choices`. This configuration is explained in the next few sections of this document. Can also set as part of knowledge base definition of `defaultAnswerUsedForExtraction` using [REST API](/rest/api/cognitiveservices/qnamaker/knowledgebase/create).|

-You use the [GenerateAnswer API](/rest/api/cognitiveservices/qnamakerruntime/runtime/generateanswer) in your bot or application to query your knowledge base with a user question, to get the best match from the question and answer pairs.

-After you publish your knowledge base, either from the [QnA Maker portal](https://www.qnamaker.ai), or by using the [API](/rest/api/cognitiveservices/qnamaker/knowledgebase/publish), you can get the details of your GenerateAnswer endpoint.

-* Required [URI parameters](/rest/api/cognitiveservices/qnamakerruntime/runtime/train#uri-parameters)

-* Required [body properties](/rest/api/cognitiveservices/qnamakerruntime/runtime/train#feedbackrecorddto).

-The [response](/rest/api/cognitiveservices/qnamakerruntime/runtime/generateanswer#successful-query) is a JSON object including all the information you need to display the answer and the next turn in the conversation, if available.

-You can create a knowledge case with multi-turn prompts using the [QnA Maker Create API](/rest/api/cognitiveservices/qnamaker/knowledgebase/create). The prompts are adding in the `context` property's `prompts` array.

-The [display text and display order](/rest/api/cognitiveservices/qnamaker/knowledgebase/update#promptdto), returned in the JSON response, is supported for editing by the [Update API](/rest/api/cognitiveservices/qnamaker/knowledgebase/update).

-You can add or delete multi-turn prompts using the [QnA Maker Update API](/rest/api/cognitiveservices/qnamaker/knowledgebase/update). The prompts are adding in the `context` property's `promptsToAdd` array and the `promptsToDelete` array.

-Use the [Train API](/rest/api/cognitiveservices/qnamaker4.0/runtime/train) to send the correct answer to QnA Maker, after the user selects it.

-Visit the [Prebuilt API reference](/rest/api/cognitiveservices-qnamaker/qnamaker5.0preview2/prebuilt/generateanswer) documentation to understand the input and output parameters required for calling the API.

- 1. **QnAs**: When exporting QnAs, all QnA pairs (with questions, answers, metadata, follow-up prompts, and the data source names) are downloaded. The QnA IDs that are exported with the questions and answers may be used to update a specific QnA pair using the [update API](/rest/api/cognitiveservices/qnamaker/knowledgebase/update). The QnA ID for a specific QnA pair remains unchanged across multiple export operations.

-* [Download knowledge base API](/rest/api/cognitiveservices/qnamaker4.0/knowledgebase/download)

-* [Replace API (reload with same knowledge base ID)](/rest/api/cognitiveservices/qnamaker4.0/knowledgebase/replace)

-* [Create API (load with new knowledge base ID)](/rest/api/cognitiveservices/qnamaker4.0/knowledgebase/create)

-[Alterations](/rest/api/cognitiveservices/qnamaker/alterations/replace) do not allow these special characters: ',', '?', ':', ';', '\"', '\'', '(', ')', '{', '}', '[', ']', '-', '+', '.', '/', '!', '*', '-', '_', '@', '#'

-QnA Maker uses the App Service to provide the query runtime used by the [generateAnswer API](/rest/api/cognitiveservices/qnamaker4.0/runtime/generateanswer).

- "workspace_name": <workspace_name>,

- export HUBBLE_VERSION=0.11

-export HUBBLE_VERSION=0.11

-Since the cluster is already using a private CIDR for pods which doesn't overlap with the VNet IP space, you don't need to specify the `--pod-cidr` parameter and the Pod CIDR will remain the same.

-| Solutions | Partners |

-|--||

-| DevOps | [Advantech](#advantech) <br> [Akuity](#akuity) <br> [Anchore](#anchore) <br> [Hashicorp](#hashicorp) <br> [Kong](#kong) <br> [NetApp](#netapp) |

-| Networking | [Buoyant](#buoyant) <br> [Isovalent](#isovalent) <br> [Solo.io](#soloio) <br> [Tetrate](#tetrate) <br> [Tigera](#tigera-inc) |

-| Observability | [Anchore](#anchore) <br> [Buoyant](#buoyant) <br> [Isovalent](#isovalent) <br> [Dynatrace](#dynatrace) <br> [Solo.io](#soloio) <br> [Tigera](#tigera-inc) |

-| Security | [Anchore](#anchore) <br> [Buoyant](#buoyant) <br> [Isovalent](#isovalent) <br> [Kong](#kong) <br> [Palo Alto Networks](#palo-alto-networks) <br> [Solo.io](#soloio) <br> [Tetrate](#tetrate) <br> [Tigera](#tigera-inc) <br> [Wiz](#wiz) |

-| Storage | [Catalogic](#catalogic) <br> [Veeam](#veeam) |

-| Config Management | [Corent](#corent) |

-| Migration | [Catalogic](#catalogic) |

-The object ID is a unique identifier for the client ID (also known as the application ID) that uniquely identifies a security principal of type *Application* within the Entra ID tenant. The resource ID is a unique identifier to manage and locate a resource in Azure. These values are required to enabled AKS workload identity.

- az role assignment list --scope $STORAGE_ACCOUNT_PRIMARY_RESOURCE_ID --output table

- * A **collector**, which collects unused images

-description: Learn how to interact with Kubernetes resources to manage an Azure Kubernetes Service (AKS) cluster from the Azure portal.

-# Access Kubernetes resources from the Azure portal

-The Azure portal includes a Kubernetes resource view for easy access to the Kubernetes resources in your Azure Kubernetes Service (AKS) cluster. Viewing Kubernetes resources from the Azure portal reduces context switching between the Azure portal and the `kubectl` command-line tool, streamlining the experience for viewing and editing your Kubernetes resources. The resource viewer currently includes multiple resource types, such as deployments, pods, and replica sets.

-The Kubernetes resource view from the Azure portal replaces the deprecated AKS dashboard add-on.

-## Prerequisites

-To see the Kubernetes resources, navigate to your AKS cluster in the Azure portal. The navigation pane on the left is used to access your resources. The resources include:

-### Deploy an application

-In this example, we'll use our sample AKS cluster to deploy the Azure Vote application from the [AKS quickstart][aks-quickstart-portal].

-1. From the **Services and ingresses** resource view, select **Create** > **Starter application**.

-2. Under **Create a basic web application**, select **Create**.

-3. On the **Application details** page, select **Next**.

-4. On the **Review YAML** page, select **Deploy**.

-Once the application is deployed, the resource view shows the two Kubernetes

-### Monitor deployment insights

-AKS clusters with [Container insights][enable-monitor] enabled can quickly view deployment and other insights. From the Kubernetes resources view, you can see the live status of individual deployments, including CPU and memory usage. You can also go to Azure Monitor for more in-depth information about specific nodes and containers.

-Here's an example of deployment insights from a sample AKS cluster:

-## Edit YAML

-The Kubernetes resource view also includes a YAML editor. A built-in YAML editor means you can update or create services and deployments from within the portal and apply changes immediately.

-To edit a YAML file for one of your resources, see the following steps:

-1. Navigate to your resource in the Azure portal.

-2. Select **YAML** and make your desired edits.

-3. Select **Review + save** > **Confirm manifest changes** > **Save**.

->[!WARNING]

-> We don't recommend performing direct production changes via UI or CLI. Instead, you should leverage [continuous integration (CI) and continuous deployment (CD) best practices](kubernetes-action.md). The Azure portal Kubernetes management capabilities, such as the YAML editor, are built for learning and flighting new deployments in a development and testing setting.

-This section addresses common problems and troubleshooting steps.

-To access the Kubernetes resources, you must have access to the AKS cluster, the Kubernetes API, and the Kubernetes objects. Ensure that you're either a cluster administrator or a user with the appropriate permissions to access the AKS cluster. For more information on cluster security, see [Access and identity options for AKS][concepts-identity].

->[!NOTE]

-> The Kubernetes resource view in the Azure portal is only supported by [managed-AAD enabled clusters](managed-azure-ad.md) or non-AAD enabled clusters. If you're using a managed-AAD enabled cluster, your Microsoft Entra user or identity needs to have the respective roles/role bindings to access the Kubernetes API and the permission to pull the [user `kubeconfig`](control-kubeconfig-access.md).

-For existing clusters, you may need to enable the Kubernetes resource view. To enable the resource view, follow the prompts in the portal for your cluster.

-> [!TIP]

-> You can add the AKS feature for [**API server authorized IP ranges**](api-server-authorized-ip-ranges.md) to limit API server access to only the firewall's public endpoint. Another option is to update the `-ApiServerAccessAuthorizedIpRange` to include access for a local client computer or IP address range (from which portal is being browsed). To allow this access, you need the computer's public IPv4 address. You can find this address with the following command or you can search "what is my IP address" in your browser.

-```bash

-# Retrieve your IP address

-CURRENT_IP=$(dig +short myip.opendns.com @resolver1.opendns.com)

-```

-```azurecli

-# Add to AKS approved list

-az aks update -g $RG -n $AKSNAME --api-server-authorized-ip-ranges $CURRENT_IP/32

-```

-### [Azure PowerShell](#tab/azure-powershell)

-> [!TIP]

-> You can add the AKS feature for [**API server authorized IP ranges**](api-server-authorized-ip-ranges.md) to limit API server access to only the firewall's public endpoint. Another option is to update the `-ApiServerAccessAuthorizedIpRange` to include access for a local client computer or IP address range (from which portal is being browsed). To allow this access, you need the computer's public IPv4 address. You can find this address with the following command or you can search "what is my IP address" in your browser.

-```azurepowershell

-# Retrieve your IP address

-$CURRENT_IP = (Invoke-RestMethod -Uri http://ipinfo.io/json).ip

-# Add to AKS approved list

-Set-AzAksCluster -ResourceGroupName $RG -Name $AKSNAME -ApiServerAccessAuthorizedIpRange $CURRENT_IP/32

-```

-This article showed you how to access Kubernetes resources from the Azure portal. For more information on cluster resources, see [Deployments and YAML manifests][deployments].

-[deployments]: concepts-clusters-workloads.md#deployments-and-yaml-manifests

-An API can be managed by any API management solution (such as Azure [API Management](../api-management/api-management-key-concepts.md) or solutions from other providers), or unmanaged.

-* **Create and maintain an organizational inventoryΓÇï** - Organizations can build a **complete inventory of APIs** available in their organization. Foster communication and let API program managers and developers collaborate for increased API reuse, quality, security, compliance, and developer productivity.ΓÇï

-description: Learn how to move App Service resources from one region to another.

-#Customer intent: As an Azure service administrator, I want to move my App Service resources to another Azure region.

-# Move an App Service resource to another region

-This article describes how to move App Service resources to a different Azure region. You might move your resources to another region for a number of reasons. For example, to take advantage of a new Azure region, to deploy features or services available in specific regions only, to meet internal policy and governance requirements, or in response to capacity planning requirements.

-App Service resources are region-specific and can't be moved across regions. You must create a copy of your existing App Service resources in the target region, then move your content over to the new app. If your source app uses a custom domain, you can [migrate it to the new app in the target region](manage-custom-dns-migrate-domain.md) when you're finished.

-To make copying your app easier, you can [clone an individual App Service app](app-service-web-app-cloning.md) into an App Service plan in another region, but it does have [limitations](app-service-web-app-cloning.md#current-restrictions), especially that it doesn't support Linux apps.

-## Prerequisites

-<!-

-## Prepare

-Identify all the App Service resources that you're currently using. For example:

-Certain resources, such as imported certificates or hybrid connections, contain integration with other Azure services. For information on how to move those resources across regions, see the documentation for the respective services.

-## Move

-1. [Create a back up of the source app](manage-backup.md).

-1. [Create an app in a new App Service plan, in the target region](app-service-plan-manage.md#create-an-app-service-plan).

-2. [Restore the back up in the target app](manage-backup.md)

-2. If you use a custom domain, [bind it preemptively to the target app](manage-custom-dns-migrate-domain.md#2-create-the-dns-records) with `asuid.` and [enable the domain in the target app](manage-custom-dns-migrate-domain.md#3-enable-the-domain-for-your-app).

-3. Configure everything else in your target app to be the same as the source app and verify your configuration.

-4. When you're ready for the custom domain to point to the target app, [remap the domain name](manage-custom-dns-migrate-domain.md#4-remap-the-active-dns-name).

-<!-- 1. Login to the [Azure portal](https://portal.azure.com) > **Resource Groups**.

-2. Locate the Resource Group that contains the source App Service resources and click on it.

-3. Select > **Settings** > **Export template**.

-4. Choose **Deploy** in the **Export template** blade.

-5. Click **TEMPLATE** > **Edit template** to open the template in the online editor.

-6. Click inside the online editor and type Ctrl+F (or Γîÿ+F on a Mac) and type `"identity": {` to find any managed identity definition. The following is an example if you have a user-assigned managed identity.

- ```json

- "identity": {

- "type": "UserAssigned",

- "userAssignedIdentities": {

- "/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/<group-name>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<identity-name>": {

- "principalId": "00000000-0000-0000-0000-000000000000",

- "clientId": "00000000-0000-0000-0000-000000000000"

- }

- }

- },

- ```

-6. Click inside the online editor and type Ctrl+F (or Γîÿ+F on a Mac) and type `"Microsoft.Web/sites/hostNameBindings` to find all hostname bindings. The following is an example if you have a user-assigned managed identity.

- ```json

- {

- "type": "Microsoft.Web/sites/hostNameBindings",

- "apiVersion": "2018-11-01",

- "name": "[concat(parameters('sites_webapp_name'), '/', parameters('sites_webapp_name'), '.azurewebsites.net')]",

- "location": "West Europe",

- "dependsOn": [

- "[resourceId('Microsoft.Web/sites', parameters('sites_webapp_name'))]"

- ],

- "properties": {

- "siteName": "<app-name>",

- "hostNameType": "Verified"

- }

- },

- ```

-6. Click inside the online editor and type Ctrl+F (or Γîÿ+F on a Mac) and type `"Microsoft.Web/certificates` to find all hostname bindings. The following is an example if you have a user-assigned managed identity.

- ```json

- {

- "type": "Microsoft.Web/certificates",

- "apiVersion": "2018-11-01",

- "name": "[parameters('certificates_test2_cephaslin_com_name')]",

- "location": "West Europe",

- "properties": {

- "hostNames": [

- "[parameters('certificates_test2_cephaslin_com_name')]"

- ],

- "password": "[parameters('certificates_test2_cephaslin_com_password')]"

- }

- },

- ```

-7. Delete the entire JSON block. Click **Save** in the online editor.

-8. Click **BASICS** > **Create new** to create a new resource group. Type the group name and click **OK**.

-9. In **BASICS** > **Location**, select the region you want. -->

-## Clean up source resources

-Delete the source app and App Service plan. [An App Service plan in the non-free tier carries a charge, even if no app is running in it.](app-service-plan-manage.md#delete-an-app-service-plan)

-## Next steps

-[Azure App Service App Cloning Using PowerShell](app-service-web-app-cloning.md)

-For **Arc-enabled VMware vSphere**, manual upgrade and cloud upgrade are available. Appliances on version 1.0.15 and higher are automatically opted-in to cloud-managed upgrade. In order for either upgrade option to work, [the upgrade prerequisites](#prerequisites) must be met. Microsoft may attempt to perform a cloud-managed upgrade of your Arc resource bridge at any time if your appliance will soon be out of support. While Microsoft offers cloud-managed upgrade, you’re still responsible for ensuring that your Arc resource bridge is within the supported n-3 versions. Disruptions could cause cloud-managed upgrade to fail and you may need to manual upgrade the Arc resource bridge. If you are close to being out of support, please manual upgrade to stay in supported versions.  Do not wait for cloud-managed upgrade. Any appliances that are earlier than version 1.0.15 must be manually upgraded.

-For **Arc-enabled System Center Virtual Machine Manager (SCVMM)**, the manual upgrade feature is available for appliance version 1.0.14 and higher. Appliances below version 1.0.14 need to perform the recovery option to get to version 1.0.15 or higher. Review the steps for [performing the recovery operation](/azure/azure-arc/system-center-virtual-machine-manager/disaster-recovery), then delete the appliance VM from SCVMM and perform the recovery steps. This deploys a new resource bridge and reconnects pre-existing Azure resources.

-## A Twitter-style clone written using PHP and Redis

-The [Retwis](https://github.com/SyntaxC4-MSFT/retwis) sample is the Redis Hello World. It's a minimal Twitter-style social network clone written using Redis and PHP using the [Predis](https://github.com/nrk/predis) client. The source code is designed to be simple and at the same time to show different Redis data structures.

-description: Configure Durable Functions with Managed Identity Credentials and Client Secret Credentials.

-# Configure Durable Functions with Microsoft Entra ID

-[Microsoft Entra ID](../../active-directory/fundamentals/active-directory-whatis.md) (Microsoft Entra ID) is a cloud-based identity and access management service. Identity-based connections allow Durable Functions to make authorized requests against Microsoft Entra protected resources, like an Azure Storage account, without the need to manage secrets manually. Using the default Azure storage provider, Durable Functions needs to authenticate against an Azure storage account. In this article, we show how to configure a Durable Functions app to utilize two kinds of Identity-based connections: **managed identity credentials** and **client secret credentials**.

-## Configure your app to use managed identity (recommended)

-A [managed identity](../../app-service/overview-managed-identity.md) allows your app to easily access other Microsoft Entra protected resources such as Azure Key Vault. Managed identity is supported in [Durable Functions extension](https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask) versions **2.7.0** and greater.

-> Strictly speaking, a managed identity is only available to apps when executing on Azure. When configured to use identity-based connections, a locally executing app will utilize your **developer credentials** to authenticate with Azure resources. Then, when deployed on Azure, it will utilize your managed identity configuration instead.

-### Prerequisites

-The following steps assume that you're starting with an existing Durable Functions app and are familiar with how to operate it.

-In particular, this quickstart assumes that you have already:

-* Created a Durable Functions project in the Azure portal or deployed a local Durable Functions to Azure.

-If this isn't the case, we suggest you start with one of the following articles, which provides detailed instructions on how to achieve all the requirements above:

-### Enable managed identity

-Only one identity is needed for your function, either a **system assigned managed identity** or a **user assigned managed identity**. To enable a managed identity for your function and learn more about the differences between the two identities, read the detailed instructions [here](../../app-service/overview-managed-identity.md).

-### Assign Role-based Access Controls (RBAC) to managed identity

-Navigate to your app's storage resource on the Azure portal. Follow [these instructions](../../active-directory/managed-identities-azure-resources/howto-assign-access-portal.md) to assign the following roles to your managed identity resource.

-* Storage Queue Data Contributor

-* Storage Blob Data Contributor

-* Storage Table Data Contributor

-### Add managed identity configuration in the Azure portal

-Navigate to your Azure function appΓÇÖs **Configuration** page and perform the following changes:

-1. Remove the default value "AzureWebJobsStorage".

- [ ](./media/durable-functions-configure-df-with-credentials/durable-functions-managed-identity-scenario-01.png#lightbox)

-2. Link your Azure storage account by adding **either one** of the following value settings:

- * **AzureWebJobsStorage__accountName**: For example: `mystorageaccount123`

- * **AzureWebJobsStorage__blobServiceUri**: Example: `https://mystorageaccount123.blob.core.windows.net/`

- **AzureWebJobsStorage__queueServiceUri**: Example: `https://mystorageaccount123.queue.core.windows.net/`

- **AzureWebJobsStorage__tableServiceUri**: Example: `https://mystorageaccount123.table.core.windows.net/`

- > [!NOTE]

- > If you are using [Azure Government](../../azure-government/documentation-government-welcome.md) or any other cloud that's separate from global Azure, then you will need to use this second option to provide specific service URLs. The values for these settings can be found in the storage account under the **Endpoints** tab. For more information on using Azure Storage with Azure Government, see the [Develop with Storage API on Azure Government](../../azure-government/documentation-government-get-started-connect-to-storage.md) documentation.

- 

-3. Finalize your managed identity configuration:

- * If **system-assigned identity** should be used, then specify nothing else.

- * If **user-assigned identity** should be used, then add the following app settings values in your app configuration:

- * **AzureWebJobsStorage__credential**: managedidentity

- * **AzureWebJobsStorage__clientId**: (This is a GUID value that you obtain from the Microsoft Entra admin center)

- 

-Registering a client application in Microsoft Entra ID is another way you can configure access to an Azure service. In the following steps, you will learn how to use client secret credentials for authentication to your Azure Storage account. This method can be used by function apps both locally and on Azure. However, client secret credential is **less recommended** than managed identity as it's more complicated to configure and manage and it requires sharing a secret credential with the Azure Functions service.

-### Prerequisites

-The following steps assume that you're starting with an existing Durable Functions app and are familiar with how to operate it.

-In particular, this quickstart assumes that you have already:

-* Created a Durable Functions project on your local machine or in the Azure portal.

-<a name='register-a-client-application-on-azure-active-directory'></a>

-### Register a client application on Microsoft Entra ID

-1. Register a client application under Microsoft Entra ID in the Azure portal according to [these instructions](../../healthcare-apis/register-application.md).

-2. Create a client secret for your client application. In your registered application:

- 1. Select **Certificates & Secrets** and select **New client secret**.

- 2. Fill in a **Description** and choose secret valid time in the **Expires** field.

- 3. Copy and save the secret value carefully because it will not show up again after you leave the page.

-

- 

-### Assign Role-based Access Controls (RBAC) to the client application

-Assign these three roles to your client application with the following steps.

-* Storage Queue Data Contributor

-* Storage Blob Data Contributor

-* Storage Table Data Contributor

-1. Navigate to your functionΓÇÖs storage account **Access Control (IAM)** page and add a new role assignment.

- 

-2. Choose the required role, click next, then search for your application, review and add.

- 

-### Add client secret configuration

-To run and test in Azure, specify the followings in your Azure function appΓÇÖs **Configuration** page in the Azure portal. To run and test locally, specify the following in the functionΓÇÖs **local.settings.json** file.

-1. Remove the default value "AzureWebJobsStorage".

-2. Link Azure storage account by adding either one of the following value settings:

- * **AzureWebJobsStorage__accountName**: For example: `mystorageaccount123`

- * **AzureWebJobsStorage__blobServiceUri**: Example: `https://mystorageaccount123.blob.core.windows.net/`

- **AzureWebJobsStorage__queueServiceUri**: Example: `https://mystorageaccount123.queue.core.windows.net/`

- **AzureWebJobsStorage__tableServiceUri**: Example: `https://mystorageaccount123.table.core.windows.net/`

-

- The values for these Uri variables can be found in the storage account under the **Endpoints** tab.

-

- 

-3. Add a client secret credential by specifying the following values:

- * **AzureWebJobsStorage__clientId**: (this is a GUID value found in the Microsoft Entra application page)

- * **AzureWebJobsStorage__ClientSecret**: (this is the secret value generated in the Microsoft Entra admin center in a previous step)

- * **AzureWebJobsStorage__tenantId**: (this is the tenant ID that the Microsoft Entra application is registered in)

- The client ID and tenant ID values can be found on your client applicationΓÇÖs overview page. The client secret value is the one that was carefully saved in the previous step. It will not be available after the page is refreshed.

-

- 

-description: Create and publish an Azure Durable Function using Visual Studio or Visual Studio Code.

-zone_pivot_groups: code-editors-set-one

-# Create your first durable function in C#

-Durable Functions is an extension of [Azure Functions](../functions-overview.md) that lets you write stateful functions in a serverless environment. The extension manages state, checkpoints, and restarts for you.

-In this article, you learn how to use Visual Studio Code to locally create and test a "hello world" durable function. This function orchestrates and chains together calls to other functions. You can then publish the function code to Azure. These tools are available as part of the Visual Studio Code [Azure Functions extension](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions).

-## Prerequisites

-To complete this tutorial:

-* Install [Visual Studio Code](https://code.visualstudio.com/download).

-* Install the following Visual Studio Code extensions:

- * [Azure Functions](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions)

- * [C#](https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.csharp)

-* Make sure that you have the latest version of the [Azure Functions Core Tools](../functions-run-local.md).

-* Durable Functions require an Azure storage account. You need an Azure subscription.

-* Make sure that you have version 3.1 or a later version of the [.NET Core SDK](https://dotnet.microsoft.com/download) installed.

-## <a name="create-an-azure-functions-project"></a>Create your local project

-In this section, you use Visual Studio Code to create a local Azure Functions project.

-1. In Visual Studio Code, press <kbd>F1</kbd> (or <kbd>Ctrl/Cmd+Shift+P</kbd>) to open the command palette. In the command palette, search for and select `Azure Functions: Create New Project...`.

- :::image type="content" source="media/durable-functions-create-first-csharp/functions-vscode-create-project.png" alt-text="Screenshot of create a function project window.":::

-1. Choose an empty folder location for your project and choose **Select**.

-1. Follow the prompts and provide the following information:

- | Prompt | Value | Description |

- | | -- | -- |

- | Select a language for your function app project | C# | Create a local C# Functions project. |

- | Select a version | Azure Functions v4 | You only see this option when the Core Tools aren't already installed. In this case, Core Tools are installed the first time you run the app. |

- | Select a template for your project's first function | Skip for now | |

- | Select how you would like to open your project | Open in current window | Reopens Visual Studio Code in the folder you selected. |

-Visual Studio Code installs the Azure Functions Core Tools if needed. 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.

-## Add functions to the app

-The following steps use a template to create the durable function code in your project.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Follow the prompts and provide the following information:

- | Prompt | Value | Description |

- | | -- | -- |

- | Select a template for your function | DurableFunctionsOrchestration | Create a Durable Functions orchestration |

- | Provide a function name | HelloOrchestration | Name of the class in which functions are created |

- | Provide a namespace | Company.Function | Namespace for the generated class |

-1. When Visual Studio Code prompts you to select a storage account, choose **Select storage account**. Follow the prompts and provide the following information to create a new storage account in Azure:

- | Prompt | Value | Description |

- | | -- | -- |

- | Select subscription | *name of your subscription* | Select your Azure subscription |

- | Select a storage account | Create a new storage account | |

- | Enter the name of the new storage account | *unique name* | Name of the storage account to create |

- | Select a resource group | *unique name* | Name of the resource group to create |

- | Select a location | *region* | Select a region close to you |

-A class containing the new functions is added to the project. Visual Studio Code also adds the storage account connection string to *local.settings.json* and a reference to the [`Microsoft.Azure.WebJobs.Extensions.DurableTask`](https://www.nuget.org/packages/Microsoft.Azure.WebJobs.Extensions.DurableTask) NuGet package to the *.csproj* project file.

-Open the new *HelloOrchestration.cs* file to view the contents. This durable function is a simple function chaining example with the following methods:

-| Method | FunctionName | Description |

-| -- | | -- |

-| **`RunOrchestrator`** | `HelloOrchestration` | Manages the durable orchestration. In this case, the orchestration starts, creates a list, and adds the result of three functions calls to the list. When the three function calls are complete, it returns the list. |

-| **`SayHello`** | `HelloOrchestration_Hello` | The function returns a hello. It's the function that contains the business logic that is being orchestrated. |

-| **`HttpStart`** | `HelloOrchestration_HttpStart` | An [HTTP-triggered function](../functions-bindings-http-webhook.md) that starts an instance of the orchestration and returns a check status response. |

-Now that you've created your function project and a durable function, you can test it on your local computer.

-## Test the function locally

-Azure Functions Core Tools lets you run an Azure Functions project on your local development computer. You're prompted to install these tools the first time you start a function from Visual Studio Code.

-1. To test your function, set a breakpoint in the `SayHello` activity function code and press <kbd>F5</kbd> to start the function app project. Output from Core Tools is displayed in the **Terminal** panel.

- > [!NOTE]

- > For more information on debugging, see [Durable Functions Diagnostics](durable-functions-diagnostics.md#debugging).

-1. In the **Terminal** panel, copy the URL endpoint of your HTTP-triggered function.

- :::image type="content" source="media/durable-functions-create-first-csharp/functions-vscode-f5.png" alt-text="Screenshot of Azure local output window.":::

-1. Use a tool like [Postman](https://www.getpostman.com/) or [cURL](https://curl.haxx.se/), and then send an HTTP POST request to the URL endpoint.

- The response is the HTTP function's initial result, letting us know that the durable orchestration has started successfully. It isn't yet the end result of the orchestration. The response includes a few useful URLs. For now, let's query the status of the orchestration.

-1. Copy the URL value for `statusQueryGetUri`, paste it into the browser's address bar, and execute the request. Alternatively, you can also continue to use Postman to issue the GET request.

- The request will query the orchestration instance for the status. You must get an eventual response, which shows us that the instance has completed and includes the outputs or results of the durable function. It looks like:

- ```json

- {

- "name": "HelloOrchestration",

- "instanceId": "9a528a9e926f4b46b7d3deaa134b7e8a",

- "runtimeStatus": "Completed",

- "input": null,

- "customStatus": null,

- "output": [

- "Hello Tokyo!",

- "Hello Seattle!",

- "Hello London!"

- ],

- "createdTime": "2020-03-18T21:54:49Z",

- "lastUpdatedTime": "2020-03-18T21:54:54Z"

- }

- ```

-1. To stop debugging, press <kbd>Shift + F5</kbd> in Visual Studio Code.

-After you've verified that the function runs correctly on your local computer, it's time to publish the project to Azure.

-## Test your function in Azure

-1. Copy the URL of the HTTP trigger from the **Output** panel. The URL that calls your HTTP-triggered function must be in the following format:

- `https://<functionappname>.azurewebsites.net/api/HelloOrchestration_HttpStart`

-1. Paste this new URL for the HTTP request into your browser's address bar. You must get the same status response as before when using the published app.

-## Next steps

-You have used Visual Studio Code to create and publish a C# durable function app.

-> [!div class="nextstepaction"]

-> [Learn about common durable function patterns](durable-functions-overview.md#application-patterns)

-In this article, you learn how to use Visual Studio 2022 to locally create and test a "hello world" durable function. This function orchestrates and chains-together calls to other functions. You then publish the function code to Azure. These tools are available as part of the Azure development workload in Visual Studio 2022.

-## Prerequisites

-To complete this tutorial:

-* Install [Visual Studio 2022](https://visualstudio.microsoft.com/vs/). Make sure that the **Azure development** workload is also installed. Visual Studio 2019 also supports Durable Functions development, but the UI and steps differ.

-* Verify that you have the [Azurite Emulator](../../storage/common//storage-use-azurite.md) installed and running.

-## Create a function app project

-The Azure Functions template creates a project that can be published to a function app in Azure. A function app lets you group functions as a logical unit for easier management, deployment, scaling, and sharing of resources.

-1. In Visual Studio, select **New** > **Project** from the **File** menu.

-1. In the **Create a new project** dialog, search for `functions`, choose the **Azure Functions** template, and then select **Next**.

- :::image type="content" source="./media/durable-functions-create-first-csharp/functions-vs-new-project.png" alt-text="Screenshot of new project dialog to create a function in Visual Studio.":::

-1. Enter a **Project name** for your project, and select **OK**. The project name must be valid as a C# namespace, so don't use underscores, hyphens, or nonalphanumeric characters.

-1. Under **Additional information**, use the settings specified in the table that follows the image.

- :::image type="content" source="./media/durable-functions-create-first-csharp/functions-vs-new-function.png" alt-text="Screenshot of create a new Azure Functions Application dialog in Visual Studio.":::

- | Setting | Suggested value | Description |

- | | - |-- |

- | **Functions worker** | .NET 6 | Creates a function project that supports .NET 6 and the Azure Functions Runtime 4.0. For more information, see [How to target Azure Functions runtime version](../functions-versions.md). |

- | **Function** | Empty | Creates an empty function app. |

- | **Storage account** | Storage Emulator | A storage account is required for durable function state management. |

-1. Select **Create** to create an empty function project. This project has the basic configuration files needed to run your functions.

-## Add functions to the app

-The following steps use a template to create the durable function code in your project.

-1. Right-click the project in Visual Studio and select **Add** > **New Azure Function**.

- :::image type="content" source="./media/durable-functions-create-first-csharp/functions-vs-add-function.png" alt-text="Screenshot of Add new function.":::

-1. Verify **Azure Function** is selected from the add menu, enter a name for your C# file, and then select **Add**.

-1. Select the **Durable Functions Orchestration** template and then select **Add**.

- :::image type="content" source="./media/durable-functions-create-first-csharp/functions-vs-select-durable-template.png" alt-text="Screenshot of Select durable template.":::

-A new durable function is added to the app. Open the new *.cs* file to view the contents. This durable function is a simple function chaining example with the following methods:

-| Method | FunctionName | Description |

-| -- | | -- |

-| **`RunOrchestrator`** | `<file-name>` | Manages the durable orchestration. In this case, the orchestration starts, creates a list, and adds the result of three functions calls to the list. When the three function calls are complete, it returns the list. |

-| **`SayHello`** | `<file-name>_Hello` | The function returns a hello. It's the function that contains the business logic that is being orchestrated. |

-| **`HttpStart`** | `<file-name>_HttpStart` | An [HTTP-triggered function](../functions-bindings-http-webhook.md) that starts an instance of the orchestration and returns a check status response. |

-You can test it on your local computer now that you've created your function project and a durable function.

-## Test the function locally

-Azure Functions Core Tools lets you run an Azure Functions project on your local development computer. You're prompted to install these tools the first time you start a function from Visual Studio.

-1. To test your function, press <kbd>F5</kbd>. If prompted, accept the request from Visual Studio to download and install Azure Functions Core (CLI) tools. You may also need to enable a firewall exception so that the tools can handle HTTP requests.

-1. Copy the URL of your function from the Azure Functions runtime output.

- :::image type="content" source="./media/durable-functions-create-first-csharp/functions-vs-debugging.png" alt-text="Screenshot of Azure local runtime.":::

-1. Paste the URL for the HTTP request into your browser's address bar and execute the request. The following shows the response in the browser to the local GET request returned by the function:

- :::image type="content" source="./media/durable-functions-create-first-csharp/functions-vs-status.png" alt-text="Screenshot of the browser window with statusQueryGetUri called out.":::

- The response is the HTTP function's initial result, letting us know that the durable orchestration has started successfully. It isn't yet the end result of the orchestration. The response includes a few useful URLs. For now, let's query the status of the orchestration.

-1. Copy the URL value for `statusQueryGetUri`, paste it into the browser's address bar, and execute the request.

- The request will query the orchestration instance for the status. You must get an eventual response that looks like the following. This output shows us the instance has completed and includes the outputs or results of the durable function.

- ```json

- {

- "name": "Durable",

- "instanceId": "d495cb0ac10d4e13b22729c37e335190",

- "runtimeStatus": "Completed",

- "input": null,

- "customStatus": null,

- "output": [

- "Hello Tokyo!",

- "Hello Seattle!",

- "Hello London!"

- ],

- "createdTime": "2019-11-02T07:07:40Z",

- "lastUpdatedTime": "2019-11-02T07:07:52Z"

- }

- ```

-1. To stop debugging, press <kbd>Shift + F5</kbd>.

-After you've verified that the function runs correctly on your local computer, it's time to publish the project to Azure.

-## Publish the project to Azure

-You must have a function app in your Azure subscription before publishing your project. You can create a function app right from Visual Studio.

-## Test your function in Azure

-1. Copy the base URL of the function app from the Publish profile page. Replace the `localhost:port` portion of the URL you used when testing the function locally with the new base URL.

- The URL that calls your durable function HTTP trigger must be in the following format:

- `https://<APP_NAME>.azurewebsites.net/api/<FUNCTION_NAME>_HttpStart`

-2. Paste this new URL for the HTTP request into your browser's address bar. You must get the same status response as before when using the published app.

-## Next steps

-You have used Visual Studio to create and publish a C# durable function app.

-> [!div class="nextstepaction"]

-> [Learn about common durable function patterns](durable-functions-overview.md#application-patterns)

-> * If you are developing durable functions in C#, you should instead consider [Visual Studio 2019 development](durable-functions-create-first-csharp.md).

-description: Create and publish a C# Azure Durable Function running in the isolated worker using Visual Studio or Visual Studio Code.

-# Create your first Durable Function in C#

-Durable Functions is an extension of [Azure Functions](../functions-overview.md) that lets you write stateful functions in a serverless environment. The extension manages state, checkpoints, and restarts for you.

-Like Azure Functions, Durable Functions supports two process models for .NET class library functions:

-To learn more about the two processes, refer to [Differences between in-process and isolated worker process .NET Azure Functions](../dotnet-isolated-in-process-differences.md).

-In this article, you learn how to use Visual Studio Code to locally create and test a "hello world" durable function. This function orchestrates and chains together calls to other functions. You can then publish the function code to Azure. These tools are available as part of the Visual Studio Code [Azure Functions extension](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions).

-To complete this tutorial:

-* Install [Visual Studio Code](https://code.visualstudio.com/download).

-* Install the following Visual Studio Code extensions:

-* Make sure that you have the latest version of the [Azure Functions Core Tools](../functions-run-local.md).

-* Durable Functions require an Azure storage account. You need an Azure subscription.

-* Make sure that you have version 3.1 or a later version of the [.NET Core SDK](https://dotnet.microsoft.com/download) installed.

-## <a name="create-an-azure-functions-project"></a>Create your local project

-In this section, you use Visual Studio Code to create a local Azure Functions project.

-1. In Visual Studio Code, press <kbd>F1</kbd> (or <kbd>Ctrl/Cmd+Shift+P</kbd>) to open the command palette. In the command palette, search for and select `Azure Functions: Create New Project...`.

- :::image type="content" source="media/durable-functions-create-first-csharp/functions-vscode-create-project.png" alt-text="Screenshot of create a function project window.":::

-1. Choose an empty folder location for your project and choose **Select**.

-1. Follow the prompts and provide the following information:

- | Prompt | Value | Description |

- | Select a language for your function app project | C# | Create a local C# Functions project. |

- | Select a version | Azure Functions v4 | You only see this option when the Core Tools aren't already installed. In this case, Core Tools are installed the first time you run the app. |

- | Select a .NET runtime | .NET 8.0 isolated | Creates a function project that supports .NET 8 running in isolated worker process and the Azure Functions Runtime 4.0. For more information, see [How to target Azure Functions runtime version](../functions-versions.md). |

- | Select a template for your project's first function | Durable Functions Orchestration | Create a Durable Functions orchestration |

- | Choose a durable storage type | Azure Storage | The default storage provider for Durable Functions. See [Durable Functions storage providers](./durable-functions-storage-providers.md) for more details. |

- | Provide a function name | HelloOrchestration | Name of the orchestration function |

- | Provide a namespace | Company.Function | Namespace for the generated class |

- | Select how you would like to open your project | Open in current window | Reopens Visual Studio Code in the folder you selected. |

-Visual Studio Code installs the Azure Functions Core Tools if needed. 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.

-There's also a file called *HelloOrchestration.cs*, which contains the basic building blocks of a Durable Functions app:

-| **`HelloOrchestration`** | Defines the durable orchestration. In this case, the orchestration starts, creates a list, and adds the result of three functions calls to the list. When the three function calls are complete, it returns the list. |

-| **`SayHello`** | Simple function returning hello. It's the function containing the business logic that is being orchestrated. |

-| **`HelloOrchestration_HttpStart`** | An [HTTP-triggered function](../functions-bindings-http-webhook.md) that starts an instance of the orchestration and returns a check status response. |

-You can find more details about these functions in [Durable Functions types and features](./durable-functions-types-features-overview.md).

-You can use [Azurite](../../storage/common/storage-use-azurite.md?tabs=visual-studio-code), which is an emulator for Azure Storage, to test the function locally. Do this by setting `AzureWebJobStorage` in _local.settings.json_ to `UseDevelopmentStorage=true`:

-You can install the Azurite extension on Visual Studio Code and start it by running `Azurite: Start` in the command palette.

-There are other storage options you can use for your Durable Functions app. See [Durable Functions storage providers](durable-functions-storage-providers.md) to learn more about different storage options and what benefits they provide.

-Azure Functions Core Tools lets you run an Azure Functions project locally. You're prompted to install these tools the first time you start a function from Visual Studio Code.

-1. To test your function, set a breakpoint in the `SayHello` activity function code and press <kbd>F5</kbd> to start the function app project. Output from Core Tools is displayed in the **Terminal** panel.

- > For more information on debugging, see [Durable Functions Diagnostics](durable-functions-diagnostics.md#debugging).

- > [!NOTE]

- > If you encounter a "No job functions found" error, please [update your Azure Functions Core Tools installation to the latest version](./../functions-core-tools-reference.md). Older versions of core tools do not support .NET isolated.

-1. In the **Terminal** panel, copy the URL endpoint of your HTTP-triggered function.

- :::image type="content" source="media/durable-functions-create-first-csharp/isolated-functions-vscode-debugging.png" alt-text="Screenshot of Azure local output window.":::

-1. Use a tool like [Postman](https://www.getpostman.com/) or [cURL](https://curl.haxx.se/), and then send an HTTP POST request to the URL endpoint.

- The response is the HTTP function's initial result, letting us know that the durable orchestration has started successfully. It isn't yet the end result of the orchestration. The response includes a few useful URLs.

-1. Copy the URL value for `statusQueryGetUri`, paste it into the browser's address bar, and execute the request. Alternatively, you can also continue to use Postman to issue the GET request.

- The request will query the orchestration instance for the status. You should see that the instance has completed and includes the outputs or results of the durable function. It looks like:

-

- > [!NOTE]

- > You can observe the [replay behavior](./durable-functions-orchestrations.md#reliability) of Durable Functions through breakpoints. Because this is an important concept to understand, it's highly recommended that you read the linked article.

-1. To stop debugging, press <kbd>Shift + F5</kbd> in Visual Studio Code.

-After you've verified that the function runs correctly on your local computer, it's time to publish the project to Azure.

-1. Copy the URL of the HTTP trigger from the **Output** panel. The URL that calls your HTTP-triggered function must be in the following format:

- `https://<functionappname>.azurewebsites.net/api/HelloOrchestration_HttpStart`

-1. Paste this new URL for the HTTP request into your browser's address bar. You must get the same status response as before when using the published app.

-## Next steps

-You have used Visual Studio Code to create and publish a C# durable function app.

-> [!div class="nextstepaction"]

-> [Learn about common durable function patterns](durable-functions-overview.md#application-patterns)

-In this article, you will learn how to use Visual Studio 2022 to locally create and test a "hello world" durable function that run in the isolated worker process. This function orchestrates and chains-together calls to other functions. You then publish the function code to Azure. These tools are available as part of the Azure development workload in Visual Studio 2022.

-To complete this tutorial:

-* Install [Visual Studio 2022](https://visualstudio.microsoft.com/vs/). Make sure that the **Azure development** workload is also installed. Visual Studio 2019 also supports Durable Functions development, but the UI and steps differ.

-* Verify that you have the [Azurite Emulator](../../storage/common/storage-use-azurite.md) installed and running.

-The Azure Functions template creates a project that can be published to a function app in Azure. A function app lets you group functions as a logical unit for easier management, deployment, scaling, and sharing of resources.

-1. In Visual Studio, select **New** > **Project** from the **File** menu.

-2. In the **Create a new project** dialog, search for `functions`, choose the **Azure Functions** template, and then select **Next**.

- :::image type="content" source="./media/durable-functions-create-first-csharp/functions-isolated-vs-new-project.png" alt-text="Screenshot of new project dialog in Visual Studio.":::

-3. Enter a **Project name** for your project, and select **OK**. The project name must be valid as a C# namespace, so don't use underscores, hyphens, or nonalphanumeric characters.

-4. Under **Additional information**, use the settings specified in the table that follows the image.

- :::image type="content" source="./media/durable-functions-create-first-csharp/functions-isolated-vs-new-function.png" alt-text="Screenshot of create a new Azure Functions Application dialog in Visual Studio.":::

- | Setting | Suggested value | Description |

- | **Functions worker** | .NET 8 Isolated (Long Term Support) | Creates a function project that supports .NET 8 running in isolated worker process and the Azure Functions Runtime 4.0. For more information, see [How to target Azure Functions runtime version](../functions-versions.md). |

- | **Function** | Durable Functions Orchestration | Creates a Durable Functions orchestration. |

-> [!NOTE]

-> If you don't see .NET 8 isolated in the Functions worker drop-down, it could be because you don't have the latest Azure Functions toolsets and templates. Go to Tools -> Options -> Projects and Solutions -> Azure Functions -> Check for updates to download the latest.

-5. Make sure the box for _"Use Azurite for runtime storage account (AzureWebJobStorage)"_ is checked. This will use Azurite emulator. Select **Create** to create a function project with a Durable Functions orchestration template. This project has the basic configuration files needed to run your functions.

-> [!NOTE]

-> There are other storage options you can use for your Durable Functions app. See [Durable Functions storage providers](durable-functions-storage-providers.md) to learn more about different storage options and what benefits they provide.

-In your function app, you'll see a file called *Function1.cs* containing three functions, which are the basic building blocks of a Durable Functions:

-| **`RunOrchestrator`** | Defines the durable orchestration. In this case, the orchestration starts, creates a list, and adds the result of three functions calls to the list. When the three function calls are complete, it returns the list. |

-| **`SayHello`** | The function returns a hello. It's the function that contains the business logic that is being orchestrated. |

-| **`HttpStart`** | An [HTTP-triggered function](../functions-bindings-http-webhook.md) that starts an instance of the orchestration and returns a check status response. |

-You can find more details about these functions in [Durable Functions types and features](./durable-functions-types-features-overview.md).

-Azure Functions Core Tools lets you run an Azure Functions project on your local development computer. You're prompted to install these tools the first time you start a function from Visual Studio.

-1. To test your function, set a breakpoint in the `SayHello` activity function code and press <kbd>F5</kbd>. If prompted, accept the request from Visual Studio to download and install Azure Functions Core (CLI) tools. You may also need to enable a firewall exception so that the tools can handle HTTP requests.

-> [!NOTE]

-> For more information on debugging, see [Durable Functions Diagnostics](durable-functions-diagnostics.md#debugging).

-2. Copy the URL of your function from the Azure Functions runtime output.

- :::image type="content" source="./media/durable-functions-create-first-csharp/isolated-functions-vs-debugging.png" alt-text="Screenshot of Azure local runtime.":::

-3. Paste the URL for the HTTP request into your browser's address bar and execute the request. The following shows the response in the browser to the local GET request returned by the function:

- :::image type="content" source="./media/durable-functions-create-first-csharp/isolated-functions-vs-status.png" alt-text="Screenshot of the browser window with statusQueryGetUri called out.":::

- The response is the HTTP function's initial result, letting us know that the durable orchestration has started successfully. It isn't yet the end result of the orchestration. The response includes a few useful URLs.

-

- At this point, your breakpoint in the activity function should be hit because the orchestration has started. Step through it to get a response for the status of the orchestration.

-4. Copy the URL value for `statusQueryGetUri`, paste it into the browser's address bar, and execute the request.

- The request will query the orchestration instance for the status. You should see that the instance has completed and includes the outputs of your activity invocations. It looks like:

-> [!NOTE]

-> You can observe the [replay behavior](./durable-functions-orchestrations.md#reliability) of Durable Functions through breakpoints. Because this is an important concept to understand, it's highly recommended that you read the linked article.

-5. To stop debugging, press <kbd>Shift + F5</kbd>.

-After you've verified that the function runs correctly on your local computer, it's time to publish the project to Azure.

-You must have a function app in your Azure subscription before publishing your project. You can create a function app right from Visual Studio.

-1. Copy the base URL of the function app from the Publish profile page. Replace the `localhost:port` portion of the URL you used when testing the function locally with the new base URL.

-2. Paste this new URL for the HTTP request into your browser's address bar. You must get the same status response as before when using the published app.

-## Next steps

-You have used Visual Studio to create and publish a C# Durable Functions app.

-> [!div class="nextstepaction"]

-> [Learn about common durable function patterns](durable-functions-overview.md#application-patterns)

-* [Complete the quickstart article](durable-functions-create-first-csharp.md)

-* Monitors run on intervals, not schedules: a timer trigger *runs* every hour; a monitor *waits* one hour between actions. A monitor's actions will not overlap unless specified, which can be important for long-running tasks.

-The first thing you need is a Weather Underground account. You can create one for free at [https://www.wunderground.com/signup](https://www.wunderground.com/signup). Once you have an account, you will need to acquire an API key. You can do so by visiting [https://www.wunderground.com/weather/api](https://www.wunderground.com/weather/api/?MR=1), then selecting Key Settings. The Stratus Developer plan is free and sufficient to run this sample.

-The orchestrator requires a location to monitor and a phone number to send a message to when the whether becomes clear at the location. This data is passed to the orchestrator as a strongly typed `MonitorRequest` object.

-Here is the code that implements the function:

-1. Gets the **MonitorRequest** consisting of the *location* to monitor and the *phone number* to which it will send an SMS notification.

-Multiple orchestrator instances can run simultaneously by calling the orchestrator function multiple times. The location to monitor and the phone number to send an SMS alert to can be specified. Finally, do note that the orchestrator function is *not* running while waiting for the timer, so you will not get charged for it.

-And here is the implementation.

-And here is the code that sends the SMS message:

-The **E3_Monitor** instance starts and queries the current weather conditions for the requested location. If the weather is clear, it calls an activity function to send an alert; otherwise, it sets a timer. When the timer expires, the orchestration will resume.

-The orchestration completes once its timeout is reached or clear skies are detected. You can also use the `terminate` API inside another function or invoke the **terminatePostUri** HTTP POST webhook referenced in the 202 response above. To use the webhook, replace `{text}` with the reason for the early termination. The HTTP POST URL will look roughly as follows:

-This sample has demonstrated how to use Durable Functions to monitor an external source's status using [durable timers](durable-functions-timers.md) and conditional logic. The next sample shows how to use external events and [durable timers](durable-functions-timers.md) to handle human interaction.

-> [Run the human interaction sample](durable-functions-phone-verification.md)

-Like Azure Functions, there are templates to help you develop Durable Functions using [Visual Studio](durable-functions-create-first-csharp.md), [Visual Studio Code](quickstart-js-vscode.md), and the [Azure portal](durable-functions-create-portal.md).

-Durable Functions provides **built-in support** for this pattern, simplifying or even removing the code you need to write to interact with long-running function executions. For example, the Durable Functions quickstart samples ([C#](durable-functions-create-first-csharp.md), [JavaScript](quickstart-js-vscode.md), [TypeScript](quickstart-ts-vscode.md), [Python](quickstart-python-vscode.md), [PowerShell](quickstart-powershell-vscode.md), and [Java](quickstart-java.md)) show a simple REST command that you can use to start new orchestrator function instances. After an instance starts, the extension exposes webhook HTTP APIs that query the orchestrator function status.

-* [C# using Visual Studio 2019](durable-functions-create-first-csharp.md)

-Function chaining refers to the pattern of executing a sequence of functions in a particular order. Often the output of one function needs to be applied to the input of another function. This article describes the chaining sequence that you create when you complete the Durable Functions quickstart ([C#](durable-functions-create-first-csharp.md), [JavaScript](quickstart-js-vscode.md), [TypeScript](quickstart-ts-vscode.md), [Python](quickstart-python-vscode.md), [PowerShell](quickstart-powershell-vscode.md), or [Java](quickstart-java.md)). For more information about Durable Functions, see [Durable Functions overview](durable-functions-overview.md).

-To get started, create your first durable function in [C#](durable-functions-create-first-csharp.md), [JavaScript](quickstart-js-vscode.md), [Python](quickstart-python-vscode.md), [PowerShell](quickstart-powershell-vscode.md), or [Java](quickstart-java.md).

-description: Create an Azure Durable Function in Java

-# Create your first durable function in Java

-_Durable Functions_ is an extension of [Azure Functions](../functions-overview.md) that lets you write stateful functions in a serverless environment. The extension manages state, checkpoints, and restarts for you.

-In this quickstart, you'll learn how to create and test a "Hello World" Durable Functions app in Java. The most basic Durable Functions app contains the following three functions:

-This quickstart will show you how to create this "Hello World" app, which you can do in different ways. Use the selector above to choose your preferred approach.

-To complete this tutorial, you need:

- - For Azure Functions 4.x, Core Tools **v4.0.4915** or newer is required.

-Add the following to your `pom.xml`:

-## Add required JSON files

-Add a `host.json` file to your project directory. It should look similar to the following:

-Durable Functions needs a storage provider to store runtime state. Add a `local.settings.json` file to your project directory to configure the storage provider. To use Azure Storage as the provider, set the value of `AzureWebJobsStorage` to the connection string of your Azure Storage account:

-The sample code below shows a simple example of each:

- * This is the activity function that gets invoked by the orchestrator function.

-## Create a local project with Maven command

-1. Run the following command to generate a project with the basic functions of a Durable Functions app:

-```powershell

-```cmd

-2. Follow the prompts and provide the following information:

- | Prompt | Value |

- | | -- |

- | **groupId** | `com.function` |

- | **artifactId** | `myDurableFunction` |

- | **version** | `1.0-SNAPSHOT` |

- | **package** | `com.function` |

- | **Y** | Hit _enter_ to confirm |

-Now you have a local project generated with the three functions that are needed for a basic Durable Functions app.

-Please check to ensure you have `com.microsoft:durabletask-azure-functions` as a dependency in your `pom.xml`.

-## Configure backend storage provider

-Durable Functions needs a storage provider to store runtime state. You can configure to use Azure Storage as the storage provider in `local.settings.json` by providing the connection string of your Azure Storage account as the value to `AzureWebJobsStorage`:

-```

-## Create your local project

-1. In Visual Studio Code, press F1 (or Ctrl/Cmd+Shift+P) to open the command palette. In the command palette, search for and select `Azure Functions: Create New Project...`.

- 

-2. Choose an empty folder location for your project and choose **Select**.

-3. Follow the prompts and provide the following information:

- |Prompt|Value|

- |**Select a language**| Choose `Java`.|

- |**Select a version of Java**| Choose `Java 8` or newer, the Java version on which your functions run in Azure. Choose a Java version that you've verified locally. |

- | **Provide a group ID** | `com.function`. |

- | **Provide an artifact ID** | `myDurableFunction`. |

- | **Provide a version** | `1.0-SNAPSHOT`. |

- | **Provide a package name** | `com.function`. |

- | **Provide an app name** | `myDurableFunction`. |

- | **Select the build tool for Java project** | Choose `Maven`.|

- |**Select how you would like to open your project**| Choose `Open in new window`.|

-You now have a project with an example HTTP function. You can remove this function if you'd like because we'll be adding the basic functions of a Durable Functions app in the next step.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-2. Select `Change template filter` to `All`.

-3. Follow the prompts and provide the following information:

- | Prompt | Value |

- | | -- |

- | **Select a template for your function**| DurableFunctionsOrchestration |

- | **Provide a package name** | `com.function`

- | **Provide a function name** | `DurableFunctionsOrchestrator` |

-4. Choose `Select storage account` on the pop-up window asking to set up storage account information and follow the prompts.

-You should now have the three basic functions for a Durable Functions app generated.

-Add the following dependency to your `pom.xml`:

-Add the `extensions` property to your `host.json`:

-Azure Functions Core Tools lets you run an Azure Functions project on your local development computer.

-> Durable Functions for Java requires Azure Functions Core Tools v4.0.4915 or newer. You can see which version is installed by running the `func --version` command from the terminal.

-1. If you are using Visual Studio Code, open a new terminal window and run the following commands to build the project:

- ```bash

- mvn clean package

- ```

-

- Then run the durable function:

-

- ```bash

- mvn azure-functions:run

- ```

-2. In the Terminal panel, copy the URL endpoint of your HTTP-triggered function.

- 

-3. Using a tool like [Postman](https://www.getpostman.com/) or [cURL](https://curl.haxx.se/), send an HTTP POST request to the URL endpoint. You should get a response similar to the following:

-

- The response is the initial result from the HTTP function letting you know the durable orchestration has started successfully. It is not yet the end result of the orchestration. The response includes a few useful URLs. For now, let's query the status of the orchestration.

-4. Copy the URL value for `statusQueryGetUri` and paste it in the browser's address bar and execute the request. Alternatively you can also continue to use Postman or cURL to issue the GET request.

- The request will query the orchestration instance for the status. You should get an eventual response, which shows us the instance has completed, and includes the outputs or results of the durable function. It looks like:

-description: Create and publish an Azure Durable Function in JavaScript using Visual Studio Code.

-# Create your first durable function in JavaScript

-*Durable Functions* is an extension of [Azure Functions](../functions-overview.md) that lets you write stateful functions in a serverless environment. The extension manages state, checkpoints, and restarts for you.

-In this article, you learn how to use the Visual Studio Code Azure Functions extension to locally create and test a "hello world" durable function. This function will orchestrate and chain together calls to other functions. You then publish the function code to Azure.

-

-To complete this tutorial:

-* Install [Visual Studio Code](https://code.visualstudio.com/download).

-* Install the [Azure Functions](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions) VS Code extension

-* Install the [Azure Functions](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions) VS Code extension version `1.10.4` or above.

-* Make sure you have the latest version of the [Azure Functions Core Tools](../functions-run-local.md).

-* Make sure you have [Azure Functions Core Tools](../functions-run-local.md) version `v4.0.5382` or above.

-* Durable Functions require an Azure storage account. You need an Azure subscription.

-* Make sure that you have version 16.x+ of [Node.js](https://nodejs.org/) installed.

-* Make sure that you have version 18.x+ of [Node.js](https://nodejs.org/) installed.

-## <a name="create-an-azure-functions-project"></a>Create your local project

-In this section, you use Visual Studio Code to create a local Azure Functions project.

-1. In Visual Studio Code, press <kbd>F1</kbd> (or <kbd>Ctrl/Cmd+Shift+P</kbd>) to open the command palette. In the command palette, search for and select `Azure Functions: Create New Project...`.

- 

-2. Choose an empty folder location for your project and choose **Select**.

-3. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a language for your function app project | JavaScript | Create a local Node.js Functions project. |

- | Select a JavaScript programming model | Model V3 | Choose the V3 programming model. |

- | Select a version | Azure Functions v4 | You only see this option when the Core Tools aren't already installed. In this case, Core Tools are installed the first time you run the app. |

- | Select a template for your project's first function | Skip for now | |

- | Select how you would like to open your project | Open in current window | Reopens VS Code in the folder you selected. |

-3. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a language for your function app project | JavaScript | Create a local Node.js Functions project. |

- | Select a JavaScript programming model | Model V4 | Choose the V4 programming model. |

- | Select a version | Azure Functions v4 | You only see this option when the Core Tools aren't already installed. In this case, Core Tools are installed the first time you run the app. |

- | Select a template for your project's first function | Skip for now | |

- | Select how you would like to open your project | Open in current window | Reopens VS Code in the folder you selected. |

-Visual Studio Code installs the Azure Functions Core Tools, if needed. 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.

-A `package.json` file is also created in the root folder.

-To work with Durable Functions in a Node.js function app, you use a library called `durable-functions`.

-To use the V4 programming model, you need to install the preview `v3.x` version of `durable-functions`.

-1. Use the *View* menu or <kbd>Ctrl + Shift + `</kbd> to open a new terminal in VS Code.

-2. Install the `durable-functions` npm package by running `npm install durable-functions` in the root directory of the function app.

-2. Install the `durable-functions` npm package preview version by running `npm install durable-functions@preview` in the root directory of the function app.

-## Creating your functions

-The most basic Durable Functions app contains three functions:

-* *Orchestrator function* - describes a workflow that orchestrates other functions.

-* *Activity function* - called by the orchestrator function, performs work, and optionally returns a value.

-* *Client function* - a regular Azure Function that starts an orchestrator function. This example uses an HTTP triggered function.

-You use a template to create the durable function code in your project.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions orchestrator | Create a Durable Functions orchestration |

- | Choose a durable storage type. | Azure Storage (Default) | Select the storage backend used for Durable Functions. |

- | Provide a function name | HelloOrchestrator | Name of your durable function |

-You've added an orchestrator to coordinate activity functions. Open *HelloOrchestrator/index.js* to see the orchestrator function. Each call to `context.df.callActivity` invokes an activity function named `Hello`.

-Next, you'll add the referenced `Hello` activity function.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions activity | Create an activity function |

- | Provide a function name | Hello | Name of your activity function |

-You've added the `Hello` activity function that is invoked by the orchestrator. Open *Hello/index.js* to see that it's taking a name as input and returning a greeting. An activity function is where you perform "the real work" in your workflow: work such as making a database call or performing some non-deterministic computation.

-Finally, you'll add an HTTP triggered function that starts the orchestration.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions HTTP starter | Create an HTTP starter function |

- | Provide a function name | DurableFunctionsHttpStart | Name of your activity function |

- | Authorization level | Anonymous | For demo purposes, allow the function to be called without authentication |

-You've added an HTTP triggered function that starts an orchestration. Open *DurableFunctionsHttpStart/index.js* to see that it uses `client.startNew` to start a new orchestration. Then it uses `client.createCheckStatusResponse` to return an HTTP response containing URLs that can be used to monitor and manage the new orchestration.

-You now have a Durable Functions app that can be run locally and deployed to Azure.

-One of the benefits of the V4 Programming Model is the flexibility of where you write your functions.

-In the V4 Model, you can use a single template to create all three functions in one file in your project.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions orchestrator | Create a file with a Durable Functions orchestration, an Activity function, and a Durable Client starter function. |

- | Choose a durable storage type | Azure Storage (Default) | Select the storage backend used for Durable Functions. |

- | Provide a function name | hello | Name used for your durable functions |

-You've created an orchestrator called `helloOrchestrator` to coordinate activity functions. Each call to `context.df.callActivity` invokes an activity function called `hello`.

-You've also added the `hello` activity function that is invoked by the orchestrator. In the same file, you can see that it's taking a name as input and returning a greeting. An activity function is where you perform "the real work" in your workflow: work such as making a database call or performing some non-deterministic computation.

-Lastly, you've also added an HTTP triggered function that starts an orchestration. In the same file, you can see that it uses `client.startNew` to start a new orchestration. Then it uses `client.createCheckStatusResponse` to return an HTTP response containing URLs that can be used to monitor and manage the new orchestration.

-You now have a Durable Functions app that can be run locally and deployed to Azure.

-Azure Functions Core Tools lets you run an Azure Functions project on your local development computer. You're prompted to install these tools the first time you start a function from Visual Studio Code.

-1. To test your function, set a breakpoint in the `Hello` activity function code (*Hello/index.js*). Press F5 or select `Debug: Start Debugging` from the command palette to start the function app project. Output from Core Tools is displayed in the **Terminal** panel.

-1. To test your function, set a breakpoint in the `hello` activity function code (*src/functions/hello.js*). Press F5 or select `Debug: Start Debugging` from the command palette to start the function app project. Output from Core Tools is displayed in the **Terminal** panel.

- > [!NOTE]

- > Refer to the [Durable Functions Diagnostics](durable-functions-diagnostics.md#debugging) for more information on debugging.

-2. Durable Functions requires an Azure Storage account to run. When VS Code prompts you to select a storage account, choose **Select storage account**.

- 

-3. Following the prompts, provide the following information to create a new storage account in Azure.

-4. In the **Terminal** panel, copy the URL endpoint of your HTTP-triggered function.

- 

-5. Using your browser, or a tool like [Postman](https://www.getpostman.com/) or [cURL](https://curl.haxx.se/), send an HTTP POST request to the URL endpoint. Replace the last segment with the name of the orchestrator function (`HelloOrchestrator`). The URL should be similar to `http://localhost:7071/api/orchestrators/HelloOrchestrator`.

-5. Using your browser, or a tool like [Postman](https://www.getpostman.com/) or [cURL](https://curl.haxx.se/), send an HTTP POST request to the URL endpoint. Replace the last segment with the name of the orchestrator function (`helloOrchestrator`). The URL should be similar to `http://localhost:7071/api/orchestrators/helloOrchestrator`.

- The response is the initial result from the HTTP function letting you know the durable orchestration has started successfully. It is not yet the end result of the orchestration. The response includes a few useful URLs. For now, let's query the status of the orchestration.

-6. Copy the URL value for `statusQueryGetUri` and paste it in the browser's address bar and execute the request. Alternatively you can also continue to use Postman to issue the GET request.

- The request queries the orchestration instance for the status. You should get an eventual response, which shows us the instance has completed, and includes the outputs or results of the durable function. It looks like:

- ::: zone pivot="nodejs-model-v3"

- ::: zone-end

- ::: zone pivot="nodejs-model-v4"

-7. To stop debugging, press **Shift + F5** in VS Code.

-After you've verified that the function runs correctly on your local computer, it's time to publish the project to Azure.

-> To use the V4 node programming model, make sure your app is running on at least version 4.25 of the Azure Functions runtime.

-1. Copy the URL of the HTTP trigger from the **Output** panel. The URL that calls your HTTP-triggered function should be in this format: `https://<functionappname>.azurewebsites.net/api/orchestrators/HelloOrchestrator`

-1. Copy the URL of the HTTP trigger from the **Output** panel. The URL that calls your HTTP-triggered function should be in this format: `https://<functionappname>.azurewebsites.net/api/orchestrators/helloOrchestrator`

-2. Paste this new URL for the HTTP request into your browser's address bar. You should get the same status response as before when using the published app.

-## Next steps

-You have used Visual Studio Code to create and publish a JavaScript durable function app.

-> [!div class="nextstepaction"]

-> [Learn about common durable function patterns](durable-functions-overview.md#application-patterns)

-description: Configure a Durable Functions app to use MSSQL

-# Configure Durable Functions with the Microsoft SQL Server (MSSQL) storage provider

-Durable Functions supports several [storage providers](durable-functions-storage-providers.md), also known as _backends_, for storing orchestration and entity runtime state. By default, new projects are configured to use the [Azure Storage provider](durable-functions-storage-providers.md#azure-storage). In this article, we walk through how to configure a Durable Functions app to utilize the [MSSQL storage provider](durable-functions-storage-providers.md#mssql).

-> [!NOTE]

-> The MSSQL backend was designed to maximize application portability and control over your data. It uses [Microsoft SQL Server](https://www.microsoft.com/sql-server/) to persist all task hub state so that users get the benefits of modern, enterprise-grade DBMS infrastructure. To learn more about when to use the MSSQL storage provider, see the [storage providers](durable-functions-storage-providers.md) documentation.

-## Note on data migration

-Migration of [Task Hub data](durable-functions-task-hubs.md) across storage providers isn't currently supported. Function apps with existing runtime data will start with a fresh, empty task hub after switching to the MSSQL backend. Similarly, the task hub contents created with MSSQL can't be preserved when switching to a different storage provider.

-The following steps assume that you're starting with an existing Durable Functions app and are familiar with how to operate it.

-In particular, this quickstart assumes that you have already:

-1. Created an Azure Functions project on your local machine.

-2. Added Durable Functions to your project with an [orchestrator function](durable-functions-bindings.md#orchestration-trigger) and a [client function](durable-functions-bindings.md#orchestration-client) that triggers it.

-3. Configured the project for local debugging.

-If this isn't the case, we suggest you start with one of the following articles, which provides detailed instructions on how to achieve all the requirements above:

-> If your app uses [Extension Bundles](../functions-bindings-register.md#extension-bundles), you should ignore this section as Extension Bundles removes the need for manual Extension management.

-You need to install the latest version of the MSSQL storage provider Extension on NuGet, which for .NET means adding a reference to it in your `.csproj` file and building the project. You can also use the [`dotnet add package`](/dotnet/core/tools/dotnet-add-package) command to add extension packages.

-The Extension package to install depends on the .NET worker you're using:

-You can install the Extension using the following [Azure Functions Core Tools CLI](../functions-run-local.md#install-the-azure-functions-core-tools) command

-For more information on installing Azure Functions Extensions via the Core Tools CLI, see [func extensions install](../functions-core-tools-reference.md#func-extensions-install).

-## Set up your Database

-> If you already have an MSSQL-compatible database, you may skip this section and its sub-section on setting up a Docker-based local database.

-As the MSSQL backend is designed for portability, you have several options to set up your backing database. For example, you can set up an on-premises SQL Server instance, use a fully managed [Azure SQL DB](/azure/azure-sql/database/sql-database-paas-overview), or use any other SQL Server-compatible hosting option.

-You can also do local, offline development with [SQL Server Express](https://www.microsoft.com/sql-server/sql-server-downloads) on your local Windows machine or use [SQL Server Docker image](https://hub.docker.com/_/microsoft-mssql-server) running in a Docker container. For ease of setup, this article focuses on the latter.

-### Set up your local Docker-based SQL Server

-To run these steps, you need a [Docker](https://www.docker.com/products/docker-desktop/) installation on your local machine. Below are PowerShell commands that you can use to set up a local SQL Server database on Docker. Note that PowerShell can be installed on Windows, macOS, or Linux using the installation instructions [here](/powershell/scripting/install/installing-powershell).

-# run the image, providing some basic setup parameters

-After running these commands, you should have a local SQL Server running on Docker and listening on port `1443`. If port `1443` conflicts with another service, you can rerun these commands after changing the variable `$port` to a different value.

-> To stop and delete a running container, you may use `docker stop <containerName>` and `docker rm <containerName>` respectively. You may use these commands to re-create your container, and to stop if after you're done with this quickstart. For more assistance, try `docker --help`.

-To validate your database installation, you can query for your new SQL database using the following Docker command:

-If the database setup completed successfully, you should see the name of your created database (for example, `DurableDB`) in the command-line output.

-The MSSQL backend needs a connection string to your database. How to obtain a connection string largely depends on your specific MSSQL Server provider. Review the documentation of your specific provider for information on how to obtain a connection string.

-Using the previous Docker commands, without changing any parameters, your connection string should be:

-```

-After obtaining your connection string, add it to a variable in `local.settings.json` so it can be used during local development.

-Below is an example `local.settings.json` assigning the default Docker-based SQL Server's connection string to the variable `SQLDB_Connection`.

-> The value of `FUNCTIONS_WORKER_RUNTIME` is dependent on your programming language of choice. For more information, please see its [reference docs](../functions-app-settings.md#functions_worker_runtime).

-Edit the storage provider section of the `host.json` file so it sets the `type` to `mssql`. You must also specify the connection string variable name, `SQLDB_Connection`, under `connectionStringName`. Set `createDatabaseIfNotExists` to `true`; this setting creates a database named `DurableDB` if one doesn't already exist, with collation `Latin1_General_100_BIN2_UTF8`.

-The snippet above is a fairly *minimal* `host.json` example. Later, you may want to consider [other parameters](https://microsoft.github.io/durabletask-mssql/#/quickstart?id=hostjson-configuration).

-Your app is now ready for local development: You can start the Function app to test it. One way to do this is to run `func host start` on your application's root and executing a simple orchestrator Function.

-While the function app is running, it updates runtime state in the configured SQL database. You can test this is working as expected using your SQL query interface. For example, in our docker-based local SQL server container, you can view the state of your orchestration instances with the following `docker` command:

-After running an orchestration, the previous query should return something like this:

-```

-## Run your app on Azure

-To run your app in Azure, you'll need a publicly accessible SQL Server instance. You can obtain one by creating an Azure SQL database.

-> If you already have an Azure SQL database, or some other publicly accessible SQL Server you would like to use, you may skip to the next section.

-You can follow [these](/azure/azure-sql/database/single-database-create-quickstart) instructions to create an Azure SQL database on the portal. When configuring the database, make sure to set the *Database collation* (under _Additional settings_) to `Latin1_General_100_BIN2_UTF8`.

-You may obtain your Azure SQL database's connection string by navigating to the database's blade in the Azure portal. Then, under **Settings**, select **Connection strings** and obtain the **ADO.NET** connection string. Make sure to provide your password in the template provided.

-Below is an example of the portal view for obtaining the Azure SQL connection string.

-

-In the Azure portal, the connection string has the database's password removed: it's replaced with `{your_password}`. Replace that segment with the password you used to create the database earlier in this section. If you forgot your password, you may reset it by navigating to the database's blade in the Azure portal, selecting your *Server name* in the **Essentials** view, and also selecting **Reset password** in the resulting page. Below are some guiding images.

-

-

-### Add connection string as an application setting

-You need to add your database's connection string as an application setting. To do this through the Azure portal, first go to your Azure Functions App view. Then under **Configuration**, select **New application setting**, where you assign **SQLDB_Connection** to map to a publicly accessible connection string. Below are some guiding images.

-

-

-You can now deploy your function app to Azure and run your tests or workload on it. To validate the MSSQL backend is correctly configured, you can query your database for Task Hub data.

-For example, with Azure SQL database you can query for your orchestration instances by navigating to your SQL database's blade, clicking Query Editor, authenticating, and then running the following query:

-After running a simple orchestrator, you should see at least one result, as shown below:

-

-For more information about the Durable Task MSSQL backend architecture, configuration, and workload behavior, see the [MSSQL storage provider documentation](https://microsoft.github.io/durabletask-mssql/).

-description: Configure a Durable Functions app to use Netherite

-# Configure Durable Functions with the Netherite storage provider

-Durable Functions offers several [storage providers](durable-functions-storage-providers.md), also called "backends", for storing orchestration and entity runtime state. By default, new projects are configured to use the [Azure Storage provider](durable-functions-storage-providers.md#azure-storage). In this article, we walk through how to configure a Durable Functions app to utilize the [Netherite storage provider](durable-functions-storage-providers.md#netherite).

-> [!NOTE]

-> Netherite was designed and developed by [Microsoft Research](https://www.microsoft.com/research) for [high throughput](https://microsoft.github.io/durabletask-netherite/#/scenarios) scenarios. In some [benchmarks](https://microsoft.github.io/durabletask-netherite/#/throughput?id=multi-node-throughput), throughput increased by over an order of magnitude compared to the default Azure Storage provider. To learn more about when to use the Netherite storage provider, see the [storage providers](durable-functions-storage-providers.md) documentation.

-## Note on data migration

-Migration of [Task Hub data](durable-functions-task-hubs.md) across storage providers isn't currently supported. Function apps with existing runtime data will start with a fresh, empty task hub after switching to the Netherite backend. Similarly, the task hub contents created with Netherite can't be preserved when switching to a different storage provider.

-The following steps assume that you are starting with an existing Durable Functions app and are familiar with how to operate it.

-In particular, this quickstart assumes that you have already:

-1. Created an Azure Functions project on your local machine.

-2. Added Durable Functions to your project with an [orchestrator function](durable-functions-bindings.md#orchestration-trigger) and a [client function](durable-functions-bindings.md#orchestration-client) that triggers it.

-3. Configured the project for local debugging.

-4. Learned how to deploy an Azure Functions project to Azure.

-If this isn't the case, we suggest you start with one of the following articles, which provides detailed instructions on how to achieve all the requirements above:

-> If your app uses [Extension Bundles](../functions-bindings-register.md#extension-bundles), you should ignore this section as Extension Bundles removes the need for manual Extension management.

-You need to install the latest version of the Netherite Extension on NuGet. This usually means including a reference to it in your `.csproj` file and building the project.

-The Extension package to install depends on the .NET worker you are using:

-You can install the Extension using the following [Azure Functions Core Tools CLI](../functions-run-local.md#install-the-azure-functions-core-tools) command

-For more information on installing Azure Functions Extensions via the Core Tools CLI, see [func extensions install](../functions-core-tools-reference.md#func-extensions-install).

-The Netherite backend requires a connection string to [Event Hubs](https://azure.microsoft.com/products/event-hubs/) to run on Azure. However, for local development, providing the string `"SingleHost"` bypasses the need for Event Hubs.

-In `local.settings.json`, set the value of `EventHubsConnection` to `SingleHost` as shown below:

-> The value of `FUNCTIONS_WORKER_RUNTIME` is dependent on your programming language of choice. For more information, please see its [reference docs](../functions-app-settings.md#functions_worker_runtime).

-Edit the storage provider section of the `host.json` file so it sets the `type` to `Netherite`.

-The snippet above is just a *minimal* configuration. Later, you may want to consider [other parameters](https://microsoft.github.io/durabletask-netherite/#/settings?id=typical-configuration).

-Your app is now ready for local development: You can start the Function app to test it. One way to do this is to run `func host start` on your application's root and executing a simple orchestrator Function.

-While the function app is running, Netherite will publish load information about its active partitions to an Azure Storage table named "DurableTaskPartitions". You can use [Azure Storage Explorer](../../vs-azure-tools-storage-manage-with-storage-explorer.md) to check that it's working as expected. If Netherite is running correctly, the table won't be empty; see the example below.

-

-> [!NOTE]

-> For more information on the contents of this table, see the [Partition Table](https://microsoft.github.io/durabletask-netherite/#/ptable) article.

-> If you are using local storage emulation on a Windows OS, please ensure you're using the [Azurite](../../storage/common/storage-use-azurite.md) storage emulator and not the legacy "Azure Storage Emulator" component. Local storage emulation with Netherite is only supported via Azurite.

-## Run your app on Azure

-You need to create an Azure Functions app on Azure. To do this, follow the instructions in the **Create a function app** section of [these instructions](../functions-create-function-app-portal.md).

-You need to set up an Event Hubs namespace to run Netherite on Azure. You can also set it up if you prefer to use Event Hubs during local development.

-Follow [these steps](../../event-hubs/event-hubs-create.md#create-an-event-hubs-namespace) to create an Event Hubs namespace on the Azure portal. When creating the namespace, you may be prompted to:

-1. Choose a *resource group*: Use the same resource group as the Function app.

-2. Choose a *plan* and provision *throughput units*. Select the defaults, this setting can be changed later.

-3. Choose the *retention* time: Select the default, this setting has no effect on Netherite.

-#### Obtain the Event Hubs connection string

-To obtain the connection string for your Event Hubs namespace, go to your Event Hubs namespace in the Azure portal, select **Shared access policies**, and then select **RootManagedSharedAccessKey**. This should reveal a field named **Connection string-primary key** and that field's value is the connection string.

-Below are guiding screenshots on how to find this data in the portal:

-

-### Add connection string as an application setting

-You need to add your connection string as an application setting in your function app. To do this through the Azure portal, go to your function app view, select **Configuration**, and then select **New application setting**. This is where you can assign `EventHubsConnection` to map to your connection string. Below are some guiding images.

-

-

-If your app is running on the Elastic Premium Plan, it is recommended that you enable runtime scale monitoring for better scaling. To do this, go to **Configuration**, select **Function runtime settings** and toggle **Runtime Scale Monitoring** to On.

-

-### Ensure your app is using a 64-bit architecture (Windows only)

-> Skip this section if your app is running on Linux.

-Netherite requires a 64-bit architecture to work. Starting on Functions V4, this should be the default. You can usually validate this in the portal: under **Configuration**, select **General Settings** and then ensure the **Platform** field is set to **64 Bit**. If you don't see this option in the portal, then it's possible you're already running on a 64-bit platform. For example, Linux apps won't show this setting because they only support 64-bit.

-

-> For guidance on deploying your project to Azure, review the deployment instructions in the article for your programming language of choice in the [prerequisites section](#prerequisites).

-For more information about the Netherite architecture, configuration, and workload behavior, including performance benchmarks, we recommend you take a look at the [Netherite documentation](https://microsoft.github.io/durabletask-netherite/#/).

-description: Create and publish an Azure Durable Function in PowerShell using Visual Studio Code.

-# Create your first durable function in PowerShell

-*Durable Functions* is an extension of [Azure Functions](../functions-overview.md) that lets you write stateful functions in a serverless environment. The extension manages state, checkpoints, and restarts for you.

-In this article, you learn how to use the Visual Studio Code Azure Functions extension to locally create and test a "hello world" durable function. This function will orchestrate and chain together calls to other functions. You then publish the function code to Azure.

-

-To complete this tutorial:

-* Install [Visual Studio Code](https://code.visualstudio.com/download).

-* Install the [Azure Functions](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions) VS Code extension

-* Make sure you have the latest version of the [Azure Functions Core Tools](../functions-run-local.md).

-* Durable Functions require an Azure storage account. You need an Azure subscription.

-## <a name="create-an-azure-functions-project"></a>Create your local project

-In this section, you use Visual Studio Code to create a local Azure Functions project.

-1. In Visual Studio Code, press F1 (or Ctrl/Cmd+Shift+P) to open the command palette. In the command palette, search for and select `Azure Functions: Create New Project...`.

- 

-1. Choose an empty folder location for your project and choose **Select**.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a language for your function app project | PowerShell | Create a local PowerShell Functions project. |

- | Select a version | Azure Functions v4 | You only see this option when the Core Tools aren't already installed. In this case, Core Tools are installed the first time you run the app. |

- | Select a template for your project's first function | Skip for now | |

- | Select how you would like to open your project | Open in current window | Reopens VS Code in the folder you selected. |

-Visual Studio Code installs the Azure Functions Core Tools, if needed. 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.

-A package.json file is also created in the root folder.

-### Configure function app to use PowerShell 7

-Open the *local.settings.json* file and confirm that a setting named `FUNCTIONS_WORKER_RUNTIME_VERSION` is set to `~7`. If it is missing or set to another value, update the contents of the file.

-The most basic Durable Functions app contains three functions:

-* *Orchestrator function* - describes a workflow that orchestrates other functions.

-* *Activity function* - called by the orchestrator function, performs work, and optionally returns a value.

-* *Client function* - a regular Azure Function that starts an orchestrator function. This example uses an HTTP triggered function.

-You use a template to create the durable function code in your project.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions orchestrator | Create a Durable Functions orchestration |

- | Provide a function name | HelloOrchestrator | Name of your durable function |

-You've added an orchestrator to coordinate activity functions. Open *HelloOrchestrator/run.ps1* to see the orchestrator function. Each call to the `Invoke-ActivityFunction` cmdlet invokes an activity function named `Hello`.

-Next, you'll add the referenced `Hello` activity function.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions activity | Create an activity function |

- | Provide a function name | Hello | Name of your activity function |

-You've added the `Hello` activity function that is invoked by the orchestrator. Open *Hello/run.ps1* to see that it's taking a name as input and returning a greeting. An activity function is where you'll perform actions such as making a database call or performing a computation.

-Finally, you'll add an HTTP triggered function that starts the orchestration.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions HTTP starter | Create an HTTP starter function |

- | Provide a function name | HttpStart | Name of your activity function |

- | Authorization level | Anonymous | For demo purposes, allow the function to be called without authentication |

-You've added an HTTP triggered function that starts an orchestration. Open *HttpStart/run.ps1* to see that it uses the `Start-NewOrchestration` cmdlet to start a new orchestration. Then it uses the `New-OrchestrationCheckStatusResponse` cmdlet to return an HTTP response containing URLs that can be used to monitor and manage the new orchestration.

-You now have a Durable Functions app that can be run locally and deployed to Azure.

-> The next version of the DF PowerShell is now in preview and may be downloaded from the PowerShell Gallery.

-> Learn about it and how to try it out in the [guide to the standalone PowerShell SDK](./durable-functions-powershell-v2-sdk-migration-guide.md).

-> You may follow the guide's [installation section](./durable-functions-powershell-v2-sdk-migration-guide.md#install-and-enable-the-sdk) for instructions compatible with this quickstart on how to enable it.

-Azure Functions Core Tools lets you run an Azure Functions project on your local development computer. You're prompted to install these tools the first time you start a function app from Visual Studio Code.

-1. To test your function, set a breakpoint in the `Hello` activity function code (*Hello/run.ps1*). Press F5 or select `Debug: Start Debugging` from the command palette to start the function app project. Output from Core Tools is displayed in the **Terminal** panel.

- > [!NOTE]

- > Refer to the [Durable Functions Diagnostics](durable-functions-diagnostics.md#debugging) for more information on debugging.

-1. Durable Functions requires an Azure Storage account to run. When VS Code prompts you to select a storage account, choose **Select storage account**.

- 

-1. Following the prompts, provide the following information to create a new storage account in Azure.

- | Prompt | Value | Description |

- | Select subscription | *name of your subscription* | Select your Azure subscription |

- | Select a storage account | Create a new storage account | |

- | Enter the name of the new storage account | *unique name* | Name of the storage account to create |

- | Select a resource group | *unique name* | Name of the resource group to create |

- | Select a location | *region* | Select a region close to you |

-1. In the **Terminal** panel, copy the URL endpoint of your HTTP-triggered function.

- 

-1. Using your browser, or a tool like [Postman](https://www.getpostman.com/) or [cURL](https://curl.haxx.se/), send an HTTP POST request to the URL endpoint. Replace the last segment with the name of the orchestrator function (`HelloOrchestrator`). The URL should be similar to `http://localhost:7071/api/orchestrators/HelloOrchestrator`.

- The response is the initial result from the HTTP function letting you know the durable orchestration has started successfully. It is not yet the end result of the orchestration. The response includes a few useful URLs. For now, let's query the status of the orchestration.

-1. Copy the URL value for `statusQueryGetUri` and paste it in the browser's address bar and execute the request. Alternatively you can also continue to use Postman to issue the GET request.

- The request will query the orchestration instance for the status. You should get an eventual response, which shows us the instance has completed, and includes the outputs or results of the durable function. It looks like:

-1. To stop debugging, press **Shift + F5** in VS Code.

-After you've verified that the function runs correctly on your local computer, it's time to publish the project to Azure.

-1. Copy the URL of the HTTP trigger from the **Output** panel. The URL that calls your HTTP-triggered function should be in this format: `https://<functionappname>.azurewebsites.net/api/orchestrators/HelloOrchestrator`

-2. Paste this new URL for the HTTP request into your browser's address bar. You should get the same status response as before when using the published app.

-## Next steps

-You have used Visual Studio Code to create and publish a PowerShell durable function app.

-> [!div class="nextstepaction"]

-> [Learn about common durable function patterns](durable-functions-overview.md#application-patterns)

-description: Create and publish an Azure Durable Function in Python using Visual Studio Code.

-# Create your first durable function in Python

-Durable Functions is an extension of [Azure Functions](../functions-overview.md) that lets you write stateful functions in a serverless environment. The extension manages state, checkpoints, and restarts for you.

-In this article, you learn how to use the Visual Studio Code Azure Functions extension to locally create and test a "hello world" durable function. This function will orchestrate and chains together calls to other functions. You can then publish the function code to Azure.

-To complete this tutorial:

-* Install [Visual Studio Code](https://code.visualstudio.com/download).

-* Install the [Azure Functions](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions) Visual Studio Code extension.

-* Make sure that you have the latest version of the [Azure Functions Core Tools](../functions-run-local.md).

-* Durable Functions require an Azure storage account. You need an Azure subscription.

-* Make sure that you have version 3.7, 3.8, 3.9, or 3.10 of [Python](https://www.python.org/) installed.

-1. In Visual Studio Code, press <kbd>F1</kbd> (or <kbd>Ctrl/Cmd+Shift+P</kbd>) to open the command palette. In the command palette, search for and select `Azure Functions: Create New Project...`.

-1. Choose an empty folder location for your project and choose **Select**.

-1. Follow the prompts and provide the following information:

- | Prompt | Value | Description |

- | Select a language for your function app project | Python | Create a local Python Functions project. |

- | Select a version | Azure Functions v4 | You only see this option when the Core Tools aren't already installed. In this case, Core Tools are installed the first time you run the app. |

- | Python version | Python 3.7, 3.8, 3.9, or 3.10 | Visual Studio Code will create a virtual environment with the version you select. |

- | Select a template for your project's first function | Skip for now | |

- | Select how you would like to open your project | Open in current window | Reopens Visual Studio Code in the folder you selected. |

-1. Follow the prompts and provide the following information:

- | Select a language | Python (Programming Model V2) | Create a local Python Functions project using the V2 programming model. |

- | Select a version | Azure Functions v4 | You only see this option when the Core Tools aren't already installed. In this case, Core Tools are installed the first time you run the app. |

- | Python version | Python 3.7, 3.8, 3.9, or 3.10 | Visual Studio Code will create a virtual environment with the version you select. |

- | Select how you would like to open your project | Open in current window | Reopens Visual Studio Code in the folder you selected. |

-Visual Studio Code installs the Azure Functions Core Tools if needed. 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.

-When you've created the project, the Azure Functions Visual Studio Code extension automatically creates a virtual environment with your selected Python version. You then need to activate the virtual environment in a terminal and install some dependencies required by Azure Functions and Durable Functions.

- ```

-1. Open the editor's integrated terminal in the current folder (<kbd>Ctrl+Shift+`</kbd>).

-1. In the integrated terminal, activate the virtual environment in the current folder, depending on your operating system:

- # [Linux](#tab/linux)

- ```bash

- source .venv/bin/activate

- ```

- # [MacOS](#tab/macos)

- ```bash

- source .venv/bin/activate

- ```

- # [Windows](#tab/windows)

- ```powershell

- .venv\scripts\activate

- ```

-

-

-1. In the integrated terminal where the virtual environment is activated, use pip to install the packages you defined.

- ```bash

- python -m pip install -r requirements.txt

- ```

-A basic Durable Functions app contains three functions:

-* *Orchestrator function*: Describes a workflow that orchestrates other functions.

-* *Activity function*: It's called by the orchestrator function, performs work, and optionally returns a value.

-* *Client function*: It's a regular Azure Function that starts an orchestrator function. This example uses an HTTP triggered function.

-You use a template to create the durable function code in your project.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Follow the prompts and provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions orchestrator | Create a Durable Functions orchestration |

- | Provide a function name | HelloOrchestrator | Name of your durable function |

-You've added an orchestrator to coordinate activity functions. Open *HelloOrchestrator/\_\_init__.py* to see the orchestrator function. Each call to `context.call_activity` invokes an activity function named `Hello`.

-Next, you'll add the referenced `Hello` activity function.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Follow the prompts and provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions activity | Create an activity function |

- | Provide a function name | Hello | Name of your activity function |

-You've added the `Hello` activity function that is invoked by the orchestrator. Open *Hello/\_\_init__.py* to see that it takes a name as input and returns a greeting. An activity function is where you'll perform actions such as making a database call or performing a computation.

-Finally, you'll add an HTTP triggered function that starts the orchestration.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Follow the prompts and provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions HTTP starter | Create an HTTP starter function |

- | Provide a function name | DurableFunctionsHttpStart | Name of your client function |

- | Authorization level | Anonymous | For demo purposes, allow the function to be called without authentication |

-You've added an HTTP triggered function that starts an orchestration. Open *DurableFunctionsHttpStart/\_\_init__.py* to see that it uses `client.start_new` to start a new orchestration. Then it uses `client.create_check_status_response` to return an HTTP response containing URLs that can be used to monitor and manage the new orchestration.

-## Enable v2 programming model

-The following application setting is required to run the v2 programming model:

-If you're running locally using [Azure Functions Core Tools](../functions-run-local.md), you should add this setting to your `local.settings.json` file. If you're running in Azure, follow these steps with the tool of your choice:

-```azurecli

-# [VS Code](#tab/vs-code-set-indexing-flag)

-1. Make sure you have the [Azure Functions extension for VS Code](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions) installed

-1. Press <kbd>F1</kbd> to open the command palette. In the command palette, search for and select `Azure Functions: Add New Setting...`.

-1. Choose your subscription and function app when prompted

-1. For the name, type `AzureWebJobsFeatureFlags` and press <kbd>Enter</kbd>.

-1. For the value, type `EnableWorkerIndexing` and press <kbd>Enter</kbd>.

-To create a basic Durable Functions app using these 3 function types, replace the contents of `function_app.py` with the following Python code.

-```Python

-# An HTTP-Triggered Function with a Durable Functions Client binding

-Review the table below for an explanation of each function and its purpose in the sample.

-| **`hello_orchestrator`** | The orchestrator function, which describes the workflow. In this case, the orchestration starts, invokes three functions in a sequence, and returns the ordered results of all 3 functions in a list. |

-| **`hello`** | The activity function, which performs the work being orchestrated. The function returns a simple greeting to the city passed as an argument. |

-| **`http_start`** | An [HTTP-triggered function](../functions-bindings-http-webhook.md) that starts an instance of the orchestration and returns a check status response. |

-> Durable Functions also supports Python V2's [blueprints](../functions-reference-python.md#blueprints). To use them, you will need to register your blueprint functions using the [`azure-functions-durable`](https://pypi.org/project/azure-functions-durable) `Blueprint` class, as

-> shown [here](https://github.com/Azure/azure-functions-durable-python/blob/dev/samples-v2/blueprint/durable_blueprints.py). The resulting blueprint can then be registered as normal. See our [sample](https://github.com/Azure/azure-functions-durable-python/tree/dev/samples-v2/blueprint) for an example.

-Azure Functions Core Tools lets you run an Azure Functions project on your local development computer. If you don't have it installed, you're prompted to install these tools the first time you start a function from Visual Studio Code.

-1. To test your function, set a breakpoint in the `Hello` activity function code (*Hello/\_\_init__.py*). Press <kbd>F5</kbd> or select `Debug: Start Debugging` from the command palette to start the function app project. Output from Core Tools is displayed in the **Terminal** panel.

-1. To test your function, set a breakpoint in the `hello` activity function code. Press <kbd>F5</kbd> or select `Debug: Start Debugging` from the command palette to start the function app project. Output from Core Tools is displayed in the **Terminal** panel.

-> [!NOTE]

-> For more information on debugging, see [Durable Functions Diagnostics](durable-functions-diagnostics.md#debugging).

-2. Durable Functions require an Azure storage account to run. When Visual Studio Code prompts you to select a storage account, select **Select storage account**.

-3. Follow the prompts and provide the following information to create a new storage account in Azure:

- | Prompt | Value | Description |

- | Select subscription | *name of your subscription* | Select your Azure subscription |

- | Select a storage account | Create a new storage account | |

- | Enter the name of the new storage account | *unique name* | Name of the storage account to create |

- | Select a resource group | *unique name* | Name of the resource group to create |

- | Select a location | *region* | Select a region close to you |

-4. In the **Terminal** panel, copy the URL endpoint of your HTTP-triggered function.

-5. Use your browser, or a tool like [Postman](https://www.getpostman.com/) or [cURL](https://curl.haxx.se/), send an HTTP request to the URL endpoint. Replace the last segment with the name of the orchestrator function (`HelloOrchestrator`). The URL must be similar to `http://localhost:7071/api/orchestrators/HelloOrchestrator`.

- The response is the initial result from the HTTP function letting you know the durable orchestration has started successfully. It isn't yet the end result of the orchestration. The response includes a few useful URLs. For now, let's query the status of the orchestration.

-5. Use your browser, or a tool like [Postman](https://www.getpostman.com/) or [cURL](https://curl.haxx.se/), send an HTTP request to the URL endpoint. Replace the last segment with the name of the orchestrator function (`hello_orchestrator`). The URL must be similar to `http://localhost:7071/api/orchestrators/hello_orchestrator`.

- The response is the initial result from the HTTP function letting you know the durable orchestration has started successfully. It isn't yet the end result of the orchestration. The response includes a few useful URLs. For now, let's query the status of the orchestration.

-2. Copy the URL value for `statusQueryGetUri`, paste it in the browser's address bar, and execute the request. Alternatively, you can also continue to use Postman to issue the GET request.

- The request will query the orchestration instance for the status. You must get an eventual response, which shows the instance has completed and includes the outputs or results of the durable function. It looks like:

-```json

-{

- "name": "HelloOrchestrator",

- "instanceId": "9a528a9e926f4b46b7d3deaa134b7e8a",

- "runtimeStatus": "Completed",

- "input": null,

- "customStatus": null,

- "output": [

- "Hello Tokyo!",

- "Hello Seattle!",

- "Hello London!"

- ],

- "createdTime": "2020-03-18T21:54:49Z",

- "lastUpdatedTime": "2020-03-18T21:54:54Z"

-}

-```

-```json

-{

- "name": "hello_orchestrator",

- "instanceId": "9a528a9e926f4b46b7d3deaa134b7e8a",

- "runtimeStatus": "Completed",

- "input": null,

- "customStatus": null,

- "output": [

- "Hello Tokyo!",

- "Hello Seattle!",

- "Hello London!"

- ],

- "createdTime": "2020-03-18T21:54:49Z",

- "lastUpdatedTime": "2020-03-18T21:54:54Z"

-}

-```

-7. To stop debugging, press <kbd>Shift+F5</kbd> in Visual Studio Code.

-After you've verified that the function runs correctly on your local computer, it's time to publish the project to Azure.

-1. Copy the URL of the HTTP trigger from the **Output** panel. The URL that calls your HTTP-triggered function must be in this format: `https://<functionappname>.azurewebsites.net/api/orchestrators/HelloOrchestrator`

-1. Copy the URL of the HTTP trigger from the **Output** panel. The URL that calls your HTTP-triggered function must be in this format: `https://<functionappname>.azurewebsites.net/api/orchestrators/hello_orchestrator`

-1. Paste this new URL for the HTTP request in your browser's address bar. You must get the same status response as before when using the published app.

-## Next steps

-You have used Visual Studio Code to create and publish a Python durable function app.

-> [!div class="nextstepaction"]

-> [Learn about common durable function patterns](durable-functions-overview.md#application-patterns)

-description: Create and publish an Azure Durable Function in TypeScript using Visual Studio Code.

-# Create your first durable function in TypeScript

-*Durable Functions* is an extension of [Azure Functions](../functions-overview.md) that lets you write stateful functions in a serverless environment. The extension manages state, checkpoints, and restarts for you.

-In this article, you learn how to use the Visual Studio Code Azure Functions extension to locally create and test a "hello world" durable function. This function will orchestrate and chain together calls to other functions. You then publish the function code to Azure.

-

-To complete this tutorial:

-* Install [Visual Studio Code](https://code.visualstudio.com/download).

-* Install the [Azure Functions](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions) VS Code extension

-* Install the [Azure Functions](https://marketplace.visualstudio.com/items?itemName=ms-azuretools.vscode-azurefunctions) VS Code extension version `1.10.4` or above.

-* Make sure you have the latest version of the [Azure Functions Core Tools](../functions-run-local.md).

-* Make sure you have [Azure Functions Core Tools](../functions-run-local.md) version `v4.0.5382` or above.

-* Durable Functions require an Azure storage account. You need an Azure subscription.

-* Make sure that you have version 16.x+ of [Node.js](https://nodejs.org/) installed.

-* Make sure that you have version 18.x+ of [Node.js](https://nodejs.org/) installed.

-* Make sure that you have [TypeScript](https://www.typescriptlang.org/) v4.x+ installed.

-In this section, you use Visual Studio Code to create a local Azure Functions project.

-1. In Visual Studio Code, press <kbd>F1</kbd> (or <kbd>Ctrl/Cmd + Shift + P</kbd>) to open the command palette. In the command palette, search for and select `Azure Functions: Create New Project...`.

- 

-2. Choose an empty folder location for your project and choose **Select**.

-3. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a language for your function app project | TypeScript | Create a local Node.js Functions project using TypeScript. |

- | Select a JavaScript programming model | Model V3 | Choose the V3 programming model. |

- | Select a version | Azure Functions v4 | You only see this option when the Core Tools aren't already installed. In this case, Core Tools are installed the first time you run the app. |

- | Select a template for your project's first function | Skip for now | |

- | Select how you would like to open your project | Open in current window | Reopens VS Code in the folder you selected. |

-3. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a language for your function app project | TypeScript | Create a local Node.js Functions project using TypeScript. |

- | Select a JavaScript programming model | Model V4 | Choose the V4 programming model. |

- | Select a version | Azure Functions v4 | You only see this option when the Core Tools aren't already installed. In this case, Core Tools are installed the first time you run the app. |

- | Select a template for your project's first function | Skip for now | |

- | Select how you would like to open your project | Open in current window | Reopens VS Code in the folder you selected. |

-Visual Studio Code installs the Azure Functions Core Tools, if needed. 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.

-A `package.json` file and a `tsconfig.json` file are also created in the root folder.

-To work with Durable Functions in a Node.js function app, you use a library called `durable-functions`.

-To use the V4 programming model, you need to install the preview `v3.x` version of `durable-functions`.

-1. Use the *View* menu or <kbd>Ctrl + Shift + `</kbd> to open a new terminal in VS Code.

-2. Install the `durable-functions` npm package by running `npm install durable-functions` in the root directory of the function app.

-2. Install the `durable-functions` npm package preview version by running `npm install durable-functions@preview` in the root directory of the function app.

-## Creating your functions

-The most basic Durable Functions app contains three functions:

-* *Orchestrator function* - describes a workflow that orchestrates other functions.

-* *Activity function* - called by the orchestrator function, performs work, and optionally returns a value.

-* *Client function* - a regular Azure Function that starts an orchestrator function. This example uses an HTTP triggered function.

-You use a template to create the durable function code in your project.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions orchestrator | Create a Durable Functions orchestration |

- | Choose a durable storage type. | Azure Storage (Default) | Select the storage backend used for Durable Functions. |

- | Provide a function name | HelloOrchestrator | Name of your durable function |

-You've added an orchestrator to coordinate activity functions. Open *HelloOrchestrator/index.ts* to see the orchestrator function. Each call to `context.df.callActivity` invokes an activity function named `Hello`.

-Next, you'll add the referenced `Hello` activity function.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions activity | Create an activity function |

- | Provide a function name | Hello | Name of your activity function |

-You've added the `Hello` activity function that is invoked by the orchestrator. Open *Hello/index.ts* to see that it's taking a name as input and returning a greeting. An activity function is where you perform "the real work" in your workflow: work such as making a database call or performing some non-deterministic computation.

-Finally, you'll add an HTTP triggered function that starts the orchestration.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions HTTP starter | Create an HTTP starter function |

- | Provide a function name | DurableFunctionsHttpStart | Name of your activity function |

- | Authorization level | Anonymous | For demo purposes, allow the function to be called without authentication |

-You've added an HTTP triggered function that starts an orchestration. Open *DurableFunctionsHttpStart/index.ts* to see that it uses `client.startNew` to start a new orchestration. Then it uses `client.createCheckStatusResponse` to return an HTTP response containing URLs that can be used to monitor and manage the new orchestration.

-You now have a Durable Functions app that can be run locally and deployed to Azure.

-One of the benefits of the V4 Programming Model is the flexibility of where you write your functions.

-In the V4 Model, you can use a single template to create all three functions in one file in your project.

-1. In the command palette, search for and select `Azure Functions: Create Function...`.

-1. Following the prompts, provide the following information:

- | Prompt | Value | Description |

- | Select a template for your function | Durable Functions orchestrator | Create a file with a Durable Functions orchestration, an Activity function, and a Durable Client starter function. |

- | Choose a durable storage type | Azure Storage (Default) | Select the storage backend used for Durable Functions. |

- | Provide a function name | hello | Name used for your durable functions |

-You've created an orchestrator called `helloOrchestrator` to coordinate activity functions. Each call to `context.df.callActivity` invokes an activity function called `hello`.

-You've also added the `hello` activity function that is invoked by the orchestrator. In the same file, you can see that it's taking a name as input and returning a greeting. An activity function is where you perform "the real work" in your workflow: work such as making a database call or performing some non-deterministic computation.

-Lastly, you've also added an HTTP triggered function that starts an orchestration. In the same file, you can see that it uses `client.startNew` to start a new orchestration. Then it uses `client.createCheckStatusResponse` to return an HTTP response containing URLs that can be used to monitor and manage the new orchestration.

-You now have a Durable Functions app that can be run locally and deployed to Azure.

-Azure Functions Core Tools lets you run an Azure Functions project on your local development computer. You're prompted to install these tools the first time you start a function from Visual Studio Code.

-1. To test your function, set a breakpoint in the `Hello` activity function code (*Hello/index.ts*). Press F5 or select `Debug: Start Debugging` from the command palette to start the function app project. Output from Core Tools is displayed in the **Terminal** panel.

-1. To test your function, set a breakpoint in the `hello` activity function code (*src/functions/hello.ts*). Press F5 or select `Debug: Start Debugging` from the command palette to start the function app project. Output from Core Tools is displayed in the **Terminal** panel.

- > [!NOTE]

- > Refer to the [Durable Functions Diagnostics](durable-functions-diagnostics.md#debugging) for more information on debugging.

-2. Durable Functions requires an Azure Storage account to run. When VS Code prompts you to select a storage account, choose **Select storage account**.

- 

-3. Following the prompts, provide the following information to create a new storage account in Azure.

- | Prompt | Value | Description |

- | Select subscription | *name of your subscription* | Select your Azure subscription |

- | Select a storage account | Create a new storage account | |

- | Enter the name of the new storage account | *unique name* | Name of the storage account to create |

- | Select a resource group | *unique name* | Name of the resource group to create |

- | Select a location | *region* | Select a region close to you |

-4. In the **Terminal** panel, copy the URL endpoint of your HTTP-triggered function.

- 

-5. Using your browser, or a tool like [Postman](https://www.getpostman.com/) or [cURL](https://curl.haxx.se/), send an HTTP POST request to the URL endpoint. Replace the last segment with the name of the orchestrator function (`HelloOrchestrator`). The URL should be similar to `http://localhost:7071/api/orchestrators/HelloOrchestrator`.

-5. Using your browser, or a tool like [Postman](https://www.getpostman.com/) or [cURL](https://curl.haxx.se/), send an HTTP POST request to the URL endpoint. Replace the last segment with the name of the orchestrator function (`helloOrchestrator`). The URL should be similar to `http://localhost:7071/api/orchestrators/helloOrchestrator`.

- The response is the initial result from the HTTP function letting you know the durable orchestration has started successfully. It is not yet the end result of the orchestration. The response includes a few useful URLs. For now, let's query the status of the orchestration.

-6. Copy the URL value for `statusQueryGetUri` and paste it in the browser's address bar and execute the request. Alternatively you can also continue to use Postman to issue the GET request.

- The request queries the orchestration instance for the status. You should get an eventual response, which shows us the instance has completed, and includes the outputs or results of the durable function. It looks like:

- ::: zone pivot="nodejs-model-v3"

- ```json

- {

- "name": "HelloOrchestrator",

- "instanceId": "9a528a9e926f4b46b7d3deaa134b7e8a",

- "runtimeStatus": "Completed",

- "input": null,

- "customStatus": null,

- "output": [

- "Hello Tokyo!",

- "Hello Seattle!",

- "Hello London!"

- ],

- "createdTime": "2020-03-18T21:54:49Z",

- "lastUpdatedTime": "2020-03-18T21:54:54Z"

- }

- ```

- ::: zone-end

- ::: zone pivot="nodejs-model-v4"

- ```json

- {

- "name": "helloOrchestrator",

- "instanceId": "6ba3f77933b1461ea1a3828c013c9d56",

- "runtimeStatus": "Completed",

- "input": "",

- "customStatus": null,

- "output": [

- "Hello, Tokyo",

- "Hello, Seattle",

- "Hello, Cairo"

- ],

- "createdTime": "2023-02-13T23:02:21Z",

- "lastUpdatedTime": "2023-02-13T23:02:25Z"

- }

- ```

- ::: zone-end

-7. To stop debugging, press **Shift + F5** in VS Code.

-After you've verified that the function runs correctly on your local computer, it's time to publish the project to Azure.

-> To use the V4 node programming model, make sure your app is running on at least version 4.25 of the Azure Functions runtime.

-1. Copy the URL of the HTTP trigger from the **Output** panel. The URL that calls your HTTP-triggered function should be in this format: `https://<functionappname>.azurewebsites.net/api/orchestrators/HelloOrchestrator`

-1. Copy the URL of the HTTP trigger from the **Output** panel. The URL that calls your HTTP-triggered function should be in this format: `https://<functionappname>.azurewebsites.net/api/orchestrators/helloOrchestrator`

-2. Paste this new URL for the HTTP request into your browser's address bar. You should get the same status response as before when using the published app.

-## Next steps

-You have used Visual Studio Code to create and publish a JavaScript durable function app.

-> [!div class="nextstepaction"]

-> [Learn about common durable function patterns](durable-functions-overview.md#application-patterns)

-+ **Authorization**: EasyAuth isn't currently supported. Unauthenticated callers currently aren't blocked when EasyAuth is enabled in a Flex Consumption plan app.

-+ **CORS**: [Cross-origin resource sharing (CORS) settings](functions-how-to-use-azure-function-app-settings.md#cors) are currently ignored for Flex Consumption apps.

-+ Quickstart: [Create your first durable function in Azure using C#](./durable/durable-functions-create-first-csharp.md)

-|[Apptus](https://apttus.com)|

-|[Simons Advisors, LLC](https://simonsadvisors.com/)|

-* You need Azure CLI version [2.61.0](https://learn.microsoft.com/cli/azure/release-notes-azure-cli#may-21-2024) or higher. Run `az --version` to find the version. If you need to install or upgrade, see [Install Azure CLI](/cli/azure/install-azure-cli).

- },

- },

- },

- },

- }

- "tableOutputStream": "['Custom-',concat(parameters('tableName'))]"

- "type": "String"

- "type": "bool"

- "Custom-Json-dataSource"

-To collect telemetry from services such as Requests, urllib3, httpx, PsycoPG2, and more, use the [Azure Monitor OpenTelemetry Distro](./opentelemetry-enable.md?tabs=python). Tracked incoming requests coming into your Python application hosted in Azure Functions will not be automatically correlated with telemetry being tracked within it. You can manually achieve trace correlation by extract the TraceContext directly as shown below:

-| | Analytics | Basic | Auxiliary (Preview) |

-SignalR Service allows you to broadcast messages to all or a subset of clients, such as those belonging to a single user. You can combine the SignalR Service bindings for Azure Functions with App Service authentication to authenticate users with providers such as Microsoft Entra ID, Facebook, and Twitter. You can then send messages directly to these authenticated users.

-Azure Functions has built-in authentication, supporting popular providers such as Facebook, Twitter, Microsoft Account, Google, and Microsoft Entra ID. This feature can be integrated with the `SignalRConnectionInfo` binding to create connections to Azure SignalR Service that is authenticated to a user ID. Your application can send messages using the `SignalR` output binding that are targeted to that user ID.

-# Application Firewall for Azure SignalR Service

-Azure Functions supports authentication with Microsoft Entra ID, Facebook, Twitter, Microsoft account, and Google. You'll use Microsoft as the identity provider for this tutorial.

-1. Follow the steps in the section [Configure SQL Server enabled by Azure Arc - Modify SQL Server configuration](https://learn.microsoft.com/sql/sql-server/azure-arc/manage-configuration?view=sql-server-ver16&tabs=azure#modify-sql-server-configuration). This section also provides syntax to configure by using Azure PowerShell or the Azure CLI.

- - You can use the query [List Arc-enabled SQL Server instances subscribed to ESU](https://learn.microsoft.com/sql/sql-server/azure-arc/manage-configuration?view=sql-server-ver16&tabs=azure&branch=main#list-arc-enabled-sql-server-instances-subscribed-to-esu) as an example to show how you can view eligible SQL Server ESU instances and their ESU subscription status.

-# Application Firewall for Azure Web PubSub Service

-description: Better understand what typical use case scenarios to use Azure Web PubSub, and learn the key benefits of Azure Web PubSub.

-The Azure Web PubSub Service makes it easy to build real-time messaging web applications using WebSockets and the publish-subscribe pattern. This real-time functionality allows publishing content updates between server and connected clients (for example, a single page web application or mobile application). The clients don't need to poll for the latest updates, or submit new HTTP requests for updates.

-This article provides an overview of the Azure Web PubSub service.

-Any scenario that requires real-time publish-subscribe messaging between the server and clients or among clients, can use the Azure Web PubSub service. Traditional real-time features that often require polling from the server or submitting HTTP requests, can also use the Azure Web PubSub service.

-The Azure Web PubSub service can be used in any application type that requires real-time content updates. We list some examples that are good to use the Azure Web PubSub service:

-* **High frequency data updates:** gaming, voting, polling, auction.

-* **Live dashboards and monitoring:** company dashboard, financial market data, instant sales update, multi-player game leader board, and IoT monitoring.

-* **Cross-platform live chat:** live chat room, chat bot, on-line customer support, real-time shopping assistant, messenger, in-game chat, and so on.

-* **Real-time location on map:** logistic tracking, delivery status tracking, transportation status updates, GPS apps.

-* **Real-time targeted ads:** personalized real-time push ads and offers, interactive ads.

-* **Collaborative apps:** coauthoring, whiteboard apps and team meeting software.

-* **Push instant notifications:** social network, email, game, travel alert.

-* **Real-time broadcasting:** live audio/video broadcasting, live captioning, translating, events/news broadcasting.

-* **IoT and connected devices:** real-time IoT metrics, remote control, real-time status, and location tracking.

-* **Automation:** real-time trigger from upstream events.

-The Azure Web PubSub service is designed for large-scale real-time applications. The service allows multiple instances to work together and scale to millions of client connections. Meanwhile, it also supports multiple global regions for sharding, high availability, or disaster recovery purposes.

-The Azure Web PubSub service works with a broad range of clients. These clients include web and mobile browsers, desktop apps, mobile apps, server processes, IoT devices, and game consoles. Since this service supports the standard WebSocket connection with publish-subscribe pattern, it's easy to use any standard WebSocket client SDK in different languages with this service.

-Azure Web PubSub service is a bi-directional messaging service that allows different messaging patterns among server and clients, for example:

-* The server sends messages to individual clients, all clients, or groups of clients that are associated with a specific user or categorized into arbitrary groups.

-* The client sends messages to clients that belong to an arbitrary group.

-* The clients send messages to server.

-| **Proxy server/firewall is blocking registration** <br/>Or <br/>**No internet connectivity** <br/><br/> If your machine has limited internet access, and you don't ensure the firewall, proxy, and network settings allow access to the FQDNS and public IP addresses, the registration will fail.| Follow these steps:<br/> <br><br>- Work with your IT team to ensure the system has internet connectivity.<br>- If you don't have a proxy server, ensure the proxy option isn't selected when you register the agent. [Check your proxy settings](#verifying-proxy-settings-for-windows).<br>- If you do have a firewall/proxy server, work with your networking team to allow access to the following FQDNs and public IP addresses. Access to all of the URLs and IP addresses listed below uses the HTTPS protocol on port 443.<br/> <br> **URLs**<br> `*.microsoft.com` <br> `*.windowsazure.com` <br> `*.microsoftonline.com` <br> `*.windows.net` <br> `*blob.core.windows.net` <br> `*queue.core.windows.net` <br> `*blob.storage.azure.net`<br><br><br>- If you're a US Government customer, ensure that you have access to the following URLs:<br><br> `www.msftncsi.com` <br> `*.microsoft.com` <br> `*.windowsazure.us` <br> `*.microsoftonline.us` <br> `*.windows.net` <br> `*.usgovcloudapi.net` <br> `*blob.core.windows.net` <br> `*queue.core.windows.net` <br> `*blob.storage.azure.net` <br><br> Try registering again after you complete the preceding troubleshooting steps.<br></br> If your connection is via Azure ExpressRoute, make sure the settings are configured as described in Azure [ExpressRoute support](../backup/backup-support-matrix-mars-agent.md#azure-expressroute-support). <br/> <br/> If you are using the [Entra Tenant Restrictions](https://learn.microsoft.com/entra/identity/enterprise-apps/tenant-restrictions) feature with your proxy, ensure that the tenant id of Recovery Services Vault used to register the MARS agent is added to the list of allowed tenants in the `Restrict-Access-To-Tenants` header. This tenant id is unique per Azure region. You can find the tenant id by opening the vault credential file and locating the `<AadTenantId>` element.|

-This page contains a list of devices that have successfully passed the Edge Secured-core certification.

-|Lenovo|[ThinkEdge SE30](https://www.lenovo.com/us/en/p/desktops/thinkedge/thinkedge-se30/len102c0004)|Windows 10 IoT Enterprise|2022-04-06|

-| **Maximum # of incoming remote streams that can be rendered simultaneously** | 9 videos + 1 screen sharing on desktop browsers*, 4 videos + 1 screen sharing on web mobile browsers | 9 videos + 1 screen sharing |

-While the Calling SDK doesn't enforce these limits, your users might experience performance degradation if they're exceeded. Use the API of [Optimal Video Count](../../how-tos/calling-sdk/manage-video.md?pivots=platform-web#remote-video-quality) to determine how many current incoming video streams your web environment can support.

- - [Create resources using guided deployments](use-guided-deployments.md)

-description: Learn how Microsoft Copilot in Azure (preview) can provide one-click or step-by-step deployment assistance.

-# Create resources using guided deployments from Microsoft Copilot in Azure

-Microsoft Copilot in Azure (preview) can help you deploy certain resources and workloads by providing one-click or step-by-step deployment assistance.

-Guided deployments are currently available for select workloads. For other types of deployments, Copilot in Azure helps by [providing links to templates](#template-suggestions) that you can customize and deploy, often with various deployment options such as Azure CLI, Terraform, Bicep, or ARM. If a template isn't available for your scenario, Copilot in Azure provides information to help you choose and deploy the best resources for your scenario.

-Copilot in Azure can help you deploy an NGINX web server, Azure MySQL Flexible Server, and PHP (the [LEMP stack](/azure/virtual-machines/linux/tutorial-lemp-stack)) on an Ubuntu Linux VM in Azure. To see the LEMP server in action, you can also install and configure a WordPress site. You can choose either a one-click deployment, or step-by-step assistance.

-You can say "**I want to deploy a LEMP stack on a Ubuntu VM**". Copilot in Azure checks for deployment experiences, and presents you with two deployment options: **Step-by-Step** or **One-Click**.

-If you choose **Step-by-step deployment** and select a subscription, Copilot in Azure launches a guided experience that walks you through each step of the deployment.

-Copilot in Azure can help you [create a Linux VM and connect to it via SSH](/azure/virtual-machines/linux/quick-create-cli). You can choose either a one-click deployment, or step-by-step assistance to handle the necessary tasks, including installing the latest Ubuntu image, provisioning the VM, generating a private key, and establishing the SSH connection.

-You can say "**How do I create a Linux VM and SSH into it?**". You'll see two deployment options: **Step-by-Step deployment** or **One-Click**. If you choose the one-click option and select a subscription, you can run the script to deploy the infrastructure. While the deployment is running, don't close or refresh the page. You'll see progress as each step of the deployment is completed.

-Copilot in Azure can help you [create an Azure Kubernetes Service (AKS) cluster](/azure/aks/learn/quick-kubernetes-deploy-cli) with an NGINX ingress controller and a custom domain. As with the other deployments, you can choose either a one-click deployment or step-by-step assistance.

-When you say "**Seamless deployment for AKS cluster on Azure**", Microsoft Copilot in Azure presents you with two deployment options: **Step-by-Step** or **One-Click**. In this example, the one-click deployment option is selected. As with the other examples, you see progress as each step of the deployment is completed.

-If a guided deployment isn't available, Copilot in Azure checks to see if there's a template available to help with your scenario. Where possible, multiple deployment options are provided, such as Azure CLI, Terraform, Bicep, or ARM. You can then download and customize the templates as desired.

-# Audit the point in time restore action for continuous backup mode in Azure Cosmos DB

-Azure Cosmos DB provides you the list of all the point in time restores for continuous mode that were performed on an Azure Cosmos DB account using [Activity Logs](../azure-monitor/essentials/activity-log.md). Activity logs can be viewed for any Azure Cosmos DB account from the **Activity Logs** page in the Azure portal. The Activity Log shows all the operations that were triggered on the specific account. When a point in time restore is triggered, it shows up as `Restore Database Account` operation on the source account as well as the target account. The Activity Log for the source account can be used to audit restore events, and the activity logs on the target account can be used to get the updates about the progress of the restore.

-> [!IMPORTANT]

-> The feature is enabled at the account level, so all containers within the account will automatically have this capability applied. The feature is available for both shared throughput databases and containers with dedicated throughput. Provisioned throughput accounts must switch over to autoscale and then enable this feature, if interested.

-## Metrics

-Use Azure Monitor to analyze how the new autoscaling is being applied across partitions and regions. Filter to your desired database account and container, then filter or split by the `PhysicalPartitionID` metric. This metric shows all partitions across their various regions.

-Then, use `NormalizedRUConsumption' to see which partitions are scaling indpendently and which regions are scaling independently if applicable. You can use the 'ProvisionedThroughput' metric to see what throughput value is getting emmitted to our billing service.

-Log Analytics is a tool in the Azure portal that helps you run server diagnostics on your API for Cassandra account. Run log queries from data collected by Azure Monitor Logs and interactively analyze their results. Records retrieved from Log Analytics queries help provide various insights into your data.

-Use the CDBCassandraRequests table to see data plane operations specifically for your API for Cassandra account. A sample query to see the topN(10) consuming request and get detailed information on each request made.

-#### Error Codes and Possible Solutions

-|Status Code | Error Code | Description |

-||-|--|

-| 200 | -1 | Successful |

-| 400 | 8704 | The query is correct but an invalid syntax. |

-| 400 | 8192 | The submitted query has a syntax error. Review your query. |

-| 400 | 8960 | The query is invalid because of some configuration issue. |

-| 401 |8448 | The logged user does not have the right permissions to perform the query. |

-| 403 | 8448 | Forbidden response as the user may not have the necessary permissions to carry out the request. |

-| 404 | 5376 | A non-timeout exception during a write request as a result of response not found. |

-| 405 | 0 | Server-side Cassandra error. The error rarely occurs, open a support ticket. |

-| 408 | 4608 | Timeout during a read request. |

-| 408 | 4352 | Timeout exception during a write serviceRequest. |

-| 409 | 9216 | Attempting to create a keyspace or table that already exist. |

-| 412 | 5376 | Precondition failure. To ensure data integrity, we ensure that the write request based on the read response is true. A non-timeout write request exception is returned. |

-| 413 | 5376 | This non-timeout exception during a write request is because of payload maybe too large. Currently, there is a limit of 2MB per row. |

-| 417 | 9472 | The exception is thrown when a prepared statement is not cached on the server node. It should be transient/non-blocking. |

-| 423 | 5376 | There is a lock because a write request that is currently processing. |

-| 429 | 4097| Overload exception is as a result of RU shortage or high request rate. Probably need more RU to handle the higher volume request. In, native Cassandra this can be interpreted as one of the VMs not having enough CPU. We advise reviewing current data model to ensure that you do not have excessive skews that might be causing hot partitions. |

-| 449 | 5376 | Concurrent execution exception. This occurs to ensure only one write update at a time for a given row. |

-| 500 | 0 | Server cassandraError: something unexpected happened. This indicates a server-side bug. |

-| 503 | 4096 | Service unavailable. |

-| | 256 | This may be because of invalid connection credentials. Please check your connection credentials. |

-| | 10 | A client message triggered protocol violation. An example is query message sent before a startup one has been sent. |

-The CDBPartitionKeyRUConsumption table contains details on request unit (RU) consumption for logical keys in each region within each of their physical partitions.

-The CBDControlPlaneRequests table contains details on control plane operations, specifically for API for Cassandra accounts.

-The system view helps show metadata requests count by primary partition. It also helps identify throttled requests. The management operation shows the account activities such as creation, deletion, key, network and replication settings. Request volume per status code over a time period.

-The chart below shows a breakdown of requests by different status code. Understand the meaning of the different codes for your [API for Cassandra codes](./error-codes-solution.md).

-The actual minimum RU/s may vary depending on your account configuration. You can use [Azure Monitor metrics](monitor.md#view-operation-level-metrics-for-azure-cosmos-db) to view the history of provisioned throughput (RU/s) and storage on a resource.

-| Time limit for MongoDB shell in the Azure Portal | 120 minutes in a 24hr period |

-┬╣ Large document sizes up to 16 MB require feature enablement in Azure portal. Read the [feature documentation](../cosmos-db/mongodb/feature-support-42.md#data-types) to learn more.

-If you have an existing application using standard (manual) provisioned throughput, you can use [Azure Monitor metrics](insights-overview.md) to determine if your traffic pattern is suitable for autoscale.

-First, find the [normalized request unit consumption metric](monitor-normalized-request-units.md#view-the-normalized-request-unit-consumption-metric) of your database or container. Normalized utilization is a measure of how much you are currently using your standard (manual) provisioned throughput. The closer the number is to 100%, the more you are fully using your provisioned RU/s. [Learn more](monitor-normalized-request-units.md#view-the-normalized-request-unit-consumption-metric) about the metric.

-1. Set the **Aggregation** on the Noramlized RU Consumption metric to **Max**.

-Over time, after you've chosen the throughput type, you should monitor your application and make adjustments as needed.

-When using autoscale, use Azure Monitor to see the provisioned autoscale max RU/s (**Autoscale Max Throughput**) and the RU/s the system is currently scaled to (**Provisioned Throughput**). Below is an example of a variable or unpredictable workload using autoscale. Note when there isn't any traffic, the system scales the RU/s to the minimum of 10% of the max RU/s, which in this case is 5000 RU/s and 50,000 RU/s, respectively.

-> [!NOTE]

-> When you use standard (manual) provisioned throughput, the **Provisioned Throughput** metric refers to what you as a user have set. When you use autoscale throughput, this metric refers to the RU/s the system is currently scaled to.

-It's helpful to monitor some key metrics for the integrated cache. These metrics include:

-Platform metrics and Activity logs are gathered automatically. To collect resource logs and route them externally from Azure Monitor, you must establish a diagnostic setting. When you activate diagnostic settings for Azure Cosmos DB accounts, you must choose to route them to either a Log Analytics workspace or an Azure Storage account.

-### [Log Analytics workspace](#tab/log-analytics)

-1. Create shell variables for `clusterName` and `resourceGroupName`.

- ```azurecli

- # Variable for API for MongoDB vCore cluster resource

- clusterName="<resource-name>"

- # Variable for resource group

- resourceGroupName="<resource-group-name>"

- ```

-1. Create shell variables for `workspaceName` and `diagnosticSettingName`,

- ```azurecli

- # Variable for workspace name

- workspaceName="<storage-account-name>"

- # Variable for diagnostic setting name

- diagnosticSettingName="<diagnostic-setting-name>"

- ```

- > [!NOTE]

- > For example, if the Log Analytics workspace's name is `test-workspace` and the diagnostic settings' name is `test-setting`:

- >

- > ```azurecli

- > workspaceName="test-workspace"

- > diagnosticSettingName:"test-setting"

- > ```

- >

-1. Get the resource identifier for the API for MongoDB vCore cluster.

- ```azurecli

- az cosmosdb mongocluster show \

- --resource-group $resourceGroupName \

- --cluster-name $clusterName

- clusterResourceId=$(az cosmosdb mongocluster show \

- --resource-group $resourceGroupName \

- --cluster-name $clusterName \

- --query "id" \

- --output "tsv" \

- )

- ```

-1. Get the resource identifier for the Log Analytics workspace.

- ```azurecli

- az monitor log-analytics workspace show \

- --resource-group $resourceGroupName \

- --name $workspaceName

- workspaceResourceId=$(az monitor log-analytics workspace show \

- --resource-group $resourceGroupName \

- --name $workspaceName \

- --query "id" \

- --output "tsv" \

- )

- ```

-1. Use `az monitor diagnostic-settings create` to create the setting.

- ```azurecli

- az monitor diagnostic-settings create \

- --resource-group $resourceGroupName \

- --name $diagnosticSettingName \

- --resource $clusterResourceId \

- --export-to-resource-specific true \

- --logs '[{category:vCoreMongoRequests,enabled:true,retention-policy:{enabled:false,days:0}}]' \

- --workspace $workspaceResourceId

- ```

- > [!IMPORTANT]

- > By enabling the `--export-to-resource-specific true` setting, you ensure that the API for MongoDB vCore request log events are efficiently ingested into the `vCoreMongoRequests` table specifically designed with a dedicated schema.

- >

- > In contrast, neglecting to configure `--export-to-resource-specific true` would result in the API for MongoDB vCore request log events being routed to the general `AzureDiagnostics` table.

- >

- > It's important to note that when creating the diagnostic setting through the Portal, log events will currently flow to the `AzureDiagnostics` table. For customers who prefer exporting logs to the resource-specific `VCoreMongoRequests` table, utilizing the Azure CLI with the `--export-to-resource-specific true` option is recommended.

- >

-### [Azure Storage account](#tab/azure-storage)

-1. Create shell variables for `clusterName` and `resourceGroupName`.

- ```azurecli

- # Variable for API for MongoDB vCore cluster resource

- clusterName="<resource-name>"

- # Variable for resource group

- resourceGroupName="<resource-group-name>"

- ```

-1. Create shell variables for `storageAccountName` and `diagnosticSettingName`,

- ```azurecli

- # Variable for storage account name

- storageAccountName="<storage-account-name>"

- # Variable for diagnostic setting name

- diagnosticSettingName="<diagnostic-setting-name>"

- ```

- > [!NOTE]

- > For example, if the Azure Storage account's name is `teststorageaccount02909` and the diagnostic settings' name is `test-setting`:

- >

- > ```azurecli

- > storageAccountName="teststorageaccount02909"

- > diagnosticSettingName:"test-setting"

- > ```

- >

-1. Get the resource identifier for the API for MongoDB vCore cluster.

- ```azurecli

- az cosmosdb mongocluster show \

- --resource-group $resourceGroupName \

- --cluster-name $clusterName

- clusterResourceId=$(az cosmosdb mongocluster show \

- --resource-group $resourceGroupName \

- --cluster-name $clusterName \

- --query "id" \

- --output "tsv" \

- )

- ```

-1. Get the resource identifier for the Log Analytics workspace.

- ```azurecli

- az storage account show \

- --resource-group $resourceGroupName \

- --name $storageAccountName

- storageResourceId=$(az storage account show \

- --resource-group $resourceGroupName \

- --name $storageAccountName \

- --query "id" \

- --output "tsv" \

- )

- ```

-1. Use `az monitor diagnostic-settings create` to create the setting.

- ```azurecli

- az monitor diagnostic-settings create \

- --resource-group $resourceGroupName \

- --name $diagnosticSettingName \

- --resource $clusterResourceId \

- --logs '[{category:vCoreMongoRequests,enabled:true,retention-policy:{enabled:false,days:0}}]' \

- --storage-account $storageResourceId

- ```

-| | **Text Embedding Model** | **Language Model** |

-Diagnostic settings in Azure are used to collect resource logs. Resources emit Azure resource Logs and provide rich, frequent data about the operation of that resource. These logs are captured per request and are referred to as "data plane logs." Some examples of the data plane operations include delete, insert, and readFeed. The content of these logs varies by resource type.

-Platform metrics and the Activity logs are collected automatically, whereas you must create a diagnostic setting to collect resource logs or forward them outside of Azure Monitor. You can turn on diagnostic setting for Azure Cosmos DB accounts and send resource logs to the following sources:

- - Data sent to Log Analytics can be written into **Azure Diagnostics (legacy)** or **Resource-specific (preview)** tables

-> We recommend creating the diagnostic setting in resource-specific mode (for all APIs except API for Table) [following our instructions for creating diagnostics setting via REST API](monitor-resource-logs.md). This option provides additional cost-optimizations with an improved view for handling data.

-| [Change feed processor](change-feed-processor.md) | No | [>= 4.42.0](https://mvnrepository.com/artifact/com.azure/azure-cosmos/4.42.0) | No | No |

-The change feed processor in .NET is currently available only for [latest version mode](change-feed-modes.md#latest-version-change-feed-mode). The point of entry is always the monitored container. In a `Container` instance, you call `GetChangeFeedProcessorBuilder`:

-The first parameter is a distinct name that describes the goal of this processor. The second name is the delegate implementation that handles changes.

-Here's an example of a delegate:

-All versions and deletes mode is in preview and can be used with preview .NET SDK versions >= `3.32.0-preview`. Here's an example for obtaining `FeedIterator` in all versions and deletes mode that returns dynamic objects:

-FeedIterator<dynamic> InteratorWithDynamic = container.GetChangeFeedIterator<dynamic>(ChangeFeedStartFrom.Now(), ChangeFeedMode.AllVersionsAndDeletes);

-If this rate is slower than the rate at which your changes happen in your Azure Cosmos DB container, your processor will start to lag behind.

-Like the [change feed processor](./change-feed-processor.md), the change feed estimator can work as a push model. The estimator will measure the difference between the last processed item (defined by the state of the leases container) and the latest change in the container, and push this value to a delegate. The interval at which the measurement is taken can also be customized with a default value of 5 seconds.

-As an example, if your change feed processor is defined like this:

-The other two parameters are the delegate, which will receive a number that represents **how many changes are pending to be read** by the processor, and the time interval at which you want this measurement to be taken.

-Each `ChangeFeedProcessorState` will contain the lease and lag information, and also who is the current instance owning it.

-The change feed estimator does not need to be deployed as part of your change feed processor, nor be part of the same project. We recommend deploying the estimator on an independent and completely different instance from your processors. A single estimator instance can track the progress for the all the leases and instances in your change feed processor deployment.

-Each estimation will consume [request units](../request-units.md) from your [monitored and lease containers](change-feed-processor.md#components-of-the-change-feed-processor). A frequency of 1 minute in-between is a good starting point, the lower the frequency, the higher the request units consumed.

-The provided example represents a sample Java application that demonstrates the implementation of the Change Feed Processor with the estimation of the lag in processing change feed events. In the application - documents are being inserted into one container (the "feed container"), and meanwhile another worker thread or worker application is pulling inserted documents from the feed container's Change Feed and operating on them in some way.

-Change Feed Processor lag checking can be performed on a separate application (like a health monitor) as long as the same input containers (feedContainer and leaseContainer) and the exact same lease prefix (```CONTAINER_NAME + "-lease"```) are used. The estimator code requires that the Change Feed Processor had an opportunity to fully initialize the leaseContainer's documents.

-The estimator calculates the accumulated lag by retrieving the current state of the Change Feed Processor and summing up the estimated lag values for each event being processed:

-* [Usage samples on GitHub (.NET)](https://github.com/Azure/azure-cosmos-dotnet-v3/tree/master/Microsoft.Azure.Cosmos.Samples/Usage/ChangeFeed)

-You can now proceed to learn more about change feed processor in the following articles:

-1. Within the code cell, add the following code to upload data from this url: <https://cosmosnotebooksdata.blob.core.windows.net/notebookdata/websiteData.json>.

-1. Within the code cell, add the following code to upload data from this url: <https://cosmosnotebooksdata.blob.core.windows.net/notebookdata/websiteData.json>.

-You can start with a minimum throughput of 400 RU/sec and scale up to tens of millions of requests per second or even more. Each request you issue against your Azure Cosmos DB container ΓÇèor database, such as a read request, write request, query request, stored procedures have a corresponding cost that is deducted from your provisioned throughput. If you provision 400 RU/s and issue a query that costs 40 RUs, you will be able to issue 10 such queries per second. Any request beyond that will get rate-limited and you should retry the request. If you are using client drivers, they support the automatic retry logic.

-2. You are migrating from a single-tenant database designed to run on IaaS-hosted VMs or on-premises, for example, NoSQL or relational databases to Azure Cosmos DB. And if you have many collections/tables/graphs and you do not want to make any changes to your data model. Note, you might have to compromise some of the benefits offered by Azure Cosmos DB if you are not updating your data model when migrating from an on-premises database. It's recommended that you always reassess your data model to get the most in terms of performance and also to optimize for costs.

-1. You have a few Azure Cosmos DB containers. Because Azure Cosmos DB is schema-agnostic, a container can contain items that have heterogeneous schemas and does not require customers to create multiple container types, one for each entity. It is always an option to consider if grouping separate say 10-20 containers into a single container makes sense. With a 400 RUs minimum for containers, pooling all 10-20 containers into one could be more cost effective.

-1. As mentioned earlier, Azure Cosmos DB allows you to mix and match the above two strategies, so you can now have some containers within Azure Cosmos DB database, which may share the throughput provisioned on the database as well as, some containers within the same database, which may have dedicated amounts of provisioned throughput.

-If you have more than one client cumulatively operating consistently above the request rate, the default retry count, which is currently set to 9, may not be sufficient. In such cases, the client throws a `RequestRateTooLargeException` with status code 429 to the application. The default retry count can be changed by setting the `RetryOptions` on the ConnectionPolicy instance. By default, the `RequestRateTooLargeException` with status code 429 is returned after a cumulative wait time of 30 seconds if the request continues to operate above the request rate. This occurs even when the current retry count is less than the max retry count, be it the default of 9 or a user-defined value.

-Good partitioning strategy is important to optimize costs in Azure Cosmos DB. Ensure that there is no skew of partitions, which are exposed through storage metrics. Ensure that there is no skew of throughput for a partition, which is exposed with throughput metrics. Ensure that there is no skew towards particular partition keys. Dominant keys in storage are exposed through metrics but the key will be dependent on your application access pattern. It's best to think about the right logical partition key. A good partition key is expected to have the following characteristics:

-The basic idea is to spread the data and the activity in your container across the set of logical partitions, so that resources for data storage and throughput can be distributed across the logical partitions. Candidates for partition keys may include the properties that appear frequently as a filter in your queries. Queries can be efficiently routed by including the partition key in the filter predicate. With such a partitioning strategy, optimizing provisioned throughput will be a lot easier.

-The request charge or the request processing cost of a given operation is directly correlated to the size of the item. Operations on large items will cost more than operations on smaller items.

-It is always a good practice to logically separate your data into logical categories based on how frequently you access the data. By categorizing it as hot, medium, or cold data you can fine-tune the storage consumed and the throughput required. Depending on the frequency of access, you can place the data into separate containers (for example, tables, graphs, and collections) and fine-tune the provisioned throughput on them to accommodate to the needs of that segment of data.

-Furthermore, if you're using Azure Cosmos DB, and you know you are not going to search by certain data values or will rarely access them, you should store the compressed values of these attributes. With this method you save on storage space, index space, and provisioned throughput and result in lower costs.

-By default, Azure Cosmos DB automatically indexes every property of every record. This is intended to ease development and ensure excellent performance across many different types of ad hoc queries. If you have large records with thousands of properties, paying the throughput cost for indexing every property may not be useful, especially if you only query against 10 or 20 of those properties. As you get closer to getting a handle on your specific workload, our guidance is to tune your index policy. Full details on Azure Cosmos DB indexing policy can be found [here](index-policy.md).

-## Monitoring provisioned and consumed throughput

-You can monitor the total number of RUs provisioned, number of rate-limited requests as well as the number of RUs youΓÇÖve consumed in the Azure portal. The following image shows an example usage metric:

-You can also set alerts to check if the number of rate-limited requests exceeds a specific threshold. See [How to monitor Azure Cosmos DB](use-metrics.md) article for more details. These alerts can send an email to the account administrators or call a custom HTTP Webhook or an Azure Function to automatically increase provisioned throughput.

-Since you are billed for the throughput provisioned, matching the provisioned throughput to your needs can help you avoid the charges for the unused throughput. You can scale your provisioned throughput up or down any time, as needed. If your throughput needs are very predictable you can use Azure Functions and use a Timer Trigger to [increase or decrease throughput on a schedule](scale-on-schedule.md).

-* Monitoring the consumption of your RUs and the ratio of rate-limited requests may reveal that you do not need to keep provisioned throughout constant throughout the day or the week. You may receive less traffic at night or during the weekend. By using either Azure portal or Azure Cosmos DB native SDKs or REST API, you can scale your provisioned throughput at any time. Azure Cosmos DBΓÇÖs REST API provides endpoints to programmatically update the performance level of your containers making it straightforward to adjust the throughput from your code depending on the time of the day or the day of the week. The operation is performed without any downtime, and typically takes effect in less than a minute.

-* Remember, the billing is at the granularity of one hour, so you will not save any money if you change your provisioned throughput more often than one hour at a time.

-3. It's recommended to use one of the native Azure Cosmos DB SDKs to benefit from automatic retries when requests get rate-limited. If youΓÇÖre working on a platform that is not supported and use Azure Cosmos DBΓÇÖs REST API, implement your own retry policy using the `x-ms-retry-after-ms` header.

-7. Monitor your provisioned vs. consumed throughput ratio regularly to make sure you have not provisioned more than required number of containers and databases. Having a little over provisioned throughput is a good safety check.

-2. One method for estimating the amount of reserved throughput required by your application is to record the request unit RU charge associated with running typical operations against a representative Azure Cosmos DB container or database used by your application and then estimate the number of operations you anticipate to perform each second. Be sure to measure and include typical queries and their usage as well. To learn how to estimate RU costs of queries programmatically or using portal see [Optimizing the cost of queries](./optimize-cost-reads-writes.md).

-6. Make sure you have even distribution of data and workloads across logical partitions of your containers. If you have uneven partition distribution, this may cause to provision higher amount of throughput than the value that is needed. If you identify that you have a skewed distribution, we recommend redistributing the workload evenly across the partitions or repartition the data.

-7. If you have many containers and these containers do not require SLAs, you can use the database-based offer for the cases where the per container throughput SLAs do not apply. You should identify which of the Azure Cosmos DB containers you want to migrate to the database level throughput offer and then migrate them by using a change feed-based solution.

-## Monitoring Priority-based execution

-You can monitor the behavior of requests with low and high priority using Azure monitor metrics in Azure portal.

-## View insights from Azure portal

-1. Sign in to the [Azure portal](https://portal.azure.com) and navigate to your Azure Cosmos DB account.

-1. You can view your account metrics either from the **Metrics** pane or the **Insights** pane.

- * **Metrics:** This pane provides numerical metrics that are collected at regular intervals and describes some aspect of a system at a particular time. For example, you can view and monitor the [server side latency metric](monitor-server-side-latency.md), [normalized request unit usage metric](monitor-normalized-request-units.md), etc.

- * **Insights:** This pane provides a customized monitoring experience for Azure Cosmos DB. Insights use the same metrics and logs that are collected in Azure Monitor and show an aggregated view for your account.

-1. Open the **Insights** pane. By default, the Insights pane shows the throughput, requests, storage, availability, latency, system, and management operations metrics for every container in your account. You can select the **Time Range**, **Database**, and **Container** for which you want to view insights. The **Overview** tab shows RU/s usage, data usage, index usage, throttled requests, and normalized RU/s consumption for the selected database and container.

- :::image type="content" source="./media/use-metrics/performance-metrics.png" alt-text="Screenshot of Azure Cosmos DB performance metrics in the Azure portal." lightbox="./media/use-metrics/performance-metrics.png" :::

-1. The following metrics are available from the **Insights** pane:

- * **Throughput**. This tab shows the total number of request units consumed or failed (429 response code) because the throughput or storage capacity provisioned for the container has exceeded.

- * **Requests**. This tab shows the total number of requests processed by status code, by operation type, and the count of failed requests (429 response code). Requests fail when the throughput or storage capacity provisioned for the container exceeds.

- * **Storage**. This tab shows the size of data and index usage over the selected time period.

- * **Availability**. This tab shows the percentage of successful requests over the total requests per hour. The Azure Cosmos DB SLAs defines the success rate.

- * **Latency**. This tab shows the read and write latency observed by Azure Cosmos DB in the region where your account is operating. You can visualize latency across regions for a geo-replicated account. You can also view server-side latency by different operations. This metric doesn't represent the end-to-end request latency.

- * **System**. This tab shows how many metadata requests that the primary partition serves. It also helps to identify the throttled requests.

- * **Management Operations**. This tab shows the metrics for account management activities such as account creation, deletion, key updates, network and replication settings.

-* Engage with us on [Twitter](https://twitter.com/azuresupport)

-* Engage with us on [Twitter](https://twitter.com/azuresupport)

-# Copy data from Amazon Marketplace Web Service using Azure Data Factory or Synapse Analytics

-This article outlines how to use the Copy Activity in an Azure Data Factory or Synapse Analytics pipeline to copy data from Amazon Marketplace Web Service. It builds on the [copy activity overview](copy-activity-overview.md) article that presents a general overview of copy activity.

-## Supported capabilities

-This Amazon Marketplace Web Service connector is supported for the following capabilities:

-| Supported capabilities|IR |

-|| --|

-|[Copy activity](copy-activity-overview.md) (source/-)|&#9312; &#9313;|

-|[Lookup activity](control-flow-lookup-activity.md)|&#9312; &#9313;|

-*&#9312; Azure integration runtime &#9313; Self-hosted integration runtime*

- For a list of data stores that are supported as sources/sinks, see the [Supported data stores](connector-overview.md#supported-data-stores) table.

-The service provides a built-in driver to enable connectivity, therefore you don't need to manually install any driver using this connector.

-## Getting started

-## Create a linked service to Amazon Marketplace Web Service using UI

-Use the following steps to create a linked service to Amazon Marketplace Web Service in the Azure portal UI.

-1. Browse to the Manage tab in your Azure Data Factory or Synapse workspace and select Linked Services, then click New:

- # [Azure Data Factory](#tab/data-factory)

- :::image type="content" source="media/doc-common-process/new-linked-service.png" alt-text="Screenshot of creating a new linked service with Azure Data Factory UI.":::

- # [Azure Synapse](#tab/synapse-analytics)

- :::image type="content" source="media/doc-common-process/new-linked-service-synapse.png" alt-text="Screenshot of creating a new linked service with Azure Synapse UI.":::

-2. Search for Amazon and select the Amazon Marketplace Web Service connector.

- :::image type="content" source="media/connector-amazon-marketplace-web-service/amazon-marketplace-web-service-connector.png" alt-text="Screenshot of the Amazon Marketplace Web Service connector.":::

-1. Configure the service details, test the connection, and create the new linked service.

- :::image type="content" source="media/connector-amazon-marketplace-web-service/configure-amazon-marketplace-web-service-linked-service.png" alt-text="Screenshot of linked service configuration for Amazon Marketplace Web Service.":::

-## Connector configuration details

-The following sections provide details about properties that are used to define Data Factory entities specific to Amazon Marketplace Web Service connector.

-## Linked service properties

-The following properties are supported for Amazon Marketplace Web Service linked service:

-| Property | Description | Required |

-|: |: |: |

-| type | The type property must be set to: **AmazonMWS** | Yes |

-| endpoint | The endpoint of the Amazon MWS Server (that is, mws.amazonservices.com) | Yes |

-| marketplaceID | The Amazon Marketplace ID you want to retrieve data from. To retrieve data from multiple Marketplace IDs, separate them with a comma (`,`). (that is, A2EUQ1WTGCTBG2) | Yes |

-| sellerID | The Amazon seller ID. | Yes |

-| mwsAuthToken | The Amazon MWS authentication token. Mark this field as a SecureString to store it securely, or [reference a secret stored in Azure Key Vault](store-credentials-in-key-vault.md). | Yes |

-| accessKeyId | The access key ID used to access data. | Yes |

-| secretKey | The secret key used to access data. Mark this field as a SecureString to store it securely, or [reference a secret stored in Azure Key Vault](store-credentials-in-key-vault.md). | Yes |

-| useEncryptedEndpoints | Specifies whether the data source endpoints are encrypted using HTTPS. The default value is true. | No |

-| useHostVerification | Specifies whether to require the host name in the server's certificate to match the host name of the server when connecting over TLS. The default value is true. | No |

-| usePeerVerification | Specifies whether to verify the identity of the server when connecting over TLS. The default value is true. | No |

-**Example:**

-```json

-{

- "name": "AmazonMWSLinkedService",

- "properties": {

- "type": "AmazonMWS",

- "typeProperties": {

- "endpoint" : "mws.amazonservices.com",

- "marketplaceID" : "A2EUQ1WTGCTBG2",

- "sellerID" : "<sellerID>",

- "mwsAuthToken": {

- "type": "SecureString",

- "value": "<mwsAuthToken>"

- },

- "accessKeyId" : "<accessKeyId>",

- "secretKey": {

- "type": "SecureString",

- "value": "<secretKey>"

- }

- }

- }

-}

-```

-## Dataset properties

-For a full list of sections and properties available for defining datasets, see the [datasets](concepts-datasets-linked-services.md) article. This section provides a list of properties supported by Amazon Marketplace Web Service dataset.

-To copy data from Amazon Marketplace Web Service, set the type property of the dataset to **AmazonMWSObject**. The following properties are supported:

-| Property | Description | Required |

-|: |: |: |

-| type | The type property of the dataset must be set to: **AmazonMWSObject** | Yes |

-| tableName | Name of the table. | No (if "query" in activity source is specified) |

-**Example**

-```json

-{

- "name": "AmazonMWSDataset",

- "properties": {

- "type": "AmazonMWSObject",

- "typeProperties": {},

- "schema": [],

- "linkedServiceName": {

- "referenceName": "<AmazonMWS linked service name>",

- "type": "LinkedServiceReference"

- }

- }

-}

-```

-## Copy activity properties

-For a full list of sections and properties available for defining activities, see the [Pipelines](concepts-pipelines-activities.md) article. This section provides a list of properties supported by Amazon Marketplace Web Service source.

-### Amazon MWS as source

-To copy data from Amazon Marketplace Web Service, set the source type in the copy activity to **AmazonMWSSource**. The following properties are supported in the copy activity **source** section:

-| Property | Description | Required |

-|: |: |: |

-| type | The type property of the copy activity source must be set to: **AmazonMWSSource** | Yes |

-| query | Use the custom SQL query to read data. For example: `"SELECT * FROM Orders where Amazon_Order_Id = 'xx'"`. | No (if "tableName" in dataset is specified) |

-**Example:**

-```json

-"activities":[

- {

- "name": "CopyFromAmazonMWS",

- "type": "Copy",

- "inputs": [

- {

- "referenceName": "<AmazonMWS input dataset name>",

- "type": "DatasetReference"

- }

- ],

- "outputs": [

- {

- "referenceName": "<output dataset name>",

- "type": "DatasetReference"

- }

- ],

- "typeProperties": {

- "source": {

- "type": "AmazonMWSSource",

- "query": "SELECT * FROM Orders where Amazon_Order_Id = 'xx'"

- },

- "sink": {

- "type": "<sink type>"

- }

- }

- }

-]

-```

-## Lookup activity properties

-To learn details about the properties, check [Lookup activity](control-flow-lookup-activity.md).

-For a list of data stores supported as sources and sinks by the copy activity, see [supported data stores](copy-activity-overview.md#supported-data-stores-and-formats).

-Autoscaling: Automatically adjusts resources based on traffic load.

-Multi-Availability Zone Operation: Provides resilience by operating across multiple availability zones.

-Logic Apps provides many connectors that make it easy to integrate a service with other clients, like Office 365 and Twitter. At a high level, the steps to set up a Logic App for email notification are:

-You can also test this functionality live by [sending a custom event with CURL from the Portal](./custom-event-quickstart-portal.md) or by [posting to a custom topic](./post-to-custom-topic.md) using any service or application that can POST to an endpoint such as [Postman](https://www.getpostman.com/). Create a custom topic and an event subscription with the endpoint set as the Function URL.

-The following sections show you how to validate an event subscriptions using Postman and Curl.

-## Validate Event Grid event subscription using Postman

-Here's an example of using Postman for validating a webhook subscription of an Event Grid event:

-

-Here is a sample **SubscriptionValidationEvent** JSON:

-To learn more about Event Grid event validation for webhooks, see [Endpoint validation with event grid events](webhook-event-delivery.md#endpoint-validation-with-event-grid-events).

-## Validate cloud event subscription using Postman

-Here's an example of using Postman for validating a webhook subscription of a cloud event:

-

-| **[Cyxtera](https://www.cyxtera.com/data-center-services/interconnection)** | Megaport<br/>PacketFabric |

-> We recommend to use [service tag](hdinsight-service-tags.md) feature for network security groups. If you require region specific service tags, please refer the [Azure IP Ranges and Service Tags ΓÇô Public Cloud](https://download.microsoft.com/download/7/1/D/71D86715-5596-4529-9B13-DA13A5DE5B63/ServiceTags_Public_20240624.json)

-1. Open the Play Store on your Chromebook, and search for **Microsoft Remote Desktop**.

- :::image type="content" source="./media/connect-virtual-machine-chromebook-remote-desktop/install-remote-desktop-chromebook.png" alt-text="Screenshot of the Microsoft Remote Desktop app in the app store." lightbox="./media/connect-virtual-machine-chromebook-remote-desktop/install-remote-desktop-chromebook.png":::

-1. Select **Install** to install the latest version of the Remote Desktop application by Microsoft Corporation.

- In this Convert Word to Vector component, we provided three different strategies: two online-training models and one pretrained model. The online-training models use your input dataset as training data, and generate vocabulary and word vectors during training. The pretrained model is already trained by a much larger text corpus, such as Wikipedia or Twitter text. The pretrained model is actually a collection of word/embedding pairs.

-The following table lists the support matrix when authenticating to __Azure Container Registry__, depending on the authentication method and the __Azure Container Registry's__ [public network access configuration](/azure/container-registry/container-registry-access-selected-networks).

-Before we dive in the code, you need a way to reference your workspace. You create `ml_client` for a handle to the workspace. Refer to [Create handle to workspace](./tutorial-explore-data.md#create-handle-to-workspace) to initialize `ml_client`.

-Before we dive in the code, you need a way to reference your workspace. You create `ml_client` for a handle to the workspace. Refer to [Create handle to workspace](./tutorial-explore-data.md#create-handle-to-workspace) to initialize `ml_client`.

-To resolve this, please [build your image separately](https://learn.microsoft.com/azure/devops/pipelines/ecosystems/containers/publish-to-acr?view=azure-devops&tabs=javascript%2Cportal%2Cmsi) so that the image only needs to be pulled during deployment creation.

-description: Upload data to cloud storage, create an Azure Machine Learning data asset, create new versions for data assets, use the data for interactive development

-# Tutorial: Upload, access and explore your data in Azure Machine Learning

-The start of a machine learning project typically involves exploratory data analysis (EDA), data-preprocessing (cleaning, feature engineering), and the building of Machine Learning model prototypes to validate hypotheses. This _prototyping_ project phase is highly interactive. It lends itself to development in an IDE or a Jupyter notebook, with a _Python interactive console_. This tutorial describes these ideas.

-This video shows how to get started in Azure Machine Learning studio so that you can follow the steps in the tutorial. The video shows how to create a notebook, clone the notebook, create a compute instance, and download the data needed for the tutorial. The steps are also described in the following sections.

-For data ingestion, the Azure Data Explorer handles raw data in [these formats](/azure/data-explorer/ingestion-supported-formats). This tutorial uses this [CSV-format credit card client data sample](https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv). We see the steps proceed in an Azure Machine Learning resource. In that resource, we'll create a local folder with the suggested name of **data** directly under the folder where this notebook is located.

-> This tutorial depends on data placed in an Azure Machine Learning resource folder location. For this tutorial, 'local' means a folder location in that Azure Machine Learning resource.

-1. The terminal window opens in a new tab.

-1. Make sure you `cd` to the same folder where this notebook is located. For example, if the notebook is in a folder named **get-started-notebooks**:

-[Learn more about this data on the UCI Machine Learning Repository.](https://archive.ics.uci.edu/ml/datasets/default+of+credit+card+clients)

-## Create handle to workspace

-Before we dive in the code, you need a way to reference your workspace. You'll create `ml_client` for a handle to the workspace. You'll then use `ml_client` to manage resources and jobs.

-1. In the upper right Azure Machine Learning studio toolbar, select your workspace name.

-1. Copy the value for workspace, resource group and subscription ID into the code.

-1. You'll need to copy one value, close the area and paste, then come back for the next one.

-> Creating MLClient will not connect to the workspace. The client initialization is lazy, it will wait for the first time it needs to make a call (this will happen in the next code cell).

-Azure Machine Learning uses Uniform Resource Identifiers (URIs), which point to storage locations in the cloud. A URI makes it easy to access data in notebooks and jobs. Data URI formats look similar to the web URLs that you use in your web browser to access web pages. For example:

-Data asset creation also creates a *reference* to the data source location, along with a copy of its metadata. Because the data remains in its existing location, you incur no extra storage cost, and don't risk data source integrity. You can create Data assets from Azure Machine Learning datastores, Azure Storage, public URLs, and local files.

-> For smaller-size data uploads, Azure Machine Learning data asset creation works well for data uploads from local machine resources to cloud storage. This approach avoids the need for extra tools or utilities. However, a larger-size data upload might require a dedicated tool or utility - for example, **azcopy**. The azcopy command-line tool moves data to and from Azure Storage. Learn more about azcopy [here](../storage/common/storage-use-azcopy-v10.md).

-The next notebook cell creates the data asset. The code sample uploads the raw data file to the designated cloud storage resource.

-Each time you create a data asset, you need a unique version for it. If the version already exists, you'll get an error. In this code, we're using the "initial" for the first read of the data. If that version already exists, we'll skip creating it again.

-You can also omit the **version** parameter, and a version number is generated for you, starting with 1 and then incrementing from there.

-In this tutorial, we use the name "initial" as the first version. The [Create production machine learning pipelines](tutorial-pipeline-python-sdk.md) tutorial will also use this version of the data, so here we are using a value that you'll see again in that tutorial.

-You can see the uploaded data by selecting **Data** on the left. You'll see the data is uploaded and a data asset is created:

-This data is named **credit-card**, and in the **Data assets** tab, we can see it in the **Name** column. This data uploaded to your workspace's default datastore named **workspaceblobstore**, seen in the **Data source** column.

-1. A common and easy-to-use API, to interact with different storage types (Blob/Files/Azure Data Lake Storage) and authentication methods.

-However, as mentioned previously, it can become hard to remember these URIs. Additionally, you must manually substitute all **<_substring_>** values in the **pd.read_csv** command with the real values for your resources.

-Read [Access data from Azure cloud storage during interactive development](how-to-access-data-interactive.md) to learn more about data access in a notebook.

-You might have noticed that the data needs a little light cleaning, to make it fit to train a machine learning model. It has:

-Also, compared to the CSV format, the Parquet file format becomes a better way to store this data. Parquet offers compression, and it maintains schema. Therefore, to clean the data and store it in Parquet, use:

-Next, create a new _version_ of the data asset (the data automatically uploads to cloud storage). For this version, we'll add a time value, so that each time this code is run, a different version number will be created.

-If you're not going to use it now, stop the compute instance:

-Read [Create data assets](how-to-create-data-assets.md) for more information about data assets.

-Read [Create datastores](how-to-datastore.md) to learn more about datastores.

-Continue with tutorials to learn how to develop a training script.

-|IMDB Movie Titles|The dataset contains information about movies that were rated in Twitter tweets: IMDB movie ID, movie name, genre, and production year. There are 17K movies in the dataset. The dataset was introduced in the paper "S. Dooms, T. De Pessemier and L. Martens. MovieTweetings: a Movie Rating Dataset Collected From Twitter. Workshop on Crowdsourcing and Human Computation for Recommender Systems, CrowdRec at RecSys 2013."|

-|Movie Ratings|The dataset is an extended version of the Movie Tweetings dataset. The dataset has 170K ratings for movies, extracted from well-structured tweets on Twitter. Each instance represents a tweet and is a tuple: user ID, IMDB movie ID, rating, timestamp, number of favorites for this tweet, and number of retweets of this tweet. The dataset was made available by A. Said, S. Dooms, B. Loni and D. Tikk for Recommender Systems Challenge 2014.|

-PowerCLI | [PowerCLI version 6.0](https://my.vmware.com/web/vmware/details?productId=491&downloadGroup=PCLI600R1) should be installed if the replication appliance is running on a VMware VM.

- Target settings | **Reserved instance** | Specify whether you want to use reserve instances for Azure VMware Solution nodes when you migrate your VMs. If you decide to use a reserved instance, you can't specify **Discount (%)**. [Learn more](https://learn.microsoft.com/azure/azure-vmware/reserved-instance) about reserved instances.

-1. Select **Save** to apply the changes.

-1. Select **Discard** to close the settings page without making changes.

-| source | string | 9 | Phone Mobile/Open311 | Mechanism or path by which the service request was received; typically ΓÇ£PhoneΓÇ¥, ΓÇ£Text/SMSΓÇ¥, ΓÇ£WebsiteΓÇ¥, ΓÇ£Mobile AppΓÇ¥, ΓÇ£TwitterΓÇ¥, etc. but terms may vary by system. |

-<li>Scale and/or resize control plane nodes to maintain quality of service

-* Don't attempt to remove or replace a master node. That's a high risk operation that can cause issues with etcd, permanent network loss, and loss of access and manageability by ARO SRE. If you feel that a master node should be replaced or removed, contact support before making any changes.

-[vm-netattach]: https://learn.microsoft.com/rest/api/networkcloud/virtual-machines/create-or-update?view=rest-networkcloud-2023-07-01&tabs=HTTP#networkattachment

-[attachednetconf]: https://learn.microsoft.com/rest/api/networkcloud/kubernetes-clusters/create-or-update?view=rest-networkcloud-2023-07-01&tabs=HTTP#attachednetworkconfiguration

-| [France-IX](https://www.franceix.net/en/english-services/cloud-access/microsoft-azure-peering-service) | Europe |

-| Paris | [France-IX](https://www.franceix.net/en/english-services/cloud-access/microsoft-azure-peering-service) |

-pg_catalog.pgaadauth_create_principal(roleName text, objectId text, objectType text, isAdmin boolean, isMfa boolean)

- :::image type="content" source="./media/how-to-restore-server-portal/restore-custom-2.png" alt-text="Screenshot that shows selections for restoring to a custom restore point.":::

- :::image type="content" source="./media/how-to-restore-server-portal/geo-restore-click.png" alt-text="Screenshot that shows the Restore button.":::

-3. Under **Source details**, for **Geo-redundant restore**, select the **Restore to paired region** checkbox.

-By default, the `UTF-8` encoding is assumed. To specify a different encoding, use the `encoding` configuration property:

- "parameters" : { "configuration" : { "parsingMode" : "text", "encoding" : "windows-1252" } }

-| **Supported by** | [Better Mobile Security Inc.](https://www.better.mobi/about#contact-us) |

-| **Supported by** | [Trend Micro](https://success.trendmicro.com/dcx/s/?language=en_US) |

-| **Supported by** | [Trend Micro](https://success.trendmicro.com/dcx/s/contactus?language=en_US) |

-| **Supported by** | [Trend Micro](https://success.trendmicro.com/dcx/s/?language=en_US) |

-The [VMware Carbon Black Cloud](https://www.vmware.com/products/carbon-black-cloud.html) connector provides the capability to ingest Carbon Black data into Microsoft Sentinel. The connector provides visibility into Audit, Notification and Event logs in Microsoft Sentinel to view dashboards, create custom alerts, and to improve monitoring and investigation capabilities.

-The [vCenter](https://www.vmware.com/in/products/vcenter-server.html) connector allows you to easily connect your vCenter server logs with Microsoft Sentinel. This gives you more insight into your organization's data centers and improves your security operation capabilities.

-To peek into **Dead-lettered** messages of a queue or subscription, the peek operation should be run on the dead letter queue associated with the queue or subscription. For more information, see [accessing dead letter queues](service-bus-dead-letter-queues.md#path-to-the-dead-letter-queue).

-Here's an example snippet for peeking all messages with the Python Service Bus SDK. The `sequence_number​` can be used to track the last peeked message and start browsing at the next message.

-description: This article provides the configuration necessary to deploy a Service Fabric managed cluster with different subnets per secondary NodeType.

-Service Fabric managed clusters now supports different subnets per secondary NodeType in a [Bring-Your-Own-Virtual-Network scenario](how-to-managed-cluster-networking.md#bring-your-own-virtual-network). With different subnets per NodeType, customers can have specific applications deployed to specific subnets and utilize traffic management via Network Security Group (NSG) rules. Customers can expect increased network isolation for their deployments through this configuration.

-* **Only secondary NodeTypes** can support subnet per NodeType.

-For ASP.NET Core, the primary mechanism for [authenticating users](/dotnet/standard/microservices-architecture/secure-net-microservices-web-applications/) is the ASP.NET Core Identity membership system. ASP.NET Core Identity stores user information (including sign-in information, roles, and claims) in a data store configured by the developer. ASP.NET Core Identity supports two-factor authentication. External authentication providers are also supported, so users can sign in using existing authentication processes from providers like Microsoft, Google, Facebook, or Twitter.

-|Profiling and throughput measurement| <ul><li>Operating system: Windows Server 2016 or Windows Server 2012 R2<br>(ideally matching at least the [size recommendations for the configuration server](/en-in/azure/site-recovery/site-recovery-plan-capacity-vmware#size-recommendations-for-the-configuration-server))</li><li>Machine configuration: 8 vCPUs, 16 GB RAM, 300 GB HDD</li><li>[.NET Framework 4.5](https://aka.ms/dotnet-framework-45)</li><li>[VMware vSphere PowerCLI 6.0 R3](https://aka.ms/download_powercli)</li><li>[Visual C++ Redistributable for Visual Studio 2012](https://aka.ms/vcplusplus-redistributable)</li><li>Internet access to Azure (`*.blob.core.windows.net`) from this server, port 443<br>[This is optional. You can choose to provide the available bandwidth during Report Generation manually.]</li><li>Azure storage account</li><li>Administrator access on the server</li><li>Minimum 100 GB of free disk space (assuming 1,000 VMs with an average of three disks each, profiled for 30 days)</li><li>VMware vCenter statistics level settings can be 1 or higher level</li><li>Allow vCenter port (default 443): Site Recovery Deployment Planner uses this port to connect to the vCenter server/ESXi host</ul></ul>|

-| Report generation | A Windows PC or Windows Server with Excel 2013 or later.<li>[.NET Framework 4.5](https://aka.ms/dotnet-framework-45)</li><li>[Visual C++ Redistributable for Visual Studio 2012](https://aka.ms/vcplusplus-redistributable)</li><li>[VMware vSphere PowerCLI 6.0 R3](https://aka.ms/download_powercli) is required only when you pass -User option in the report generation command to fetch the latest VM configuration information of the VMs. The Deployment Planner connects to vCenter server. Allow vCenter port (default 443) port to connect to vCenter server.</li>|

-## Next step

-[Customer responsibilities for running Azure Spring Apps in a virtual network](vnet-customer-responsibilities.md)

-When transitioning on-premises workloads to Azure Storage, reducing downtime and ensuring predictable periods of unavailability is crucial for users and business operations. For the initial bulk migration, you can use [Azure Data Box](https://learn.microsoft.com/azure/databox/) and combine it with Azure Storage Mover for online catch-up.

-You can now test the wiring between the local function and the database by debugging (F5 in Visual Studio Code). The SQL database needs to be reachable from your machine. [SSMS](/sql/ssms/sql-server-management-studio-ssms) can be used to check connectivity. Then a tool like [Postman](https://www.postman.com/) can be used to issue POST requests to the local endpoint. A request with an empty body should return http 204. A request with an actual payload should be persisted in the destination table (in replace / update mode). Here's a sample payload corresponding to the schema used in this sample:

-You can now test the wiring between the local function and the database by debugging (F5 in VS Code). The SQL database needs to be reachable from your machine. [SSMS](/sql/ssms/sql-server-management-studio-ssms) can be used to check connectivity. Then a tool like [Postman](https://www.postman.com/) can be used to issue POST requests to the local endpoint. A request with an empty body should return http 204. A request with an actual payload should be persisted in the destination table (in accumulate / merge mode). Here's a sample payload corresponding to the schema used in this sample:

-Synapse notebooks provide code snippets that make it easier to enter common used code patterns, such as configuring your Spark session, reading data as a Spark DataFrame, or drawing charts with matplotlib etc.

-A step-by-step cell execution status is displayed beneath the cell to help you see its current progress. Once the cell run is complete, an execution summary with the total duration and end time are shown and kept there for future reference.

-Microsoft's general trademark guidelines can be found at [https://go.microsoft.com/fwlink/?LinkID=254653](https://go.microsoft.com/fwlink/?LinkID=254653).

-> * Go to theΓÇ»[Contoso Wind Farm demo](https://insights.timeseries.azure.com/preview/samples) environment for a live Time Series Model example.

-The [Contoso Wind Farm demo](https://insights.timeseries.azure.com/preview/samples) provides several live instance examples.

-The [Contoso Wind Farm demo](https://insights.timeseries.azure.com/preview/samples) displays a standard instance and type hierarchy.

-The [Contoso Wind Farm demo](https://insights.timeseries.azure.com/preview/samples) visualizes several Time Series Model types associated with their respective instances.

-This article describes the various features and options available within the Azure Time Series Insights Gen2 [Demo environment](https://insights.timeseries.azure.com/preview/demo).

-* Use it to view the Gen2 [Demo environment](https://insights.timeseries.azure.com/preview/demo).

-To help users migrate their [Time Series Model variables](./concepts-variables.md) and saved queries, there is a built-in tool available through the [Azure Time Series Insights Explorer](https://insights.timeseries.azure.com). Navigate to the environment you wish to migrate and follow the steps below. **You can complete the migration partially and return to complete it at a later time, however, none of the updates can be reverted.**

-There are several common reasons why your data might not appear in the [Azure Time Series Insights Gen2 Explorer](https://insights.timeseries.azure.com/preview).

-* Access your environment in the [Azure Time Series Insight Explorer](https://insights.timeseries.azure.com).

-For many customers, the Time Series Model maps to an existing asset model or ERP system already in place. If you don't have an existing model, a prebuilt user experience is [provided](https://github.com/Microsoft/tsiclient) to get up and running quickly. To envision how a model might help you, view the [sample demo environment](https://insights.timeseries.azure.com/preview/demo).

-1. Go to theΓÇ»[Contoso Wind Farm demo](https://insights.timeseries.azure.com/preview/samples) environment.

-If no data is appearing in the [Azure Time Series Insights explorer](https://insights.timeseries.azure.com), consider these common causes.

-1. Increase the SKU capacity to the maximum allowed value (10, in this case). After you increase capacity, the ingress process starts to catch up much more quickly. You're charged for the increased capacity. To visualize how quickly you're catching up, you can view the availability chart in the [Azure Time Series Insights explorer](https://insights.timeseries.azure.com).

-This article describes the features and options for the Azure Time Series Insights Gen1 [Explorer web app](https://insights.timeseries.azure.com/). The Azure Time Series Insights Explorer demonstrates the powerful data visualization capabilities provided by the service and can be accessed within your own environment.

-1. To start, open the [Azure Time Series Insights Explorer](https://insights.timeseries.azure.com/) in your web browser. On the left side of the window, select an environment. All environments that you have access to are listed in alphabetical order.

- Environment name | A unique name | This name represents the environment in [time series Explorer](https://insights.timeseries.azure.com)

-* [Send events](time-series-insights-send-events.md) to the event source.

-* View your environment in [Azure Time Series Insights Explorer](https://insights.timeseries.azure.com).

-> * View the free [Azure Time Series Insights demo](https://insights.timeseries.azure.com/samples).

-> [!TIP]

-> See the Explorer live [using the URL](https://insights.timeseries.azure.com/classic/samples?environmentId=10000000-0000-0000-0000-100000000108&relativeMillis=3600000&timeSeriesDefinitions=[%7B%22name%22:%22F1PressureId%22,%22splitBy%22:%22Id%22,%22measureName%22:%22Pressure%22,%22predicate%22:%22%27Factory1%27%22%7D,%7B%22name%22:%22F2TempStation%22,%22splitBy%22:%22Station%22,%22measureName%22:%22Temperature%22,%22predicate%22:%22%27Factory2%27%22%7D,%7B%22name%22:%22F3VibrationPL%22,%22splitBy%22:%22ProductionLine%22,%22measureName%22:%22Vibration%22,%22predicate%22:%22%27Factory3%27%22%7D]) example above.

-* [View your environment](https://insights.timeseries.azure.com) in the Azure Time Series Insights Explorer.

-1. In your browser, go to the [Gen1 demo](https://insights.timeseries.azure.com/demo).

-Update Manager is a unified service to help manage and govern updates for all your machines. You can monitor Windows and Linux update compliance across your machines in Azure and on-premises/on other cloud platforms (connected by [Azure Arc](https://learn.microsoft.com/azure/azure-arc/)) from a single pane of management. You can also use Update Manager to make real-time updates or schedule them within a defined maintenance window.

- - [Automatic virtual machine (VM) guest patching](../virtual-machines/automatic-vm-guest-patching.md) and [hot patching](https://learn.microsoft.com/azure/automanage/automanage-hotpatch) for Azure VMs.

- - [Hybrid machines](https://learn.microsoft.com/azure/azure-arc/servers/)

- - [VMWare machines](https://learn.microsoft.com/azure/azure-arc/vmware-vsphere/)

- - [SCVMM machines](https://learn.microsoft.com/azure/azure-arc/system-center-virtual-machine-manager/)

- - [Azure Stack HCI VMs](https://learn.microsoft.com/azure-stack/hci/)

- - Secure machines with new ways of patching such as [automatic VM guest patching](../virtual-machines/automatic-vm-guest-patching.md) in Azure, [hot patching](https://learn.microsoft.com/azure/automanage/automanage-hotpatch) or [custom maintenance schedules](https://aka.ms/umc-scheduled-patching).

-1. Create a maintenance configuration by following the steps listed [here](https://learn.microsoft.com/rest/api/maintenance/maintenance-configurations/create-or-update?view=rest-maintenance-2023-09-01-preview&tabs=HTTP).

-For Windows machines, you must allow traffic to any endpoints required by the Windows Update agent. You can find an updated list of required endpoints in [issues related to HTTP Proxy](https://learn.microsoft.com/troubleshoot/windows-client/installing-updates-features-roles/windows-update-issues-troubleshooting?toc=%2Fwindows%2Fdeployment%2Ftoc.json&bc=%2Fwindows%2Fdeployment%2Fbreadcrumb%2Ftoc.json#issues-related-to-httpproxy). If you have a local [WSUS](https://learn.microsoft.com/windows-server/administration/windows-server-update-services/plan/plan-your-wsus-deployment) deployment, you must allow traffic to the server specified in your [WSUS key](https://learn.microsoft.com/windows/deployment/update/waas-wu-settings#configuring-automatic-updates-by-editing-the-registry).

-Azure Update Manager relies on the [Windows Update client](https://learn.microsoft.com/windows/deployment/update/windows-update-overview) to download and install Windows updates. There are specific settings that are used by the Windows Update client when connecting to Windows Server Update Services (WSUS) or Windows Update. For more information, see [configure Windows Update client](configure-wu-agent.md).

-Using Azure Update Manager, you can deploy Extended Security Updates for your Azure Arc-enabled Windows Server 2012 / R2 machines. ESUs are available are default to Azure Virtual machines. To enroll in Windows Server 2012 Extended Security Updates on Arc connected machines, follow the guidance on [How to get Extended Security Updates (ESU) for Windows Server 2012 and 2012 R2 via Azure Arc](https://learn.microsoft.com/windows-server/get-started/extended-security-updates-deploy#extended-security-updates-enabled-by-azure-arc).

-Update Manager relies on the locally configured update repository to update supported Windows systems, either WSUS or Windows Update. Tools such as [System Center Updates Publisher](https://learn.microsoft.com/mem/configmgr/sum/tools/updates-publisher) allow you to import and publish custom updates with WSUS. This scenario allows Update Manager to update machines that use Configuration Manager as their update repository with third party software. To learn how to configure Updates Publisher, see [Install Updates Publisher](https://learn.microsoft.com/mem/configmgr/sum/tools/install-updates-publisher).

-If the [Windows Update Agent (WUA)](https://learn.microsoft.com/windows/win32/wua_sdk/updating-the-windows-update-agent) is configured to fetch updates from Windows Update repository or Microsoft Update repository or [Windows Server Update Services](https://learn.microsoft.com/windows-server/administration/windows-server-update-services/get-started/windows-server-update-services-wsus) (WSUS), AUM will honor these settings. For more information, see how to [configure Windows Update client](https://learn.microsoft.com/windows-server/administration/windows-server-update-services/get-started/windows-server-update-services-wsus). By default, **it is configured to fetch updates from Windows Updates repository**.

- - Twitter

-[Activity Log](https://learn.microsoft.com/azure/azure-monitor/essentials/activity-log?tabs=powershell) is a subscription log that provides insight into subscription-level events that have occurred in Azure. Customers are able to:

-An [action group](https://learn.microsoft.com/azure/azure-monitor/alerts/action-groups) is a collection of notification preferences defined by the owner of an Azure subscription. Azure Monitor and Service Health alerts use action groups to notify users that an alert has been triggered.

-* [ARM Resource Manager](https://learn.microsoft.com/azure/azure-monitor/alerts/action-groups#create-an-action-group-with-a-resource-manager-template)

-* [Portal](https://learn.microsoft.com/azure/azure-monitor/alerts/action-groups#create-an-action-group-in-the-azure-portal)

- * [New-AzActionGroup](https://learn.microsoft.com/powershell/module/az.monitor/new-azactiongroup?view=azps-12.0.0)

- * [Get-AzActionGroup](https://learn.microsoft.com/powershell/module/az.monitor/get-azactiongroup?view=azps-12.0.0)

- * [Remove-AzActionGroup](https://learn.microsoft.com/powershell/module/az.monitor/remove-azactiongroup?view=azps-12.0.0)

-* [CLI](https://learn.microsoft.com/cli/azure/monitor/action-group?view=azure-cli-latest#az-monitor-action-group-create)

-* [SMS and/or Email notifications](https://learn.microsoft.com/azure/azure-monitor/alerts/action-groups#email-azure-resource-manager)

-* [Webhooks](https://learn.microsoft.com/azure/azure-monitor/alerts/action-groups#webhook) - Customers can attach webhooks to their automation runbooks and configure their action groups to trigger the runbooks. You can start a runbook from a [webhook](https://docs.microsoft.com/azure/automation/automation-webhooks)

-* [ITSM Connections](https://learn.microsoft.com/azure/azure-monitor/alerts/itsmc-overview)

-In the previous image, a Reserved VM Instance discount is applied to one of the unused instances and the cost for that instance is zeroed out. For the other instance, PAYG rate is charged for the VM size reserved.

-In the previous image, the VM Reserved Instance discount is applied to VM 0, which is only charged for other components such as disk and networking. The other unused instance is being charged at PAYG rate for the VM size reserved.

-[Premium Storage](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Supported <br>[Premium Storage caching](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Supported <br>[Live Migration](https://learn.microsoft.com/azure/virtual-machines/maintenance-and-updates): Not Supported for Preview <br>[Memory Preserving Updates](https://learn.microsoft.com/azure/virtual-machines/maintenance-and-updates): Supported <br>[VM Generation Support](https://learn.microsoft.com/azure/virtual-machines/generation-2): Generation 2<br>[Accelerated Networking](https://learn.microsoft.com/azure/virtual-network/create-vm-accelerated-networking-cli): Supported <br>[Ephemeral OS Disks](https://learn.microsoft.com/azure/virtual-machines/ephemeral-os-disks): Not Supported for Preview<br>[Nested Virtualization](https://learn.microsoft.com/virtualization/hyper-v-on-windows/user-guide/nested-virtualization): Supported

-[Premium Storage](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Supported <br>[Premium Storage caching](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Supported <br>[Live Migration](https://learn.microsoft.com/azure/virtual-machines/maintenance-and-updates): Not Supported for Preview <br>[Memory Preserving Updates](https://learn.microsoft.com/azure/virtual-machines/maintenance-and-updates): Supported <br>[VM Generation Support](https://learn.microsoft.com/azure/virtual-machines/generation-2): Generation 2<br>[Accelerated Networking](https://learn.microsoft.com/azure/virtual-network/create-vm-accelerated-networking-cli): Supported <br>[Ephemeral OS Disks](https://learn.microsoft.com/azure/virtual-machines/ephemeral-os-disks): Not Supported for Preview <br>[Nested Virtualization](https://learn.microsoft.com/virtualization/hyper-v-on-windows/user-guide/nested-virtualization): Supported

-The new Dsv6 and Ddsv6 Virtual Machine (VM) series only works on OS images that are tagged with NVMe support. If your current OS image is not supported for NVMe, an error message is shown. NVMe support is available in 50+ of the most popular OS images, and we continuously improve the OS image coverage. Refer to our up-to-date [**lists**](https://learn.microsoft.com/azure/virtual-machines/enable-nvme-interface) for information on which OS images are tagged as NVMe supported. For more information on NVMe enablement, see our [**FAQ**](https://learn.microsoft.com/azure/virtual-machines/enable-nvme-faqs).

-[Premium Storage](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Supported <br>[Premium Storage caching](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Supported <br>Live Migration: Not Supported for Preview <br>Memory Preserving Updates: Supported <br>[VM Generation Support](https://learn.microsoft.com/azure/virtual-machines/generation-2): Generation 2 <br>[Accelerated Networking](https://learn.microsoft.com/azure/virtual-network/create-vm-accelerated-networking-cli): Supported <br>[Ephemeral OS Disks](https://learn.microsoft.com/azure/virtual-machines/ephemeral-os-disks): Not Supported for Preview<br>[Nested Virtualization](https://learn.microsoft.com/virtualization/hyper-v-on-windows/user-guide/nested-virtualization): Supported

-[Premium Storage](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Supported <br>[Premium Storage caching](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Supported <br>[Live Migration](https://learn.microsoft.com/azure/virtual-machines/maintenance-and-updates): Not Supported for Preview <br>[Memory Preserving Updates](https://learn.microsoft.com/azure/virtual-machines/maintenance-and-updates): Supported <br>[VM Generation Support](https://learn.microsoft.com/azure/virtual-machines/generation-2): Generation 2<br>[Accelerated Networking](https://learn.microsoft.com/azure/virtual-network/create-vm-accelerated-networking-cli): Supported <br>[Ephemeral OS Disks](https://learn.microsoft.com/azure/virtual-machines/ephemeral-os-disks): Not Supported for Preview <br>[Nested Virtualization](https://learn.microsoft.com/virtualization/hyper-v-on-windows/user-guide/nested-virtualization): Supported

-To learn how to get the best storage performance for your VMs, see [Virtual machine and disk performance](https://learn.microsoft.com/azure/virtual-machines/disks-performance).

-**Expected network bandwidth** is the maximum aggregated bandwidth allocated per VM type across all NICs, for all destinations. For more information, see [Virtual machine network bandwidth](https://learn.microsoft.com/azure/virtual-network/virtual-machine-network-throughput).

-Upper limits aren't guaranteed. Limits offer guidance for selecting the right VM type for the intended application. Actual network performance depends on several factors including network congestion, application loads, and network settings. For information on optimizing network throughput, see [Optimize network throughput for Azure virtual machines](https://learn.microsoft.com/azure/virtual-network/virtual-network-optimize-network-bandwidth). To achieve the expected network performance on Linux or Windows, you may need to select a specific version or optimize your VM. For more information, see [Bandwidth/Throughput testing (NTTTCP)](https://learn.microsoft.com/azure/virtual-network/virtual-network-bandwidth-testing).

-[Premium Storage](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Not Supported<br>[Premium Storage caching](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Not Supported<br>[Live Migration](https://learn.microsoft.com/azure/virtual-machines/maintenance-and-updates): Supported<br>[Memory Preserving Updates](https://learn.microsoft.com/azure/virtual-machines/maintenance-and-updates): Supported<br>[VM Generation Support](https://learn.microsoft.com/azure/virtual-machines/generation-2): Generation 2<br>[Accelerated Networking](https://learn.microsoft.com/azure/virtual-network/create-vm-accelerated-networking-cli)¹: Required<br>[Ephemeral OS Disks](https://learn.microsoft.com/azure/virtual-machines/ephemeral-os-disks): Not Supported for Preview<br>[Nested Virtualization](https://learn.microsoft.com/virtualization/hyper-v-on-windows/user-guide/nested-virtualization): Supported

-[Premium Storage](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Supported<br>[Premium Storage caching](https://learn.microsoft.com/azure/virtual-machines/premium-storage-performance): Supported<br>[Live Migration](https://learn.microsoft.com/azure/virtual-machines/maintenance-and-updates): Supported<br>[Memory Preserving Updates](https://learn.microsoft.com/azure/virtual-machines/maintenance-and-updates): Supported<br>[VM Generation Support](https://learn.microsoft.com/azure/virtual-machines/generation-2): Generation 2<br>[Accelerated Networking](https://learn.microsoft.com/azure/virtual-network/create-vm-accelerated-networking-cli)¹: Required<br>[Ephemeral OS Disks](https://learn.microsoft.com/azure/virtual-machines/ephemeral-os-disks): Not Supported for Preview<br>[Nested Virtualization](https://learn.microsoft.com/virtualization/hyper-v-on-windows/user-guide/nested-virtualization): Supported

-To learn how to get the best storage performance for your VMs, see [Virtual machine and disk performance](https://learn.microsoft.com/azure/virtual-machines/disks-performance).

-**Expected network bandwidth** is the maximum aggregated bandwidth allocated per VM type across all NICs, for all destinations. For more information, see [Virtual machine network bandwidth](https://learn.microsoft.com/azure/virtual-network/virtual-machine-network-throughput).

-Upper limits aren't guaranteed. Limits offer guidance for selecting the right VM type for the intended application. Actual network performance will depend on several factors including network congestion, application loads, and network settings. For information on optimizing network throughput, see [Optimize network throughput for Azure virtual machines](https://learn.microsoft.com/azure/virtual-network/virtual-network-optimize-network-bandwidth). To achieve the expected network performance on Linux or Windows, you may need to select a specific version or optimize your VM. For more information, see [Bandwidth/Throughput testing (NTTTCP)](https://learn.microsoft.com/azure/virtual-network/virtual-network-bandwidth-testing).

-| Ubuntu | 18.04 LTS, 20.04 LTS | CX3-Pro, CX5, CX6 |

- | General purpose workloads | D-series V4 </br> D-series V5 | **[Dv4 and Dsv4-series](/azure/virtual-machines/dv4-dsv4-series)** </br> **[Ddv4 and Ddsv4-series](/azure/virtual-machines/ddv4-ddsv4-series)** </br> **[Dav4 and Dasv4-series](/azure/virtual-machines/dav4-dasv4-series)** </br> **[Dv5 and Dsv5-series](/azure/virtual-machines/dv5-dsv5-series)** </br> **[Ddv5 and Ddsv5-series](/azure/virtual-machines/ddv5-ddsv5-series)** </br> **[Dlsv5 and Dldsv5-series](/azure/virtual-machines/dlsv5-dldsv5-series)** </br> **[Dasv5 and Dadsv5-series](/azure/virtual-machines/dasv5-dadsv5-series)** |

- | General purpose and memory intensive workloads | E-series V4 </br> E-series V5 | **[Ev4 and Esv4-series](/azure/virtual-machines/ev4-esv4-series)** </br> **[Edv4 and Edsv4-series](/azure/virtual-machines/edv4-edsv4-series)** </br> **[Eav4 and Easv4-series](/azure/virtual-machines/eav4-easv4-series)** </br> **[Ev5 and Esv5-series](/azure/virtual-machines/ev5-esv5-series)** </br> **[Edv5 and Edsv5-series](/azure/virtual-machines/edv5-edsv5-series)** </br> **[Easv5 and Eadsv5-series](/azure/virtual-machines/easv5-eadsv5-series)** |

-For more information about availability zones and zone redundant gateways, see [What are availability zones](https://learn.microsoft.com/azure/reliability/availability-zones-overview?toc=%2Fazure%2Fvpn-gateway%2Ftoc.json&tabs=azure-cli#availability-zones)?