Merge branch 'main' of https://github.com/MicrosoftDocs/azure-docs-pr into networkover

Author: duongau

articles/azure-app-configuration/enable-dynamic-configuration-aspnet-core.md

@@ -39,7 +39,7 @@ A *sentinel key* is a key that you update after you complete the change of all o
 
 1. Open *Program.cs*, and update the `AddAzureAppConfiguration` method you added previously during the quickstart.
 
-    #### [.NET 6.x](#tab/core6x)
+    #### [.NET 6.0+](#tab/core6x)
     ```csharp
     // Load configuration from Azure App Configuration
     builder.Configuration.AddAzureAppConfiguration(options =>
@@ -91,7 +91,7 @@ A *sentinel key* is a key that you update after you complete the change of all o
 
 1. Add Azure App Configuration middleware to the service collection of your app.
 
-    #### [.NET 6.x](#tab/core6x)
+    #### [.NET 6.0+](#tab/core6x)
     Update *Program.cs* with the following code. 
 
     ```csharp
@@ -131,7 +131,7 @@ A *sentinel key* is a key that you update after you complete the change of all o
 
 1. Call the `UseAzureAppConfiguration` method. It enables your app to use the App Configuration middleware to update the configuration for you automatically.
 
-    #### [.NET 6.x](#tab/core6x)
+    #### [.NET 6.0+](#tab/core6x)
     Update *Program.cs* withe the following code. 
 
     ```csharp

articles/azure-app-configuration/enable-dynamic-configuration-dotnet-core.md

@@ -1,7 +1,7 @@
 ---
-title: "Tutorial: Use dynamic configuration in a .NET Core app"
+title: "Tutorial: Use dynamic configuration in a .NET app"
 titleSuffix: Azure App Configuration
-description: In this tutorial, you learn how to dynamically update the configuration data for .NET Core apps
+description: In this tutorial, you learn how to dynamically update the configuration data for .NET apps
 services: azure-app-configuration
 documentationcenter: ''
 author: mcleanbyron
@@ -14,31 +14,70 @@ ms.workload: tbd
 ms.devlang: csharp
 ms.custom: devx-track-csharp, devx-track-dotnet
 ms.topic: tutorial
-ms.date: 07/01/2019
+ms.date: 07/11/2023
 ms.author: mcleans
 #Customer intent: I want to dynamically update my app to use the latest configuration data in App Configuration.
 ---
-# Tutorial: Use dynamic configuration in a .NET Core app
+# Tutorial: Use dynamic configuration in a .NET app
 
-The App Configuration .NET provider library supports updating configuration on demand without causing an application to restart. This tutorial shows how you can implement dynamic configuration updates in your code. It builds on the app introduced in the quickstart. You should finish [Create a .NET Core app with App Configuration](./quickstart-dotnet-core-app.md) before continuing.
+The App Configuration .NET provider library supports updating configuration on demand without causing an application to restart. This tutorial shows how you can implement dynamic configuration updates in your code. It builds on the app introduced in the quickstart. You should finish [Create a .NET app with App Configuration](./quickstart-dotnet-core-app.md) before continuing.
 
 You can use any code editor to do the steps in this tutorial. [Visual Studio Code](https://code.visualstudio.com/) is an excellent option that's available on the Windows, macOS, and Linux platforms.
 
 In this tutorial, you learn how to:
 
 > [!div class="checklist"]
-> * Set up your .NET Core app to update its configuration in response to changes in an App Configuration store.
+> * Set up your .NET app to update its configuration in response to changes in an App Configuration store.
 > * Consume the latest configuration in your application.
 
 ## Prerequisites
 
 [!INCLUDE [quickstarts-free-trial-note](../../includes/quickstarts-free-trial-note.md)]
 
-Finish the quickstart [Create a .NET Core app with App Configuration](./quickstart-dotnet-core-app.md).
+Finish the quickstart [Create a .NET app with App Configuration](./quickstart-dotnet-core-app.md).
 
 ## Activity-driven configuration refresh
 
-Open *Program.cs* and update the code as following.
+Open the `Program.cs` file and update the code configurations to match the following:
+
+### [ASP.NET Core 6.0+](#tab/core6x)
+
+```csharp
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Configuration.AzureAppConfiguration;
+
+IConfiguration _configuration = null;
+IConfigurationRefresher _refresher = null;
+
+var builder = new ConfigurationBuilder();
+builder.AddAzureAppConfiguration(options =>
+{
+    options.Connect(Environment.GetEnvironmentVariable("ConnectionString"))
+            .ConfigureRefresh(refresh =>
+            {
+                refresh.Register("TestApp:Settings:Message")
+                       .SetCacheExpiration(TimeSpan.FromSeconds(10));
+            });
+
+    _refresher = options.GetRefresher();
+});
+
+_configuration = builder.Build();
+
+Console.WriteLine(_configuration["TestApp:Settings:Message"] ?? "Hello world!");
+
+// Wait for the user to press Enter
+Console.ReadLine();
+
+if (_refresher != null)
+{
+    await _refresher.TryRefreshAsync();
+    Console.WriteLine(_configuration["TestApp:Settings:Message"] ?? "Hello world!");
+
+}
+```
+
+### [ASP.NET Core 3.x](#tab/core3x)
 
 ```csharp
 using Microsoft.Extensions.Configuration;
