Timer di Durable Functions (Azure Functions)

Artikel
03/25/2023

Durable Functions menyediakan timer durable untuk digunakan dalam fungsi orkestrator untuk menerapkan penundaan atau mengatur batas waktu pada tindakan asinkron. Timer tahan lama harus digunakan dalam fungsi orkestrator alih-alih API "tidur" atau "tunda" yang mungkin dibangun ke dalam bahasa.

Timer tahan lama adalah tugas yang dibuat menggunakan API "buat timer" yang sesuai untuk bahasa yang disediakan, seperti yang ditunjukkan di bawah, dan menggunakan waktu atau durasi sebagai argumen.

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

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

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

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

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

Saat Anda "menunggu" tugas timer, fungsi orkestrator akan tidur hingga waktu kedaluwarsa yang ditentukan.

Catatan

Orkestrasi akan terus memproses peristiwa masuk lainnya sambil menunggu tugas timer berakhir.

Batasan timer

Saat Anda membuat timer yang kedaluwarsa pada pukul 16:30 UTC, Kerangka Kerja Tahan Lama yang mendasari mengantrekan pesan yang hanya terlihat pada 16:30 UTC. Jika aplikasi fungsi diturunkan skalanya ke nol instans sementara itu, pesan timer yang baru terlihat akan memastikan bahwa aplikasi fungsi diaktifkan kembali pada mesin virtual yang sesuai.

Catatan

Untuk aplikasi JavaScript, Python, dan PowerShell, timer Durable dibatasi hingga enam hari. Untuk mengatasi batasan ini, Anda dapat menggunakan API timer dalam perulangan while untuk mensimulasikan penundaan yang lebih lama. Aplikasi .NET dan Java terbaru mendukung timer yang sangat panjang.
Tergantung pada versi SDK dan penyedia penyimpanan yang digunakan, timer panjang 6 hari atau lebih dapat diimplementasikan secara internal menggunakan serangkaian timer yang lebih singkat (misalnya, durasi 3 hari) hingga waktu kedaluwarsa yang diinginkan tercapai. Ini dapat diamati di penyimpanan data yang mendasar tetapi tidak akan berdampak pada perilaku orkestrasi.
Jangan gunakan API tanggal/waktu bawaan untuk mendapatkan waktu saat ini. Saat menghitung tanggal masa mendatang untuk timer kedaluwarsa, selalu gunakan API waktu saat ini fungsi orkestrator. Untuk informasi selengkapnya, lihat artikel Batasan kode fungsi orkestrator.

Penggunaan untuk penundaan

Contoh berikut ini menggambarkan cara menggunakan time durable untuk menunda eksekusi. Contohnya adalah menerbitkan pemberitahuan penagihan setiap hari selama 10 hari.

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

Catatan

Contoh C# sebelumnya menargetkan Durable Functions 2.x. Untuk Durable Functions 1.x, Anda harus menggunakan DurableOrchestrationContext dan bukan IDurableOrchestrationContext. Untuk informasi selengkapnya tentang perbedaan antara versi, lihat artikel Versi Durable Functions.

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

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)

param($Context)

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

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

Peringatan

Hindari perulangan tak terbatas dalam fungsi orkestrator. Untuk informasi tentang cara menerapkan skenario perulangan tanpa batas dengan aman dan efisien, lihat Eternal Orchestrations.

Penggunaan untuk batas waktu

Contoh ini menggambarkan cara menggunakan timer durable untuk menerapkan batas waktu.

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

Catatan

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

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)

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
}

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

Peringatan

Di .NET, JavaScript, Python, dan PowerShell, Anda harus membatalkan timer tahan lama yang dibuat jika kode Anda tidak akan menunggu hingga selesai. Lihat contoh di atas tentang cara membatalkan timer yang tertunda. Durable Task Framework tidak akan mengubah status orkestrasi menjadi "Selesai" hingga semua tugas yang belum selesai, termasuk tugas timer tahan lama, diselesaikan atau dibatalkan.

Mekanisme pembatalan ini menggunakan pola when-any tidak menghentikan fungsi aktivitas yang sedang berlangsung atau eksekusi suborkestrasi. Sebaliknya, itu hanya memungkinkan fungsi orkestrator untuk mengabaikan hasil dan melanjutkan. Jika aplikasi fungsi Anda menggunakan paket Konsumsi, Anda masih akan ditagihkan untuk setiap waktu dan memori yang dikonsumsi oleh fungsi aktivitas yang ditinggalkan. Secara default, fungsi yang berjalan dalam paket Konsumsi memiliki batas waktu lima menit. Jika batas ini terlampaui, host Azure Functions didaur ulang untuk menghentikan semua eksekusi dan mencegah situasi penagihan tak terkendali. Batas waktu fungsi dapat dikonfigurasi.

Untuk contoh yang lebih mendalam tentang cara menerapkan batas waktu dalam fungsi orkestrator, lihat artikel Interaksi Manusia & Batas Waktu - Verifikasi Telepon.

Langkah berikutnya

Pelajari cara menaikkan dan menangani kejadian eksternal

Bagikan melalui

Timer di Durable Functions (Azure Functions)

Batasan timer

Penggunaan untuk penundaan

Penggunaan untuk batas waktu

Langkah berikutnya

Sumber Daya Tambahan: