Azure Resource Manager Durabletask Dotnet

1---
2name: azure-resource-manager-durabletask-dotnet
3description: |
4  Azure Resource Manager SDK for Durable Task Scheduler in .NET. Use for MANAGEMENT PLANE operations: creating/managing Durable Task Schedulers, Task Hubs, and retention policies via Azure Resource Manager. Triggers: "Durable Task Scheduler", "create scheduler", "task hub", "DurableTaskSchedulerResource", "provision Durable Task", "orchestration scheduler".
5package: Azure.ResourceManager.DurableTask
6---
7 
8# Azure.ResourceManager.DurableTask (.NET)
9 
10Management plane SDK for provisioning and managing Azure Durable Task Scheduler resources via Azure Resource Manager.
11 
12> **⚠️ Management vs Data Plane**
13> - **This SDK (Azure.ResourceManager.DurableTask)**: Create schedulers, task hubs, configure retention policies
14> - **Data Plane SDK (Microsoft.DurableTask.Client.AzureManaged)**: Start orchestrations, query instances, send events
15 
16## Installation
17 
18```bash
19dotnet add package Azure.ResourceManager.DurableTask
20dotnet add package Azure.Identity
21```
22 
23**Current Versions**: Stable v1.0.0 (2025-11-03), Preview v1.0.0-beta.1 (2025-04-24)
24**API Version**: 2025-11-01
25 
26## Environment Variables
27 
28```bash
29AZURE_SUBSCRIPTION_ID=<your-subscription-id>
30AZURE_RESOURCE_GROUP=<your-resource-group>
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.DurableTask;
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        └── DurableTaskSchedulerResource
61            ├── DurableTaskHubResource
62            └── DurableTaskRetentionPolicyResource
63```
64 
65## Core Workflow
66 
67### 1. Create Durable Task Scheduler
68 
69```csharp
70using Azure.ResourceManager.DurableTask;
71using Azure.ResourceManager.DurableTask.Models;
72 
73// Get resource group
74var resourceGroup = await subscription
75    .GetResourceGroupAsync("my-resource-group");
76 
77// Define scheduler with Dedicated SKU
78var schedulerData = new DurableTaskSchedulerData(AzureLocation.EastUS)
79{
80    Properties = new DurableTaskSchedulerProperties
81    {
82        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Dedicated)
83        {
84            Capacity = 1  // Number of instances
85        },
86        // Optional: IP allowlist for network security
87        IPAllowlist = { "10.0.0.0/24", "192.168.1.0/24" }
88    }
89};
90 
91// Create scheduler (long-running operation)
92var schedulerCollection = resourceGroup.Value.GetDurableTaskSchedulers();
93var operation = await schedulerCollection.CreateOrUpdateAsync(
94    WaitUntil.Completed,
95    "my-scheduler",
96    schedulerData);
97 
98DurableTaskSchedulerResource scheduler = operation.Value;
99Console.WriteLine($"Scheduler created: {scheduler.Data.Name}");
100Console.WriteLine($"Endpoint: {scheduler.Data.Properties.Endpoint}");
101```
102 
103### 2. Create Scheduler with Consumption SKU
104 
105```csharp
106// Consumption SKU (serverless)
107var consumptionSchedulerData = new DurableTaskSchedulerData(AzureLocation.EastUS)
108{
109    Properties = new DurableTaskSchedulerProperties
110    {
111        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Consumption)
112        // No capacity needed for consumption
113    }
114};
115 
116var operation = await schedulerCollection.CreateOrUpdateAsync(
117    WaitUntil.Completed,
118    "my-serverless-scheduler",
119    consumptionSchedulerData);
120```
121 
122### 3. Create Task Hub
123 
124```csharp
125// Task hubs are created under a scheduler
126var taskHubData = new DurableTaskHubData
127{
128    // Properties are optional for basic task hub
129};
130 
131var taskHubCollection = scheduler.GetDurableTaskHubs();
132var hubOperation = await taskHubCollection.CreateOrUpdateAsync(
133    WaitUntil.Completed,
134    "my-taskhub",
135    taskHubData);
136 
137DurableTaskHubResource taskHub = hubOperation.Value;
138Console.WriteLine($"Task Hub created: {taskHub.Data.Name}");
139```
140 
141### 4. List Schedulers
142 
143```csharp
144// List all schedulers in subscription
145await foreach (var sched in subscription.GetDurableTaskSchedulersAsync())
146{
147    Console.WriteLine($"Scheduler: {sched.Data.Name}");
148    Console.WriteLine($"  Location: {sched.Data.Location}");
149    Console.WriteLine($"  SKU: {sched.Data.Properties.Sku?.Name}");
150    Console.WriteLine($"  Endpoint: {sched.Data.Properties.Endpoint}");
151}
152 
153// List schedulers in resource group
154var schedulers = resourceGroup.Value.GetDurableTaskSchedulers();
155await foreach (var sched in schedulers.GetAllAsync())
156{
157    Console.WriteLine($"Scheduler: {sched.Data.Name}");
158}
159```
160 
161### 5. Get Scheduler by Name
162 
163```csharp
164// Get existing scheduler
165var existingScheduler = await schedulerCollection.GetAsync("my-scheduler");
166Console.WriteLine($"Found: {existingScheduler.Value.Data.Name}");
167 
168// Or use extension method
169var schedulerResource = armClient.GetDurableTaskSchedulerResource(
170    DurableTaskSchedulerResource.CreateResourceIdentifier(
171        subscriptionId,
172        "my-resource-group",
173        "my-scheduler"));
174var scheduler = await schedulerResource.GetAsync();
175```
176 
177### 6. Update Scheduler
178 
179```csharp
180// Get current scheduler
181var scheduler = await schedulerCollection.GetAsync("my-scheduler");
182 
183// Update with new configuration
184var updateData = new DurableTaskSchedulerData(scheduler.Value.Data.Location)
185{
186    Properties = new DurableTaskSchedulerProperties
187    {
188        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Dedicated)
189        {
190            Capacity = 2  // Scale up
191        },
192        IPAllowlist = { "10.0.0.0/16" }  // Update IP allowlist
193    }
194};
195 
196var updateOperation = await schedulerCollection.CreateOrUpdateAsync(
197    WaitUntil.Completed,
198    "my-scheduler",
199    updateData);
200```
201 
202### 7. Delete Resources
203 
204```csharp
205// Delete task hub first
206var taskHub = await scheduler.GetDurableTaskHubs().GetAsync("my-taskhub");
207await taskHub.Value.DeleteAsync(WaitUntil.Completed);
208 
209// Then delete scheduler
210await scheduler.DeleteAsync(WaitUntil.Completed);
211```
212 
213### 8. Manage Retention Policies
214 
215```csharp
216// Get retention policy collection
217var retentionPolicies = scheduler.GetDurableTaskRetentionPolicies();
218 
219// Create or update retention policy
220var retentionData = new DurableTaskRetentionPolicyData
221{
222    Properties = new DurableTaskRetentionPolicyProperties
223    {
224        // Configure retention settings
225    }
226};
227 
228var retentionOperation = await retentionPolicies.CreateOrUpdateAsync(
229    WaitUntil.Completed,
230    "default",  // Policy name
231    retentionData);
232```
233 
234## Key Types Reference
235 
236| Type | Purpose |
237|------|---------|
238| `ArmClient` | Entry point for all ARM operations |
239| `DurableTaskSchedulerResource` | Represents a Durable Task Scheduler |
240| `DurableTaskSchedulerCollection` | Collection for scheduler CRUD |
241| `DurableTaskSchedulerData` | Scheduler creation/update payload |
242| `DurableTaskSchedulerProperties` | Scheduler configuration (SKU, IPAllowlist) |
243| `DurableTaskSchedulerSku` | SKU configuration (Name, Capacity, RedundancyState) |
244| `DurableTaskSchedulerSkuName` | SKU options: `Dedicated`, `Consumption` |
245| `DurableTaskHubResource` | Represents a Task Hub |
246| `DurableTaskHubCollection` | Collection for task hub CRUD |
247| `DurableTaskHubData` | Task hub creation payload |
248| `DurableTaskRetentionPolicyResource` | Retention policy management |
249| `DurableTaskRetentionPolicyData` | Retention policy configuration |
250| `DurableTaskExtensions` | Extension methods for ARM client |
251 
252## SKU Options
253 
254| SKU | Description | Use Case |
255|-----|-------------|----------|
256| `Dedicated` | Fixed capacity with configurable instances | Production workloads, predictable performance |
257| `Consumption` | Serverless, auto-scaling | Development, variable workloads |
258 
259## Extension Methods
260 
261The SDK provides extension methods on `SubscriptionResource` and `ResourceGroupResource`:
262 
263```csharp
264// On SubscriptionResource
265subscription.GetDurableTaskSchedulers();           // List all in subscription
266subscription.GetDurableTaskSchedulersAsync();      // Async enumerable
267 
268// On ResourceGroupResource  
269resourceGroup.GetDurableTaskSchedulers();          // Get collection
270resourceGroup.GetDurableTaskSchedulerAsync(name);  // Get by name
271 
272// On ArmClient
273armClient.GetDurableTaskSchedulerResource(id);     // Get by resource ID
274armClient.GetDurableTaskHubResource(id);           // Get task hub by ID
275```
276 
277## Best Practices
278 
2791. **Use `WaitUntil.Completed`** for operations that must finish before proceeding
2802. **Use `WaitUntil.Started`** when you want to poll manually or run operations in parallel
2813. **Always use `DefaultAzureCredential`** — never hardcode keys
2824. **Handle `RequestFailedException`** for ARM API errors
2835. **Use `CreateOrUpdateAsync`** for idempotent operations
2846. **Delete task hubs before schedulers** — schedulers with task hubs cannot be deleted
2857. **Use IP allowlists** for network security in production
286 
287## Error Handling
288 
289```csharp
290using Azure;
291 
292try
293{
294    var operation = await schedulerCollection.CreateOrUpdateAsync(
295        WaitUntil.Completed, schedulerName, schedulerData);
296}
297catch (RequestFailedException ex) when (ex.Status == 409)
298{
299    Console.WriteLine("Scheduler already exists");
300}
301catch (RequestFailedException ex) when (ex.Status == 404)
302{
303    Console.WriteLine("Resource group not found");
304}
305catch (RequestFailedException ex)
306{
307    Console.WriteLine($"ARM Error: {ex.Status} - {ex.ErrorCode}: {ex.Message}");
308}
309```
310 
311## Complete Example
312 
313```csharp
314using Azure;
315using Azure.Identity;
316using Azure.ResourceManager;
317using Azure.ResourceManager.DurableTask;
318using Azure.ResourceManager.DurableTask.Models;
319using Azure.ResourceManager.Resources;
320 
321// Setup
322var credential = new DefaultAzureCredential();
323var armClient = new ArmClient(credential);
324 
325var subscriptionId = Environment.GetEnvironmentVariable("AZURE_SUBSCRIPTION_ID")!;
326var resourceGroupName = Environment.GetEnvironmentVariable("AZURE_RESOURCE_GROUP")!;
327 
328var subscription = armClient.GetSubscriptionResource(
329    new ResourceIdentifier($"/subscriptions/{subscriptionId}"));
330var resourceGroup = await subscription.GetResourceGroupAsync(resourceGroupName);
331 
332// Create scheduler
333var schedulerData = new DurableTaskSchedulerData(AzureLocation.EastUS)
334{
335    Properties = new DurableTaskSchedulerProperties
336    {
337        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Dedicated)
338        {
339            Capacity = 1
340        }
341    }
342};
343 
344var schedulerCollection = resourceGroup.Value.GetDurableTaskSchedulers();
345var schedulerOp = await schedulerCollection.CreateOrUpdateAsync(
346    WaitUntil.Completed, "my-scheduler", schedulerData);
347var scheduler = schedulerOp.Value;
348 
349Console.WriteLine($"Scheduler endpoint: {scheduler.Data.Properties.Endpoint}");
350 
351// Create task hub
352var taskHubData = new DurableTaskHubData();
353var taskHubOp = await scheduler.GetDurableTaskHubs().CreateOrUpdateAsync(
354    WaitUntil.Completed, "my-taskhub", taskHubData);
355var taskHub = taskHubOp.Value;
356 
357Console.WriteLine($"Task Hub: {taskHub.Data.Name}");
358 
359// Cleanup
360await taskHub.DeleteAsync(WaitUntil.Completed);
361await scheduler.DeleteAsync(WaitUntil.Completed);
362```
363 
364## Related SDKs
365 
366| SDK | Purpose | Install |
367|-----|---------|---------|
368| `Azure.ResourceManager.DurableTask` | Management plane (this SDK) | `dotnet add package Azure.ResourceManager.DurableTask` |
369| `Microsoft.DurableTask.Client.AzureManaged` | Data plane (orchestrations, activities) | `dotnet add package Microsoft.DurableTask.Client.AzureManaged` |
370| `Microsoft.DurableTask.Worker.AzureManaged` | Worker for running orchestrations | `dotnet add package Microsoft.DurableTask.Worker.AzureManaged` |
371| `Azure.Identity` | Authentication | `dotnet add package Azure.Identity` |
372| `Azure.ResourceManager` | Base ARM SDK | `dotnet add package Azure.ResourceManager` |
373 
374## Source Reference
375 
376- [GitHub: Azure.ResourceManager.DurableTask](https://github.com/Azure/azure-sdk-for-net/tree/main/sdk/durabletask/Azure.ResourceManager.DurableTask)
377- [NuGet: Azure.ResourceManager.DurableTask](https://www.nuget.org/packages/Azure.ResourceManager.DurableTask)
378