@@ -85,10 +124,11 @@ namespace TestConsole
     }
 }
 ```
+---
 
 In the `ConfigureRefresh` method, a key within your App Configuration store is registered for change monitoring. The `Register` method has an optional boolean parameter `refreshAll` that can be used to indicate whether all configuration values should be refreshed if the registered key changes. In this example, only the key *TestApp:Settings:Message* will be refreshed. The `SetCacheExpiration` method specifies the minimum time that must elapse before a new request is made to App Configuration to check for any configuration changes. In this example, you override the default expiration time of 30 seconds, specifying a time of 10 seconds instead for demonstration purposes.
 
-Calling the `ConfigureRefresh` method alone won't cause the configuration to refresh automatically. You call the `TryRefreshAsync` method from the interface `IConfigurationRefresher` to trigger a refresh. This design is to avoid phantom requests sent to App Configuration even when your application is idle. You will want to include the `TryRefreshAsync` call where you consider your application active. For example, it can be when you process an incoming message, an order, or an iteration of a complex task. It can also be in a timer if your application is active all the time. In this example, you call `TryRefreshAsync` every time you press the Enter key. Note that, even if the call `TryRefreshAsync` fails for any reason, your application will continue to use the cached configuration. Another attempt will be made when the configured cache expiration time has passed and the `TryRefreshAsync` call is triggered by your application activity again. Calling `TryRefreshAsync` is a no-op before the configured cache expiration time elapses, so its performance impact is minimal, even if it's called frequently.
+Calling the `ConfigureRefresh` method alone won't cause the configuration to refresh automatically. You call the `TryRefreshAsync` method from the interface `IConfigurationRefresher` to trigger a refresh. This design is to avoid phantom requests sent to App Configuration even when your application is idle. You'll want to include the `TryRefreshAsync` call where you consider your application active. For example, it can be when you process an incoming message, an order, or an iteration of a complex task. It can also be in a timer if your application is active all the time. In this example, you call `TryRefreshAsync` every time you press the Enter key. Even if the call `TryRefreshAsync` fails for any reason, your application continues to use the cached configuration. Another attempt is made when the configured cache expiration time has passed and the `TryRefreshAsync` call is triggered by your application activity again. Calling `TryRefreshAsync` is a no-op before the configured cache expiration time elapses, so its performance impact is minimal, even if it's called frequently.
 
 ## Build and run the app locally
 
@@ -186,7 +226,7 @@ Logs are output upon configuration refresh and contain detailed information on k
 
 ## Next steps
 
-In this tutorial, you enabled your .NET Core app to dynamically refresh configuration settings from App Configuration. To learn how to use an Azure managed identity to streamline the access to App Configuration, continue to the next tutorial.
+In this tutorial, you enabled your .NET app to dynamically refresh configuration settings from App Configuration. To learn how to use an Azure managed identity to streamline the access to App Configuration, continue to the next tutorial.
 
 > [!div class="nextstepaction"]
 > [Managed identity integration](./howto-integrate-azure-managed-service-identity.md)

articles/azure-app-configuration/howto-integrate-azure-managed-service-identity.md

@@ -7,14 +7,14 @@ ms.author: mcleans
 ms.service: azure-app-configuration
 ms.custom: devx-track-csharp, fasttrack-edit, subject-rbac-steps, devdivchpfy22
 ms.topic: conceptual
-ms.date: 08/23/2022
+ms.date: 07/11/2023
 zone_pivot_groups: appconfig-provider
 ---
 # Use managed identities to access App Configuration
 
 Azure Active Directory [managed identities](../active-directory/managed-identities-azure-resources/overview.md) simplify secrets management for your cloud application. With a managed identity, your code can use the service principal created for the Azure service it runs on. You use a managed identity instead of a separate credential stored in Azure Key Vault or a local connection string.
 
-Azure App Configuration and its .NET Core, .NET Framework, and Java Spring client libraries have managed identity support built into them. Although you aren't required to use it, the managed identity eliminates the need for an access token that contains secrets. Your code can access the App Configuration store using only the service endpoint. You can embed this URL in your code directly without exposing any secret.
+Azure App Configuration and its .NET, .NET Framework, and Java Spring client libraries have managed identity support built into them. Although you aren't required to use it, the managed identity eliminates the need for an access token that contains secrets. Your code can access the App Configuration store using only the service endpoint. You can embed this URL in your code directly without exposing any secret.
 
 :::zone target="docs" pivot="framework-dotnet"
 
@@ -45,7 +45,7 @@ To complete this tutorial, you must have:
 
 :::zone target="docs" pivot="framework-dotnet"
 
-* [.NET Core SDK](https://dotnet.microsoft.com/download).
+* [.NET SDK](https://dotnet.microsoft.com/download).
 * [Azure Cloud Shell configured](../cloud-shell/quickstart.md).
 
 :::zone-end
@@ -128,24 +128,17 @@ The following steps describe how to assign the App Configuration Data Reader rol
     using Azure.Identity;
     ```
 
