外部イベントの処理

オーケストレーター関数は、外部イベントを待機してからリッスンできます。 Durable Functionsのこの機能は、多くの場合、人間の相互作用やその他の外部トリガーを処理するために役立ちます。

注

外部イベントは一方向の非同期操作です。イベントを送信するクライアントがオーケストレーター関数からの同期応答を必要とする状況には適していません。

オーケストレーションは外部イベントを待機して待つことができます。この機能は、多くの場合、人間の操作やその他の外部トリガーを処理する場合に役立ちます。

注

外部イベントは一方向の非同期操作です。イベントを送信するクライアントがオーケストレーションからの同期応答を必要とする状況には適していません。

Important

現在、PowerShell Durable Task SDK は使用できません。

イベントを待機する

オーケストレーショントリガーバインドの "wait-for-external-event" API を使用すると、オーケストレーター関数は外部クライアントによって配信されたイベントを非同期的に待機してリッスンできます。リッスンオーケストレーター関数は、イベントの名前と、受信する データの形状 を宣言します。

"wait-for-external-event" API を使用すると、オーケストレーションは外部クライアントによって配信されたイベントを非同期的に待機してリッスンできます。待機しているオーケストレーションは、イベントの名前と、受信する データの形状 を宣言します。

分離ワーカーモデル

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

public class BudgetApproval
{
    private readonly ILogger _logger;

    public BudgetApproval(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<BudgetApproval>();
    }

    [Function("BudgetApproval")]
    public async Task Run(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        bool approved = await context.WaitForExternalEventAsync<bool>("Approval");
        if (approved)
        {
            // approval granted - do the approved action
        }
        else
        {
            // approval denied - send a notification
        }
    }
}

インプロセスモデル

[FunctionName("BudgetApproval")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    bool approved = await context.WaitForExternalEvent<bool>("Approval");
    if (approved)
    {
        // approval granted - do the approved action
    }
    else
    {
        // approval denied - send a notification
    }
}

注

Durable Functions 1.x を使用している場合は、DurableOrchestrationContext の代わりに IDurableOrchestrationContext を使用します。バージョン固有の詳細については、Durable Functions バージョンに関する記事を参照してください。

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

module.exports = df.orchestrator(function*(context) {
    const approved = yield context.df.waitForExternalEvent("Approval");
    if (approved) {
        // approval granted - do the approved action
    } else {
        // approval denied - send a notification
    }
});

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    approved = yield context.wait_for_external_event('Approval')
    if approved:
        # approval granted - do the approved action
    else:
        # approval denied - send a notification

main = df.Orchestrator.create(orchestrator_function)

@FunctionName("WaitForExternalEvent")
public void waitForExternalEvent(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    boolean approved = ctx.waitForExternalEvent("Approval", boolean.class).await();
    if (approved) {
        // approval granted - do the approved action
    } else {
        // approval denied - send a notification
    }
}

param($Context)

$approved = Start-DurableExternalEventListener -EventName "Approval"

if ($approved) {
    # approval granted - do the approved action
} else {
    # approval denied - send a notification
}

public class BudgetApproval : TaskOrchestrator<object?, bool>
{
    public override async Task<bool> RunAsync(TaskOrchestrationContext context, object? input)
    {
        bool approved = await context.WaitForExternalEvent<bool>("Approval");
        if (approved)
        {
            // approval granted - do the approved action
        }
        else
        {
            // approval denied - send a notification
        }
        return approved;
    }
}

from durabletask import task

def budget_approval(ctx: task.OrchestrationContext, _):
    approved = yield ctx.wait_for_external_event("Approval")
    if approved:
        # approval granted - do the approved action
        pass
    else:
        # approval denied - send a notification
        pass
    return approved

public class BudgetApproval implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        boolean approved = ctx.waitForExternalEvent("Approval", boolean.class).await();
        if (approved) {
            // approval granted - do the approved action
        } else {
            // approval denied - send a notification
        }
    }
}

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

