Implementovat trvalé časovače pro zpoždění a časové limity

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.

Durable Functions poskytuje trvanlivé časovače pro použití ve funkcích orchestrátoru, aby implementovaly prodlevy nebo nastavily časové limity u asynchronních akcí. Používejte trvalé časovače ve funkcích orchestrátoru sleep místo rozhraní API, delay která mohou být součástí jazyka.

Odolné sady SDK úloh poskytují trvalé časovače pro použití v orchestracích k implementaci zpoždění nebo nastavení časových limitů u asynchronních akcí. Používejte trvalé časovače v orchestracích místo rozhraní API, jako jsou sleep nebo delay, která můžou být součástí jazyka.

Důležité

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

Trvalé časovače jsou úlohy vytvořené pomocí příslušného create timer rozhraní API pro zadaný jazyk, jak je znázorněno v následujících příkladech, a jako argument přijímají buď konkrétní časový okamžik, nebo dobu trvání.

C#

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

JavaScript

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

Python

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

PowerShell

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

Java

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

C#

// Put the orchestration to sleep for 72 hours
await context.CreateTimer(TimeSpan.FromHours(72), CancellationToken.None);

Python

# Put the orchestration to sleep for 72 hours
from datetime import timedelta
yield ctx.create_timer(timedelta(hours=72))

Java

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

JavaScript

// Put the orchestration to sleep for 72 hours
yield ctx.createTimer(72 * 60 * 60);

PowerShell

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

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

Když await úlohu časovače, orchestrace se pozastaví do zadaného času vypršení platnosti.

Poznámka:

Orchestrace nadále zpracovávají další příchozí události při čekání na vypršení platnosti úlohy časovače.

Omezení trvalých časovačů

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

Poznámka:

• Pro javascriptové, Python a aplikace PowerShellu jsou trvalé časovače omezené na šest dnů. Pokud chcete toto omezení obejít, použijte rozhraní API časovače ve while smyčce k simulaci delšího zpoždění. Aktuální .NET a Java aplikace podporují libovolně dlouhé časovače.
• V závislosti na používané verzi sady SDK a poskytovatele úložiště můžou být dlouhé časovače šesti dnů nebo více interně implementovány pomocí řady kratších časovačů (například třídenní doby trvání), dokud nedosáhne požadované doby vypršení platnosti. Toto chování je pozorovatelné v podkladovém úložišti dat, ale nemá 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.

Když vytvoříte časovač, jehož platnost vyprší v 18:30 UTC, podkladová architektura úloh Durable Task Framework vytvoří zprávu, která se zobrazí pouze v 14:30 UTC. Zpráva časovače zajistí, že se pracovní proces znovu aktivuje, jakmile vyprší platnost časovače.

Poznámka:

• Zadání dlouhého zpoždění (například zpoždění několika dnů nebo více) může vést k vytvoření několika interně spravovaných trvalých časovačů. Kód orchestrace nemusí o tomto chování vědět. Může se však zobrazit v protokolech rámce a ve stavu uložené historie.
• K získání aktuálního času nepoužívejte předdefinovaná rozhraní API pro datum a čas. Při výpočtu budoucího data vypršení platnosti časovače vždy použijte vlastnost aktuálního času kontextu orchestrace (například context.CurrentUtcDateTime v .NET, ctx.current_utc_datetime v Python nebo ctx.currentUtcDateTime v JavaScriptu).

Použití trvalých časovačů 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ů.

C#

[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 místo DurableOrchestrationContext použijte IDurableOrchestrationContext. Další informace o rozdílech mezi verzemi najdete v článku o verzích Durable Functions .

JavaScript

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

Python

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)

PowerShell

param($Context)

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

Java

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

C#

public class BillingIssuer : TaskOrchestrator<object?, string>
{
    public override async Task<string> RunAsync(TaskOrchestrationContext context, object? input)
    {
        for (int i = 0; i < 10; i++)
        {
            await context.CreateTimer(TimeSpan.FromDays(1), CancellationToken.None);
            await context.CallActivityAsync("SendBillingEvent");
        }
        return "done";
    }
}

Python

from datetime import timedelta
from durabletask import task

def send_billing_event(ctx: task.ActivityContext, _) -> None:
    # Send billing event
    pass

def billing_issuer(ctx: task.OrchestrationContext, _):
    for i in range(10):
        yield ctx.create_timer(timedelta(days=1))
        yield ctx.call_activity(send_billing_event)
    return "done"

Java

