Časovače v Durable Functions (Azure Functions)

Článek
11/08/2023

Durable Functions poskytuje trvalé časovače pro použití ve funkcích orchestrátoru k implementaci zpoždění nebo nastavení časových limitů u asynchronních akcí. Trvalé časovače by se měly používat ve funkcích orchestrátoru místo rozhraní API "sleep" nebo "delay", která mohou být integrována do jazyka.

Trvalé časovače jsou úlohy vytvořené pomocí příslušného rozhraní API pro vytvoření časovače pro zadaný jazyk, jak je znázorněno níže, a jako argument trvá buď čas splnění, nebo dobu trvání.

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

Když úlohu časovače "čekáte", funkce orchestrátoru přejde do režimu spánku do zadané doby vypršení platnosti.

Poznámka:

Orchestrace budou dál zpracovávat další příchozí události při čekání na vypršení platnosti úlohy časovače.

Omezení časovače

Když vytvoříte časovač, jehož platnost vyprší v 17:30 UTC, podkladová architektura Durable Task Framework vytvoří zprávu, která se zobrazí pouze v 14:30 UTC. Pokud se mezitím aplikace funkcí škáluje na nula instancí, zpráva nově viditelného časovače zajistí, že se aplikace funkcí znovu aktivuje na příslušném virtuálním počítači.

Poznámka:

V aplikacích JavaScript, Python a PowerShell jsou časovače Durable omezené na šest dnů. Pokud chcete toto omezení obejít, můžete pomocí rozhraní API časovače ve while smyčce simulovat delší prodlevu. Aktuální aplikace .NET a Java podporují libovolně dlouhé časovače.
V závislosti na používané verzi sady SDK a poskytovatele úložiště mohou být dlouhé časovače 6 dnů nebo více interně implementovány pomocí řady kratších časovačů (např. 3denní doby trvání) do dosažení požadované doby vypršení platnosti. To je možné pozorovat v podkladovém úložišti dat, ale nebude mít vliv na chování orchestrace.
K získání aktuálního času nepoužívejte integrovaná rozhraní API pro datum a čas. Při výpočtu budoucího data vypršení platnosti časovače vždy použijte aktuální rozhraní API funkce orchestratoru. Další informace najdete v článku omezení kódu funkce orchestrátoru.

Využití pro zpoždění

Následující příklad ukazuje, jak použít trvalé časovače ke zpoždění provádění. Příklad vydává oznámení o fakturaci každý den po dobu 10 dnů.

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

Poznámka:

Předchozí příklad jazyka C# cílí na Durable Functions 2.x. Pro Durable Functions 1.x je nutné použít DurableOrchestrationContext místo IDurableOrchestrationContext. Další informace o rozdílech mezi verzemi najdete v článku o verzích Durable Functions.

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

Upozorňující

Vyhněte se nekonečným smyčkám ve funkcích orchestrátoru. Informace o tom, jak bezpečně a efektivně implementovat nekonečné scénáře smyčky, naleznete v tématu Eternal Orchestrations.

Využití pro vypršení časového limitu

Tento příklad ukazuje, jak používat trvalé časovače k implementaci časových limitů.

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

Poznámka:

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

Upozorňující

V .NET, JavaScriptu, Pythonu a PowerShellu je nutné zrušit všechny vytvořené trvalé časovače, pokud váš kód nečeká, až se dokončí. V příkladech výše se dozvíte, jak zrušit čekající časovače. Architektura trvalých úloh nezmění stav orchestrace na Dokončeno, dokud nebudou dokončeny všechny nevyřízených úkolů, včetně trvalých úloh časovače, buď dokončeny, nebo zrušeny.

Tento mechanismus zrušení pomocí vzoru, kdy se neukončí probíhající funkce aktivity ani provádění dílčí orchestrace. Místo toho jednoduše umožňuje funkci orchestrátoru ignorovat výsledek a pokračovat. Pokud vaše aplikace funkcí používá plán Consumption, stále se vám bude účtovat kdykoli a paměť spotřebovaná funkcí opuštěné aktivity. Ve výchozím nastavení mají funkce spuštěné v plánu Consumption časový limit 5 minut. Pokud dojde k překročení tohoto limitu, hostitel Azure Functions se recykluje, aby se zastavilo veškeré spuštění a zabránilo situaci při fakturaci. Časový limit funkce je konfigurovatelný.

Podrobnější příklad implementace časových limitů ve funkcích orchestrátoru najdete v článku Lidské interakce a časové limity – Telefon ověření.

Další kroky

Informace o vyvolání a zpracování externích událostí

Časovače v Durable Functions (Azure Functions)

Omezení časovače

Využití pro zpoždění

Využití pro vypršení časového limitu

Další kroky

Další materiály