Quickstart: Create a PowerShell Durable Functions app

Use Durable Functions, a feature of Azure Functions, to write stateful serverless workflows in PowerShell. In this quickstart, you clone and run a sample app that demonstrates two common orchestration patterns:

• Function chaining: Calls activities sequentially (Tokyo → Seattle → London).
• Fan-out/fan-in: Calls activities in parallel across five cities, then aggregates the results.

By the end, you'll have both orchestrations running locally with the Durable Task Scheduler emulator and be able to view their status in the dashboard.

Prerequisites

• PowerShell 7.4+ installed.
• Azure Functions Core Tools v4 or later.
• Docker for running the emulator and Azurite.
• Clone the Durable Task Scheduler GitHub repository to use the quickstart sample.

Set up the Durable Task Scheduler emulator

The Durable Task Scheduler emulator provides a local development environment so you can test orchestrations without an Azure subscription. The PowerShell Functions host also requires Azurite for local storage.

Start both containers:

docker run -d --name dtsemulator -p 8080:8080 -p 8082:8082 \
  mcr.microsoft.com/dts/dts-emulator:latest

docker run -d --name azurite -p 10000:10000 -p 10001:10001 -p 10002:10002 \
  mcr.microsoft.com/azure-storage/azurite

Run the quickstart sample

1. Navigate to the Hello Cities sample directory:

   cd samples/durable-functions/powershell/HelloCities
   

2. Verify that the local.settings.json file contains the following configuration:

   {
     "IsEncrypted": false,
     "Values": {
       "AzureWebJobsStorage": "UseDevelopmentStorage=true",
       "FUNCTIONS_WORKER_RUNTIME": "powershell",
       "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
     }
   }
   

3. Start the function app:

   func start
   

4. In a separate terminal, trigger the function chaining orchestration:

   $response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartChaining
   $response
   

   The response contains status URLs for the orchestration instance. Copy the statusQueryGetUri value and run it to check the result:

   Invoke-RestMethod -Uri $response.statusQueryGetUri
   

5. Trigger the fan-out/fan-in orchestration:

   $response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartFanOutFanIn
   Invoke-RestMethod -Uri $response.statusQueryGetUri
   

Expected output

The POST request returns a JSON response with status URLs. For example:

{
  "id": "<instanceId>",
  "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/<instanceId>?code=...",
  "sendEventPostUri": "...",
  "terminatePostUri": "...",
  "purgeHistoryDeleteUri": "..."
}

When you query statusQueryGetUri and the orchestration's runtimeStatus is Completed, you can find the greeting results in the output field. The chaining orchestration returns:

{
  "name": "ChainingOrchestration",
  "runtimeStatus": "Completed",
  "output": ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
}

The fan-out/fan-in orchestration returns:

{
  "name": "FanOutFanInOrchestration",
  "runtimeStatus": "Completed",
  "output": ["Hello Tokyo!", "Hello Seattle!", "Hello London!", "Hello Paris!", "Hello Berlin!"]
}

Open the Durable Task Scheduler dashboard at http://localhost:8082 to view the orchestration status and execution history.

Understand the code

The sample project uses the PowerShell function model where each function lives in its own subdirectory with a function.json binding file and a run.ps1 script.

Activity function

The SayHello activity (SayHello/run.ps1) takes a city name and returns a greeting:

param($city)

Write-Host "Saying hello to $city."
"Hello $city!"

Orchestrator functions

The chaining orchestrator (ChainingOrchestration/run.ps1) calls SayHello sequentially for three cities:

param($Context)

$output = @()
$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'Tokyo'
$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'Seattle'
$output += Invoke-DurableActivity -FunctionName 'SayHello' -Input 'London'

$output

The fan-out/fan-in orchestrator (FanOutFanInOrchestration/run.ps1) schedules activities in parallel:

param($Context)

$cities = @('Tokyo', 'Seattle', 'London', 'Paris', 'Berlin')

# Fan-out: schedule all activities in parallel
$parallelTasks = @()
foreach ($city in $cities) {
    $parallelTasks += Invoke-DurableActivity -FunctionName 'SayHello' -Input $city -NoWait
}

# Fan-in: wait for all to complete
$output = Wait-ActivityFunction -Task $parallelTasks

$output

Client functions

HTTP-triggered client functions start each orchestration. For example, StartChaining/run.ps1:

param($Request, $TriggerMetadata)

$instanceId = Start-DurableOrchestration -FunctionName 'ChainingOrchestration'
Write-Host "Started chaining orchestration with ID = '$instanceId'."

$response = New-DurableOrchestrationCheckStatusResponse -Request $Request -InstanceId $instanceId
Push-OutputBinding -Name Response -Value $response

Configuration

The sample uses the Durable Task Scheduler emulator as its storage backend. This is configured in host.json:

{
  "version": "2.0",
  "extensions": {
    "durableTask": {
      "hubName": "default",
      "storageProvider": {
        "type": "azureManaged",
        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
      }
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  },
  "managedDependency": {
    "enabled": true
  }
}

The managedDependency setting automatically installs the required PowerShell modules defined in requirements.psd1, including the Durable Functions SDK.

Clean up resources

Stop the emulator containers when you're done:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Next steps

• Learn about common Durable Functions app patterns.
• Review the standalone PowerShell SDK guide.
• Learn about Durable Functions storage providers.