Vzor lidské interakce

Pattern lidské interakce popisuje pracovní postupy, které se pozastaví a čekají na vstup od člověka, než pokračují. Tento vzor je užitečný pro schvalovací pracovní postupy, vícefaktorovou autentizaci a případy, kdy osoba odpoví v časovém limitu.

Na vysoké úrovni vzor funguje takto:

1. Orchestrátor zavolá aktivitu, aby upozornil osobu (poslat SMS kód, e-mail schvalovatele a podobně).
2. Orchestrátor spustí trvalý časovač a současně čeká na externí událost od osoby.
3. Pokud osoba odpoví před spuštěním časovače, orchestrátor zpracuje odpověď.
4. Pokud se časovač spustí jako první, orchestrátor zpracuje vypršení časového limitu (například odmítnutím požadavku).

V tomto článku:

• Přehled scénáře lidské interakce – proč je tento vzor důležitý
• Definování orchestrátoru – implementace závodu timer-vs-event
• Definování aktivit – Odesílání oznámení a zpracování výsledků
• Spustit ukázku lidské interakce – Testování pracovního postupu od začátku do konce

Poznámka:

Sady pivotů Durable Functions a Durable Task SDK ukazují stejný vzor s různými scénáři: Durable Functions používá příklad ověření telefonu pomocí SMS, zatímco sady SDK Durable Task používají příklad schvalovacího workflow.

Tato ukázka ukazuje, jak vytvořit orchestraci Durable Functions, která zahrnuje lidskou interakci. Příklad implementuje systém ověření telefonu založený na SMS. Ověřování telefonního čísla a více-faktorového ověřování (MFA) jsou běžné.

Poznámka:

Kompletní ukázky kódu jsou k dispozici pro C#, JavaScript a Python. PowerShell a Java ukázky momentálně nejsou dostupné.

Poznámka:

Verze 4 programovacího modelu Node.js pro Azure Functions je obecně dostupná. Model v4 je navržený tak, aby poskytoval flexibilnější a intuitivnější prostředí pro vývojáře v JavaScriptu a TypeScriptu. Další informace o rozdílech mezi v3 a v4 najdete v průvodci migrací.

V následujících fragmentech kódu JavaScript (PM4) označuje programovací model v4, nové prostředí.

Předpoklady

C#

• Dokončení článku rychlého startu
• Klonujte nebo si stáhněte projekt samplů z GitHub
  • Izolované vzory modelů
  • Vzorky modelů během procesu

JavaScript

Programovací model V3

• Dokončení článku rychlého startu
• Naklonujte nebo si stáhněte ukázkový projekt z GitHubu

Programovací model V4

• Dokončení článku rychlého startu
• Naklonujte nebo si stáhněte ukázkový projekt z GitHubu

Python

• Dokončení článku rychlého startu
• Naklonujte nebo si stáhněte ukázkový projekt z GitHubu

PowerShell

• Dokončení článku rychlého startu
• Naklonujte nebo si stáhněte ukázkový projekt z GitHubu

Java

• Dokončení článku rychlého startu

Tento článek ukazuje, jak implementovat model lidské interakce pomocí sad SDK Durable Task. Příklad implementuje pracovní postup schválení, ve kterém orchestrace čeká na osobu, aby schválila nebo odmítla žádost, než bude moci pokračovat.

Přehled scénáře lidské interakce

Ověření telefonu pomáhá ověřit, že uživatelé, kteří používají vaši aplikaci, nejsou spammery a že řídí telefonní číslo, které poskytují. Vícefaktorové ověřování je běžný způsob ochrany účtů. Vytvoření vlastního ověření telefonu vyžaduje stavovou interakci s osobou. Uživatel obvykle získá kód (například čtyřmístné číslo) a musí odpovědět v přiměřeném časovém intervalu.

Standardní Azure Functions jsou bezstavové (stejně jako mnoho dalších koncových bodů cloudu), takže tento typ interakce vyžaduje uložení stavu v databázi nebo jiném trvalém úložišti. Také rozdělíte interakci mezi několik funkcí a koordinujete je. Jedna funkce například vygeneruje kód, uloží ho a odešle ho do telefonu uživatele. Jiná funkce obdrží odpověď uživatele a namapuje ji na původní požadavek na ověření kódu. Přidejte časový limit, který pomáhá chránit zabezpečení. Tento pracovní postup se rychle zkompiluje.

Durable Functions snižuje složitost tohoto scénáře. V této ukázce spravuje funkce orchestrátoru stavovou interakci bez externího úložiště dat. Protože jsou funkce orchestrátoru odolné, jsou tyto interaktivní toky vysoce spolehlivé.

Pracovní postupy schválení jsou běžné v obchodních aplikacích, kde musí být žádost před pokračováním zkontrolována člověkem. Požadavky na pracovní postup jsou:

• Čekání na lidskou odpověď po neomezenou dobu nebo na vypršení časového limitu
• Zpracování výsledků schválení i zamítnutí
• Vypršení časového limitu podpory při přijetí žádné odpovědi
• Sledování stavu , aby žadatel mohl zkontrolovat průběh

Sady SDK trvalých úloh zjednodušují tento scénář pomocí následujících:

• Externí události: Orchestrace může pozastavit a čekat na událost vyvolanou externím systémem nebo uživatelem.
• Trvalé časovače: Nastavte časový limit, který se aktivuje, pokud není přijata žádná odpověď.
• Vlastní stav: Sledovat a zpřístupnit aktuální stav pracovního postupu klientům

Konfigurujte integraci Twilio

Tato ukázka zahrnuje použití služby Twilio k odesílání sms zpráv na mobilní telefon. Azure Functions už podporuje Twilio prostřednictvím vazby Twilio a ukázka tuto funkci používá.

První věc, kterou potřebujete, je účet Twilio. Můžete vytvořit jednu zdarma na https://www.twilio.com/try-twilio. Jakmile budete mít účet, přidejte do aplikace funkcí následující tři nastavení aplikace.

Název nastavení aplikace	Popis hodnoty
TwilioAccountSid	Identifikátor SID pro váš účet Twilio
TwilioAuthToken	Ověřovací token pro váš účet Twilio
TwilioPhoneNumber	Telefonní číslo přidružené k vašemu účtu Twilio. Slouží k odesílání zpráv SMS.

Definování orchestrátoru

funkce orchestrátoru E4_SmsPhoneVerification

C#

Izolovaný model pracovního procesu

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;

public static partial class PhoneVerification
{
    [Function("E4_SmsPhoneVerification")]
    public static async Task<bool> Run(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        string phoneNumber = context.GetInput<string>()
            ?? throw new ArgumentNullException(
                nameof(phoneNumber),
                "A phone number input is required.");

        int challengeCode = await context.CallActivityAsync<int>(
            "E4_SendSmsChallenge",
            phoneNumber);

        using var timeoutCts = new CancellationTokenSource();

        // The user has 90 seconds to respond with the code they received.
        DateTime expiration = context.CurrentUtcDateTime.AddSeconds(90);
        Task timeoutTask = context.CreateTimer(expiration, timeoutCts.Token);

        bool authorized = false;
        for (int retryCount = 0; retryCount <= 3; retryCount++)
        {
            Task<int> challengeResponseTask =
                context.WaitForExternalEvent<int>("SmsChallengeResponse");

            Task winner = await Task.WhenAny(challengeResponseTask, timeoutTask);
            if (winner == challengeResponseTask)
            {
                if (challengeResponseTask.Result == challengeCode)
                {
                    authorized = true;
                    break;
                }
            }
            else
            {
                break;
            }
        }

        if (!timeoutTask.IsCompleted)
        {
            // All pending timers must complete or be canceled before the function exits.
            timeoutCts.Cancel();
        }

        return authorized;
    }
}

Poznámka:

Tento orchestrátor je deterministický, protože CurrentUtcDateTime vrací stejnou hodnotu ve stejném bodě při každém opakování. Toto chování zajišťuje, že winner je stejné pro každé opakované volání Task.WhenAny.

Model v probíhajícím procesu

[FunctionName("E4_SmsPhoneVerification")]
public static async Task<bool> Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string phoneNumber = context.GetInput<string>();
    if (string.IsNullOrEmpty(phoneNumber))
    {
        throw new ArgumentNullException(
            nameof(phoneNumber),
            "A phone number input is required.");
    }

    int challengeCode = await context.CallActivityAsync<int>(
        "E4_SendSmsChallenge",
        phoneNumber);

    using (var timeoutCts = new CancellationTokenSource())
    {
        // The user has 90 seconds to respond with the code they received in the SMS message.
        DateTime expiration = context.CurrentUtcDateTime.AddSeconds(90);
        Task timeoutTask = context.CreateTimer(expiration, timeoutCts.Token);

        bool authorized = false;
        for (int retryCount = 0; retryCount <= 3; retryCount++)
        {
            Task<int> challengeResponseTask =
                context.WaitForExternalEvent<int>("SmsChallengeResponse");

            Task winner = await Task.WhenAny(challengeResponseTask, timeoutTask);
            if (winner == challengeResponseTask)
            {
                // We got back a response! Compare it to the challenge code.
                if (challengeResponseTask.Result == challengeCode)
                {
                    authorized = true;
                    break;
                }
            }
            else
            {
                // Timeout expired
                break;
            }
        }

        if (!timeoutTask.IsCompleted)
        {
            // All pending timers must be complete or canceled before the function exits.
            timeoutCts.Cancel();
        }

        return authorized;
    }
}

Poznámka:

Nemusí to být zpočátku zřejmé, ale tento orchestrátor neporušuje deterministické omezení orchestrace. Je deterministický, protože CurrentUtcDateTime vlastnost vypočítá čas vypršení platnosti časovače a vrátí stejnou hodnotu při každém přehrání v tomto okamžiku v kódu orchestrátoru. Toto chování zajišťuje, že winner je stejné pro každé opakované volání Task.WhenAny.

JavaScript

Programovací model V3

Funkce E4_SmsPhoneVerification používá standardní function.json pro funkce orchestrátoru.

{
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ],
  "disabled": false
}

Tady je kód, který implementuje funkci:

const df = require("durable-functions");
const moment = require("moment");

module.exports = df.orchestrator(function* (context) {
    const phoneNumber = context.df.getInput();
    if (!phoneNumber) {
        throw "A phone number input is required.";
    }

    const challengeCode = yield context.df.callActivity("E4_SendSmsChallenge", phoneNumber);

    // The user has 90 seconds to respond with the code they received in the SMS message.
    const expiration = moment.utc(context.df.currentUtcDateTime).add(90, "s");
    const timeoutTask = context.df.createTimer(expiration.toDate());

    let authorized = false;
    for (let i = 0; i <= 3; i++) {
        const challengeResponseTask = context.df.waitForExternalEvent("SmsChallengeResponse");

        const winner = yield context.df.Task.any([challengeResponseTask, timeoutTask]);

        if (winner === challengeResponseTask) {
            // We got back a response! Compare it to the challenge code.
            if (challengeResponseTask.result === challengeCode) {
                authorized = true;
                break;
            }
        } else {
            // Timeout expired
            break;
        }
    }

    if (!timeoutTask.isCompleted) {
        // All pending timers must be complete or canceled before the function exits.
        timeoutTask.cancel();
    }

    return authorized;
});

Poznámka:

Nemusí to být zpočátku zřejmé, ale tento orchestrátor neporušuje deterministické omezení orchestrace. Je deterministický, protože currentUtcDateTime vlastnost vypočítá čas vypršení platnosti časovače a vrátí stejnou hodnotu při každém přehrání v tomto okamžiku v kódu orchestrátoru. Toto chování zajišťuje, že winner je stejné pro každé opakované volání context.df.Task.any.

Programovací model V4

Tady je kód, který implementuje smsPhoneVerification funkci orchestrace:

const df = require("durable-functions");
const { DateTime } = require("luxon");

const sendSmsChallengeActivityName = "sendSmsChallenge";

