Merge pull request #124950 from MicrosoftDocs/repo_sync_working_branch

Resolve syncing conflicts from repo_sync_working_branch to main

Author: Court72

articles/azure-app-configuration/quickstart-aspnet-core-app.md

@@ -1,13 +1,13 @@
 ---
-title: Quickstart for Azure App Configuration with ASP.NET Core | Microsoft Docs
+title: Quickstart for Azure App Configuration with ASP.NET Core
 description: Create an ASP.NET Core app with Azure App Configuration to centralize storage and management of application settings for an ASP.NET Core application.
 services: azure-app-configuration
 author: zhenlan
 ms.service: azure-app-configuration
 ms.devlang: csharp
 ms.custom: devx-track-csharp, mode-other, engagement-fy23
 ms.topic: quickstart
-ms.date: 02/20/2024
+ms.date: 11/20/2024
 ms.author: zhenlwa
 #Customer intent: As an ASP.NET Core developer, I want to learn how to manage all my app settings in one place.
 ---
@@ -42,18 +42,48 @@ Use the [.NET command-line interface (CLI)](/dotnet/core/tools) to create a new
 Run the following command to create an ASP.NET Core web app in a new *TestAppConfig* folder:
 
 ```dotnetcli
-dotnet new webapp --output TestAppConfig --framework net6.0
+dotnet new webapp --output TestAppConfig
 ```
 
 ## Connect to the App Configuration store
 
-1. Navigate into the project's directory *TestAppConfig*, and run the following command to add a [Microsoft.Azure.AppConfiguration.AspNetCore](https://www.nuget.org/packages/Microsoft.Azure.AppConfiguration.AspNetCore) NuGet package reference:
+Connect to your App Configuration store using Microsoft Entra ID (recommended), or a connection string.
 
+1. Navigate into the project's directory *TestAppConfig*, and run the following command to add NuGet package references.
+
+    ### [Microsoft Entra ID (recommended)](#tab/entra-id)
+
+    ```dotnetcli
+    dotnet add package Microsoft.Azure.AppConfiguration.AspNetCore
+    dotnet add package Azure.Identity
+    ```
+
+    ### [Connection string](#tab/connection-string)
     ```dotnetcli
     dotnet add package Microsoft.Azure.AppConfiguration.AspNetCore
     ```
+    ---
+
+1. Run the following command to restore packages for your project:
+
+    ```dotnetcli
+    dotnet restore
+    ```
+
+1. Create a user secret for the application by navigating into the *TestAppConfig* folder and running the following command.
+
+    ### [Microsoft Entra ID (recommended)](#tab/entra-id)
+        
+    The command uses [Secret Manager](/aspnet/core/security/app-secrets) to store a secret named `Endpoints:AppConfiguration`, which stores the endpoint for your App Configuration store. Replace the `<your-App-Configuration-endpoint>` placeholder with your App Configuration store's endpoint. You can find the endpoint in your App Configuration store's **Overview** blade in the Azure portal.
+    
+    ```dotnetcli
+    dotnet user-secrets init
+    dotnet user-secrets set Endpoints:AppConfiguration "<your-App-Configuration-endpoint>"
+    ```
+    
+    ### [Connection string](#tab/connection-string)
 
