Emberi interakciós minta

Az emberi interakciós minta olyan munkafolyamatokat ír le, amelyek szüneteltetik és várják a személyek bemenetét a folytatás előtt. A minta hasznos a jóváhagyási munkafolyamatokhoz, a többtényezős hitelesítéshez és minden olyan forgatókönyvhöz, amikor egy személy egy adott határidőn belül válaszol.

Magas szinten a minta a következőképpen működik:

1. A vezénylő meghív egy tevékenységet egy személy értesítésére (SMS-kód küldése, jóváhagyó e-mail küldése stb.).
2. A vezénylő elindít egy tartós időzítőt, és egyidejűleg vár egy külső eseményre a személytől.
3. Ha a személy az időzítő kilövése előtt válaszol, a vezénylő feldolgozza a választ.
4. Ha az időzítő először aktiválódik, a vezénylő kezeli az időtúllépést (például a kérés elutasításával).

A cikk tartalma:

• Emberi interakciós forgatókönyv áttekintése – Miért fontos ez a minta?
• A vezénylő definiálása – Az időzítő és az esemény versenyének megvalósítása
• A tevékenységek meghatározása – Értesítések és folyamateredmények küldése
• Az emberi interakciós minta futtatása – A munkafolyamat végpontok közötti tesztelése

Megjegyzés:

A Durable Functions és a Durable Task SDK kimutatásai ugyanazt a mintát szemléltetik különböző forgatókönyvekkel: a Durable Functions SMS alapú telefonos hitelesítést példát alkalmaz, míg a Durable Task SDK-k jóváhagyási munkafolyamatot példát alkalmaznak.

Ez a minta bemutatja, hogyan hozhat létre Durable Functions vezénylést, amely magában foglalja az emberi interakciót. A példa egy SMS-alapú telefonos ellenőrző rendszert implementál. Ez gyakori a telefonszám-ellenőrzés és a többtényezős hitelesítés (MFA) folyamatokban.

Megjegyzés:

A C#, JavaScript és Python teljes kódminták érhetők el. A PowerShell- és Java-minták jelenleg nem érhetők el.

Megjegyzés:

Az Azure Functions Node.js programozási modelljének 4. verziója általánosan elérhető. A v4-es modell úgy lett kialakítva, hogy rugalmasabb és intuitívabb élményt nyújtson a JavaScript- és TypeScript-fejlesztők számára. A v3 és a v4 közötti különbségekről további információt a migrálási útmutatóban talál.

A következő kódrészletekben a JavaScript (PM4) a v4-es programozási modellt, az új élményt jelöli.

Előfeltételek

C#

• A rövid útmutatót ismertető cikk befejezése
• A mintaprojekt klónozása vagy letöltése a GitHubról (a folyamatban lévő modellt használja)

JavaScript

V3 programozási modell

• A rövid útmutatót ismertető cikk befejezése
• A mintaprojektet GitHub

V4 programozási modell

• A rövid útmutatót ismertető cikk befejezése
• A mintaprojektet GitHub

Python

• A rövid útmutatót ismertető cikk befejezése
• A mintaprojektet GitHub

PowerShell

• A rövid útmutatót ismertető cikk befejezése
• A mintaprojektet GitHub

Java

• A rövid útmutatót ismertető cikk befejezése

Ez a cikk bemutatja, hogyan implementálható az emberi interakciós minta a Durable Task SDK-k használatával. A példa egy jóváhagyási munkafolyamatot valósít meg, amelyben egy orchestráció megvárja, hogy egy személy jóváhagyja vagy elutasítsa a kérelmet, mielőtt folytatná.

Emberi interakciós forgatókönyv áttekintése

A telefonos ellenőrzés segít meggyőződni arról, hogy az alkalmazást használó személyek nem levélszemétküldők, és hogy ők irányítják a megadott telefonszámot. A fiókok védelmének gyakori módja a többtényezős hitelesítés. A saját telefonos ellenőrzés létrehozásához állapotalapú interakcióra van szükség egy személlyel. A felhasználó általában kap egy kódot (például egy négyjegyű számot), és ésszerű időn belül válaszolnia kell.

