Durable Functions and Orchestration

Standard Azure Functions are stateless — each invocation is independent with no built-in way to coordinate multiple steps, wait for external events, or manage long-running workflows. Durable Functions is an extension that adds stateful orchestration capabilities, enabling you to write complex workflows as code. This lesson covers orchestrator functions, activity functions, patterns, and best practices.

---

What are Durable Functions?

Durable Functions is an extension of Azure Functions that lets you write stateful functions in a serverless environment. The extension manages state, checkpoints, and restarts automatically using an Azure Storage backend.

The framework introduces three new function types:

Function Type	Purpose
Orchestrator	Defines the workflow — calls activities, waits for events, manages control flow
Activity	A single unit of work within the workflow — the actual business logic
Entity	A stateful object that can be read and updated (actor model)
Client	Starts orchestrations or sends events to running instances

---

How It Works: Replay Architecture

Durable Functions uses an event-sourcing and replay architecture:

1. The orchestrator function starts and executes until it hits an await (e.g., calling an activity)
2. The framework checkpoints the orchestrator state to Azure Storage
3. The orchestrator function is unloaded from memory
4. When the awaited activity completes, the orchestrator is replayed from the beginning
5. Previously completed activities return their cached results immediately
6. Execution continues from where it left off

Execution 1:  [Start] → [Call Activity A] → checkpoint → unload
Execution 2:  [Start] → [Activity A result from cache] → [Call Activity B] → checkpoint → unload
Execution 3:  [Start] → [A cached] → [B cached] → [Call Activity C] → checkpoint → unload
Execution 4:  [Start] → [A cached] → [B cached] → [C cached] → [Return result] → complete

This replay mechanism allows orchestrations to run for minutes, hours, days, or even months without holding a function instance in memory the entire time.

---

Creating a Durable Function

Orchestrator Function

The orchestrator defines the workflow:

const df = require('durable-functions');

df.app.orchestration('processOrderOrchestrator', function* (context) {
    const order = context.df.getInput();

    // Step 1: Validate the order
    const isValid = yield context.df.callActivity('validateOrder', order);
    if (!isValid) {
        return { status: 'rejected', reason: 'Validation failed' };
    }

    // Step 2: Process payment
    const payment = yield context.df.callActivity('processPayment', order);

    // Step 3: Ship the order
    const shipment = yield context.df.callActivity('shipOrder', {
        orderId: order.id,
        paymentId: payment.id
    });

    // Step 4: Send confirmation
    yield context.df.callActivity('sendConfirmation', {
        orderId: order.id,
        trackingNumber: shipment.trackingNumber
    });

    return { status: 'completed', trackingNumber: shipment.trackingNumber };
});

Activity Functions

Each activity performs a single unit of work:

df.app.activity('validateOrder', {
    handler: async (order) => {
        // Validate inventory, customer, pricing
        return order.items.length > 0 && order.total > 0;
    }
});

df.app.activity('processPayment', {
    handler: async (order) => {
        // Call payment gateway
        return { id: 'pay_' + Date.now(), amount: order.total };
    }
});