Menangani kesalahan dan pengulangan dalam orkestrasi

Anda menerapkan orkestrasi Durable Functions dalam kode, sehingga Anda menggunakan fitur penanganan kesalahan bawaan bahasa Anda. Penanganan kesalahan dan kompensasi tidak memerlukan konsep baru, tetapi beberapa perilaku orkestrasi perlu diketahui.

Nota

Model pemrograman Node.js versi 4 untuk Azure Functions umumnya tersedia. Model v4 dirancang untuk memberikan pengalaman yang lebih fleksibel dan intuitif bagi pengembang JavaScript dan TypeScript. Untuk informasi selengkapnya tentang perbedaan antara v3 dan v4, lihat panduan migrasi.

Dalam cuplikan kode berikut, JavaScript (PM4) menunjukkan model pemrograman v4, pengalaman baru.

Aplikasi yang menggunakan layanan cloud perlu menangani kegagalan, dan percobaan ulang sisi klien adalah bagian penting dari desain. SDK Tugas Tahan Lama mencakup dukungan untuk penanganan kesalahan, percobaan ulang, dan batas waktu untuk membantu Anda membangun alur kerja yang kuat.

Menangani kesalahan dalam fungsi aktivitas dan sub-orkestrasi

Dalam Durable Functions, pengecualian yang tidak tertangani yang terjadi dalam aktivitas fungsi atau sub-orkestrasi diarahkan kembali ke fungsi orkestrator menggunakan tipe pengecualian standar.

Fungsi orkestrator berikut mentransfer dana antara dua akun:

C#

Model pekerja terisolasi

Dalam Durable Functions C# Terisolasi, pengecualian yang tidak tertangani muncul sebagai TaskFailedException.

Pesan pengecualian biasanya mengidentifikasi fungsi aktivitas atau sub-orkestrasi mana yang menyebabkan kegagalan. Untuk mengakses informasi kesalahan yang lebih rinci, periksa properti FailureDetails .

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

Nota

• Pesan pengecualian biasanya mengidentifikasi fungsi aktivitas atau sub-orkestrasi mana yang menyebabkan kegagalan. Untuk mengakses informasi kesalahan yang lebih rinci, periksa properti FailureDetails tersebut.
• Secara default, FailureDetails menyertakan jenis kesalahan, pesan kesalahan, pelacakan tumpukan, dan pengecualian berlapis (masing-masing direpresentasikan sebagai objek rekursif FailureDetails ). Untuk menyertakan properti pengecualian kustom dalam output kegagalan, lihat Sertakan Properti Pengecualian Kustom untuk FailureDetails (.NET Terisolasi).

Penting

Catatan migrasi (dalam proses untuk diisolasi): Dalam model dalam proses, FunctionFailedException.InnerException berisi objek pengecualian asli yang dilemparkan oleh aktivitas, yang dapat Anda transmisikan dan periksa secara langsung. Dalam model pekerja yang terisolasi, TaskFailedExceptiontidak menyertakan pengecualian asli sebagai InnerException. Sebaliknya, detail kesalahan hanya tersedia melalui FailureDetails properti , yang menyediakan properti berbasis string (ErrorType, , ErrorMessageStackTrace). Anda tidak dapat melemparkan atau mengakses objek pengecualian asli secara langsung. Gunakan FailureDetails.IsCausedBy<T>() untuk memeriksa jenis pengecualian asli.

Model dalam proses

Dalam C# Durable Functions in-process, pengecualian yang tidak tertangani dilemparkan sebagai FunctionFailedException.

Pesan pengecualian biasanya menyertakan fungsi aktivitas atau sub-orkestrasi yang gagal. Untuk detailnya, periksa 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
            });
    }
}

Nota

Contoh C# sebelumnya menggunakan Durable Functions 2.x. Untuk Durable Functions 1.x, gunakan DurableOrchestrationContext alih-alih IDurableOrchestrationContext. Untuk perbedaan versi, lihat artikel versi Durable Functions.

JavaScript

Model pemrograman V3

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

Model pemrograman V4

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

Secara default, cmdlets di PowerShell tidak menimbulkan pengecualian yang dapat ditangkap menggunakan blok try/catch. Anda memiliki dua opsi untuk mengubah perilaku ini:

1. Gunakan bendera -ErrorAction Stop saat memanggil cmdlet, seperti Invoke-DurableActivity.
2. Atur variabel preferensi $ErrorActionPreference ke "Stop" dalam fungsi orkestrator sebelum memanggil cmdlet.

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

Untuk informasi selengkapnya tentang penanganan kesalahan di PowerShell, lihat dokumentasi PowerShell Try-Catch-Finally.

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

Jika panggilan fungsi CreditAccount pertama gagal, fungsi orkestrator mengkompensasi dengan memberi kredit dana kembali ke akun sumber.

Dalam Durable Task SDK, pengecualian yang tidak tertangani yang terjadi dalam aktivitas atau sub-orkestrasi diarahkan kembali ke orkestrator menggunakan tipe TaskFailedException. Properti pengecualian FailureDetails memberikan informasi terperinci tentang kegagalan tersebut.

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

Tidak ada sampel PowerShell yang tersedia. Gunakan sampel .NET, JavaScript, Java, atau Python.

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

Jika aktivitas CreditAccount gagal, orkestrator menangkap pengecualian dan mengimbangi dengan mengkreditkan dana kembali ke akun sumber.

Menangani kesalahan dengan beberapa panggilan aktivitas (fan-out/fan-in)

C#

Saat Anda menggunakan Task.WhenAll untuk menjalankan beberapa panggilan aktivitas secara paralel (pola fan-out/fan-in) dan satu atau beberapa aktivitas gagal, await hanya melemparkan pengecualian pertama. Untuk mengakses semua kegagalan, periksa properti Exception pada objek Task yang dikembalikan oleh Task.WhenAll.

Model pekerja terisolasi

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

Model dalam proses

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

Di JavaScript, saat Anda menggunakan context.df.Task.all untuk menjalankan beberapa panggilan aktivitas secara paralel, kegagalan pertama menyebabkan tugas selesai dengan kesalahan. Bungkus pemanggilan dalam blok try/catch untuk menangani kesalahan.

Python

Di Python, ketika Anda menggunakan context.task_all untuk menjalankan beberapa panggilan aktivitas secara paralel, kegagalan pertama menyebabkan tugas selesai dengan kesalahan. Bungkus panggilan dalam bungkusan try/except untuk menangani kesalahan.

PowerShell

Di PowerShell, gunakan Wait-DurableTask dengan beberapa tugas. Jika ada tugas yang gagal, kesalahan akan ditampilkan.

Java

Di Java, saat Anda menggunakan ctx.allOf untuk menjalankan beberapa panggilan aktivitas secara paralel, kegagalan pertama menyebabkan tugas selesai dengan kesalahan. Gunakan blok try/catch untuk menangani kesalahan.

Menangani kesalahan dalam fungsi entitas

Penanganan pengecualian dalam fungsi entitas tergantung pada model hosting Durable Functions:

C#

Model pekerja terisolasi

Dalam Durable Functions C# terisolasi, runtime membungkus pengecualian fungsi entitas dalam EntityOperationFailedException. Untuk mendapatkan detail pengecualian asli, cek properti 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>();
}

Model dalam proses

Dalam Durable Functions dengan C# dalam proses, fungsi entitas mengembalikan jenis pengecualian aslinya ke orkestrator.

[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

PowerShell tidak mendukung fungsi entitas.

Java

Java tidak mendukung fungsi entitas.

Pengulangan otomatis pada kegagalan

Saat Anda memanggil fungsi aktivitas atau fungsi sub-orkestrasi, pastikan untuk menetapkan kebijakan pengulangan otomatis. Contoh berikut memanggil fungsi hingga tiga kali dan menunggu lima detik di antara percobaan ulang:

C#

Model pekerja terisolasi

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

    // ...
}

Model dalam proses

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

    // ...
}

Nota

Contoh C# sebelumnya adalah untuk Durable Functions 2.x. Untuk Durable Functions 1.x, Anda harus menggunakan DurableOrchestrationContext alih-alih IDurableOrchestrationContext. Untuk informasi selengkapnya tentang perbedaan antar versi, lihat artikel versi Durable Functions .

