Azure Durable Functions

1. What are Azure Durable Functions?

• Durable Functions let you build workflows such as function chaining, fan-out/fan-in parallelism, async HTTP APIs, human interaction, and more.

• They maintain state automatically using Azure Storage checkpoints (blobs, queues, tables).

• Use cases include order processing pipelines, batch jobs, approval workflows, IoT data orchestration, and more.

2. Core Concepts and Components

3. Supported Languages & Tools

• Officially supported in: C# (.NET Isolated and in-process), JavaScript/TypeScript, Python, Java.

• Development tooling includes Visual Studio, Visual Studio Code (with Azure Functions extension), Azure Functions Core Tools CLI.

• Azure Portal can show function state and logs but not for authoring complex orchestrations.

4. Development: Typical Durable Functions Example (C#)

Basic Orchestrator, Activity, and Client Functions in C#

// Orchestrator
[FunctionName("OrchestratorFunction")]
public static async Task<List<string>> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var outputs = new List<string>();

    outputs.Add(await context.CallActivityAsync<string>("SayHello", "Tokyo"));
    outputs.Add(await context.CallActivityAsync<string>("SayHello", "Seattle"));
    outputs.Add(await context.CallActivityAsync<string>("SayHello", "London"));

    return outputs;
}

// Activity function
[FunctionName("SayHello")]
public static string SayHello([ActivityTrigger] string name, ILogger log)
{
    return $"Hello, {name}!";
}

// Client function (HTTP trigger)
[FunctionName("HttpStart")]
public static async Task<HttpResponseMessage> HttpStart(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
    [DurableClient] IDurableOrchestrationClient starter,
    ILogger log)
{
    string instanceId = await starter.StartNewAsync("OrchestratorFunction", null);

    log.LogInformation($"Started orchestration with ID = '{instanceId}'.");

    return starter.CreateCheckStatusResponse(req, instanceId);
}

• Client function triggers the orchestrator.

• Orchestrator defines the workflow calling activities.

• Activities perform individual tasks.

5. Pricing and Hosting

• Pricing: Billed based on the underlying Azure Functions hosting plan you choose: Consumption, Premium, or Dedicated (App Service Plan).

• Storage costs: Durable Functions use Azure Storage (blobs, queues, tables) for state management and checkpoints; costs depend on storage usage and transactions.

• Consumption Plan
• Serverless, scale-to-zero, pay per execution and duration.
• Has cold starts, suitable for intermittent workloads.

• Premium Plan
• Pre-warmed instances (no cold start), VNet support, longer timeouts.
• Billed per vCPU and memory, plus storage.

• Dedicated Plan
• Runs on App Service VMs, manual scaling, no cold start.
• Suited for predictable workloads.

6. Scaling and Performance

• Scales automatically to meet demand, similar to Azure Functions.

• Orchestrations can run long time (days) thanks to checkpointing and replay.

• Patterns like fan-out/fan-in enable parallel execution to improve throughput.

• Cold start considerations apply based on hosting plan.

7. Security and Identity Management (IAM)

• Integrated with Azure AD for access control at the Function App level.

• Managed Identities can be used within orchestrator and activity functions to securely access Azure resources (e.g., Key Vault, Storage).

• Function app-level authentication and keys protect access.

• Durable Functions' state is stored in Azure Storage secured by built-in encryption and network controls.

8. Deployment and Configuration

• Deployed like standard Azure Functions:
• Via Visual Studio / VS Code publishing
• Azure CLI (az functionapp deployment)
• CI/CD pipelines (Azure DevOps, GitHub Actions)
• Zip deploy, ARM/Bicep templates

• Configuration through app settings, environment variables, and Azure Key Vault integration.

• Durable Functions require underlying Azure Storage configured in the AzureWebJobsStorage app setting.

9. Key Configuration Files and Settings

• host.json: Configuration for durable function behavior (e.g., max concurrency, history size).

• local.settings.json (local dev): Storage connection strings and function app settings.

• DurableTask options: Configure task hub name, storage provider, extended session options.

10. Advanced Patterns and Features

11. Example: Durable Function in Python (Quick snippet)

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

app = df.DFApp()

@app.route(route="orchestrators/hello_orchestrator")
@app.durable_client_input(client_name="client")
async def http_start(req: func.HttpRequest, client):
    instance_id = await client.start_new("hello_orchestrator")
    return client.create_check_status_response(req, instance_id)

@app.orchestration_trigger(context_name="context")
def hello_orchestrator(context: df.DurableOrchestrationContext):
    results = []
    results.append(context.call_activity("hello", "Seattle"))
    results.append(context.call_activity("hello", "Tokyo"))
    results.append(context.call_activity("hello", "London"))
    return results

@app.activity_trigger(input_name="city")
def hello(city: str):
    return f"Hello {city}"

12. Monitoring and Diagnostics

• Use Application Insights for telemetry, tracing, and performance metrics of orchestrations and activities.

• Orchestration status can be tracked via Durable Functions HTTP APIs (instances, history).

• Logs and failures are surfaced in Azure Monitor and Azure Portal.

13. Best Practices

• Keep orchestrator functions deterministic (no random, time-dependent, or side-effects outside function calls).

• Avoid blocking calls or heavy CPU-bound tasks in orchestrators; move to activities.

• Use retries policies on activities for transient errors.

• Minimize orchestration history size with SetCustomStatus or checkpoint strategies.

• Use fan-in/fan-out judiciously to avoid excessive resource consumption.

14. Summary Table for Azure Durable Functions

FAQ

• Orchestrator Functions: Define workflows using regular code constructs with durable state checkpointing and replay.

• Activity Functions: Stateless tasks performing discrete units of work called by orchestrators.

• Client Functions: Trigger orchestrators, often HTTP-triggered to start workflows and query status.

• Durable Entities: Stateful actor-like objects that manage their own state and event processing independently.

• Function Chaining: Invoking functions sequentially, passing outputs from one to the next.

• Fan-out/Fan-in: Running multiple functions in parallel and aggregating their results.

• Async HTTP APIs: Long-running operations exposing status endpoints for clients.

• Human Interaction: Pausing workflows awaiting external events (e.g., approvals).

• Durable Entities: Managing stateful entities akin to actors.

Intermediate Interview Questions and Answers

Advanced and Tricky Questions and Answers

Scenario-Based Questions and Answers