Azure Resource Manager Redis Dotnet

1---
2name: azure-resource-manager-redis-dotnet
3description: |
4  Azure Resource Manager SDK for Redis in .NET. Use for MANAGEMENT PLANE operations: creating/managing Azure Cache for Redis instances, firewall rules, access keys, patch schedules, linked servers (geo-replication), and private endpoints via Azure Resource Manager. NOT for data plane operations (get/set keys, pub/sub) - use StackExchange.Redis for that. Triggers: "Redis cache", "create Redis", "manage Redis", "ARM Redis", "RedisResource", "provision Redis", "Azure Cache for Redis".
5package: Azure.ResourceManager.Redis
6---
7 
8# Azure.ResourceManager.Redis (.NET)
9 
10Management plane SDK for provisioning and managing Azure Cache for Redis resources via Azure Resource Manager.
11 
12> **⚠️ Management vs Data Plane**
13> - **This SDK (Azure.ResourceManager.Redis)**: Create caches, configure firewall rules, manage access keys, set up geo-replication
14> - **Data Plane SDK (StackExchange.Redis)**: Get/set keys, pub/sub, streams, Lua scripts
15 
16## Installation
17 
18```bash
19dotnet add package Azure.ResourceManager.Redis
20dotnet add package Azure.Identity
21```
22 
23**Current Version**: 1.5.1 (Stable)  
24**API Version**: 2024-11-01  
25**Target Frameworks**: .NET 8.0, .NET Standard 2.0
26 
27## Environment Variables
28 
29```bash
30AZURE_SUBSCRIPTION_ID=<your-subscription-id>
31# For service principal auth (optional)
32AZURE_TENANT_ID=<tenant-id>
33AZURE_CLIENT_ID=<client-id>
34AZURE_CLIENT_SECRET=<client-secret>
35```
36 
37## Authentication
38 
39```csharp
40using Azure.Identity;
41using Azure.ResourceManager;
42using Azure.ResourceManager.Redis;
43 
44// Always use DefaultAzureCredential
45var credential = new DefaultAzureCredential();
46var armClient = new ArmClient(credential);
47 
48// Get subscription
49var subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID");
50var subscription = armClient.GetSubscriptionResource(
51    new ResourceIdentifier($"/subscriptions/{subscriptionId}"));
52```
53 
54## Resource Hierarchy
55 
56```
57ArmClient
58└── SubscriptionResource
59    └── ResourceGroupResource
60        └── RedisResource
61            ├── RedisFirewallRuleResource
62            ├── RedisPatchScheduleResource
63            ├── RedisLinkedServerWithPropertyResource
64            ├── RedisPrivateEndpointConnectionResource
65            └── RedisCacheAccessPolicyResource
66```
67 
68## Core Workflows
69 
70### 1. Create Redis Cache
71 
72```csharp
73using Azure.ResourceManager.Redis;
74using Azure.ResourceManager.Redis.Models;
75 
76// Get resource group
77var resourceGroup = await subscription
78    .GetResourceGroupAsync("my-resource-group");
79 
80// Define cache configuration
81var cacheData = new RedisCreateOrUpdateContent(
82    location: AzureLocation.EastUS,
83    sku: new RedisSku(RedisSkuName.Standard, RedisSkuFamily.BasicOrStandard, 1))
84{
85    EnableNonSslPort = false,
86    MinimumTlsVersion = RedisTlsVersion.Tls1_2,
87    RedisConfiguration = new RedisCommonConfiguration
88    {
89        MaxMemoryPolicy = "volatile-lru"
90    },
91    Tags =
92    {
93        ["environment"] = "production"
94    }
95};
96 
97// Create cache (long-running operation)
98var cacheCollection = resourceGroup.Value.GetAllRedis();
99var operation = await cacheCollection.CreateOrUpdateAsync(
100    WaitUntil.Completed,
101    "my-redis-cache",
102    cacheData);
103 
104RedisResource cache = operation.Value;
105Console.WriteLine($"Cache created: {cache.Data.HostName}");
106```
107 
108### 2. Get Redis Cache
109 
110```csharp
111// Get existing cache
112var cache = await resourceGroup.Value
113    .GetRedisAsync("my-redis-cache");
114 
115Console.WriteLine($"Host: {cache.Value.Data.HostName}");
116Console.WriteLine($"Port: {cache.Value.Data.Port}");
117Console.WriteLine($"SSL Port: {cache.Value.Data.SslPort}");
118Console.WriteLine($"Provisioning State: {cache.Value.Data.ProvisioningState}");
119```
120 
121### 3. Update Redis Cache
122 
123```csharp
124var patchData = new RedisPatch
125{
126    Sku = new RedisSku(RedisSkuName.Standard, RedisSkuFamily.BasicOrStandard, 2),
127    RedisConfiguration = new RedisCommonConfiguration
128    {
129        MaxMemoryPolicy = "allkeys-lru"
130    }
131};
132 
133var updateOperation = await cache.Value.UpdateAsync(
134    WaitUntil.Completed,
135    patchData);
136```
137 
138### 4. Delete Redis Cache
139 
140```csharp
141await cache.Value.DeleteAsync(WaitUntil.Completed);
142```
143 
144### 5. Get Access Keys
145 
146```csharp
147var keys = await cache.Value.GetKeysAsync();
148Console.WriteLine($"Primary Key: {keys.Value.PrimaryKey}");
149Console.WriteLine($"Secondary Key: {keys.Value.SecondaryKey}");
150```
151 
152### 6. Regenerate Access Keys
153 
154```csharp
155var regenerateContent = new RedisRegenerateKeyContent(RedisRegenerateKeyType.Primary);
156var newKeys = await cache.Value.RegenerateKeyAsync(regenerateContent);
157Console.WriteLine($"New Primary Key: {newKeys.Value.PrimaryKey}");
158```
159 
160### 7. Manage Firewall Rules
161 
162```csharp
163// Create firewall rule
164var firewallData = new RedisFirewallRuleData(
165    startIP: System.Net.IPAddress.Parse("10.0.0.1"),
166    endIP: System.Net.IPAddress.Parse("10.0.0.255"));
167 
168var firewallCollection = cache.Value.GetRedisFirewallRules();
169var firewallOperation = await firewallCollection.CreateOrUpdateAsync(
170    WaitUntil.Completed,
171    "allow-internal-network",
172    firewallData);
173 
174// List all firewall rules
175await foreach (var rule in firewallCollection.GetAllAsync())
176{
177    Console.WriteLine($"Rule: {rule.Data.Name} ({rule.Data.StartIP} - {rule.Data.EndIP})");
178}
179 
180// Delete firewall rule
181var ruleToDelete = await firewallCollection.GetAsync("allow-internal-network");
182await ruleToDelete.Value.DeleteAsync(WaitUntil.Completed);
183```
184 
185### 8. Configure Patch Schedule (Premium SKU)
186 
187```csharp
188// Patch schedules require Premium SKU
189var scheduleData = new RedisPatchScheduleData(
190    new[]
191    {
192        new RedisPatchScheduleSetting(RedisDayOfWeek.Saturday, 2) // 2 AM Saturday
193        {
194            MaintenanceWindow = TimeSpan.FromHours(5)
195        },
196        new RedisPatchScheduleSetting(RedisDayOfWeek.Sunday, 2) // 2 AM Sunday
197        {
198            MaintenanceWindow = TimeSpan.FromHours(5)
199        }
200    });
201 
202var scheduleCollection = cache.Value.GetRedisPatchSchedules();
203await scheduleCollection.CreateOrUpdateAsync(
204    WaitUntil.Completed,
205    RedisPatchScheduleDefaultName.Default,
206    scheduleData);
207```
208 
209### 9. Import/Export Data (Premium SKU)
210 
211```csharp
212// Import data from blob storage
213var importContent = new ImportRdbContent(
214    files: new[] { "https://mystorageaccount.blob.core.windows.net/container/dump.rdb" },
215    format: "RDB");
216 
217await cache.Value.ImportDataAsync(WaitUntil.Completed, importContent);
218 
219// Export data to blob storage
220var exportContent = new ExportRdbContent(
221    prefix: "backup",
222    container: "https://mystorageaccount.blob.core.windows.net/container?sastoken",
223    format: "RDB");
224 
225await cache.Value.ExportDataAsync(WaitUntil.Completed, exportContent);
226```
227 
228### 10. Force Reboot
229 
230```csharp
231var rebootContent = new RedisRebootContent
232{
233    RebootType = RedisRebootType.AllNodes,
234    ShardId = 0 // For clustered caches
235};
236 
237await cache.Value.ForceRebootAsync(rebootContent);
238```
239 
240## SKU Reference
241 
242| SKU | Family | Capacity | Features |
243|-----|--------|----------|----------|
244| Basic | C | 0-6 | Single node, no SLA, dev/test only |
245| Standard | C | 0-6 | Two nodes (primary/replica), SLA |
246| Premium | P | 1-5 | Clustering, geo-replication, VNet, persistence |
247 
248**Capacity Sizes (Family C - Basic/Standard)**:
249- C0: 250 MB
250- C1: 1 GB
251- C2: 2.5 GB
252- C3: 6 GB
253- C4: 13 GB
254- C5: 26 GB
255- C6: 53 GB
256 
257**Capacity Sizes (Family P - Premium)**:
258- P1: 6 GB per shard
259- P2: 13 GB per shard
260- P3: 26 GB per shard
261- P4: 53 GB per shard
262- P5: 120 GB per shard
263 
264## Key Types Reference
265 
266| Type | Purpose |
267|------|---------|
268| `ArmClient` | Entry point for all ARM operations |
269| `RedisResource` | Represents a Redis cache instance |
270| `RedisCollection` | Collection for cache CRUD operations |
271| `RedisFirewallRuleResource` | Firewall rule for IP filtering |
272| `RedisPatchScheduleResource` | Maintenance window configuration |
273| `RedisLinkedServerWithPropertyResource` | Geo-replication linked server |
274| `RedisPrivateEndpointConnectionResource` | Private endpoint connection |
275| `RedisCacheAccessPolicyResource` | RBAC access policy |
276| `RedisCreateOrUpdateContent` | Cache creation payload |
277| `RedisPatch` | Cache update payload |
278| `RedisSku` | SKU configuration (name, family, capacity) |
279| `RedisAccessKeys` | Primary and secondary access keys |
280| `RedisRegenerateKeyContent` | Key regeneration request |
281 
282## Best Practices
283 
2841. **Use `WaitUntil.Completed`** for operations that must finish before proceeding
2852. **Use `WaitUntil.Started`** when you want to poll manually or run operations in parallel
2863. **Always use `DefaultAzureCredential`** — never hardcode keys
2874. **Handle `RequestFailedException`** for ARM API errors
2885. **Use `CreateOrUpdateAsync`** for idempotent operations
2896. **Navigate hierarchy** via `Get*` methods (e.g., `cache.GetRedisFirewallRules()`)
2907. **Use Premium SKU** for production workloads requiring geo-replication, clustering, or persistence
2918. **Enable TLS 1.2 minimum** — set `MinimumTlsVersion = RedisTlsVersion.Tls1_2`
2929. **Disable non-SSL port** — set `EnableNonSslPort = false` for security
29310. **Rotate keys regularly** — use `RegenerateKeyAsync` and update connection strings
294 
295## Error Handling
296 
297```csharp
298using Azure;
299 
300try
301{
302    var operation = await cacheCollection.CreateOrUpdateAsync(
303        WaitUntil.Completed, cacheName, cacheData);
304}
305catch (RequestFailedException ex) when (ex.Status == 409)
306{
307    Console.WriteLine("Cache already exists");
308}
309catch (RequestFailedException ex) when (ex.Status == 400)
310{
311    Console.WriteLine($"Invalid configuration: {ex.Message}");
312}
313catch (RequestFailedException ex)
314{
315    Console.WriteLine($"ARM Error: {ex.Status} - {ex.ErrorCode}: {ex.Message}");
316}
317```
318 
319## Common Pitfalls
320 
3211. **SKU downgrades not allowed** — You cannot downgrade from Premium to Standard/Basic
3222. **Clustering requires Premium** — Shard configuration only available on Premium SKU
3233. **Geo-replication requires Premium** — Linked servers only work with Premium caches
3244. **VNet injection requires Premium** — Virtual network support is Premium-only
3255. **Patch schedules require Premium** — Maintenance windows only configurable on Premium
3266. **Cache name globally unique** — Redis cache names must be unique across all Azure subscriptions
3277. **Long provisioning times** — Cache creation can take 15-20 minutes; use `WaitUntil.Started` for async patterns
328 
329## Connecting with StackExchange.Redis (Data Plane)
330 
331After creating the cache with this management SDK, use StackExchange.Redis for data operations:
332 
333```csharp
334using StackExchange.Redis;
335 
336// Get connection info from management SDK
337var cache = await resourceGroup.Value.GetRedisAsync("my-redis-cache");
338var keys = await cache.Value.GetKeysAsync();
339 
340// Connect with StackExchange.Redis
341var connectionString = $"{cache.Value.Data.HostName}:{cache.Value.Data.SslPort},password={keys.Value.PrimaryKey},ssl=True,abortConnect=False";
342var connection = ConnectionMultiplexer.Connect(connectionString);
343var db = connection.GetDatabase();
344 
345// Data operations
346await db.StringSetAsync("key", "value");
347var value = await db.StringGetAsync("key");
348```
349 
350## Related SDKs
351 
352| SDK | Purpose | Install |
353|-----|---------|---------|
354| `StackExchange.Redis` | Data plane (get/set, pub/sub, streams) | `dotnet add package StackExchange.Redis` |
355| `Azure.ResourceManager.Redis` | Management plane (this SDK) | `dotnet add package Azure.ResourceManager.Redis` |
356| `Microsoft.Azure.StackExchangeRedis` | Azure-specific Redis extensions | `dotnet add package Microsoft.Azure.StackExchangeRedis` |
357