Věčná orchestrace v Durable Functions (Azure Functions)

Věčná orchestrace jsou funkce orchestrátoru, které nikdy nekončí. Jsou užitečné, když chcete použít Durable Functions pro agregátory a všechny scénáře, které vyžadují nekonečnou smyčku.

Historie orchestrace

Jak je vysvětleno v tématu historie orchestrace , architektura durable task framework sleduje historii orchestrace jednotlivých funkcí. Tato historie se neustále rozšiřuje, dokud funkce orchestrátoru pokračuje v plánování nové práce. Pokud funkce orchestrátoru přejde do nekonečné smyčky a nepřetržitě plánuje pracovat, může se tato historie kriticky zvětšit a způsobit významné problémy s výkonem. Koncept věčné orchestrace byl navržen tak, aby zmírnil tyto druhy problémů u aplikací, které potřebují nekonečné smyčky.

Resetování a restartování

Místo použití nekonečných smyček funkce orchestrátoru resetují svůj stav voláním metody continue-as-newvazby triggeru orchestrace. Tato metoda přebírá serializovatelný parametr JSON, který se stane novým vstupem pro další generování funkce orchestrátoru.

Při zavolání continue-as-new se instance orchestrace sama restartuje s novou vstupní hodnotou. Zachová se stejné ID instance, ale historie funkce orchestratoru se resetuje.

Poznámka

Durable Task Framework udržuje stejné ID instance, ale interně vytvoří nové ID spuštění pro funkci orchestrátoru, která se resetuje pokračováním jako novou. Toto ID spuštění není vystaveno externě, ale může být užitečné vědět o ladění provádění orchestrace.

Příklad pravidelné práce

Jedním z případů použití pro věčnou orchestraci je kód, který musí provádět pravidelnou práci po neomezenou dobu.

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

Poznámka

Předchozí příklad jazyka C# je pro Durable Functions 2.x. Pro Durable Functions 1.x musíte místo IDurableOrchestrationContextpoužít DurableOrchestrationContext . Další informace o rozdílech mezi verzemi najdete v článku Durable Functions verze.

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 nepodporuje pokračování jako nový.

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

Rozdíl mezi tímto příkladem a funkcí aktivovanou časovačem spočívá v tom, že časy triggeru vyčištění nejsou založené na plánu. Například plán CRON, který spouští funkci každou hodinu, ji spustí v 1:00, 2:00, 3:00 atd. a může potenciálně narazit na problémy s překrývajícími se. Pokud ale v tomto příkladu vyčištění trvá 30 minut, bude naplánováno na 1:00, 2:30, 4:00 atd. a neexistuje žádná možnost překrytí.

Zahájení věčné orchestrace

Pomocí metody trvalého klienta start-new nebo schedule-new spusťte trvalou orchestraci stejně jako u jakékoli jiné funkce orchestrace.

Poznámka

Pokud potřebujete zajistit, aby byla spuštěna jednorázová věčná orchestrace, je důležité při spouštění orchestrace zachovat stejnou instanci id . Další informace najdete v tématu Správa instancí.

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

Poznámka

Předchozí kód je pro Durable Functions 2.x. Pro Durable Functions 1.x musíte místo atributu použít OrchestrationClient atribut a místo parametru DurableOrchestrationClient použít typ parametru IDurableOrchestrationClient.DurableClient Další informace o rozdílech mezi verzemi najdete v článku Durable Functions verze.

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 nepodporuje pokračování jako nový.

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

Ukončení věčné orchestrace

Pokud je potřeba funkci orchestrátoru nakonec dokončit, stačí nevolatContinueAsNew a nechat funkci ukončit.

Pokud je funkce orchestrátoru v nekonečné smyčce a je potřeba ji zastavit, zastavte ji pomocí rozhraní API pro ukončenívazby klienta orchestrace . Další informace najdete v tématu Správa instancí.

Další kroky

Naučte se implementovat jednoúčelové orchestrace.