public class BillingIssuer implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        for (int i = 0; i < 10; i++) {
            ctx.createTimer(Duration.ofDays(1)).await();
            ctx.callActivity("SendBillingEvent").await();
        }
        ctx.complete("done");
    }
}

JavaScript

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

const sendBillingEvent = async (_: ActivityContext): Promise<void> => {
    // Send billing event
};

const billingIssuer: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    for (let i = 0; i < 10; i++) {
        yield ctx.createTimer(24 * 60 * 60); // 1 day
        yield ctx.callActivity(sendBillingEvent);
    }
    return "done";
};

PowerShell

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

Výstraha

Vyhněte se nekonečným smyčkám ve funkcích orchestrátoru. Informace o bezpečném a efektivním implementaci scénářů nekonečné smyčky najdete v tématu Věčná orchestrace.

Výstraha

Vyhněte se nekonečným smyčkám v orchestracích. Informace o bezpečném a efektivním implementaci scénářů nekonečné smyčky najdete v tématu Věčná orchestrace.

Používejte trvalé časovače pro nastavení časových limitů

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

C#

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

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

JavaScript

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

Python

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)

PowerShell

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
}

Java

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

C#

public class TryGetQuote : TaskOrchestrator<object?, bool>
{
    public override async Task<bool> RunAsync(TaskOrchestrationContext context, object? input)
    {
        using var cts = new CancellationTokenSource();

        Task<double> activityTask = context.CallActivityAsync<double>("GetQuote");
        Task timeoutTask = context.CreateTimer(TimeSpan.FromSeconds(30), cts.Token);

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

Python

from datetime import timedelta
from durabletask import task

def get_quote(ctx: task.ActivityContext, _) -> float:
    # Get quote logic
    return 100.0

def try_get_quote(ctx: task.OrchestrationContext, _):
    activity_task = ctx.call_activity(get_quote)
    timeout_task = ctx.create_timer(timedelta(seconds=30))

    winner = yield task.when_any([activity_task, timeout_task])
    if winner == activity_task:
        # success case
        return True
    else:
        # timeout case
        return False

Java

public class TryGetQuote implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        Task<Double> activityTask = ctx.callActivity("GetQuote", Double.class);
        Task<Void> timerTask = ctx.createTimer(Duration.ofSeconds(30));

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

JavaScript

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

const getQuote = async (_: ActivityContext): Promise<number> => {
    // Get quote logic
    return 100.0;
};

const tryGetQuote: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const activityTask = ctx.callActivity(getQuote);
    const timeoutTask = ctx.createTimer(30);

    const winner = yield whenAny([activityTask, timeoutTask]);
    if (winner === activityTask) {
        // success case
        return true;
    } else {
        // timeout case
        return false;
    }
};

PowerShell

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

Výstraha

V .NET, JavaScriptu, Python a PowerShellu zrušte všechny vytvořené trvalé časovače, pokud váš kód nečeká na jejich dokončení. V předchozích příkladech se dozvíte, jak zrušit čekající časovače. Framework trvalých úloh nezmění stav orchestrace na "Dokončeno", dokud nebudou dokončeny všechny nevyřízené úkoly, včetně odolných časovačových úloh, buď dokončené, nebo zrušené.

Výstraha

Pokud vaše sada SDK podporuje zrušení časovače (například v .NET), zrušte všechny vytvořené trvalé časovače v případech, kdy váš kód na ně nečeká, až se dokončí. V předchozích příkladech se dozvíte, jak zrušit čekající časovače. Framework trvalých úloh nezmění stav orchestrace na "Dokončeno", dokud nebudou dokončeny všechny nevyřízené úkoly, včetně odolných časovačových úloh, buď dokončené, nebo zrušené.

Tento mechanismus zrušení pomocí vzoru when-any neukončí aktuální funkce aktivity ani spuštění dílčí orchestraci. Místo toho jednoduše umožňuje funkci orchestrátoru ignorovat výsledek a pokračovat dál. Pokud vaše aplikace funkcí používá plán Consumption, stále se vám účtují náklady na čas a paměť, kterou nečinná funkce spotřebovává. 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 služby Azure Functions se recykluje, aby zastavil veškeré spuštění a zabránil nekontrolovatelné situaci ohledně fakturace. Časový limit funkce je konfigurovatelný.

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

Tento mechanismus zrušení pomocí vzoru kdykoli neukončí probíhající aktivity ani provádění procesů dílčí orchestrace. Místo toho jednoduše umožňuje orchestraci ignorovat výsledek a pokračovat dál.

Další kroky

Naučte se, jak vyvolat a zpracovat externí události

Začínáme se sadami SDK Durable Task