const budgetApproval: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const approved = yield ctx.waitForExternalEvent("Approval");
    if (approved) {
        // approval granted - do the approved action
    } else {
        // approval denied - send a notification
    }
    return approved;
};

前の例では、特定の 1 つのイベントをリッスンし、イベントの受信時にアクションを実行します。

次の例のように、複数のイベントを同時にリッスンできます。この例では、3 つのイベント通知のうち 1 つを待機します。

分離ワーカーモデル

[Function("Select")]
public async Task Run(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    Task<float> event1 = context.WaitForExternalEventAsync<float>("Event1");
    Task<bool> event2 = context.WaitForExternalEventAsync<bool>("Event2");
    Task<int> event3 = context.WaitForExternalEventAsync<int>("Event3");

    Task winner = await Task.WhenAny(event1, event2, event3);
    if (winner == event1)
    {
        // ...
    }
    else if (winner == event2)
    {
        // ...
    }
    else if (winner == event3)
    {
        // ...
    }
}

インプロセスモデル

[FunctionName("Select")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var event1 = context.WaitForExternalEvent<float>("Event1");
    var event2 = context.WaitForExternalEvent<bool>("Event2");
    var event3 = context.WaitForExternalEvent<int>("Event3");

    var winner = await Task.WhenAny(event1, event2, event3);
    if (winner == event1)
    {
        // ...
    }
    else if (winner == event2)
    {
        // ...
    }
    else if (winner == event3)
    {
        // ...
    }
}

注

Durable Functions 1.x を使用していますか? DurableOrchestrationContextではなく、IDurableOrchestrationContextでスワップします。その他のバージョンの違いについては、Durable Functionsバージョンに関する記事を参照してください。

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

module.exports = df.orchestrator(function*(context) {
    const event1 = context.df.waitForExternalEvent("Event1");
    const event2 = context.df.waitForExternalEvent("Event2");
    const event3 = context.df.waitForExternalEvent("Event3");

    const winner = yield context.df.Task.any([event1, event2, event3]);
    if (winner === event1) {
        // ...
    } else if (winner === event2) {
        // ...
    } else if (winner === event3) {
        // ...
    }
});

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    event1 = context.wait_for_external_event('Event1')
    event2 = context.wait_for_external_event('Event2')
    event3 = context.wait_for_external_event('Event3')

    winner = yield context.task_any([event1, event2, event3])
    if winner == event1:
        # ...
    elif winner == event2:
        # ...
    elif winner == event3:
        # ...

main = df.Orchestrator.create(orchestrator_function)

@FunctionName("Select")
public void selectOrchestrator(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    Task<Void> event1 = ctx.waitForExternalEvent("Event1");
    Task<Void> event2 = ctx.waitForExternalEvent("Event2");
    Task<Void> event3 = ctx.waitForExternalEvent("Event3");

    Task<?> winner = ctx.anyOf(event1, event2, event3).await();
    if (winner == event1) {
        // ...
    } else if (winner == event2) {
        // ...
    } else if (winner == event3) {
        // ...
    }
}

param($Context)

$event1 = Start-DurableExternalEventListener -EventName "Event1" -NoWait
$event2 = Start-DurableExternalEventListener -EventName "Event2" -NoWait
$event3 = Start-DurableExternalEventListener -EventName "Event3" -NoWait

$winner = Wait-DurableTask -Task @($event1, $event2, $event3) -Any

if ($winner -eq $event1) {
    # ...
} else if ($winner -eq $event2) {
    # ...
} else if ($winner -eq $event3) {
    # ...
}

public class SelectOrchestrator : TaskOrchestrator<object?, object?>
{
    public override async Task<object?> RunAsync(TaskOrchestrationContext context, object? input)
    {
        Task<float> event1 = context.WaitForExternalEvent<float>("Event1");
        Task<bool> event2 = context.WaitForExternalEvent<bool>("Event2");
        Task<int> event3 = context.WaitForExternalEvent<int>("Event3");

        Task winner = await Task.WhenAny(event1, event2, event3);
        if (winner == event1)
        {
            // ...
        }
        else if (winner == event2)
        {
            // ...
        }
        else if (winner == event3)
        {
            // ...
        }
        return null;
    }
}