-1. If you wish to access only values stored directly in App Configuration, update the `CreateWebHostBuilder` method by replacing the `config.AddAzureAppConfiguration()` method (this method is found in the `Microsoft.Azure.AppConfiguration.AspNetCore` package).
+1. To access values stored in App Configuration, update the `Builder` configuration to use the the `AddAzureAppConfiguration()` method.
 
-    > [!IMPORTANT]
-    > `CreateHostBuilder` replaces `CreateWebHostBuilder` in .NET Core 3.0. Select the correct syntax based on your environment.
-
-    ### [.NET Core 5.x](#tab/core5x)
+    ### [.NET 6.0+](#tab/core6x)
 
     ```csharp
-    public static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .ConfigureWebHostDefaults(webBuilder =>
-                webBuilder.ConfigureAppConfiguration((hostingContext, config) =>
-                {
-                    var settings = config.Build();
-                    config.AddAzureAppConfiguration(options =>
-                        options.Connect(new Uri(settings["AppConfig:Endpoint"]), new ManagedIdentityCredential()));
-                })
-                .UseStartup<Startup>());
+    var builder = WebApplication.CreateBuilder(args);
+
+    builder.Configuration.AddAzureAppConfiguration(options =>
+        options.Connect(
+            new Uri(builder.Configuration["AppConfig:Endpoint"]),
+            new ManagedIdentityCredential()));
     ```
 
     ### [.NET Core 3.x](#tab/core3x)
@@ -163,29 +156,12 @@ The following steps describe how to assign the App Configuration Data Reader rol
                 .UseStartup<Startup>());
     ```
 
-    ### [.NET Core 2.x](#tab/core2x)
-
-    ```csharp
-    public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
-        WebHost.CreateDefaultBuilder(args)
-               .ConfigureAppConfiguration((hostingContext, config) =>
-               {
-                   var settings = config.Build();
-                   config.AddAzureAppConfiguration(options =>
-                       options.Connect(new Uri(settings["AppConfig:Endpoint"]), new ManagedIdentityCredential()));
-               })
-               .UseStartup<Startup>();
-    ```
-
     ---
 
     > [!NOTE]
     > If you want to use a **user-assigned managed identity**, be sure to specify the `clientId` when creating the [ManagedIdentityCredential](/dotnet/api/azure.identity.managedidentitycredential).
     >```csharp
