Orquestrações eternas em Durable Functions (Funções do Azure)

Orquestrações eternas são funções orquestradoras que nunca terminam. São úteis quando pretende utilizar Durable Functions para agregadores e qualquer cenário que exija um ciclo infinito.

Histórico de orquestrações

Conforme explicado no tópico de história da orquestração , o Durable Task Framework mantém um registo da história de cada orquestração de funções. Esta história cresce continuamente, desde que a função do orquestrador continue a agendar novos trabalhos. Se a função do orquestrador entrar num ciclo infinito e agendar continuamente o trabalho, este histórico poderá aumentar de forma crítica e causar problemas de desempenho significativos. O conceito de orquestração eterna foi concebido para mitigar este tipo de problemas para aplicações que precisam de ciclos infinitos.

Repor e reiniciar

Em vez de utilizar ciclos infinitos, as funções do orquestrador repõem o respetivo estado ao chamar o método continue-as-new do enlace do acionador de orquestração. Este método utiliza um parâmetro serializável JSON, que se torna a nova entrada para a próxima geração de funções do orquestrador.

Quando continua como novo é chamado, a instância de orquestração reinicia-se com o novo valor de entrada. O mesmo ID de instância é mantido, mas o histórico da função do orquestrador é reposto.

Nota

O Durable Task Framework mantém o mesmo ID de instância, mas cria internamente um novo ID de execução para a função orchestrator que é reposta por continue-as-new. Este ID de execução não é exposto externamente, mas pode ser útil saber quando depurar a execução da orquestração.

Exemplo de trabalho periódico

Um caso de utilização para orquestrações eternas é o código que precisa de fazer trabalho periódico indefinidamente.

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

Nota

O exemplo C# anterior é para Durable Functions 2.x. Para Durable Functions 1.x, tem de utilizar DurableOrchestrationContext em vez de IDurableOrchestrationContext. Para obter mais informações sobre as diferenças entre versões, consulte o artigo Durable Functions versões.

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

O PowerShell não suporta a continuação como nova.

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 diferença entre este exemplo e uma função acionada pelo temporizador é que os tempos de acionador de limpeza aqui não se baseiam numa agenda. Por exemplo, uma agenda CRON que executa uma função a cada hora irá executá-la às 1:00, 2:00, 3:00, etc. e pode potencialmente encontrar problemas de sobreposição. Neste exemplo, no entanto, se a limpeza demorar 30 minutos, será agendada às 1:00, 2:30, 4:00, etc. e não há hipótese de sobreposição.

Iniciar uma orquestração eterna

Utilize o método start-new ou schedule-new durable client para iniciar uma orquestração eterna, tal como faria com qualquer outra função de orquestração.

Nota

Se precisar de garantir que uma orquestração eterna singleton está em execução, é importante manter a mesma instância id ao iniciar a orquestração. Para obter mais informações, veja Gestão de Instâncias.

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

Nota

O código anterior destina-se a Durable Functions 2.x. Para Durable Functions 1.x, tem de utilizar OrchestrationClient o atributo em vez do DurableClient atributo e tem de utilizar o DurableOrchestrationClient tipo de parâmetro em vez de IDurableOrchestrationClient. Para obter mais informações sobre as diferenças entre versões, consulte o artigo Durable Functions versões.

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

O PowerShell não suporta a continuação como nova.

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

Sair de uma orquestração eterna

Se uma função do orquestrador precisar de ser concluída eventualmente, tudo o que precisa de fazer é não ligar ContinueAsNew e deixar a função sair.

Se uma função de orquestrador estiver num ciclo infinito e precisar de ser parada, utilize a API de terminação do enlace do cliente de orquestração para a parar. Para obter mais informações, veja Gestão de Instâncias.

Passos seguintes

Saiba como implementar orquestrações singleton