Durable Functions untuk Aliran Kerja Berkeadaan
Orkestrakan aliran kerja jangka panjang menggunakan corak orkestrator Durable Functions (pecah dan gabung, rantaian, pemantauan), serta fahami cara keadaan ditanda semak.
Durable Functions untuk Aliran Kerja Berkeadaan ialah pelajaran Cloud & IT Cert Prep percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Cloud & IT Cert Prep, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Cloud & IT Cert Prep merangkumi sejumlah 4 pelajaran.
Mengapa Fungsi Durable?
Fungsi Azure biasa tidak mempunyai keadaan — setiap seruan berjalan secara berasingan tanpa mengingati seruan sebelumnya. Fungsi Durable memperluas fungsi Azure dengan keupayaan untuk menulis aliran kerja berkeadaan dan berjalan lama menggunakan kod async/await biasa. Durable Task Framework secara automatik menyimpan titik semak keadaan ke Azure Storage selepas setiap langkah, supaya aliran kerja dapat bertahan daripada mula semula pelayan, tempoh masa tamat atau penyelenggaraan terancang, kemudian disambung semula tepat dari tempat ia terhenti.
Tiga Jenis Fungsi
Fungsi Durable memperkenalkan tiga jenis fungsi. Fungsi orchestrator menyelaras keseluruhan aliran kerja — ia memanggil fungsi aktiviti dan menunggu hasil menggunakan yield atau await tanpa benar-benar menyekat utas. Fungsi aktiviti melaksanakan satu unit kerja (memanggil API atau menulis ke pangkalan data) dan merupakan satu-satunya tempat kesan sampingan patut berlaku. Fungsi entity mengekalkan cebisan kecil keadaan tahan lama (pembilang dan bendera) merentas seruan.
// 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);
};Corak Rantaian
Corak rantaian menjalankan fungsi aktiviti secara berjujukan dengan menghantar output daripada satu fungsi sebagai input kepada fungsi seterusnya. Orchestrator menunggu setiap aktiviti mengikut giliran. Jika mana-mana aktiviti gagal, aliran kerja akan berhenti dan boleh dimulakan semula dari langkah yang gagal. Ini ialah corak Fungsi Durable yang paling mudah dan sesuai untuk aliran kerja yang setiap langkahnya bergantung pada hasil langkah sebelumnya, seperti saluran paip pemprosesan 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 };
});Corak Fan-Out / Fan-In
Corak fan-out/fan-in melancarkan berbilang fungsi aktiviti secara selari dan menunggu kesemuanya selesai sebelum meneruskan. Orchestrator memulakan semua tugas serentak menggunakan callActivity tanpa menunggunya, mengumpulkan objek tugas ke dalam tatasusunan, kemudian menghasilkan pada Task.all(). Kaedah ini jauh lebih pantas berbanding pemprosesan berjujukan untuk item kerja bebas seperti memproses berbilang fail, memanggil berbilang API atau melaksanakan operasi kelompok.
// 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;
});Corak Pemantauan
Corak pemantauan meninjau sistem luaran pada sela masa tertentu sehingga sesuatu syarat dipenuhi — serupa dengan gelung tinjauan tetapi sepenuhnya tahan lama. Orchestrator memanggil aktiviti untuk menyemak status, menunggu sela masa yang boleh dikonfigurasikan menggunakan createTimer, kemudian mengulangi gelung. Oleh sebab keadaan disimpan sebagai titik semak ke storan antara setiap tinjauan, orchestrator tidak menggunakan sumber pengkomputeran semasa menunggu, menjadikannya jauh lebih cekap berbanding pendekatan berasaskan pemasa 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');
});Corak Interaksi Manusia
Corak interaksi manusia menjeda orkestrasi dan menunggu peristiwa luaran — seperti kelulusan pengurus. Orchestrator menghasilkan pada waitForExternalEvent, yang boleh menunggu selama beberapa hari atau minggu tanpa menggunakan sumber pengkomputeran. Sistem luaran (pautan kelulusan melalui e-mel, aplikasi mudah alih atau webhook) memanggil API HTTP Fungsi Durable untuk mencetuskan peristiwa tersebut, lalu menyahsekat orkestrasi. Gabungkan dengan pemasa untuk menetapkan tempoh masa tamat automatik dan peningkatan jika tiada respons diterima.
// 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';
}
});Kekangan Orchestrator
Fungsi orchestrator mempunyai kekangan penting kerana fungsi tersebut mungkin dimainkan semula daripada sejarah berkali-kali untuk membina semula keadaan. Fungsi ini mestilah deterministik — jangan gunakan Date.now(), Math.random() atau membuat seruan I/O secara langsung. Sebaliknya, gunakan context.df.currentUtcDateTime untuk cap masa dan panggil fungsi aktiviti bagi semua I/O. Pengelogan dalam badan orchestrator akan menghasilkan entri log pendua semasa main semula; gunakan fungsi aktiviti untuk pengelogan.
// 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
});Menguruskan Instance: Status dan Penamatan
Setiap pelaksanaan orkestrasi mempunyai ID instance unik yang boleh anda gunakan untuk menanyakan statusnya, menghantar peristiwa atau menamatkannya. API pengurusan HTTP Fungsi Durable menyediakan titik akhir untuk menyemak status (GET /instances/{id}), menghantar peristiwa (POST /instances/{id}/raiseEvent/{name}) dan menamatkan (POST /instances/{id}/terminate). Gunakan pengikatan klien Durable dalam fungsi anda untuk mengakses operasi ini secara programatik.
// 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 Storan dan Prestasi
Fungsi Durable menyimpan sejarah orkestrasi, keadaan instance dan baris gilir mesej antara fungsi dalam Akaun Azure Storage (atau backend Azure SQL/Netherite untuk daya pemprosesan yang lebih tinggi). Setiap titik semak menulis ke Azure Table Storage dan Azure Queue Storage. Untuk senario daya pemprosesan tinggi (beribu-ribu orkestrasi serentak), backend storan Netherite menggunakan Azure Event Hubs untuk prestasi yang jauh lebih baik. Pantau kedalaman baris gilir orkestrasi untuk mengesan kesesakan.
// 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'
}
}
}
}Pengendalian Ralat dan Percubaan Semula
Fungsi aktiviti boleh mencetuskan pengecualian, yang disebarkan kembali kepada orchestrator sebagai TaskFailedException. Gunakan blok cuba-tangkap dalam orchestrator untuk mengendalikan kegagalan dengan baik. Bagi ralat sementara, konfigurasikan percubaan semula automatik dengan penangguhan menggunakan callActivityWithRetry, dengan menyatakan bilangan percubaan maksimum, sela percubaan semula pertama dan pekali penangguhan. Ini ialah corak yang disyorkan untuk aktiviti yang memanggil API atau pangkalan data luaran.
// 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;
}
});Entity Durable
Entity Durable (fungsi entity) melaksanakan cebisan kecil keadaan tahan lama yang boleh diakses berdasarkan identiti — serupa dengan pelaku maya. Sesuatu entity mempunyai ID dan keadaan yang kekal antara seruan. Anda memanggil operasi pada entity daripada orchestrator atau klien, dan entity memprosesnya satu demi satu (bersiri). Kegunaan umum termasuk pembilang, mesin keadaan kelulusan, pengehad kadar dan troli beli-belah — apa-apa senario yang memerlukan keadaan tahan lama yang boleh dikemas kini tanpa pangkalan 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);Semakan Pantas
Uji pemahaman anda tentang konsep Asas Microsoft Azure (AZ-900) daripada pelajaran ini.
Rumusan Pelajaran
Dalam pelajaran ini, anda telah mempelajari bahawa: Fungsi Durable membolehkan aliran kerja berkeadaan dan berjalan lama dengan menyimpan keadaan orchestrator sebagai titik semak ke Azure Storage, corak utama termasuk rantaian, fan-out/fan-in, pemantauan dan interaksi manusia, dan orchestrator mestilah deterministik — semua I/O serta seruan tidak deterministik mesti dilakukan melalui fungsi aktiviti. Seterusnya, kita akan meneroka Azure Logic Apps.
Pelajari Cloud & IT Cert Prep dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 150
- Pelajaran
- 600
Soalan Lazim
Adakah pelajaran “Durable Functions untuk Aliran Kerja Berkeadaan” percuma?
Ya — teks penuh “Durable Functions untuk Aliran Kerja Berkeadaan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Cloud & IT Cert Prep, tingkat taraf kepada CoddyKit PRO. Kursus Cloud & IT Cert Prep merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Durable Functions untuk Aliran Kerja Berkeadaan”?
Orkestrakan aliran kerja jangka panjang menggunakan corak orkestrator Durable Functions (pecah dan gabung, rantaian, pemantauan), serta fahami cara keadaan ditanda semak. Anda berlatih Cloud & IT Cert Prep menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Cloud & IT Cert Prep?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Cloud & IT Cert Prep di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.
Berapa lamakah pelajaran “Durable Functions untuk Aliran Kerja Berkeadaan” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Cloud & IT Cert Prep ini?
Ya. Setiap pelajaran Cloud & IT Cert Prep menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Pencetus dan Pengikatan Azure Functions
- Durable Functions untuk Aliran Kerja Berkeadaan
- Azure Logic Apps
- Event Grid dan Seni Bina Dipacu Peristiwa