Örök vezénylések Durable Functions (Azure Functions)

Az örök vezénylés olyan vezénylési függvények, amelyek soha nem érnek véget. Ezek akkor hasznosak, ha Durable Functions szeretne használni az összesítőkhöz és minden olyan forgatókönyvhöz, amely végtelen hurkot igényel.

Vezénylési előzmények

A vezénylési előzményekről szóló témakörben leírtak szerint a Durable Task Framework nyomon követi az egyes függvényvezénylések előzményeit. Ez az előzmény folyamatosan növekszik, amíg a vezénylő függvény továbbra is új munkát ütemez. Ha a vezénylő függvény végtelen hurokba kerül, és folyamatosan ütemezi a munkát, ez az előzmények kritikusan nagyok lehetnek, és jelentős teljesítményproblémákat okozhatnak. Az örök vezénylési koncepció úgy lett kialakítva, hogy enyhítse a végtelen hurkokat igénylő alkalmazások ilyen jellegű problémáit.

Alaphelyzetbe állítás és újraindítás

Végtelen hurkok használata helyett a vezénylési függvények alaphelyzetbe állítják az állapotukat a vezénylési trigger kötésénekújként történő meghívásával. Ez a metódus egy JSON-szerializálható paramétert használ, amely a következő vezénylőfüggvény-generáció új bemenete lesz.

Ha a folytatás újként van meghívva, a vezénylési példány újraindul az új bemeneti értékkel. A rendszer megőrzi ugyanazt a példányazonosítót, de a vezénylő függvény előzményei alaphelyzetbe lesznek állítva.

Megjegyzés

A Durable Task Framework ugyanazt a példányazonosítót tartja fenn, de belsőleg létrehoz egy új végrehajtási azonosítót a vezénylő függvényhez, amely a folytatással alaphelyzetbe áll. Ez a végrehajtási azonosító külsőleg nem érhető el, de hasznos lehet tudni a vezénylés végrehajtásának hibakereséséről.

Példa időszakos munkavégzésre

Az örök vezénylések egyik felhasználási esete az a kód, amely korlátlan ideig rendszeres munkát végez.

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

Megjegyzés

Az előző C#-példa a Durable Functions 2.x. Az 1.x Durable Functions helyett a parancsot kell használnia DurableOrchestrationContextIDurableOrchestrationContext. A verziók közötti különbségekről a verziók Durable Functions című cikkben talál további információt.

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

A PowerShell nem támogatja az újként történő folytatást.

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

A példa és az időzítő által aktivált függvény közötti különbség az, hogy a törlési eseményindítók időpontjai itt nem ütemezésen alapulnak. Például egy CRON-ütemezés, amely óránként hajt végre egy függvényt, 1:00-kor, 2:00-kor, 3:00-kor stb. hajtja végre, és átfedési problémákba ütközhet. Ebben a példában azonban, ha a törlés 30 percet vesz igénybe, akkor 1:00-ra, 2:30-ra, 4:00-ra stb. lesz ütemezve, és nincs esély az átfedésre.

Egy örök vezénylés indítása

A start-new vagy schedule-new durable client metódussal elindíthat egy örök vezénylést, ugyanúgy, mint bármely más vezénylési függvényt.

Megjegyzés

Ha meg kell győződnie arról, hogy egyetlen örök vezénylés fut, fontos, hogy a vezénylés indításakor ugyanazt a példányt id tartsa fenn. További információ: Példánykezelés.

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

Megjegyzés

Az előző kód a Durable Functions 2.x-hez készült. Az 1.x Durable Functions esetében attribútumot kell használnia OrchestrationClient az DurableClient attribútum helyett, és a DurableOrchestrationClient paramétertípust kell használnia a IDurableOrchestrationClienthelyett. A verziók közötti különbségekről a verziók Durable Functions című cikkben talál további információt.

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

A PowerShell nem támogatja az újként történő folytatást.

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

Kilépés az örök vezénylésből

Ha egy vezénylőfüggvénynek végül be kell fejeződnie, csak annyit kell tennie, hogy nem hívja ContinueAsNew meg, és hagyja, hogy a függvény kilépjen.

Ha egy vezénylőfüggvény végtelen hurokban van, és le kell állítani, a vezénylési ügyfélkötésleállítási API-ját használva állítsa le. További információ: Példánykezelés.

Következő lépések

Útmutató önálló vezénylések implementálásához