Durable Task

https://learn.microsoft.com/en-us/azure/durable-task/
Admin
Durable Task is Microsoft's durable execution framework for building fault-tolerant workflows and...
Tokens:488,985
Snippets:3,374
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### Build and start the function app (Java)

Source: https://learn.microsoft.com/en-us/azure/durable-task/scheduler/quickstart-durable-task-scheduler

Build the Java function app with Maven and start it locally. This is the first step for the Java quickstart.

```bash
mvn clean package
mvn azure-functions:run
```

--------------------------------

### Example output of fan out/fan in orchestration

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/quickstart-portable-durable-task-sdks

Shows the expected console output when running the quickstart program. It includes the orchestration start, processing of each work item with delays, aggregation, and the final result with total items, sum, and average.

```text
Using local emulator with no authentication
Starting fan out/fan in orchestration with 10 items
Started orchestration with ID: abc123-def456-ghi789
Waiting for orchestration to complete...
Processing work item 1 (delay 823ms)
Processing work item 2 (delay 1205ms)
Processing work item 3 (delay 512ms)
Processing work item 4 (delay 1890ms)
Processing work item 5 (delay 645ms)
Processing work item 6 (delay 1102ms)
Processing work item 7 (delay 933ms)
Processing work item 8 (delay 1567ms)
Processing work item 9 (delay 701ms)
Processing work item 10 (delay 1344ms)
Aggregating 10 results...
Orchestration completed with status: COMPLETED
Result: {"totalItems":10,"sum":385,"average":38.5,"results":[...]}
```

--------------------------------

### Example output for the FanOutFanIn quickstart

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/quickstart-portable-durable-task-sdks

Shows the expected output from the client, including the orchestration ID, work items, and aggregated results.

```text
Starting Fan-Out Fan-In Pattern - Parallel Processing Client
Using local emulator with no authentication
Starting parallel processing orchestration with 5 work items
Work items: ["Task1","Task2","Task3","LongerTask4","VeryLongTask5"]
Started orchestration with ID: 7f8e9a6b-1c2d-3e4f-5a6b-7c8d9e0f1a2b
Waiting for orchestration to complete...
Orchestration completed with status: Completed
Processing results:
Work item: Task1, Result: 5
Work item: Task2, Result: 5
Work item: Task3, Result: 5
Work item: LongerTask4, Result: 11
Work item: VeryLongTask5, Result: 13
Total items processed: 5
```

--------------------------------

### Install Go Durable Task SDK

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/durable-task-overview

Use go get to install the Go SDK. Requires Go 1.25 or later. The SDK is in beta and connects to Durable Task Scheduler or the local emulator.

```bash
go get github.com/microsoft/durabletask-go@v1.0.0-beta3
```

--------------------------------

### Start orchestration with specific version (JavaScript)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-orchestration-versioning

JavaScript example of an HTTP handler that starts a new orchestration instance with a specific version using df.getClient and startNew.

```javascript
const HttpStart: HttpHandler = async (request: HttpRequest, context: InvocationContext): Promise<HttpResponse> => {
    const client = df.getClient(context);
    const instanceId = await client.startNew("ProcessOrderOrchestrator", {
        input: orderId,
        version: "1.0"
    });

    // ...
};
```

--------------------------------

### Python: Define a sub-orchestration

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-sub-orchestrations

Python example of a sub-orchestration that creates an installation package, sends the URL to the device, and waits for an external event.

```python
from durabletask import task

def device_provisioning_orchestrator(ctx: task.OrchestrationContext, device_id: str):
    # Step 1: Create an installation package in blob storage and return a SAS URL.
    sas_url = yield ctx.call_activity("create_installation_package", input=device_id)

    # Step 2: Notify the device that the installation package is ready.
    yield ctx.call_activity("send_package_url_to_device", input={"id": device_id, "url": sas_url})

    # Step 3: Wait for the device to acknowledge that it has downloaded the new package.
    yield ctx.wait_for_external_event("DownloadCompletedAck")

    # Step 4: ...
```

