Durable Functions for workflows in Azure - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start a Durable Function orchestration.

Azure

client = df.DurableOrchestrationClient(context)
instance_id = await client.[1]("MyOrchestrator", input_data)

Drag options to blanks, or click blank then click option'

Astart_new

Binvoke

Crun

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'run' instead of 'start_new' which does not start orchestration.

Confusing 'invoke' or 'execute' as valid methods.

The start_new method starts a new orchestration instance in Durable Functions.

2fill in blank

medium

Complete the code to define an activity function in Durable Functions.

Azure

@df.activity_trigger
async def [1](name: str) -> str:
    return f"Hello, {name}!"

Drag options to blanks, or click blank then click option'

Amain

Borchestrator_function

Cgreeting_activity

Drun_activity

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'orchestrator_function' which is reserved for orchestrator functions.

Using generic names like 'main' that do not describe activity.

The function name for an activity can be any valid name, but here greeting_activity clearly indicates an activity function.

3fill in blank

hard

Fix the error in the orchestrator function to call an activity function.

Azure

def orchestrator_function(context: df.DurableOrchestrationContext):
    result = yield context.[1]("greeting_activity", "Azure")
    return result

Drag options to blanks, or click blank then click option'

Astart_activity

Bcall_activity_async

Ccall_sub_orchestrator

Dcall_activity

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'call_activity_async' which is not a valid method.

Using 'start_activity' which does not exist.

The correct method to call an activity function inside an orchestrator is call_activity.

4fill in blank

hard

Fill both blanks to correctly wait for an orchestration to complete and get its status.

Azure

status = await client.[1](instance_id)
result = await client.[2](instance_id)

Drag options to blanks, or click blank then click option'

Await_for_completion

Bget_status

Cget_result

Dstart_new

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'start_new' instead of waiting or getting status.

Confusing 'get_result' with 'get_status'.

The method wait_for_completion waits for orchestration completion, and get_status retrieves the current status.

5fill in blank

hard

Fill all three blanks to correctly define an orchestrator function that calls two activities sequentially.

Azure

def [1](context: df.DurableOrchestrationContext):
    result1 = yield context.[2]("activity_one", None)
    result2 = yield context.[3]("activity_two", result1)
    return result2

Drag options to blanks, or click blank then click option'

Aorchestrator_function

Bcall_activity

Dmain_function

Attempts:

3 left

💡 Hint

Common Mistakes

Using different method names for activity calls.

Naming the orchestrator function incorrectly.

The orchestrator function is named orchestrator_function. It calls activities using call_activity method for both calls.

Practice

1. What is the main purpose of Durable Functions in Azure?

easy

A. To create virtual machines

B. To store large amounts of data

C. To monitor network traffic

D. To manage long-running workflows reliably

Solution

1. Step 1: Understand Durable Functions role

   Durable Functions are designed to handle workflows that take a long time and need to be reliable.

2. Step 2: Compare options

   Options A, B, and D describe other Azure services, not Durable Functions.

3. Final Answer:

   To manage long-running workflows reliably -> Option D

4. Quick Check:

   Durable Functions = Manage workflows reliably [OK]

Hint: Durable Functions = reliable long workflows [OK]

Common Mistakes:

• Confusing Durable Functions with storage services
• Thinking Durable Functions create VMs
• Assuming Durable Functions monitor networks

2. Which of the following is the correct way to define an orchestrator function in Azure Durable Functions?

easy

A. function orchestrator(context) { /* workflow code */ }

B. function activity(context) { /* workflow code */ }

C. async function orchestrator(context) { /* workflow code */ }

D. async function activity(context) { /* workflow code */ }

Solution

1. Step 1: Identify orchestrator function syntax

   Orchestrator functions must be async to support awaiting activity calls.

2. Step 2: Differentiate activity and orchestrator functions

   Options C and D define activity functions, not orchestrators.

3. Final Answer:

   async function orchestrator(context) { /* workflow code */ } -> Option C

4. Quick Check:

   Orchestrator = async function [OK]

Hint: Orchestrators are async functions [OK]

Common Mistakes:

• Using non-async function for orchestrator
• Confusing activity function syntax with orchestrator
• Omitting async keyword

3. Given the following orchestrator code snippet, what will be the output if the activity function returns 'Hello'?

const result = yield context.callActivity('SayHello');
return result + ' World!';

medium

A. "Hello World!"

B. "World! Hello"

C. "Hello"

D. "World!"

Solution

1. Step 1: Understand callActivity result

   The activity function returns 'Hello', which is assigned to result.

2. Step 2: Concatenate strings

   The orchestrator returns result + ' World!', so 'Hello' + ' World!' = 'Hello World!'.

3. Final Answer:

   "Hello World!" -> Option A

4. Quick Check:

   Result + ' World!' = 'Hello World!' [OK]

Hint: callActivity returns value used in concatenation [OK]

Common Mistakes:

• Reversing string order
• Returning only activity result without addition
• Ignoring yield keyword effect

4. Identify the error in this orchestrator function code:

async function orchestrator(context) {
  const result = context.callActivity('Task');
  return result;
}

medium

A. Function should not be async

B. Missing await or yield before callActivity

C. Incorrect function name

D. callActivity should be called outside orchestrator

Solution

1. Step 1: Check callActivity usage

   callActivity returns a promise and must be awaited or yielded inside orchestrator.

2. Step 2: Identify missing await/yield

   The code calls callActivity without await or yield, causing incorrect behavior.

3. Final Answer:

   Missing await or yield before callActivity -> Option B

4. Quick Check:

   callActivity needs await/yield [OK]

Hint: Always await or yield callActivity in orchestrator [OK]

Common Mistakes:

• Forgetting await/yield on callActivity
• Thinking async keyword is wrong here
• Misplacing callActivity outside orchestrator

5. You want to create a workflow that calls two activity functions in sequence and combines their results. Which orchestrator code correctly implements this?

hard

A. const result1 = await context.callActivity('Activity1');
const result2 = await context.callActivity('Activity2');
return result1 + ' & ' + result2;

B. const result1 = context.callActivity('Activity1');
const result2 = context.callActivity('Activity2');
return result1 + ' & ' + result2;

C. const result1 = await context.callActivity('Activity1');
const result2 = context.callActivity('Activity2');
return result1 + ' & ' + result2;

D. const result1 = context.callActivity('Activity1');
const result2 = await context.callActivity('Activity2');
return result1 + ' & ' + result2;

Solution

1. Step 1: Understand sequential calls in orchestrator

   Each callActivity must be awaited to get the actual result before next call.

2. Step 2: Check options for proper await usage

   Only const result1 = await context.callActivity('Activity1'); const result2 = await context.callActivity('Activity2'); return result1 + ' & ' + result2; awaits both calls, ensuring correct sequence and result combination.

3. Final Answer:

   const result1 = await context.callActivity('Activity1');\nconst result2 = await context.callActivity('Activity2');\nreturn result1 + ' & ' + result2; -> Option A

4. Quick Check:

   Await both activities for correct sequence [OK]

Hint: Await each callActivity for sequential results [OK]

Common Mistakes:

• Not awaiting callActivity causing promises instead of results
• Mixing awaited and non-awaited calls
• Returning promises instead of strings