Időzítők a Durable Functionsben (Azure Functions)

Cikk
01/10/2024

A Durable Functions tartós időzítőket biztosít a vezénylő függvényekben a késések megvalósításához vagy az aszinkron műveletekhez való időkorlátok beállításához. A tartós időzítőket az "alvó" vagy a "késleltetési" API-k helyett a vezénylési funkciókban kell használni, amelyek beépíthetők a nyelvbe.

A tartós időzítők olyan feladatok, amelyek a megadott nyelv megfelelő "időzítő" API-jának használatával jönnek létre, ahogyan az alább látható, és argumentumként egy határidőt vagy időtartamot vesznek igénybe.

// Put the orchestrator to sleep for 72 hours
DateTime dueTime = context.CurrentUtcDateTime.AddHours(72);
await context.CreateTimer(dueTime, CancellationToken.None);

// Put the orchestrator to sleep for 72 hours
// Note that DateTime comes from the "luxon" module
const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime, {zone: 'utc'}).plus({ hours: 72 });
yield context.df.createTimer(deadline.toJSDate());

# Put the orchestrator to sleep for 72 hours
due_time = context.current_utc_datetime + timedelta(hours=72)
durable_timeout_task = context.create_timer(due_time)

# Put the orchestrator to sleep for 72 hours
$duration = New-TimeSpan -Hours 72
Start-DurableTimer -Duration $duration

// Put the orchestrator to sleep for 72 hours
ctx.createTimer(Duration.ofHours(72)).await();

Amikor "várja" az időzítőfeladatot, a vezénylő függvény a megadott lejárati időig alvó állapotba kerül.

Megjegyzés:

A vezénylések továbbra is feldolgozzák a többi bejövő eseményt, miközben az időzítőfeladat lejáratára várnak.

Időzítő korlátozásai

Amikor létrehoz egy időzítőt, amely 16:30 -kor (UTC) lejár, a mögöttes Durable Task Framework egy üzenetet küld, amely csak 16:30-kor (UTC) válik láthatóvá. Ha a függvényalkalmazás addig is nullára van skálázva, az újonnan látható időzítőüzenet gondoskodik arról, hogy a függvényalkalmazás ismét aktiválva legyen egy megfelelő virtuális gépen.

Megjegyzés:

JavaScript-, Python- és PowerShell-alkalmazások esetén a tartós időzítők legfeljebb hat napig használhatók. A korlátozás megkerüléséhez használhatja az időzítő API-kat egy while ciklusban, hogy hosszabb késleltetést szimuláljon. A naprakész .NET- és Java-alkalmazások tetszőlegesen hosszú időzítőket támogatnak.
A használt SDK-verziótól és a tárolószolgáltatótól függően a 6 napos vagy annál hosszabb hosszú időzítők belsőleg, rövidebb időzítők (például 3 napos időtartamok) használatával implementálhatók, amíg el nem éri a kívánt lejárati időt. Ez megfigyelhető a mögöttes adattárban, de nem befolyásolja a vezénylési viselkedést.
Ne használjon beépített dátum/idő API-kat az aktuális idő lekéréséhez. Az időzítő lejáratának jövőbeli dátumának kiszámításakor mindig használja a vezénylő függvény aktuális idő API-ját. További információkért tekintse meg a vezénylő függvénykód korlátozásait ismertető cikket.

Használat késleltetéshez

Az alábbi példa bemutatja, hogyan használhat tartós időzítőket a végrehajtás késleltetéséhez. A példa egy 10 napig naponta megjelenő számlázási értesítés.

[FunctionName("BillingIssuer")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    for (int i = 0; i < 10; i++)
    {
        DateTime deadline = context.CurrentUtcDateTime.Add(TimeSpan.FromDays(1));
        await context.CreateTimer(deadline, CancellationToken.None);
        await context.CallActivityAsync("SendBillingEvent");
    }
}

Megjegyzés:

Az előző C# példa a Durable Functions 2.x-et célozza meg. 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.

const df = require("durable-functions");
const { DateTime } = require("luxon");

module.exports = df.orchestrator(function*(context) {
    for (let i = 0; i < 10; i++) {
        const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime, {zone: 'utc'}).plus({ days: 1 });
        yield context.df.createTimer(deadline.toJSDate());
        yield context.df.callActivity("SendBillingEvent");
    }
});

import azure.functions as func
import azure.durable_functions as df
from datetime import datetime, timedelta

def orchestrator_function(context: df.DurableOrchestrationContext):
    for i in range(0, 9):
        deadline = context.current_utc_datetime + timedelta(days=1)
        yield context.create_timer(deadline)
        yield context.call_activity("SendBillingEvent")

main = df.Orchestrator.create(orchestrator_function)

param($Context)

for ($num = 0 ; $num -le 9 ; $num++){    
    $expiryTime =  New-TimeSpan -Days 1
    $timerTask = Start-DurableTimer -Duration $expiryTime
    Invoke-DurableActivity -FunctionName 'SendBillingEvent'
}