JavaScript

Model pemrograman V3

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

    // ...
});

Model pemrograman V4

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();
    // ...
}

Panggilan fungsi aktivitas dalam contoh sebelumnya menggunakan parameter untuk mengonfigurasi kebijakan coba lagi otomatis. Sesuaikan kebijakan dengan opsi ini:

• Max number of attempts:Jumlah maksimal dari upaya yang dicoba. Jika diatur ke 1, tidak ada percobaan ulang yang terjadi.
• Interval percobaan pertama: Jumlah waktu untuk menunggu sebelum upaya coba lagi pertama.
• Koefisien backoff: Koefisien yang digunakan untuk menentukan nilai peningkatan dari backoff. Secara default ke 1.
• Interval coba lagi maksimum: Jumlah waktu maksimum untuk menunggu di antara upaya coba lagi.
• Batas waktu percobaan ulang: Waktu maksimum untuk mencoba kembali. Secara default, percobaan ulang berlanjut tanpa batas waktu.

SDK Durable Task mencakup metode penjadwalan alternatif yang mengulangi aktivitas yang gagal berdasarkan strategi yang disediakan. Metode ini berguna untuk aktivitas yang membaca data dari layanan web atau melakukan penulisan idempotensi ke database.

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

Sampel ini ditampilkan untuk .NET, JavaScript, Java, dan Python.

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

Opsi kebijakan pengulangan adalah:

• Jumlah maksimum upaya: Jumlah maksimum upaya coba lagi. Jika diatur ke 1, tidak ada percobaan ulang yang terjadi.
• Interval percobaan pertama: Jumlah waktu untuk menunggu sebelum upaya coba lagi pertama.
• Koefisien backoff: Koefisien yang digunakan untuk menentukan nilai peningkatan dari backoff. Secara default ke 1.
• Interval coba lagi maksimum: Jumlah waktu maksimum untuk menunggu di antara upaya coba lagi.
• Coba lagi waktu habis: Jumlah maksimum waktu yang harus dihabiskan untuk melakukan pengulangan.

Penangan ulang khusus

Dalam .NET dan Java, terapkan penangan ulang dalam kode saat kebijakan ulang deklaratif kurang ekspresif. Dalam bahasa lain, terapkan logika coba lagi dengan menggunakan perulangan, penanganan pengecualian, dan timer untuk menunda antara percobaan ulang.

C#

Model pekerja terisolasi

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...
}

Model dalam proses

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

JavaScript tidak mendukung handler coba lagi kustom di Durable Functions. Terapkan logika coba lagi dalam fungsi orkestrator dengan menggunakan perulangan, penanganan pengecualian, dan timer untuk menunda antara percobaan ulang.

Python

Python tidak mendukung handler coba lagi kustom. Terapkan logika coba lagi dalam fungsi orkestrator dengan menggunakan perulangan, penanganan pengecualian, dan timer untuk menunda antara percobaan ulang.

PowerShell

PowerShell tidak mendukung handler coba lagi kustom. Terapkan logika coba lagi dalam fungsi orkestrator dengan menggunakan perulangan, penanganan pengecualian, dan timer untuk menunda antara percobaan ulang.

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...
}

Penangan ulang khusus

Di .NET dan Java, terapkan penangan ulang dalam kode untuk mengontrol logika pengulangan. Pendekatan ini berguna ketika kebijakan deklaratif untuk upaya ulang tidak cukup ekspresif.

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

Penangan ulang kustom tidak didukung di Python. Terapkan logika coba lagi kustom dengan menggunakan perulangan, penanganan pengecualian, dan timer:

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

Handler coba lagi kustom tidak didukung di PowerShell. Terapkan logika coba lagi kustom dengan menggunakan perulangan, penanganan pengecualian, dan timer.

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

Batas waktu fungsi

Jika panggilan fungsi memerlukan waktu terlalu lama, tetapkan batas waktu dalam fungsi orkestrator. Buat timer tahan lama dengan pemilih any tugas, seperti dalam contoh berikut:

C#

Model pekerja terisolasi

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

Model dalam proses

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

Nota