--------------------------------

### Java: Define a sub-orchestration

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-sub-orchestrations

Java example of a sub-orchestration that creates an installation package, sends the URL to the device, and waits for an external event.

```java
@FunctionName("DeviceProvisioningOrchestration")
public void deviceProvisioningOrchestration(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    // Step 1: Create an installation package in blob storage and return a SAS URL.
    String deviceId = ctx.getInput(String.class);
    String blobUri = ctx.callActivity("CreateInstallPackage", deviceId, String.class).await();

    // Step 2: Notify the device that the installation package is ready.
    String[] args = { deviceId, blobUri };
    ctx.callActivity("SendPackageUrlToDevice", args).await();

    // Step 3: Wait for the device to acknowledge that it has downloaded the new package.
    ctx.waitForExternalEvent("DownloadCompletedAck").await();

    // Step 4: ...
}
```

--------------------------------

### Node.js V3 HTTP starter (HttpStart/index.js)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-sequence

Uses df.getClient to get a DurableOrchestrationClient, starts an orchestration with client.startNew, and returns a check-status response. Requires a durableClient input binding.

```javascript
const df = require("durable-functions");

module.exports = async function (context, req) {
    const client = df.getClient(context);
    const instanceId = await client.startNew(req.params.functionName, undefined, req.body);

    context.log(`Started orchestration with ID = '${instanceId}'.`);

    return client.createCheckStatusResponse(context.bindingData.req, instanceId);
};
```

--------------------------------

### C#: Define a sub-orchestration

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-sub-orchestrations

C# example of a sub-orchestration that creates an installation package, sends the URL to the device, and waits for an external event.

```csharp
using Microsoft.DurableTask;

[DurableTask]
public class DeviceProvisioningOrchestration : TaskOrchestrator<string, object?>
{
    public override async Task<object?> RunAsync(TaskOrchestrationContext context, string deviceId)
    {
        // Step 1: Create an installation package in blob storage and return a SAS URL.
        Uri sasUrl = await context.CallActivityAsync<Uri>("CreateInstallationPackage", deviceId);

        // Step 2: Notify the device that the installation package is ready.
        await context.CallActivityAsync("SendPackageUrlToDevice", (deviceId, sasUrl.ToString()));

        // Step 3: Wait for the device to acknowledge that it has downloaded the new package.
        await context.WaitForExternalEvent<bool>("DownloadCompletedAck");

        // Step 4: ...
        return null;
    }
}
```

--------------------------------

### Get entity example request

Source: https://learn.microsoft.com/en-us/azure/durable-task/durable-functions/durable-functions-http-api

Example request to get the state of a Counter entity named 'steps'.

```http
GET /runtime/webhooks/durabletask/entities/Counter/steps
```

--------------------------------

### Example request to start RestartVMs orchestrator

Source: https://learn.microsoft.com/en-us/azure/durable-task/durable-functions/durable-functions-http-api

Example HTTP request that starts a RestartVMs orchestrator function with a JSON payload containing resourceGroup and subscriptionId. Returns HTTP 202 on success.

```http
POST /runtime/webhooks/durabletask/orchestrators/RestartVMs?code=XXX
Content-Type: application/json
Content-Length: 83

{
    "resourceGroup": "myRG",
    "subscriptionId": "aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e"
}
```

--------------------------------

### Commands to run the Go quickstart

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/quickstart-portable-durable-task-sdks

Commands to run the program after saving main.go. Run 'go mod tidy' to record the SDK's transitive dependencies and checksums, then 'go run .' to execute the program.

```bash
go mod tidy
go run .
```

--------------------------------

### Navigate to Hello Cities sample directory

Source: https://learn.microsoft.com/en-us/azure/durable-task/durable-functions/quickstart-js-vscode

Change to the Hello Cities sample directory for the JavaScript Durable Functions quickstart.

```bash
cd samples/durable-functions/javascript/HelloCities
```

--------------------------------

### Get entity example response

Source: https://learn.microsoft.com/en-us/azure/durable-task/durable-functions/durable-functions-http-api

Example response content for a Counter entity with a currentValue field.

```json
{
    "currentValue": 5
}
```

--------------------------------

### Start sub-orchestration with specific version (Python)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-orchestration-versioning

Python example of an orchestrator function that starts a sub-orchestration with a specific version using context.call_sub_orchestrator.

```python
@myApp.orchestration_trigger(context_name="context")
def run_main_orchestrator(context: df.DurableOrchestrationContext):
    payment_result = yield context.call_sub_orchestrator(
        "ProcessPaymentOrchestrator",
        order_id,
        version="1.0"
    )

    # ...
```

--------------------------------

### Navigate to .NET SDK sample directory

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/quickstart-portable-durable-task-sdks

Changes to the .NET FanOutFanIn sample directory from the Azure-Samples/Durable-Task-Scheduler root.

```bash
cd samples/durable-task-sdks/dotnet/FanOutFanIn
```

--------------------------------

### Start sub-orchestration with specific version (JavaScript)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-orchestration-versioning

JavaScript example of an orchestrator function that starts a sub-orchestration with a specific version using context.df.callSubOrchestrator.

```javascript
const RunMainOrchestrator: OrchestrationHandler = function* (context: OrchestrationContext) {
    const paymentResult = yield context.df.callSubOrchestrator(
        "ProcessPaymentOrchestrator",
        orderId,
        { version: "1.0" }
    );

    // ...
};
```

--------------------------------

### Build and run the .NET client

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/quickstart-portable-durable-task-sdks

From the FanOutFanIn directory, navigate to the Client directory, build, and run the client.

```bash
cd Client
dotnet build
dotnet run
```

--------------------------------

### Start orchestration with specific version (PowerShell)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-orchestration-versioning

PowerShell example that starts a new orchestration instance with a specific version using Start-DurableOrchestration.

```powershell
param($Request, $TriggerMetadata)

$instanceId = Start-DurableOrchestration -FunctionName "ProcessOrderOrchestrator" -Input $orderId -Version "1.0"

# ...
```

--------------------------------

### Build and start the function app

Source: https://learn.microsoft.com/en-us/azure/durable-task/durable-functions/durable-functions-isolated-create-first-csharp

Build the project with dotnet build and start the function app with func start.

```bash
dotnet build
```

```bash
func start
```

--------------------------------

### Start sub-orchestration with specific version (C#)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-orchestration-versioning

C# example of an orchestrator function that starts a sub-orchestration with a specific version using SubOrchestratorOptions and CallSubOrchestratorAsync.

```csharp
[Function("MainOrchestrator")]
public static async Task<string> RunMainOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var subOptions = new SubOrchestratorOptions
    {
        Version = "1.0"
    };

    var result = await context.CallSubOrchestratorAsync<string>(
        "ProcessPaymentOrchestrator", orderId, subOptions);
    // ...
}
```

--------------------------------

### Navigate to Hello Cities sample directory

Source: https://learn.microsoft.com/en-us/azure/durable-task/durable-functions/quickstart-python-vscode

Change to the Hello Cities sample directory for the Python Durable Functions quickstart.

```bash
cd samples/durable-functions/python/hello-cities
```

--------------------------------

### Create virtual environment and install dependencies

Source: https://learn.microsoft.com/en-us/azure/durable-task/durable-functions/quickstart-python-vscode

Create a Python virtual environment, activate it, and install the required dependencies from requirements.txt.

```bash
python -m venv .venv
.venv\Scripts\activate
pip install -r requirements.txt
```

--------------------------------

### Java Durable Task SDK start orchestration

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-instance-management

Java example using DurableTaskClient to schedule a new orchestration instance and optionally wait for it to start.

```java
import com.microsoft.durabletask.DurableTaskClient;

// Schedule a new orchestration instance
String instanceId = client.scheduleNewOrchestrationInstance("HelloWorld", input);
System.out.println("Started orchestration with ID = '" + instanceId + "'.");

// Optionally, wait for the orchestration to start
OrchestrationMetadata metadata = client.waitForInstanceStart(instanceId, Duration.ofSeconds(30), false);
```

--------------------------------

### Navigate to Hello Cities sample directory

Source: https://learn.microsoft.com/en-us/azure/durable-task/durable-functions/durable-functions-isolated-create-first-csharp

Change to the Hello Cities sample directory for the .NET isolated worker.

```bash
cd samples/durable-functions/dotnet/HelloCities/http
```

--------------------------------

### Python Durable Task SDK start orchestration

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-instance-management

Python example using DurableTaskSchedulerClient to schedule a new orchestration instance and optionally wait for it to start.

```python
from durabletask.azuremanaged.client import DurableTaskSchedulerClient

# Schedule a new orchestration instance
instance_id = client.schedule_new_orchestration(hello_world, input=input_data)
print(f"Started orchestration with ID = '{instance_id}'.")

# Optionally, wait for the orchestration to start
state = client.wait_for_orchestration_start(instance_id, timeout=30)
```

--------------------------------

### Python HTTP starter (HttpStart/__init__.py)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-sequence

Uses DurableOrchestrationClient constructor to create a client, starts an orchestration with start_new, and returns a check-status response. Requires a durableClient input binding.

```python
import logging

import azure.functions as func
import azure.durable_functions as df


async def main(req: func.HttpRequest, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)
    instance_id = await client.start_new(req.route_params["functionName"], None, None)

    logging.info(f"Started orchestration with ID = '{instance_id}'.")

    return client.create_check_status_response(req, instance_id)
```

--------------------------------

### C# Durable Task SDK start orchestration

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-instance-management

C# example using DurableTaskClient to schedule a new orchestration instance and optionally wait for it to start.

```csharp
using Microsoft.DurableTask.Client;

// Schedule a new orchestration instance
string instanceId = await client.ScheduleNewOrchestrationInstanceAsync("HelloWorld", input);
Console.WriteLine($"Started orchestration with ID = '{instanceId}'.");

// Optionally, wait for the orchestration to start
OrchestrationMetadata metadata = await client.WaitForInstanceStartAsync(instanceId, timeout: TimeSpan.FromSeconds(30));
```

--------------------------------

### Start orchestration with specific version (Python)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-orchestration-versioning

Python example of an HTTP-triggered function that starts a new orchestration instance with a specific version using client.start_new.

```python
@myApp.route(route="orchestrators/{functionName}")  
@myApp.durable_client_input(client_name="client")  
async def http_start(req: func.HttpRequest, client):
    instance_id = await client.start_new("ProcessOrderOrchestrator", client_input=order_id, version="1.0")

    # ...
```

--------------------------------

### Navigate to Java SDK sample directory

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/quickstart-portable-durable-task-sdks

Changes to the Java fan-out-fan-in sample directory from the Azure-Samples/Durable-Task-Scheduler root.

```bash
cd samples/durable-task-sdks/java/fan-out-fan-in
```

--------------------------------

### Python: provision_new_devices sub-orchestration example

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-sub-orchestrations

Python example of a parent orchestration that calls a sub-orchestration for each device ID in parallel. Uses call_sub_orchestrator and task.when_all.

```python
from durabletask import task

def provision_new_devices(ctx: task.OrchestrationContext, _):
    device_ids = yield ctx.call_activity("get_new_device_ids")

    # Run multiple device provisioning flows in parallel
    provisioning_tasks = []
    for device_id in device_ids:
        provision_task = ctx.call_sub_orchestrator(device_provisioning_orchestrator, input=device_id)
        provisioning_tasks.append(provision_task)

    yield task.when_all(provisioning_tasks)
```

