एसिंक्रोनस फ़ंक्शन को फिर से आज़माएं

इस दस्तावेज़ में बताया गया है कि एसिंक्रोनस (नॉन-एचटीटीपीएस) बैकग्राउंड फ़ंक्शन के काम न करने पर, उन्हें फिर से चलाने का अनुरोध कैसे किया जा सकता है.

इवेंट-ड्रिवन फ़ंक्शन पूरे क्यों नहीं हो पाते

कभी-कभी, किसी इंटरनल गड़बड़ी की वजह से कोई फ़ंक्शन समय से पहले बंद हो सकता है. डिफ़ॉल्ट रूप से, फ़ंक्शन को अपने-आप फिर से चलाया जा सकता है या नहीं भी चलाया जा सकता है.

आम तौर पर, इवेंट-ड्रिवन फ़ंक्शन, फ़ंक्शन कोड में मौजूद गड़बड़ियों की वजह से, पूरी तरह से काम नहीं कर पाता है. ऐसा इन वजहों से हो सकता है:

  • फ़ंक्शन में कोई गड़बड़ी है और रनटाइम में कोई समस्या आ रही है.
  • फ़ंक्शन, किसी सेवा के एंडपॉइंट तक नहीं पहुंच पाता या ऐसा करने की कोशिश में टाइम आउट हो जाता है.
  • फ़ंक्शन जान-बूझकर कोई समस्या दिखाता है. उदाहरण के लिए, जब कोई पैरामीटर, पुष्टि करने की प्रोसेस में फ़ेल हो जाता है.
  • Node.js फ़ंक्शन, अस्वीकार किया गया प्रॉमिस दिखाता है या कॉलबैक को null के अलावा कोई वैल्यू पास करता है.

ऊपर बताई गई किसी भी स्थिति में, फ़ंक्शन काम करना बंद कर देगा और एक गड़बड़ी दिखाएगा. मैसेज जनरेट करने वाले इवेंट ट्रिगर में, फिर से कोशिश करने की नीतियां होती हैं. इन्हें अपनी ज़रूरत के हिसाब से बदला जा सकता है.

फिर से कोशिश करने की प्रोसेस

Cloud Functions इवेंट सोर्स से जनरेट होने वाले हर इवेंट के लिए, इवेंट-ड्रिवन फ़ंक्शन को कम से कम एक बार ज़रूर चलाता है. डिफ़ॉल्ट रूप से, अगर कोई फ़ंक्शन गड़बड़ी के साथ बंद होता है, तो उसे फिर से नहीं चलाया जाता और इवेंट को छोड़ दिया जाता है. इवेंट-ड्रिवन फ़ंक्शन के लिए, फिर से कोशिश करने की सुविधा चालू करने पर, Cloud Functions फ़ंक्शन के काम न करने पर उसे तब तक फिर से चलाता है, जब तक वह पूरी तरह से काम न करे या फिर से कोशिश करने की समयसीमा खत्म न हो जाए.

किसी फ़ंक्शन के लिए, फिर से कोशिश करने की सुविधा चालू न होने पर, डिफ़ॉल्ट रूप से, फ़ंक्शन हमेशा यह रिपोर्ट करता है कि वह पूरी तरह से काम कर रहा है. साथ ही, उसके लॉग में 200 OK रिस्पॉन्स कोड दिख सकते हैं. ऐसा तब भी होता है, जब फ़ंक्शन में कोई गड़बड़ी आती है. यह साफ़ तौर पर बताने के लिए कि आपके फ़ंक्शन में कोई गड़बड़ी आई है, पक्का करें कि गड़बड़ियों की रिपोर्ट सही तरीके से की जाए.

अपने फ़ंक्शन कोड से, फिर से कोशिश करने की सुविधा को कॉन्फ़िगर करना

Cloud Functions for Firebase की मदद से, किसी फ़ंक्शन के कोड में, फिर से कोशिश करने की सुविधा चालू की जा सकती है. बैकग्राउंड इवेंट के लिए, जैसे कि नया Firestore दस्तावेज़ बनाने के लिए, failurePolicy (1st gen) या retry नीति (2nd gen) विकल्प को true पर सेट करें:

1st gen

exports.docCreated = functions
  .runWith({
    // retry on failure
    failurePolicy: true,
  })
  .firestore.document("my-collection/{docId}")
  .onCreate((change, context) => {
    /* ... */
  });

