Timers in Durable Functions (Azure Functions)

Artikel
11/08/2023

Durable Functions biedt duurzame timers voor gebruik in orchestratorfuncties om vertragingen te implementeren of time-outs in te stellen voor asynchrone acties. Duurzame timers moeten worden gebruikt in orchestratorfuncties in plaats van 'slaapstand' of 'vertraging'-API's die in de taal kunnen worden ingebouwd.

Duurzame timers zijn taken die zijn gemaakt met behulp van de juiste 'timer maken' API voor de opgegeven taal, zoals hieronder wordt weergegeven, en een vervaldatum of een duur als argument in beslag nemen.

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

Wanneer u de timertaak 'wacht', slaapt de orchestratorfunctie tot de opgegeven verlooptijd.

Notitie

Indelingen blijven andere binnenkomende gebeurtenissen verwerken terwijl wordt gewacht tot een timertaak verloopt.

Timerbeperkingen

Wanneer u een timer maakt die om 16:30 uur UTC verloopt, wordt een bericht dat alleen om 16:30 uur UTC zichtbaar wordt door het onderliggende Durable Task Framework. Als de functie-app ondertussen omlaag wordt geschaald naar nul exemplaren, zorgt het nieuw zichtbare timerbericht ervoor dat de functie-app opnieuw wordt geactiveerd op een geschikte VIRTUELE machine.

Notitie

Voor JavaScript-, Python- en PowerShell-apps zijn duurzame timers beperkt tot zes dagen. Als u deze beperking wilt omzeilen, kunt u de timer-API's in een while lus gebruiken om een langere vertraging te simuleren. Bijgewerkte .NET- en Java-apps ondersteunen willekeurige lange timers.
Afhankelijk van de versie van de SDK en de opslagprovider die wordt gebruikt, kunnen lange timers van 6 dagen of meer intern worden geïmplementeerd met behulp van een reeks kortere timers (bijvoorbeeld van drie dagen) totdat de gewenste verlooptijd is bereikt. Dit kan worden waargenomen in het onderliggende gegevensarchief, maar heeft geen invloed op het indelingsgedrag.
Gebruik geen ingebouwde datum-/tijd-API's om de huidige tijd op te halen. Bij het berekenen van een toekomstige datum voor een timer die verloopt, gebruikt u altijd de huidige tijd-API van de orchestrator-functie. Zie het artikel codebeperkingen voor orchestratorfuncties voor meer informatie.

Gebruik voor vertraging

In het volgende voorbeeld ziet u hoe u duurzame timers gebruikt voor het vertragen van de uitvoering. In het voorbeeld wordt elke dag een factureringsmelding voor 10 dagen uitgegeven.

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

Notitie

Het vorige C#-voorbeeld is gericht op Durable Functions 2.x. Voor Durable Functions 1.x moet u in DurableOrchestrationContext plaats van IDurableOrchestrationContext. Zie het artikel Over Durable Functions-versies voor meer informatie over de verschillen tussen versies.

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

Waarschuwing

Vermijd oneindige lussen in orchestratorfuncties. Zie Eeuwige orchestrations voor informatie over het veilig en efficiënt implementeren van oneindige lusscenario's.

Gebruik voor time-out

In dit voorbeeld ziet u hoe u duurzame timers gebruikt om time-outs te implementeren.

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

Notitie

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

Waarschuwing

In .NET, JavaScript, Python en PowerShell moet u alle gemaakte duurzame timers annuleren als uw code niet wacht totdat ze zijn voltooid. Zie de bovenstaande voorbeelden voor het annuleren van timers die in behandeling zijn. Het Durable Task Framework wijzigt de status van een indeling pas in Voltooid als alle openstaande taken, inclusief duurzame timertaken, zijn voltooid of geannuleerd.

Dit annuleringsmechanisme waarbij gebruik wordt gemaakt van het patroon wanneer een patroon de actieve activiteitsfunctie of uitvoeringen van subindelingen niet beëindigt. In plaats daarvan kan de orchestratorfunctie het resultaat negeren en verdergaan. Als uw functie-app gebruikmaakt van het verbruiksabonnement, worden er nog steeds kosten in rekening gebracht voor tijd en geheugen die worden verbruikt door de verlaten activiteitsfunctie. Standaard hebben functies die worden uitgevoerd in het verbruiksabonnement een time-out van vijf minuten. Als deze limiet wordt overschreden, wordt de Azure Functions-host gerecycled om alle uitvoeringen te stoppen en te voorkomen dat er sprake is van een situatie met een runaway-facturering. De time-out van de functie kan worden geconfigureerd.

Zie het artikel Human Interaction & Time-outs - Telefoon Verificatie voor een uitgebreider voorbeeld van het implementeren van time-outs in orchestratorfuncties.

Volgende stappen

Meer informatie over het genereren en afhandelen van externe gebeurtenissen

Delen via

Timers in Durable Functions (Azure Functions)

Timerbeperkingen

Gebruik voor vertraging

Gebruik voor time-out

Volgende stappen

Feedback

Aanvullende resources