--------------------------------

### Start orchestration with specific version (Java)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-orchestration-versioning

Java example of an HTTP-triggered function that starts a new orchestration instance with a specific version using NewOrchestrationInstanceOptions and scheduleNewOrchestrationInstance.

```java
@FunctionName("HttpStart")
public HttpResponseMessage httpStart(
    @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST},
        authLevel = AuthorizationLevel.ANONYMOUS) 
    HttpRequestMessage<Optional<String>> request,
    @DurableClientInput(name = "durableContext") 
    DurableClientContext durableContext,
    final ExecutionContext context) {

    DurableTaskClient client = durableContext.getClient();
    NewOrchestrationInstanceOptions options =
        new NewOrchestrationInstanceOptions().setVersion("1.0");
    String instanceId = client.scheduleNewOrchestrationInstance(
        "ProcessOrderOrchestrator", orderId, options);
    // ...
}
```

--------------------------------

### Start orchestration with specific version (C#)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-orchestration-versioning

C# example of an HTTP-triggered function that starts a new orchestration instance with a specific version using StartOrchestrationOptions and ScheduleNewOrchestrationInstanceAsync.

```csharp
[Function("HttpStart")]
public static async Task<HttpResponseData> HttpStart(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
    [DurableClient] DurableTaskClient client,
    FunctionContext executionContext)
{
    var options = new StartOrchestrationOptions
    {
        Version = "1.0"
    };

    string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
        "ProcessOrderOrchestrator", orderId, options);
    // ...
}
```

--------------------------------

### Generate GUID with ctx.newGuid() in a TypeScript orchestrator

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-code-constraints

TypeScript example using ctx.newGuid() instead of crypto.randomUUID(). The generated GUID is a Type 5 UUID safe for replay.

```typescript
import { OrchestrationContext, TOrchestrator } from "@microsoft/durabletask-js";

const guidExample: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    // Use ctx.newGuid() instead of crypto.randomUUID()
    const randomGuid = ctx.newGuid();
    return randomGuid;
};
```

--------------------------------

### Start an instance

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-instance-management

Start a new orchestration instance.

```APIDOC
## Start an instance

### Description
Start a new orchestration instance.

### Method
ScheduleNewOrchestration

### Endpoint
`durabletaskscheduler.Client.ScheduleNewOrchestration`

### Parameters
None documented.

### Request Example
None documented.

### Response
#### Success Response
None documented.
```

--------------------------------

### Navigate to AKS scenario sample

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/quickstart-aks-durable-task-scheduler

Change to the AKS scenario sample directory from the repository root.

```bash
cd samples/scenarios/DocumentProcessingOnAKS
```

--------------------------------

### Java: ProvisionNewDevices sub-orchestration example

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-sub-orchestrations

Java example of a parent orchestration that calls a sub-orchestration for each device ID in parallel. Uses callSubOrchestrator and allOf.

```java
import com.microsoft.durabletask.TaskOrchestration;
import com.microsoft.durabletask.TaskOrchestrationContext;

public class ProvisionNewDevices implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        List<?> deviceIDs = ctx.getInput(List.class);

        // Schedule each device provisioning sub-orchestration to run in parallel
        List<Task<Void>> parallelTasks = deviceIDs.stream()
            .map(device -> ctx.callSubOrchestrator("DeviceProvisioningOrchestration", device))
            .collect(Collectors.toList());

        ctx.allOf(parallelTasks).await();
    }
}
```

--------------------------------

### Install Microsoft.Azure.Functions.Worker.Extensions.DurableTask.AzureManaged package

Source: https://learn.microsoft.com/en-us/azure/durable-task/scheduler/quickstart-durable-task-scheduler

Use the dotnet add package command to install the latest version of the Durable Task Scheduler extension. The --prerelease flag is required to get the latest prerelease version.

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

--------------------------------

### HTTP GET request to fetch custom status

