Temporizadores en Durable Functions (Azure Functions)

Artículo
03/25/2023

Durable Functions proporciona temporizadores durables para usarlos en funciones de orquestador para implementar retrasos o configurar tiempos de expiración en acciones asincrónicas. Los temporizadores duraderos deben usarse en funciones del orquestador en lugar de api de "sleep" o "delay" que se pueden integrar en el lenguaje.

Los temporizadores duraderos son tareas que se crean mediante la API "crear temporizador" adecuada para el idioma proporcionado, como se muestra a continuación, y tardan un tiempo de vencimiento o una duración como argumento.

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

Cuando se "espera" la tarea del temporizador, la función del orquestador se suspenderá hasta la hora de expiración especificada.

Nota

Las orquestaciones seguirán procesando otros eventos entrantes mientras esperan que una tarea del temporizador expire.

Limitaciones de los temporizadores

Cuando se crea un temporizador que expira a las 16:30 UTC, la instancia de Durable Task Framework subyacente pone en cola un mensaje que se vuelve visible solo a las 16:30 UTC. Si la aplicación de funciones se reduce verticalmente a cero instancias mientras tanto, el mensaje del temporizador recién visible garantizará que la aplicación de funciones se active de nuevo en una máquina virtual adecuada.

Nota

En el caso de las aplicaciones de JavaScript, Python y PowerShell, los temporizadores duraderos están limitados a seis días. Para sortear esta limitación, puede usar las API del temporizador en un bucle whilepara simular un retraso mayor. Las aplicaciones .NET y Java actualizadas admiten temporizadores arbitrariamente largos.
En función de la versión del SDK y del proveedor de almacenamiento que se use, los temporizadores largos de seis días, o más, se pueden implementar internamente mediante una serie de temporizadores más cortos (por ejemplo, de tres días) hasta que se alcance la hora de expiración deseada. Esto se puede observar en el almacén de datos subyacente, pero no afectará al comportamiento de la orquestación.
No use la API de fecha y hora integradas para obtener la hora actual. Al calcular una fecha futura para que expire un temporizador, use siempre la API de hora actual de la función de orquestador. Para más información, consulte el artículo sobre las restricciones de código de las funciones de orquestador.

Uso para retraso

En el ejemplo siguiente se muestra cómo utilizar temporizadores durables para retrasar la ejecución. En el ejemplo se emite una notificación de facturación cada día durante 10 días.

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

Nota

El ejemplo de C# anterior corresponde a Durable Functions 2.x. En el caso de Durable Functions 1.x, debe usar DurableOrchestrationContext en lugar de IDurableOrchestrationContext. Para obtener más información sobre las diferencias entre versiones, vea el artículo Versiones de 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";
}

Advertencia

Evite bucles infinitos en funciones de orquestador. Para más información acerca de cómo implementar de forma segura y eficaz escenarios de bucle infinito, consulte Orquestaciones infinitas.

Uso para tiempo de expiración

En este ejemplo se muestra cómo utilizar temporizadores durables para implementar tiempos de expiración.

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

Nota

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

Advertencia

En .NET, JavaScript, Python y PowerShell, debe cancelar los temporizadores duraderos creados si el código no esperará a que se completen. Consulte los ejemplos anteriores para ver cómo cancelar temporizadores pendientes. El Durable Task Framework no cambiará el estado de una orquestación a "Completado" hasta que todas las tareas pendientes, incluidas las tareas Durables con temporizador, se completen o se cancelen.

Este mecanismo de cancelación que usa el patrón when-any no termina las ejecuciones de funciones de actividad o suborquestación en curso. En su lugar, simplemente permite que la función de orquestador pase por alto el resultado y continúe. Si la aplicación de función usa el plan Consumo, se le sigue facturando por el tiempo y la memoria consumidos por la función de actividad abandonada. De manera predeterminada, las funciones en ejecución en el plan de consumo tienen un tiempo de expiración de cinco minutos. Si se supera este límite, el host de Azure Functions se recicla para detener toda la ejecución y evitar una situación de facturación descontrolada. El tiempo de expiración de la función se puede configurar.

Para obtener un ejemplo más detallado de cómo implementar tiempos de espera en funciones de orquestador, vea el artículo Las interacciones humanas en Durable Functions: comprobación telefónica de ejemplo.

Pasos siguientes

Más información acerca de cómo generar y controlar eventos externos

Temporizadores en Durable Functions (Azure Functions)

Limitaciones de los temporizadores

Uso para retraso

Uso para tiempo de expiración

Pasos siguientes

Recursos adicionales