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

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

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

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

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

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

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

फिर से कोशिश करने का सिमैंटिक्स

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

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

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

Cloud Functions for Firebase की मदद से, किसी फ़ंक्शन के कोड में फिर से कोशिश करने की सुविधा चालू की जा सकती है. बैकग्राउंड इवेंट के लिए ऐसा करने के लिए, जैसे कि नया Firestore दस्तावेज़ बनाना, failurePolicy (पहली जनरेशन) या retry नीति (दूसरी जनरेशन) विकल्प को 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 को सेट करने पर, फ़ंक्शन को इस तरह कॉन्फ़िगर किया जाता है कि वह गड़बड़ी होने पर फिर से कोशिश करे.

फिर से कोशिश करने की विंडो

दूसरी जनरेशन के फ़ंक्शन के लिए, फिर से कोशिश करने की यह विंडो 24 घंटे बाद खत्म हो जाती है. पहली जनरेशन के फ़ंक्शन के लिए, यह सात दिनों के बाद खत्म हो जाता है. 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 को Promises के साथ इस्तेमाल करना

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

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

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

इवेंट-ड्रिवन फ़ंक्शन को फिर से ट्रिगर करने की सुविधा को आइडेंपोटेंट बनाना

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

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

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

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

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

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

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

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