Support for Azure Redis Cache and Cluster resources (#198)

* git rebase origin/main

* Unit tests for Redis commands

* Remove incomplete redis.bicep

* dotnet format

* Add Redis commands to docs

* Add live tests for Redis

* Redis CODEOWNERS

* Address code review feedback

* Cleanup PR issues

* Accommodate changes in command Name/Desc/Title

* Support for Azure Redis Caches and Clusters

* Unit tests for Redis commands

* dotnet format

* Cleanup empty class declarations

* Enable EntraID auth; disable local auth on cache

* Remove duplicated code from merge error

* dotnet format

---------

Co-authored-by: Xiang Yan <xiangsjtu@gmail.com>

Author: philon-msft

.github/CODEOWNERS

@@ -116,6 +116,13 @@
 # ServiceLabel: %area-ServiceBus
 # ServiceOwners:                       @shankarsama @EldertGrootenboer
 
+# PRLabel: %area-Redis
+/src/Arguments/Redis/             @philon-msft @xiangyan99
+/src/Commands/Redis/              @philon-msft @xiangyan99
+/src/Services/Azure/Redis/        @philon-msft @xiangyan99
+
+# ServiceLabel: %area-Redis
+# ServiceOwners:                       @philon-msft @carldc
 
 # PRLabel: %area-Storage
 /src/Arguments/Storage/                @alzimmermsft @jongio

.vscode/cspell.json

@@ -131,6 +131,7 @@
     ],
     "words": [
         "1espt",
+        "accesspolicy",
         "ADMINPROVIDER",
         "alcoop",
         "appconfig",
@@ -150,6 +151,7 @@
         "gethealth",
         "healthmodels",
         "kcsb",
+        "keyspace",
         "Kusto",
         "esrp",
         "ESRPRELPACMANTEST",
@@ -171,6 +173,7 @@
         "npmjs",
         "onboarded",
         "pscore",
+        "RediSearch",
         "resourcegroup",
         "resourcegroups",
         "servicebus",

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### Features Added
 
+- Support for Azure Redis Caches and Clusters https://github.com/Azure/azure-mcp/pull/198
+
 ### Breaking Changes
 
 ### Bugs Fixed

Directory.Packages.props

@@ -13,6 +13,8 @@
     <PackageVersion Include="Azure.ResourceManager.AppConfiguration" Version="1.4.0" />
     <PackageVersion Include="Azure.ResourceManager.Kusto" Version="1.1.0" />
     <PackageVersion Include="Azure.ResourceManager.PostgreSql" Version="1.2.0" />
+    <PackageVersion Include="Azure.ResourceManager.Redis" Version="1.5.0" />
+    <PackageVersion Include="Azure.ResourceManager.RedisEnterprise" Version="1.1.0" />
     <PackageVersion Include="Azure.Security.KeyVault.Keys" Version="4.7.0" />
     <PackageVersion Include="Azure.Storage.Blobs" Version="12.24.0" />
     <PackageVersion Include="Azure.ResourceManager.CosmosDB" Version="1.3.2" />

docs/azmcp-commands.md

@@ -229,6 +229,21 @@ azmcp servicebus topic subscription peek --subscription <subscription> --namespa
 azmcp servicebus topic subscription details --subscription <subscription> --namespace <service-bus-namespace> --topic-name <topic-name> --subscription-name <subscription-name>
 ```
 
+### Azure Redis Operations
+```bash
+# Lists Redis Clusters in the Azure Managed Redis or Azure Redis Enterprise services
+azmcp redis cluster list --subscription <subscription> 
+
+# Lists Databases in an Azure Redis Cluster
+azmcp redis cluster database list --subscription <subscription> --resource-group <resource-group> --cluster <cluster-name>
+
+# Lists Redis Caches in the Azure Cache for Redis service
+azmcp redis cache list --subscription <subscription> 
+
+# Lists Access Policy Assignments in an Azure Redis Cache
+azmcp redis cache list accesspolicy --subscription <subscription>  --resource-group <resource-group> --cache <cache-name>
+```
+
 ### Azure Resource Group Operations
 ```bash
 # List resource groups in a subscription

infra/services/redis.bicep

@@ -0,0 +1,72 @@
+targetScope = 'resourceGroup'
+
+@minLength(3)
+@maxLength(24)
+@description('The base resource name.')
+param baseName string = resourceGroup().name
+
+@description('The location of the resource. By default, this is the same as the resource group.')
+param location string = resourceGroup().location
+
+@description('The tenant ID to which the application and resources belong.')
+param tenantId string = '72f988bf-86f1-41af-91ab-2d7cd011db47'
+
+@description('The client OID to grant access to test resources.')
+param testApplicationOid string
+
+resource redisCache 'Microsoft.Cache/Redis@2024-11-01' = {
+  name: baseName
+  location: location
+  properties: {
+    enableNonSslPort: false
+    minimumTlsVersion: '1.2'
+    disableAccessKeyAuthentication: true
+    sku: {
+      capacity: 0
+      family: 'C'
+      name: 'Basic'
+    }
+    redisConfiguration: {
+      'aad-enabled': 'true'
+    }
+  }
+}
+
+resource redisCacheAccessPolicyAssignment 'Microsoft.Cache/Redis/accessPolicyAssignments@2024-11-01' = {
+  parent: redisCache
+  name: baseName
+  properties: {
+    accessPolicyName: 'Data Owner'
+    objectId: testApplicationOid
+    objectIdAlias: testApplicationOid
+  }
+}
+
+resource redisCluster 'Microsoft.Cache/redisEnterprise@2025-05-01-preview' = {
+  location: location
+  name: baseName
+  sku: {
+    name: 'Balanced_B0'
+  }
+  identity: {
+    type: 'None'
+  }
+  properties: {
+    minimumTlsVersion: '1.2'
+  }
+}
+
+resource redisClusterDatabase 'Microsoft.Cache/redisEnterprise/databases@2025-05-01-preview' = {
+  parent: redisCluster
+  name: 'default'
+  properties:{
+    clientProtocol: 'Encrypted'
+    port: 10000
+    clusteringPolicy: 'OSSCluster'
+    evictionPolicy: 'NoEviction'
+    persistence:{
+      aofEnabled: false 
+      rdbEnabled: false
+    }
+  }
+}

infra/test-resources.bicep

@@ -76,6 +76,16 @@ module servicebus 'services/servicebus.bicep' = {
   }
 }
 
+module redis 'services/redis.bicep' = {
+  name: '${deploymentName}-redis'
+  params: {
+    baseName: baseName
+    location: location
+    tenantId: tenantId
+    testApplicationOid: testApplicationOid
+  }
+}
+
 module kusto 'services/kusto.bicep' = {
   name: '${deploymentName}-kusto'
   params: {

src/Arguments/Redis/CacheForRedis/AccessPolicyListArguments.cs

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace AzureMcp.Arguments.Redis.CacheForRedis;
+
+public class AccessPolicyListArguments : BaseCacheArguments;

src/Arguments/Redis/CacheForRedis/BaseCacheArguments.cs

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json.Serialization;
+using AzureMcp.Models.Argument;
+
+namespace AzureMcp.Arguments.Redis.CacheForRedis;
+
+public class BaseCacheArguments : SubscriptionArguments
+{
+    [JsonPropertyName(ArgumentDefinitions.Redis.CacheName)]
+    public string? Cache { get; set; }
+}

src/Arguments/Redis/CacheForRedis/CacheListArguments.cs

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace AzureMcp.Arguments.Redis.CacheForRedis;
+
+public class CacheListArguments : SubscriptionArguments;

src/Arguments/Redis/ManagedRedis/BaseClusterArguments.cs

@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json.Serialization;
+using AzureMcp.Models.Argument;
+
+namespace AzureMcp.Arguments.Redis.ManagedRedis;
+
+public class BaseClusterArguments : SubscriptionArguments
+{
+    [JsonPropertyName(ArgumentDefinitions.Redis.ClusterName)]
+    public string? Cluster { get; set; }
+}

src/Arguments/Redis/ManagedRedis/ClusterListArguments.cs

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace AzureMcp.Arguments.Redis.ManagedRedis;
+
+public class ClusterListArguments : SubscriptionArguments;

src/Arguments/Redis/ManagedRedis/DatabaseListArguments.cs

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace AzureMcp.Arguments.Redis.ManagedRedis;
+
+public class DatabaseListArguments : BaseClusterArguments;

src/AzureMcp.csproj

@@ -51,6 +51,8 @@
     <PackageReference Include="Azure.ResourceManager.AppConfiguration" />
     <PackageReference Include="Azure.ResourceManager.Kusto" />
     <PackageReference Include="Azure.ResourceManager.PostgreSql" />
+    <PackageReference Include="Azure.ResourceManager.Redis" />
+    <PackageReference Include="Azure.ResourceManager.RedisEnterprise" />
     <PackageReference Include="Azure.Security.KeyVault.Keys" />
     <PackageReference Include="Azure.Storage.Blobs" />
     <PackageReference Include="Azure.ResourceManager.CosmosDB" />

src/Commands/CommandFactory.cs

@@ -87,6 +87,7 @@ private void RegisterCommandGroup()
         RegisterGroupCommands();
         RegisterMcpServerCommands();
         RegisterServiceBusCommands();
+        RegisterRedisCommands();
     }
 
     private void RegisterBestPracticesCommand()
@@ -372,6 +373,34 @@ private void RegisterServiceBusCommands()
         topic.AddSubGroup(subscription);
     }
 
+    private void RegisterRedisCommands()
+    {
+        var redis = new CommandGroup("redis", "Redis Cache operations - Commands for managing and accessing Azure Redis Cache resources.");
+        _rootGroup.AddSubGroup(redis);
+
+        // Azure Cache for Redis
+        var cache = new CommandGroup("cache", "Redis Cache resource operations - Commands for listing and managing Redis Cache resources in your Azure subscription.");
+        redis.AddSubGroup(cache);
+
+        cache.AddCommand("list", new Redis.CacheForRedis.CacheListCommand(GetLogger<Redis.CacheForRedis.CacheListCommand>()));
+
+        var accessPolicy = new CommandGroup("accesspolicy", "Redis Cluster database operations - Commands for listing and managing Redis Cluster databases in your Azure subscription.");
+        cache.AddSubGroup(accessPolicy);
+
+        accessPolicy.AddCommand("list", new Redis.CacheForRedis.AccessPolicyListCommand(GetLogger<Redis.CacheForRedis.AccessPolicyListCommand>()));
+
+        // Azure Managed Redis
+        var cluster = new CommandGroup("cluster", "Redis Cluster resource operations - Commands for listing and managing Redis Cluster resources in your Azure subscription.");
+        redis.AddSubGroup(cluster);
+
+        cluster.AddCommand("list", new Redis.ManagedRedis.ClusterListCommand(GetLogger<Redis.ManagedRedis.ClusterListCommand>()));
+
+        var database = new CommandGroup("database", "Redis Cluster database operations - Commands for listing and managing Redis Cluster Databases in your Azure subscription.");
+        cluster.AddSubGroup(database);
+
+        database.AddCommand("list", new Redis.ManagedRedis.DatabaseListCommand(GetLogger<Redis.ManagedRedis.DatabaseListCommand>()));
+    }
+
     private void ConfigureCommands(CommandGroup group)
     {
         // Configure direct commands in this group

src/Commands/Redis/CacheForRedis/AccessPolicyListCommand.cs

@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.CommandLine.Parsing;
+using AzureMcp.Arguments.Redis.CacheForRedis;
+using AzureMcp.Models.Command;
+using AzureMcp.Models.Redis.CacheForRedis;
+using AzureMcp.Services.Interfaces;
+using Microsoft.Extensions.Logging;
+using ModelContextProtocol.Server;
+
+namespace AzureMcp.Commands.Redis.CacheForRedis;
+
+/// <summary>
+/// Lists the access policy assignments in the specified Azure cache.
+/// </summary>
+public sealed class AccessPolicyListCommand(ILogger<AccessPolicyListCommand> logger) : BaseCacheCommand<AccessPolicyListArguments>()
+{
+    private const string _commandTitle = "List Redis Cache Access Policy Assignments";
+    private readonly ILogger<AccessPolicyListCommand> _logger = logger;
+
+    public override string Name => "list";
+    public override string Description =>
+        $"""
+        List the Access Policies and Assignments for the specified Redis cache. Returns an array of Redis Access Policy Assignment details.
+        Use this command to explore which Access Policies have been assigned to which identities for your Redis cache.
+        """;
+
+    public override string Title => _commandTitle;
+
+    [McpServerTool(Destructive = false, ReadOnly = true, Title = _commandTitle)]
+    public override async Task<CommandResponse> ExecuteAsync(CommandContext context, ParseResult parseResult)
+    {
+        try
+        {
+            var args = BindArguments(parseResult);
+
+            if (!await ProcessArguments(context, args))
+            {
+                return context.Response;
+            }
+
+            var redisService = context.GetService<IRedisService>() ?? throw new InvalidOperationException("Redis service is not available.");
+            var accessPolicyAssignments = await redisService.ListAccessPolicyAssignmentsAsync(
+                args.Cache!,
+                args.ResourceGroup!,
+                args.Subscription!,
+                args.Tenant,
+                args.AuthMethod,
+                args.RetryPolicy);
+
+            context.Response.Results = accessPolicyAssignments.Any() ?
+                ResponseResult.Create(
+                    new AccessPolicyListCommandResult(accessPolicyAssignments),
+                    RedisJsonContext.Default.AccessPolicyListCommandResult) :
+                null;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to list Redis Access Policy Assignments");
+            HandleException(context.Response, ex);
+        }
+
+        return context.Response;
+    }
+
+    internal record AccessPolicyListCommandResult(IEnumerable<AccessPolicyAssignment> AccessPolicyAssignments);
+}

src/Commands/Redis/CacheForRedis/BaseCacheCommand.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.CommandLine;
+using System.CommandLine.Parsing;
+using System.Diagnostics.CodeAnalysis;
+using AzureMcp.Arguments.Redis.CacheForRedis;
+using AzureMcp.Models.Argument;
+
+namespace AzureMcp.Commands.Redis.CacheForRedis;
+
+public abstract class BaseCacheCommand<
+    [DynamicallyAccessedMembers(TrimAnnotations.CommandAnnotations)] T>
+    : SubscriptionCommand<T> where T : BaseCacheArguments, new()
+{
+    protected readonly Option<string> _cacheOption = ArgumentDefinitions.Redis.Cache.ToOption();
+
+    protected override void RegisterOptions(Command command)
+    {
+        base.RegisterOptions(command);
+        command.AddOption(_cacheOption);
+        command.AddOption(_resourceGroupOption);
+    }
+
+    protected override void RegisterArguments()
+    {
+        base.RegisterArguments();
+        AddArgument(CreateCacheArgument());
+        AddArgument(CreateResourceGroupArgument());
+    }
+
+    protected override T BindArguments(ParseResult parseResult)
+    {
+        var args = base.BindArguments(parseResult);
+        args.Cache = parseResult.GetValueForOption(_cacheOption);
+        args.ResourceGroup = parseResult.GetValueForOption(_resourceGroupOption) ?? ArgumentDefinitions.Common.ResourceGroup.DefaultValue;
+        return args;
+    }
+
+    protected ArgumentBuilder<T> CreateCacheArgument() =>
+        ArgumentBuilder<T>
+            .Create(ArgumentDefinitions.Redis.Cache.Name, ArgumentDefinitions.Redis.Cache.Description)
+            .WithValueAccessor(args => args.Cache ?? string.Empty)
+            .WithIsRequired(ArgumentDefinitions.Redis.Cache.Required);
+}