Jaliya's Blog: Migrating Azure Durable Function App to Use Durable Task Scheduler: Running Locally

Durable Task Scheduler (DTS) is the latest addition to Azure Durable Functions. The public preview is announced a couple of weeks ago, and you can find it here: Announcing the public preview launch of Azure Functions durable task scheduler. Also if you are using Azure Durable Functions with Netherite, Netherite will no longer receive official support after 31 March 2028. The replacement is DTS, so it's time to get into the game.

In this post I am not going to be writing what DTS is, above post is very detailed. Instead here in this post, let's see how we can migrate an existing durable function app to use DTS as the backend.

I have the following .NET 9.0 Isolated simple durable function app. Here I also have a simple Durable Entity as I want to make sure DTS supports Durable Entities as well.

using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.DurableTask;
using Microsoft.DurableTask.Client;
using Microsoft.DurableTask.Entities;
 
namespace FunctionsPlayground;
 
public static class Function
{
    [Function(nameof(HttpStart))]
    public static async Task<HttpResponseData> HttpStart(
        [HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestData req,
        [DurableClient] DurableTaskClient client,
        FunctionContext executionContext)
    {
        string instanceId = 
            await client.ScheduleNewOrchestrationInstanceAsync(nameof(RunOrchestrator));
 
        return await client.CreateCheckStatusResponseAsync(req, instanceId);
    }
 
    [Function(nameof(RunOrchestrator))]
    public static async Task<List<string>> RunOrchestrator(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        EntityInstanceId entityId = new(nameof(HelloHistoryEntity), "helloHistory");
 
        await context.Entities.CallEntityAsync<string>(entityId, 
            nameof(HelloHistoryEntity.Reset));
 
        string result = await context.CallActivityAsync<string>(nameof(SayHello), "Tokyo");
        await context.Entities.CallEntityAsync<string>(entityId, 
            nameof(HelloHistoryEntity.Add), 
            result);
 
        result = await context.CallActivityAsync<string>(nameof(SayHello), "Seattle");
        await context.Entities.CallEntityAsync<string>(entityId, 
            nameof(HelloHistoryEntity.Add), 
            result);
 
        result = await context.CallActivityAsync<string>(nameof(SayHello), "London");
        await context.Entities.CallEntityAsync<string>(entityId, 
            nameof(HelloHistoryEntity.Add), 
            result);
 
        List<string> outputs = await context.Entities.CallEntityAsync<List<string>>(entityId, 
            nameof(HelloHistoryEntity.Get));
        return outputs;
    }
 
    [Function(nameof(SayHello))]
    public static string SayHello([ActivityTrigger] string name, FunctionContext executionContext)
    {
        return $"Hello {name}!";
    }
}
 
public class HelloHistoryEntity : TaskEntity<List<string>>
{
    public void Add(string message) => State.Add(message);
 
    public void Reset() => State = [];
 
    public List<string> Get() => State;
 
    [Function(nameof(HelloHistoryEntity))]
    public Task RunEntityAsync([EntityTrigger] TaskEntityDispatcher dispatcher)
    {
        return dispatcher.DispatchAsync(this);
    }
}

Now this is running fine and I want to change the backend to use DTS.

First step is setting up DTS emulator locally. For that, I am running the following docker commands. Note: Docker is a prerequisite.

docker pull mcr.microsoft.com/dts/dts-emulator:v0.0.5
docker run -d -p 8080:8080 -p 8082:8082 mcr.microsoft.com/dts/dts-emulator:v0.0.5

DTS Emulator Running Locally

Here:

8080: gRPC endpoint that allows an app to connect to the scheduler
8082: Endpoint for durable task scheduler dashboard

I can navigate to http://localhost:8082/ in the browser and ensure it's all good.

DTS Dashboard

Next step is updating the project.

First I am adding the following package to the project.

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.DurableTask.AzureManaged --prerelease

Then updating the host.json configuring the durableTask extension.

{
  "version": "2.0",
  "extensions": {
    "durableTask": {
      "hubName": "%TASKHUB_NAME%",
      "storageProvider": {
        "type": "azureManaged",
        "connectionStringName": "DTS_CONNECTION_STRING"
      }
    }
  }
}

Now finally setting the appsettings for DTS in local.settings.json.

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
    "DTS_CONNECTION_STRING": "Endpoint=http://localhost:8080;Authentication=None",
    "TASKHUB_NAME": "default"
  }
}