-1. Run the following command. The command uses [Secret Manager](/aspnet/core/security/app-secrets) to store a secret named `ConnectionStrings:AppConfig`, which stores the connection string for your App Configuration store. Replace the `<your_connection_string>` placeholder with your App Configuration store's connection string. You can find the connection string under **Access Keys** of your App Configuration store in the Azure portal.
+    The command uses [Secret Manager](/aspnet/core/security/app-secrets) to store a secret named `ConnectionStrings:AppConfig`, which stores the connection string for your App Configuration store. Replace the `<your_connection_string>` placeholder with your App Configuration store's connection string. You can find the connection string in your App Configuration store's **Access settings** in the Azure portal.
 
     ```dotnetcli
     dotnet user-secrets init
@@ -62,10 +92,49 @@ dotnet new webapp --output TestAppConfig --framework net6.0
 
     > [!TIP]
     > Some shells will truncate the connection string unless it's enclosed in quotes. Ensure that the output of the `dotnet user-secrets list` command shows the entire connection string. If it doesn't, rerun the command, enclosing the connection string in quotes.
-
+    
     Secret Manager stores the secret outside of your project tree, which helps prevent the accidental sharing of secrets within source code. It's used only to test the web app locally. When the app is deployed to Azure like [App Service](../app-service/overview.md), use the *Connection strings*, *Application settings* or environment variables to store the connection string. Alternatively, to avoid connection strings all together, you can [connect to App Configuration using managed identities](./howto-integrate-azure-managed-service-identity.md) or your other [Microsoft Entra identities](./concept-enable-rbac.md).
+    
+    ---
 
-1. Open *Program.cs* and add Azure App Configuration as an extra configuration source by calling the `AddAzureAppConfiguration` method.
+1. Open *Program.cs* and add the following namespaces:
+
+
+    ### [Microsoft Entra ID (recommended)](#tab/entra-id)
+    ```csharp
+    using Microsoft.Extensions.Configuration;
+    using Microsoft.Azure.AppConfiguration.AspNetCore;
+    using Azure.Identity;
+    ```
+
+    ### [Connection string](#tab/connection-string)
+    ```csharp
+    using Microsoft.Extensions.Configuration;
+    using Microsoft.Azure.AppConfiguration.AspNetCore;
+    ```
+    ---
+
+1. Connect to your App Configuration store by calling the `AddAzureAppConfiguration` method in the `Program.cs` file.
+ 
+    ### [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.
+
+    ```csharp
+    var builder = WebApplication.CreateBuilder(args); 
+    
+    // Load configuration from Azure App Configuration 
+    builder.Configuration.AddAzureAppConfiguration(options =>
+    {
+        string endpoint = builder.Configuration.Get("Endpoints:AppConfiguration");
+        options.Connect(new Uri(endpoint), new DefaultAzureCredential());
+    });
+
+     // The rest of existing code in program.cs
+    // ... ...    
+    ```
+
+    ### [Connection string](#tab/connection-string)
 
     ```csharp
     var builder = WebApplication.CreateBuilder(args);
