Zpracování externích událostí v trvalých orchestracích

Externí události umožňují běžícím orchestracím přijímat signály z externích zdrojů — jako jsou lidská schválení, zpětné volání webhooků nebo jiné systémy. V tomto článku se dozvíte, jak čekat, odesílat a zpracovávat externí události v trvalých orchestracích.

Tip

Chcete odeslat události do orchestrace? Přeskočte na Odeslat události.

Důležité

Support pro model v procesu skončí 10. listopadu 2026. Důrazně doporučujeme migrovat aplikace do izolovaného modelu pracovních procesů pro plnou podporu.

Funkce orchestratoru můžou čekat a naslouchat externím událostem. Tato funkce Durable Functions je často užitečná pro zpracování lidské interakce nebo jiných externích triggerů.

Poznámka:

Externí události jsou jednosměrné asynchronní operace. Nejsou vhodné pro situace, kdy klient odesílající událost potřebuje synchronní odpověď z funkce orchestrátoru.

Orchestrace můžou čekat a naslouchat externím událostem. Tato funkce je často užitečná pro zpracování lidské interakce nebo jiných externích triggerů.

Poznámka:

Externí události jsou jednosměrné asynchronní operace. Nejsou vhodné pro situace, kdy klient odesílající událost potřebuje synchronní odpověď z orchestrace.

Důležité

V současné době není sada POWERShell Durable Task SDK dostupná.

Čekání na externí události

Rozhraní API "wait-for-external-event"vazby spouštěče orchestrace umožňuje funkci orchestrátoru asynchronně čekat a naslouchat na událost doručenou externím klientem. Funkce naslouchače orchestrátoru deklaruje název události a tvar dat, která očekává přijmout.

Rozhraní API "wait-for-external-event" umožňuje orchestraci asynchronně čekat a naslouchat události, kterou doručí externí klient. Orchestrace naslouchání deklaruje název události a strukturu dat, kterou očekává přijmout.

C#

Izolovaný model pracovního procesu

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

Model v probíhajícím procesu

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

Poznámka:

Pokud používáte Durable Functions 1.x, místo DurableOrchestrationContext použijte IDurableOrchestrationContext. Další podrobnosti o konkrétních verzích najdete v článku Durable Functions.

JavaScript

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

Python

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)

Java

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

PowerShell

param($Context)

$approved = Start-DurableExternalEventListener -EventName "Approval"

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

C#

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

Python

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

Java

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

JavaScript

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

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Předchozí příklad naslouchá konkrétní jedné události a provede akci při přijetí události.

Můžete naslouchat více událostem souběžně, například v následujícím příkladu, což čeká na jedno ze tří možných oznámení o událostech.

C#

Izolovaný model pracovního procesu

[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)
    {
        // ...
    }
}

Model v probíhajícím procesu

[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)
    {
        // ...
    }
}

Poznámka:

Používáte Durable Functions 1.x? Vyměňte DurableOrchestrationContext místo IDurableOrchestrationContext. Další informace o jiných rozdílech verzí najdete v článku Durable Functions.

JavaScript

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

Python

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)

Java

@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) {
        // ...
    }
}

PowerShell

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) {
    # ...
}

C#

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

Python

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

Java

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) {
            // ...
        }
    }
}

JavaScript

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

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Předchozí příklad naslouchá libovolné z více událostí. Můžete také počkat na všechny události.

C#

Izolovaný model pracovního procesu

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

Model v probíhajícím procesu

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

Poznámka:

Pokud používáte Durable Functions 1.x, místo DurableOrchestrationContext použijte IDurableOrchestrationContext. Přejděte na Durable Functions verzí pro úplný přehled rozdílů mezi verzemi.

Pokud v .NET nelze datovou část události převést na očekávaný typ T, vyvolá se výjimka.

JavaScript

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

Python

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)

Java

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

PowerShell

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

C#

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

Pokud v .NET nelze datovou část události převést na očekávaný typ T, vyvolá se výjimka.

Python

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)

Java

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

JavaScript

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

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Rozhraní API "wait-for-external-event" čeká na určitý vstup neomezeně dlouho. Aplikaci funkcí můžete bezpečně uvolnit při čekání. Pokud a když událost dorazí pro tuto instanci orchestrace, instance se probouzí automaticky a okamžitě zpracuje událost.

Poznámka:

Pokud vaše aplikace funkcí používá plán využití, nebudou účtovány žádné poplatky za provoz, když funkce orchestrátoru čeká na úkol externí události, bez ohledu na dobu čekání.

Stejně jako aktivní funkce, externí události mají záruku doručení alespoň jednou. To znamená, že za určitých podmínek (například restartování, škálování, chybové ukončení atd.) může vaše aplikace obdržet duplicity stejné externí události. Proto doporučujeme, aby externí události obsahovaly určitý druh ID, který umožňuje jejich ruční deduplikaci v orchestrátorech.

Rozhraní API "wait-for-external-event" čeká na určitý vstup neomezeně dlouho. Během čekání můžete pracovníka bezpečně zastavit. Pokud a když událost dorazí pro tuto instanci orchestrace, probouzí se automaticky a okamžitě zpracuje událost.

Externí události mají alespoň jednou záruku doručení. To znamená, že za určitých podmínek (například restartování, škálování, chybové ukončení atd.) může vaše aplikace obdržet duplicity stejné externí události. Proto doporučujeme, aby externí události obsahovaly určitý druh ID, který jim umožňuje ručně zrušit duplikování v orchestracích.

Odesílání událostí

K odeslání externí události do orchestrace můžete použít rozhraní API "raise-event" definované vazbou klienta orchestrace . K odeslání externí události do orchestrace můžete použít také integrované rozhraní API HTTP pro vyvolání události .

Vyvoláná událost obsahuje parametr instanceID, an eventNamea eventData jako parametry. Funkce orchestratoru wait-for-external-event zpracovávají tyto události pomocí rozhraní API. Aby mohla být událost zpracována, musí se shodovat jak na konci eventName, tak na konci příjmu. Data události musí být také serializovatelná ve formátu JSON.

Mechanismus "raise-event" interně vytvoří frontu zprávy, která je zachycena čekající orchestrátorskou funkcí. Pokud instance nečeká na zadaný název události, přidá se zpráva události do fronty uložené v paměti. Pokud instance orchestrace později začne naslouchat názvu události, zkontroluje frontu pro zprávy událostí.

Poznámka:

Pokud neexistuje žádná instance orchestrace se zadaným ID instance, zpráva události se zahodí.

Níže je příklad funkce aktivované frontou, která odesílá událost Schválení do instance funkce orchestrátoru. ID instance orchestrace pochází z textu zprávy fronty.

K odeslání externí události do orchestrace můžete použít rozhraní API "raise-event" v klientovi Durable Task.

Vyvoláná událost obsahuje ID instance, eventName a eventData jako parametry. Orchestrace zpracovávají tyto události pomocí API "wait-for-external-event". Název události se musí shodovat jak na odesílajícím, tak i přijímajícím konci, aby se událost zpracovávala. Data události musí být také serializovatelná ve formátu JSON.

Interně mechanismy "raise-event" zařadí zprávu do fronty, kterou následně vyzvedne čekající orchestrace. Pokud instance nečeká na zadaný název události, zpráva události se přidá do fronty v operační paměti. Pokud instance orchestrace později začne naslouchat názvu události, zkontroluje frontu zpráv událostí.

Poznámka:

Pokud není k dispozici žádná instance orchestrace se zadaným parametrem instanceID, zpráva události se zahodí.

Níže je příklad, který odešle událost Schválení do instance orchestrace.

C#

Izolovaný model pracovního procesu

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

Model v probíhajícím procesu

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

Poznámka:

Pro Durable Functions 1.x použijte místo toho atribut OrchestrationClient a typ parametru DurableOrchestrationClient. Všechny změny specifické pro verzi najdete v článku Durable Functions.

JavaScript

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

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

Python

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)

Java

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

PowerShell

param($instanceId)

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

C#

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

Python

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

Java

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

JavaScript

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

PowerShell

Sada Durable Task SDK není pro PowerShell k dispozici. Místo toho použijte Durable Functions.

Rozhraní API "raise-event" interně zařadí do fronty zprávu, kterou přijme čekající orchestrace. Pokud instance nečeká na zadaný název události, zpráva události se přidá do vyrovnávací paměti v paměti. Pokud instance orchestrace později začne naslouchat názvu události, zkontroluje vyrovnávací paměť pro zprávy událostí a aktivuje úlohu, která na ni čekala.

Poznámka:

Pokud neexistuje žádná instance orchestrace se zadaným ID instance, zpráva události se zahodí.

HTTP

Následuje příklad požadavku HTTP, který vyvolá Approval událost do instance orchestrace.

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

"true"

V tomto případě je ID instance pevně zakódované jako MyInstanceId.

Osvědčené postupy

Při práci s externími událostmi mějte na paměti následující osvědčené postupy:

Použití jedinečných názvů událostí pro odstranění duplicitních dat

Externí události mají alespoň jednou záruku doručení. Za určitých výjimečných podmínek (ke kterým může dojít při restartování, škálování nebo chybovém ukončení), může vaše aplikace obdržet duplicity stejné externí události. Doporučujeme, aby externí události obsahovaly jedinečné ID, které umožňuje jejich ruční odstranění duplicit v orchestrátorech.

Poznámka:

Poskytovatel úložiště MSSQL využívá externí události a aktualizuje stav orchestrátoru transakcí, takže neexistuje žádné riziko duplicitních událostí s tímto back-endem, na rozdíl od poskytovatele Azure Storage. Přesto se ale doporučuje, aby externí události měly jedinečné názvy, aby byl kód přenosný napříč back-endy.

Využijte časové limity, abyste se vyhnuli nekonečným čekáním.

Rozhraní wait-for-external-event API ve výchozím nastavení čeká na neomezenou dobu. Ve většině reálných scénářů, jako jsou lidská schválení, byste měli udržovat závod mezi durable timer a externí událostí, aby orchestraci mohla provést akci (eskalaci, odmítnutí, opakování), pokud událost nedorazí v rámci daného termínu.

Kompletní návod s ukázkami kódu najdete v tématu Interakce člověka a vypršení časových limitů.

Další kroky

Informace o implementaci zpracování chyb

Spusťte ukázku, která čeká na lidskou interakci

Začínáme se sadami SDK Durable Task