A Durable Functions hibáinak kezelése (Azure Functions)

A durable function vezénylések kódban vannak implementálva, és használhatják a programozási nyelv beépített hibakezelési funkcióit. A hibák kezelésének és a kompenzációnak a vezénylésekhez való hozzáadásához nincs szükség új fogalmakra. Vannak azonban olyan viselkedések, amelyeket érdemes figyelembe vennie.

Megjegyzés

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

A következő kódrészletekben a JavaScript (PM4) az új V4 programozási modellt jelöli.

Tevékenységfüggvények hibái

A tevékenységfüggvényekben megjelenő kivételeket a rendszer visszaállítja a vezénylő függvénybe, és egyként FunctionFailedExceptiondobja ki. A vezénylő függvényben az igényeinek megfelelő hibakezelési és kompenzációs kódot írhat.

Vegyük például a következő vezénylő függvényt, amely az egyik fiókból a másikba utal át pénzt:

C# (InProc)

[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 (Exception)
    {
        // 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 a 2.x Durable Functions. Az 1.x Durable Functions helyett a következőt kell használnia DurableOrchestrationContextIDurableOrchestrationContext: . A verziók közötti különbségekről további információt a Durable Functions verziókról szóló cikkben talál.

C# (izolált)

[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 (Exception)
    {
        // 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
            });
    }
}

JavaScript (PM3)

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

JavaScript (PM4)

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:
        yield context.call_activity('CreditAccount', {
            'account': transfer_details['sourceAccount'],
            'amount': transfer_details['amount']
        })

main = df.Orchestrator.create(orchestrator_function)

PowerShell

Alapértelmezés szerint a PowerShell-parancsmagok nem emelnek kivételeket, amelyek a try/catch blokkok használatával elkaphatók. Kétféleképpen módosíthatja ezt a viselkedést:

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

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éssel kapcsolatos további információkért lásd 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.

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

Amikor tevékenységfüggvényeket vagy alvezénylési függvényeket hív meg, megadhat egy automatikus újrapróbálkozási szabályzatot. Az alábbi példa legfeljebb háromszor próbál meghívni egy függvényt, és minden újrapróbálkozás között 5 másodpercet vár:

C# (InProc)

[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 2.x Durable Functions. Az 1.x Durable Functions helyett a következőt kell használnia DurableOrchestrationContextIDurableOrchestrationContext: . A verziók közötti különbségekről további információt a Durable Functions verziókról szóló cikkben talál.

C# (izolált)

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

    // ...
}

JavaScript (PM3)

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

    // ...
});

JavaScript (PM4)

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("FlakeyFunction", options).await();
    // ...
}

Az előző példában a tevékenységfüggvény hívása egy paramétert vesz igénybe az automatikus újrapróbálkozási szabályzat konfigurálásához. Az automatikus újrapróbálkozási szabályzat testreszabására több lehetőség is van:

• Kísérletek maximális száma: A kísérletek maximális száma. Ha az 1 értékre van állítva, nem lesz ú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ésének mértékének meghatározására használt együttható. Alapértelmezés szerint 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 száma. Az alapértelmezett viselkedés az újrapróbálkozás határozatlan ideig.

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

A .NET vagy a Java használatakor lehetősége van újrapróbálkozás-kezelők implementálására is a kódban. Ez akkor hasznos, ha a deklaratív újrapróbálkozási szabályzatok nem elég kifejezőek. Az egyéni újrapróbálkozási kezelőket nem támogató nyelvek esetében továbbra is alkalmazhat újrapróbálkozási szabályzatokat hurkok, kivételkezelés és időzítők használatával az újrapróbálkozások közötti késések injektálására.

C# (InProc)

RetryOptions retryOptions = new RetryOptions(
    firstRetryInterval: TimeSpan.FromSeconds(5),
    maxNumberOfAttempts: int.MaxValue)
    {
        Handle = exception =>
        {
            // True to handle and try again, false to not handle and throw.
            if (exception is TaskFailedException failure)
            {
                // Exceptions from TaskActivities are always this type. Inspect the
                // inner Exception to get more details.
            }

            return false;
        };
    }

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

C# (izolált)

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

JavaScript (PM3)

A JavaScript jelenleg nem támogatja az egyéni újrapróbálkozás-kezelőket. Azonban továbbra is lehetősége van az újrapróbálkozási logika implementálására közvetlenül 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ésések injektálására.

JavaScript (PM4)

A JavaScript jelenleg nem támogatja az egyéni újrapróbálkozás-kezelőket. Azonban továbbra is lehetősége van az újrapróbálkozási logika implementálására közvetlenül 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ésések injektálására.

Python

A Python jelenleg nem támogatja az egyéni újrapróbálkozás-kezelőket. Azonban továbbra is lehetősége van az újrapróbálkozási logika implementálására közvetlenül 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ésések injektálására.

PowerShell

A PowerShell jelenleg nem támogatja az egyéni újrapróbálkozás-kezelőket. Azonban továbbra is lehetősége van az újrapróbálkozási logika implementálására közvetlenül 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ésések injektálására.

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

Függvény időtúllépései

Előfordulhat, hogy egy vezénylőfüggvényen belül fel szeretné hagyni a függvényhívást, ha az túl sokáig tart. Ennek ma a megfelelő módja egy tartós időzítő létrehozása egy "bármely" feladatválasztóval, az alábbi példához hasonlóan:

C# (InProc)

[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 2.x Durable Functions. Az 1.x Durable Functions helyett a következőt kell használnia DurableOrchestrationContextIDurableOrchestrationContext: . A verziók közötti különbségekről további információt a Durable Functions verziókról szóló cikkben talál.

C# (izolált)

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

JavaScript (PM3)

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

JavaScript (PM4)

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("SlowFunction");
    Task<Void> timeoutTask = ctx.createTimer(Duration.ofMinutes(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 valójában nem állítja le a folyamatban lévő tevékenységfüggvények végrehajtását. Ehelyett egyszerűen lehetővé teszi, hogy a vezénylő függvény figyelmen kívül hagyja az eredményt, és továbblépjen. További információt az Időzítők dokumentációjában talál.

Nem kezelt kivételek

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

Következő lépések

Tudnivalók az örök vezénylésekről

Megtudhatja, hogyan diagnosztizálhatja a problémákat