df.app.orchestration("smsPhoneVerification", function* (context) {
    const phoneNumber = context.df.getInput();
    if (!phoneNumber) {
        throw new Error("A phone number input is required.");
    }

    const challengeCode = yield context.df.callActivity(sendSmsChallengeActivityName, phoneNumber);

    // The user has 90 seconds to respond with the code they received in the SMS message.
    const expiration = DateTime.fromJSDate(context.df.currentUtcDateTime).plus({ seconds: 90 });
    const timeoutTask = context.df.createTimer(expiration.toJSDate());

    let authorized = false;
    for (let i = 0; i <= 3; i++) {
        const challengeResponseTask = context.df.waitForExternalEvent("SmsChallengeResponse");

        const winner = yield context.df.Task.any([challengeResponseTask, timeoutTask]);

        if (winner === timeoutTask) {
            // Timeout expired
            break;
        }

        // We got back a response! Compare it to the challenge code.
        if (challengeResponseTask.result === challengeCode) {
            authorized = true;
            break;
        }
    }

    if (!timeoutTask.isCompleted) {
        // All pending timers must be complete or canceled before the function exits.
        timeoutTask.cancel();
    }

    return authorized;
});

Python

Funkce E4_SmsPhoneVerification používá standardní function.json pro funkce orchestrátoru.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ]
}

Tady je kód, který implementuje funkci:

import azure.durable_functions as df
from datetime import timedelta

def is_valid_phone_number(phone_number: str):
    has_area_code = phone_number[0] == "+"
    is_positive_num = phone_number[1:].isdigit()
    return has_area_code and is_positive_num

def orchestrator_function(context: df.DurableOrchestrationContext):

    phone_number = context.get_input()

    if (not phone_number) or (not is_valid_phone_number(phone_number)):
        msg = "Please provide a phone number beginning with an international dialing prefix"+\
            "(+) followed by the country code, and then rest of the phone number. Example:"\
            "'+1425XXXXXXX'"
        raise Exception(msg)

    challenge_code = yield context.call_activity("SendSMSChallenge", phone_number)

    expiration = context.current_utc_datetime + timedelta(seconds=180)
    timeout_task = context.create_timer(expiration)

    authorized = False
    for _ in range(3):
        challenge_response_task = context.wait_for_external_event("SmsChallengeResponse")
        winner = yield context.task_any([challenge_response_task, timeout_task])

        if (winner == challenge_response_task):
            # We got back a response! Compare it to the challenge code
            if (challenge_response_task.result == challenge_code):
                authorized = True
                break
        else:
            # Timeout expired
            break
    
    if not timeout_task.is_completed:
        # All pending timers must be complete or canceled before the function exits.
        timeout_task.cancel()

    return authorized

main = df.Orchestrator.create(orchestrator_function)

Poznámka:

Nemusí to být zpočátku zřejmé, ale tento orchestrátor neporušuje deterministické omezení orchestrace. Je deterministický, protože vlastnost currentUtcDateTime počítá čas vypršení časovače a v tomto bodě orchestrátoru vrací stejnou hodnotu při každém opakování. Toto chování zajišťuje, že každé opakované volání do context.df.Task.any vede ke stejnému winner.

PowerShell

Orchestrátor odešle SMS výzvu a čeká na odpověď uživatele. Umožňuje až tři pokusy během 90sekundového časového limitu.

param($Context)

$phoneNumber = $Context.Input

# Step 1: Send the SMS challenge code
$challengeCode = Invoke-DurableActivity -FunctionName 'E4_SendSmsChallenge' -Input $phoneNumber

# Step 2: Wait for the user to respond with the code
# Allow up to three attempts within a 90-second timeout window
$authorized = $false
$timeoutTask = Start-DurableTimer -Duration (New-TimeSpan -Seconds 90) -NoWait

for ($retryCount = 0; $retryCount -lt 3; $retryCount++) {
    $challengeResponseTask = Start-DurableExternalEventListener -EventName 'SmsChallengeResponse' -NoWait
    $winner = Wait-DurableTask -Task @($challengeResponseTask, $timeoutTask) -Any

    if ($winner -eq $timeoutTask) {
        break
    }

    $response = Get-DurableTaskResult -Task $challengeResponseTask
    if ($response -eq $challengeCode) {
        $authorized = $true
        break
    }
}

# Cancel the timeout timer if the user was verified before it fired
if ($authorized) {
    Stop-DurableTimerTask -Task $timeoutTask
}

$authorized

Java

@FunctionName("E4_SmsPhoneVerification")
public boolean smsPhoneVerification(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {

    String phoneNumber = ctx.getInput(String.class);

    // Step 1: Send the SMS challenge code
    int challengeCode = ctx.callActivity(
            "E4_SendSmsChallenge", phoneNumber, Integer.class).await();

    // Step 2: Create a 90-second timeout timer
    Duration timeout = Duration.ofSeconds(90);

    // Step 3: Wait for the user to respond with the code
    // Allow up to three attempts within the timeout window
    boolean authorized = false;
    Task<Void> timeoutTask = ctx.createTimer(timeout);

    for (int retryCount = 0; retryCount < 3; retryCount++) {
        Task<String> challengeResponseTask = ctx.waitForExternalEvent(
                "SmsChallengeResponse", String.class);

        Task<?> winner = ctx.anyOf(challengeResponseTask, timeoutTask).await();

        if (winner == challengeResponseTask) {
            String response = challengeResponseTask.await();
            if (Integer.parseInt(response) == challengeCode) {
                authorized = true;
                break;
            }
        } else {
            // Timeout expired
            break;
        }
    }

    return authorized;
}

Poznámka:

Tento orchestrátor je deterministický, protože ctx.createTimer při každém opakování produkuje ctx.waitForExternalEvent stejné výsledky.

Po spuštění tato funkce orchestrátoru provádí následující kroky:

1. Získá telefonní číslo pro odeslání SMS oznámení.
2. Volání E4_SendSmsChallenge slouží k odeslání zprávy SMS uživateli a vrací očekávaný čtyřmístný ověřovací kód.
3. Vytvoří trvalý časovač, který se aktivuje 90 sekund po aktuálním čase.
4. Souběžně s časovačem čeká na událost SmsChallengeResponse od uživatele.

Uživatel obdrží zprávu SMS se čtyřmístným kódem. Mají 90 sekund, aby odeslali stejný kód instanci orchestrátoru, aby dokončili ověření. Pokud odesílají nesprávný kód, získají tři další pokusy ve stejném 90sekundovém okně.

Výstraha

Zrušte časovače , které už nepotřebujete. V předchozím příkladu orchestrace ruší časovač, když přijme odpověď na výzvu.

Orchestrátor odešle žádost o schválení a pak čeká na lidskou odpověď nebo časový limit.

C#

using Microsoft.DurableTask;
using System;
using System.Threading;
using System.Threading.Tasks;

[DurableTask(nameof(ApprovalOrchestration))]
public class ApprovalOrchestration : TaskOrchestrator<ApprovalRequestData, ApprovalResult>
{
    public override async Task<ApprovalResult> RunAsync(
        TaskOrchestrationContext context, ApprovalRequestData input)
    {
        string requestId = input.RequestId;
        double timeoutHours = input.TimeoutHours;

        // Step 1: Submit the approval request (notify approver)
        SubmissionResult submissionResult = await context.CallActivityAsync<SubmissionResult>(
            nameof(SubmitApprovalRequestActivity), input);

        // Make the status available via custom status
        context.SetCustomStatus(submissionResult);

        // Step 2: Create a durable timer for the timeout
        DateTime timeoutDeadline = context.CurrentUtcDateTime.AddHours(timeoutHours);

        using var timeoutCts = new CancellationTokenSource();
        Task timeoutTask = context.CreateTimer(timeoutDeadline, timeoutCts.Token);

        // Step 3: Wait for an external event (approval/rejection)
        Task<ApprovalResponseData> approvalTask = context.WaitForExternalEvent<ApprovalResponseData>(
            "approval_response");

        // Step 4: Wait for either the timeout or the approval response
        Task completedTask = await Task.WhenAny(approvalTask, timeoutTask);

        // Step 5: Process based on which task completed
        ApprovalResult result;

        if (completedTask == approvalTask)
        {
            // Human responded in time - cancel the timeout timer
            timeoutCts.Cancel();

            ApprovalResponseData approvalData = approvalTask.Result;

            // Process the approval
            result = await context.CallActivityAsync<ApprovalResult>(
                nameof(ProcessApprovalActivity),
                new ProcessApprovalInput
                {
                    RequestId = requestId,
                    IsApproved = approvalData.IsApproved,
                    Approver = approvalData.Approver
                });
        }
        else
        {
            // Timeout occurred
            result = new ApprovalResult
            {
                RequestId = requestId,
                Status = "Timeout",
                ProcessedAt = context.CurrentUtcDateTime.ToString("o")
            };
        }

        return result;
    }
}

JavaScript

import {
  OrchestrationContext,
  TOrchestrator,
  whenAny,
} from "@microsoft/durabletask-js";

const approvalOrchestrator: TOrchestrator = async function* (
  ctx: OrchestrationContext,
  amount: number
): any {
  // Step 1: Submit the request
  const requestId: string = yield ctx.callActivity(submitRequest, { amount });

  ctx.setCustomStatus({ stage: "Awaiting approval", requestId });

  // Step 2: Race external event vs timer
  const approvalEvent = ctx.waitForExternalEvent<{ approved: boolean }>(
    "approval"
  );
  const timeout = ctx.createTimer(5); // 5-second timeout

  const winner = yield whenAny([approvalEvent, timeout]);

  let result: string;
  if (winner === approvalEvent) {
    // Human responded in time
    const decision = approvalEvent.getResult();
    ctx.setCustomStatus({
      stage: "Processing",
      requestId,
      approved: decision.approved,
    });
    result = yield ctx.callActivity(processApproval, {
      requestId,
      approved: decision.approved,
    });
  } else {
    // Timer fired first — timed out
    ctx.setCustomStatus({ stage: "Timed out", requestId });
    result = yield ctx.callActivity(notifyTimeout, requestId);
  }

  ctx.setCustomStatus({ stage: "Completed", requestId });
  return result;
};

Python

import datetime
from durabletask import task

def human_interaction_orchestrator(ctx: task.OrchestrationContext, input_data: dict) -> dict:
    """
    Orchestrator that demonstrates the human interaction pattern.

    Submits an approval request, then waits for a human to approve or reject.
    """
    request_id = input_data.get("request_id")
    timeout_hours = input_data.get("timeout_hours", 24)

    # Step 1: Submit the approval request (notify approver)
    request_data = {
        "request_id": request_id,
        "requester": input_data.get("requester"),
        "item": input_data.get("item")
    }

    submission_result = yield ctx.call_activity("submit_approval_request", input=request_data)

    # Make the status available via custom status
    ctx.set_custom_status(submission_result)

    # Step 2: Create a durable timer for the timeout
    timeout_deadline = ctx.current_utc_datetime + datetime.timedelta(hours=timeout_hours)
    timeout_task = ctx.create_timer(timeout_deadline)

    # Step 3: Wait for an external event (approval/rejection)
    approval_task = ctx.wait_for_external_event("approval_response")

    # Step 4: Wait for either the timeout or the approval response
    winner_task = yield task.when_any([approval_task, timeout_task])

    # Step 5: Process based on which task completed
    if winner_task == approval_task:
        # Human responded in time
        approval_data = yield approval_task

        # Process the approval
        result = yield ctx.call_activity("process_approval", input={
            "request_id": request_id,
            "is_approved": approval_data.get("is_approved", False),
            "approver": approval_data.get("approver", "Unknown")
        })
    else:
        # Timeout occurred
        result = {
            "request_id": request_id,
            "status": "Timeout",
            "timed_out_at": ctx.current_utc_datetime.isoformat()
        }

    return result

PowerShell

Tato ukázka se zobrazuje pro .NET, JavaScript, Java a Python.

Java

import com.microsoft.durabletask.*;
import com.microsoft.durabletask.azuremanaged.DurableTaskSchedulerWorkerExtensions;
import java.time.Duration;

DurableTaskGrpcWorker worker = DurableTaskSchedulerWorkerExtensions.createWorkerBuilder(connectionString)
    .addOrchestration(new TaskOrchestrationFactory() {
        @Override
        public String getName() { return "ApprovalWorkflow"; }

        @Override
        public TaskOrchestration create() {
            return ctx -> {
                // Get the approval request
                ApprovalRequest request = ctx.getInput(ApprovalRequest.class);

                // Set initial status
                ctx.setCustomStatus(new WorkflowStatus("Waiting for approval", null));

                // Create a timeout timer
                Task timeoutTask = ctx.createTimer(
                    Duration.ofHours((long) request.timeoutHours));

                // Wait for external event (approval response)
                Task<ApprovalResponse> approvalTask = ctx.waitForExternalEvent(
                    "approval_response", ApprovalResponse.class);

                // Wait for either approval or timeout
                Task<?> winner = ctx.anyOf(approvalTask, timeoutTask).await();

                if (winner == approvalTask) {
                    // Human responded in time
                    ApprovalResponse response = approvalTask.await();
                    String status = response.isApproved ? "APPROVED" : "REJECTED";
                    ctx.setCustomStatus(new WorkflowStatus(status, response));
                    ctx.complete(new WorkflowResult(
                        status,
                        response.isApproved ? "Request approved" : "Request rejected"));
                } else {
                    // Timeout occurred
                    ctx.setCustomStatus(new WorkflowStatus("Timed out", null));
                    ctx.complete(new WorkflowResult("TIMEOUT", "Request timed out"));
                }
            };
        }
    })
    .build();

Tento orchestrátor provádí následující akce:

1. Odešle žádost o schválení zavoláním aktivity, která schvalovatele upozorní.
2. Nastaví vlastní stav, aby klienti mohli sledovat průběh.
3. Vytvoří trvalý časovač pro konečný časový limit.
4. Čeká na externí událost (approval_response), kterou schvalovatel vyvolá.
5. Používá WhenAny, when_any nebo anyOf, aby čekal na to, co se dokončí jako první: schválení nebo vypršení časového limitu.
6. Zpracuje výsledek podle toho, který úkol je dokončen.

Výstraha

Zrušte časovače , které už nepotřebujete. V příkladu jazyka C# orchestrace zruší časovač časového limitu, když obdrží schválení.

Definování aktivit

funkce aktivity E4_SendSmsChallenge

Funkce E4_SendSmsChallenge odešle uživateli SMS zprávu obsahující čtyřmístný kód.

C#

Izolovaný model pracovního procesu

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
using Twilio;
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;

public static partial class PhoneVerification
{
    [Function("E4_SendSmsChallenge")]
    public static async Task<int> SendSmsChallenge(
        [ActivityTrigger] string phoneNumber,
        FunctionContext executionContext)
    {
        ILogger logger = executionContext.GetLogger("E4_SendSmsChallenge");

        int challengeCode = Random.Shared.Next(10000);
        logger.LogInformation(
            "Sending verification code {ChallengeCode:0000} to {PhoneNumber}.",
            challengeCode,
            phoneNumber);

        string accountSid = Environment.GetEnvironmentVariable("TwilioAccountSid")
            ?? throw new InvalidOperationException("TwilioAccountSid is not configured.");
        string authToken = Environment.GetEnvironmentVariable("TwilioAuthToken")
            ?? throw new InvalidOperationException("TwilioAuthToken is not configured.");
        string fromNumber = Environment.GetEnvironmentVariable("TwilioPhoneNumber")
            ?? throw new InvalidOperationException("TwilioPhoneNumber is not configured.");

        TwilioClient.Init(accountSid, authToken);
        await MessageResource.CreateAsync(
            to: new PhoneNumber(phoneNumber),
            from: new PhoneNumber(fromNumber),
            body: $"Your verification code is {challengeCode:0000}");

        return challengeCode;
    }
}

Poznámka:

Pro spuštění izolovaného worker vzorku nainstalujte Twilio balíček NuGet. Nastavte TwilioAccountSidnastavení , TwilioAuthToken, a TwilioPhoneNumber aplikace.

Model v probíhajícím procesu

[FunctionName("E4_SendSmsChallenge")]
public static int SendSmsChallenge(
    [ActivityTrigger] string phoneNumber,
    ILogger log,
    [TwilioSms(AccountSidSetting = "TwilioAccountSid", AuthTokenSetting = "TwilioAuthToken", From = "%TwilioPhoneNumber%")]
        out CreateMessageOptions message)
{
    // Get a random number generator with a random seed (not time-based)
    var rand = new Random(Guid.NewGuid().GetHashCode());
    int challengeCode = rand.Next(10000);

    log.LogInformation($"Sending verification code {challengeCode} to {phoneNumber}.");

    message = new CreateMessageOptions(new PhoneNumber(phoneNumber));
    message.Body = $"Your verification code is {challengeCode:0000}";

    return challengeCode;
}

Poznámka:

Pokud chcete spustit ukázku, nainstalujte balíček NuGet Microsoft.Azure.WebJobs.Extensions.Twilio. Neinstalujte hlavní balíček NuGet Twilio , protože může způsobit konflikty verzí a chyby sestavení.

JavaScript

Programovací model V3

Definujte soubor function.json následovně:

{
  "bindings": [
    {
      "name": "phoneNumber",
      "type": "activityTrigger",
      "direction": "in"
    },
    {
      "type": "twilioSms",
      "name": "message",
      "from": "%TwilioPhoneNumber%",
      "accountSidSetting": "TwilioAccountSid",
      "authTokenSetting": "TwilioAuthToken",
      "direction": "out"
    }
  ],
  "disabled": false
}

Tento kód vygeneruje čtyřmístný kód výzvy a odešle zprávu SMS:

const seedrandom = require("seedrandom");
const uuidv1 = require("uuid/v1");

module.exports = function (context, phoneNumber) {
    // Get a random number generator with a random seed (not time-based)
    const rand = seedrandom(uuidv1());
    const challengeCode = Math.floor(rand() * 10000);

    context.log(`Sending verification code ${challengeCode} to ${phoneNumber}.`);

    context.bindings.message = {
        body: `Your verification code is ${challengeCode.toPrecision(4)}`,
        to: phoneNumber,
    };

    context.done(null, challengeCode);
};

Programovací model V4

Tady je kód, který vygeneruje čtyřciferný kód výzvy a odešle zprávu SMS:

const { output } = require("@azure/functions");
const df = require("durable-functions");

const sendSmsChallengeActivityName = "sendSmsChallenge";

const twilioOutput = output.generic({
    type: "twilioSms",
    from: "%TwilioPhoneNumber%",
    accountSidSetting: "TwilioAccountSid",
    authTokenSetting: "TwilioAuthToken",
});

df.app.activity(sendSmsChallengeActivityName, {
    extraOutputs: [twilioOutput],
    handler: function (phoneNumber, context) {
        // Get a random challenge code
        const challengeCode = Math.floor(Math.random() * 10000);

        context.log(`Sending verification code ${challengeCode} to ${phoneNumber}.`);

        context.extraOutputs.set(twilioOutput, {
            body: `Your verification code is ${challengeCode.toPrecision(4)}`,
            to: phoneNumber,
        });

        return challengeCode;
    },
});

Python

Definujte soubor function.json následovně:

{
  "bindings": [
    {
      "name": "phoneNumber",
      "type": "activityTrigger",
      "direction": "in"
    },
    {
      "type": "twilioSms",
      "name": "message",
      "from": "%TwilioPhoneNumber%",
      "accountSidSetting": "TwilioAccountSid",
      "authTokenSetting": "TwilioAuthToken",
      "direction": "out"
    }
  ]
}

Tento kód vygeneruje čtyřmístný kód výzvy a odešle zprávu SMS:

import json
import random

random.seed(10)

def main(phoneNumber, message):
  code = random.randint(0, 10000)
  payload = {
    "body": f"Your verification code is {code}",
    "to": phoneNumber
  }

  message.set(json.dumps(payload))
  code_str = str(code)
  return code_str

PowerShell

Aktivita generuje náhodný čtyřmístný kód výzvy. V reálné aplikaci tento kód také odesílá SMS zprávu na určené telefonní číslo.

param($phoneNumber)

# Generate a random four-digit challenge code
$challengeCode = Get-Random -Minimum 1000 -Maximum 10000

Write-Host "Sending verification code $challengeCode to $phoneNumber."

# In a real app, send the SMS here using Twilio or another provider
$challengeCode

Java

@FunctionName("E4_SendSmsChallenge")
public int sendSmsChallenge(
        @DurableActivityTrigger(name = "phoneNumber") String phoneNumber) {

    // Generate a random four-digit challenge code
    int challengeCode = ThreadLocalRandom.current().nextInt(1000, 10000);

    // In a real app, send the SMS here using Twilio or another provider
    Logger logger = Logger.getLogger("E4_SendSmsChallenge");
    logger.info(String.format("Sending verification code %d to %s.", challengeCode, phoneNumber));

    return challengeCode;
}

Aktivity odesílají žádost o schválení a zpracovávají odpověď.

Aktivita odeslání žádosti o schválení

C#

using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;

[DurableTask(nameof(SubmitApprovalRequestActivity))]
public class SubmitApprovalRequestActivity : TaskActivity<ApprovalRequestData, SubmissionResult>
{
    private readonly ILogger<SubmitApprovalRequestActivity> _logger;

    public SubmitApprovalRequestActivity(ILogger<SubmitApprovalRequestActivity> logger)
    {
        _logger = logger;
    }

    public override Task<SubmissionResult> RunAsync(
        TaskActivityContext context, ApprovalRequestData input)
    {
        _logger.LogInformation(
            "Submitting approval request {RequestId} from {Requester} for {Item}",
            input.RequestId, input.Requester, input.Item);

        // In a real system, this would send an email, notification, or update a database
        var result = new SubmissionResult
        {
            RequestId = input.RequestId,
            Status = "Pending",
            SubmittedAt = DateTime.UtcNow.ToString("o"),
            ApprovalUrl = $"http://localhost:8000/api/approvals/{input.RequestId}"
        };

        return Task.FromResult(result);
    }
}

JavaScript

import { ActivityContext } from "@microsoft/durabletask-js";

const submitRequest = async (
  _ctx: ActivityContext,
  request: { amount: number }
): Promise<string> => {
  console.log(
    `[submitRequest] Purchase request submitted: $${request.amount}`
  );
  return `REQ-${Date.now()}`;
};

Python

import datetime
from durabletask import task

def submit_approval_request(ctx: task.ActivityContext, request_data: dict) -> dict:
    """
    Activity that submits an approval request.
    In a real application, this would notify a human approver via email, message, etc.
    """
    request_id = request_data.get("request_id")
    requester = request_data.get("requester")
    item = request_data.get("item")

    # In a real system, this would send an email, notification, or update a database
    return {
        "request_id": request_id,
        "status": "Pending",
        "submitted_at": datetime.datetime.now().isoformat(),
        "approval_url": f"http://localhost:8000/api/approvals/{request_id}"
    }

PowerShell

Tato ukázka se zobrazuje pro .NET, JavaScript, Java a Python.

Java

Ukázka Java odešle žádost o schválení přímo. Pro produkční aplikaci vytvořte samostatnou aktivitu:

.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "SubmitApprovalRequest"; }

    @Override
    public TaskActivity create() {
        return ctx -> {
            ApprovalRequest request = ctx.getInput(ApprovalRequest.class);

            // In a real system, send email/notification
            logger.info("Submitting approval request for " + request.item);

            return new SubmissionResult(
                "Pending",
                Instant.now().toString(),
                "http://localhost:8000/api/approvals/" + request.requester);
        };
    }
})

