निर्धारित कार्य

अवलोकन

आप एक स्केज्यूलर को सर्वर के साथ समवर्ती रूप से चला सकते हैं ताकि कार्यों को नियमित अंतराल से संभाल सकें। स्केज्यूलर नियमित अंतराल से कार्यों को कतार में जोड़ता रहेगा, जिसे फिर क्लस्टर में उपलब्ध कर्मचारी सर्वर द्वारा क्रमिक रूप से निष्पादित किया जाएगा।

आपको यह सुनिश्चित करना होगा कि प्रत्येक नियोजन के लिए केवल एक स्केज्यूलर चल रहा हो ताकि डुप्लीकेट कार्य को बचाया जा सके। केंद्रीकृत दृष्टिकोण का उपयोग करना यह सुनिश्चित करता है कि समवर्तनीकरण आवश्यक नहीं है और सेवा ताले का उपयोग किए बिना चल सकती है।

यदि आपको नियमित कार्यों को डायनामिक रूप से जोड़ना और हटाना हो, तो सीधे स्केज्यूलर के बजाय पीरियडिकटास्कमैनेजर का उपयोग करें। अधिक विस्तृत जानकारी के लिए इस विकी का परिचय देखें।

समय क्षेत्र

नियमित कार्यों के लिए डिफ़ॉल्ट रूप से UTC समय प्रयोग होता है, लेकिन आप स्केज्यूलरओप्ट्स का उपयोग करके समय क्षेत्र बदल सकते हैं।

// उदाहरण के लिए, डिफ़ॉल्ट UTC समय क्षेत्र के बजाय America/Los_Angeles समय क्षेत्र का उपयोग करें।
loc, err := time.LoadLocation("America/Los_Angeles")
if err != nil {
    panic(err)
}
scheduler := asynq.NewScheduler(
    redisConnOpt, 
    &asynq.SchedulerOpts{
        Location: loc,
    },
)

कार्य पंजीकरण

कार्यों को नियमित अंतराल से कतार में जोड़ने के लिए, आपको स्केज्यूलर के साथ कार्य रिकॉर्ड को पंजीकृत करना होगा।

scheduler := asynq.NewScheduler(redisConnOpt, nil)

task := asynq.NewTask("example_task", nil)

// आप एक cron विनिर्देशन स्ट्रिंग का उपयोग करके नियोजन निर्धारित करने के लिए कर सकते हैं।
entryID, err := scheduler.Register("* * * * *", task)
if err != nil {
    log.Fatal(err)
}
log.Printf("पंजीकृत एक प्रविष्टि: %q\n", entryID)

// आप अंतराल निर्दिष्ट करने के लिए "@every " का भी उपयोग कर सकते हैं।
entryID, err = scheduler.Register("@every 30s", task)
if err != nil {
    log.Fatal(err)
}
log.Printf("पंजीकृत एक प्रविष्टि: %q\n", entryID)

// आप विकल्प भी पारित कर सकते हैं।
entryID, err = scheduler.Register("@every 24h", task, asynq.Queue("myqueue"))
if err != nil {
    log.Fatal(err)
}
log.Printf("पंजीकृत एक प्रविष्टि: %q\n", entryID)

स्केज्यूलर चलाना

स्केज्यूलर को चलाने के लिए, स्केज्यूलर पर Run को कॉल करें।

scheduler := asynq.NewScheduler(redisConnOpt, nil)

// ... कार्यों को पंजीकृत करें

if err := scheduler.Run(); err != nil {
    log.Fatal(err)
}

Run को कॉल करने से टर्म या इंट (जैसे Ctrl-C) सिग्नल के लिए प्रतीक्षा की जाएगी।

त्रुटि संभालना

यदि स्केज्यूलर को कार्यों को enqueue करने में विफलता होती है, तो त्रुटि को हैंडल करने के लिए आप एक हैंडलर फ़ंक्शन प्रदान कर सकते हैं।

func handleEnqueueError(task *asynq.Task, opts []asynq.Option, err error) {
    // आपका त्रुटि संभालने का तरीका
}

scheduler := asynq.NewScheduler(
    redisConnOpt, 
    &asynq.SchedulerOpts{
        EnqueueErrorHandler: handleEnqueueError,
    },
)

CLI के माध्यम से जांच

CLI में cron नामक एक सबकमांड होता है जिसका उपयोग स्केज्यूलर रिकॉर्ड की जांच के लिए किया जाता है।

वर्तमान में चल रहे स्केज्यूलर के लिए सभी रिकॉर्ड देखने के लिए, आप निम्नलिखित कमांड चला सकते हैं:

asynq cron ls

इस कमांड से प्रत्येक रिकॉर्ड के लिए आईडी, विनिर्देश स्पष्टीकरण, अगले इन-क्यू टाइम और अंतिम इन-क्यू टाइम को एक सूची आउटपुट होगी।

आप निम्नलिखित कमांड चला सकते हैं ताकि प्रत्येक रिकॉर्ड का इतिहास देख सकें:

asynq cron history