Durable Functions orchestration patterns in Azure - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ service_behavior

intermediate

What happens when a Durable Function orchestration calls an activity function that fails?

Consider a Durable Function orchestration that calls an activity function which throws an exception. What is the default behavior of the orchestration?

A The orchestration retries the activity function automatically based on the retry policy if configured; otherwise, it fails and stops.

B The orchestration ignores the failure and continues executing the next activity functions.

C The orchestration immediately restarts from the beginning without any retries.

D The orchestration pauses indefinitely until manual intervention.

💡 Hint

Think about how Durable Functions handle errors and retries in activity functions.

By default, if an activity function fails, the orchestration fails unless a retry policy is set. With a retry policy, the orchestration retries the activity function automatically before failing.

❓ Architecture

intermediate

Which orchestration pattern is best for running multiple activity functions in parallel and waiting for all to complete?

You want to run several independent activity functions at the same time and proceed only after all have finished. Which Durable Functions orchestration pattern should you use?

A Async HTTP APIs pattern

B Function chaining pattern

C Fan-out/fan-in pattern

D Monitor pattern

💡 Hint

Consider which pattern allows parallel execution and aggregation of results.

The fan-out/fan-in pattern runs multiple activity functions in parallel (fan-out) and waits for all to complete before continuing (fan-in).

❓ Configuration

advanced

What is the correct way to implement a Durable Function that waits for an external event before continuing?

You want your orchestration to pause and wait until it receives a specific external event named 'ApprovalReceived'. Which code snippet correctly implements this behavior?

Azure

public static async Task RunOrchestrator([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    // Wait for external event
    var approval = await context.WaitForExternalEvent<bool>("ApprovalReceived");
    if (approval)
    {
        await context.CallActivityAsync("ProcessApproval", null);
    }
    else
    {
        await context.CallActivityAsync("RejectApproval", null);
    }
}

A await context.WaitForExternalEvent<bool>();

B await context.WaitForExternalEvent("ApprovalReceived");

C await context.WaitForExternalEvent<int>("ApprovalReceived");

D await context.WaitForExternalEvent<bool>("ApprovalReceived");

💡 Hint

Check the method signature and required parameters for waiting on external events.

The method WaitForExternalEvent requires the event name and the expected type. Option D correctly specifies both.

❓ security

advanced

How can you securely pass sensitive data to an activity function in Durable Functions?

You need to send a secret API key to an activity function without exposing it in logs or storage. What is the best practice to handle this?

A Store the secret in Azure Key Vault and retrieve it inside the activity function at runtime.

B Hardcode the secret inside the activity function code.

C Include the secret in the orchestration input JSON to keep it encrypted automatically.

D Pass the secret as a parameter directly from the orchestration function to the activity function.

💡 Hint

Think about secure storage and minimizing exposure of secrets.

Storing secrets in Azure Key Vault and retrieving them at runtime inside the activity function avoids exposing secrets in orchestration inputs or logs.

🧠 Conceptual

expert

What is the main advantage of Durable Functions' 'function chaining' pattern compared to traditional sequential function calls?

Durable Functions support a 'function chaining' pattern where one function calls another in sequence. What key benefit does this pattern provide over normal sequential calls in serverless environments?

A It executes all functions in parallel to reduce total execution time.

B It preserves state and checkpoints progress between function calls, allowing reliable long-running workflows.

C It automatically scales the number of function instances based on CPU usage.

D It encrypts all data passed between functions by default.

💡 Hint

Consider how Durable Functions manage state and reliability in workflows.

The function chaining pattern allows Durable Functions to save state and checkpoint after each function call, enabling reliable long-running workflows that can survive restarts.