A standard Azure Functions állapot nélküliek (mint sok más felhővégpont), ezért az ilyen típusú interakciókhoz állapotot kell tárolnia egy adatbázisban vagy egy másik állandó tárolóban. Az interakciót több függvényre is feloszthatja, és összehangolhatja őket. Egy függvény például létrehoz egy kódot, tárolja és elküldi a felhasználó telefonjára. Egy másik függvény megkapja a felhasználó válaszát, és leképozza az eredeti kéréshez a kód érvényesítéséhez. Időtúllépés beállítása a biztonság fokozása érdekében. Ez a munkafolyamat gyorsan összetetté válik.

Durable Functions csökkenti a forgatókönyv összetettségét. Ebben a mintában egy vezénylő függvény külső adattár nélkül kezeli az állapotalapú interakciót. Mivel a vezénylő függvények tartósak, ezek az interaktív folyamatok rendkívül megbízhatóak.

A jóváhagyási munkafolyamatok gyakoriak az üzleti alkalmazásokban, ahol a kéréseket egy embernek felül kell vizsgálnia a folytatás előtt. A munkafolyamat követelményei a következők:

• Várjon határozatlan ideig az emberi válaszra, vagy amíg időtúllépést nem ér el
• A jóváhagyás és az elutasítás kimenetelének kezelése
• Időtúllépések támogatása ha nem érkezett válasz
• Állapot nyomon követése , hogy a kérelmező ellenőrizni tudja az állapotot

A Durable Task SDK-k leegyszerűsítik ezt a forgatókönyvet a következőkkel:

• Külső események: A vezénylés szüneteltetheti és megvárhatja a külső rendszer vagy felhasználó által kiváltott eseményeket
• Tartós időzítők: Állítson be egy időtúllépést, amely aktiválódik, ha nem érkezik válasz
• Egyéni állapot: Az aktuális munkafolyamat állapotának nyomon követése és az ügyfelek számára való elérhetővé helyezése

Twilio-integráció konfigurálása

Ez a minta magában foglalja a Twilio szolgáltatás használatát SMS-üzenetek mobiltelefonra való küldéséhez. Azure Functions már támogatja a Twilio-t a Twilio kötésen keresztül, és a minta ezt a funkciót használja.

Az első dolog, amire szüksége van, egy Twilio-fiók. Létrehozhat egyet ingyenesen a .. címen https://www.twilio.com/try-twilio. Miután rendelkezik fiókkal, adja hozzá az alábbi három alkalmazásbeállítást a függvényalkalmazáshoz.

Alkalmazásbeállítás neve	Érték leírása
TwilioAccountSid	A Twilio-fiók SID-azonosítója
TwilioAuthToken	A Twilio-fiók hitelesítési jogkivonata
TwilioPhoneNumber	A Twilio-fiókhoz társított telefonszám. Ez SMS-üzenetek küldésére szolgál.

Az orchesztrátor definiálása

E4_SmsPhoneVerification vezérlő függvény

C#

[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;
    }
}

Megjegyzés:

Elsőre talán nem nyilvánvaló, de ez a vezénylő nem sérti a determinisztikus vezénylési kényszert. Ez determinisztikus, mert a CurrentUtcDateTime tulajdonság kiszámítja az időzítő lejárati idejét, és ugyanazt az értéket adja vissza minden visszajátszáskor a vezénylési kódban. Ez a viselkedés biztosítja, hogy winner minden ismétlődő hívás Task.WhenAnyesetében ugyanaz legyen.

JavaScript

V3 programozási modell

A E4_SmsPhoneVerification függvény a szabványos function.json használja a vezénylési függvényekhez.

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

A függvényt megvalósító kód a következő:

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;
});

Megjegyzés:

Elsőre talán nem nyilvánvaló, de ez a vezénylő nem sérti a determinisztikus vezénylési kényszert. Ez determinisztikus, mert a currentUtcDateTime tulajdonság kiszámítja az időzítő lejárati idejét, és ugyanazt az értéket adja vissza minden visszajátszáskor a vezénylési kódban. Ez a viselkedés biztosítja, hogy winner minden ismétlődő hívás context.df.Task.anyesetében ugyanaz legyen.

