Orchestrazioni perenni in Funzioni permanenti (Funzioni di Azure)

Articolo
06/01/2023

Le orchestrazioni perenni sono funzioni di orchestrazione che non terminano mai. Sono utili quando si vuole usare Funzioni permanenti per gli aggregatori e per qualsiasi scenario che richiede un ciclo infinito.

Cronologia di orchestrazione

Come illustrato nell'argomento della cronologia dell'orchestrazione , Durable Task Framework tiene traccia della cronologia di ogni orchestrazione di funzioni. Questa cronologia aumenta in modo costante finché la funzione dell'agente di orchestrazione continua a pianificare nuovo lavoro. Se la funzione dell'agente di orchestrazione entra in un ciclo infinito e pianifica lavoro in modo continuo, le dimensioni della cronologia potrebbero diventare eccessive con notevoli problemi a livello di prestazioni. Il concetto di orchestrazione perenne è stato ideato per ridurre questa tipologia di problemi per le applicazioni che necessitano di un ciclo infinito.

Reimpostazione e riavvio

Invece di usare cicli infiniti, le funzioni dell'agente di orchestrazione ne reimpostano lo stato chiamando il metodo continue-as-newdell'associazione del trigger di orchestrazione. Questo metodo accetta un parametro serializzabile JSON, che diventa il nuovo input per la generazione della funzione dell'agente di orchestrazione successiva.

Quando viene chiamato continue-as-new , l'istanza di orchestrazione viene riavviata con il nuovo valore di input. Lo stesso ID istanza viene mantenuto, ma la cronologia della funzione dell'agente di orchestrazione viene reimpostata.

Nota

Durable Task Framework mantiene lo stesso ID istanza, ma crea internamente un nuovo ID di esecuzione per la funzione dell'agente di orchestrazione che viene reimpostato continuando come nuovo. Questo ID di esecuzione non viene esposto esternamente, ma può essere utile sapere quando si esegue il debug dell'esecuzione dell'orchestrazione.

Esempio di operazioni periodiche

Un caso d'uso di orchestrazioni perenni è il codice che deve eseguire operazioni periodiche per un periodo illimitato.

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

Nota

L'esempio C# precedente è per Durable Functions 2.x. Per Durable Functions 1.x, è necessario usare DurableOrchestrationContext anziché IDurableOrchestrationContext. Per altre informazioni sulle differenze tra le versioni, vedere l'articolo Durable Functions versioni.

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

La differenza tra questo esempio e una funzione attivata da timer è che i tempi del trigger di pulizia non sono basati su una pianificazione. Ad esempio, una pianificazione CRON che esegue una funzione ogni ora verrà eseguita all'1:00, alle 2:00, alle 3:00 e così via e potrebbe potenzialmente generare problemi di sovrapposizione. In questo esempio, tuttavia, se la pulizia richiede 30 minuti, verrà pianificata all'1:00, alle 2:30, alle 4:00 e così via senza possibilità di sovrapposizione.

Avvio di un'orchestrazione eterna

Usare il metodo client durevole start-new o schedule-new per avviare un'orchestrazione eterna, proprio come qualsiasi altra funzione di orchestrazione.

Nota

Se è necessario assicurarsi che sia in esecuzione un'orchestrazione eterna singleton, è importante mantenere la stessa istanza id all'avvio dell'orchestrazione. Per altre informazioni, vedere Gestione delle istanze.

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

Nota

Il codice precedente è per Durable Functions 2.x. Per Durable Functions 1.x, è necessario usare OrchestrationClient l'attributo anziché l'attributo DurableClient ed è necessario usare il DurableOrchestrationClient tipo di parametro anziché IDurableOrchestrationClient. Per altre informazioni sulle differenze tra le versioni, vedere l'articolo Durable Functions versioni.

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

Uscire da un'orchestrazione perenne

Se una funzione dell'agente di orchestrazione deve essere completata, è sufficiente non chiamare ContinueAsNew e consentire l'uscita della funzione.

Se una funzione dell'agente di orchestrazione si trova in un ciclo infinito e deve essere arrestata, usare l'API terminatedell'associazione client di orchestrazione per arrestarla. Per altre informazioni, vedere Gestione delle istanze.

Passaggi successivi

Informazioni su come implementare le orchestrazioni singleton

Condividi tramite

Orchestrazioni perenni in Funzioni permanenti (Funzioni di Azure)

Cronologia di orchestrazione

Reimpostazione e riavvio

Esempio di operazioni periodiche

Avvio di un'orchestrazione eterna

Uscire da un'orchestrazione perenne

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive