Merge pull request #292350 from MicrosoftDocs/main

12/23/2024 PM Publish

Author: Taojunshen

articles/azure-cache-for-redis/cache-aspnet-output-cache-provider.md

@@ -15,8 +15,7 @@ The Redis Output Cache Provider is an out-of-process storage mechanism for outpu
 
 For ASP.NET Core applications, see [Output Caching in ASP.NET core using Redis in .NET 8](/aspnet/core/performance/caching/output?view=aspnetcore-8.0#redis-cache&preserve-view=true).
 
-<!-- This section points to create azure cache for redis instead of amr. Not sure if this article was updated or not? -->
-To use the Redis Output Cache Provider, first configure your cache, and then configure your ASP.NET application using the Redis Output Cache Provider NuGet package. This article provides guidance on configuring your application to use the Redis Output Cache Provider. For more information about creating and configuring an Azure Managed Redis (preview) instance, see [Create a cache](cache-dotnet-how-to-use-azure-redis-cache.md#create-a-cache).
+To use the Redis Output Cache Provider, first configure your cache, and then configure your ASP.NET application using the Redis Output Cache Provider NuGet package. This article provides guidance on configuring your application to use the Redis Output Cache Provider.
 
 ## Store ASP.NET core page output in Redis
 

articles/azure-cache-for-redis/cache-development-faq.yml

@@ -51,7 +51,7 @@ sections:
           ### Timeout values
             * Consider your workload and set the values to match. If you're storing large values, set the timeout to a higher value.
             * Set `AbortOnConnectFail` to false and let StackExchange.Redis reconnect for you.
-            * Use a single, long-lived `ConnectionMultiplexer` instance rather than creating a new connection for each request. For an example of how to manage a connection, see the `RedisConnection`` class in [Connect to the cache with RedisConnection](cache-dotnet-how-to-use-azure-redis-cache.md#connect-to-the-cache-with-redisconnection).
+            * Use a single, long-lived `ConnectionMultiplexer` instance rather than creating a new connection for each request. 
             * Set the `ConnectionMultiplexer.ClientName` property to an app instance unique name for diagnostic purposes.
             * Use multiple `ConnectionMultiplexer` instances for custom workloads.
               * You can follow this model if you have varying load in your application. For example:

articles/azure-cache-for-redis/cache-dotnet-core-quickstart.md

@@ -2,14 +2,15 @@
 title: 'Quickstart: Use Azure Cache for Redis in .NET Core'
 description: In this quickstart, learn how to access Azure Cache for Redis in your .NET Core apps
 
-
-
 ms.devlang: csharp
 ms.custom: devx-track-csharp, mvc, mode-other, devx-track-dotnet, ignite-2024
 ms.topic: quickstart
-ms.date: 03/25/2022
+ms.date: 12/20/2024
+zone_pivot_groups: redis-type
+#Customer intent: As a .NET developer, new to Azure Redis, I want to create a new Node.js app that uses Azure Managed Redis or Azure Cache for Redis.
 ---
-# Quickstart: Use Azure Cache for Redis in .NET Core
+
+# Quickstart: Use Azure Redis in .NET Core
 
 In this quickstart, you incorporate Azure Cache for Redis into a .NET Core app to have access to a secure, dedicated cache that is accessible from any application within Azure. You specifically use the [StackExchange.Redis](https://github.com/StackExchange/StackExchange.Redis) client with C# code in a .NET Core console app.
 
@@ -22,126 +23,99 @@ Clone the repo [https://github.com/Azure-Samples/azure-cache-redis-samples/tree/
 - Azure subscription - [create one for free](https://azure.microsoft.com/free/)
 - [.NET Core SDK](https://dotnet.microsoft.com/download)
 
-## Create a cache
+::: zone pivot="azure-managed-redis"
+
+## Create an Azure Managed Redis (preview) instance
+
+[!INCLUDE [managed-redis-create](includes/managed-redis-create.md)]
+
+::: zone-end
+
+::: zone pivot="azure-cache-redis"
+
+## Create an Azure Cache for Redis instance
 
 [!INCLUDE [redis-cache-create](~/reusable-content/ce-skilling/azure/includes/azure-cache-for-redis/includes/redis-cache-create.md)]
 
-[!INCLUDE [cache-entra-access](includes/cache-entra-access.md)]
+::: zone-end
 
-Make a note of the **HOST NAME**. You'll use these values later to for *appsettings.json*.
+[!INCLUDE [cache-entra-access](includes/cache-entra-access.md)]
 
-## Add a local secret for the connection string
+### Install the Library for using Microsoft Entra ID Authentication
 
-In your *appsettings.json* file, add the following:
+The [Azure.StackExchange.Redis](https://www.nuget.org/packages/Microsoft.Azure.StackExchangeRedis) library contains the Microsoft Entra ID authentication method for connecting to Azure Redis services using Microsoft Entra ID. It's applicable to all Azure Cache for Redis, Azure Cache for Redis Enterprise, and Azure Managed Redis (Preview).
 
-```json
-{
-  "RedisHostName": "your_Azure_Redis_hostname"
-}
+```cli
+dotnet add package Microsoft.Azure.StackExchangeRedis
 ```
 
-1. Replace "your_Azure_Redis_hostname" with your Azure Redis host name and port numbers. For example: `cache-name.region.redis.azure.net:10000` for Azure Managed Redis (preview), and `cache-name.redis.cache.windows.net:6380` for Azure Cache for Redis services.
+---
 
-1. Save the file.
+## Connect to the cache using Microsoft Entra ID
 
-## Connect to the cache with RedisConnection
+1. Include the libraries in your code
 
-In `RedisConnection.cs`, you see the `StackExchange.Redis` namespace has been added to the code. This is needed for the `RedisConnection` class.
+   ```csharp
+   using Azure.Identity;
+   using StackExchange.Redis
+   ```
 
-```csharp
-using StackExchange.Redis;
+1. Using the default Azure credentials to authenticate the client connection. This enables your code to use the signed-in user credential when running locally, and an Azure managed identity when running in Azure without code change.
 
+```csharp
+var configurationOptions = await ConfigurationOptions.Parse($"{_redisHostName}").ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
+ConnectionMultiplexer _newConnection = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
+IDatabase Database = _newConnection.GetDatabase();
 ```
-<!-- Is this right Philo -->
-The `RedisConnection` code ensures that there is always a healthy connection to the cache by managing the `ConnectionMultiplexer` instance from `StackExchange.Redis`. The `RedisConnection` class recreates the connection when a connection is lost and unable to reconnect automatically.
 
-For more information, see [StackExchange.Redis](https://stackexchange.github.io/StackExchange.Redis/) and the code in a [GitHub repo](https://github.com/StackExchange/StackExchange.Redis).
+::: zone pivot="azure-managed-redis"
 
-<!-- :::code language="csharp" source="~/samples-cache/quickstart/dotnet-core/RedisConnection.cs"::: -->
+### To edit the _appsettings.json_ file
 
-## Executing cache commands
+1. Edit the _Web.config_ file. Then add the following content:
 
-In `program.cs`, you can see the following code for the `RunRedisCommandsAsync` method in the `Program` class for the console application:
-<!-- Replaced this code with lines 57-81 from dotnet-core/Program.cs -->
-```csharp
-private static async Task RunRedisCommandsAsync(string prefix)
-    {
-        // Simple PING command
-        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: PING");
-        RedisResult pingResult = await _redisConnection.BasicRetryAsync(async (db) => await db.ExecuteAsync("PING"));
-        Console.WriteLine($"{prefix}: Cache response: {pingResult}");
-
-        // Simple get and put of integral data types into the cache
-        string key = "Message";
-        string value = "Hello! The cache is working from a .NET console app!";
-
-        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: GET {key} via StringGetAsync()");
-        RedisValue getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync(key));
-        Console.WriteLine($"{prefix}: Cache response: {getMessageResult}");
-
-        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: SET {key} \"{value}\" via StringSetAsync()");
-        bool stringSetResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringSetAsync(key, value));
-        Console.WriteLine($"{prefix}: Cache response: {stringSetResult}");
-
-        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: GET {key} via StringGetAsync()");
-        getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync(key));
-        Console.WriteLine($"{prefix}: Cache response: {getMessageResult}");
-
-        // Store serialized object to cache
-        Employee e007 = new Employee("007", "Davide Columbo", 100);
-        stringSetResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringSetAsync("e007", JsonSerializer.Serialize(e007)));
-        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache response from storing serialized Employee object: {stringSetResult}");
-
-        // Retrieve serialized object from cache
-        getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync("e007"));
-        Employee e007FromCache = JsonSerializer.Deserialize<Employee>(getMessageResult);
-        Console.WriteLine($"{prefix}: Deserialized Employee .NET object:{Environment.NewLine}");
-        Console.WriteLine($"{prefix}: Employee.Name : {e007FromCache.Name}");
-        Console.WriteLine($"{prefix}: Employee.Id   : {e007FromCache.Id}");
-        Console.WriteLine($"{prefix}: Employee.Age  : {e007FromCache.Age}{Environment.NewLine}");
-    }
+    ```json
+    "_redisHostName":"<cache-hostname>"
+    ```
 
