Gecikmeler ve zaman aşımları için dayanıklı zamanlayıcılar uygulama

Durable Functions, orchestrator işlevlerinde kullanılmak üzere gecikmeleri uygulamak veya zaman uyumsuz eylemlerde zaman aşımlarını ayarlamak için dayanıklı zamanlayıcılar sağlar. Ya da dilde yerleşik olabilecek API'ler yerine sleepdelay orchestrator işlevlerinde dayanıklı zamanlayıcılar kullanın.

Dayanıklı Görev SDK'ları, gecikmeleri uygulamak veya eşzamansız eylemlerde zaman aşımlarını ayarlamak için orkestrasyonlarda kullanılmak üzere dayanıklı zamanlayıcılar sağlar. Orkestrasyonlarda, dilde yerleşik olabilecek sleep veya delay API'ler yerine dayanıklı zamanlayıcılar kullanın.

Önemli

Şu anda PowerShell Dayanıklı Görev SDK'sı kullanılamıyor.

Dayanıklı zamanlayıcılar, aşağıdaki örneklerde görüldüğü gibi sağlanan dil için uygun create timer API kullanılarak oluşturulmuş görevlerdir ve argüman olarak bir son tarih veya bir süre alır.

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

Dayanıklı Görev SDK'sı PowerShell için kullanılamaz. Bunun yerine Durable Functions kullanın.

Zamanlayıcı görevini başlattığınızda await, orkestratör işlevi belirtilen sona erme zamanına kadar uyku moduna girer.

Zamanlayıcı görevini await yaptığınızda, orkestrasyon belirtilen süreye kadar uyur.

Uyarı

Orkestrasyonlar, zamanlayıcı görevinin süresi dolarken gelen olayları işlemeye devam eder.

Kalıcı zamanlayıcı sınırlamaları

Süresi 16:30 UTC'de dolan bir süreölçer oluşturduğunuzda, temel alınan Dayanıklı Görev Çerçevesi yalnızca 16:30 UTC'de görünür hale gelen bir ileti sıralar. Bu sırada işlev uygulamasının ölçeği sıfır örneğe düşürüldüyse, yeni görünen zamanlayıcı iletisi işlev uygulamasının uygun bir VM'de yeniden etkinleştirilmesini sağlar.

Uyarı

• JavaScript, Python ve PowerShell uygulamaları için dayanıklı zamanlayıcılar altı günle sınırlıdır. Bu sınırlamayı geçici olarak çözmek için zamanlayıcı API'lerini bir döngüde while kullanarak daha uzun bir gecikmeyi simüle edin. Güncel .NET ve Java uygulamaları rastgele uzun süreölçerleri destekler.
• Kullanılan SDK ve depolama sağlayıcısının sürümüne bağlı olarak, altı gün veya daha uzun süreölçerler, istenen süre sonu zamanına ulaşılana kadar dahili olarak bir dizi daha kısa süreölçer (örneğin, üç günlük süreler) kullanılarak uygulanabilir. Bu davranış, temel alınan veri deposunda gözlemlenebilir ancak düzenleme davranışını etkilemez.
• Geçerli saati almak için yerleşik tarih/saat API'lerini kullanmayın. Zamanlayıcının süresinin dolması için gelecekteki bir tarihi hesaplarken her zaman orchestrator işlevinin geçerli saat API'sini kullanın. Daha fazla bilgi için orchestrator işlev kodu kısıtlamaları makalesine bakın.

Süresi 16:30 UTC'de dolan bir süreölçer oluşturduğunuzda, temel alınan Dayanıklı Görev Çerçevesi yalnızca 16:30 UTC'de görünür hale gelen bir ileti sıralar. Zamanlayıcı iletisi, süreölçerin süresi dolduğunda çalışanın yeniden etkinleştirilmesini sağlar.

Uyarı

• Uzun bir gecikme (örneğin, birkaç gün veya daha uzun bir gecikme) belirtilmesi, dahili olarak yönetilen birden çok dayanıklı süreölçer oluşturulmasına neden olabilir. Düzenleme kodunun bu davranışın farkında olması gerekmez. Ancak, framework günlüklerinde ve depolanmış geçmiş kayıt durumunda görünebilir.
• Geçerli saati almak için yerleşik tarih ve saat API'lerini kullanmayın. Zamanlayıcının süresinin dolacağı gelecekteki bir tarihi hesaplarken, her zaman orkestrasyon bağlamının geçerli saat özelliğini kullanın (örneğin .NET'de context.CurrentUtcDateTime, Python'da ctx.current_utc_datetime veya JavaScript'te ctx.currentUtcDateTime).