@FunctionName("BillingIssuer")
public String billingIssuer(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    for (int i = 0; i < 10; i++) {
        ctx.createTimer(Duration.ofDays(1)).await();
        ctx.callActivity("SendBillingEvent").await();
    }
    return "done";
}

Figyelmeztetés

Kerülje a végtelen hurkokat a vezénylő függvényekben. A végtelen ciklusos forgatókönyvek biztonságos és hatékony implementálásáról további információt az Örök vezénylések című témakörben talál.

Időtúllépési használat

Ez a példa bemutatja, hogyan lehet tartós időzítőket használni az időtúllépések implementálásához.

[FunctionName("TryGetQuote")]
public static async Task<bool> Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    TimeSpan timeout = TimeSpan.FromSeconds(30);
    DateTime deadline = context.CurrentUtcDateTime.Add(timeout);

    using (var cts = new CancellationTokenSource())
    {
        Task activityTask = context.CallActivityAsync("GetQuote");
        Task timeoutTask = context.CreateTimer(deadline, cts.Token);

        Task winner = await Task.WhenAny(activityTask, timeoutTask);
        if (winner == activityTask)
        {
            // success case
            cts.Cancel();
            return true;
        }
        else
        {
            // timeout case
            return false;
        }
    }
}

Megjegyzés:

const df = require("durable-functions");
const { DateTime } = require("luxon");

module.exports = df.orchestrator(function*(context) {
    const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime, {zone: 'utc'}).plus({ seconds: 30 });

    const activityTask = context.df.callActivity("GetQuote");
    const timeoutTask = context.df.createTimer(deadline.toJSDate());

    const winner = yield context.df.Task.any([activityTask, timeoutTask]);
    if (winner === activityTask) {
        // success case
        timeoutTask.cancel();
        return true;
    }
    else
    {
        // timeout case
        return false;
    }
});

import azure.functions as func
import azure.durable_functions as df
from datetime import datetime, timedelta

def orchestrator_function(context: df.DurableOrchestrationContext):
    deadline = context.current_utc_datetime + timedelta(seconds=30)
    activity_task = context.call_activity("GetQuote")
    timeout_task = context.create_timer(deadline)

    winner = yield context.task_any([activity_task, timeout_task])
    if winner == activity_task:
        timeout_task.cancel()
        return True
    elif winner == timeout_task:
        return False

main = df.Orchestrator.create(orchestrator_function)

param($Context)

$expiryTime =  New-TimeSpan -Seconds 30

$activityTask = Invoke-DurableActivity -FunctionName 'GetQuote'-NoWait
$timerTask = Start-DurableTimer -Duration $expiryTime -NoWait

$winner = Wait-DurableTask -Task @($activityTask, $timerTask) -Any

if ($winner -eq $activityTask) {
    Stop-DurableTimerTask -Task $timerTask
    return $True
}
else {
    return $False
}

@FunctionName("TryGetQuote")
public boolean tryGetQuote(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    Task<Double> activityTask = ctx.callActivity("GetQuote", Double.class);
    Task<Void> timerTask = ctx.createTimer(Duration.ofSeconds(30));

    Task<?> winner = ctx.anyOf(activityTask, timerTask);
    if (winner == activityTask) {
        // success case
        return true;
    } else {
        // timeout case
        return false;
    }
}

Figyelmeztetés

A .NET-ben, a JavaScriptben, a Pythonban és a PowerShellben le kell mondania a létrehozott tartós időzítőket, ha a kód nem várja meg, hogy befejeződjenek. Tekintse meg a fenti példákat a függőben lévő időzítők megszakításához. A Durable Task Framework mindaddig nem módosítja a vezénylés állapotát "Befejezve" értékre, amíg az összes befejezetlen tevékenység, beleértve a tartós időzítőfeladatokat is, nem fejeződik be vagy nem fejeződik be.

Ez a bármikori mintát használó lemondási mechanizmus nem szünteti meg a folyamatban lévő tevékenységfüggvényeket vagy az al-vezénylési végrehajtásokat. Ehelyett egyszerűen lehetővé teszi, hogy a vezénylő függvény figyelmen kívül hagyja az eredményt, és továbblépjen. Ha a függvényalkalmazás a Használat csomagot használja, a rendszer továbbra is a felhagyott tevékenységfüggvény által felhasznált időért és memóriáért számláz. A Használati tervben futó függvények alapértelmezés szerint öt perc időtúllépéssel rendelkeznek. Ha túllépi ezt a korlátot, az Azure Functions-gazdagép újraindul az összes végrehajtás leállításához és az elszabadult számlázási helyzet megelőzéséhez. A függvény időtúllépése konfigurálható.

Az időtúllépések vezénylési függvényekben való implementálásának részletesebb példáját az Emberi interakció és időtúllépések – Telefon Ellenőrzés című cikkben találja.

További lépések

Ismerje meg, hogyan gyűjthet és kezelhet külső eseményeket

Share via

Időzítők a Durable Functionsben (Azure Functions)

Időzítő korlátozásai

Használat késleltetéshez

Időtúllépési használat

További lépések

További források