from durabletask import task

def select_orchestrator(ctx: task.OrchestrationContext, _):
    event1 = ctx.wait_for_external_event("Event1")
    event2 = ctx.wait_for_external_event("Event2")
    event3 = ctx.wait_for_external_event("Event3")

    winner = yield task.when_any([event1, event2, event3])
    if winner == event1:
        # ...
        pass
    elif winner == event2:
        # ...
        pass
    elif winner == event3:
        # ...
        pass

public class SelectOrchestrator implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        Task<Void> event1 = ctx.waitForExternalEvent("Event1");
        Task<Void> event2 = ctx.waitForExternalEvent("Event2");
        Task<Void> event3 = ctx.waitForExternalEvent("Event3");

        Task<?> winner = ctx.anyOf(event1, event2, event3).await();
        if (winner == event1) {
            // ...
        } else if (winner == event2) {
            // ...
        } else if (winner == event3) {
            // ...
        }
    }
}

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

const selectOrchestrator: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const event1 = ctx.waitForExternalEvent("Event1");
    const event2 = ctx.waitForExternalEvent("Event2");
    const event3 = ctx.waitForExternalEvent("Event3");

    const winner = yield whenAny([event1, event2, event3]);
    if (winner === event1) {
        // ...
    } else if (winner === event2) {
        // ...
    } else if (winner === event3) {
        // ...
    }
};

前の例では、複数のイベント のいずれかを リッスンします。 すべてのイベントを待機することもできます。

分離ワーカーモデル

[Function("NewBuildingPermit")]
public async Task Run(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    string applicationId = context.GetInput<string>();

    Task gate1 = context.WaitForExternalEventAsync<object>("CityPlanningApproval");
    Task gate2 = context.WaitForExternalEventAsync<object>("FireDeptApproval");
    Task gate3 = context.WaitForExternalEventAsync<object>("BuildingDeptApproval");

    // all three departments must grant approval before a permit can be issued
    await Task.WhenAll(gate1, gate2, gate3);

    await context.CallActivityAsync("IssueBuildingPermit", applicationId);
}

インプロセスモデル

[FunctionName("NewBuildingPermit")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    string applicationId = context.GetInput<string>();

    var gate1 = context.WaitForExternalEvent("CityPlanningApproval");
    var gate2 = context.WaitForExternalEvent("FireDeptApproval");
    var gate3 = context.WaitForExternalEvent("BuildingDeptApproval");

    // all three departments must grant approval before a permit can be issued
    await Task.WhenAll(gate1, gate2, gate3);

    await context.CallActivityAsync("IssueBuildingPermit", applicationId);
}

注

1.x Durable Functions実行している場合は、DurableOrchestrationContext の代わりに IDurableOrchestrationContext を使用します。バージョンの違いの詳細については、Durable Functions バージョンに進みます。

.NETでは、イベントペイロードを予期される型 T に変換できない場合は、例外がスローされます。

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

module.exports = df.orchestrator(function*(context) {
    const applicationId = context.df.getInput();

    const gate1 = context.df.waitForExternalEvent("CityPlanningApproval");
    const gate2 = context.df.waitForExternalEvent("FireDeptApproval");
    const gate3 = context.df.waitForExternalEvent("BuildingDeptApproval");

    // all three departments must grant approval before a permit can be issued
    yield context.df.Task.all([gate1, gate2, gate3]);

    yield context.df.callActivity("IssueBuildingPermit", applicationId);
});

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    application_id = context.get_input()

    gate1 = context.wait_for_external_event('CityPlanningApproval')
    gate2 = context.wait_for_external_event('FireDeptApproval')
    gate3 = context.wait_for_external_event('BuildingDeptApproval')

    yield context.task_all([gate1, gate2, gate3])
    yield context.call_activity('IssueBuildingPermit', application_id)