2nd gen

const { onDocumentCreated } = require("firebase-functions/firestore");

exports.docCreated = onDocumentCreated(
  {
    // retry on failure
    retry: true,
  },
  "my-collection/{docId}",
  (event) => {
    /* ... */
  },
);

दिखाए गए तरीके से true सेट करने पर, किसी फ़ंक्शन को काम न करने पर फिर से चलाने के लिए कॉन्फ़िगर किया जाता है.

फिर से कोशिश करने की समयसीमा

2nd gen फ़ंक्शन के लिए, फिर से कोशिश करने की यह समयसीमा 24 घंटे बाद खत्म हो जाती है. 1st gen फ़ंक्शन के लिए, यह समयसीमा सात दिनों के बाद खत्म हो जाती है. Cloud Functions नए बनाए गए इवेंट-ड्रिवन फ़ंक्शन को एक्स्पोनेंशियल बैकऑफ़ रणनीति का इस्तेमाल करके फिर से चलाता है. इसमें 10 से 600 सेकंड के बीच, बैकऑफ़ बढ़ता जाता है. यह नीति, नए फ़ंक्शन पर पहली बार डिप्लॉय करने पर लागू होती है. यह उन मौजूदा फ़ंक्शन पर पिछली तारीख से लागू नहीं होती जिन्हें इस रिलीज़ नोट में बताए गए बदलाव लागू होने से पहले पहली बार डिप्लॉय किया गया था. भले ही, आपने उन फ़ंक्शन को फिर से डिप्लॉय किया हो.

सबसे सही तरीके

इस सेक्शन में, फिर से कोशिश करने की सुविधा का इस्तेमाल करने के सबसे सही तरीकों के बारे में बताया गया है.

अस्थायी गड़बड़ियों को ठीक करने के लिए, फिर से कोशिश करने की सुविधा का इस्तेमाल करना

आपका फ़ंक्शन, पूरी तरह से काम करने तक लगातार फिर से चलाया जाता है. इसलिए, फिर से कोशिश करने की सुविधा चालू करने से पहले, बग जैसी स्थायी गड़बड़ियों को अपने कोड से हटा देना चाहिए. फिर से कोशिश करने की सुविधा का इस्तेमाल, रुक-रुककर होने वाली या अस्थायी गड़बड़ियों को ठीक करने के लिए सबसे सही है. जैसे, भरोसेमंद न होने वाला सेवा एंडपॉइंट या टाइमआउट. ऐसा इसलिए, क्योंकि फिर से कोशिश करने पर इन गड़बड़ियों के ठीक होने की संभावना ज़्यादा होती है.

फिर से कोशिश करने के लूप से बचने के लिए, खत्म होने की शर्त सेट करना

फिर से कोशिश करने की सुविधा का इस्तेमाल करते समय, अपने फ़ंक्शन को लगातार लूपिंग से बचाना सबसे सही तरीका है. ऐसा करने के लिए, फ़ंक्शन के प्रोसेस शुरू करने से पहले, खत्म होने की साफ़ तौर पर तय की गई शर्त शामिल करें. ध्यान दें कि यह तरीका सिर्फ़ तब काम करता है, जब आपका फ़ंक्शन पूरी तरह से काम करता है और खत्म होने की शर्त का आकलन कर पाता है.

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

उदाहरण के लिए, यह कोड स्निपेट, 10 सेकंड से पुराने सभी इवेंट छोड़ देता है:

const eventAgeMs = Date.now() - Date.parse(event.timestamp);
const eventMaxAgeMs = 10000;
if (eventAgeMs > eventMaxAgeMs) {
  console.log(`Dropping event ${event} with age[ms]: ${eventAgeMs}`);
  callback();
  return;
}

प्रॉमिस के साथ catch का इस्तेमाल करना

अगर आपके फ़ंक्शन के लिए, फिर से कोशिश करने की सुविधा चालू है, तो हैंडल न की गई किसी भी गड़बड़ी से, फिर से कोशिश करने की सुविधा ट्रिगर हो जाएगी. पक्का करें कि आपका कोड, उन गड़बड़ियों को कैप्चर करे जिनकी वजह से फिर से कोशिश करने की सुविधा ट्रिगर नहीं होनी चाहिए.

यहां एक उदाहरण दिया गया है कि आपको क्या करना चाहिए:

return doFooAsync().catch((err) => {
    if (isFatal(err)) {
        console.error(`Fatal error ${err}`);
    }
    return Promise.reject(err);
});

इवेंट-ड्रिवन फ़ंक्शन को फिर से चलाया जा सकता है, इसलिए उन्हें आइडमपोटेंट बनाएं

इवेंट-ड्रिवन फ़ंक्शन को फिर से चलाया जा सकता है, इसलिए उन्हें आइडमपोटेंट होना चाहिए. किसी फ़ंक्शन को आइडमपोटेंट बनाने के लिए, यहां कुछ सामान्य दिशा-निर्देश दिए गए हैं:

  • कई बाहरी एपीआई (जैसे, Stripe) आपको पैरामीटर के तौर पर, आइडमपोटेंसी की कुंजी उपलब्ध कराने की सुविधा देते हैं. अगर ऐसे किसी एपीआई का इस्तेमाल किया जा रहा है, तो आपको इवेंट आईडी को आइडमपोटेंसी की कुंजी के तौर पर इस्तेमाल करना चाहिए.
  • आइडमपोटेंसी, कम से कम एक बार डिलीवरी की सुविधा के साथ अच्छी तरह काम करती है, क्योंकि इससे फिर से कोशिश करना सुरक्षित हो जाता है. इसलिए, भरोसेमंद कोड लिखने के लिए, आइडमपोटेंसी को फिर से कोशिश करने की सुविधा के साथ जोड़ना एक सामान्य सबसे सही तरीका है.
  • पक्का करें कि आपका कोड, इंटरनल तौर पर आइडमपोटेंट हो. उदाहरण के लिए:
    • पक्का करें कि नतीजे में बदलाव किए बिना, म्यूटेशन एक से ज़्यादा बार हो सकें.
    • स्टेट में बदलाव करने से पहले, किसी लेन-देन में डेटाबेस की स्थिति के बारे में क्वेरी करें.
    • पक्का करें कि सभी साइड इफ़ेक्ट, खुद आइडमपोटेंट हों.
  • कोड से अलग, फ़ंक्शन के बाहर लेन-देन की जांच करें. उदाहरण के लिए, किसी जगह पर स्टेट को सेव करें, जिसमें यह रिकॉर्ड किया गया हो कि किसी दिए गए इवेंट आईडी को पहले ही प्रोसेस किया जा चुका है.
  • फ़ंक्शन कॉल के डुप्लीकेट को आउट-ऑफ़-बैंड तरीके से हैंडल करें. उदाहरण के लिए, एक अलग क्लीन अप प्रोसेस बनाएं, जो फ़ंक्शन कॉल के डुप्लीकेट होने के बाद, क्लीन अप करे.

फिर से कोशिश करने की नीति को कॉन्फ़िगर करना

अपने फ़ंक्शन की ज़रूरतों के हिसाब से, आपको फिर से कोशिश करने की नीति को सीधे तौर पर कॉन्फ़िगर करना पड़ सकता है. इससे, आपको इनमें से किसी भी कॉम्बिनेशन को सेट अप करने की अनुमति मिलेगी:

  • फिर से कोशिश करने की समयसीमा को सात दिनों से घटाकर, 10 मिनट तक करना.
  • एक्स्पोनेंशियल बैकऑफ़ रणनीति के लिए, कम से कम और ज़्यादा से ज़्यादा बैकऑफ़ टाइम बदलना.
  • फिर से कोशिश करने की रणनीति को तुरंत फिर से कोशिश करने के लिए बदलना.
  • a डेड-लेटर विषय कॉन्फ़िगर करना.
  • डिलीवरी की कोशिशों की ज़्यादा से ज़्यादा और कम से कम संख्या सेट करना.

फिर से कोशिश करने की नीति को कॉन्फ़िगर करने के लिए:

  1. कोई एचटीटीपी फ़ंक्शन लिखें.
  2. Pub/Sub सदस्यता बनाने के लिए, Pub/Sub API का इस्तेमाल करें. इसमें, फ़ंक्शन के यूआरएल को टारगेट के तौर पर तय करें.

गड़बड़ियों को हैंडल करने के बारे में Pub/Sub दस्तावेज़ देखें को सीधे तौर पर कॉन्फ़िगर करने के बारे में ज़्यादा जानकारी पाने के लिए.Pub/Sub