Azure.ResourceManager.DurableTask (.NET)

SDK du plan de gestion pour provisionner et gérer les ressources Azure Durable Task Scheduler via Azure Resource Manager.

⚠️ Plan de gestion vs plan de données

• Ce SDK (Azure.ResourceManager.DurableTask) : Créer des planificateurs, des task hubs, configurer les politiques de rétention
• SDK plan de données (Microsoft.DurableTask.Client.AzureManaged) : Démarrer des orchestrations, interroger les instances, envoyer des événements

Installation

dotnet add package Azure.ResourceManager.DurableTask
dotnet add package Azure.Identity

Versions actuelles : Stable v1.0.0 (2025-11-03), Preview v1.0.0-beta.1 (2025-04-24) Version API : 2025-11-01

Variables d'environnement

AZURE_SUBSCRIPTION_ID=<your-subscription-id>
AZURE_RESOURCE_GROUP=<your-resource-group>
# Pour l'authentification par service principal (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.DurableTask;

// Utiliser toujours DefaultAzureCredential
var credential = new DefaultAzureCredential();
var armClient = new ArmClient(credential);

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

Hiérarchie des ressources

ArmClient
└── SubscriptionResource
    └── ResourceGroupResource
        └── DurableTaskSchedulerResource
            ├── DurableTaskHubResource
            └── DurableTaskRetentionPolicyResource

Flux de travail principal

1. Créer un Durable Task Scheduler

using Azure.ResourceManager.DurableTask;
using Azure.ResourceManager.DurableTask.Models;

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

// Définir le planificateur avec une SKU Dedicated
var schedulerData = new DurableTaskSchedulerData(AzureLocation.EastUS)
{
    Properties = new DurableTaskSchedulerProperties
    {
        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Dedicated)
        {
            Capacity = 1  // Nombre d'instances
        },
        // Optionnel : liste d'IP autorisées pour la sécurité réseau
        IPAllowlist = { "10.0.0.0/24", "192.168.1.0/24" }
    }
};

// Créer le planificateur (opération longue)
var schedulerCollection = resourceGroup.Value.GetDurableTaskSchedulers();
var operation = await schedulerCollection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "my-scheduler",
    schedulerData);

DurableTaskSchedulerResource scheduler = operation.Value;
Console.WriteLine($"Scheduler créé : {scheduler.Data.Name}");
Console.WriteLine($"Endpoint : {scheduler.Data.Properties.Endpoint}");

2. Créer un planificateur avec une SKU Consumption

// SKU Consumption (serverless)
var consumptionSchedulerData = new DurableTaskSchedulerData(AzureLocation.EastUS)
{
    Properties = new DurableTaskSchedulerProperties
    {
        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Consumption)
        // Aucune capacité nécessaire pour consumption
    }
};

var operation = await schedulerCollection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "my-serverless-scheduler",
    consumptionSchedulerData);

3. Créer un Task Hub

// Les task hubs sont créés sous un planificateur
var taskHubData = new DurableTaskHubData
{
    // Les propriétés sont optionnelles pour un task hub simple
};

var taskHubCollection = scheduler.GetDurableTaskHubs();
var hubOperation = await taskHubCollection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "my-taskhub",
    taskHubData);

DurableTaskHubResource taskHub = hubOperation.Value;
Console.WriteLine($"Task Hub créé : {taskHub.Data.Name}");

4. Lister les planificateurs

// Lister tous les planificateurs de l'abonnement
await foreach (var sched in subscription.GetDurableTaskSchedulersAsync())
{
    Console.WriteLine($"Planificateur : {sched.Data.Name}");
    Console.WriteLine($"  Localisation : {sched.Data.Location}");
    Console.WriteLine($"  SKU : {sched.Data.Properties.Sku?.Name}");
    Console.WriteLine($"  Endpoint : {sched.Data.Properties.Endpoint}");
}

// Lister les planificateurs dans le groupe de ressources
var schedulers = resourceGroup.Value.GetDurableTaskSchedulers();
await foreach (var sched in schedulers.GetAllAsync())
{
    Console.WriteLine($"Planificateur : {sched.Data.Name}");
}

5. Récupérer un planificateur par nom

// Récupérer un planificateur existant
var existingScheduler = await schedulerCollection.GetAsync("my-scheduler");
Console.WriteLine($"Trouvé : {existingScheduler.Value.Data.Name}");

// Ou utiliser la méthode d'extension
var schedulerResource = armClient.GetDurableTaskSchedulerResource(
    DurableTaskSchedulerResource.CreateResourceIdentifier(
        subscriptionId,
        "my-resource-group",
        "my-scheduler"));
var scheduler = await schedulerResource.GetAsync();

6. Mettre à jour un planificateur

// Récupérer le planificateur actuel
var scheduler = await schedulerCollection.GetAsync("my-scheduler");

// Mettre à jour avec une nouvelle configuration
var updateData = new DurableTaskSchedulerData(scheduler.Value.Data.Location)
{
    Properties = new DurableTaskSchedulerProperties
    {
        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Dedicated)
        {
            Capacity = 2  // Augmenter l'échelle
        },
        IPAllowlist = { "10.0.0.0/16" }  // Mettre à jour la liste d'IP autorisées
    }
};