main = df.Orchestrator.create(orchestrator_function)

@FunctionName("NewBuildingPermit")
public void newBuildingPermit(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    String applicationId = ctx.getInput(String.class);

    Task<Void> gate1 = ctx.waitForExternalEvent("CityPlanningApproval");
    Task<Void> gate2 = ctx.waitForExternalEvent("FireDeptApproval");
    Task<Void> gate3 = ctx.waitForExternalEvent("BuildingDeptApproval");

    // all three departments must grant approval before a permit can be issued
    ctx.allOf(List.of(gate1, gate2, gate3)).await();

    ctx.callActivity("IssueBuildingPermit", applicationId).await();
}

param($Context)

$applicationId = $Context.Input
$gate1 = Start-DurableExternalEventListener -EventName "CityPlanningApproval" -NoWait
$gate2 = Start-DurableExternalEventListener -EventName "FireDeptApproval" -NoWait
$gate3 = Start-DurableExternalEventListener -EventName "BuildingDeptApproval" -NoWait

Wait-DurableTask -Task @($gate1, $gate2, $gate3)

Invoke-ActivityFunction -FunctionName 'IssueBuildingPermit' -Input $applicationId

public class NewBuildingPermit : TaskOrchestrator<string, object?>
{
    public override async Task<object?> RunAsync(TaskOrchestrationContext context, string applicationId)
    {
        Task<object?> gate1 = context.WaitForExternalEvent<object?>("CityPlanningApproval");
        Task<object?> gate2 = context.WaitForExternalEvent<object?>("FireDeptApproval");
        Task<object?> gate3 = context.WaitForExternalEvent<object?>("BuildingDeptApproval");

        // all three departments must grant approval before a permit can be issued
        await Task.WhenAll(gate1, gate2, gate3);

        await context.CallActivityAsync("IssueBuildingPermit", applicationId);
        return null;
    }
}

.NETでは、イベントペイロードを予期される型 T に変換できない場合は、例外がスローされます。

from durabletask import task

def issue_building_permit(ctx: task.ActivityContext, application_id: str) -> None:
    # Issue the permit
    pass

def new_building_permit(ctx: task.OrchestrationContext, application_id: str):
    gate1 = ctx.wait_for_external_event("CityPlanningApproval")
    gate2 = ctx.wait_for_external_event("FireDeptApproval")
    gate3 = ctx.wait_for_external_event("BuildingDeptApproval")

    # all three departments must grant approval before a permit can be issued
    yield task.when_all([gate1, gate2, gate3])
    yield ctx.call_activity(issue_building_permit, input=application_id)

public class NewBuildingPermit implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        String applicationId = ctx.getInput(String.class);

        Task<Void> gate1 = ctx.waitForExternalEvent("CityPlanningApproval");
        Task<Void> gate2 = ctx.waitForExternalEvent("FireDeptApproval");
        Task<Void> gate3 = ctx.waitForExternalEvent("BuildingDeptApproval");

        // all three departments must grant approval before a permit can be issued
        ctx.allOf(List.of(gate1, gate2, gate3)).await();

        ctx.callActivity("IssueBuildingPermit", applicationId).await();
    }
}

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

const issueBuildingPermit = async (_: ActivityContext, applicationId: string): Promise<void> => {
    // Issue the permit
};

const newBuildingPermit: TOrchestrator = async function* (
    ctx: OrchestrationContext,
    applicationId: string,
): any {
    const gate1 = ctx.waitForExternalEvent("CityPlanningApproval");
    const gate2 = ctx.waitForExternalEvent("FireDeptApproval");
    const gate3 = ctx.waitForExternalEvent("BuildingDeptApproval");

    // all three departments must grant approval before a permit can be issued
    yield whenAll([gate1, gate2, gate3]);
    yield ctx.callActivity(issueBuildingPermit, applicationId);
};

"wait-for-external-event" API は、何らかの入力を無期限に待機します。待機中に関数アプリを安全にアンロードできます。このオーケストレーションインスタンスのイベントが到着した場合、インスタンスは自動的に起動され、すぐにイベントが処理されます。

