Merge pull request #292153 from MicrosoftDocs/main

OOB Publish 12/18 - ASAP

Author: Albertyang0

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

@@ -7,12 +7,12 @@ ms.devlang: csharp
 author: zhiyuanliang-ms
 ms.author: zhiyuanliang
 ms.topic: how-to
-ms.date: 03/26/2024
+ms.date: 12/02/2024
 ---
 
 # Roll out features to targeted audiences in an ASP.NET Core application
 
-In this guide, you'll use the targeting filter to roll out a feature to targeted audience for your ASP.NET Core application. For more information about the targeting filter, see [Roll out features to targeted audiences](./howto-targetingfilter.md).
+In this guide, you'll use the targeting filter to roll out a feature to targeted audiences for your ASP.NET Core application. For more information about the targeting filter, see [Roll out features to targeted audiences](./howto-targetingfilter.md).
 
 ## Prerequisites
 
@@ -23,30 +23,92 @@ In this guide, you'll use the targeting filter to roll out a feature to targeted
 
 ## Create a web application with a feature flag
 
-In this section, you will create a web application that allows users to sign in and use the *Beta* feature flag you created before.
+In this section, you create a web application that allows users to sign in and use the *Beta* feature flag you created before.
 
 1. Create a web application that authenticates against a local database using the following command.
 
    ```dotnetcli
    dotnet new webapp --auth Individual -o TestFeatureFlags
    ```
 
-1. Add references to the following NuGet packages.
+1. Navigate to the newly created *TestFeatureFlags* directory and add references to the following NuGet packages.
+
+    ### [Microsoft Entra ID (recommended)](#tab/entra-id)
+
+    ```dotnetcli
+    dotnet add package Microsoft.Azure.AppConfiguration.AspNetCore
+    dotnet add package Microsoft.FeatureManagement.AspNetCore
+    dotnet add package Azure.Identity
+    ```
+
+    ### [Connection string](#tab/connection-string)
 
     ```dotnetcli
     dotnet add package Microsoft.Azure.AppConfiguration.AspNetCore
     dotnet add package Microsoft.FeatureManagement.AspNetCore
     ```
+    ---
+
+1. Create a user secret for the application by running the following commands.
+
+    ### [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>"
+    ```
 
-1. Store the connection string for your App Configuration store.
+    ### [Connection string](#tab/connection-string)
+
+    The command uses [Secret Manager](/aspnet/core/security/app-secrets) to store a secret named `ConnectionStrings:AppConfiguration`, which stores the connection string for your App Configuration store. Replace the `<your-App-Configuration-connection-string>` placeholder with your App Configuration store's read-only 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
-    dotnet user-secrets set ConnectionStrings:AppConfig "<your_connection_string>"
+    dotnet user-secrets set ConnectionStrings:AppConfiguration "<your-App-Configuration-connection-string>"
     ```
+    ---
 
 1. Add Azure App Configuration and feature management to your application.
 
+    ### [Microsoft Entra ID (recommended)](#tab/entra-id)
+    
+    1. 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.
+
+    1. Update the *Program.cs* file with the following code.
+    
+        ``` C#
+        // Existing code in Program.cs
+        // ... ...
+    
+        using Azure.Identity;
+    
+        var builder = WebApplication.CreateBuilder(args);
+    
+        // Retrieve the endpoint
+        string endpoint = builder.Configuration.GetValue<string>("Endpoints:AppConfiguration") 
+            ?? throw new InvalidOperationException("The setting `Endpoints:AppConfiguration` was not found.");
+        
+        // Connect to Azure App Configuration and load all feature flags with no label
+        builder.Configuration.AddAzureAppConfiguration(options =>
+        {
+            options.Connect(new Uri(endpoint), new DefaultAzureCredential())
+                   .UseFeatureFlags();
+        });
+    
+        // Add Azure App Configuration middleware to the container of services
+        builder.Services.AddAzureAppConfiguration();
+    
+        // Add feature management to the container of services
+        builder.Services.AddFeatureManagement();
+    
+        // The rest of existing code in Program.cs
+        // ... ...
+        ```
+
+    ### [Connection string](#tab/connection-string)
+    
     Update the *Program.cs* file with the following code. 
 
     ``` C#
@@ -55,14 +117,15 @@ In this section, you will create a web application that allows users to sign in
 
     var builder = WebApplication.CreateBuilder(args);
 
-    // Retrieve the App Config connection string
-    string AppConfigConnectionString = builder.Configuration.GetConnectionString("AppConfig") ?? throw new InvalidOperationException("Connection string 'AppConfig' not found."); ;
+    // Retrieve the connection string
+    string connectionString = builder.Configuration.GetConnectionString("AppConfiguration")
+        ?? throw new InvalidOperationException("The connection string 'AppConfiguration' was not found.");
 
-    // Load feature flag configuration from Azure App Configuration
+    // Connect to Azure App Configuration and load all feature flags with no label
     builder.Configuration.AddAzureAppConfiguration(options =>
     {
-        options.Connect(AppConfigConnectionString);
-        options.UseFeatureFlags();
+        options.Connect(connectionString)
+               .UseFeatureFlags();
     });
 
     // Add Azure App Configuration middleware to the container of services
@@ -75,6 +138,8 @@ In this section, you will create a web application that allows users to sign in
     // ... ...
     ```
 
