Pola interaksi manusia

Pola interaksi manusia menjelaskan alur kerja yang menjeda dan menunggu input dari seseorang sebelum mereka melanjutkan. Pola ini berguna untuk alur kerja persetujuan, autentikasi multifaktor, dan skenario apa pun di mana seseorang merespons dalam batas waktu.

Pada tingkat tinggi, pola bekerja sebagai berikut:

Orkestrator memanggil aktivitas untuk memberi tahu seseorang (mengirim kode SMS, mengirim email kepada pemberi izin, dll.).
Orkestrator memulai timer tahan lama dan secara bersamaan menunggu peristiwa eksternal dari orang tersebut.
Jika orang tersebut merespons sebelum timer diaktifkan, orkestrator memproses respons.
Jika timer diaktifkan terlebih dahulu, orkestrator menangani batas waktu (misalnya, dengan menolak permintaan).

Dalam artikel ini:

Gambaran umum skenario interaksi manusia - Mengapa pola ini penting
Tentukan orkestrator - Menerapkan balapan antara timer dan event
Menentukan aktivitas - Mengirim pemberitahuan dan hasil proses
Jalankan sampel interaksi manusia - Uji alur kerja secara end to end

Nota

Pivot Durable Functions dan Durable Task SDK menunjukkan pola yang sama dengan skenario yang berbeda: Durable Functions menggunakan contoh verifikasi telepon melalui SMS, sementara Durable Task SDKs menggunakan contoh alur kerja persetujuan.

Sampel ini menunjukkan cara membangun orkestrasi Durable Functions yang mencakup interaksi manusia. Contoh menerapkan sistem verifikasi telepon berbasis SMS. Ini umum dalam verifikasi nomor telepon dan alur autentikasi multifaktor (MFA).

Nota

Sampel kode lengkap tersedia untuk C#, JavaScript, dan Python. Sampel PowerShell dan Java saat ini tidak tersedia.

Nota

Model pemrograman Node.js versi 4 untuk Azure Functions umumnya tersedia. Model v4 dirancang untuk memberikan pengalaman yang lebih fleksibel dan intuitif bagi pengembang JavaScript dan TypeScript. Untuk informasi selengkapnya tentang perbedaan antara v3 dan v4, lihat panduan migrasi.

Dalam cuplikan kode berikut, JavaScript (PM4) menunjukkan model pemrograman v4, pengalaman baru.

Prasyarat

Menyelesaikan artikel pengantar cepat
Mengkloning atau mengunduh proyek sampel dari GitHub (menggunakan model dalam proses)

Artikel ini memperlihatkan cara menerapkan pola interaksi manusia dengan menggunakan SDK Tugas Tahan Lama. Contoh menerapkan alur kerja persetujuan di mana orkestrasi menunggu seseorang menyetujui atau menolak permintaan sebelum berlanjut.

Gambaran umum skenario interaksi manusia

Verifikasi telepon membantu mengonfirmasi bahwa orang yang menggunakan aplikasi Anda bukan spammer dan bahwa mereka mengontrol nomor telepon yang mereka berikan. Autentikasi multifaktor adalah cara umum untuk melindungi akun. Membangun verifikasi ponsel milik Anda sendiri memerlukan interaksi berbasis status dengan seseorang. Pengguna biasanya mendapatkan kode (misalnya, angka empat digit) dan harus merespons dalam jumlah waktu yang wajar.

Azure Functions standar tidak menyimpan status (seperti banyak titik akhir cloud lainnya), sehingga jenis interaksi ini memerlukan Anda untuk menyimpan status dalam database atau penyimpanan persisten lainnya. Anda juga membagi interaksi di beberapa fungsi dan mengoordinasikannya. Misalnya, satu fungsi menghasilkan kode, menyimpannya, dan mengirimkannya ke ponsel pengguna. Fungsi lain menerima respons pengguna dan memetakannya ke permintaan asli untuk memvalidasi kode. Tambahkan batas waktu untuk membantu melindungi keamanan. Alur kerja ini menjadi rumit dengan cepat.

Durable Functions mengurangi kompleksitas skenario ini. Dalam sampel ini, fungsi orkestrator mengelola interaksi stateful tanpa penyimpanan data eksternal. Karena fungsi orkestrator tahan lama, alur interaktif ini sangat dapat diandalkan.

Alur kerja persetujuan umum dalam aplikasi bisnis di mana permintaan harus ditinjau oleh manusia sebelum melanjutkan. Persyaratan alur kerja adalah:

Tunggu selama mungkin untuk respons manusia, atau hingga waktu habis
Menangani hasil persetujuan dan penolakan
Batas waktu dukungan saat tidak ada respons yang diterima
Melacak status sehingga pemohon dapat memeriksa kemajuan

SDK Durable Task menyederhanakan skenario ini dengan:

