Tartós időzítők implementálása késésekhez és időtúllépésekhez

Durable Functionsdurable időzítőket biztosít a vezénylési függvényekben a késések implementálásához vagy az aszinkron műveletekhez való időkorlátok beállításához. Használjon tartós időzítőket a vezénylési sleepdelay függvényekben a nyelvbe beépített API-k helyett.

A Durable Task SDK-k tartós időzítőket biztosítanak a vezénylésekhez a késések megvalósításához vagy az aszinkron műveletek időkorlátjának beállításához. Használjon tartós időzítőket a vezénylésekhez a nyelvbe beépített sleep vagy delay API-k helyett.

Fontos

A PowerShell Durable Task SDK jelenleg nem érhető el.

A tartós időzítők a megadott nyelvhez megfelelő create timer API-val létrehozott feladatok, ahogyan az az alábbi példákban is látható, és argumentumként a határidőt vagy az időtartamot is figyelembe veszik.

C#

// Put the orchestrator to sleep for 72 hours
DateTime dueTime = context.CurrentUtcDateTime.AddHours(72);
await context.CreateTimer(dueTime, CancellationToken.None);

JavaScript

// Put the orchestrator to sleep for 72 hours
// Note that DateTime comes from the "luxon" module
const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime, {zone: 'utc'}).plus({ hours: 72 });
yield context.df.createTimer(deadline.toJSDate());

Python

# Put the orchestrator to sleep for 72 hours
due_time = context.current_utc_datetime + timedelta(hours=72)
durable_timeout_task = context.create_timer(due_time)

PowerShell

# Put the orchestrator to sleep for 72 hours
$duration = New-TimeSpan -Hours 72
Start-DurableTimer -Duration $duration

Java

// Put the orchestrator to sleep for 72 hours
ctx.createTimer(Duration.ofHours(72)).await();

C#

// Put the orchestration to sleep for 72 hours
await context.CreateTimer(TimeSpan.FromHours(72), CancellationToken.None);

Python

# Put the orchestration to sleep for 72 hours
from datetime import timedelta
yield ctx.create_timer(timedelta(hours=72))

Java

// Put the orchestration to sleep for 72 hours
ctx.createTimer(Duration.ofHours(72)).await();

JavaScript

// Put the orchestration to sleep for 72 hours
yield ctx.createTimer(72 * 60 * 60);

PowerShell

A Durable Task SDK nem érhető el a PowerShellhez. Használja inkább Durable Functions.

await Az időzítőfeladatnál a vezénylő függvény a megadott lejárati időig alszik.

Amikor elindítja az időzítő feladatot, az orkesztráció a megadott lejárati időig szünetel.

Megjegyzés:

Az orkesztrációk továbbra is feldolgozzák a többi bejövő eseményt, miközben egy időzítő feladat lejáratára várnak.

Tartós időzítő korlátozásai

Amikor létrehoz egy időzítőt, amely 16:30 (UTC) időpontban lejár, a mögöttes Durable Task Framework egy üzenetet küld, amely csak 16:30-kor (UTC) válik láthatóvá. Ha a függvényalkalmazás addig is nullára van skálázva, az újonnan látható időzítőüzenet biztosítja, hogy a függvényalkalmazás ismét aktiválódjon egy megfelelő virtuális gépen.

Megjegyzés:

• JavaScript-, Python- és PowerShell-alkalmazások esetén a tartós időzítők legfeljebb hat napig használhatók. A korlátozás megkerüléséhez használja az időzítő API-kat egy while ciklusban a hosszabb késleltetés szimulálásához. A naprakész .NET és Java alkalmazások tetszőlegesen hosszú időzítőket támogatnak.
• A használt SDK-verziótól és a tárolószolgáltatótól függően előfordulhat, hogy a hosszú, hat napos vagy annál hosszabb időzítőket belsőleg rövidebb időzítők (például háromnapos időtartamok) használatával implementálják, amíg el nem éri a kívánt lejárati időt. Ez a viselkedés megfigyelhető a mögöttes adattárban, de nem befolyásolja a vezénylési viselkedést.
• Ne használjon beépített dátum/idő API-kat az aktuális idő lekéréséhez. Az időzítő lejáratának jövőbeli dátumának kiszámításakor mindig használja a vezénylő függvény aktuális idő API-ját. További információkért tekintse meg a vezénylő függvénykód korlátozásait ismertető cikket.

Amikor létrehoz egy időzítőt, amely 16:30 (UTC) időpontban lejár, a mögöttes Durable Task Framework egy üzenetet küld, amely csak 16:30-kor (UTC) válik láthatóvá. Az időzítőüzenet biztosítja, hogy a munkavállaló újra aktiválódjön, amikor az időzítő lejár.

Megjegyzés:

• Ha hosszú késleltetést (például néhány napos vagy több napos késést) ad meg, az több, belsőleg felügyelt tartós időzítő létrehozását eredményezheti. A vezénylési kódnak nem kell tisztában lennie ezzel a viselkedésével. Ez azonban látható lehet a keretrendszernaplókban és a tárolt előzmények állapotában.
• Ne használjon beépített dátum- és idő API-kat az aktuális idő lekéréséhez. Az időzítő lejáratának jövőbeli dátumának kiszámításakor mindig használja a vezénylési környezet aktuális időtulajdonságát (például context.CurrentUtcDateTime .NET, ctx.current_utc_datetime Python vagy ctx.currentUtcDateTime JavaScriptben).

Tartós időzítők használata késésekhez

Az alábbi példa bemutatja, hogyan késleltetheti a végrehajtást tartós időzítőkkel. A példa 10 napig minden nap egy számlázási értesítést ad ki.

C#

[FunctionName("BillingIssuer")]
public static async Task Run(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    for (int i = 0; i < 10; i++)
    {
        DateTime deadline = context.CurrentUtcDateTime.Add(TimeSpan.FromDays(1));
        await context.CreateTimer(deadline, CancellationToken.None);
        await context.CallActivityAsync("SendBillingEvent");
    }
}

Megjegyzés:

Az előző C# példa a 2.x Durable Functions célozza meg. Az 1.x Durable Functions esetében a DurableOrchestrationContext használatát IDurableOrchestrationContext helyett kell alkalmazni. 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

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

module.exports = df.orchestrator(function*(context) {
    for (let i = 0; i < 10; i++) {
        const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime, {zone: 'utc'}).plus({ days: 1 });
        yield context.df.createTimer(deadline.toJSDate());
        yield context.df.callActivity("SendBillingEvent");
    }
});

Python

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

def orchestrator_function(context: df.DurableOrchestrationContext):
    for i in range(0, 9):
        deadline = context.current_utc_datetime + timedelta(days=1)
        yield context.create_timer(deadline)
        yield context.call_activity("SendBillingEvent")

main = df.Orchestrator.create(orchestrator_function)

PowerShell

param($Context)

for ($num = 0 ; $num -le 9 ; $num++){
    $expiryTime = New-TimeSpan -Days 1
    $timerTask = Start-DurableTimer -Duration $expiryTime
    Invoke-DurableActivity -FunctionName 'SendBillingEvent'
}

Java

@FunctionName("BillingIssuer")
public String billingIssuer(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    for (int i = 0; i < 10; i++) {
        ctx.createTimer(Duration.ofDays(1)).await();
        ctx.callActivity("SendBillingEvent").await();
    }
    return "done";
}

C#

public class BillingIssuer : TaskOrchestrator<object?, string>
{
    public override async Task<string> RunAsync(TaskOrchestrationContext context, object? input)
    {
        for (int i = 0; i < 10; i++)
        {
            await context.CreateTimer(TimeSpan.FromDays(1), CancellationToken.None);
            await context.CallActivityAsync("SendBillingEvent");
        }
        return "done";
    }
}

Python

from datetime import timedelta
from durabletask import task

def send_billing_event(ctx: task.ActivityContext, _) -> None:
    # Send billing event
    pass

def billing_issuer(ctx: task.OrchestrationContext, _):
    for i in range(10):
        yield ctx.create_timer(timedelta(days=1))
        yield ctx.call_activity(send_billing_event)
    return "done"

Java

public class BillingIssuer implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        for (int i = 0; i < 10; i++) {
            ctx.createTimer(Duration.ofDays(1)).await();
            ctx.callActivity("SendBillingEvent").await();
        }
        ctx.complete("done");
    }
}

JavaScript

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

const sendBillingEvent = async (_: ActivityContext): Promise<void> => {
    // Send billing event
};

const billingIssuer: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    for (let i = 0; i < 10; i++) {
        yield ctx.createTimer(24 * 60 * 60); // 1 day
        yield ctx.callActivity(sendBillingEvent);
    }
    return "done";
};

PowerShell

A Durable Task SDK nem érhető el a PowerShellhez. Használja inkább Durable Functions.

Figyelmeztetés

Kerülje a végtelen hurkokat a vezénylő függvényekben. A végtelen ciklusos forgatókönyvek biztonságos és hatékony implementálásáról további információt az Örök vezénylések című témakörben talál.

Figyelmeztetés

A vezénylések során kerülje a végtelen hurkokat. A végtelen ciklusos forgatókönyvek biztonságos és hatékony implementálásáról további információt az Örök vezénylések című témakörben talál.

Tartós időzítők használata időtúllépésekhez

Ez a példa bemutatja, hogyan lehet tartós időzítőket használni az időtúllépések implementálásához:

C#

[FunctionName("TryGetQuote")]
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("GetQuote");
        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élda a 2.x Durable Functions célozza meg. Az 1.x Durable Functions esetében a DurableOrchestrationContext használatát IDurableOrchestrationContext helyett kell alkalmazni. 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

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