-```
+1. Replace `<cache-hostname>` with your cache host name as it appears in the Overview section of the Resource menu in the Azure portal.
 
-Cache items can be stored and retrieved by using the `StringSetAsync` and `StringGetAsync` methods.
+   For example, with Azure Managed Redis or the Enterprise tiers: _my-redis.eastus.azure.net:10000_
 
-In the example, you can see the `Message` key is set to value. The app updated that cached value. The app also executed the `PING` and command.
+1. Save the file.
 
-### Work with .NET objects in the cache
+For more information, see [StackExchange.Redis](https://stackexchange.github.io/StackExchange.Redis/) and the code in a [GitHub repo](https://github.com/StackExchange/StackExchange.Redis).
 
-The Redis server stores most data as strings, but these strings can contain many types of data, including serialized binary data, which can be used when storing .NET objects in the cache.
+::: zone-end
 
-Azure Cache for Redis can cache both .NET objects and primitive data types, but before a .NET object can be cached it must be serialized.
+::: zone pivot="azure-cache-redis"
 
-This .NET object serialization is the responsibility of the application developer, and gives the developer flexibility in the choice of the serializer.
+### To edit the _appsettings.json_ file
 
-The following `Employee` class was defined in *Program.cs*  so that the sample could also show how to get and set a serialized object:
+1. Edit the _appsettings.json_ file. Then add the following content:
 
-```csharp
-class Employee
-    {
-        public string Id { get; set; }
-        public string Name { get; set; }
-        public int Age { get; set; }
-
-        public Employee(string id, string name, int age)
-        {
-            Id = id;
-            Name = name;
-            Age = age;
-        }
-    }
-```
+    ```json
+    "_redisHostName":"<cache-hostname>"
+    ```
+
+1. Replace `<cache-hostname>` with your cache host name as it appears in the Overview section of the Resource menu in the Azure portal. 
+
+   For example, with Azure Cache for Redis: _my-redis.eastus.azure.net:6380_
+
+1. Save the file.
+
+For more information, see [StackExchange.Redis](https://stackexchange.github.io/StackExchange.Redis/) and the code in a [GitHub repo](https://github.com/StackExchange/StackExchange.Redis).
+::: zone-end
 
 ## Run the sample
 
-If you have opened any files, save them and build the app with the following command:
+If you opened any files, save them, and build the app with the following command:
 
 ```dos
 dotnet build
 ```
 
-Run the app with the following command to test serialization of .NET objects:
+To test serialization of .NET objects, run the app with the following command:
 
 ```dos
 dotnet run
@@ -151,7 +125,7 @@ dotnet run
 
 [!INCLUDE [cache-delete-resource-group](includes/cache-delete-resource-group.md)]
 
-## Next steps
+## Related content
 
 - [Connection resilience](cache-best-practices-connection.md)
 - [Best Practices Development](cache-best-practices-development.md)