+    ---
+
 1. Enable configuration and feature flag refresh from Azure App Configuration with the App Configuration middleware.
 
     Update Program.cs withe the following code.
@@ -104,7 +169,7 @@ In this section, you will create a web application that allows users to sign in
     <h1>This is the beta website.</h1>
     ```
 
-1. Open *Beta.cshtml.cs*, and add `FeatureGate` attribute to the `BetaModel` class.
+1. Open *Beta.cshtml.cs*, and add the `FeatureGate` attribute to the `BetaModel` class.
 
     ``` C#
     using Microsoft.AspNetCore.Mvc.RazorPages;

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

@@ -64,12 +64,6 @@ Connect to your App Configuration store using Microsoft Entra ID (recommended),
     ```
     ---
 
-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)
@@ -83,11 +77,11 @@ Connect to your App Configuration store using Microsoft Entra ID (recommended),
     
     ### [Connection string](#tab/connection-string)
 
-    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.
+    The command uses [Secret Manager](/aspnet/core/security/app-secrets) to store a secret named `ConnectionStrings:AppConfiguration`, which stores the connection string for your App Configuration store. Replace the `<your-App-Configuration-connection-string>` placeholder with your App Configuration store's read-only 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
-    dotnet user-secrets set ConnectionStrings:AppConfig "<your_connection_string>"
+    dotnet user-secrets set ConnectionStrings:AppConfiguration "<your-App-Configuration-connection-string>"
     ```
 
     > [!TIP]
@@ -124,15 +118,16 @@ Connect to your App Configuration store using Microsoft Entra ID (recommended),
     var builder = WebApplication.CreateBuilder(args); 
     
     // Retrieve the endpoint
-    string endpoint = builder.Configuration.Get("Endpoints:AppConfiguration");
-    
+    string endpoint = builder.Configuration.GetValue<string>("Endpoints:AppConfiguration")
+        ?? throw new InvalidOperationException("The setting `Endpoints:AppConfiguration` was not found.");
+
     // Load configuration from Azure App Configuration 
     builder.Configuration.AddAzureAppConfiguration(options =>
     {
         options.Connect(new Uri(endpoint), new DefaultAzureCredential());
     });
     
-     // The rest of existing code in program.cs
+    // The rest of existing code in program.cs
     // ... ...    
     ```
 
@@ -142,7 +137,8 @@ Connect to your App Configuration store using Microsoft Entra ID (recommended),
     var builder = WebApplication.CreateBuilder(args);
 
     // Retrieve the connection string
-    string connectionString = builder.Configuration.GetConnectionString("AppConfig");
+    string connectionString = builder.Configuration.GetConnectionString("AppConfiguration")
+        ?? throw new InvalidOperationException("The connection string 'AppConfiguration' was not found.");
 
     // Load configuration from Azure App Configuration
     builder.Configuration.AddAzureAppConfiguration(connectionString);

articles/azure-app-configuration/use-variant-feature-flags-aspnet-core.md

@@ -1,17 +1,17 @@
 ---
-title: 'Tutorial: Use variant feature flags from Azure App Configuration in an ASP.NET application'
+title: 'Tutorial: Use variant feature flags from Azure App Configuration in an ASP.NET Core application'
 titleSuffix: Azure App configuration
-description: In this tutorial, you learn how to use variant feature flags in an ASP.NET application
+description: In this tutorial, you learn how to use variant feature flags in an ASP.NET Core application
 #customerintent: As a user of Azure App Configuration, I want to learn how I can use variants and variant feature flags in my ASP.NET application.
 author: rossgrambo
 ms.author: rossgrambo
 ms.service: azure-app-configuration
 ms.devlang: csharp
 ms.topic: tutorial
-ms.date: 10/18/2024
+ms.date: 12/18/2024
 ---
 
-# Tutorial: Use variant feature flags from Azure App Configuration in an ASP.NET application
+# Tutorial: Use variant feature flags in an ASP.NET Core application
 
 In this tutorial, you use a variant feature flag to manage experiences for different user segments in an example application, *Quote of the Day*. You utilize the variant feature flag created in [Use variant feature flags](./use-variant-feature-flags.md). Before proceeding, ensure you create the variant feature flag named *Greeting* in your App Configuration store.
 
@@ -28,10 +28,11 @@ In this tutorial, you use a variant feature flag to manage experiences for diffe
     dotnet new razor --auth Individual -o QuoteOfTheDay
     ```
 
