azure-resource-manager-durabletask-dotnet

Azure Resource Manager SDK for Durable Task Scheduler in .NET.

Quality

47%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./skills/azure-resource-manager-durabletask-dotnet/SKILL.md

Azure.ResourceManager.DurableTask (.NET)

Name: azure-resource-manager-durabletask-dotnet
Rating: 45.6 (1 reviews)
Author: administrakt0r

Management plane SDK for provisioning and managing Azure Durable Task Scheduler resources via Azure Resource Manager.

⚠️ Management vs Data Plane

This SDK (Azure.ResourceManager.DurableTask): Create schedulers, task hubs, configure retention policies

Data Plane SDK (Microsoft.DurableTask.Client.AzureManaged): Start orchestrations, query instances, send events

Installation

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

Current Versions: Stable v1.1.0 (2026-03-12), Stable v1.0.0 (2025-11-03), Preview v1.0.0-beta.1 (2025-04-24) API Version: 2026-02-01

Environment Variables

AZURE_SUBSCRIPTION_ID=<your-subscription-id>
AZURE_RESOURCE_GROUP=<your-resource-group>
# For service principal auth (optional)
AZURE_TENANT_ID=<tenant-id>
AZURE_CLIENT_ID=<client-id>
AZURE_CLIENT_SECRET=<client-secret>

Authentication

using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.DurableTask;

// Always use DefaultAzureCredential
var credential = new DefaultAzureCredential();
var armClient = new ArmClient(credential);

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

Resource Hierarchy

ArmClient
└── SubscriptionResource
    └── ResourceGroupResource
        └── DurableTaskSchedulerResource
            ├── DurableTaskHubResource
            ├── DurableTaskRetentionPolicyResource
            └── DurableTaskPrivateEndpointConnectionResource  (v1.1.0+)

Core Workflow

1. Create Durable Task Scheduler

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

// Get resource group
var resourceGroup = await subscription
    .GetResourceGroupAsync("my-resource-group");

// Define scheduler with Dedicated SKU
var schedulerData = new DurableTaskSchedulerData(AzureLocation.EastUS)
{
    Properties = new DurableTaskSchedulerProperties
    {
        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Dedicated)
        {
            Capacity = 1  // Number of instances
        },
        // Optional: IP allowlist for network security
        IPAllowlist = { "10.0.0.0/24", "192.168.1.0/24" }
    }
};

// Create scheduler (long-running operation)
var schedulerCollection = resourceGroup.Value.GetDurableTaskSchedulers();
var operation = await schedulerCollection.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "my-scheduler",
    schedulerData);

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

2. Create Scheduler with Consumption SKU

// Consumption SKU (serverless)
var consumptionSchedulerData = new DurableTaskSchedulerData(AzureLocation.EastUS)
{
    Properties = new DurableTaskSchedulerProperties
    {
        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Consumption)
        // No capacity needed for consumption
    }
};

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

3. Create Task Hub

// Task hubs are created under a scheduler
var taskHubData = new DurableTaskHubData
{
    // Properties are optional for basic task hub
};

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

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

4. List Schedulers

// List all schedulers in subscription
await foreach (var sched in subscription.GetDurableTaskSchedulersAsync())
{
    Console.WriteLine($"Scheduler: {sched.Data.Name}");
    Console.WriteLine($"  Location: {sched.Data.Location}");
    Console.WriteLine($"  SKU: {sched.Data.Properties.Sku?.Name}");
    Console.WriteLine($"  Endpoint: {sched.Data.Properties.Endpoint}");
}

// List schedulers in resource group
var schedulers = resourceGroup.Value.GetDurableTaskSchedulers();
await foreach (var sched in schedulers.GetAllAsync())
{
    Console.WriteLine($"Scheduler: {sched.Data.Name}");
}

5. Get Scheduler by Name

// Get existing scheduler
var existingScheduler = await schedulerCollection.GetAsync("my-scheduler");
Console.WriteLine($"Found: {existingScheduler.Value.Data.Name}");

