Hibák és újrapróbálkozások kezelése orkestrációkban

A Durable Functions vezényléseket kódban implementálhatja, így a nyelv beépített hibakezelési funkcióit használhatja. A hibakezelés és a kompenzáció nem igényel új fogalmakat, de néhány vezénylési viselkedésről érdemes tudni.

Megjegyzés:

Az Azure Functions Node.js programozási modelljének 4. verziója általánosan elérhető. A v4-es modell úgy lett kialakítva, hogy rugalmasabb és intuitívabb élményt nyújtson a JavaScript- és TypeScript-fejlesztők számára. A v3 és a v4 közötti különbségekről további információt a migrálási útmutatóban talál.

A következő kódrészletekben a JavaScript (PM4) a v4-es programozási modellt, az új élményt jelöli.

A felhőszolgáltatásokat használó alkalmazásoknak kezelni kell a hibákat, és az ügyféloldali újrapróbálkozások fontos részét képezik a tervezésnek. A Durable Task SDK-k támogatják a hibakezelést, az újrapróbálkozásokat és az időtúllépéseket a robusztus munkafolyamatok létrehozásához.

Tevékenységfüggvények és alvezérlések hibáinak kezelése

Durable Functions esetében a tevékenységfüggvényeken vagy alvezényléseken belül felmerülő kezeletlen kivételeket szabványos kivételtípusok használatával visszaküldik a vezénylő függvényhez.

A következő orchestrator függvény két számla között utal át pénzt:

C#

Izolált munkavállalói modell

A Durable Functions C# izolált, nem kezelt kivételei TaskFailedException néven jelennek meg.

A kivételüzenet általában azonosítja, hogy mely tevékenységfüggvények vagy al-vezénylések okozták a hibát. A részletesebb hibainformációk eléréséhez vizsgálja meg a FailureDetails tulajdonságot .

[FunctionName("TransferFunds")]
public static async Task Run(
    [OrchestrationTrigger] TaskOrchestrationContext context, TransferOperation transferDetails)
{
    await context.CallActivityAsync("DebitAccount",
        new
        {
            Account = transferDetails.SourceAccount,
            Amount = transferDetails.Amount
        });

    try
    {
        await context.CallActivityAsync("CreditAccount",
            new
            {
                Account = transferDetails.DestinationAccount,
                Amount = transferDetails.Amount
            });
    }
    catch (TaskFailedException)
    {
        // Refund the source account.
        // Another try/catch could be used here based on the needs of the application.
        await context.CallActivityAsync("CreditAccount",
            new
            {
                Account = transferDetails.SourceAccount,
                Amount = transferDetails.Amount
            });
    }
}

Megjegyzés:

• A kivételüzenet általában azonosítja, hogy mely tevékenységfüggvények vagy al-vezénylések okozták a hibát. A részletesebb hibainformációk eléréséhez vizsgálja meg a tulajdonságot FailureDetails .
• Alapértelmezés szerint tartalmazza a FailureDetails, a hibaüzenetet, a veremkövetést és a beágyazott belső kivételeket (mindegyik rekurzív objektumként van jelölveFailureDetails). Ha további egyéni kivételtulajdonságokat szeretne felvenni a hibakimenetbe, tekintse meg a Hibakezelési Részletek egyéni kivétel tulajdonságainak felvétele (.NET izolált) című témakört.

Fontos

Migrálási megjegyzés (folyamatban az elkülönítéshez): A folyamatban lévő modellben FunctionFailedException.InnerException a tevékenység által elvetett eredeti kivételobjektumot tartalmazza, amelyet közvetlenül vethet és vizsgálhat meg. Az izolált feldolgozói TaskFailedException nem tartalmazza az eredeti kivételt InnerException. Ehelyett a hiba részletei csak a FailureDetails tulajdonságon keresztül érhetők el, amely sztringalapú tulajdonságokat (ErrorType, ErrorMessage, StackTrace) biztosít. Az eredeti kivételobjektumot nem lehet közvetlenül leadni vagy elérni. Az eredeti kivételtípus ellenőrzésére használható FailureDetails.IsCausedBy<T>() .

Folyamaton belüli modell

A Durable Functions C# in-process használata esetén a nem kezelt kivételek FunctionFailedException néven jelennek meg.

A kivételüzenet általában tartalmazza a sikertelen tevékenységfüggvényt vagy al-orkesztrációt. A részletekért ellenőrizze a következőt: InnerException.

[FunctionName("TransferFunds")]
public static async Task Run([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var transferDetails = context.GetInput<TransferOperation>();

    await context.CallActivityAsync("DebitAccount",
        new
        {
            Account = transferDetails.SourceAccount,
            Amount = transferDetails.Amount
        });

    try
    {
        await context.CallActivityAsync("CreditAccount",
            new
            {
                Account = transferDetails.DestinationAccount,
                Amount = transferDetails.Amount
            });
    }
    catch (FunctionFailedException)
    {
        // Refund the source account.
        // Another try/catch could be used here based on the needs of the application.
        await context.CallActivityAsync("CreditAccount",
            new
            {
                Account = transferDetails.SourceAccount,
                Amount = transferDetails.Amount
            });
    }
}

Megjegyzés:

Az előző C#-példák Durable Functions 2.x-et használnak. Az 1.x Durable Functions esetében a DurableOrchestrationContext használatát IDurableOrchestrationContext helyett kell alkalmazni. A verzióeltéréseket a Durable Functions verziók cikkben találja.

JavaScript

V3 programozási modell

const df = require("durable-functions");

module.exports = df.orchestrator(function* (context) {
    const transferDetails = context.df.getInput();

    yield context.df.callActivity("DebitAccount", {
        account: transferDetails.sourceAccount,
        amount: transferDetails.amount,
    });

    try {
        yield context.df.callActivity("CreditAccount", {
            account: transferDetails.destinationAccount,
            amount: transferDetails.amount,
        });
    } catch (error) {
        // Refund the source account.
        // Another try/catch could be used here based on the needs of the application.
        yield context.df.callActivity("CreditAccount", {
            account: transferDetails.sourceAccount,
            amount: transferDetails.amount,
        });
    }
})

V4 programozási modell

const df = require("durable-functions");

df.app.orchestration("transferFunds", function* (context) {
    const transferDetails = context.df.getInput();

    yield context.df.callActivity("debitAccount", {
        account: transferDetails.sourceAccount,
        amount: transferDetails.amount,
    });

    try {
        yield context.df.callActivity("creditAccount", {
            account: transferDetails.destinationAccount,
            amount: transferDetails.amount,
        });
    } catch (error) {
        // Refund the source account.
        // Another try/catch could be used here based on the needs of the application.
        yield context.df.callActivity("creditAccount", {
            account: transferDetails.sourceAccount,
            amount: transferDetails.amount,
        });
    }
});

Python

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    transfer_details = context.get_input()

    yield context.call_activity('DebitAccount', {
         'account': transfer_details['sourceAccount'],
         'amount' : transfer_details['amount']
    })

    try:
        yield context.call_activity('CreditAccount', {
                'account': transfer_details['destinationAccount'],
                'amount': transfer_details['amount'],
            })
    except Exception:
        yield context.call_activity('CreditAccount', {
            'account': transfer_details['sourceAccount'],
            'amount': transfer_details['amount']
        })

main = df.Orchestrator.create(orchestrator_function)

PowerShell

A PowerShell-parancsmagok alapértelmezés szerint nem generálnak kivételeket, amelyeket try/catch blokkokkal lehetne elkapni. Ennek a viselkedésnek a módosítására két lehetősége van:

1. Használja a -ErrorAction Stop jelölőt a parancsmagok, például a Invoke-DurableActivity meghívásakor.
2. A parancsmagok meghívása előtt állítsa be a $ErrorActionPreference beállítási változót "Stop" a vezénylő függvénybe.

param($Context)

$ErrorActionPreference = "Stop"

$transferDetails = $Context.Input

Invoke-DurableActivity -FunctionName 'DebitAccount' -Input @{ account = $transferDetails.sourceAccount; amount = $transferDetails.amount }

try {
    Invoke-DurableActivity -FunctionName 'CreditAccount' -Input @{ account = $transferDetails.destinationAccount; amount = $transferDetails.amount }
} catch {
    Invoke-DurableActivity -FunctionName 'CreditAccount' -Input @{ account = $transferDetails.sourceAccount; amount = $transferDetails.amount }
}

A PowerShell hibakezelésével kapcsolatos további információkért tekintse meg a Try-Catch-Finally PowerShell dokumentációt.

Java

@FunctionName("TransferFunds")
public void transferFunds(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    TransferOperation transfer = ctx.getInput(TransferOperation.class);
    ctx.callActivity(
        "DebitAccount", 
        new OperationArgs(transfer.sourceAccount, transfer.amount)).await();
    try {
        ctx.callActivity(
            "CreditAccount", 
            new OperationArgs(transfer.destinationAccount, transfer.amount)).await();
    } catch (TaskFailedException ex) {
        // Refund the source account on failure
        ctx.callActivity(
            "CreditAccount", 
            new OperationArgs(transfer.sourceAccount, transfer.amount)).await();
    }
}

Ha az első CreditAccount függvényhívás meghiúsul, a vezénylő függvény kompenzálja az összeget a forrásfiókba történő jóváírással.

A Durable Task SDK-kban a tevékenységek vagy alvezénylések során felmerülő kezeletlen kivételeket a rendszer visszaállítja a vezénylőhöz a TaskFailedException típus használatával. A kivétel tulajdonsága FailureDetails részletes információkat nyújt a hibáról.

C#

using Microsoft.DurableTask;

[DurableTask(nameof(TransferFundsOrchestration))]
public class TransferFundsOrchestration : TaskOrchestrator<TransferOperation, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, TransferOperation transfer)
    {
        await context.CallActivityAsync(
            nameof(DebitAccountActivity),
            new AccountOperation { Account = transfer.SourceAccount, Amount = transfer.Amount });

        try
        {
            await context.CallActivityAsync(
                nameof(CreditAccountActivity),
                new AccountOperation { Account = transfer.DestinationAccount, Amount = transfer.Amount });
        }
        catch (TaskFailedException ex)
        {
            // Log the failure details
            var details = ex.FailureDetails;

            // Compensate by refunding the source account
            await context.CallActivityAsync(
                nameof(CreditAccountActivity),
                new AccountOperation { Account = transfer.SourceAccount, Amount = transfer.Amount });

            return $"Transfer failed: {details.ErrorMessage}. Compensation completed.";
        }

        return "Transfer completed successfully";
    }
}

JavaScript

import { OrchestrationContext, TOrchestrator } from "@microsoft/durabletask-js";

const transferFundsOrchestrator: TOrchestrator = async function* (
  ctx: OrchestrationContext
): any {
  const transfer = ctx.getInput() as {
    sourceAccount: string;
    destinationAccount: string;
    amount: number;
  };

  yield ctx.callActivity(debitAccount, {
    account: transfer.sourceAccount,
    amount: transfer.amount,
  });

  try {
    yield ctx.callActivity(creditAccount, {
      account: transfer.destinationAccount,
      amount: transfer.amount,
    });
  } catch (error) {
    // Compensate by refunding the source account
    yield ctx.callActivity(creditAccount, {
      account: transfer.sourceAccount,
      amount: transfer.amount,
    });
    return `Transfer failed. Compensation completed.`;
  }

  return "Transfer completed successfully";
};

Python

from durabletask import task

def transfer_funds_orchestrator(ctx: task.OrchestrationContext, transfer: dict) -> str:
    """
    Orchestrator that demonstrates error handling with compensation.
    """
    source_account = transfer.get("source_account")
    destination_account = transfer.get("destination_account")
    amount = transfer.get("amount")

    # Debit the source account
    yield ctx.call_activity("debit_account", input={
        "account": source_account,
        "amount": amount
    })

    try:
        # Credit the destination account
        yield ctx.call_activity("credit_account", input={
            "account": destination_account,
            "amount": amount
        })
    except task.TaskFailedError as ex:
        # Compensate by refunding the source account
        yield ctx.call_activity("credit_account", input={
            "account": source_account,
            "amount": amount
        })
        return f"Transfer failed: {ex}. Compensation completed."

    return "Transfer completed successfully"

PowerShell

Nem érhető el PowerShell-minta. Használja a .NET, JavaScript, Java vagy Python mintát.

Java

import com.microsoft.durabletask.*;

public TaskOrchestration createTransferOrchestration() {
    return ctx -> {
        TransferOperation transfer = ctx.getInput(TransferOperation.class);

        ctx.callActivity("DebitAccount",
            new AccountOperation(transfer.sourceAccount, transfer.amount)).await();

        try {
            ctx.callActivity("CreditAccount",
                new AccountOperation(transfer.destinationAccount, transfer.amount)).await();
        } catch (TaskFailedException ex) {
            // Compensate by refunding the source account
            ctx.callActivity("CreditAccount",
                new AccountOperation(transfer.sourceAccount, transfer.amount)).await();

            ctx.complete("Transfer failed: " + ex.getMessage() + ". Compensation completed.");
            return;
        }

        ctx.complete("Transfer completed successfully");
    };
}

Ha a CreditAccount tevékenység meghiúsul, a vezénylő elkapja a kivételt, és a kompenzálást az összeg forrásfiókba történő jóváírásával hajtja végre.

Hibák kezelése több tevékenységhívással (kiterjesztés/beépítés)

C#

Ha Task.WhenAll több tevékenységhívást futtat párhuzamosan (fan-out/fan-in minta), és egy vagy több tevékenység sikertelen lesz, await csak az első kivételt veti ki. Az összes hiba eléréséhez vizsgálja meg a által visszaadott tulajdonságát a tagon.

Izolált munkavállalói modell

var tasks = new[]
{
    context.CallActivityAsync("Activity1", input1),
    context.CallActivityAsync("Activity2", input2),
    context.CallActivityAsync("Activity3", input3),
};

var allTask = Task.WhenAll(tasks);
try
{
    await allTask;
}
catch (TaskFailedException)
{
    // 'await' rethrows only the first exception. To inspect all failures,
    // check allTask.Exception, which is an AggregateException.
    if (allTask.Exception != null)
    {
        foreach (var inner in allTask.Exception.InnerExceptions)
        {
            if (inner is TaskFailedException taskFailed)
            {
                // Use taskFailed.FailureDetails to inspect error details
                var errorType = taskFailed.FailureDetails.ErrorType;
                var errorMessage = taskFailed.FailureDetails.ErrorMessage;
            }
        }
    }
}

Folyamaton belüli modell

var tasks = new[]
{
    context.CallActivityAsync("Activity1", input1),
    context.CallActivityAsync("Activity2", input2),
    context.CallActivityAsync("Activity3", input3),
};

var allTask = Task.WhenAll(tasks);
try
{
    await allTask;
}
catch (FunctionFailedException)
{
    // 'await' rethrows only the first exception. To inspect all failures,
    // check allTask.Exception, which is an AggregateException.
    if (allTask.Exception != null)
    {
        foreach (var inner in allTask.Exception.InnerExceptions)
        {
            if (inner is FunctionFailedException funcFailed)
            {
                // Use funcFailed.InnerException to access the original exception
            }
        }
    }
}

JavaScript

A JavaScriptben, amikor context.df.Task.all több tevékenységhívást futtat párhuzamosan, az első hiba miatt a feladat egy hibával fejeződik be. A hiba kezeléséhez csomagolja be a hívást egy try/catch blokkba.

Python

A Pythonban, amikor context.task_all több tevékenységhívást futtat párhuzamosan, az első hiba miatt a feladat egy hibával fejeződik be. A hiba kezeléséhez helyezze el a hívást egy try/except blokkba.

PowerShell

A PowerShellben több tevékenységgel használható Wait-DurableTask . Ha valamelyik feladat meghiúsul, a hiba felmerül.

Java

A Java-ban, ha ctx.allOf több tevékenységhívást futtat párhuzamosan, az első hiba miatt a feladat egy hibával fejeződik be. A hiba kezeléséhez használjon try-catch blokkot.

Entitásfüggvények hibáinak kezelése

Az entitásfüggvények kivételkezelése a Durable Functions üzemeltetési modelltől függ:

C#

Izolált munkavállalói modell

Az izolált C# Durable Functions futtatókörnyezet az entitásfüggvény-kivételeket csomagolja egy EntityOperationFailedException. Az eredeti kivétel részleteinek lekéréséhez vizsgálja meg a tulajdonságot FailureDetails .

[Function(nameof(MyOrchestrator))]
public static async Task<List<string>> MyOrchestrator(
   [Microsoft.Azure.Functions.Worker.OrchestrationTrigger] TaskOrchestrationContext context)
{
    var entityId = new Microsoft.DurableTask.Entities.EntityInstanceId(nameof(Counter), "myCounter");
    try
    {
        await context.Entities.CallEntityAsync(entityId, "Add", 1);
    }
    catch (EntityOperationFailedException ex)
    {
        // Add your error handling
    }

    return new List<string>();
}

Folyamaton belüli modell

A C# folyamaton belül működő Durable Functions esetében az entitásfüggvények visszaadják az eredeti kivételtípusokat a vezénylőnek.

[FunctionName("Function1")]
public static async Task<string> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    try
    {
        var entityId = new EntityId(nameof(Counter), "myCounter");
        await context.CallEntityAsync(entityId, "Add", 1);
    }
    catch (Exception ex)
    {
        // The exception type is InvalidOperationException with the message "this is an entity exception".
    }
    return string.Empty;
}

[FunctionName("Counter")]
public static void Counter([EntityTrigger] IDurableEntityContext ctx)
{
    switch (ctx.OperationName.ToLowerInvariant())
    {
        case "add":
            throw new InvalidOperationException("this is an entity exception");
        case "get":
            ctx.Return(ctx.GetState<int>());
            break;
    }
}

JavaScript

df.app.orchestration("counterOrchestration", function* (context) {
    const entityId = new df.EntityId(counterEntityName, "myCounter");

    try {
        const currentValue = yield context.df.callEntity(entityId, "get");
        if (currentValue < 10) {
            yield context.df.callEntity(entityId, "add", 1);
        }
    } catch (err) {
        context.log(`Entity call failed: ${err.message ?? err}`);
    }
});

Python

@myApp.orchestration_trigger(context_name="context")
def run_orchestrator(context):
    try:
        entityId = df.EntityId("Counter", "myCounter")
        yield context.call_entity(entityId, "get")
        return "finished"
    except Exception as e:
        # Add your error handling

PowerShell

A PowerShell nem támogatja az entitásfüggvényeket.

Java

Java nem támogatja az entitásfüggvényeket.

Automatikus újrapróbálkozás hiba esetén

Amikor tevékenységfüggvényeket vagy részvezénylési függvényeket hív meg, adjon meg egy automatikus újrapróbálkozási szabályzatot. Az alábbi példa egy függvényt legfeljebb háromszor hív meg, és öt másodpercet vár az újrapróbálkozások között:

C#

Izolált munkavállalói modell

[FunctionName("TimerOrchestratorWithRetry")]
public static async Task Run([OrchestrationTrigger] TaskOrchestrationContext context)
{
    var options = TaskOptions.FromRetryPolicy(new RetryPolicy(
        maxNumberOfAttempts: 3,
        firstRetryInterval: TimeSpan.FromSeconds(5)));

    await context.CallActivityAsync("FlakyFunction", options: options);

    // ...
}

Folyamaton belüli modell

[FunctionName("TimerOrchestratorWithRetry")]
public static async Task Run([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var retryOptions = new RetryOptions(
        firstRetryInterval: TimeSpan.FromSeconds(5),
        maxNumberOfAttempts: 3);

    await context.CallActivityWithRetryAsync("FlakyFunction", retryOptions, null);

    // ...
}

Megjegyzés:

Az előző C# példák a Durable Functions 2.x verziójára vonatkoznak. Az 1.x Durable Functions esetén a DurableOrchestrationContext-t kell használni IDurableOrchestrationContext helyett. A verziók közötti különbségekről további információt a Durable Functions verzióiról szóló cikkben talál.

JavaScript

V3 programozási modell

const df = require("durable-functions");

module.exports = df.orchestrator(function*(context) {
    const firstRetryIntervalInMilliseconds = 5000;
    const maxNumberOfAttempts = 3;

    const retryOptions = 
        new df.RetryOptions(firstRetryIntervalInMilliseconds, maxNumberOfAttempts);

    yield context.df.callActivityWithRetry("FlakyFunction", retryOptions);

    // ...
});

V4 programozási modell

const df = require("durable-functions");

df.app.orchestration("callActivityWithRetry", function* (context) {
    const firstRetryIntervalInMilliseconds = 5000;
    const maxNumberOfAttempts = 3;

    const retryOptions = new df.RetryOptions(firstRetryIntervalInMilliseconds, maxNumberOfAttempts);

    yield context.df.callActivityWithRetry("FlakyFunction", retryOptions);

    // ...
});

Python

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    first_retry_interval_in_milliseconds = 5000
    max_number_of_attempts = 3

    retry_options = df.RetryOptions(first_retry_interval_in_milliseconds, max_number_of_attempts)

    yield context.call_activity_with_retry('FlakyFunction', retry_options)

main = df.Orchestrator.create(orchestrator_function)

PowerShell

param($Context)

$retryOptions = New-DurableRetryOptions `
                    -FirstRetryInterval (New-TimeSpan -Seconds 5) `
                    -MaxNumberOfAttempts 3

Invoke-DurableActivity -FunctionName 'FlakyFunction' -RetryOptions $retryOptions

Java

@FunctionName("TimerOrchestratorWithRetry")
public void timerOrchestratorWithRetry(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    final int maxAttempts = 3;
    final Duration firstRetryInterval = Duration.ofSeconds(5);
    RetryPolicy policy = new RetryPolicy(maxAttempts, firstRetryInterval);
    TaskOptions options = new TaskOptions(policy);
    ctx.callActivity("FlakyFunction", options).await();
    // ...
}

Az előző példában szereplő tevékenységfüggvény-hívás egy paraméterrel konfigurál egy automatikus újrapróbálkozési szabályzatot. Szabja testre a szabályzatot az alábbi beállításokkal:

• Kísérletek maximális száma: A kísérletek maximális száma. Ha 1 értékre van állítva, nem történik újrapróbálkozás.
• Első újrapróbálkozási időköz: Az első újrapróbálkozási kísérlet előtti várakozási idő.
• Visszalépési együttható: A visszalépés növekedési ütemének meghatározására használt együttható. Alapértelmezett érték: 1.
• Maximális újrapróbálkozási időköz: Az újrapróbálkozási kísérletek közötti várakozás maximális időtartama.
• Újrapróbálkozási időtúllépés: Az újrapróbálkozással töltött idő maximális száma. Alapértelmezés szerint az újrapróbálkozások határozatlan ideig folytatódnak.

A Durable Task SDK-k alternatív ütemezési módszereket tartalmaznak, amelyek egy megadott szabályzat alapján újrapróbálkoznak a sikertelen tevékenységekre. Ezek a módszerek olyan tevékenységekhez hasznosak, amelyek adatokat olvasnak webszolgáltatásokból, vagy idempotens írásokat végeznek egy adatbázisba.

C#

using Microsoft.DurableTask;

[DurableTask(nameof(OrchestratorWithRetry))]
public class OrchestratorWithRetry : TaskOrchestrator<string, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, string input)
    {
        // Configure retry policy
        var retryPolicy = new RetryPolicy(
            maxNumberOfAttempts: 3,
            firstRetryInterval: TimeSpan.FromSeconds(5),
            backoffCoefficient: 2.0,
            maxRetryInterval: TimeSpan.FromMinutes(1),
            retryTimeout: TimeSpan.FromMinutes(5));

        var options = TaskOptions.FromRetryPolicy(retryPolicy);

        // Call activity with automatic retry
        string result = await context.CallActivityAsync<string>(
            nameof(UnreliableActivity), input, options);

        return result;
    }
}

JavaScript

import {
  OrchestrationContext,
  TOrchestrator,
  RetryPolicy,
} from "@microsoft/durabletask-js";

const retryPolicyOrchestrator: TOrchestrator = async function* (
  ctx: OrchestrationContext
): any {
  const retryPolicy = new RetryPolicy({
    maxNumberOfAttempts: 3,
    firstRetryIntervalInMilliseconds: 5000,
    backoffCoefficient: 2.0,
    maxRetryIntervalInMilliseconds: 60000,
  });

  const result: string = yield ctx.callActivity(
    unreliableActivity,
    ctx.getInput(),
    { retry: retryPolicy }
  );

  return result;
};

Python

from durabletask import task
from durabletask.task import RetryPolicy

def orchestrator_with_retry(ctx: task.OrchestrationContext, input_data: str) -> str:
    """
    Orchestrator that demonstrates automatic retry on activity failure.
    """
    # Configure retry policy
    retry_policy = RetryPolicy(
        first_retry_interval=5,        # seconds
        max_number_of_attempts=3,
        backoff_coefficient=2.0,
        max_retry_interval=60,         # seconds
        retry_timeout=300              # seconds
    )

    # Call activity with automatic retry
    result = yield ctx.call_activity(
        "unreliable_activity",
        input=input_data,
        retry_policy=retry_policy
    )

    return result

PowerShell

Ez a minta .NET, JavaScript, Java és Python esetében jelenik meg.

Java

import com.microsoft.durabletask.*;
import java.time.Duration;

public TaskOrchestration createOrchestratorWithRetry() {
    return ctx -> {
        String input = ctx.getInput(String.class);

        // Configure retry policy
        RetryPolicy retryPolicy = new RetryPolicy(
            3,                              // maxNumberOfAttempts
            Duration.ofSeconds(5),          // firstRetryInterval
            2.0,                            // backoffCoefficient
            Duration.ofMinutes(1),          // maxRetryInterval
            Duration.ofMinutes(5)           // retryTimeout
        );

        TaskOptions options = new TaskOptions(retryPolicy);

        // Call activity with automatic retry
        String result = ctx.callActivity(
            "UnreliableActivity", input, options, String.class).await();

        ctx.complete(result);
    };
}

Az újrapróbálkozás szabályzatbeállításai a következők:

• Kísérletek maximális száma: Az újrapróbálkozási kísérletek maximális száma. Ha 1 értékre van állítva, nem történik újrapróbálkozás.
• Első újrapróbálkozási időköz: Az első újrapróbálkozási kísérlet előtti várakozási idő.
• Visszalépési együttható: A visszalépés növekedési ütemének meghatározására használt együttható. Alapértelmezett érték: 1.
• Maximális újrapróbálkozási időköz: Az újrapróbálkozási kísérletek közötti várakozás maximális időtartama.
• Újrapróbálkozás időtúllépése: Az újrapróbálkozással töltött idő maximális mennyisége.

Egyéni újrapróbálkozás-kezelők

A .NET és Java akkor implementálják az újrapróbálkozási kezelőket a kódban, ha a deklaratív újrapróbálkozási szabályzatok nem elég kifejezőek. Más nyelvekben az újrapróbálkozások logikáját hurkokkal, kivételkezeléssel és időzítőkkel valósíthatja meg az újrapróbálkozások közötti késleltetés érdekében.

C#

Izolált munkavállalói modell

TaskOptions retryOptions = TaskOptions.FromRetryHandler(retryContext =>
{
    // Don't retry anything that derives from ApplicationException
    if (retryContext.LastFailure.IsCausedBy<ApplicationException>())
    {
        return false;
    }

    // Quit after N attempts
    return retryContext.LastAttemptNumber < 3;
});

try
{
    await ctx.CallActivityAsync("FlakeyActivity", options: retryOptions);
}
catch (TaskFailedException)
{
    // Case when the retry handler returns false...
}

Folyamaton belüli modell

RetryOptions retryOptions = new RetryOptions(
    firstRetryInterval: TimeSpan.FromSeconds(5),
    maxNumberOfAttempts: int.MaxValue)
{
    Handle = exception =>
    {
        // Return true to handle and retry, or false to throw.
        if (exception is TaskFailedException failure)
        {
            // Exceptions from task activities are always this type. Inspect the
            // inner exception for more details.
        }

        return false;
    }
};

await ctx.CallActivityWithRetryAsync("FlakeyActivity", retryOptions, null);

JavaScript

A JavaScript nem támogatja az egyedi újrapróbálkozási kezelőket a Durable Functions. Az újrapróbálkozás logikájának implementálása a vezénylő függvényben hurkok, kivételkezelés és időzítők használatával az újrapróbálkozások közötti késleltetés érdekében.

Python

Python nem támogatja az egyéni újrapróbálkozás-kezelőket. Az újrapróbálkozás logikájának implementálása a vezénylő függvényben hurkok, kivételkezelés és időzítők használatával az újrapróbálkozások közötti késleltetés érdekében.

PowerShell

A PowerShell nem támogatja az egyéni újrapróbálkozás-kezelőket. Az újrapróbálkozás logikájának implementálása a vezénylő függvényben hurkok, kivételkezelés és időzítők használatával az újrapróbálkozások közötti késleltetés érdekében.

Java

RetryHandler retryHandler = retryCtx -> {
    // Don't retry anything that derives from RuntimeException
    if (retryCtx.getLastFailure().isCausedBy(RuntimeException.class)) {
        return false;
    }

    // Quit after N attempts
    return retryCtx.getLastAttemptNumber() < 3;
};

TaskOptions options = new TaskOptions(retryHandler);
try {
    ctx.callActivity("FlakeyActivity", options).await();
} catch (TaskFailedException ex) {
    // Case when the retry handler returns false...
}

Egyéni újrapróbálkozás-kezelők

A .NET és Java az újrapróbálkozás-kezelőket kódban implementálva szabályozza az újrapróbálkozás logikáját. Ez a megközelítés akkor hasznos, ha a deklaratív újrapróbálkozási szabályzatok nem elég kifejezőek.

C#

using Microsoft.DurableTask;

[DurableTask(nameof(OrchestratorWithCustomRetry))]
public class OrchestratorWithCustomRetry : TaskOrchestrator<string, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, string input)
    {
        // Custom retry handler with conditional logic
        TaskOptions retryOptions = TaskOptions.FromRetryHandler(retryContext =>
        {
            // Don't retry if it's a validation error
            if (retryContext.LastFailure.IsCausedBy<ArgumentException>())
            {
                return false;
            }

            // Retry up to 5 times for transient errors
            return retryContext.LastAttemptNumber < 5;
        });

        try
        {
            return await context.CallActivityAsync<string>(
                nameof(UnreliableActivity), input, retryOptions);
        }
        catch (TaskFailedException)
        {
            // All retries exhausted
            return "Operation failed after all retries";
        }
    }
}

JavaScript

import {
  OrchestrationContext,
  TOrchestrator,
} from "@microsoft/durabletask-js";
import type { RetryHandler, RetryContext } from "@microsoft/durabletask-js";

const customRetryHandlerOrchestrator: TOrchestrator = async function* (
  ctx: OrchestrationContext
): any {
  const maxAttempts = 4;

  const customRetryHandler: RetryHandler = (retryCtx: RetryContext) => {
    if (retryCtx.lastAttemptNumber >= maxAttempts) {
      return false; // give up
    }
    // Only retry transient errors
    if (!retryCtx.lastFailure.message?.includes("TransientError")) {
      return false;
    }
    return true; // retry immediately
  };

  const result: string = yield ctx.callActivity(
    unreliableActivity,
    ctx.getInput(),
    { retry: customRetryHandler }
  );

  return result;
};

Python

Az egyéni újrapróbálkozás-kezelők nem támogatottak a Python. Egyéni újrapróbálkozési logika implementálása hurkok, kivételkezelés és időzítők használatával:

import datetime
from durabletask import task

def orchestrator_with_custom_retry(ctx: task.OrchestrationContext, input_data: str) -> str:
    """
    Orchestrator that demonstrates custom retry logic.
    """
    max_attempts = 5
    retry_interval_seconds = 5

    for attempt in range(1, max_attempts + 1):
        try:
            result = yield ctx.call_activity("unreliable_activity", input=input_data)
            return result
        except task.TaskFailedError as ex:
            if attempt >= max_attempts:
                return f"Operation failed after {max_attempts} attempts"

            # Wait before retrying
            next_retry = ctx.current_utc_datetime + datetime.timedelta(seconds=retry_interval_seconds)
            yield ctx.create_timer(next_retry)

    return "Unexpected error"

PowerShell

Az egyéni újrapróbálkozás-kezelők nem támogatottak a PowerShellben. Egyéni újrapróbálkozások logikáját hurkokkal, kivételkezeléssel és időzítőkkel valósíthatja meg.

Java

import com.microsoft.durabletask.*;

public TaskOrchestration createOrchestratorWithCustomRetry() {
    return ctx -> {
        String input = ctx.getInput(String.class);

        // Custom retry handler with conditional logic
        RetryHandler retryHandler = retryContext -> {
            // Don't retry validation errors
            if (retryContext.getLastFailure().isCausedBy(IllegalArgumentException.class)) {
                return false;
            }

            // Retry up to 5 times for transient errors
            return retryContext.getLastAttemptNumber() < 5;
        };

        TaskOptions options = new TaskOptions(retryHandler);

        try {
            String result = ctx.callActivity("UnreliableActivity", input, options, String.class).await();
            ctx.complete(result);
        } catch (TaskFailedException ex) {
            // All retries exhausted
            ctx.complete("Operation failed after all retries");
        }
    };
}

Függvény időkorlátai

Ha egy függvényhívás túl sokáig tart, szakítsa meg az időzítést a vezérlő függvényben. Hozzon létre egy tartós időzítőt egy any feladatválasztóval, ahogyan az alábbi példában is látható:

C#

Izolált munkavállalói modell

[Function("TimerOrchestrator")]
public static async Task<bool> Run([OrchestrationTrigger] TaskOrchestrationContext context)
{
    TimeSpan timeout = TimeSpan.FromSeconds(30);
    DateTime deadline = context.CurrentUtcDateTime.Add(timeout);

    using (var cts = new CancellationTokenSource())
    {
        Task activityTask = context.CallActivityAsync("FlakyFunction");
        Task timeoutTask = context.CreateTimer(deadline, cts.Token);

        Task winner = await Task.WhenAny(activityTask, timeoutTask);
        if (winner == activityTask)
        {
            // success case
            cts.Cancel();
            return true;
        }
        else
        {
            // timeout case
            return false;
        }
    }
}

Folyamaton belüli modell

[FunctionName("TimerOrchestrator")]
public static async Task<bool> Run([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    TimeSpan timeout = TimeSpan.FromSeconds(30);
    DateTime deadline = context.CurrentUtcDateTime.Add(timeout);

    using (var cts = new CancellationTokenSource())
    {
        Task activityTask = context.CallActivityAsync("FlakyFunction");
        Task timeoutTask = context.CreateTimer(deadline, cts.Token);

        Task winner = await Task.WhenAny(activityTask, timeoutTask);
        if (winner == activityTask)
        {
            // success case
            cts.Cancel();
            return true;
        }
        else
        {
            // timeout case
            return false;
        }
    }
}

Megjegyzés:

Az előző C# példák a Durable Functions 2.x verziójára vonatkoznak. Az 1.x Durable Functions esetén a DurableOrchestrationContext-t kell használni IDurableOrchestrationContext helyett. A verziók közötti különbségekről további információt a Durable Functions verzióiról szóló cikkben talál.

JavaScript

V3 programozási modell

const df = require("durable-functions");
const moment = require("moment");

module.exports = df.orchestrator(function*(context) {
    const deadline = moment.utc(context.df.currentUtcDateTime).add(30, "s");

    const activityTask = context.df.callActivity("FlakyFunction");
    const timeoutTask = context.df.createTimer(deadline.toDate());

    const winner = yield context.df.Task.any([activityTask, timeoutTask]);
    if (winner === activityTask) {
        // success case
        timeoutTask.cancel();
        return true;
    } else {
        // timeout case
        return false;
    }
});

V4 programozási modell

const df = require("durable-functions");
const { DateTime } = require("luxon");

df.app.orchestration("timerOrchestrator", function* (context) {
    const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime).plus({ seconds: 30 });

    const activityTask = context.df.callActivity("FlakyFunction");
    const timeoutTask = context.df.createTimer(deadline.toJSDate());

    const winner = yield context.df.Task.any([activityTask, timeoutTask]);
    if (winner === activityTask) {
        // success case
        timeoutTask.cancel();
        return true;
    } else {
        // timeout case
        return false;
    }
});

Python

import azure.functions as func
import azure.durable_functions as df
from datetime import datetime, timedelta

def orchestrator_function(context: df.DurableOrchestrationContext):
    deadline = context.current_utc_datetime + timedelta(seconds = 30)

    activity_task = context.call_activity('FlakyFunction')
    timeout_task = context.create_timer(deadline)

    winner = yield context.task_any([activity_task, timeout_task])
    if winner == activity_task:
        timeout_task.cancel()
        return True
    else:
        return False

main = df.Orchestrator.create(orchestrator_function)

PowerShell

param($Context)

$expiryTime = New-TimeSpan -Seconds 30

$activityTask = Invoke-DurableActivity -FunctionName 'FlakyFunction' -NoWait
$timerTask = Start-DurableTimer -Duration $expiryTime -NoWait

$winner = Wait-DurableTask -Task @($activityTask, $timerTask) -NoWait

if ($winner -eq $activityTask) {
    Stop-DurableTimerTask -Task $timerTask
    return $True
}
else {
    return $False
}

Java

@FunctionName("TimerOrchestrator")
public boolean timerOrchestrator(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    Task<Void> activityTask = ctx.callActivity("FlakyFunction");
    Task<Void> timeoutTask = ctx.createTimer(Duration.ofSeconds(30));

    Task<?> winner = ctx.anyOf(activityTask, timeoutTask).await();
    if (winner == activityTask) {
        // success case
        return true;
    } else {
        // timeout case
        return false;
    }
}

Megjegyzés:

Ez a mechanizmus nem vet véget a már folyamatban lévő tevékenységfüggvény-végrehajtásnak. Lehetővé teszi, hogy a vezénylő függvény figyelmen kívül hagyja az eredményt, és továbblépjön. További információ: Időzítők.

Tevékenység időtúllépései

Ha egy tevékenységhívás túl sokáig tart, abbahagyhatja a várakozást. Hozzon létre egy tartós időzítőt, és hasonlítsa össze a tevékenységi feladattal.

C#

using Microsoft.DurableTask;
using System;
using System.Threading;
using System.Threading.Tasks;

[DurableTask(nameof(OrchestratorWithTimeout))]
public class OrchestratorWithTimeout : TaskOrchestrator<string, bool>
{
    public override async Task<bool> RunAsync(
        TaskOrchestrationContext context, string input)
    {
        TimeSpan timeout = TimeSpan.FromSeconds(30);
        DateTime deadline = context.CurrentUtcDateTime.Add(timeout);

        using var cts = new CancellationTokenSource();
        Task activityTask = context.CallActivityAsync(nameof(SlowActivity), input);
        Task timeoutTask = context.CreateTimer(deadline, cts.Token);

        Task winner = await Task.WhenAny(activityTask, timeoutTask);
        if (winner == activityTask)
        {
            // Activity completed in time - cancel the timer
            cts.Cancel();
            return true;
        }
        else
        {
            // Timeout occurred
            return false;
        }
    }
}

JavaScript

import {
  OrchestrationContext,
  TOrchestrator,
} from "@microsoft/durabletask-js";

const orchestratorWithTimeout: TOrchestrator = async function* (
  ctx: OrchestrationContext
): any {
  const timeoutSeconds = 30;

  // Start both the activity and a timeout timer
  const activityTask = ctx.callActivity(slowActivity, ctx.getInput());
  const timeoutTask = ctx.createTimer(timeoutSeconds);

  // Wait for whichever completes first
  const winner = yield ctx.whenAny([activityTask, timeoutTask]);

  if (winner === activityTask) {
    // Activity completed in time
    return true;
  } else {
    // Timeout occurred
    return false;
  }
};

Python

import datetime
from durabletask import task

def orchestrator_with_timeout(ctx: task.OrchestrationContext, input_data: str) -> bool:
    """
    Orchestrator that demonstrates activity timeout using a timer.
    """
    timeout_seconds = 30
    deadline = ctx.current_utc_datetime + datetime.timedelta(seconds=timeout_seconds)

    # Create both tasks
    activity_task = ctx.call_activity("slow_activity", input=input_data)
    timeout_task = ctx.create_timer(deadline)

    # Wait for whichever completes first
    winner = yield task.when_any([activity_task, timeout_task])

    if winner == activity_task:
        # Activity completed in time
        return True
    else:
        # Timeout occurred
        return False

PowerShell

Ez a minta .NET, JavaScript, Java és Python esetében jelenik meg.

Java

import com.microsoft.durabletask.*;
import java.time.Duration;

public TaskOrchestration createOrchestratorWithTimeout() {
    return ctx -> {
        String input = ctx.getInput(String.class);

        // Create activity task
        Task<String> activityTask = ctx.callActivity("SlowActivity", input, String.class);

        // Create timeout timer (30 seconds)
        Task<Void> timeoutTask = ctx.createTimer(Duration.ofSeconds(30));

        // Wait for whichever completes first
        Task<?> winner = ctx.anyOf(activityTask, timeoutTask).await();

        if (winner == activityTask) {
            // Activity completed in time
            ctx.complete(true);
        } else {
            // Timeout occurred
            ctx.complete(false);
        }
    };
}

Megjegyzés:

Ez a mechanizmus nem vet véget a már folyamatban lévő tevékenységek végrehajtásának. Lehetővé teszi, hogy a vezénylő figyelmen kívül hagyja az eredményt, és továbblép. További információkért tekintse meg az Időzítők dokumentációját.

Kezeletlen kivételek

Ha egy vezénylő függvény nem kezelt kivétellel meghiúsul, a futtatókörnyezet naplózza a kivétel részleteit, és a példány Failed állapottal fejeződik be.

A FailureDetails egyéni kivételtulajdonságainak inkludálása (.NET elkülönített környezet)

A .NET izolált modellt használó Durable Task munkafolyamatokban a feladathibák egy FailureDetails objektumra vannak szerializálva. Alapértelmezés szerint az objektum a következő mezőket tartalmazza:

• ErrorType—Kivételtípus neve
• Message— Kivételüzenet
• StackTrace— Szerializált verem nyomkövetése
• InnerFailure— Beágyazott FailureDetails objektum belső kivételekhez

A Microsoft.Azure.Functions.Worker.Extensions.DurableTask v1.9.0 verziótól kezdve ezt a viselkedést a IExceptionPropertiesProvider megvalósításával bővítheti (a Microsoft.DurableTask.Worker csomag v1.16.1 verziójától kezdődően). Ez a szolgáltató határozza meg, hogy mely kivételtípusok és tulajdonságok szerepeljenek a FailureDetails.Properties szótárban.

Megjegyzés:

• Ez a funkció csak .NET Izolált verzióban érhető el. A Java támogatása még nem érhető el.
• Győződjön meg arról, hogy a Microsoft.Azure.Functions.Worker.Extensions.DurableTask v1.9.0 vagy későbbi verzióját használja.
• Győződjön meg arról, hogy a Microsoft.DurableTask.Worker 1.16.1-s vagy újabb verzióját használja.

Kivételtulajdonság-szolgáltató implementálása

Implementáljon egy egyedi IExceptionPropertiesProvider-t, amely kivonja és visszaadja a kiválasztott tulajdonságokat a fontos kivételekhez, amelyek számítanak. A visszaadott szótár szerializálódik a Properties mező FailureDetails területére, amikor egy megfelelő kivételtípus kerül dobásra.

using Microsoft.DurableTask.Worker;

public class CustomExceptionPropertiesProvider : IExceptionPropertiesProvider
{
    public IDictionary<string, object?>? GetExceptionProperties(Exception exception)
    {
        return exception switch
        {
            ArgumentOutOfRangeException e => new Dictionary<string, object?>
            {
                ["ParamName"] = e.ParamName,
                ["ActualValue"] = e.ActualValue
            },
            InvalidOperationException e => new Dictionary<string, object?>
            {
                ["CustomHint"] = "Invalid operation occurred",
                ["TimestampUtc"] = DateTime.UtcNow
            },
            _ => null // Other exception types not handled
        };
    }
}

A szolgáltató regisztrálása

A Program.cs-ban regisztrálja az egyéni IExceptionPropertiesProvider a .NET Izolált feldolgozó gazdagépen:

using Microsoft.DurableTask.Worker;
using Microsoft.Extensions.DependencyInjection;

var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults(builder =>
    {
        // Register custom exception properties provider
        builder.Services.AddSingleton<IExceptionPropertiesProvider, CustomExceptionPropertiesProvider>();
    })
    .Build();

host.Run();

A szolgáltató regisztrálása után minden olyan kivétel, amely egy kezelt típusnak felel meg, automatikusan tartalmazza a konfigurált tulajdonságokat a FailureDetails szolgáltatóban.

FailureDetails-példakimenet

Amikor egy kivétel lép fel, amely megfelel a szolgáltató konfigurációjának, az orkesztáció a következőhöz hasonló szerializált FailureDetails objektumot kap:

{
  "errorType": "TaskFailedException",
  "message": "Activity failed with an exception.",
  "stackTrace": "...",
  "innerFailure": {
    "errorType": "ArgumentOutOfRangeException",
    "message": "Specified argument was out of range.",
    "properties": {
      "ParamName": "count",
      "ActualValue": 42
    }
  }
}

Kezeletlen kivételek

Ha egy orchestrátor nem kezelt kivétel miatt meghibásodik, a futtatókörnyezet naplózza a kivétel részleteit, és a példány Failed állapottal fejeződik be. TaskFailedException A FailureDetails tulajdonság tartalmazza a hibatípust, az üzenetet és a verem nyomkövetését.

Következő lépések

Örök zeneművek

Problémák diagnosztizálása

A Durable Task SDK-k használatának első lépései

• JavaScript SDK példák a GitHubon.