Merge branch 'main' into release-monitor-alerts-backup

Author: v-alje

articles/api-management/v2-service-tiers-overview.md

@@ -72,6 +72,7 @@ The following API Management capabilities are currently unavailable in the v2 ti
 
 **Infrastructure and networking**
 * Multi-region deployment 
+* Availability zone support
 * Multiple custom domain names 
 * Capacity metric - *replaced by CPU Percentage of Gateway and Memory Percentage of Gateway metrics*
 * Built-in analytics - *replaced by Azure Monitor-based dashboard*

articles/azure-app-configuration/enable-dynamic-configuration-python.md

@@ -7,7 +7,7 @@ author: mrm9084
 ms.service: azure-app-configuration
 ms.devlang: python
 ms.topic: tutorial
-ms.date: 01/29/2024
+ms.date: 12/03/2024
 ms.custom: devx-track-python, devx-track-extended-python
 ms.author: mametcal
 #Customer intent: As a Python developer, I want to dynamically update my app to use the latest configuration data in Azure App Configuration.
@@ -38,6 +38,44 @@ Add the following key-value to your Azure App Configuration store. For more info
 
 1. Create a new Python file named *app.py* and add the following code:
 
+    ### [Microsoft Entra ID (recommended)](#tab/entra-id)
+
+    You use the `DefaultAzureCredential` to authenticate to your App Configuration store. Follow the [instructions](./concept-enable-rbac.md#authentication-with-token-credentials) to assign your credential the **App Configuration Data Reader** role. Be sure to allow sufficient time for the permission to propagate before running your application.
+
+    ```python
+    from azure.appconfiguration.provider import load, WatchKey
+    from azure.identity import DefaultAzureCredential
+    import os
+    import time
+
+    endpoint = os.environ.get("APPCONFIGURATION_ENDPOINT")
+
+    # Connecting to Azure App Configuration using connection string
+    # Setting up to refresh when the Sentinel key is changed.
+    config = load(
+        endpoint=endpoint,
+        credential=DefaultAzureCredential(),
+        refresh_on=[WatchKey("sentinel")],
+        refresh_interval=10, # Default value is 30 seconds, shorted for this sample
+    )
+
+    print("Update the `message` in your Azure App Configuration store using Azure portal or CLI.")
+    print("First, update the `message` value, and then update the `sentinel` key value.")
+
+    while (True):
+        # Refreshing the configuration setting
+        config.refresh()
+
+        # Current value of message
+        print(config["message"])
+
+        # Waiting before the next refresh
+        time.sleep(5)
+    ```
+
+
+    ### [Connection string](#tab/connection-string)
+
     ```python
     from azure.appconfiguration.provider import load, WatchKey
     import os
@@ -66,6 +104,7 @@ Add the following key-value to your Azure App Configuration store. For more info
         # Waiting before the next refresh
         time.sleep(5)
     ```
+    ---
 
 1. Run your script:
 
@@ -104,6 +143,7 @@ In `app.py`, set up Azure App Configuration to load your configuration values. T
 
 ```python
 from azure.appconfiguration.provider import load, WatchKey
+from azure.identity import DefaultAzureCredential
 
 azure_app_config = None  # declare azure_app_config as a global variable
 
@@ -112,7 +152,8 @@ def on_refresh_success():
 
 
 global azure_app_config
-azure_app_config = load(connection_string=os.environ.get("AZURE_APPCONFIG_CONNECTION_STRING")
+azure_app_config = load(endpoint=os.environ.get("AZURE_APPCONFIG_ENDPOINT"),
+                        credential=DefaultAzureCredential(),
                         refresh_on=[WatchKey("sentinel")],
                         on_refresh_success=on_refresh_success,
                         refresh_interval=10, # Default value is 30 seconds, shortened for this sample
@@ -164,7 +205,8 @@ def on_refresh_success():
    app.config.update(azure_app_config)
 
 AZURE_APPCONFIGURATION = load(
-        connection_string=os.environ.get("AZURE_APPCONFIG_CONNECTION_STRING"),
+        connection_string=os.environ.get(endpoint=os.environ.get("AZURE_APPCONFIG_ENDPOINT"),
+         credential=DefaultAzureCredential(),
         refresh_on=[WatchKey("sentinel")],
         on_refresh_success=on_refresh_success,
         refresh_interval=10, # Default value is 30 seconds, shortened for this sample

articles/azure-app-configuration/quickstart-python-provider.md

@@ -2,13 +2,13 @@
 title: Quickstart for using Azure App Configuration with Python apps | Microsoft Learn
 description: In this quickstart, create a Python app with the Azure App Configuration to centralize storage and management of application settings separate from your code.
 services: azure-app-configuration
-author: maud-lv
+author: mrm9084
 ms.service: azure-app-configuration
 ms.devlang: python
 ms.topic: quickstart
 ms.custom: devx-track-python, mode-other, engagement-fy23
-ms.date: 11/20/2023
-ms.author: malev
+ms.date: 12/03/2024
+ms.author: mametcal
 #Customer intent: As a Python developer, I want to manage all my app settings in one place.
 ---
 # Quickstart: Create a Python app with Azure App Configuration
@@ -57,17 +57,22 @@ In this section, you will create a console application and load data from your A
 
 1. Create a new file called *app-configuration-quickstart.py* in the *app-configuration-quickstart* directory and add the following code:
 
+    ### [Microsoft Entra ID (recommended)](#tab/entra-id)
+    You use the `DefaultAzureCredential` to authenticate to your App Configuration store. Follow the [instructions](./concept-enable-rbac.md#authentication-with-token-credentials) to assign your credential the **App Configuration Data Reader** role. Be sure to allow sufficient time for the permission to propagate before running your application.
+
     ```python
     from azure.appconfiguration.provider import (
         load,
         SettingSelector
     )
+    from azure.identity import DefaultAzureCredential
     import os
 
-    connection_string = os.environ.get("AZURE_APPCONFIG_CONNECTION_STRING")
+    endpoint = os.environ.get("AZURE_APPCONFIG_ENDPOINT")
 
     # Connect to Azure App Configuration using a connection string.
-    config = load(connection_string=connection_string)
+    config = load(endpoint=endpoint, credential=credential)
+    credential = DefaultAzureCredential()
 
     # Find the key "message" and print its value.
     print(config["message"])
@@ -76,88 +81,99 @@ In this section, you will create a console application and load data from your A
 
     # Connect to Azure App Configuration using a connection string and trimmed key prefixes.
     trimmed = {"test."}
-    config = load(connection_string=connection_string, trim_prefixes=trimmed)
+    config = load(endpoint=endpoint, credential=credential, trim_prefixes=trimmed)
     # From the keys with trimmed prefixes, find a key with "message" and print its value.
     print(config["message"])
 
     # Connect to Azure App Configuration using SettingSelector.
     selects = {SettingSelector(key_filter="message*", label_filter="\0")}
-    config = load(connection_string=connection_string, selects=selects)
+    config = load(endpoint=endpoint, credential=credential, selects=selects)
 
     # Print True or False to indicate if "message" is found in Azure App Configuration.
     print("message found: " + str("message" in config))
     print("test.message found: " + str("test.message" in config))
     ```
 
-### Run the application
-
-1. Set an environment variable named **AZURE_APPCONFIG_CONNECTION_STRING**, and set it to the connection string of your App Configuration store. At the command line, run the following command:
+    ### [Connection string](#tab/connection-string)
+    ```python
+    from azure.appconfiguration.provider import (
+        load,
+        SettingSelector
+    )
+    import os
 
-    #### [Windows command prompt](#tab/windowscommandprompt)
+    connection_string = os.environ.get("AZURE_APPCONFIG_CONNECTION_STRING")
 
-    To run the app locally using the Windows command prompt, run the following command and replace `<app-configuration-store-connection-string>` with the connection string of your app configuration store:
+    # Connect to Azure App Configuration using a connection string.
+    config = load(connection_string=connection_string)
 
-    ```cmd
-    setx AZURE_APPCONFIG_CONNECTION_STRING "connection-string-of-your-app-configuration-store"
-    ```
+    # Find the key "message" and print its value.
+    print(config["message"])
+    # Find the key "my_json" and print the value for "key" from the dictionary.
+    print(config["my_json"]["key"])
 
-    #### [PowerShell](#tab/powershell)
+    # Connect to Azure App Configuration using a connection string and trimmed key prefixes.
+    trimmed = {"test."}
+    config = load(connection_string=connection_string, trim_prefixes=trimmed)
+    # From the keys with trimmed prefixes, find a key with "message" and print its value.
+    print(config["message"])
 
-    If you use Windows PowerShell, run the following command and replace `<app-configuration-store-connection-string>` with the connection string of your app configuration store:
+    # Connect to Azure App Configuration using SettingSelector.
+    selects = {SettingSelector(key_filter="message*", label_filter="\0")}
+    config = load(connection_string=connection_string, selects=selects)
 
-    ```azurepowershell
-    $Env:AZURE_APPCONFIG_CONNECTION_STRING = "<app-configuration-store-connection-string>"
+    # Print True or False to indicate if "message" is found in Azure App Configuration.
+    print("message found: " + str("message" in config))
+    print("test.message found: " + str("test.message" in config))
     ```
+    ---
 
-    #### [macOS](#tab/unix)
-
-    If you use macOS, run the following command and replace `<app-configuration-store-connection-string>` with the connection string of your app configuration store:
+### Run the application
 
-    ```console
-    export AZURE_APPCONFIG_CONNECTION_STRING='<app-configuration-store-connection-string>'
-    ```
+1. Set an environment variable.
 
-    #### [Linux](#tab/linux)
+    ### [Microsoft Entra ID (recommended)](#tab/entra-id)
+    Set the environment variable named **AZURE_APPCONFIG_ENDPOINT** to the endpoint of your App Configuration store found under the *Overview* of your store in the Azure portal.
 
-    If you use Linux, run the following command and replace `<app-configuration-store-connection-string>` with the connection string of your app configuration store:
+    If you use the Windows command prompt, run the following command and restart the command prompt to allow the change to take effect:
 
-    ```console
-    export AZURE_APPCONFIG_CONNECTION_STRING='<app-configuration-store-connection-string>'
+    ```cmd
+    setx AZURE_APPCONFIG_ENDPOINT "endpoint-of-your-app-configuration-store"
     ```
 
-1. Print out the value of the environment variable to validate that it is set properly with the command below.
+    If you use PowerShell, run the following command:
 
-    #### [Windows command prompt](#tab/windowscommandprompt)
+    ```powershell
+    $Env:AZURE_APPCONFIG_ENDPOINT = "endpoint-of-your-app-configuration-store"
+    ```
 
-    Using the Windows command prompt, restart the command prompt to allow the change to take effect and run the following command:
+    If you use macOS or Linux, run the following command:
 
-    ```cmd
-    echo %AZURE_APPCONFIG_CONNECTION_STRING%
+    ```bash
+    export AZURE_APPCONFIG_ENDPOINT='endpoint-of-your-app-configuration-store'
     ```
 
-    #### [PowerShell](#tab/powershell)
+    ### [Connection string](#tab/connection-string)
+    Set the environment variable named **AZURE_APPCONFIG_CONNECTION_STRING** to the read-only connection string of your App Configuration store found under *Access keys* of your store in the Azure portal.
 
-    If you use Windows PowerShell, run the following command:
+    If you use the Windows command prompt, run the following command and restart the command prompt to allow the change to take effect:
 
-    ```azurepowershell
-    $Env:AZURE_APPCONFIG_CONNECTION_STRING
+    ```cmd
+    setx AZURE_APPCONFIG_CONNECTION_STRING "connection-string-of-your-app-configuration-store"
     ```
 
-    #### [macOS](#tab/unix)
-
-    If you use macOS, run the following command:
+   If you use PowerShell, run the following command:
 
-    ```console
-    echo "$AZURE_APPCONFIG_CONNECTION_STRING"
+    ```powershell
+    $Env:AZURE_APPCONFIG_CONNECTION_STRING = "connection-string-of-your-app-configuration-store"
     ```
 
-    #### [Linux](#tab/linux)
-
-    If you use Linux, run the following command:
+    If you use macOS or Linux, run the following command:
 
-    ```console
-    echo "$AZURE_APPCONFIG_CONNECTION_STRING"
+    ```bash
+    export AZURE_APPCONFIG_CONNECTION_STRING='connection-string-of-your-app-configuration-store'
     ```
+    ---
 
 1. After the environment variable is properly set, run the following command to run the app locally:
 
@@ -182,7 +198,7 @@ The App Configuration provider loads data into a `Mapping` object, accessible as
 You can use Azure App Configuration in your existing Flask web apps by updating its in-built configuration. You can do this by passing your App Configuration provider object to the `update` function of your Flask app instance in `app.py`:
 
 ```python
-azure_app_config = load(connection_string=os.environ.get("AZURE_APPCONFIG_CONNECTION_STRING"))
+azure_app_config = load(endpoint=os.environ.get("AZURE_APPCONFIG_ENDPOINT"), credential=credential)
 
 # NOTE: This will override all existing configuration settings with the same key name.
 app.config.update(azure_app_config)
@@ -195,7 +211,7 @@ message = app.config.get("message")
 You can use Azure App Configuration in your existing Django web apps by adding the following lines of code into your `settings.py` file
 
 ```python
-AZURE_APPCONFIGURATION = load(connection_string=os.environ.get("AZURE_APPCONFIG_CONNECTION_STRING"))
+AZURE_APPCONFIGURATION = load(endpoint=os.environ.get("AZURE_APPCONFIG_ENDPOINT"), credential=credential)
 ```
 
 To access individual configuration settings in the Django views, you can reference them from the provider object created in Django settings. For example, in `views.py`:

articles/azure-edge-hardware-center/media/azure-edge-hardware-center-manage-order/cancel-order-2.png

@@ -451,10 +451,10 @@ public static async Task<HttpResponseData> Run(
 
     if (entity is null)
     {
-        return request.CreateResponse(HttpStatusCode.NotFound);
+        return req.CreateResponse(HttpStatusCode.NotFound);
     }
 
-    HttpResponseData response = request.CreateResponse(HttpStatusCode.OK);
+    HttpResponseData response = req.CreateResponse(HttpStatusCode.OK);
     await response.WriteAsJsonAsync(entity);
 
     return response;

articles/azure-edge-hardware-center/media/azure-edge-hardware-center-manage-order/cancel-order-3.png

@@ -134,6 +134,11 @@ public SignalRConnectionInfo negotiate(
 
 :::zone-end
 
+> [!Warning]
+> For the simplicity, we omit the authentication and authorization parts in this sample. As a result, this endpoint is publicly accessible without any restrictions. To ensure the security of your negotiation endpoint, you should implement appropriate authentication and authorization mechanisms based on your specific requirements. For guidance on protecting your HTTP endpoints, see the following articles: 
+> * [Secure HTTP endpoints](../azure-functions/security-concepts.md#secure-http-endpoints).
+> * [Authentication and authorization in Azure App Service and Azure Functions](../app-service/overview-authentication-authorization.md)
+
 ## Usage
 
 ### Authenticated tokens