// Or use extension method
var schedulerResource = armClient.GetDurableTaskSchedulerResource(
    DurableTaskSchedulerResource.CreateResourceIdentifier(
        subscriptionId,
        "my-resource-group",
        "my-scheduler"));
var scheduler = await schedulerResource.GetAsync();

6. Update Scheduler

// Get current scheduler
var scheduler = await schedulerCollection.GetAsync("my-scheduler");

// Update with new configuration
var updateData = new DurableTaskSchedulerData(scheduler.Value.Data.Location)
{
    Properties = new DurableTaskSchedulerProperties
    {
        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Dedicated)
        {
            Capacity = 2  // Scale up
        },
        IPAllowlist = { "10.0.0.0/16" }  // Update IP allowlist
    }
};

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

7. Delete Resources

// Delete task hub first
var taskHub = await scheduler.GetDurableTaskHubs().GetAsync("my-taskhub");
await taskHub.Value.DeleteAsync(WaitUntil.Completed);

// Then delete scheduler
await scheduler.DeleteAsync(WaitUntil.Completed);

8. Manage Retention Policies

// Get retention policy collection
var retentionPolicies = scheduler.GetDurableTaskRetentionPolicies();

// Create or update retention policy
var retentionData = new DurableTaskRetentionPolicyData
{
    Properties = new DurableTaskRetentionPolicyProperties
    {
        // Configure retention settings
    }
};

var retentionOperation = await retentionPolicies.CreateOrUpdateAsync(
    WaitUntil.Completed,
    "default",  // Policy name
    retentionData);

9. Configure Private Endpoint Connections (v1.1.0+)

// Disable public network access for enhanced security
var schedulerData = new DurableTaskSchedulerData(AzureLocation.EastUS)
{
    Properties = new DurableTaskSchedulerProperties
    {
        Sku = new DurableTaskSchedulerSku(DurableTaskSchedulerSkuName.Dedicated)
        {
            Capacity = 1
        },
        PublicNetworkAccess = PublicNetworkAccess.Disabled  // Disable public access
    }
};

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

// List private endpoint connections
var scheduler = operation.Value;
await foreach (var peConnection in scheduler.GetDurableTaskPrivateEndpointConnections().GetAllAsync())
{
    Console.WriteLine($"PE Connection: {peConnection.Data.Name}");
    Console.WriteLine($"  Status: {peConnection.Data.Properties.PrivateLinkServiceConnectionState.Status}");
}

// Approve a private endpoint connection
var peConnectionName = "my-pe-connection";
var peConnectionResource = await scheduler.GetDurableTaskPrivateEndpointConnectionAsync(peConnectionName);
var approveData = new DurableTaskPrivateEndpointConnectionData
{
    Properties = new DurableTaskPrivateEndpointConnectionProperties
    {
        PrivateLinkServiceConnectionState = new DurableTaskPrivateLinkServiceConnectionState
        {
            Status = DurableTaskPrivateEndpointServiceConnectionStatus.Approved,
            Description = "Approved by admin"
        }
    }
};
await peConnectionResource.Value.UpdateAsync(approveData);

Key Types Reference

Type	Purpose
`ArmClient`	Entry point for all ARM operations
`DurableTaskSchedulerResource`	Represents a Durable Task Scheduler
`DurableTaskSchedulerCollection`	Collection for scheduler CRUD
`DurableTaskSchedulerData`	Scheduler creation/update payload
`DurableTaskSchedulerProperties`	Scheduler configuration (SKU, IPAllowlist, PublicNetworkAccess)
`DurableTaskSchedulerSku`	SKU configuration (Name, Capacity, RedundancyState)
`DurableTaskSchedulerSkuName`	SKU options: `Dedicated`, `Consumption`
`DurableTaskHubResource`	Represents a Task Hub
`DurableTaskHubCollection`	Collection for task hub CRUD
`DurableTaskHubData`	Task hub creation payload
`DurableTaskRetentionPolicyResource`	Retention policy management
`DurableTaskRetentionPolicyData`	Retention policy configuration
`DurableTaskPrivateEndpointConnectionResource`	Private endpoint connection (v1.1.0+)
`DurableTaskPrivateEndpointConnectionCollection`	Collection for PE connection management (v1.1.0+)
`DurableTaskPrivateEndpointConnectionData`	PE connection payload (v1.1.0+)
`DurableTaskPrivateEndpointConnectionProperties`	PE connection state and configuration (v1.1.0+)
`DurableTaskPrivateLinkServiceConnectionState`	PE connection approval/rejection state (v1.1.0+)
`PublicNetworkAccess`	Enum: `Enabled`, `Disabled` (v1.1.0+)
`DurableTaskExtensions`	Extension methods for ARM client