var updateOperation = await schedulerCollection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "my-scheduler",
    updateData);

7. Supprimer des ressources

// Supprimer d'abord le task hub
var taskHub = await scheduler.GetDurableTaskHubs().GetAsync("my-taskhub");
await taskHub.Value.DeleteAsync(WaitUntil.Completed);

// Puis supprimer le planificateur
await scheduler.DeleteAsync(WaitUntil.Completed);

8. Gérer les politiques de rétention

// Récupérer la collection de politiques de rétention
var retentionPolicies = scheduler.GetDurableTaskRetentionPolicies();

// Créer ou mettre à jour une politique de rétention
var retentionData = new DurableTaskRetentionPolicyData
{
    Properties = new DurableTaskRetentionPolicyProperties
    {
        // Configurer les paramètres de rétention
    }
};

var retentionOperation = await retentionPolicies.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "default",  // Nom de la politique
    retentionData);

Référence des types clés

Options SKU

Méthodes d'extension

Le SDK fournit des méthodes d'extension sur SubscriptionResource et ResourceGroupResource :

// Sur SubscriptionResource
subscription.GetDurableTaskSchedulers();           // Lister tous dans l'abonnement
subscription.GetDurableTaskSchedulersAsync();      // Énumération asynchrone

// Sur ResourceGroupResource  
resourceGroup.GetDurableTaskSchedulers();          // Récupérer la collection
resourceGroup.GetDurableTaskSchedulerAsync(name);  // Récupérer par nom

// Sur ArmClient
armClient.GetDurableTaskSchedulerResource(id);     // Récupérer par ID de ressource
armClient.GetDurableTaskHubResource(id);           // Récupérer le task hub par ID

Bonnes pratiques

1. Utiliser WaitUntil.Completed pour les opérations qui doivent se terminer avant de continuer
2. Utiliser WaitUntil.Started quand on veut interroger manuellement ou exécuter les opérations en parallèle
3. Toujours utiliser DefaultAzureCredential — ne jamais encoder les clés en dur
4. Gérer RequestFailedException pour les erreurs de l'API ARM
5. Utiliser CreateOrUpdateAsync pour les opérations idempotentes
6. Supprimer les task hubs avant les planificateurs — les planificateurs avec task hubs ne peuvent pas être supprimés
7. Utiliser les listes d'IP autorisées pour la sécurité réseau en production

Gestion des erreurs

using Azure;

try
{
    var operation = await schedulerCollection.CreateOrUpdateAsync(
        WaitUntil.Completed, schedulerName, schedulerData);
}
catch (RequestFailedException ex) when (ex.Status == 409)
{
    Console.WriteLine("Le planificateur existe déjà");
}
catch (RequestFailedException ex) when (ex.Status == 404)
{
    Console.WriteLine("Groupe de ressources introuvable");
}
catch (RequestFailedException ex)
{
    Console.WriteLine($"Erreur ARM : {ex.Status} - {ex.ErrorCode}: {ex.Message}");
}

Exemple complet

using Azure;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.DurableTask;
using Azure.ResourceManager.DurableTask.Models;
using Azure.ResourceManager.Resources;

// Configuration
var credential = new DefaultAzureCredential();
var armClient = new ArmClient(credential);

var subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID")!;
var resourceGroupName = Environment.GetEnvironmentVariable("AZURE_RESOURCE_GROUP")!;

var subscription = armClient.GetSubscriptionResource(
    new ResourceIdentifier($"/subscriptions/{subscriptionId}"));
var resourceGroup = await subscription.GetResourceGroupAsync(resourceGroupName);

// Créer le planificateur
var schedulerData = new DurableTaskSchedulerData(AzureLocation.EastUS)
{
    Properties = new DurableTaskSchedulerProperties
    {
        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Dedicated)
        {
            Capacity = 1
        }
    }
};

var schedulerCollection = resourceGroup.Value.GetDurableTaskSchedulers();
var schedulerOp = await schedulerCollection.CreateOrUpdateAsync(
    WaitUntil.Completed, "my-scheduler", schedulerData);
var scheduler = schedulerOp.Value;

Console.WriteLine($"Endpoint du planificateur : {scheduler.Data.Properties.Endpoint}");

// Créer le task hub
var taskHubData = new DurableTaskHubData();
var taskHubOp = await scheduler.GetDurableTaskHubs().CreateOrUpdateAsync(
    WaitUntil.Completed, "my-taskhub", taskHubData);
var taskHub = taskHubOp.Value;

Console.WriteLine($"Task Hub : {taskHub.Data.Name}");

// Nettoyage
await taskHub.DeleteAsync(WaitUntil.Completed);
await scheduler.DeleteAsync(WaitUntil.Completed);

SDK associés

Référence source

• GitHub : Azure.ResourceManager.DurableTask
• NuGet : Azure.ResourceManager.DurableTask