Külső események kezelése a Durable Functionsben (Azure Functions)

Az Orchestrator-függvények képesek várni és figyelni a külső eseményeket. A Durable Functions ezen funkciója gyakran hasznos emberi interakciók vagy más külső eseményindítók kezelésére.

Feljegyzés

A külső események egyirányú aszinkron műveletek. Nem alkalmasak olyan helyzetekre, amikor az eseményt küldő ügyfélnek szinkron választ kell adni a vezénylő függvénytől.

Várakozás eseményekre

A vezénylési trigger kötésének "wait-for-external-event" API-ja lehetővé teszi, hogy a vezénylő függvény aszinkron módon várja meg és figyelje a külső ügyfél által küldött eseményeket. A figyelő vezénylő függvény deklarálja az esemény nevét és a várható adatok alakját.

C#

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

Feljegyzés

Az előző C# kód a Durable Functions 2.x-hez készült. A Durable Functions 1.x esetén a helyett IDurableOrchestrationContexta DurableOrchestrationContext . A verziók közötti különbségekről további információt a Durable Functions verzióiról szóló cikkben talál.

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

PowerShell

param($Context)

$approved = Start-DurableExternalEventListener -EventName "Approval"

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

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

Az előző példa egy adott eseményt figyel, és a fogadáskor műveletet hajt végre.

Egyszerre több eseményt is figyelhet, például az alábbi példában, amely a három lehetséges eseményértesítés egyikére vár.

C#

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

Feljegyzés

Az előző C# kód a Durable Functions 2.x-hez készült. A Durable Functions 1.x esetén a helyett IDurableOrchestrationContexta DurableOrchestrationContext . A verziók közötti különbségekről további információt a Durable Functions verzióiról szóló cikkben talál.

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 = context.task_any([event1, event2, event3])
    if winner == event1:
        # ...
    elif winner == event2:
        # ...
    elif winner == event3:
        # ...

main = df.Orchestrator.create(orchestrator_function)

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

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

Az előző példa több esemény bármelyikét figyeli. Az összes eseményre is lehet várni.

C#

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

Feljegyzés

Az előző kód a Durable Functions 2.x-hez készült. A Durable Functions 1.x esetén a helyett IDurableOrchestrationContexta DurableOrchestrationContext . A verziók közötti különbségekről további információt a Durable Functions verzióiról szóló cikkben talál.

A .NET-ben, ha az esemény hasznos adatai nem konvertálhatók a várt típusra T, a rendszer kivételt küld.

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)

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

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

A "wait-for-external-event" API határozatlan ideig várakozik bizonyos bemenetekre. A függvényalkalmazás biztonságosan eltávolítható várakozás közben. Ha és amikor egy esemény érkezik erre a vezénylési példányra, a rendszer automatikusan felébred, és azonnal feldolgozza az eseményt.

Feljegyzés

Ha a függvényalkalmazás a Használati csomagot használja, a rendszer nem számol fel számlázási díjakat, miközben egy vezénylő függvény egy külső eseményfeladatra vár, függetlenül attól, hogy mennyi ideig vár.

A Tevékenységfüggvényekhez hasonlóan a külső események is legalább egyszeri kézbesítési garanciával rendelkeznek. Ez azt jelenti, hogy bizonyos feltételek mellett (például újraindítások, skálázás, összeomlások stb.) az alkalmazás ugyanahhoz a külső eseményhez duplikátumokat kaphat. Ezért azt javasoljuk, hogy a külső események valamilyen azonosítót tartalmazzanak, amely lehetővé teszi, hogy manuálisan duplikálják őket a vezénylőkben.

Események küldése

A vezénylési ügyfélkötés által definiált "raise-event" API használatával külső eseményt küldhet egy vezénylésnek. A beépített emelési esemény HTTP API-val külső eseményt is küldhet vezénylésre.

Az emelt esemény tartalmaz egy példányazonosítót, egy eventName és egy eventData paramétert. Az Orchestrator függvények ezeket az eseményeket a "wait-for-external-event" API-k használatával kezelik. Az eseménynévnek egyeznie kell mind a küldési, mind a fogadási végeken az esemény feldolgozásához. Az eseményadatoknak JSON-szerializálhatónak is kell lenniük.

A "raise-event" mechanizmusok belsőleg egy üzenetet idéznek elő, amelyet a várakozó vezénylő függvény fog át. Ha a példány nem a megadott eseménynévre vár, a rendszer hozzáadja az eseményüzenetet egy memóriabeli üzenetsorhoz. Ha a vezénylési példány később elkezdi figyelni az esemény nevét, ellenőrzi az üzenetsort az eseményüzenetek esetében.

Feljegyzés

Ha nincs vezénylési példány a megadott példányazonosítóval, a rendszer elveti az eseményüzenetet.

Az alábbiakban egy üzenetsor által aktivált függvény látható, amely egy "Jóváhagyási" eseményt küld egy vezénylő függvénypéldánynak. A vezénylési példány azonosítója az üzenetsor törzséből származik.

C#

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

Feljegyzés

Az előző C# kód a Durable Functions 2.x-hez készült. A Durable Functions 1.x esetében az attribútum helyett attribútumot DurableClient kell használniaOrchestrationClient, és a DurableOrchestrationClient paramétertípust kell használnia helyett.IDurableOrchestrationClient A verziók közötti különbségekről további információt a Durable Functions verzióiról szóló cikkben talál.

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)

PowerShell

param($instanceId)

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

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

A "raise-event" API belsőleg egy üzenetet küld, amelyet a várakozó vezénylő függvény fog átvenni. Ha a példány nem a megadott eseménynévre vár, a rendszer hozzáadja az eseményüzenetet egy memóriabeli pufferhez. Ha a vezénylési példány később elkezdi figyelni az esemény nevét, ellenőrzi az eseményüzenetek pufferét, és aktiválja a rá váró feladatot.

Feljegyzés

Ha nincs vezénylési példány a megadott példányazonosítóval, a rendszer elveti az eseményüzenetet.

HTTP

Az alábbi példa egy HTTP-kérésre mutat be egy "Jóváhagyási" eseményt egy vezénylési példányra.

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

"true"

Ebben az esetben a példányazonosító a MyInstanceId kóddal van kódolva.

Következő lépések

Útmutató a hibakezelés implementálásához

Az emberi interakcióra váró minta futtatása