Wieczne orkiestracje

Ważna

Wsparcie dla modelu w toku zakończy się 10 listopada 2026 r. Zdecydowanie zalecamy przeprowadzenie migracji aplikacji do izolowanego modelu roboczego w celu uzyskania pełnej obsługi.

Orkiestracje wieczne to funkcje orkiestratora, które działają bezterminowo, okresowo resetując własną historię za pomocą continue-as-new API. Są one przydatne w przypadku agregatorów, okresowych zadań w tle i dowolnego scenariusza Durable Functions, który wymaga nieskończonej pętli bez nieograniczonego wzrostu historii.

Bez continue-as-neworkiestratora, który działa w nieskończonej pętli, gromadzącego z każdą zaplanowaną operacją historię orkiestracji, ostatecznie dochodzi do problemów z wydajnością i nadmiernego użycia pamięci. Wieczny wzorzec aranżacji rozwiązuje ten problem, resetując historię w każdej iteracji.

Uwaga / Notatka

Przykłady kodu dla trwałej orkiestracji są dostępne dla języków C#, JavaScript, Python i Java. Program PowerShell nie obsługuje continue-as-new.

W tym artykule:

Jak działa dalsze działanie jako nowe — mechanizm resetowania
Zagadnienia — zachowanie wyjątku, niekompletne zadania i zdarzenia zewnętrzne
Przykład pracy okresowej — pętla oczyszczania, która pozwala uniknąć nakładania się timera
Rozpocznij wieczne orkiestracje — uruchamianie i wzorce singleton
Wyjście z wiecznej orkiestracji — płynne zatrzymanie oraz zakończenie

Orkiestracje wieczne to orkiestracje, które działają bezterminowo, okresowo resetując swoją historię przy użyciu interfejsu continue-as-new API. Są one przydatne w agregatorach, okresowych zadaniach w tle i każdym scenariuszu, który wymaga nieskończonej pętli bez niekontrolowanego rozrostu historii.

Bez continue-as-new orkiestracji, która zapętla się w nieskończoność i gromadzi historię przy każdym zaplanowanym zadaniu, w końcu powoduje problemy z wydajnością i zbyt duże zużycie pamięci. Wieczny wzorzec aranżacji rozwiązuje ten problem, resetując historię w każdej iteracji.

Ważna

Obecnie zestaw POWERShell Durable Task SDK nie jest dostępny.

W tym artykule:

Jak działa dalsze działanie jako nowe — mechanizm resetowania
Zagadnienia — zachowanie wyjątku, niekompletne zadania i zdarzenia zewnętrzne
Przykład pracy okresowej — pętla oczyszczania, która pozwala uniknąć nakładania się timera
Rozpocznij wieczne orkiestracje — uruchamianie i wzorce singleton
Wyjście z wiecznej orkiestracji — płynne zatrzymanie oraz zakończenie

Jak działa kontynuacja zgodnie z nowym działaniem

Zamiast używać nieskończonych pętli, funkcje orkiestratora resetują swój stan, wywołując metodę continue-as-newpowiązania wyzwalacza orkiestracji. Ta metoda przyjmuje parametr z możliwością serializacji JSON, który staje się nowym wejściem dla następnej generacji funkcji orkiestratora.

Po wywołaniu continue-as-new wystąpienie orkiestracji restartuje się z nową wartością wejściową. Ten sam identyfikator wystąpienia jest zachowywany, ale historia funkcji orkiestratora jest resetowana.

Zamiast używać nieskończonych pętli, orkiestracje resetują swój stan, wywołując metodę continue-as-new w kontekście aranżacji. Ta metoda przyjmuje parametr z możliwością serializacji JSON, który staje się nowym wejściem dla następnej generacji aranżacji.

Po wywołaniu continue-as-new wystąpienie orkiestracji restartuje się z nową wartością wejściową. Ten sam identyfikator wystąpienia jest zachowywany, ale historia orkiestracji jest resetowana.

Zagadnienia dotyczące orkiestracji wiecznej

Podczas używania continue-as-new metody w aranżacji należy pamiętać o następujących kwestiach:

Gdy funkcja orkiestratora zostanie zresetowana przy użyciu metody continue-as-new, Durable Task Framework zachowuje ten sam identyfikator wystąpienia, ale wewnętrznie tworzy i używa nowego identyfikatora wykonania na przyszłość. Ten identyfikator uruchomienia nie jest udostępniony zewnętrznie, ale jest przydatny podczas debugowania wykonywania orkiestracji.
Gdy podczas wykonywania wystąpi nieobsługiwany wyjątek, orkiestracja przechodzi w stan niepowodzenia i kończy wykonywanie. Wywołanie metody continue-as-new z finally bloku nie powoduje ponownego uruchomienia aranżacji po wystąpieniu wyjątku nieuchwyconego.
Wyniki wszystkich niekompletnych zadań są odrzucane, gdy orkiestracja wywołuje continue-as-new. Jeśli na przykład czasomierz jest zaplanowany, a następnie continue-as-new zostanie wywołany przed uruchomieniem czasomierza, zdarzenie czasomierza zostanie odrzucone.
Opcjonalnie można zachować nieprzetworzone zdarzenia zewnętrzne podczas continue-as-new ponownych uruchomień. W języku C# ContinueAsNew domyślnie zachowuje nieprzetworzone zdarzenia. W Java continueAsNew również domyślnie zachowuje zdarzenia. W Python continue_as_new nie zachowuje zdarzeń, chyba że save_events=True. W języku JavaScript continueAsNew wymaga parametru saveEvents (true lub false) w celu kontrolowania tego zachowania.