注

関数アプリで従量課金プランを使用している場合、オーケストレーター関数が外部イベントタスクを待機している間、待機時間に関係なく課金料金は発生しません。

アクティビティ関数と同様に、外部イベントには 少なくとも 1 回の 配信保証があります。つまり、特定の条件下 (再起動、スケーリング、クラッシュなど) では、アプリケーションが同じ外部イベントの重複を受け取る可能性があります。そのため、外部イベントには、オーケストレーターで手動で重複を解除できる何らかの種類の ID が含まれていることをお勧めします。

"wait-for-external-event" API は、何らかの入力を無期限に待機します。待機中にワーカーを安全に停止できます。このオーケストレーションインスタンスのイベントが到着した場合、イベントは自動的に起動され、すぐにイベントが処理されます。

外部イベントには、 少なくとも 1 回の 配信保証があります。つまり、特定の条件下 (再起動、スケーリング、クラッシュなど) では、アプリケーションが同じ外部イベントの重複を受け取る可能性があります。そのため、外部イベントには、オーケストレーションで手動で重複を解除できる何らかの ID が含まれていることをお勧めします。

イベントを送信する

オーケストレーションクライアント バインドによって定義された "raise-event" API を使用して、外部イベントをオーケストレーションに送信できます。組み込みの raise イベント HTTP API を使用して、オーケストレーションに外部イベントを送信することもできます。

発生したイベントには、パラメーターとして instanceID、 eventName、および eventData が含まれます。オーケストレーター関数は、 wait-for-external-event API を使用してこれらのイベントを処理します。 eventNameは、イベントを処理するために、送信側と受信側の両方で一致する必要があります。イベントデータも JSON シリアル化可能である必要があります。

内部的には、 "raise-event" メカニズムは、待機中のオーケストレーター関数によって取得されるメッセージをエンキューします。インスタンスが指定された イベント名 を待機していない場合、イベントメッセージはメモリ内キューに追加されます。オーケストレーションインスタンスが後でその イベント名 のリッスンを開始すると、キューでイベントメッセージがチェックされます。

注

指定したインスタンス ID を持つオーケストレーションインスタンスがない場合、イベントメッセージは破棄されます。

オーケストレーター関数インスタンスに "Approval" イベントを送信するキューによってトリガーされる関数の例を次に示します。オーケストレーションインスタンス ID は、キューメッセージの本文から取得されます。

Durable Task クライアントで "raise-event" API を使用して、オーケストレーションに外部イベントを送信できます。

発生したイベントには、 インスタンス ID、 eventName、および eventData がパラメーターとして含まれます。オーケストレーションは 、"wait-for-external-event" API を使用してこれらのイベントを処理します。イベントを処理するには、送信側と受信側の両方で eventName が一致する必要があります。イベントデータも JSON シリアル化可能である必要があります。

内部では、"raise-event" メカニズムは、待機中のオーケストレーションによって取得されるメッセージをキューに入れます。インスタンスが指定された イベント名 を待機していない場合、イベントメッセージはメモリ内キューに追加されます。オーケストレーションインスタンスが後でその イベント名 のリッスンを開始すると、キューでイベントメッセージがチェックされます。

注

指定した instanceIDを持つオーケストレーションインスタンスがない場合、イベントメッセージは破棄されます。

オーケストレーションインスタンスに "Approval" イベントを送信する例を次に示します。

分離ワーカーモデル

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

public class ApprovalQueueProcessor
{
    [Function("ApprovalQueueProcessor")]
    public async Task Run(
        [QueueTrigger("approval-queue")] string instanceId,
        [DurableClient] DurableTaskClient client)
    {
        await client.RaiseEventAsync(instanceId, "Approval", true);
    }
}

インプロセスモデル