Aktivita schválení procesu

C#

using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;

[DurableTask(nameof(ProcessApprovalActivity))]
public class ProcessApprovalActivity : TaskActivity<ProcessApprovalInput, ApprovalResult>
{
    private readonly ILogger<ProcessApprovalActivity> _logger;

    public ProcessApprovalActivity(ILogger<ProcessApprovalActivity> logger)
    {
        _logger = logger;
    }

    public override Task<ApprovalResult> RunAsync(
        TaskActivityContext context, ProcessApprovalInput input)
    {
        string status = input.IsApproved ? "Approved" : "Rejected";
        _logger.LogInformation(
            "Processing {Status} request {RequestId} by {Approver}",
            status, input.RequestId, input.Approver);

        // In a real system, this would update a database, trigger workflows, etc.
        var result = new ApprovalResult
        {
            RequestId = input.RequestId,
            Status = status,
            ProcessedAt = DateTime.UtcNow.ToString("o"),
            Approver = input.Approver
        };

        return Task.FromResult(result);
    }
}

// Data classes
public class ApprovalRequestData
{
    public string RequestId { get; set; } = string.Empty;
    public string Requester { get; set; } = string.Empty;
    public string Item { get; set; } = string.Empty;
    public double TimeoutHours { get; set; } = 24.0;
}