Source: https://learn.microsoft.com/en-us/azure/durable-task/durable-functions/durable-functions-diagnostics

External clients can fetch the custom status while the orchestration is running using the HTTP status query API. The example shows a GET request to the durabletask webhook.

```http
GET /runtime/webhooks/durabletask/instances/instance123?code=XYZ
```

--------------------------------

### Run the client

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/quickstart-aks-durable-task-scheduler

Run the client project from the Client directory.

```bash
cd Client
dotnet run
```

--------------------------------

### Query all orchestration instances in JavaScript

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-instance-management

JavaScript example using createAzureManagedClient to get all instances and log each instance ID.

```javascript
import { createAzureManagedClient } from "@microsoft/durabletask-js-azuremanaged";

const client = createAzureManagedClient(connectionString);

// Query all orchestration instances
const instances = client.getAllInstances();

for await (const instance of instances) {
    console.log(instance.instanceId);
}
```

--------------------------------

### Build the solution

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/quickstart-aks-durable-task-scheduler

Build the DurableTaskOnAKS solution.

```bash
dotnet build DurableTaskOnAKS.sln
```

--------------------------------

### Generate GUID with context.NewGuid() in a TaskOrchestrator class (C# isolated)

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-code-constraints

Complete C# isolated worker example showing a TaskOrchestrator that uses context.NewGuid() instead of Guid.NewGuid(). The generated GUID is a Type 5 UUID safe for replay.

```csharp
using Microsoft.DurableTask;

public class GuidExample : TaskOrchestrator<object?, Guid>
{
    public override async Task<Guid> RunAsync(TaskOrchestrationContext context, object? input)
    {
        // Use context.NewGuid() instead of Guid.NewGuid()
        Guid randomGuid = context.NewGuid();
        return randomGuid;
    }
}
```

--------------------------------

### Java: waitForInstanceCompletion

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-instance-management

Java example using the Durable Task client to start an orchestration and wait for its completion with a configurable timeout.

```APIDOC
## Java: waitForInstanceCompletion

### Description
Starts an orchestration and waits for its completion, returning the orchestration output or a check status response if the timeout expires.

### Method
POST

### Endpoint
`/api/orchestrators/{functionName}/wait` (inferred from the HTTP trigger route)

### Parameters
#### Path Parameters
- **functionName** (string) - Required - The name of the orchestrator function to start.

#### Query Parameters
- **timeout** (number) - Required - Timeout in seconds before returning a check status response.

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- Returns the orchestration output as JSON.

#### Response Example
```json
{
  "output": "orchestration output"
}
```

#### Timeout Response (202)
- Returns a check status response if the orchestration does not complete within the timeout.

#### Response Example
```json
{
  "id": "instanceId",
  "statusQueryGetUri": "...",
  "sendEventPostUri": "...",
  "terminatePostUri": "...",
  "rewindPostUri": "...",
  "purgeHistoryDeleteUri": "..."
}
```
```

--------------------------------

### Create Go module and install DTS SDK

Source: https://learn.microsoft.com/en-us/azure/durable-task/sdks/quickstart-portable-durable-task-sdks

Creates a new Go module and installs the durabletask-go SDK version v1.0.0-beta3.

```bash
mkdir durable-task-go-quickstart
cd durable-task-go-quickstart
go mod init example.com/durable-task-go-quickstart
go get github.com/microsoft/durabletask-go@v1.0.0-beta3
```

--------------------------------

### Fan-out-fan-in orchestration in Java

Source: https://learn.microsoft.com/en-us/azure/durable-task/common/durable-task-hubs

Java example of an orchestrator that starts two activities in parallel and waits for both to complete using ctx.allOf.

```java
@FunctionName("Example")
public void exampleOrchestrator(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    Task<Void> t1 = ctx.callActivity("MyActivity", 1);
    Task<Void> t2 = ctx.callActivity("MyActivity", 2);
    ctx.allOf(List.of(t1, t2)).await();
}
```
Tokens:
Raw