Gecikmeler için dayanıklı zamanlayıcıları kullanma

Aşağıdaki örnekte, yürütmeyi geciktirmek için dayanıklı zamanlayıcıların nasıl kullanılacağı gösterilmektedir. Örnek, 10 gün boyunca her gün bir faturalama bildirimi oluşturur.

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

Uyarı

Yukarıdaki C# örneği Durable Functions 2.x'i hedefler. Durable Functions 1.x için DurableOrchestrationContext yerine IDurableOrchestrationContext kullanın. Sürümler arasındaki farklar hakkında daha fazla bilgi için Dayanıklı İşlevler sürümleri makalesine bakın.

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

Dayanıklı Görev SDK'sı PowerShell için kullanılamaz. Bunun yerine Durable Functions kullanın.

Uyarı

Orchestrator işlevlerinde sonsuz döngülerden kaçının. Sonsuz döngü senaryolarını güvenli ve verimli bir şekilde nasıl uygulayacağınız hakkında bilgi için Eternal orchestrations bölümüne bakın.

Uyarı

Düzenlemelerde sonsuz döngülerden kaçının. Sonsuz döngü senaryolarını güvenli ve verimli bir şekilde nasıl uygulayacağınız hakkında bilgi için Eternal orchestrations bölümüne bakın.

Zaman aşımları için dayanıklı zamanlayıcıları kullanma

Bu örnekte, zaman aşımlarını uygulamak için dayanıklı zamanlayıcıların nasıl kullanılacağı gösterilmektedir:

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

Uyarı

Önceki C# örneği 2.x Durable Functions hedeflemektedir. Durable Functions 1.x için DurableOrchestrationContext yerine IDurableOrchestrationContext kullanın. Sürümler arasındaki farklar hakkında daha fazla bilgi için Dayanıklı İşlevler sürümleri makalesine bakın.

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

Dayanıklı Görev SDK'sı PowerShell için kullanılamaz. Bunun yerine Durable Functions kullanın.

Uyarı

.NET, JavaScript, Python ve PowerShell'de, kodunuz onları tamamlanmasını beklemiyorsa oluşturulan kalıcı zamanlayıcıları iptal edin. Bekleyen süreölçerleri iptal etmek için önceki örneklere bakın. Dayanıklı Görev Çerçevesi, dayanıklı zamanlayıcı görevleri de dahil olmak üzere tüm bekleyen görevler tamamlanana veya iptal edilene kadar düzenlemenin durumunu "Tamamlandı" olarak değiştirmez.

Uyarı

SDK'nız zamanlayıcı iptalini destekliyorsa (örneğin, .NET), kodunuz tamamlanmasını beklemiyorsa oluşturulan dayanıklı zamanlayıcıları iptal edin. Bekleyen süreölçerleri iptal etmek için önceki örneklere bakın. Dayanıklı Görev Çerçevesi, dayanıklı zamanlayıcı görevleri de dahil olmak üzere tüm bekleyen görevler tamamlanana veya iptal edilene kadar düzenlemenin durumunu "Tamamlandı" olarak değiştirmez.

Herhangi bir zaman desenini kullanan bu iptal mekanizması devam eden etkinlik işlevini veya alt düzenleme yürütmelerini sonlandırmaz. Bunun yerine, orchestrator işlevinin sonucu görmezden gelerek devam etmesini sağlar. İşlev uygulamanız Tüketim planını kullanıyorsa, terk edilmiş etkinlik işlevinin kullandığı süre ve bellek nedeniyle faturalandırılırsınız. Varsayılan olarak, Tüketim planında çalışan işlevlerin zaman aşımı beş dakikadır. Bu sınır aşılırsa, Azure Functions ana bilgisayar tüm yürütmeyi durdurmak ve kaçak faturalama durumunu önlemek için yeniden başlatılır. İşlev zaman aşımı yapılandırılabilir.

Orchestrator işlevlerinde zaman aşımlarını uygulama hakkında daha ayrıntılı bir örnek için İnsan etkileşimi makalesine bakın.

Herhangi bir zaman desenini kullanan bu iptal mekanizması devam eden etkinliği veya alt düzenleme yürütmelerini sonlandırmaz. Bunun yerine, orkestrasyonun sonucu görmezden gelip devam etmesini sağlar.

Sonraki Adımlar

Dış olayları tetiklemeyi ve işlemeyi öğrenin

Dayanıklı Görev SDK'larını kullanmaya başlama