Вечные оркестрации

Вечные оркестрации — это функции оркестратора, которые никогда не заканчиваются. Они полезны, если вы хотите использовать Durable Functions для агрегаторов и любой сценарий, требующий бесконечного цикла.

Вечные оркестрации — это оркестрации , которые никогда не заканчиваются. Они полезны, если вы хотите использовать долговечные оркестрации для агрегаторов и любого сценария, требующего бесконечного цикла.

Это важно

В настоящее время пакет SDK для устойчивых задач PowerShell недоступен.

История оркестрации

Как описано в разделе история оркестрации, платформа Durable Task отслеживает историю каждой оркестрации функций. Эта история постоянно растет до тех пор, пока функция оркестратора планирует новую работу. Если функция оркестратора переходит в бесконечный цикл и постоянно планирует работу, история может критически увеличиться и привести к значительным проблемам производительности. Концепция вечной оркестрации была разработана для устранения таких проблем для приложений, которым требуются бесконечные циклы.

Пакеты SDK Durable Task отслеживают историю каждой оркестрации. Эта история постоянно растет до тех пор, пока оркестрация планирует новую работу. Если оркестрация переходит в бесконечный цикл и постоянно планирует работу, история может значительно увеличиться и вызвать значительные проблемы с производительностью. Концепция вечной оркестрации была разработана для устранения таких проблем для приложений, которым требуются бесконечные циклы.

Настройка и перезапуск

Вместо использования бесконечных циклов функции оркестратора сбрасывают своё состояние, вызывая метод привязки триггера оркестрации . Этот метод принимает параметр, сериализуемый в JSON, который становится новыми входными данными для следующего запуска функции оркестратора.

При вызове continue-as-new экземпляр оркестрации перезапускается с новым входным значением. Тот же идентификатор экземпляра сохраняется, но история функции оркестратора сбрасывается.

Вместо использования бесконечных циклов, оркестрации сбрасывают свое состояние, вызывая метод continue-as-new в контексте оркестрации. Этот метод принимает параметр, сериализуемый в JSON, который становится новым входным данными для следующего цикла оркестрации.

При вызове continue-as-new экземпляр оркестрации перезапускается с новым входным значением. Тот же идентификатор экземпляра сохраняется, но журнал оркестрации сбрасывается.

Рекомендации по постоянной оркестрации

Помните об этом при использовании метода continue-as-new в схемах оркестрации:

• При сбросе функции оркестратора методом continue-as-new фреймворк Durable Task сохраняет тот же идентификатор экземпляра, но внутренне создает и использует новый идентификатор выполнения. Этот идентификатор выполнения не раскрывается внешне, но полезен для отладки выполнения оркестрации.

• Когда необработанное исключение возникает во время выполнения, оркестрация вводит состояние сбоя и завершает выполнение. В этом состоянии вызов continue-as-new из finally блока инструкции try-catch не может перезапустить оркестрацию.

Это важно

Если оркестрация сталкивается с неуловимым исключением во время выполнения, оркестрация вводит состояние "сбой" и выполнение завершается. В частности, это означает, что вызов функции continue-as-new, даже если использование происходит в блоке finally, не перезапускает оркестрацию в случае необработанного исключения.

Помните об этом при использовании метода continue-as-new в схемах оркестрации:

• Когда оркестрация сбрасывается с использованием метода , SDK устойчивых задач сохраняют тот же идентификатор экземпляра, но внутренне создавая и используя новый идентификатор выполнения . Этот идентификатор выполнения не доступен извне, но может быть полезен при отладке выполнения оркестрации.

• Когда необработанное исключение возникает во время выполнения, оркестрация вводит состояние сбоя и завершает выполнение. В этом состоянии вызов continue-as-new из finally блока инструкции try-catch не может перезапустить оркестрацию.

• Результаты любых неполных задач удаляются при вызове continue-as-newоркестрации. Например, если таймер запланирован, а затем continue-as-new вызывается до запуска таймера, событие таймера отменяется.

• При необходимости можно сохранять необработанные внешние события при continue-as-new перезапусках. В .NET и Java continue-as-new сохраняет необработанные события по умолчанию. В Python continue_as_new не сохраняет события, если только save_events=True. В JavaScript continueAsNew нужен параметр saveEvents (true или false) для управления этим поведением. Во всех случаях необработанные события доставляются при следующем вызове оркестрации waitForExternalEvent или wait_for_external_event.