V4 programozási modell

Az smsPhoneVerification orchestration funkciót megvalósító kód:

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

A E4_SmsPhoneVerification függvény a szabványos function.json használja a vezénylési függvényekhez.

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

A függvényt megvalósító kód a következő:

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)

Megjegyzés:

Elsőre talán nem nyilvánvaló, de ez a vezénylő nem sérti a determinisztikus vezénylési kényszert. Ez determinisztikus, mert a tulajdonság az currentUtcDateTime időzítő lejárati idejének kiszámítására szolgál, és ugyanazt az értéket adja vissza minden visszajátszáskor a vezénylési kódban. Ez a viselkedés fontos annak biztosítása érdekében, hogy minden ismételt hívás winner ugyanazt az eredményt context.df.Task.any eredményezze.

PowerShell

Hamarosan megjelenik a PowerShell-minta.

Java

Hamarosan jön a Java példa.

A kezdés után ez a vezénylő függvény a következőket végzi el:

1. Lekéri a telefonszámot az SMS-értesítés elküldéséhez.
2. Felhívja E4_SendSmsChallenge , hogy küldjön SMS-üzenetet a felhasználónak, és visszaadja a várt négyjegyű kihíváskódot.
3. Tartós időzítőt hoz létre, amely az aktuális idő után 90 másodpercet aktivál.
4. Az időzítővel párhuzamosan egy SmsChallengeResponse eseményt vár a felhasználótól.

A felhasználó egy négyjegyű kóddal rendelkező SMS-üzenetet kap. 90 másodpercük van arra, hogy ugyanazt a kódot elküldjék a vezénylő példánynak az ellenőrzés befejezéséhez. Ha nem a megfelelő kódot küldik el, még három próbálkozást kapnak ugyanazon a 90 másodperces ablakban.

Figyelmeztetés

Megszakíthatja az időzítőket , amelyekre már nincs szüksége. A fenti példában a vezénylés megszakítja az időzítőt, amikor elfogadja a kihívásra adott választ.

Az orchesztrátor elküld egy jóváhagyási kérelmet, majd megvárja az emberi választ vagy az időtúllépést.

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

Ez a minta .NET, JavaScript, Java és Python esetében jelenik meg.

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();

Ez a vezénylő a következő műveleteket hajtja végre:

1. A jóváhagyási kérelmet egy olyan tevékenység meghívásával küldi el, amely értesíti a jóváhagyót.
2. Beállítja az egyéni állapotot, hogy az ügyfelek nyomon tudják követni az előrehaladást.
3. Tartós időzítőt hoz létre az időtúllépési határidőhöz.
4. A jóváhagyó által kiváltott külső eseményre (approval_response) vár.
5. A WhenAny, when_any vagy anyOf elemeket használja arra, hogy megvárja, melyik fejeződik be először: a jóváhagyás vagy az időtúllépés.
6. Az, hogy melyik feladat fejeződik be, alapján dolgozza fel az eredményt.

Figyelmeztetés

Megszakíthatja az időzítőket , amelyekre már nincs szüksége. Az C# példában az orchestráció megszakítja az időtúllépési időzítőt, amikor jóváhagyást kap.

A tevékenységek meghatározása

E4_SendSmsChallenge tevékenységfüggvény

A E4_SendSmsChallenge függvény a Twilio-kötéssel küld egy négyjegyű kódot tartalmazó SMS-üzenetet a felhasználónak.

C#

[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;
}

Megjegyzés:

A minta futtatásához telepítse a Microsoft.Azure.WebJobs.Extensions.Twilio NuGet-csomagot. Ne telepítse a fő Twilio NuGet-csomagot , mert verzióütközéseket és buildelési hibákat okozhat.

JavaScript

V3 programozási modell

A function.json fájl a következőképpen van definiálva:

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

Ez a kód létrehozza a négyjegyű feladatkódot, és elküldi az SMS-üzenetet:

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);
};

V4 programozási modell

Az alábbi kód generálja a négyjegyű feladatkódot, és elküldi az SMS-üzenetet:

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

A function.json fájl a következőképpen van definiálva:

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

Ez a kód létrehozza a négyjegyű feladatkódot, és elküldi az SMS-üzenetet:

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

Hamarosan megjelenik a PowerShell-minta.

Java

Hamarosan jön a Java példa.

A tevékenységek elküldik a jóváhagyási kérelmet, és feldolgozzák a választ.

Jóváhagyási kérelem tevékenységének elküldése

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

Ez a minta .NET, JavaScript, Java és Python esetében jelenik meg.

Java

A Java minta beágyazottan küldi el a jóváhagyási kérelmet. Éles alkalmazásokhoz hozzon létre egy külön tevékenységet:

.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);
        };
    }
})

Folyamat-jóváhagyási tevékenység

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

Ez a minta .NET, JavaScript, Java és Python esetében jelenik meg.

Java

A Java minta feldolgozza a jóváhagyásokat az orchestratorban. Éles alkalmazásokhoz hozzon létre egy külön aktivitást.

Az emberi interakciós minta futtatása

Használja a mintában lévő HTTP-kérések által aktivált függvényeket az orchestration elindításához a következő HTTP POST-kérés elküldésével:

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}"}

A vezénylő függvény megkapja a telefonszámot, és azonnal sms-t küld erre a számra egy véletlenszerűen generált 4 jegyű ellenőrző kóddal – például 2168. A függvény ezután 90 másodpercet vár a válaszig.

A kóddal való válaszadáshoz használja a RaiseEventAsync (.NET) vagy raiseEvent (JavaScript és TypeScript) egy másik függvényben, vagy hívja meg a sendEventPostUri HTTP POST végpontot a 202-es válaszban. Cserélje le {eventName} a következőre 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

Ha az eseményt az időzítő lejárta előtt küldi el, a vezénylés befejeződik, és a output mező értéke truea sikeres ellenőrzést jelzi.

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"}

Ha az időzítő lejár, vagy négyszer hibás kódot ad meg, kérdezze le az állapotot, hogy megtudja, output érték lett-e false, ami azt jelzi, hogy a telefonos ellenőrzés sikertelen volt.

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"}

A minta futtatásához:

1. Indítsa el a Durable Task Scheduler emulatort a helyi fejlesztéshez. A Dockert telepíteni kell.

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

2. Indítsa el a feldolgozót a vezénylő és a tevékenységek regisztrálásához.

3. Futtassa a klienst egy jóváhagyási munkafolyamat ütemezése és események küldése érdekében.

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

Ez a minta .NET, JavaScript, Java és Python esetében jelenik meg.

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);

Következő lépések

Ez a minta speciális Durable Functions képességeket mutat be, beleértve a WaitForExternalEvent és CreateTimer API-kat. Bemutatja, hogyan kombinálható a Task.WhenAny (C#), a context.df.Task.any (JavaScript és TypeScript), illetve a context.task_any (Python) a megbízható időtúllépési minta implementálása olyan munkafolyamatokhoz, amelyek megvárják, amíg a felhasználók válaszolnak.

Ismerje meg a Durable Functions kötéseit

• Tartós időzítők
• Külső események és példánykezelés
• Örök zeneművek

Ez a minta bemutatja, hogyan lehet a Durable Task SDK-k használatával olyan munkafolyamatokat implementálni, amelyek várnak az emberek válaszára, konfigurálható időtúllépésekkel. Főbb fogalmak:

• Külső események: WaitForExternalEvent bemenetre való várakozás
• Tartós időzítők: CreateTimeridőtúllépések implementálása
• Versenyfeladatok: A WhenAny, when_any, vagy anyOf használata annak kezelése érdekében, amelyik feladat először fejeződik be

A Durable Task SDK-k használatának első lépései

• Tartós időzítők
• Örök zeneművek
• Tartós feladat JavaScript SDK a GitHubon