Durable Functions untuk Alur Kerja Berstatus
Orkestrasi alur kerja yang berjalan lama menggunakan pola orkestrator Durable Functions (fan-out/fan-in, perantaian, pemantauan), lalu pahami cara status dibuatkan titik pemeriksaannya.
Durable Functions untuk Alur Kerja Berstatus adalah pelajaran Cloud & IT Cert Prep gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Cloud & IT Cert Prep, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Cloud & IT Cert Prep mencakup 4 pelajaran total.
Mengapa Durable Functions?
Fungsi Azure biasa bersifat stateless—setiap pemanggilan berjalan secara independen tanpa mengingat pemanggilan sebelumnya. Durable Functions memperluas Fungsi Azure dengan kemampuan untuk menulis alur kerja stateful yang berjalan lama menggunakan kode async/await biasa. Durable Task Framework secara otomatis membuat titik pemeriksaan status ke Penyimpanan Azure setelah setiap langkah, sehingga alur kerja dapat bertahan selama server dimulai ulang, terjadi timeout, atau pemeliharaan terencana, lalu dilanjutkan tepat dari posisi terakhir.
Tiga Jenis Fungsi
Durable Functions memperkenalkan tiga jenis fungsi. Fungsi orkestrator mengoordinasikan keseluruhan alur kerja—fungsi ini memanggil fungsi aktivitas dan menunggu hasil menggunakan yield atau await tanpa benar-benar memblokir thread. Fungsi aktivitas menjalankan satu unit pekerjaan (memanggil API atau menulis ke basis data) dan merupakan satu-satunya tempat efek samping seharusnya terjadi. Fungsi entitas memelihara bagian kecil dari status durable (penghitung, penanda) di antara pemanggilan.
// Client function (HTTP trigger) — starts the orchestration
module.exports = async function (context, req) {
const client = df.getClient(context);
const orderId = req.body.orderId;
const instanceId = await client.startNew('OrderOrchestrator', undefined, { orderId });
return client.createCheckStatusResponse(context.bindingData.req, instanceId);
};Pola Chaining
Pola chaining menjalankan fungsi aktivitas secara berurutan, dengan meneruskan keluaran salah satu fungsi sebagai masukan ke fungsi berikutnya. Orkestrator menunggu setiap aktivitas secara bergantian. Jika ada aktivitas yang gagal, alur kerja berhenti dan dapat dimulai ulang dari langkah yang gagal. Ini adalah pola Durable Functions yang paling sederhana dan cocok untuk alur kerja yang setiap langkahnya bergantung pada hasil langkah sebelumnya, seperti alur pemrosesan pesanan.
// Orchestrator: chaining pattern
const df = require('durable-functions');
module.exports = df.orchestrator(function* (context) {
const orderId = context.df.getInput().orderId;
const validated = yield context.df.callActivity('ValidateOrder', orderId);
const charged = yield context.df.callActivity('ChargePayment', validated);
const shipped = yield context.df.callActivity('ShipOrder', charged);
return { status: 'shipped', trackingId: shipped.trackingId };
});Pola Fan-Out / Fan-In
Pola fan-out/fan-in menjalankan beberapa fungsi aktivitas secara paralel dan menunggu semuanya selesai sebelum melanjutkan. Orkestrator memulai semua tugas secara bersamaan menggunakan callActivity tanpa menunggunya, mengumpulkan objek tugas ke dalam array, lalu melakukan Task.all(). Cara ini jauh lebih cepat daripada pemrosesan berurutan untuk pekerjaan independen seperti memproses beberapa file, memanggil beberapa API, atau menjalankan operasi batch.
// Orchestrator: fan-out / fan-in
module.exports = df.orchestrator(function* (context) {
const items = context.df.getInput().items;
// Fan-out: start all tasks in parallel
const tasks = items.map(item => context.df.callActivity('ProcessItem', item));
// Fan-in: wait for all tasks to complete
const results = yield context.df.Task.all(tasks);
return results;
});Pola Monitor
Pola monitor melakukan polling terhadap sistem eksternal pada interval tertentu hingga suatu kondisi terpenuhi—mirip dengan loop polling, tetapi sepenuhnya durable. Orkestrator memanggil suatu aktivitas untuk memeriksa status, menunggu interval yang dapat dikonfigurasi menggunakan createTimer, lalu mengulangi proses tersebut. Karena status dibuatkan titik pemeriksaan ke penyimpanan di antara setiap polling, orkestrator tidak menggunakan sumber daya komputasi saat menunggu, sehingga jauh lebih efisien daripada pendekatan berbasis timer yang tidur.
// Orchestrator: monitor pattern (poll until job completes)
module.exports = df.orchestrator(function* (context) {
const jobId = context.df.getInput().jobId;
const expiry = new Date(context.df.currentUtcDateTime);
expiry.setHours(expiry.getHours() + 24); // 24-hour timeout
while (context.df.currentUtcDateTime < expiry) {
const status = yield context.df.callActivity('GetJobStatus', jobId);
if (status === 'completed') return { jobId, status };
if (status === 'failed') throw new Error('Job failed');
// Wait 30 seconds before next poll
const nextCheck = new Date(context.df.currentUtcDateTime);
nextCheck.setSeconds(nextCheck.getSeconds() + 30);
yield context.df.createTimer(nextCheck);
}
throw new Error('Workflow timed out');
});Pola Interaksi Manusia
Pola interaksi manusia menjeda orkestrasi dan menunggu peristiwa eksternal—misalnya persetujuan manajer. Orkestrator melakukan waitForExternalEvent, yang dapat menunggu selama berhari-hari atau berminggu-minggu tanpa menggunakan komputasi. Sistem eksternal (tautan persetujuan melalui email, aplikasi seluler, atau webhook) memanggil API HTTP Durable Functions untuk memicu peristiwa tersebut dan melanjutkan orkestrasi. Gabungkan dengan timer untuk menerapkan timeout otomatis dan eskalasi jika tidak ada respons.
// Orchestrator: wait for human approval with timeout
module.exports = df.orchestrator(function* (context) {
const request = context.df.getInput();
yield context.df.callActivity('SendApprovalEmail', request);
const timeout = df.Task.createTimer(context, new Date(Date.now() + 48 * 3600 * 1000));
const approval = context.df.waitForExternalEvent('ApprovalResponse');
const winner = yield context.df.Task.any([approval, timeout]);
if (winner === approval) {
const approved = winner.result;
return approved ? 'Approved' : 'Rejected';
} else {
return 'Timed out — escalated';
}
});Batasan Orkestrator
Fungsi orkestrator memiliki batasan penting karena dapat diputar ulang berkali-kali dari riwayat untuk membangun ulang status. Fungsi ini harus bersifat deterministik—jangan pernah menggunakan Date.now(), Math.random(), atau melakukan panggilan I/O langsung. Sebagai gantinya, gunakan context.df.currentUtcDateTime untuk stempel waktu dan panggil fungsi aktivitas untuk semua I/O. Logging di dalam isi orkestrator akan menghasilkan entri log duplikat selama pemutaran ulang; gunakan fungsi aktivitas untuk logging.
// WRONG — non-deterministic, will cause replay bugs
module.exports = df.orchestrator(function* (context) {
const now = new Date(); // Don't use Date()
const rand = Math.random(); // Don't use Math.random()
const data = await fetch('/api'); // Don't make HTTP calls directly
});
// CORRECT
module.exports = df.orchestrator(function* (context) {
const now = context.df.currentUtcDateTime; // OK
const data = yield context.df.callActivity('FetchData', null); // OK
});Mengelola Instans: Status dan Penghentian
Setiap proses orkestrasi memiliki ID instans unik yang dapat digunakan untuk meminta statusnya, mengirim peristiwa, atau menghentikannya. API manajemen HTTP Durable Functions menyediakan endpoint untuk memeriksa status (GET /instances/{id}), mengirim peristiwa (POST /instances/{id}/raiseEvent/{name}), dan menghentikan proses (POST /instances/{id}/terminate). Gunakan binding klien Durable dalam fungsi Anda untuk mengakses operasi ini secara terprogram.
// Client function: check orchestration status
module.exports = async function (context, req) {
const client = df.getClient(context);
const instanceId = req.params.instanceId;
const status = await client.getStatus(instanceId, true, true, true);
return {
status: 200,
body: {
instanceId,
runtimeStatus: status.runtimeStatus,
customStatus: status.customStatus,
output: status.output
}
};
};Backend Penyimpanan dan Performa
Durable Functions menyimpan riwayat orkestrasi, status instans, dan antrean pesan antarfungsi dalam Akun Penyimpanan Azure (atau backend Azure SQL/Netherite untuk throughput yang lebih tinggi). Setiap titik pemeriksaan menulis ke Azure Table Storage dan Azure Queue Storage. Untuk skenario dengan throughput tinggi (ribuan orkestrasi bersamaan), backend penyimpanan Netherite menggunakan Azure Event Hubs untuk memberikan performa yang jauh lebih baik. Pantau kedalaman antrean orkestrasi untuk mendeteksi hambatan.
// host.json: configure the Durable Task storage provider
{
'version': '2.0',
'extensions': {
'durableTask': {
'hubName': 'MyTaskHub',
'storageProvider': {
'type': 'azure',
'connectionStringName': 'AzureWebJobsStorage',
'controlQueueBatchSize': 32,
'maxQueuePollingInterval': '00:00:02'
}
}
}
}Penanganan Error dan Percobaan Ulang
Fungsi aktivitas dapat melempar pengecualian yang diteruskan kembali ke orkestrator sebagai TaskFailedException. Gunakan blok try-catch dalam orkestrator untuk menangani kegagalan dengan baik. Untuk error sementara, konfigurasikan percobaan ulang otomatis dengan jeda bertahap menggunakan callActivityWithRetry, dengan menentukan jumlah percobaan maksimum, interval percobaan ulang pertama, dan koefisien jeda bertahap. Ini adalah pola yang direkomendasikan untuk aktivitas yang memanggil API atau basis data eksternal.
// Orchestrator: retry an activity with exponential backoff
module.exports = df.orchestrator(function* (context) {
const retryOptions = new df.RetryOptions(
5000, // firstRetryIntervalInMilliseconds
3 // maxNumberOfAttempts
);
retryOptions.backoffCoefficient = 2; // 5s, 10s, 20s
try {
const result = yield context.df.callActivityWithRetry(
'CallExternalAPI',
retryOptions,
context.df.getInput()
);
return result;
} catch (e) {
yield context.df.callActivity('SendFailureAlert', e.message);
throw e;
}
});Entitas Durable
Entitas Durable (fungsi entitas) mengimplementasikan bagian kecil status durable yang dapat diakses berdasarkan identitas—mirip dengan aktor virtual. Entitas memiliki ID dan status yang dipertahankan di antara pemanggilan. Anda memanggil operasi pada entitas dari orkestrator atau klien, dan entitas memprosesnya satu per satu (secara serial). Penggunaan umumnya mencakup penghitung, mesin status persetujuan, pembatas laju, dan keranjang belanja—yaitu skenario apa pun yang memerlukan status durable yang dapat diperbarui tanpa basis data.
// Counter entity function
const df = require('durable-functions');
module.exports = df.entity(function (context) {
let count = context.df.getState(() => 0);
const operation = context.df.operationName;
if (operation === 'add') count += context.df.getInput();
if (operation === 'reset') count = 0;
if (operation === 'get') context.df.return(count);
context.df.setState(count);
});
// From orchestrator, increment counter entity
// const entityId = new df.EntityId('Counter', 'myCounter');
// yield context.df.callEntity(entityId, 'add', 1);Pemeriksaan Singkat
Uji pemahaman Anda tentang konsep Microsoft Azure Fundamentals (AZ-900) dari pelajaran ini.
Ringkasan Pelajaran
Dalam pelajaran ini, Anda telah mempelajari bahwa Durable Functions memungkinkan alur kerja stateful yang berjalan lama dengan membuat titik pemeriksaan status orkestrator ke Penyimpanan Azure, pola utamanya mencakup chaining, fan-out/fan-in, monitor, dan interaksi manusia, serta orkestrator harus deterministik—semua I/O dan pemanggilan nondeterministik harus dilakukan melalui fungsi aktivitas. Selanjutnya, kita akan membahas Azure Logic Apps.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Durable Functions untuk Alur Kerja Berstatus” gratis?
Ya — teks lengkap “Durable Functions untuk Alur Kerja Berstatus” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Cloud & IT Cert Prep, upgrade ke CoddyKit PRO. Kursus Cloud & IT Cert Prep mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Durable Functions untuk Alur Kerja Berstatus”?
Orkestrasi alur kerja yang berjalan lama menggunakan pola orkestrator Durable Functions (fan-out/fan-in, perantaian, pemantauan), lalu pahami cara status dibuatkan titik pemeriksaannya. Kamu berlatih Cloud & IT Cert Prep dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Cloud & IT Cert Prep?
Tidak diperlukan pengalaman sebelumnya. Cloud & IT Cert Prep di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.
Berapa lama pelajaran “Durable Functions untuk Alur Kerja Berstatus” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Cloud & IT Cert Prep ini?
Ya. Setiap pelajaran Cloud & IT Cert Prep menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Pemicu dan Pengikatan Azure Functions
- Durable Functions untuk Alur Kerja Berstatus
- Azure Logic Apps
- Event Grid dan Arsitektur Berbasis Peristiwa