Azure.ResourceManager.Redis (.NET)

SDK du plan de gestion pour provisionner et gérer les ressources Azure Cache for Redis via Azure Resource Manager.

⚠️ Plan de gestion vs Plan de données

• Ce SDK (Azure.ResourceManager.Redis) : Créer des caches, configurer les règles de pare-feu, gérer les clés d'accès, configurer la géo-réplication
• SDK du plan de données (StackExchange.Redis) : Obtenir/définir des clés, pub/sub, streams, scripts Lua

Installation

dotnet add package Azure.ResourceManager.Redis
dotnet add package Azure.Identity

Version actuelle : 1.5.1 (Stable)
Version API : 2024-11-01
Frameworks cibles : .NET 8.0, .NET Standard 2.0

Variables d'environnement

AZURE_SUBSCRIPTION_ID=<your-subscription-id>
# Pour l'authentification par principal de service (optionnel)
AZURE_TENANT_ID=<tenant-id>
AZURE_CLIENT_ID=<client-id>
AZURE_CLIENT_SECRET=<client-secret>

Authentification

using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Redis;

// Toujours utiliser DefaultAzureCredential
var credential = new DefaultAzureCredential();
var armClient = new ArmClient(credential);

// Obtenir l'abonnement
var subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID");
var subscription = armClient.GetSubscriptionResource(
    new ResourceIdentifier($"/subscriptions/{subscriptionId}"));

Hiérarchie des ressources

ArmClient
└── SubscriptionResource
    └── ResourceGroupResource
        └── RedisResource
            ├── RedisFirewallRuleResource
            ├── RedisPatchScheduleResource
            ├── RedisLinkedServerWithPropertyResource
            ├── RedisPrivateEndpointConnectionResource
            └── RedisCacheAccessPolicyResource

Flux de travail principaux

1. Créer un cache Redis

using Azure.ResourceManager.Redis;
using Azure.ResourceManager.Redis.Models;

// Obtenir le groupe de ressources
var resourceGroup = await subscription
    .GetResourceGroupAsync("my-resource-group");

// Définir la configuration du cache
var cacheData = new RedisCreateOrUpdateContent(
    location: AzureLocation.EastUS,
    sku: new RedisSku(RedisSkuName.Standard, RedisSkuFamily.BasicOrStandard, 1))
{
    EnableNonSslPort = false,
    MinimumTlsVersion = RedisTlsVersion.Tls1_2,
    RedisConfiguration = new RedisCommonConfiguration
    {
        MaxMemoryPolicy = "volatile-lru"
    },
    Tags =
    {
        ["environment"] = "production"
    }
};

// Créer le cache (opération longue)
var cacheCollection = resourceGroup.Value.GetAllRedis();
var operation = await cacheCollection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "my-redis-cache",
    cacheData);

RedisResource cache = operation.Value;
Console.WriteLine($"Cache created: {cache.Data.HostName}");

2. Obtenir un cache Redis

// Obtenir un cache existant
var cache = await resourceGroup.Value
    .GetRedisAsync("my-redis-cache");

Console.WriteLine($"Host: {cache.Value.Data.HostName}");
Console.WriteLine($"Port: {cache.Value.Data.Port}");
Console.WriteLine($"SSL Port: {cache.Value.Data.SslPort}");
Console.WriteLine($"Provisioning State: {cache.Value.Data.ProvisioningState}");

3. Mettre à jour un cache Redis

var patchData = new RedisPatch
{
    Sku = new RedisSku(RedisSkuName.Standard, RedisSkuFamily.BasicOrStandard, 2),
    RedisConfiguration = new RedisCommonConfiguration
    {
        MaxMemoryPolicy = "allkeys-lru"
    }
};

var updateOperation = await cache.Value.UpdateAsync(
    WaitUntil.Completed,
    patchData);

4. Supprimer un cache Redis

await cache.Value.DeleteAsync(WaitUntil.Completed);

5. Obtenir les clés d'accès

var keys = await cache.Value.GetKeysAsync();
Console.WriteLine($"Primary Key: {keys.Value.PrimaryKey}");
Console.WriteLine($"Secondary Key: {keys.Value.SecondaryKey}");

6. Régénérer les clés d'accès

var regenerateContent = new RedisRegenerateKeyContent(RedisRegenerateKeyType.Primary);
var newKeys = await cache.Value.RegenerateKeyAsync(regenerateContent);
Console.WriteLine($"New Primary Key: {newKeys.Value.PrimaryKey}");

7. Gérer les règles de pare-feu

// Créer une règle de pare-feu
var firewallData = new RedisFirewallRuleData(
    startIP: System.Net.IPAddress.Parse("10.0.0.1"),
    endIP: System.Net.IPAddress.Parse("10.0.0.255"));

var firewallCollection = cache.Value.GetRedisFirewallRules();
var firewallOperation = await firewallCollection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "allow-internal-network",
    firewallData);

// Lister toutes les règles de pare-feu
await foreach (var rule in firewallCollection.GetAllAsync())
{
    Console.WriteLine($"Rule: {rule.Data.Name} ({rule.Data.StartIP} - {rule.Data.EndIP})");
}

// Supprimer une règle de pare-feu
var ruleToDelete = await firewallCollection.GetAsync("allow-internal-network");
await ruleToDelete.Value.DeleteAsync(WaitUntil.Completed);

8. Configurer un calendrier de correctif (SKU Premium)

// Les calendriers de correctif nécessitent une SKU Premium
var scheduleData = new RedisPatchScheduleData(
    new[]
    {
        new RedisPatchScheduleSetting(RedisDayOfWeek.Saturday, 2) // 2 h du matin samedi
        {
            MaintenanceWindow = TimeSpan.FromHours(5)
        },
        new RedisPatchScheduleSetting(RedisDayOfWeek.Sunday, 2) // 2 h du matin dimanche
        {
            MaintenanceWindow = TimeSpan.FromHours(5)
        }
    });

var scheduleCollection = cache.Value.GetRedisPatchSchedules();
await scheduleCollection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    RedisPatchScheduleDefaultName.Default,
    scheduleData);

9. Importer/Exporter des données (SKU Premium)

// Importer les données depuis le stockage blob
var importContent = new ImportRdbContent(
    files: new[] { "https://mystorageaccount.blob.core.windows.net/container/dump.rdb" },
    format: "RDB");

await cache.Value.ImportDataAsync(WaitUntil.Completed, importContent);

// Exporter les données vers le stockage blob
var exportContent = new ExportRdbContent(
    prefix: "backup",
    container: "https://mystorageaccount.blob.core.windows.net/container?sastoken",
    format: "RDB");

await cache.Value.ExportDataAsync(WaitUntil.Completed, exportContent);

10. Forcer un redémarrage

var rebootContent = new RedisRebootContent
{
    RebootType = RedisRebootType.AllNodes,
    ShardId = 0 // Pour les caches en cluster
};

await cache.Value.ForceRebootAsync(rebootContent);

Référence SKU

Tailles de capacité (Famille C - Basic/Standard) :

• C0 : 250 Mo
• C1 : 1 Go
• C2 : 2,5 Go
• C3 : 6 Go
• C4 : 13 Go
• C5 : 26 Go
• C6 : 53 Go

Tailles de capacité (Famille P - Premium) :

• P1 : 6 Go par fragment
• P2 : 13 Go par fragment
• P3 : 26 Go par fragment
• P4 : 53 Go par fragment
• P5 : 120 Go par fragment

Référence des types de clé

Bonnes pratiques

1. Utiliser WaitUntil.Completed pour les opérations qui doivent se terminer avant de continuer
2. Utiliser WaitUntil.Started pour sonder manuellement ou exécuter les opérations en parallèle
3. Toujours utiliser DefaultAzureCredential — ne jamais coder en dur les clés
4. Gérer RequestFailedException pour les erreurs de l'API ARM
5. Utiliser CreateOrUpdateAsync pour les opérations idempotentes
6. Naviguer dans la hiérarchie via les méthodes Get* (par exemple, cache.GetRedisFirewallRules())
7. Utiliser la SKU Premium pour les charges de travail de production nécessitant la géo-réplication, le clustering ou la persistance
8. Activer TLS 1.2 minimum — définir MinimumTlsVersion = RedisTlsVersion.Tls1_2
9. Désactiver le port non-SSL — définir EnableNonSslPort = false pour la sécurité
10. Pivoter les clés régulièrement — utiliser RegenerateKeyAsync et mettre à jour les chaînes de connexion

Gestion des erreurs

using Azure;

try
{
    var operation = await cacheCollection.CreateOrUpdateAsync(
        WaitUntil.Completed, cacheName, cacheData);
}
catch (RequestFailedException ex) when (ex.Status == 409)
{
    Console.WriteLine("Cache already exists");
}
catch (RequestFailedException ex) when (ex.Status == 400)
{
    Console.WriteLine($"Invalid configuration: {ex.Message}");
}
catch (RequestFailedException ex)
{
    Console.WriteLine($"ARM Error: {ex.Status} - {ex.ErrorCode}: {ex.Message}");
}

Pièges courants

1. Les rétrogradations de SKU ne sont pas autorisées — Vous ne pouvez pas rétrograder de Premium à Standard/Basic
2. Le clustering nécessite Premium — La configuration des fragments n'est disponible que sur la SKU Premium
3. La géo-réplication nécessite Premium — Les serveurs liés ne fonctionnent qu'avec les caches Premium
4. L'injection VNet nécessite Premium — Le support des réseaux virtuels est réservé à Premium
5. Les calendriers de correctif nécessitent Premium — Les fenêtres de maintenance ne sont configurables que sur Premium
6. Le nom du cache est mondialement unique — Les noms des caches Redis doivent être uniques dans tous les abonnements Azure
7. Temps de provisionnement longs — La création du cache peut prendre 15 à 20 minutes ; utiliser WaitUntil.Started pour les modèles asynchrones

Connexion avec StackExchange.Redis (Plan de données)

Après avoir créé le cache avec ce SDK de gestion, utiliser StackExchange.Redis pour les opérations de données :

using StackExchange.Redis;

// Obtenir les infos de connexion du SDK de gestion
var cache = await resourceGroup.Value.GetRedisAsync("my-redis-cache");
var keys = await cache.Value.GetKeysAsync();

// Se connecter avec StackExchange.Redis
var connectionString = $"{cache.Value.Data.HostName}:{cache.Value.Data.SslPort},password={keys.Value.PrimaryKey},ssl=True,abortConnect=False";
var connection = ConnectionMultiplexer.Connect(connectionString);
var db = connection.GetDatabase();

// Opérations de données
await db.StringSetAsync("key", "value");
var value = await db.StringGetAsync("key");

SDKs associés