-1. Create a [user secret](/aspnet/core/security/app-secrets) for the application by navigating into the *QuoteOfTheDay* folder and run the following command. This secret holds the endpoint for your App Configuration.
+1. Navigate to the *QuoteOfTheDay* directory and create a [user secret](/aspnet/core/security/app-secrets) for the application by running the following commands. 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 set Endpoints:AppConfiguration "<App Configuration Endpoint>"
+    dotnet user-secrets init
+    dotnet user-secrets set Endpoints:AppConfiguration "<your-App-Configuration-endpoint>"
     ```
 
 1. Add the latest versions of the required packages.
@@ -44,26 +45,31 @@ In this tutorial, you use a variant feature flag to manage experiences for diffe
 
 ## Connect to App Configuration for feature management
 
-1. In *Program.cs*, add the following using statements.
+1. Open *Program.cs* and add the following using statements.
 
     ```csharp
     using Azure.Identity;
     using Microsoft.Extensions.Configuration.AzureAppConfiguration;
     using Microsoft.FeatureManagement;
     ```
 
-1. In *Program.cs*, under the line `var builder = WebApplication.CreateBuilder(args);`, add the App Configuration provider, which pulls down the configuration from Azure App Configuration when the application starts. By default, the `UseFeatureFlags` method pulls down all feature flags with no label.
+1. Add the following code to connect to your App Configuration store and call `UseFeatureFlags` to pull down all feature flags with no label.
 
     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); 
+
+    // Retrieve the endpoint
+    string endpoint = builder.Configuration.GetValue<string>("Endpoints:AppConfiguration")
+        ?? throw new InvalidOperationException("The setting `Endpoints:AppConfiguration` was not found.");
+
+    // Load configuration and feature flags from Azure App Configuration
     builder.Configuration
         .AddAzureAppConfiguration(options =>
         {
-            string endpoint = builder.Configuration.Get("Endpoints:AppConfiguration");
-            options.Connect(new Uri(endpoint), new DefaultAzureCredential());
-
-            options.UseFeatureFlags();
+            options.Connect(new Uri(endpoint), new DefaultAzureCredential())
+                   .UseFeatureFlags();
         });
     ```
 

articles/azure-cache-for-redis/cache-network-isolation.md

@@ -52,14 +52,25 @@ Virtual Network (VNet) enables many Azure resources to securely communicate with
 
 ### Limitations of VNet injection
 
-- Creating and maintaining virtual network configurations is error prone. Troubleshooting network configuration issues is challenging. Incorrect virtual network configurations can lead to various issues:
-  - loss of metrics for your cache instances
-  - unplanned loss of availability, which can cause data loss (loss of availability caused by customer network configuration might not be covered by SLA)
-  - failure to replicate data, which can cause data loss
+- Creating and maintaining virtual network configurations are often error prone. Troubleshooting is challenging, too. Incorrect virtual network configurations can lead to issues:
+
+  - obstructed metrics transmission from your cache instances
+  
+  - failure of replica node to replicate data from primary node
+  
+  - potential data loss
+  
   - failure of management operations like scaling
+  
+  - intermittent or complete SSL/TLS failures
+  
+  - failure to apply updates, including important security and reliability improvements
+  
+  - in the most severe scenarios, loss of availability
+  
 - When using a VNet injected cache, you must keep your VNet updated to allow access to cache dependencies, such as Certificate Revocation Lists, Public Key Infrastructure, Azure Key Vault, Azure Storage, Azure Monitor, and more.
-- VNet injected caches are only available for Premium-tier Azure Cache for Redis instances.
-- You can't inject an existing Azure Cache for Redis instance into a Virtual Network. You can only select this option when you create the cache.
+- VNet injected caches are only available for Premium-tier Azure Cache for Redis instances, not other tiers.
+- You can't inject an existing Azure Cache for Redis instance into a Virtual Network. You must select this option when you *create* the cache.
 
 ## Firewall rules
 

articles/cdn/edgio-retirement-faq.md

@@ -60,4 +60,4 @@ New Azure CDN from Edgio profiles can't be created after December 13, 2025.
 
 ### Can I request an extension for the retirement/shutdown of the Azure CDN from Edgio service?
 
-No, extensions aren't possible. Edgio confirmed that their platform will shut down by January 15, 2024.
+No, extensions aren't possible. Edgio confirmed that their platform will shut down by January 15, 2025.