public class ApprovalResponseData
{
    public bool IsApproved { get; set; }
    public string Approver { get; set; } = string.Empty;
}

public class SubmissionResult
{
    public string RequestId { get; set; } = string.Empty;
    public string Status { get; set; } = string.Empty;
    public string SubmittedAt { get; set; } = string.Empty;
    public string ApprovalUrl { get; set; } = string.Empty;
}

public class ProcessApprovalInput
{
    public string RequestId { get; set; } = string.Empty;
    public bool IsApproved { get; set; }
    public string Approver { get; set; } = string.Empty;
}

public class ApprovalResult
{
    public string RequestId { get; set; } = string.Empty;
    public string Status { get; set; } = string.Empty;
    public string ProcessedAt { get; set; } = string.Empty;
    public string? Approver { get; set; }
}

JavaScript

import { ActivityContext } from "@microsoft/durabletask-js";

const processApproval = async (
  _ctx: ActivityContext,
  data: { requestId: string; approved: boolean }
): Promise<string> => {
  console.log(
    `[processApproval] Request ${data.requestId}: ${
      data.approved ? "APPROVED" : "REJECTED"
    }`
  );
  return data.approved ? "Order placed" : "Order cancelled";
};

const notifyTimeout = async (
  _ctx: ActivityContext,
  requestId: string
): Promise<string> => {
  console.log(
    `[notifyTimeout] Request ${requestId} timed out — auto-rejected`
  );
  return "Timed out — auto-rejected";
};