[FunctionName("ApprovalQueueProcessor")]
public static async Task Run(
    [QueueTrigger("approval-queue")] string instanceId,
    [DurableClient] IDurableOrchestrationClient client)
{
    await client.RaiseEventAsync(instanceId, "Approval", true);
}

注

Durable Functions 1.x の場合は、代わりに OrchestrationClient 属性と DurableOrchestrationClient パラメーター型を使用します。 Durable Functions のバージョンに特化した変更点をすべて確認できる記事をご覧ください。

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

module.exports = async function(context, instanceId) {
    const client = df.getClient(context);
    await client.raiseEvent(instanceId, "Approval", true);
};

import azure.functions as func
import azure.durable_functions as df

async def main(instance_id:str, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)
    await client.raise_event(instance_id, 'Approval', True)

@FunctionName("ApprovalQueueProcessor")
public void approvalQueueProcessor(
        @QueueTrigger(name = "instanceID", queueName = "approval-queue") String instanceID,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {
    durableContext.getClient().raiseEvent(instanceID, "Approval", true);
}

param($instanceId)

Send-DurableExternalEvent -InstanceId $InstanceId -EventName "Approval"

内部的には、"raise-event" API は、待機中のオーケストレーター関数によって取得されるメッセージをエンキューします。インスタンスが指定された イベント名 を待機していない場合、イベントメッセージはメモリ内バッファーに追加されます。オーケストレーションインスタンスが後でその イベント名 のリッスンを開始すると、バッファーでイベントメッセージがチェックされ、待機していたタスクがトリガーされます。

注

指定したインスタンス ID を持つオーケストレーション インスタンスがない場合、イベントメッセージは破棄されます。

await client.RaiseEventAsync(instanceId, "Approval", true);

client.raise_orchestration_event(instance_id, "Approval", data=True)

client.raiseEvent(instanceId, "Approval", true);

await client.raiseOrchestrationEvent(instanceId, "Approval", true);

内部的には、"raise-event" API は、待機中のオーケストレーションによって取得されるメッセージをエンキューします。インスタンスが指定された イベント名 を待機していない場合、イベントメッセージはメモリ内バッファーに追加されます。オーケストレーションインスタンスが後でその イベント名 のリッスンを開始すると、バッファーでイベントメッセージがチェックされ、待機していたタスクがトリガーされます。

注

指定したインスタンス ID を持つオーケストレーション インスタンスがない場合、イベントメッセージは破棄されます。

HTTP

オーケストレーションインスタンスに対して Approval イベントを発生させる HTTP 要求の例を次に示します。

POST /runtime/webhooks/durabletask/instances/MyInstanceId/raiseEvent/Approval&code=XXX
Content-Type: application/json

"true"

この場合、インスタンス ID は MyInstanceId としてハードコーディングされます。

外部イベントのベストプラクティス

外部イベントを操作するときは、次のベストプラクティスに留意してください。

重複除去に一意のイベント名を使用する

外部イベントには、 少なくとも 1 回の 配信保証があります。特定のまれな状況 (再起動、スケーリング、またはクラッシュ中に発生する可能性があります) では、アプリケーションが同じ外部イベントの重複を受け取る可能性があります。外部イベントには、オーケストレーターで手動で重複除去できるようにする一意の ID が含まれていることをお勧めします。

注

MSSQL ストレージプロバイダーは、外部イベントを使用し、オーケストレーターの状態をトランザクションで更新するため、Azure Storage プロバイダーとは異なり、そのバックエンドでイベントが重複するリスクはありません。ただし、外部イベントには一意の名前を付け、バックエンド間でコードを移植できるようにすることをお勧めします。

次のステップ

エラー処理を実装する方法について説明します

人間の操作を待機するサンプルを実行する

Durable Task SDK で始める

フィードバック

このページはお役に立ちましたか?

Last updated on 2026-03-06

次の方法で共有

外部イベントの処理

イベントを待機する

イベントを送信する

HTTP

外部イベントのベスト プラクティス

重複除去に一意のイベント名を使用する

次のステップ

フィードバック

その他のリソース

外部イベントのベストプラクティス