SKU Options

SKU	Description	Use Case
`Dedicated`	Fixed capacity with configurable instances	Production workloads, predictable performance
`Consumption`	Serverless, auto-scaling	Development, variable workloads

Extension Methods

The SDK provides extension methods on SubscriptionResource and ResourceGroupResource:

// On SubscriptionResource
subscription.GetDurableTaskSchedulers();           // List all in subscription
subscription.GetDurableTaskSchedulersAsync();      // Async enumerable

// On ResourceGroupResource  
resourceGroup.GetDurableTaskSchedulers();          // Get collection
resourceGroup.GetDurableTaskSchedulerAsync(name);  // Get by name

// On ArmClient
armClient.GetDurableTaskSchedulerResource(id);     // Get by resource ID
armClient.GetDurableTaskHubResource(id);           // Get task hub by ID

Best Practices

Use WaitUntil.Completed for operations that must finish before proceeding
Use WaitUntil.Started when you want to poll manually or run operations in parallel
Always use DefaultAzureCredential — never hardcode keys
Handle RequestFailedException for ARM API errors
Use CreateOrUpdateAsync for idempotent operations
Delete task hubs before schedulers — schedulers with task hubs cannot be deleted
Use IP allowlists for network security in production
Use private endpoints for production workloads requiring network isolation (v1.1.0+)
Disable public network access when using private endpoints for maximum security

Error Handling

using Azure;

try
{
    var operation = await schedulerCollection.CreateOrUpdateAsync(
        WaitUntil.Completed, schedulerName, schedulerData);
}
catch (RequestFailedException ex) when (ex.Status == 409)
{
    Console.WriteLine("Scheduler already exists");
}
catch (RequestFailedException ex) when (ex.Status == 404)
{
    Console.WriteLine("Resource group not found");
}
catch (RequestFailedException ex)
{
    Console.WriteLine($"ARM Error: {ex.Status} - {ex.ErrorCode}: {ex.Message}");
}

Complete Example

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

// Setup
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);

// Create scheduler
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($"Scheduler endpoint: {scheduler.Data.Properties.Endpoint}");

// Create 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}");

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

Related SDKs

SDK	Purpose	Install
`Azure.ResourceManager.DurableTask`	Management plane (this SDK)	`dotnet add package Azure.ResourceManager.DurableTask`
`Microsoft.DurableTask.Client.AzureManaged`	Data plane (orchestrations, activities)	`dotnet add package Microsoft.DurableTask.Client.AzureManaged`
`Microsoft.DurableTask.Worker.AzureManaged`	Worker for running orchestrations	`dotnet add package Microsoft.DurableTask.Worker.AzureManaged`
`Azure.Identity`	Authentication	`dotnet add package Azure.Identity`
`Azure.ResourceManager`	Base ARM SDK	`dotnet add package Azure.ResourceManager`

Source Reference

When to Use

This skill is applicable to execute the workflow or actions described in the overview.

Repository: administrakt0r/AI-Agents-Safe-Coding-Skills
Path: skills/azure-resource-manager-durabletask-dotnet/SKILL.md
Commit: 57c135b

Last updated: 18 hours ago
First committed: 28 days ago

Also appears in

administrakt0r/AI-Agents-Safe-Coding-Skills

In sync

since Aug 19, 2026

administrakt0r/AI-Agents-Safe-Coding-Skills

In sync

since Aug 19, 2026

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.