Python

import datetime
from durabletask import task

def process_approval(ctx: task.ActivityContext, approval_data: dict) -> dict:
    """
    Activity that processes the approval once received.
    """
    request_id = approval_data.get("request_id")
    is_approved = approval_data.get("is_approved")
    approver = approval_data.get("approver")

    status = "Approved" if is_approved else "Rejected"

    # In a real system, this would update a database, trigger workflows, etc.
    return {
        "request_id": request_id,
        "status": status,
        "processed_at": datetime.datetime.now().isoformat(),
        "approver": approver
    }

PowerShell

Tato ukázka se zobrazuje pro .NET, JavaScript, Java a Python.

Java

Ukázková aplikace v jazyce Java zpracovává schválení v rámci orchestrátoru. Pro produkční aplikaci vytvořte samostatnou aktivitu.

Spusťte ukázku lidské interakce

Pomocí funkcí aktivovaných protokolem HTTP v ukázce spusťte orchestraci odesláním následujícího požadavku HTTP POST:

POST http://{host}/orchestrators/E4_SmsPhoneVerification
Content-Length: 14
Content-Type: application/json

"+1425XXXXXXX"

HTTP/1.1 202 Accepted
Content-Type: application/json; charset=utf-8

{"id":"741c65651d4c40cea29acdd5bb47baf1",
 "sendEventPostUri":"http://{host}/runtime/webhooks/durabletask/instances/741c65651d4c40cea29acdd5bb47baf1/raiseEvent/{eventName}?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}",
 "statusQueryGetUri":"http://{host}/runtime/webhooks/durabletask/instances/741c65651d4c40cea29acdd5bb47baf1?taskHub=...&code={systemKey}",
 "terminatePostUri":"http://{host}/runtime/webhooks/durabletask/instances/741c65651d4c40cea29acdd5bb47baf1/terminate?reason={text}&taskHub=...&code={systemKey}"}

Funkce orchestrátoru obdrží telefonní číslo a okamžitě odešle sms zprávu na toto číslo s náhodně vygenerovaným 4místným ověřovacím kódem , 2168například . Funkce pak počká 90 sekund na odpověď.

Pokud chcete odpovědět s kódem, použijte RaiseEventAsync (.NET) nebo raiseEvent (JavaScript a TypeScript) v jiné funkci nebo v odpovědi 202 zavolejte sendEventPostUri koncový bod HTTP POST. Nahraďte {eventName} za SmsChallengeResponse

POST http://{host}/runtime/webhooks/durabletask/instances/741c65651d4c40cea29acdd5bb47baf1/raiseEvent/SmsChallengeResponse?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}
Content-Length: 4
Content-Type: application/json

2168

Pokud událost odešlete před vypršením platnosti časovače, orchestrace se dokončí a output pole se nastaví na truehodnotu , která označuje úspěšné ověření.

GET http://{host}/runtime/webhooks/durabletask/instances/741c65651d4c40cea29acdd5bb47baf1?taskHub=DurableFunctionsHub&connection=Storage&code={systemKey}

HTTP/1.1 200 OK
Content-Length: 144
Content-Type: application/json; charset=utf-8

{"runtimeStatus":"Completed","input":"+1425XXXXXXX","output":true,"createdTime":"2026-04-23T19:10:49Z","lastUpdatedTime":"2026-04-23T19:12:23Z"}

Pokud časovač vyprší nebo čtyřikrát zadáte nesprávný kód, zkontrolujte stav, aby byl output nastaven na false, což značí, že ověření telefonu selhalo.

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 145

{"runtimeStatus":"Completed","input":"+1425XXXXXXX","output":false,"createdTime":"2026-04-23T19:20:49Z","lastUpdatedTime":"2026-04-23T19:22:23Z"}

Chcete-li spustit ukázku:

1. Spusťte emulátor plánovače úloh Durable pro místní vývoj. Musí být nainstalovaný Docker.

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

2. Spusťte pracovní proces ke zaregistrování orchestrátoru a aktivit.

3. Spuštěním klienta naplánujte pracovní postup schválení a odešlete události.

C#

using System;
using System.Threading.Tasks;

var client = DurableTaskClientBuilder.UseDurableTaskScheduler(connectionString).Build();

// Schedule the approval workflow
var input = new ApprovalRequestData
{
    RequestId = "request-" + Guid.NewGuid().ToString(),
    Requester = "john.doe@example.com",
    Item = "Vacation Request - 5 days",
    TimeoutHours = 24
};

string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
    nameof(ApprovalOrchestration), input);

Console.WriteLine($"Started approval workflow: {instanceId}");

// Simulate human approving the request
Console.WriteLine("Simulating approval...");
await Task.Delay(2000);

// Raise the approval event
var approvalResponse = new ApprovalResponseData
{
    IsApproved = true,
    Approver = "manager@example.com"
};

await client.RaiseEventAsync(instanceId, "approval_response", approvalResponse);

// Wait for completion
var result = await client.WaitForInstanceCompletionAsync(instanceId, getInputsAndOutputs: true);
Console.WriteLine($"Result: {result.ReadOutputAs<ApprovalResult>().Status}");

JavaScript

import {
  DurableTaskAzureManagedClientBuilder,
  DurableTaskAzureManagedWorkerBuilder,
} from "@microsoft/durabletask-js-azuremanaged";

const client = new DurableTaskAzureManagedClientBuilder()
  .connectionString(connectionString)
  .build();

const worker = new DurableTaskAzureManagedWorkerBuilder()
  .connectionString(connectionString)
  .addOrchestrator(approvalOrchestrator)
  .addActivity(submitRequest)
  .addActivity(processApproval)
  .addActivity(notifyTimeout)
  .build();

await worker.start();

// Schedule the approval workflow
const approvalId = await client.scheduleNewOrchestration(
  approvalOrchestrator,
  500 // amount
);

console.log(`Orchestration started: ${approvalId}`);

// Wait for it to reach "Awaiting approval", then send approval
await new Promise((r) => setTimeout(r, 3000));

await client.raiseOrchestrationEvent(approvalId, "approval", {
  approved: true,
});
console.log("Sent approval event");

const result = await client.waitForOrchestrationCompletion(
  approvalId,
  true,
  60
);
console.log(`Result: ${result?.serializedOutput}`);

await worker.stop();
await client.stop();

Python

from durabletask.azuremanaged.client import DurableTaskSchedulerClient
import time
import uuid

client = DurableTaskSchedulerClient(
    host_address=endpoint,
    secure_channel=endpoint != "http://localhost:8080",
    taskhub=taskhub,
    token_credential=credential
)

# Schedule the approval workflow
input_data = {
    "request_id": f"request-{uuid.uuid4()}",
    "requester": "john.doe@example.com",
    "item": "Vacation Request - 5 days",
    "timeout_hours": 24
}

instance_id = client.schedule_new_orchestration(
    human_interaction_orchestrator,
    input=input_data
)

print(f"Started approval workflow: {instance_id}")

# Simulate human approving the request
print("Simulating approval...")
time.sleep(2)

# Raise the approval event
approval_response = {
    "is_approved": True,
    "approver": "manager@example.com"
}

client.raise_orchestration_event(instance_id, "approval_response", data=approval_response)

# Wait for completion
result = client.wait_for_orchestration_completion(instance_id, timeout=60)
print(f"Result: {result.serialized_output}")

PowerShell

Tato ukázka se zobrazuje pro .NET, JavaScript, Java a Python.

Java

import java.time.Duration;
import java.time.Instant;
import java.util.UUID;

DurableTaskClient client = DurableTaskSchedulerClientExtensions
    .createClientBuilder(connectionString).build();

// Schedule the approval workflow
ApprovalRequest request = new ApprovalRequest(
    "john.doe@example.com",
    "Vacation Request - 5 days",
    24  // timeout hours
);

String instanceId = client.scheduleNewOrchestrationInstance(
    "ApprovalWorkflow",
    new NewOrchestrationInstanceOptions()
        .setInput(request)
        .setInstanceId("request-" + UUID.randomUUID().toString()));

System.out.println("Started approval workflow: " + instanceId);

// Simulate human approving the request
System.out.println("Simulating approval...");
Thread.sleep(2000);

// Raise the approval event
ApprovalResponse response = new ApprovalResponse(
    true,  // isApproved
    "manager@example.com",
    "Approved",
    Instant.now().toString()
);

client.raiseEvent(instanceId, "approval_response", response);

// Wait for completion
OrchestrationMetadata result = client.waitForInstanceCompletion(
    instanceId, Duration.ofSeconds(60), true);

System.out.println("Result: " + result.readOutputAs(WorkflowResult.class).status);

Další kroky

Tato ukázka ukazuje pokročilé možnosti Durable Functions, včetně rozhraní API WaitForExternalEvent a CreateTimer. Ukazuje, jak kombinovat Task.WhenAny (C#), context.df.Task.any (JavaScript a TypeScript) nebo context.task_any (Python) a implementovat spolehlivý vzor časového limitu pro pracovní postupy, které čekají na reakce lidí.

Učte se o vazbách Durable Functions

• Trvalé časovače
• Externí události a správa instancí
• Věčná orchestrace

Tato ukázka ukazuje, jak pomocí sad SDK durable task implementovat pracovní postupy, které čekají na reakci lidí s konfigurovatelnými časovými limity. Klíčové koncepty:

• Externí události: Použití WaitForExternalEvent k čekání na vstup
• Trvalé časovače: Použití CreateTimer k implementaci časových limitů
• Závodní úkoly: Použití WhenAny, when_any nebo anyOf k vyřízení úkolu, který se dokončí jako první

Začínáme se sadami SDK Durable Task

• Trvalé časovače
• Věčná orchestrace
• Durable Task JavaScript SDK na GitHub