स्टेटफुल वर्कफ़्लो के लिए Durable Functions
Durable Functions ऑर्केस्ट्रेटर पैटर्न (fan-out/fan-in, chaining, monitor) का उपयोग करके लंबे समय तक चलने वाले वर्कफ़्लो का समन्वय करें और समझें कि स्थिति का चेकपॉइंट कैसे बनाया जाता है।
स्टेटफुल वर्कफ़्लो के लिए Durable Functions, CoddyKit पर Cloud & IT Cert Prep का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Cloud & IT Cert Prep सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Cloud & IT Cert Prep पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
Durable फ़ंक्शंस क्यों?
सामान्य Azure फ़ंक्शंस स्थिति-विहीन होते हैं—हर आह्वान पिछले कॉल की कोई जानकारी रखे बिना स्वतंत्र रूप से चलता है। Durable फ़ंक्शंस Azure फ़ंक्शंस में साधारण async/await कोड का उपयोग करके स्थिति-सक्षम, लंबे समय तक चलने वाले वर्कफ़्लो लिखने की क्षमता जोड़ते हैं। Durable Task Framework हर चरण के बाद स्थिति को Azure Storage में स्वचालित रूप से सुरक्षित करता है, इसलिए वर्कफ़्लो सर्वर के पुनः आरंभ होने, समय-सीमा समाप्त होने या नियोजित रखरखाव के बाद भी जारी रह सकते हैं और ठीक वहीं से फिर शुरू हो सकते हैं जहाँ वे रुके थे।
तीन फ़ंक्शन प्रकार
Durable फ़ंक्शंस तीन फ़ंक्शन प्रकार प्रस्तुत करते हैं। ऑर्केस्ट्रेटर फ़ंक्शन पूरे वर्कफ़्लो का समन्वय करता है—यह गतिविधि फ़ंक्शंस को कॉल करता है और yield या await का उपयोग करके परिणामों की प्रतीक्षा करता है, लेकिन वास्तव में किसी थ्रेड को अवरुद्ध नहीं करता। गतिविधि फ़ंक्शन किसी एक कार्य-इकाई को पूरा करता है (किसी API को कॉल करना, डेटाबेस में लिखना) और साइड इफ़ेक्ट केवल इसी स्थान पर होने चाहिए। एंटिटी फ़ंक्शन कॉल के बीच छोटे-छोटे स्थायी डेटा (काउंटर, फ़्लैग) बनाए रखता है।
// 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);
};चेनिंग पैटर्न
चेनिंग पैटर्न गतिविधि फ़ंक्शंस को क्रमिक रूप से चलाता है और एक के आउटपुट को अगले के इनपुट के रूप में भेजता है। ऑर्केस्ट्रेटर प्रत्येक गतिविधि की बारी-बारी से प्रतीक्षा करता है। यदि कोई गतिविधि विफल हो जाती है, तो वर्कफ़्लो रुक जाता है और विफल चरण से पुनः शुरू किया जा सकता है। यह Durable फ़ंक्शंस का सबसे सरल पैटर्न है और ऐसे वर्कफ़्लो के लिए उपयुक्त है जहाँ प्रत्येक चरण पिछले चरण के परिणाम पर निर्भर करता है, जैसे ऑर्डर प्रोसेसिंग पाइपलाइन।
// 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 };
});Fan-Out / Fan-In पैटर्न
fan-out/fan-in पैटर्न कई गतिविधि फ़ंक्शंस को समानांतर रूप से शुरू करता है और आगे बढ़ने से पहले उन सभी के पूरा होने की प्रतीक्षा करता है। ऑर्केस्ट्रेटर सभी कार्यों को callActivity का उपयोग करके बिना उनकी प्रतीक्षा किए एक साथ शुरू करता है, कार्य ऑब्जेक्ट को एक ऐरे में एकत्र करता है, फिर Task.all() पर प्रतीक्षा करता है। स्वतंत्र कार्य-इकाइयों, जैसे कई फ़ाइलों को प्रोसेस करना, कई API को कॉल करना या बैच संचालन, के लिए यह क्रमिक प्रोसेसिंग से बहुत तेज़ होता है।
// 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;
});मॉनिटर पैटर्न
मॉनिटर पैटर्न किसी शर्त के पूरा होने तक निश्चित अंतराल पर बाहरी सिस्टम की जाँच करता है—यह पोलिंग लूप जैसा होता है, लेकिन पूरी तरह स्थायी रहता है। ऑर्केस्ट्रेटर स्थिति जाँचने के लिए किसी गतिविधि को कॉल करता है, createTimer का उपयोग करके कॉन्फ़िगर किए गए अंतराल तक प्रतीक्षा करता है, फिर यह प्रक्रिया दोहराता है। प्रत्येक जाँच के बीच स्थिति स्टोरेज में सुरक्षित रहती है, इसलिए प्रतीक्षा के दौरान ऑर्केस्ट्रेटर कंप्यूट संसाधनों का उपयोग नहीं करता। इससे यह सोने वाले टाइमर-आधारित तरीके की तुलना में कहीं अधिक कुशल होता है।
// 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');
});मानवीय सहभागिता पैटर्न
मानवीय सहभागिता पैटर्न किसी ऑर्केस्ट्रेशन को रोककर बाहरी घटना की प्रतीक्षा करता है—जैसे प्रबंधक की स्वीकृति। ऑर्केस्ट्रेटर waitForExternalEvent पर प्रतीक्षा करता है, जो कंप्यूट संसाधनों का उपयोग किए बिना कई दिनों या हफ़्तों तक प्रतीक्षा कर सकता है। कोई बाहरी सिस्टम (ईमेल स्वीकृति लिंक, मोबाइल ऐप, वेबहुक) घटना को सक्रिय करने के लिए Durable फ़ंक्शंस HTTP API को कॉल करता है और ऑर्केस्ट्रेशन फिर आगे बढ़ता है। यदि कोई प्रतिक्रिया न आए, तो स्वचालित समय-सीमा और एस्केलेशन के लिए इसे टाइमर के साथ मिलाकर उपयोग करें।
// 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';
}
});ऑर्केस्ट्रेटर की सीमाएँ
ऑर्केस्ट्रेटर फ़ंक्शंस पर महत्वपूर्ण सीमाएँ होती हैं, क्योंकि स्थिति को फिर से बनाने के लिए उन्हें इतिहास से कई बार दोहराकर चलाया जा सकता है। उन्हें नियतात्मक होना चाहिए—कभी भी Date.now(), Math.random() का उपयोग न करें और न ही सीधे I/O कॉल करें। इसके बजाय, टाइमस्टैम्प के लिए context.df.currentUtcDateTime का उपयोग करें और सभी I/O के लिए गतिविधि फ़ंक्शंस को कॉल करें। ऑर्केस्ट्रेटर के मुख्य भाग में लॉगिंग करने पर दोहराए गए निष्पादन के दौरान लॉग प्रविष्टियाँ कई बार बनेंगी; इसलिए लॉगिंग के लिए गतिविधि फ़ंक्शंस का उपयोग करें।
// 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
});इंस्टेंस प्रबंधन: स्थिति और समाप्ति
प्रत्येक ऑर्केस्ट्रेशन रन की एक विशिष्ट इंस्टेंस ID होती है, जिसका उपयोग उसकी स्थिति पूछने, घटनाएँ भेजने या उसे समाप्त करने के लिए किया जा सकता है। Durable फ़ंक्शंस HTTP प्रबंधन API स्थिति जाँचने (GET /instances/{id}), घटनाएँ भेजने (POST /instances/{id}/raiseEvent/{name}) और समाप्त करने (POST /instances/{id}/terminate) के लिए एंडपॉइंट प्रदान करती है। इन संचालन को प्रोग्राम के माध्यम से करने के लिए अपने फ़ंक्शंस में Durable क्लाइंट बाइंडिंग का उपयोग करें।
// 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
}
};
};स्टोरेज बैकएंड और प्रदर्शन
Durable फ़ंक्शंस ऑर्केस्ट्रेशन इतिहास, इंस्टेंस स्थिति और इंटर-फ़ंक्शन संदेश कतारों को Azure Storage Account में संग्रहीत करते हैं (अधिक थ्रूपुट के लिए Azure SQL/Netherite बैकएंड भी उपलब्ध हैं)। प्रत्येक चेकपॉइंट Azure Table Storage और Azure Queue Storage में लिखता है। अधिक थ्रूपुट वाले परिदृश्यों (हज़ारों समवर्ती ऑर्केस्ट्रेशन) में Netherite स्टोरेज बैकएंड बेहतर प्रदर्शन के लिए Azure Event Hubs का उपयोग करता है। रुकावटों का पता लगाने के लिए ऑर्केस्ट्रेशन कतार की गहराई पर नज़र रखें।
// 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'
}
}
}
}त्रुटि प्रबंधन और पुनःप्रयास
गतिविधि फ़ंक्शंस अपवाद उत्पन्न कर सकते हैं, जो ऑर्केस्ट्रेटर तक TaskFailedException के रूप में पहुँचते हैं। विफलताओं को उचित ढंग से संभालने के लिए ऑर्केस्ट्रेटर में try-catch ब्लॉक का उपयोग करें। अस्थायी त्रुटियों के लिए callActivityWithRetry का उपयोग करके बैकऑफ़ के साथ स्वचालित पुनःप्रयास कॉन्फ़िगर करें और अधिकतम प्रयास, पहला पुनःप्रयास अंतराल तथा बैकऑफ़ गुणांक निर्दिष्ट करें। बाहरी API या डेटाबेस को कॉल करने वाली गतिविधियों के लिए यह अनुशंसित पैटर्न है।
// 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;
}
});Durable एंटिटी
Durable Entities (एंटिटी फ़ंक्शंस) पहचान के माध्यम से उपलब्ध छोटे-छोटे स्थायी डेटा को लागू करते हैं—यह वर्चुअल एक्टर्स के समान है। किसी एंटिटी की एक ID और ऐसी स्थिति होती है जो कॉल के बीच बनी रहती है। आप ऑर्केस्ट्रेटर या क्लाइंट से एंटिटी पर संचालन कॉल करते हैं और एंटिटी उन्हें एक-एक करके (क्रमबद्ध रूप से) प्रोसेस करती है। सामान्य उपयोगों में काउंटर, स्वीकृति स्थिति मशीन, दर सीमक और शॉपिंग कार्ट शामिल हैं—अर्थात ऐसे सभी परिदृश्य जिनमें डेटाबेस के बिना स्थायी, अद्यतन किए जा सकने वाले डेटा की आवश्यकता होती है।
// 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);त्वरित जाँच
इस पाठ में सिखाई गई Microsoft Azure Fundamentals (AZ-900) की अवधारणाओं के बारे में अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: Durable फ़ंक्शंस ऑर्केस्ट्रेटर की स्थिति को Azure Storage में चेकपॉइंट करके स्थिति-सक्षम, लंबे समय तक चलने वाले वर्कफ़्लो सक्षम करते हैं; मुख्य पैटर्न में चेनिंग, fan-out/fan-in, मॉनिटर और मानवीय सहभागिता शामिल हैं; और ऑर्केस्ट्रेटर नियतात्मक होने चाहिए—सभी I/O और अनियतात्मक कॉल गतिविधि फ़ंक्शंस के माध्यम से किए जाने चाहिए। आगे हम Azure Logic Apps का अध्ययन करेंगे।
एआई शिक्षक के साथ Cloud & IT Cert Prep सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 150
- पाठ
- 600
अक्सर पूछे जाने वाले प्रश्न
क्या “स्टेटफुल वर्कफ़्लो के लिए Durable Functions” पाठ निःशुल्क है?
हाँ—“स्टेटफुल वर्कफ़्लो के लिए Durable Functions” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Cloud & IT Cert Prep पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Cloud & IT Cert Prep पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“स्टेटफुल वर्कफ़्लो के लिए Durable Functions” में मैं क्या सीखूँगा?
Durable Functions ऑर्केस्ट्रेटर पैटर्न (fan-out/fan-in, chaining, monitor) का उपयोग करके लंबे समय तक चलने वाले वर्कफ़्लो का समन्वय करें और समझें कि स्थिति का चेकपॉइंट कैसे बनाया जाता है। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Cloud & IT Cert Prep का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Cloud & IT Cert Prep शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Cloud & IT Cert Prep शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।
“स्टेटफुल वर्कफ़्लो के लिए Durable Functions” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Cloud & IT Cert Prep पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Cloud & IT Cert Prep पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Azure Functions ट्रिगर और बाइंडिंग
- स्टेटफुल वर्कफ़्लो के लिए Durable Functions
- Azure Logic Apps
- Event Grid और इवेंट-आधारित संरचना