Это важно

Если оркестрация сталкивается с неуловимым исключением во время выполнения, оркестрация вводит состояние "сбой" и выполнение завершается. В частности, это означает, что вызов функции continue-as-new, даже если использование происходит в блоке finally, не перезапускает оркестрацию в случае необработанного исключения.

Пример периодической работы

Одним из вариантов использования для вечной оркестрации является код, который периодически работает бесконечно.

C#

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

Замечание

Предыдущий пример C# предназначен для Durable Functions 2.x. Для Durable Functions 1.x необходимо использовать DurableOrchestrationContext вместо IDurableOrchestrationContext. Дополнительные сведения о различиях между версиями см. в статье о версиях устойчивых функций .

JavaScript

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

Python

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)

PowerShell

PowerShell не поддерживает continue-as-new.

Java

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

Разница между этим примером и функцией, активирующей таймер, заключается в том, что время запуска очистки не зависит от расписания. Например, расписание CRON, которое выполняет функцию каждый час, выполняется в 1:00, 2:00, 3:00 и т. д. и т. д., и может привести к перекрывающимся проблемам. В этом примере, если очистка занимает 30 минут, она планируется на 1:00, 2:30, 4:00 и так далее, и исключается вероятность пересечения.

C#

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

Python

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)

Java

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

JavaScript

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

PowerShell

Пакет SDK для устойчивых задач недоступен для PowerShell. Вместо этого используйте Durable Functions.

Разница между этим примером и подходом на основе таймера заключается в том, что время запуска очистки не основано на расписании. Например, расписание, которое выполняется каждый час в 1:00, 2:00, 3:00 и т. д., и т. д., и может потенциально столкнуться с перекрывающимися проблемами. В этом примере, если очистка занимает 30 минут, она планируется на 1:00, 2:30, 4:00 и так далее, и исключается вероятность пересечения.

Запустить вечную оркестрацию

Используйте метод клиента старт-новый или план-новый для запуска бессрочной оркестрации, как и для всех остальных функций оркестрации.

Замечание

Если необходимо убедиться, что выполняется синглтонная вечная оркестрация, используйте тот же идентификатор id при запуске оркестрации. Дополнительные сведения см. в разделе Управление экземплярами.

C#

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

Замечание

Предыдущий код предназначен для Durable Functions 2.x. Для устойчивых функций 1.x используйте атрибут OrchestrationClient вместо атрибута DurableClient, и используйте тип параметра DurableOrchestrationClient вместо IDurableOrchestrationClient. Для получения дополнительной информации о различиях между версиями см. версии Durable Functions.

JavaScript

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

Python

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)

PowerShell

PowerShell не поддерживает continue-as-new.

Java

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

Используйте метод клиента schedule-new для запуска непрерывной оркестрации, точно так же как для других видов оркестраций.

Замечание

Если необходимо убедиться, что выполняется синглтонная вечная оркестрация, используйте тот же идентификатор id при запуске оркестрации.

C#

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

Python

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

Java

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

JavaScript

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

PowerShell

Пакет SDK для устойчивых задач недоступен для PowerShell. Вместо этого используйте Durable Functions.

Выход из вечной оркестрации

Если функция оркестратора должна завершиться в конечном итоге, не вызывайте ContinueAsNew и дайте функции завершить выполнение.

Если функция оркестратора находится в бесконечном цикле и её нужно остановить, используйте API terminateпривязки клиента оркестрации, чтобы завершить её. Дополнительные сведения см. в разделе Управление экземплярами.

Если оркестрация должна завершиться в конечном итоге, не вызывайте continue-as-new и не позволяйте оркестрации выйти.

Если оркестрация находится в бесконечном цикле и должна быть остановлена, используйте API завершения на клиенте устойчивых задач, чтобы остановить его.

C#

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

Python

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

Java

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

JavaScript

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

PowerShell

Пакет SDK для устойчивых задач недоступен для PowerShell. Вместо этого используйте Durable Functions.

Дальнейшие действия

Узнайте, как реализовать однотонные оркестрации

Начало работы с Durable Task SDK