-    >config.AddAzureAppConfiguration(options =>
-    >       {
-    >           options.Connect(new Uri(settings["AppConfig:Endpoint"]), new ManagedIdentityCredential("<your_clientId>"))
-    >        });
+    >new ManagedIdentityCredential("<your_clientId>")
     >```
     >As explained in the [Managed Identities for Azure resources FAQs](../active-directory/managed-identities-azure-resources/known-issues.md), there is a default way to resolve which managed identity is used. In this case, the Azure Identity library enforces you to specify the desired identity to avoid possible runtime issues in the future. For instance, if a new user-assigned managed identity is added or if the system-assigned managed identity is enabled. So, you will need to specify the `clientId` even if only one user-assigned managed identity is defined, and there is no system-assigned managed identity.
 

articles/azure-app-configuration/howto-labels-aspnet-core.md

@@ -7,7 +7,7 @@ ms.devlang: csharp
 author: mcleanbyron
 ms.topic: conceptual
 ms.custom: devx-track-csharp
-ms.date: 3/12/2020
+ms.date: 07/11/2023
 ms.author: mcleans
 
 ---
@@ -42,28 +42,22 @@ using Microsoft.Extensions.Configuration.AzureAppConfiguration;
 
 Load configuration values with the label corresponding to the current environment by passing the environment name into the `Select` method:
 
-### [.NET Core 5.x](#tab/core5x)
+### [ASP.NET Core 6.0+](#tab/core6x)
 
 ```csharp
-    public static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-        .ConfigureWebHostDefaults(webBuilder =>
-        webBuilder.ConfigureAppConfiguration((hostingContext, config) =>
-        {
-            var settings = config.Build();
-            config.AddAzureAppConfiguration(options =>
-                options
-                    .Connect(settings.GetConnectionString("AppConfig"))
-                    // Load configuration values with no label
-                    .Select(KeyFilter.Any, LabelFilter.Null)
-                    // Override with any configuration values specific to current hosting env
-                    .Select(KeyFilter.Any, hostingContext.HostingEnvironment.EnvironmentName)
-            );
-        })
-        .UseStartup<Startup>());
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Configuration.AddAzureAppConfiguration(options =>
+    {
+            options.Connect(builder.Configuration.GetConnectionString("AppConfig"))
+                // Load configuration values with no label
+                .Select(KeyFilter.Any, LabelFilter.Null)
+                // Override with any configuration values specific to current hosting env
+                .Select(KeyFilter.Any, builder.Environment.EnvironmentName);
+    });
 ```
 
-### [.NET Core 3.x](#tab/core3x)
+### [ASP.NET Core 3.x](#tab/core3x)
 
 ```csharp
     public static IHostBuilder CreateHostBuilder(string[] args) =>
@@ -84,28 +78,8 @@ Load configuration values with the label corresponding to the current environmen
         .UseStartup<Startup>());
 ```
 
-### [.NET Core 2.x](#tab/core2x)
-
-```csharp
-public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
-        WebHost.CreateDefaultBuilder(args)
-        .ConfigureAppConfiguration((hostingContext, config) =>
-        {
-            var settings = config.Build();
-            config.AddAzureAppConfiguration(options =>
-                options
-                    .Connect(settings.GetConnectionString("AppConfig"))
-                    // Load configuration values with no label
-                    .Select(KeyFilter.Any, LabelFilter.Null)
-                    // Override with any configuration values specific to current hosting env
-                    .Select(KeyFilter.Any, hostingContext.HostingEnvironment.EnvironmentName)
-            );
-        })
-        .UseStartup<Startup>();
-```
 ---
 
-
 > [!IMPORTANT]
 > The preceding code snippet uses the Secret Manager tool to load App Configuration connection string. For information storing the connection string using the Secret Manager, see [Quickstart for Azure App Configuration with ASP.NET Core](quickstart-aspnet-core-app.md).