Peristiwa eksternal: Orkestrasi dapat menjeda dan menunggu peristiwa yang diangkat oleh sistem atau pengguna eksternal
Timer tahan lama: Atur batas waktu yang diaktifkan jika tidak ada respons yang diterima
Status kustom: Melacak dan mengekspos status alur kerja saat ini ke klien

Mengonfigurasi integrasi Twilio

Sampel ini melibatkan penggunaan layanan Twilio untuk mengirim pesan SMS ke ponsel. Azure Functions sudah memiliki dukungan untuk Twilio melalui pengikatan Twilio, dan sampel menggunakan fitur tersebut.

Hal pertama yang Anda butuhkan adalah akun Twilio. Anda dapat membuat akun gratis di https://www.twilio.com/try-twilio. Setelah memiliki akun, tambahkan tiga pengaturan aplikasi berikut ke aplikasi fungsi Anda.

Nama pengaturan aplikasi	Deskripsi nilai
TwilioAccountSid	SID untuk akun Twilio Anda
TwilioAuthToken	Token Auth untuk akun Twilio Anda
TwilioPhoneNumber	Nomor telepon yang terkait dengan akun Twilio Anda. Ini digunakan untuk mengirim pesan SMS.

Tentukan orkestrator

Fungsi orkestrator E4_SmsPhoneVerification

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

Nota

Awalnya mungkin tidak jelas, tetapi orkestrator ini tidak melanggar batasan orkestrasi deterministik. Ini deterministik karena CurrentUtcDateTime properti menghitung waktu kedaluwarsa timer, dan mengembalikan nilai yang sama pada setiap pemutaran ulang pada titik ini dalam kode orkestrator. Perilaku ini memastikan bahwa winner sama untuk setiap panggilan berulang ke Task.WhenAny.

Model pemrograman V3

Fungsi E4_SmsPhoneVerification menggunakan standar function.json untuk fungsi orkestrator.

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

Berikut adalah kode yang mengimplementasikan fungsi :

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

Nota

Awalnya mungkin tidak jelas, tetapi orkestrator ini tidak melanggar batasan orkestrasi deterministik. Ini deterministik karena currentUtcDateTime properti menghitung waktu kedaluwarsa timer, dan mengembalikan nilai yang sama pada setiap pemutaran ulang pada titik ini dalam kode orkestrator. Perilaku ini memastikan bahwa winner sama untuk setiap panggilan berulang ke context.df.Task.any.

Model pemrograman V4

Berikut adalah kode yang mengimplementasikan smsPhoneVerification fungsi orkestrasi:

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

Fungsi E4_SmsPhoneVerification menggunakan standar function.json untuk fungsi orkestrator.

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

Berikut adalah kode yang mengimplementasikan fungsi :

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)

Nota

Awalnya mungkin tidak jelas, tetapi orkestrator ini tidak melanggar batasan orkestrasi deterministik. Hal ini bersifat deterministik karena properti currentUtcDateTime digunakan untuk menghitung waktu kedaluwarsa timer, dan mengembalikan nilai yang sama pada setiap pemutaran ulang pada titik ini dalam kode orkestrator. Perilaku ini penting untuk memastikan bahwa setiap panggilan berulang ke winner menghasilkan hasil context.df.Task.any yang sama.

Setelah dimulai, fungsi orkestrator ini melakukan hal berikut:

Mendapatkan nomor telepon untuk mengirim pemberitahuan SMS.
Memanggil E4_SendSmsChallenge untuk mengirim pesan SMS kepada pengguna dan mengembalikan kode tantangan empat digit yang diharapkan.
Membuat timer tahan lama yang memicu 90 detik setelah waktu saat ini.
Sejalan dengan timer, menunggu peristiwa SmsChallengeResponse dari pengguna.

Pengguna menerima pesan SMS dengan kode empat digit. Mereka memiliki 90 detik untuk mengirim kode yang sama ke instans orkestrator untuk menyelesaikan verifikasi. Jika mereka mengirimkan kode yang salah, mereka mendapatkan tiga percobaan lagi dalam jendela 90 detik yang sama.

Peringatan

Batalkan timer yang tidak lagi Anda butuhkan. Dalam contoh di atas, orkestrasi membatalkan timer ketika menerima respons tantangan.

Orkestrator mengirimkan permintaan persetujuan, lalu menunggu respons manusia atau batas waktu.

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

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

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

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

Orkestrator ini melakukan tindakan berikut:

Mengajukan permintaan persetujuan dengan memanggil fungsi yang memberi tahu penyetuju.
Mengatur status kustom sehingga klien dapat melacak kemajuan.
Membuat timer berdaya tahan untuk batas waktu kedaluwarsa.
Menunggu peristiwa eksternal (approval_response) yang dipicu oleh pemberi persetujuan.
Menggunakan WhenAny, when_any, atau anyOf untuk menunggu mana yang selesai terlebih dahulu: persetujuan atau batas waktu.
Memproses hasil berdasarkan tugas mana yang selesai.