Contoh C# sebelumnya adalah untuk Durable Functions 2.x. Untuk Durable Functions 1.x, Anda harus menggunakan DurableOrchestrationContext alih-alih IDurableOrchestrationContext. Untuk informasi selengkapnya tentang perbedaan antar versi, lihat artikel versi Durable Functions .

JavaScript

Model pemrograman V3

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

Model pemrograman V4

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

Nota

Mekanisme ini tidak mengakhiri eksekusi fungsi aktivitas yang sudah berlangsung. Ini memungkinkan fungsi orkestrator mengabaikan hasilnya dan melanjutkan. Untuk informasi selengkapnya, lihat Timer.

Batas waktu aktivitas

Apabila panggilan aktivitas memakan waktu terlalu lama, Anda bisa berhenti menunggunya. Buat timer tahan lama dan adu kecepatan dengan tugas aktivitas.

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

Sampel ini ditampilkan untuk .NET, JavaScript, Java, dan Python.

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

Nota

Mekanisme ini tidak mengakhiri eksekusi aktivitas yang sudah berlangsung. Ini memungkinkan orkestrator mengabaikan hasilnya dan melanjutkan. Untuk informasi selengkapnya, lihat dokumentasi Timer.

Pengecualian yang Tidak Tertangani

Jika fungsi orkestrator gagal dengan pengecualian yang tidak tertangani, runtime mencatat detail pengecualian, dan instans selesai dengan Failed status.

Sertakan properti pengecualian kustom untuk FailureDetails (.NET Terisolasi)

Dalam alur kerja Tugas Tahan Lama yang menggunakan model .NET Terisolasi, kegagalan tugas diserialisasikan ke objek FailureDetails. Secara default, objek menyertakan bidang ini:

• ErrorType—Nama jenis pengecualian
• Message—Pesan pengecualian
• StackTrace—Pelacakan tumpukan berseri
• InnerFailure—Objek bertingkat FailureDetails untuk pengecualian internal

Dimulai dengan Microsoft. Azure. Functions.Worker.Extensions.DurableTask v1.9.0, Anda dapat memperluas perilaku ini dengan menerapkan IExceptionPropertiesProvider (ditentukan dalam paket Microsoft.DurableTask.Worker mulai dari v1.16.1). Penyedia ini menentukan jenis dan properti pengecualian yang akan disertakan dalam kamus FailureDetails.Properties.

Nota

• Fitur ini hanya tersedia di .NET Isolated . Dukungan untuk Java belum tersedia.
• Pastikan Anda menggunakan Microsoft.Azure.Functions.Worker.Extensions.DurableTask v1.9.0 atau yang lebih baru.
• Pastikan Anda menggunakan Microsoft.DurableTask.Worker v1.16.1 atau yang lebih baru.

Menerapkan penyedia properti pengecualian

Terapkan kustom IExceptionPropertiesProvider untuk mengekstrak dan mengembalikan properti yang dipilih untuk pengecualian yang Anda pedulikan. Kamus yang dikembalikan diserialisasikan ke Properties bidang FailureDetails ketika jenis pengecualian yang cocok dilemparkan.

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

Mendaftarkan penyedia

Di Program.cs, daftarkan IExceptionPropertiesProvider kustom Anda di host pekerja terisolasi .NET Anda:

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

Setelah Anda mendaftarkan penyedia, pengecualian apa pun yang cocok dengan jenis yang ditangani secara otomatis menyertakan properti yang dikonfigurasi dalam .FailureDetails

Output Detail Kegagalan Sampel

Ketika terjadi pengecualian yang cocok dengan konfigurasi penyedia Anda, orkestrasi menerima objek berseri FailureDetails seperti ini:

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

Pengecualian yang Tidak Tertangani

Jika orkestrator gagal karena pengecualian yang tidak tertangani, runtime mencatat detail pengecualian, dan instans selesai dengan Failed status. TaskFailedException memiliki FailureDetails properti yang menyertakan jenis kesalahan, pesan, dan jejak tumpukan.

Langkah berikutnya

Orkestrasi abadi

Mendiagnosis masalah

Mulai menggunakan Durable Task SDK

• JavaScript SDK sampel pada GitHub