Wieczne orkiestracje w Durable Functions (Azure Functions)

Orkiestracje wieczne to funkcje orkiestratora, które nigdy się nie kończą. Są one przydatne, gdy chcesz użyć Durable Functions dla agregatorów i dowolnego scenariusza, który wymaga nieskończonej pętli.

Historia orkiestracji

Jak wyjaśniono w temacie historia aranżacji , struktura Durable Task Framework śledzi historię każdej aranżacji funkcji. Ta historia stale rośnie, o ile funkcja orkiestratora nadal planuje nowe prace. Jeśli funkcja orkiestratora przechodzi w nieskończoną pętlę i stale planuje pracę, ta historia może być krytycznie duża i powodować znaczne problemy z wydajnością. Koncepcja wiecznej aranżacji została zaprojektowana w celu wyeliminowania tego rodzaju problemów dla aplikacji, które wymagają nieskończonych pętli.

Resetowanie i ponowne uruchamianie

Zamiast używać nieskończonych pętli, funkcje orkiestratora resetują swój stan, wywołując metodę kontynuuj jako nową metodę powiązania wyzwalacza aranżacji. 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 polecenia kontynuuj jako nowy wystąpienie orkiestracji uruchamia się ponownie przy użyciu nowej wartości wejściowej. Ten sam identyfikator wystąpienia jest zachowywany, ale historia funkcji orkiestratora jest resetowany.

Uwaga

Rozszerzenie Durable Task Framework zachowuje ten sam identyfikator wystąpienia, ale wewnętrznie tworzy nowy identyfikator wykonania dla funkcji orkiestratora, która zostanie zresetowana przez kontynuowanie jako nowe. Ten identyfikator wykonywania nie jest uwidaczniony zewnętrznie, ale może być przydatny podczas debugowania wykonywania orkiestracji.

Przykład pracy okresowej

Jednym z przypadków użycia wiecznych aranżacji jest kod, który musi wykonywać okresową pracę na czas nieokreślony.

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

Uwaga

Poprzedni przykład w języku C# dotyczy Durable Functions 2.x. W przypadku Durable Functions 1.x należy użyć wartości DurableOrchestrationContext zamiast IDurableOrchestrationContext. Aby uzyskać więcej informacji na temat różnic między wersjami, zobacz artykuł Durable Functions versions (Wersje Durable Functions).

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)

Program PowerShell

Program PowerShell nie obsługuje kontynuacji jako nowego.

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

Różnica między tym przykładem a funkcją wyzwalaną czasomierzem polega na tym, że czasy wyzwalacza oczyszczania nie są oparte na harmonogramie. Na przykład harmonogram CRON, który wykonuje funkcję co godzinę, wykona ją o godzinie 1:00, 2:00, 3:00 itp. i może potencjalnie napotkać nakładające się problemy. W tym przykładzie jednak jeśli czyszczenie trwa 30 minut, zostanie zaplanowane o godzinie 1:00, 2:30, 4:00 itd. i nie ma szans na nakładanie się.

Rozpoczynanie wiecznej aranżacji

Użyj metody klienta o nazwie start-new lub schedule-new , aby rozpocząć wieczną aranżację, tak jak w przypadku każdej innej funkcji orkiestracji.

Uwaga

Jeśli musisz upewnić się, że pojedyncza wieczna orkiestracja jest uruchomiona, ważne jest, aby zachować to samo wystąpienie id podczas uruchamiania orkiestracji. Aby uzyskać więcej informacji, zobacz Zarządzanie wystąpieniami.

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

Uwaga

Poprzedni kod jest przeznaczony dla Durable Functions 2.x. W przypadku Durable Functions 1.x należy użyć OrchestrationClient atrybutu zamiast atrybutu DurableClient i należy użyć typu parametru DurableOrchestrationClientIDurableOrchestrationClientzamiast . Aby uzyskać więcej informacji na temat różnic między wersjami, zobacz artykuł Durable Functions versions (Wersje 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)

Program PowerShell

Program PowerShell nie obsługuje kontynuacji jako nowego.

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

Wyjście z wiecznej orkiestracji

Jeśli funkcja orkiestratora musi zakończyć się ostatecznie, to wszystko, co musisz zrobić, nie jest wywoływane ContinueAsNew i niech funkcja zakończy działanie.

Jeśli funkcja orkiestratora znajduje się w nieskończonej pętli i musi zostać zatrzymana, użyj interfejsu API zakończeniapowiązania klienta orkiestracji , aby go zatrzymać. Aby uzyskać więcej informacji, zobacz Zarządzanie wystąpieniami.

Następne kroki

Dowiedz się, jak zaimplementować aranżacje pojedyncze