Timer in Durable Functions (Azure Functions)

Artikel
03/25/2023

Durable Functions bieten permanente Timer für die Verwendung in Orchestratorfunktionen zum Implementieren von Verzögerungen oder zum Einrichten von Timeouts für asynchrone Aktionen. Dauerhafte Timer sollten in Orchestratorfunktionen anstelle der „sleep“- oder „delay“-APIs verwendet werden, die möglicherweise in die Sprache integriert sind.

Dauerhafte Timer sind Aufgaben, die mithilfe der entsprechenden „create timer“-API für die bereitgestellte Programmiersprache erstellt werden (wie unten dargestellt) und entweder eine Fälligkeitszeit oder eine Dauer als Argument akzeptieren.

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

Wenn Sie die Zeitgeberaufgabe erwarten, wartet die Orchestratorfunktion bis zur angegebenen Ablaufzeit.

Hinweis

Die Orchestrierungen verarbeiten weiterhin andere eingehende Ereignisse, während sie auf das Ablaufen einer Timeraufgabe warten.

Timereinschränkungen

Wenn Sie einen Timer erstellen, der um 16:30 Uhr UTC abläuft, stellt das zugrunde liegende Durable Task-Framework eine Nachricht in die Warteschlange, die erst um 16:30 Uhr UTC sichtbar wird. Wenn die Funktions-App in der Zwischenzeit auf null Instanzen herunterskaliert wird, stellt die neue sichtbare Timernachricht sicher, dass die Funktions-App erneut auf einer geeigneten VM aktiviert wird.

Hinweis

Für JavaScript-, Python- und PowerShell-Apps sind dauerhafte Timer auf sechs Tage beschränkt. Um diese Einschränkung zu umgehen, können Sie die Timer-APIs in einer while-Schleife verwenden, um eine längere Verzögerung zu simulieren. Aktuelle .NET- und Java-Apps unterstützen beliebig lange Timer.
Je nach Version des verwendeten SDK und Speicheranbieters können lange Timer von sechs Tagen oder mehr intern mithilfe einer Reihe kürzerer Timer (z. B. mit einer Dauer von drei Tagen) implementiert werden, bis die gewünschte Ablaufzeit erreicht wird. Dies kann im zugrunde liegenden Datenspeicher beobachtet werden, wirkt sich jedoch nicht auf das Orchestrierungsverhalten aus.
Verwenden Sie keine integrierten Datums- oder Uhrzeit-APIs zum Abrufen der aktuellen Uhrzeit. Wenn Sie ein Ablaufdatum für einen Timer in der Zukunft berechnen, verwenden Sie immer die aktuelle time-API der Orchestratorfunktion. Weitere Informationen finden Sie im Artikel Codeeinschränkungen für Orchestratorfunktionen.

Verwendung für Verzögerung

Das folgende Beispiel veranschaulicht, wie Sie permanente Timer für die Ausführungsverzögerung verwenden. Im Beispiel wird 10 Tage lang täglich eine Abrechnungsbenachrichtigung ausgegeben.

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

Hinweis

Die vorherigen C#-Beispiele gelten für Durable Functions 2.x. Für Durable Functions 1.x müssen Sie DurableOrchestrationContext anstelle von IDurableOrchestrationContext verwenden. Weitere Informationen zu den Unterschieden zwischen den Versionen finden Sie im Artikel Durable Functions-Versionen.

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

Warnung

Vermeiden Sie Endlosschleifen in Orchestratorfunktionen. Informationen zum sicheren und effizienten Implementieren von Endlosschleifenszenarien finden Sie unter Eternal orchestrations in Durable Functions (Azure Functions) (Ewige Orchestrierungen in Durable Functions [Azure Functions]).

Verwendung für das Timeout

In diesem Beispiel wird veranschaulicht, wie mit permanenten Timern Timeouts implementiert werden.

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

Hinweis

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

Warnung

In .NET, JavaScript, Python und PowerShell müssen Sie alle erstellten dauerhaften Timer abbrechen, wenn Ihr Code nicht auf ihren Abschluss wartet. Informationen dazu, wie Sie ausstehende Timer abbrechen, finden Sie in den Beispielen oben. Das Durable Task-Framework ändert den Status einer Orchestrierung nicht in „Abgeschlossen“, solange nicht alle ausstehenden Aufgaben (einschließlich solcher mit dauerhaften Timern) abgeschlossen oder abgebrochen werden.

Dieser Abbruchmechanismus mit when-any-Muster beendet nicht die Ausführung von laufenden Aktivitätsfunktionen oder untergeordneten Orchestrierungen. Stattdessen lässt er zu, dass die Orchestratorfunktion das Ergebnis ignoriert und fortfährt. Wenn Ihre Funktions-App den Verbrauchstarif verwendet, wird Ihnen weiterhin jeglicher Zeit- und Arbeitsspeicherverbrauch der abgebrochenen Aktivitätsfunktion in Rechnung gestellt. Standardmäßig gilt für Funktionen, die im Rahmen des Verbrauchstarifs ausgeführt werden, ein Timeout von fünf Minuten. Wenn dieses Limit überschritten wird, wird der Azure Functions-Host neu gestartet, um jegliche Ausführung zu beenden und eine unkontrollierte Abrechnungssituation zu verhindern. Der Funktionstimeout ist konfigurierbar.

Ein ausführlicheres Beispiel zum Implementieren von Timeouts in Orchestratorfunktionen finden Sie im Artikel Human interaction and Timeouts – Phone Verification (Menschliche Interaktion und Timeouts – Telefonüberprüfung).

Nächste Schritte

Behandeln von externen Ereignissen in Durable Functions (Azure Functions)

Freigeben über

Timer in Durable Functions (Azure Functions)

Timereinschränkungen

Verwendung für Verzögerung

Verwendung für das Timeout

Nächste Schritte

Feedback

Zusätzliche Ressourcen