Peringatan

Batalkan timer yang tidak lagi Anda butuhkan. Dalam contoh C#, orkestrasi membatalkan timer batas waktu saat menerima persetujuan.

Menentukan aktivitas

Fungsi aktivitas E4_SendSmsChallenge

Fungsi E4_SendSmsChallenge menggunakan pengikatan Twilio untuk mengirim pesan SMS yang menyertakan kode empat digit kepada pengguna.

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

Nota

Untuk menjalankan sampel, instal paket NuGet Microsoft.Azure.WebJobs.Extensions.Twilio. Jangan instal paket Twilio NuGet utama karena dapat menyebabkan konflik versi dan kesalahan build.

Model pemrograman V3

File function.json didefinisikan seperti ini:

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

Kode ini menghasilkan kode tantangan empat digit dan mengirim pesan 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);
};

Model pemrograman V4

Berikut adalah kode yang menghasilkan kode tantangan empat digit dan mengirim pesan 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;
    },
});

File function.json didefinisikan seperti ini:

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

Kode ini menghasilkan kode tantangan empat digit dan mengirim pesan 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

Aktivitas mengirimkan permintaan persetujuan dan memproses respons.

Mengajukan aktivitas permintaan persetujuan

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

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

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

Sampel Java mengirimkan permintaan persetujuan sebaris. Untuk aplikasi produksi, buat aktivitas terpisah:

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

Aktivitas persetujuan proses

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

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

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
    }

Menjalankan sampel interaksi manusia

Gunakan fungsi yang dipicu HTTP dalam sampel untuk memulai orkestrasi dengan mengirim permintaan HTTP POST berikut:

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

Fungsi orkestrator menerima nomor telepon dan segera mengirim pesan SMS ke nomor tersebut dengan kode verifikasi 4 digit yang dihasilkan secara acak—misalnya, 2168. Lalu, Fungsi tersebut menunggu 90 detik untuk merespons.

Untuk membalas dengan kode, gunakan RaiseEventAsync (.NET) atau raiseEvent (JavaScript dan TypeScript) di fungsi lain, atau panggil titik akhir sendEventPostUri HTTP POST dalam respons 202. Ganti {eventName} dengan 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

Jika Anda mengirim peristiwa sebelum timer kedaluwarsa, orkestrasi selesai, dan output bidang diatur ke true, yang menunjukkan verifikasi yang berhasil.

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

Jika timer kedaluwarsa atau Anda memasukkan kode yang salah empat kali, periksa status untuk melihat output ditetapkan menjadi false, yang menunjukkan bahwa verifikasi telepon gagal.

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

Untuk menjalankan sampel:

Mulai emulator Durable Task Scheduler untuk pengembangan lokal. Docker harus diinstal.

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

Mulai pekerja untuk mendaftarkan orkestrator dan aktivitas.
Jalankan klien untuk menjadwalkan alur kerja persetujuan dan mengirim peristiwa.

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

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

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

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

Langkah berikutnya

Sampel ini menunjukkan kemampuan Durable Functions tingkat lanjut, termasuk API WaitForExternalEvent dan CreateTimer. Ini menunjukkan cara menggabungkan Task.WhenAny (C#), context.df.Task.any (JavaScript dan TypeScript), atau context.task_any (Python) untuk menerapkan pola waktu habis yang andal untuk alur kerja yang menunggu orang merespons.

Pelajari konsep binding pada Durable Functions

Sampel ini menunjukkan cara menggunakan SDK Tugas Tahan Lama untuk menerapkan alur kerja yang menunggu orang merespons, dengan batas waktu yang dapat dikonfigurasi. Konsep utama:

Peristiwa eksternal: Menggunakan WaitForExternalEvent untuk menunggu input
Timer tahan lama: Menggunakan CreateTimer untuk mengimplementasikan batas waktu
Tugas balapan: Menggunakan WhenAny, when_any, atau anyOf untuk menangani tugas mana pun yang selesai terlebih dahulu

Mulai menggunakan Durable Task SDK

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-04-28

Pola interaksi manusia

Prasyarat

Gambaran umum skenario interaksi manusia

Mengonfigurasi integrasi Twilio

Tentukan orkestrator

Fungsi orkestrator E4_SmsPhoneVerification

Menentukan aktivitas

Fungsi aktivitas E4_SendSmsChallenge

Mengajukan aktivitas permintaan persetujuan

Aktivitas persetujuan proses

Menjalankan sampel interaksi manusia

Langkah berikutnya

Saran dan Komentar

Sumber Daya Tambahan: