Eviga orkestreringar i Durable Functions (Azure Functions)

Evig orkestrering är orkestreringsfunktioner som aldrig tar slut. De är användbara när du vill använda Durable Functions för aggregeringar och alla scenarion som kräver en oändlig loop.

Orkestreringshistorik

Som förklaras i avsnittet om orkestreringshistorik håller Durable Task Framework reda på historiken för varje funktionsorkestrering. Den här historiken växer kontinuerligt så länge orchestrator-funktionen fortsätter att schemalägga nytt arbete. Om orchestrator-funktionen går in i en oändlig loop och kontinuerligt schemalägger arbete kan den här historiken bli kritiskt stor och orsaka betydande prestandaproblem. Det eviga orkestreringskonceptet utformades för att minimera den här typen av problem för program som behöver oändliga loopar.

Återställa och starta om

I stället för att använda oändliga loopar återställer orkestreringsfunktionerna sitt tillstånd genom att anropa metoden fortsätt som ny för orkestreringsutlösarbindningen. Den här metoden tar en JSON-serialiserbar parameter, som blir nya indata för nästa orchestrator-funktionsgenerering.

När continue-as-new anropas startar orkestreringsinstansen om sig själv med det nya indatavärdet. Samma instans-ID behålls, men orchestrator-funktionens historik återställs.

Anteckning

Durable Task Framework har samma instans-ID, men skapar internt ett nytt körnings-ID för orchestrator-funktionen som återställs av continue-as-new. Det här körnings-ID:t exponeras inte externt, men det kan vara bra att känna till när du felsöker orkestreringskörning.

Periodiskt arbetsexempel

Ett användningsfall för eviga orkestreringar är kod som behöver utföra periodiskt arbete på obestämd tid.

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

Anteckning

Föregående C#-exempel är för Durable Functions 2.x. För Durable Functions 1.x måste du använda DurableOrchestrationContext i stället för IDurableOrchestrationContext. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions versioner.

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 stöder inte 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);
}

Skillnaden mellan det här exemplet och en timerutlöst funktion är att rensningsutlösarens tider här inte baseras på ett schema. Ett CRON-schema som kör en funktion varje timme kör det till exempel kl. 1:00, 2:00, 3:00 osv. och kan eventuellt stöta på överlappande problem. Men om rensningen tar 30 minuter i det här exemplet schemaläggs den kl. 1:00, 2:30, 4:00 osv. och det finns ingen risk för överlappning.

Starta en evig orkestrering

Använd metoden start-new eller schedule-new durable client för att starta en evig orkestrering, precis som med andra orkestreringsfunktioner.

Anteckning

Om du behöver se till att en evig singleton-orkestrering körs är det viktigt att behålla samma instans id när du startar orkestreringen. Mer information finns i Instanshantering.

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

Anteckning

Den tidigare koden är för Durable Functions 2.x. För Durable Functions 1.x måste du använda OrchestrationClient attributet i stället för DurableClient attributet och du måste använda DurableOrchestrationClient parametertypen i stället för IDurableOrchestrationClient. Mer information om skillnaderna mellan versioner finns i artikeln Durable Functions versioner.

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 stöder inte 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);
}

Avsluta från en evig orkestrering

Om en orchestrator-funktion så småningom behöver slutföras behöver du inte anropa ContinueAsNew och låta funktionen avslutas.

Om en orchestrator-funktion finns i en oändlig loop och måste stoppas använder du slut-API :et för orkestreringsklientbindningen för att stoppa den. Mer information finns i Instanshantering.

Nästa steg

Lär dig hur du implementerar singleton-orkestreringar