@@ -79,8 +148,10 @@ dotnet new webapp --output TestAppConfig --framework net6.0
     // The rest of existing code in program.cs
     // ... ...
     ```
+    ---
+
+    This code loads *all* key-values that have *no label* from your App Configuration store. For more information on loading data from App Configuration, see the [App Configuration provider API reference](/dotnet/api/Microsoft.Extensions.Configuration.AzureAppConfigurationExtensions).
 
-    This code will connect to your App Configuration store using a connection string and load *all* key-values that have *no labels*. For more information on the App Configuration provider, see the [App Configuration provider API reference](/dotnet/api/Microsoft.Extensions.Configuration.AzureAppConfiguration).
 
 ## Read from the App Configuration store
 

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

@@ -166,7 +166,7 @@ Azure Database for MySQL bindings for Azure Functions have a required property f
 
 ## Samples
 
-In addition to the samples for C#, Java, JavaScript, PowerShell, and Python available in the [Azure SQL bindings GitHub repository](https://github.com/Azure/azure-functions-mysql-extension/tree/main/samples), more are available in Azure Samples.
+In addition to the samples for C#, Java, JavaScript, PowerShell, and Python available in the [Azure MySQL bindings GitHub repository](https://github.com/Azure/azure-functions-mysql-extension/tree/main/samples), more are available in Azure Samples.
 
 
 ## Next steps

articles/azure-maps/consent-management.md

@@ -0,0 +1,36 @@
+---
+title: Microsoft Azure Maps consent management
+description: This article describes consent management in Azure Maps as it applies to data residency laws.
+author: pbrasil
+ms.author: peterbr
+ms.date: 11/19/2024
+ms.topic: conceptual
+ms.service: azure-maps
+ms.subservice: manage-account
+---
+
+# Consent management
+
+Azure Maps is a global service that is available worldwide. When creating your Azure Maps account, you select a _Region_. The Region selection is the accounts geographic scope, which allows you to limit data residency to the selected region. All requests (including input data) are processed and stored exclusively in the specified geographic area (region).
+
+In some cases, you will need to enable your search requests to be processed in a region or geography other than the one your Azure Maps Account is in. For example, due to local data residency laws, all South Korean addresses must be processed in South Korea, which is the _Korea Central_ region in Azure Maps. To do this, you must give Azure Maps consent to process your data in the _Korea Central_ region. For more information on how to give Azure maps consent to process data in a different region, see [Configure global data processing].
+
+For more information on geographic scope in Azure Maps, see [Azure Maps service geographic scope].
+
+## Frequently asked questions
+
+**My scenario doesn't have any South Korea data. Do I still need to enable cross region processing to use Azure Maps?**
+
+No, if your scenario doesn't require South Korea data, you don't need to enable cross region processing. This is a specific regional requirement due to data residency laws.
+
+**Where will my data be stored if I enable cross region processing in South Korea?**
+
+Giving consent to process data in a different region will not affect where your metadata and logs are stored. Those are still contained within the region specified when creating your Azure Maps Account.
+
+## Next steps
+
+> [!div class="nextstepaction"]
+> [Configure global data processing]
+
+[Azure Maps service geographic scope]: geographic-scope.md
+[Configure global data processing]: how-to-manage-consent.md

articles/azure-maps/geocoding-coverage.md

@@ -133,7 +133,7 @@ The ability to geocode in a country/region is dependent upon the road data cover
 | Samoa                                               |                 |                |              |      ✓     |       ✓        |
 | Singapore                                           |        ✓        |        ✓      |       ✓      |      ✓     |       ✓        |
 | Solomon Islands                                     |                 |                |              |      ✓     |       ✓        |
-| South Korea                                         |                 |                |              |      ✓     |       ✓        |
+| South Korea<sup>1</sup>                             |                 |                |              |      ✓     |       ✓        |
 | Sri Lanka                                           |                 |                |              |      ✓     |       ✓        |
 | Taiwan                                              |        ✓        |        ✓      |       ✓      |      ✓     |       ✓        |
 | Thailand                                            |        ✓        |                |       ✓     |      ✓     |       ✓        |
@@ -146,6 +146,8 @@ The ability to geocode in a country/region is dependent upon the road data cover
 | Vietnam                                             |        ✓        |                |       ✓     |      ✓     |       ✓        |
 | Wallis & Futuna                                     |                 |                |              |      ✓     |       ✓        |
 
+<sup>1</sup> Coverage is dependent on enabling data processing in South Korea. For more information, see [Enable South Korea addresses in Azure Maps](how-to-manage-consent.md).
+
 ## Europe
 
 | Country/Region                                      | Address points  |House numbers  | Street level  | City level | Points of interest |

articles/azure-maps/how-to-manage-consent.md

@@ -0,0 +1,127 @@
+---
+title: Configure global data processing
+description: This article describes how to configure the global data processing settings in Azure Maps to comply with data residency laws.
+author: pbrasil
+ms.author: peterbr
+ms.date: 11/19/2024
+ms.topic: how-to
+ms.service: azure-maps
+ms.subservice: manage-account
+---
+
+# Configure global data processing
+
+In some cases, it may be necessary to process requests in a region different from your Azure Maps Account's region due to local data residency laws. When this happens, you can grant Azure Maps consent to process your data in other specified regions. For more information, see [Consent management].
+
+This article guides you on configuring global data processing settings to comply with data residency laws using multiple approaches including the [Azure Portal](#configure-global-data-processing-in-the-azure-portal), [REST APIs](#configure-global-data-processing-using-rest-api) or an [ARM deployment template](#configure-global-data-processing-using-an-arm-deployment-template). This allows Azure Maps to process address requests within the specified country's region, regardless of your Azure Maps Account's region.
+
+> [!IMPORTANT]
+> If your scenarios don't involve South Korea data, there is no need to enable cross-region processing. This requirement is specific to South Korea due to its data residency laws.
+
+## Configure global data processing in the Azure portal
+
+The Azure Maps Resource location is enabled by default and can be configured in the **Process Data Globally** page of the Azure portal.
+
+To give consent to one or more regions:
+
+1. Sign in to your Azure Maps Account in the [Azure portal].
+1. In **Settings**, select **Process data globally**.
+
+   A map of the world appears with a plus sign for each region that can be selected.
+
+   :::image type="content" source="./media/consent-management/process-data-globally.png" lightbox="./media/consent-management/process-data-globally.png" alt-text="Screenshot showing the process data globally screen in the Azure portal.":::
+
+1. Additionally you can select **Add region**, then select the region you wish to add or remove.
+
+   :::image type="content" source="./media/consent-management/select-korea-central.png" lightbox="./media/consent-management/select-korea-central.png" alt-text="Screenshot showing the process data globally screen in the Azure portal with the Korea Central region selected.":::
+
+1. Once you all desired regions are chosen, select **Save**.
+
+   :::image type="content" source="./media/consent-management/save-selection.png" lightbox="./media/consent-management/save-selection.png" alt-text="Screenshot showing the save button highlighted in process data globally screen in the Azure portal.":::
+
+Once your updates are saved, one or more new selections appear in the list of regions.
+
+:::image type="content" source="./media/consent-management/new-region-added.png" lightbox="./media/consent-management/new-region-added.png" alt-text="Screenshot showing the process data globally screen in the Azure portal with the Korea Central region added to the list of supported regions.":::
+
+## Configure global data processing using REST API
+
+Consent can be managed using [Azure Maps Account Management REST APIs]. To Configure global data processing, send an [Accounts - Update]  `PATCH` request and pass in the `properties.locations` parameter in the body of the request.
+
+Be sure to include the appropriate [subscription key], resource group and Azure Maps account name.
+
+```html
+https://management.azure.com/subscriptions/<subscription-key>/resourceGroups/<resource-group-name>/providers/Microsoft.Maps/accounts/<account-name>?api-version=2024-07-01-preview
+```
+
+**Header**
+
+Be sure to include a correct [access-token].
+
+```html
+Content-Type: application/json
+Authorization: Bearer <access-token> 
+```
+
+**Body**
+
+```json
+{
+  "properties": {
+    "locations": [
+      {
+        "locationName": "Korea Central"
+      }
+    ]
+  },
+}
+```
+
+## Configure global data processing using an ARM deployment template
+
+The following template will add _West Europe_ to the list of valid global data processing regions.
+
+Be sure to include the appropriate Azure Maps account name and location.
+
+```json
+{
+  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
+  "contentVersion": "1.0.0.0",
+  "resources": [
+    {
+      "type": "Microsoft.Maps/accounts",
+      "apiVersion": "2024-07-01-preview",
+      "name": "<account-name>",
+      "location": "<account-location>",
+      "sku": {
+        "name": "G2"
+      },
+      "properties":
+      {
+        "locations": [
+          {
+            "locationName": "West Europe"
+          }
+        ]
+      }
+    }
+  ]
+}
+```
+
+> [!NOTE]
+> Your data is always stored in the region you created your Azure Maps Account, regardless of your global data processing settings.
+
+## Next steps
+
+Azure Maps is a global service that allows specifying a geographic scope, which enables limiting data residency to specific regions.
+
+> [!div class="nextstepaction"]
+> [Azure Maps service geographic scope]
+
+[access-token]: azure-maps-authentication.md#microsoft-entra-authentication
+[Accounts - Update]: /rest/api/maps-management/accounts/update
+[Azure Maps Account Management REST APIs]: /rest/api/maps-management/accounts
+[Azure portal]: https://ms.portal.azure.com
+[Azure Maps service geographic scope]: geographic-scope.md
+[Consent management]: consent-management.md
+[subscription key]: quick-demo-map-app.md#get-the-subscription-key-for-your-account