Podczas używania continue-as-new metody w aranżacji należy pamiętać o następujących kwestiach:

Gdy orkiestracja zostanie zresetowana przy użyciu metody continue-as-new, zestawy SDK zadań trwałych zachowują ten sam identyfikator wystąpienia, ale wewnętrznie tworzą i używają nowego identyfikatora wykonania na przyszłość. Ten identyfikator wykonania nie jest widoczny zewnętrznie, ale może być przydatny podczas debugowania procesów orkiestracyjnych.
Gdy podczas wykonywania wystąpi nieobsługiwany wyjątek, orkiestracja przechodzi w stan niepowodzenia i kończy wykonywanie. Wywołanie metody continue-as-new z finally bloku nie powoduje ponownego uruchomienia aranżacji po wystąpieniu wyjątku nieuchwyconego.
Wyniki wszystkich niekompletnych zadań są odrzucane, gdy orkiestracja wywołuje continue-as-new. Jeśli na przykład czasomierz jest zaplanowany, a następnie continue-as-new zostanie wywołany przed uruchomieniem czasomierza, zdarzenie czasomierza zostanie odrzucone.
Opcjonalnie można zachować nieprzetworzone zdarzenia zewnętrzne podczas continue-as-new ponownych uruchomień. W .NET i Java continue-as-new domyślnie zachowuje nieprzetworzone zdarzenia. W Python continue_as_new nie zachowuje zdarzeń, chyba że save_events=True. W języku JavaScript continueAsNew wymaga parametru saveEvents (true lub false) w celu kontrolowania tego zachowania. We wszystkich przypadkach nieprzetworzone zdarzenia są dostarczane, gdy orkiestracja następnie wywołuje waitForExternalEvent lub wait_for_external_event.

Przykład pracy okresowej

Jednym z typowych przypadków użycia trwałych orkiestracji jest okresowa praca w tle, taka jak zadania czyszczące.

Dlaczego nie używać wyzwalacza czasomierza? Wyzwalacz czasomierza oparty na CRON jest uruchamiany w stałych godzinach niezależnie od tego, czy poprzednie uruchomienie zostało zakończone. Wieczna orkiestracja czeka na ukończenie operacji przed zaplanowaniem następnej iteracji, więc operacje nigdy się nie nakładają.

Approach	Harmonogram (1-godzinny interwał, 30-minutowe zadanie)	Nakładanie się ryzyka
Wyzwalacz czasomierza (CRON)	1:00, 2:00, 3:00	Tak — jeśli zadanie przekracza interwał
Wieczna orkiestracja	1:00, 2:30, 4:00	Nie — następne uruchomienie czeka na ukończenie

Model izolowanego pracownika

[Function("Periodic_Cleanup_Loop")]
public static async Task Run(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    await context.CallActivityAsync("DoCleanup");

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

    context.ContinueAsNew(null);
}

Model w trakcie przetwarzania

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

Rozpoczynanie wiecznej aranżacji

Użyj metody start-new klienta trwałego lub schedule-new, aby rozpocząć wieczną orkiestrację, podobnie jak każdą inną funkcję orkiestracji. Aby zapewnić, że tylko jedno wystąpienie jest uruchamiane w danym momencie, użyj stałego identyfikatora wystąpienia. Aby uzyskać więcej informacji, zobacz Orkiestracje Singleton.

Model izolowanego pracownika

[Function("Trigger_Eternal_Orchestration")]
public static async Task<HttpResponseData> OrchestrationTrigger(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData request,
    [DurableClient] DurableTaskClient client)
{
    string instanceId = "StaticId";

    await client.ScheduleNewOrchestrationInstanceAsync(
        "Periodic_Cleanup_Loop",
        null,
        new StartOrchestrationOptions { InstanceId = instanceId });
    return await client.CreateCheckStatusResponseAsync(request, instanceId);
}

Model w trakcie przetwarzania

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

Użyj metody client schedule-new, aby rozpocząć nieskończoną orkiestrację, podobnie jak w przypadku każdej innej orkiestracji. Aby zapewnić, że tylko jedno wystąpienie jest uruchamiane w danym momencie, użyj stałego identyfikatora wystąpienia. Aby uzyskać więcej informacji, zobacz Orkiestracje 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);

Wyjście z wiecznej orkiestracji

Jeśli funkcja orkiestratora musi ostatecznie się zakończyć, nie wykonuj continue-as-new i pozwól funkcji się zakończyć.

Jeśli funkcja orkiestratora znajduje się w nieskończonej pętli i musi zostać zatrzymana, użyj interfejsu API terminate powiązania klienta orkiestracji , aby go zatrzymać.

Model izolowanego pracownika

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

Model w trakcie przetwarzania

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

Aby uzyskać więcej informacji, zobacz Zarządzanie wystąpieniami.

Jeśli orkiestracja musi ostatecznie się zakończyć, nie wywołuj metody continue-as-new i pozwól, aby orkiestracja się zakończyła.

Jeśli orkiestracja znajduje się w nieskończonej pętli i musi zostać zatrzymana, użyj interfejsu API terminate na kliencie zadań Durable, aby ją zatrzymać.

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

Następne kroki

Dowiedz się, jak zaimplementować singelton orkiestracje

Rozpocznij pracę z zestawami SDK Durable Task

Opinia

Czy ta strona była pomocna?

Last updated on 2026-04-28

Wieczne orkiestracje

Jak działa kontynuacja zgodnie z nowym działaniem

Zagadnienia dotyczące orkiestracji wiecznej

Przykład pracy okresowej

Rozpoczynanie wiecznej aranżacji

Wyjście z wiecznej orkiestracji

Następne kroki

Opinia

Dodatkowe zasoby