module.exports = df.orchestrator(function*(context) {
    const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime, {zone: 'utc'}).plus({ seconds: 30 });

    const activityTask = context.df.callActivity("GetQuote");
    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("GetQuote")
    timeout_task = context.create_timer(deadline)

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

main = df.Orchestrator.create(orchestrator_function)

PowerShell

param($Context)

$expiryTime =  New-TimeSpan -Seconds 30

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

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

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

Java

@FunctionName("TryGetQuote")
public boolean tryGetQuote(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    Task<Double> activityTask = ctx.callActivity("GetQuote", Double.class);
    Task<Void> timerTask = ctx.createTimer(Duration.ofSeconds(30));

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

C#

public class TryGetQuote : TaskOrchestrator<object?, bool>
{
    public override async Task<bool> RunAsync(TaskOrchestrationContext context, object? input)
    {
        using var cts = new CancellationTokenSource();

        Task<double> activityTask = context.CallActivityAsync<double>("GetQuote");
        Task timeoutTask = context.CreateTimer(TimeSpan.FromSeconds(30), cts.Token);

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

Python

from datetime import timedelta
from durabletask import task

def get_quote(ctx: task.ActivityContext, _) -> float:
    # Get quote logic
    return 100.0

def try_get_quote(ctx: task.OrchestrationContext, _):
    activity_task = ctx.call_activity(get_quote)
    timeout_task = ctx.create_timer(timedelta(seconds=30))

    winner = yield task.when_any([activity_task, timeout_task])
    if winner == activity_task:
        # success case
        return True
    else:
        # timeout case
        return False

Java

public class TryGetQuote implements TaskOrchestration {
    @Override
    public void run(TaskOrchestrationContext ctx) {
        Task<Double> activityTask = ctx.callActivity("GetQuote", Double.class);
        Task<Void> timerTask = ctx.createTimer(Duration.ofSeconds(30));

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

JavaScript

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

const getQuote = async (_: ActivityContext): Promise<number> => {
    // Get quote logic
    return 100.0;
};

const tryGetQuote: TOrchestrator = async function* (ctx: OrchestrationContext): any {
    const activityTask = ctx.callActivity(getQuote);
    const timeoutTask = ctx.createTimer(30);

    const winner = yield whenAny([activityTask, timeoutTask]);
    if (winner === activityTask) {
        // success case
        return true;
    } else {
        // timeout case
        return false;
    }
};

PowerShell

A Durable Task SDK nem érhető el a PowerShellhez. Használja inkább Durable Functions.

Figyelmeztetés

.NET, JavaScript, Python és PowerShell esetén törölje a létrehozott tartós időzítőket, ha a kód nem várja meg, hogy befejeződjenek. Tekintse meg az előző példákat a függőben lévő időzítők megszakításához. A Durable Task Framework nem módosítja az orchestration állapotát "Befejezve" értékre, amíg minden hátralévő tevékenység, beleértve a tartós időzítőfeladatokat is, be nem fejeződik vagy törlésre nem kerül.

Figyelmeztetés

Ha az SDK támogatja az időzítő lemondását (például .NET), törölje a létrehozott tartós időzítőket, ha a kód nem várja meg, hogy befejeződjenek. Tekintse meg az előző példákat a függőben lévő időzítők megszakításához. A Durable Task Framework nem módosítja az orchestration állapotát "Befejezve" értékre, amíg minden hátralévő tevékenység, beleértve a tartós időzítőfeladatokat is, be nem fejeződik vagy törlésre nem kerül.

Ez a amikor-bármelyik mintát használó megszakítási mechanizmus nem állítja le a folyamatban lévő tevékenységi függvényeket vagy az al-vezénylési végrehajtást. Ehelyett egyszerűen lehetővé teszi, hogy a vezénylő függvény figyelmen kívül hagyja az eredményt, és továbblépjön. Ha a függvényalkalmazás a Használati csomagot használja, akkor továbbra is kiszámlázzuk az elhagyott tevékenységfüggvény által felhasznált időt és memóriát. A Használati tervben futó függvények alapértelmezés szerint öt perc időtúllépéssel rendelkeznek. Ha túllépi ezt a korlátot, az Azure Functions gazdagép újraindítása leállítja az összes végrehajtást, és megakadályozza az elszabadult számlázási problémát. A függvény időtúllépése konfigurálható.

Az időtúllépések vezénylési függvényekben való implementálásának részletesebb példáját az Emberi interakció című cikkben találja.

Ez a bármikori mintát használó lemondási mechanizmus nem szünteti meg az éppen folyamatban lévő tevékenységeket vagy az al-orkesztrációs futtatásokat. Ehelyett egyszerűen lehetővé teszi, hogy az orkesztráció figyelmen kívül hagyja az eredményt, és továbblépjen.

Következő lépések

Ismerje meg, hogyan generálhat és kezelhet külső eseményeket

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