Timers i Durable Functions (Azure Functions)

Artikel
11/08/2023

Durable Functions tillhandahåller varaktiga timers för användning i orkestreringsfunktioner för att implementera fördröjningar eller för att konfigurera tidsgränser för asynkrona åtgärder. Varaktiga timers bör användas i orkestreringsfunktioner i stället för "viloläge" eller "fördröja" API:er som kan vara inbyggda i språket.

Varaktiga timers är uppgifter som skapas med lämpligt "create timer"-API för det angivna språket, som visas nedan, och tar antingen en förfallen tid eller en varaktighet som argument.

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

När du "väntar" på timeraktiviteten kommer orchestrator-funktionen att viloläge tills den angivna förfallotiden har löpt ut.

Kommentar

Orkestreringar fortsätter att bearbeta andra inkommande händelser i väntan på att en timeraktivitet ska upphöra att gälla.

Tidsbegränsningar

När du skapar en timer som upphör att gälla kl. 16:30 UTC visas ett meddelande som visas först kl. 16:30 UTC. Om funktionsappen skalas ned till noll instanser under tiden ser det nyligen synliga timermeddelandet till att funktionsappen aktiveras igen på en lämplig virtuell dator.

Kommentar

För JavaScript-, Python- och PowerShell-appar är durable timers begränsade till sex dagar. Om du vill kringgå den här begränsningen kan du använda timer-API:erna i en while loop för att simulera en längre fördröjning. Uppdaterade .NET- och Java-appar stöder godtyckligt långa timers.
Beroende på vilken version av SDK och lagringsprovider som används kan långa timer på 6 dagar eller mer implementeras internt med hjälp av en serie kortare timers (t.ex. med 3 dagars varaktighet) tills önskad förfallotid har uppnåtts. Detta kan observeras i det underliggande datalagret men påverkar inte orkestreringsbeteendet.
Använd inte inbyggda api:er för datum/tid för att hämta den aktuella tiden. När du beräknar ett framtida datum för att en timer ska upphöra att gälla använder du alltid orkestreringsfunktionens api för aktuell tid. Mer information finns i artikeln om begränsningar för orchestrator-funktionskod .

Användning för fördröjning

I följande exempel visas hur du använder varaktiga timers för att fördröja körningen. Exemplet är att utfärda ett faktureringsmeddelande varje dag i 10 dagar.

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

Kommentar

Det tidigare C#-exemplet är avsett för Durable Functions 2.x. För Durable Functions 1.x måste du använda DurableOrchestrationContext i stället för IDurableOrchestrationContext. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions-versioner .

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

Varning

Undvik oändliga loopar i orkestreringsfunktioner. Information om hur du på ett säkert och effektivt sätt implementerar scenarier med oändliga loopar finns i Eviga orkestreringar.

Användning för timeout

Det här exemplet visar hur du använder varaktiga timers för att implementera tidsgränser.

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

Kommentar

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

Varning

I .NET, JavaScript, Python och PowerShell måste du avbryta alla skapade varaktiga timers om koden inte väntar på att de ska slutföras. Se exemplen ovan för hur du avbryter väntande timers. Durable Task Framework ändrar inte orkestreringens status till "Slutförd" förrän alla utestående aktiviteter, inklusive varaktiga timeruppgifter, antingen har slutförts eller avbrutits.

Den här annulleringsmekanismen med hjälp av när-något-mönstret inte avslutar pågående aktivitetsfunktion eller underorkestreringskörningar. I stället tillåter den helt enkelt orkestreringsfunktionen att ignorera resultatet och gå vidare. Om din funktionsapp använder förbrukningsplanen debiteras du fortfarande för varje tid och minne som förbrukas av den övergivna aktivitetsfunktionen. Som standard har funktioner som körs i förbrukningsplanen en tidsgräns på fem minuter. Om den här gränsen överskrids återanvänds Azure Functions-värden för att stoppa all körning och förhindra en skenande faktureringssituation. Tidsgränsen för funktionen kan konfigureras.

Ett mer djupgående exempel på hur du implementerar timeouter i orkestreringsfunktioner finns i artikeln Mänsklig interaktion och timeouter – Telefon Verifiering.

Nästa steg

Lär dig hur du genererar och hanterar externa händelser

Timers i Durable Functions (Azure Functions)

Tidsbegränsningar

Användning för fördröjning

Användning för timeout

Nästa steg

Ytterligare resurser