Orquestaciones eternas

Las orquestaciones eternas son funciones de orquestador que se ejecutan indefinidamente al restablecer periódicamente su propio historial mediante la continue-as-new API. Son útiles para los agregadores, los trabajos en segundo plano periódicos y cualquier escenario de Durable Functions que requiere un bucle infinito sin crecimiento de historial ilimitado.

Sin continue-as-new, un orquestador que ejecuta bucles eternamente acumule historial de orquestaciones con cada tarea programada, lo cual causaría finalmente problemas de rendimiento y uso excesivo de memoria. El patrón de orquestación eterna resuelve esto restableciendo el historial en cada iteración.

Nota:

Los ejemplos de código de orquestación eterna están disponibles para C#, JavaScript, Python y Java. PowerShell no admite continue-as-new.

En este artículo:

Cómo funciona continuar como nuevo - el mecanismo de restablecimiento
Consideraciones : comportamiento de excepciones, tareas incompletas y eventos externos
Ejemplo de trabajo periódico : un bucle de limpieza que evita la superposición del temporizador
Iniciar una orquestación eterna : patrones de inicio y singleton
Salida de una orquestación eterna: parada y terminación elegante

Las orquestaciones eternas son orquestaciones que se ejecutan indefinidamente restableciendo periódicamente su propio historial mediante la continue-as-new API. Son útiles para agregadores, trabajos en segundo plano periódicos y cualquier escenario que requiera un bucle infinito sin crecimiento de historial ilimitado.

Sin continue-as-new, una orquestación que se repita para siempre acumularía historial con cada tarea programada, lo que eventualmente causaría problemas de rendimiento y un uso excesivo de memoria. El patrón de orquestación eterna resuelve esto restableciendo el historial en cada iteración.

Importante

Actualmente, el SDK de Durable Task de PowerShell no está disponible.

En este artículo:

Cómo funciona continuar como nuevo — el mecanismo de restablecimiento
Consideraciones : comportamiento de excepciones, tareas incompletas y eventos externos
Ejemplo de trabajo periódico : un bucle de limpieza que evita la superposición del temporizador
Iniciar una orquestación eterna : patrones de inicio y singleton
Salir de una orquestación eterna : parada y finalización con gracia

Cómo funciona "continue-as-new"

En lugar de usar bucles infinitos, las funciones del orquestador restablecen su estado llamando al método continue-as-new del enlace del desencadenador de orquestación. Este método toma un parámetro serializable json que se convierte en la nueva entrada para la próxima generación de funciones de orquestador.

Cuando se llama a continue-as-new, la instancia de orquestación se reinicia con el nuevo valor de entrada. Se mantiene el mismo identificador de instancia, pero se restablece el historial de la función de orquestador.

En lugar de usar bucles infinitos, las orquestaciones restablecen su estado llamando al continue-as-new método en el contexto de orquestación. Este método toma un parámetro serializable json que se convierte en la nueva entrada para la próxima generación de orquestación.

Cuando se llama a continue-as-new, la instancia de orquestación se reinicia con el nuevo valor de entrada. Se mantiene el mismo identificador de instancia, pero el historial de la orquestación se restablece.

Consideraciones sobre orquestación eterna

Tenga en cuenta estas consideraciones al usar el continue-as-new método en una orquestación:

Cuando se restablece una función de orquestador mediante el continue-as-new método , Durable Task Framework mantiene el mismo identificador de instancia, pero crea internamente y usa un nuevo identificador de ejecución en el futuro. Este ID de ejecución no se expone externamente, pero es útil al depurar la ejecución de la orquestación.
Cuando se produce una excepción no controlada durante la ejecución, la orquestación entra en un estado de error y finaliza la ejecución. Una llamada a continue-as-new desde un finally bloque no reinicia la orquestación después de una excepción no detectada.
Los resultados de cualquier tarea incompleta se descartan cuando una orquestación llama a continue-as-new. Por ejemplo, si se programa un temporizador y se llama a continue-as-new antes de que se active el temporizador, se descarta el evento del temporizador.
Opcionalmente, puede conservar eventos externos sin procesar en los reinicios de continue-as-new. En C#, ContinueAsNew conserva los eventos sin procesar de forma predeterminada. En Java, continueAsNew también conserva los eventos de forma predeterminada. En Python, continue_as_new no conserva los eventos a menos que save_events=True. En JavaScript, continueAsNew requiere un saveEvents parámetro (true o false) para controlar este comportamiento.

Tenga en cuenta estas consideraciones al usar el continue-as-new método en una orquestación:

Cuando se restablece una orquestación mediante el continue-as-new método , los SDK de Durable Task mantienen el mismo identificador de instancia, pero crean internamente y usan un nuevo identificador de ejecución en el futuro. Este identificador de ejecución no se expone externamente, pero puede ser útil al depurar la ejecución de la orquestación.
Cuando se produce una excepción no controlada durante la ejecución, la orquestación entra en un estado de error y finaliza la ejecución. Una llamada a continue-as-new desde un bloque finallyno reinicia la orquestación tras una excepción no detectada.
Los resultados de cualquier tarea incompleta se descartan cuando una orquestación llama a continue-as-new. Por ejemplo, si se programa un temporizador y se llama a continue-as-new antes de que se active el temporizador, se descarta el evento del temporizador.
Opcionalmente, puede conservar eventos externos sin procesar en los reinicios de continue-as-new. En .NET y Java, continue-as-new conserva los eventos sin procesar de forma predeterminada. En Python, continue_as_new no conserva los eventos a menos que save_events=True. En JavaScript, continueAsNew requiere un saveEvents parámetro (true o false) para controlar este comportamiento. En todos los casos, los eventos sin procesar se entregan cuando la orquestación realiza la siguiente llamada a waitForExternalEvent o wait_for_external_event.

Ejemplo de trabajo periódico

Un caso de uso común para las orquestaciones permanentes es el trabajo periódico en segundo plano, como los trabajos de limpieza.

¿Por qué no usar un activador de temporizador? Un disparador de temporizador basado en CRON se ejecuta en momentos fijos, independientemente de si la ejecución anterior ha finalizado. Una orquestación eterna espera a que se complete el trabajo antes de programar la siguiente iteración, por lo que las ejecuciones nunca se superponen.

Approach	Programación (intervalo de 1 hora, trabajo de 30 minutos)	Riesgo de superposición
Desencadenador de temporizador (CRON)	1:00, 2:00, 3:00	Sí: si el trabajo supera el intervalo
Orquestación eterna	1:00, 2:30, 4:00	No: la próxima ejecución espera la finalización

[FunctionName("Periodic_Cleanup_Loop")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    await context.CallActivityAsync("DoCleanup", null);

    // sleep for one hour between cleanups
    DateTime nextCleanup = context.CurrentUtcDateTime.AddHours(1);
    await context.CreateTimer(nextCleanup, CancellationToken.None);

    context.ContinueAsNew(null);
}

const df = require("durable-functions");
const moment = require("moment");

module.exports = df.orchestrator(function*(context) {
    yield context.df.callActivity("DoCleanup");

    // sleep for one hour between cleanups
    const nextCleanup = moment.utc(context.df.currentUtcDateTime).add(1, "h");
    yield context.df.createTimer(nextCleanup.toDate());

    yield context.df.continueAsNew(undefined);
});

import azure.functions as func
import azure.durable_functions as df
from datetime import datetime, timedelta

def orchestrator_function(context: df.DurableOrchestrationContext):
    yield context.call_activity("DoCleanup")

    # sleep for one hour between cleanups
    next_cleanup = context.current_utc_datetime + timedelta(hours = 1)
    yield context.create_timer(next_cleanup)

    context.continue_as_new(None)

main = df.Orchestrator.create(orchestrator_function)

@FunctionName("Periodic_Cleanup_Loop")
public void periodicCleanupLoop(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    ctx.callActivity("DoCleanup").await();

    ctx.createTimer(Duration.ofHours(1)).await();

    ctx.continueAsNew(null);
}

public class PeriodicCleanupLoop : TaskOrchestrator<object?, object?>
{
    public override async Task<object?> RunAsync(TaskOrchestrationContext context, object? input)
    {
        await context.CallActivityAsync("DoCleanup");

        // sleep for one hour between cleanups
        await context.CreateTimer(TimeSpan.FromHours(1), CancellationToken.None);

        context.ContinueAsNew(null);
        return null;
    }
}

from datetime import timedelta
from durabletask import task

def do_cleanup(ctx: task.ActivityContext, _) -> None:
    # Cleanup logic here
    pass

def periodic_cleanup_loop(ctx: task.OrchestrationContext, _):
    yield ctx.call_activity(do_cleanup)

    # sleep for one hour between cleanups
    yield ctx.create_timer(timedelta(hours=1))

    ctx.continue_as_new(None)

public class PeriodicCleanupLoop implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        ctx.callActivity("DoCleanup").await();

        // sleep for one hour between cleanups
        ctx.createTimer(Duration.ofHours(1)).await();

        ctx.continueAsNew(null);
    }
}

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

const doCleanup = async (_: ActivityContext, _input: void): Promise<void> => {
    // Cleanup logic here
};

const periodicCleanupLoop: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    yield ctx.callActivity(doCleanup);

    // sleep for one hour between cleanups
    yield ctx.createTimer(60 * 60);

    ctx.continueAsNew(null, false);
};

Iniciar una orquestación eterna

Use el método de cliente durable start-new o schedule-new para iniciar una orquestación eterna, al igual que cualquier otra función de orquestación. Para asegurarse de que solo se ejecuta una instancia a la vez, use un identificador de instancia fijo. Para obtener más información, consulte Orquestaciones singleton.

[FunctionName("Trigger_Eternal_Orchestration")]
public static async Task<HttpResponseMessage> OrchestrationTrigger(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequestMessage request,
    [DurableClient] IDurableOrchestrationClient client)
{
    string instanceId = "StaticId";

    await client.StartNewAsync("Periodic_Cleanup_Loop", instanceId); 
    return client.CreateCheckStatusResponse(request, instanceId);
}

const df = require("durable-functions");

module.exports = async function (context, req) {
    const client = df.getClient(context);
    const instanceId = "StaticId";

    // null is used as the input, since there is no input in "Periodic_Cleanup_Loop".
    await client.startNew("Periodic_Cleanup_Loop", instanceId, null);

    context.log(`Started orchestration with ID = '${instanceId}'.`);
    return client.createCheckStatusResponse(context.bindingData.req, instanceId);
};

async def main(req: func.HttpRequest, starter: str) -> func.HttpResponse:
    client = df.DurableOrchestrationClient(starter)
    instance_id = 'StaticId'

    await client.start_new('Periodic_Cleanup_Loop', instance_id, None)

    logging.info(f"Started orchestration with ID = '{instance_id}'.")
    return client.create_check_status_response(req, instance_id)

@FunctionName("Trigger_Eternal_Orchestration")
public HttpResponseMessage triggerEternalOrchestration(
        @HttpTrigger(name = "req") HttpRequestMessage<?> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext) {

    String instanceID = "StaticID";
    DurableTaskClient client = durableContext.getClient();
    client.scheduleNewOrchestrationInstance("Periodic_Cleanup_Loop", null, instanceID);
    return durableContext.createCheckStatusResponse(req, instanceID);
}

Use el método de cliente schedule-new para iniciar una orquestación eterna, al igual que cualquier otra orquestación. Para asegurarse de que solo se ejecuta una instancia a la vez, use un identificador de instancia fijo. Para obtener más información, consulte Orquestaciones Singleton.

string instanceId = "StaticId";
await client.ScheduleNewOrchestrationInstanceAsync(
    "PeriodicCleanupLoop",
    null,
    new StartOrchestrationOptions { InstanceId = instanceId });

instance_id = "StaticId"
client.schedule_new_orchestration(periodic_cleanup_loop, instance_id=instance_id)

String instanceId = "StaticId";
client.scheduleNewOrchestrationInstance("PeriodicCleanupLoop", null, instanceId);

const instanceId = "StaticId";
await client.scheduleNewOrchestration(periodicCleanupLoop, undefined, instanceId);

Salir de una orquestación eterna

Si una función de orquestador necesita finalmente completarse, no llame a continue-as-new y permita que la función termine.

Si una función de orquestador está en un bucle infinito y debe detenerse, use la API de finalización del enlace de cliente de orquestación para detenerla.

await client.TerminateAsync(instanceId, "Cleanup no longer needed");

await client.terminate(instanceId, "Cleanup no longer needed");

await client.terminate(instance_id, "Cleanup no longer needed")

Stop-DurableOrchestration -InstanceId $instanceId -Reason "Cleanup no longer needed"

client.terminate(instanceId, "Cleanup no longer needed");

Para obtener más información, consulte Administración de instancias.

Si una orquestación necesita finalmente completarse, no llame a continue-as-new y permita que la orquestación termine.

Si una orquestación está en un bucle infinito y debe detenerse, use la API de finalización en el cliente de tareas duradero para detenerla.

await client.TerminateInstanceAsync(instanceId, "Cleanup no longer needed");

client.terminate_orchestration(instance_id, output="Cleanup no longer needed")

client.terminate(instanceId, "Cleanup no longer needed");

await client.terminateOrchestration(instanceId, "Cleanup no longer needed");

Pasos siguientes

Más información acerca de cómo implementar orquestaciones singleton

Introducción a los SDK de Durable Task

Comentarios

¿Le resultó útil esta página?

Last updated on 2026-04-28