फ़ंक्शन मैनेज करें

Firebase सीएलआई निर्देशों का इस्तेमाल करके या अपने फ़ंक्शन के सोर्स कोड में रनटाइम के विकल्प सेट करके, फ़ंक्शन डिप्लॉय किए जा सकते हैं, मिटाए जा सकते हैं, और उनमें बदलाव किया जा सकता है.

फ़ंक्शन डिप्लॉय करें

फ़ंक्शन डिप्लॉय करने के लिए, इस Firebase सीएलआई कमांड को चलाएं:

firebase deploy --only functions

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

firebase deploy --only functions:addMessage,functions:makeUppercase

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

उपलब्ध निर्देशों की पूरी सूची के लिए, Firebase सीएलआई का रेफ़रंस देखें.

डिफ़ॉल्ट रूप से, Firebase सीएलआई, सोर्स कोड के लिए functions/ फ़ोल्डर में दिखता है. आपके पास कोडबेस या फ़ाइलों के कई सेट में फ़ंक्शन व्यवस्थित करने का विकल्प भी होता है.

फ़ंक्शन मिटाएं

डिप्लॉय किए गए पुराने फ़ंक्शन को इस तरह मिटाया जा सकता है:

• साफ़ तौर पर, functions:delete के साथ Firebase सीएलआई में
• साफ़ तौर पर, Google Cloud Console में.
• इंप्लिसिट रूप से, डिप्लॉयमेंट से पहले सोर्स से फ़ंक्शन को हटाकर.

डेटा मिटाने की सभी कार्रवाइयां, फ़ंक्शन को प्रोडक्शन से हटाने से पहले आपको पुष्टि करने के लिए कहती हैं.

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

# Delete all functions that match the specified name in all regions.
firebase functions:delete myFunction

# Delete a specified function running in a specific region.
firebase functions:delete myFunction --region us-east-1

# Delete more than one function
firebase functions:delete myFunction myOtherFunction

# Delete a specified functions group.
firebase functions:delete groupA

# Bypass the confirmation prompt.
firebase functions:delete myFunction --force

इंप्लिसिट फ़ंक्शन मिटाने की सुविधा से, firebase deploy आपके सोर्स को पार्स करता है. साथ ही, फ़ाइल से हटाए गए किसी भी फ़ंक्शन को प्रोडक्शन से हटा देता है.

फ़ंक्शन के नाम, क्षेत्र या ट्रिगर में बदलाव करें

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

फ़ंक्शन का नाम बदलना

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

// before
const functions = require('firebase-functions');

exports.webhook = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

// after
const functions = require('firebase-functions');

exports.webhookNew = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

इसके बाद, नए फ़ंक्शन को डिप्लॉय करने के लिए, इन निर्देशों का पालन करें:

# Deploy new function called webhookNew
firebase deploy --only functions:webhookNew

# Wait until deployment is done; now both webhookNew and webhook are running

# Delete webhook
firebase functions:delete webhook

फ़ंक्शन का इलाका या इलाका बदलना

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

1. फ़ंक्शन का नाम बदलें और ज़रूरत के हिसाब से इसके क्षेत्र या इलाके बदलें.
2. बदले गए नाम वाला फ़ंक्शन डिप्लॉय करें. इससे, क्षेत्र के दोनों सेट में कुछ समय के लिए एक ही कोड चलेगा.
3. पिछले फ़ंक्शन को मिटाएं.

उदाहरण के लिए, अगर आपके पास webhook नाम का कोई फ़ंक्शन है, जो फ़िलहाल us-central1 के डिफ़ॉल्ट फ़ंक्शन क्षेत्र में है और आपको उसे asia-northeast1 पर माइग्रेट करना है, तो पहले अपने सोर्स कोड में बदलाव करके फ़ंक्शन का नाम बदलें और क्षेत्र में बदलाव करें.

// before
const functions = require('firebase-functions');

exports.webhook = functions
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

// after
const functions = require('firebase-functions');

exports.webhookAsia = functions
    .region('asia-northeast1')
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

इसके बाद, चलाकर डिप्लॉय करें:

firebase deploy --only functions:webhookAsia

अब एक जैसे दो फ़ंक्शन चल रहे हैं: us-central1 में webhook चल रहा है और asia-northeast1 में webhookAsia चल रहा है.

इसके बाद, webhook मिटाएं:

firebase functions:delete webhook

अब सिर्फ़ एक फ़ंक्शन है - webhookAsia, जो asia-northeast1 में चल रहा है.

फ़ंक्शन का ट्रिगर टाइप बदलना

समय के साथ, 'Firebase के लिए Cloud Functions' डिप्लॉयमेंट के दौरान, आपको कई वजहों से फ़ंक्शन का ट्रिगर टाइप बदलना पड़ सकता है. उदाहरण के लिए, हो सकता है कि आप एक तरह के Firebase रीयल टाइम डेटाबेस या Cloud Firestore इवेंट को एक टाइप से दूसरे टाइप में बदलना चाहें.

सिर्फ़ सोर्स कोड को बदलकर और firebase deploy चलाकर, किसी फ़ंक्शन का इवेंट टाइप नहीं बदला जा सकता. गड़बड़ियों से बचने के लिए, इस प्रोसेस से फ़ंक्शन के ट्रिगर टाइप को बदलें:

1. अपने हिसाब से ट्रिगर करने के तरीके के साथ नया फ़ंक्शन शामिल करने के लिए, सोर्स कोड में बदलाव करें.
2. ऐसा फ़ंक्शन डिप्लॉय करें जिससे पुराने और नए, दोनों फ़ंक्शन कुछ समय के लिए काम करें.
3. Firebase सीएलआई का इस्तेमाल करके, प्रोडक्शन से पुराने फ़ंक्शन को साफ़ तौर पर मिटाएं.

उदाहरण के लिए, अगर आपके पास objectChanged नाम का कोई ऐसा Node.js फ़ंक्शन है जिसमें onChange का लेगसी टाइप है और आपको इसे onFinalize में बदलना है, तो पहले फ़ंक्शन का नाम बदलें और उसमें onFinalize इवेंट टाइप के हिसाब से बदलाव करें.

// before
const functions = require('firebase-functions');

exports.objectChanged = functions.storage.object().onChange((object) => {
    return console.log('File name is: ', object.name);
});

// after
const functions = require('firebase-functions');

exports.objectFinalized = functions.storage.object().onFinalize((object) => {
    return console.log('File name is: ', object.name);
});

इसके बाद, पुराने फ़ंक्शन को मिटाने से पहले, नया फ़ंक्शन बनाने के लिए इन निर्देशों का पालन करें:

# Create new function objectFinalized
firebase deploy --only functions:objectFinalized

# Wait until deployment is done; now both objectChanged and objectFinalized are running

# Delete objectChanged
firebase functions:delete objectChanged

रनटाइम के विकल्प सेट करें

'Firebase के लिए Cloud Functions' की मदद से, आप रनटाइम के विकल्प चुन सकते हैं, जैसे कि Node.js रनटाइम वर्शन और हर फ़ंक्शन के लिए टाइम आउट, मेमोरी का बंटवारा, और फ़ंक्शन के कम से कम/ज़्यादा से ज़्यादा इंस्टेंस.

सबसे सही तरीका यह है कि ये विकल्प (Node.js वर्शन को छोड़कर) फ़ंक्शन कोड के अंदर कॉन्फ़िगरेशन ऑब्जेक्ट पर सेट किए जाने चाहिए. यह RuntimeOptions ऑब्जेक्ट, आपके फ़ंक्शन के रनटाइम के विकल्पों के लिए सबसे सटीक सोर्स है. यह ऑब्जेक्ट, सेट किए गए विकल्पों को Google Cloud Console या gcloud सीएलआई जैसे किसी दूसरे तरीके से बदल देता है.

अगर आपके डेवलपमेंट वर्कफ़्लो में Google Cloud Console या gcloud सीएलआई के ज़रिए मैन्युअल तरीके से रनटाइम के विकल्प सेट करना शामिल है और आपको हर डिप्लॉय पर ये वैल्यू ओवरराइड नहीं करनी हैं, तो preserveExternalChanges विकल्प को true पर सेट करें. अगर यह विकल्प true पर सेट है, तो Firebase आपके कोड में सेट किए गए रनटाइम विकल्पों को नीचे दी गई प्राथमिकता के साथ आपके फ़ंक्शन के डिप्लॉय किए गए मौजूदा वर्शन की सेटिंग के साथ मर्ज कर देता है:

1. फ़ंक्शन कोड में विकल्प सेट किया गया है: बाहरी बदलावों को बदलें.
2. फ़ंक्शन कोड में, विकल्प को RESET_VALUE पर सेट किया गया है: बाहरी बदलावों को डिफ़ॉल्ट वैल्यू से बदलें.
3. विकल्प को फ़ंक्शन कोड में सेट नहीं किया गया है, लेकिन उसे मौजूदा डिप्लॉय किए गए फ़ंक्शन में सेट किया गया है: डिप्लॉय किए गए फ़ंक्शन में दिए गए विकल्प का इस्तेमाल करें.

ज़्यादातर मामलों में, preserveExternalChanges: true विकल्प का इस्तेमाल करने का सुझाव नहीं दिया जाता. ऐसा इसलिए, क्योंकि अब आपका कोड आपके फ़ंक्शन के रनटाइम विकल्पों के लिए, सही जानकारी का पूरा सोर्स नहीं होगा. अगर इसका इस्तेमाल किया जाता है, तो Google Cloud Console की जांच करें या फ़ंक्शन का पूरा कॉन्फ़िगरेशन देखने के लिए gcloud सीएलआई का इस्तेमाल करें.

Node.js वर्शन सेट करें

Cloud Functions के लिए Firebase SDK टूल की मदद से, Node.js रनटाइम को चुना जा सकता है. आपके पास किसी प्रोजेक्ट में सभी फ़ंक्शन को, काम करने वाले इन Node.js वर्शन में से किसी एक से जुड़े रनटाइम एनवायरमेंट पर खास तौर पर चलाने का विकल्प होता है:

• Node.js 20 (झलक)
• Node.js 18
• Node.js 16
• Node.js 14

Node.js वर्शन को सेट करने के लिए:

शुरू करने की प्रोसेस के दौरान, आपकी functions/ डायरेक्ट्री में बनाई गई package.json फ़ाइल में, engines फ़ील्ड में वर्शन सेट किया जा सकता है. उदाहरण के लिए, सिर्फ़ वर्शन 18 का इस्तेमाल करने के लिए, package.json में इस लाइन में बदलाव करें:

  "engines": {"node": "18"}

अगर आप यार्न पैकेज मैनेजर का इस्तेमाल कर रहे हैं या engines फ़ील्ड की दूसरी खास ज़रूरतें हैं, तो आप firebase.json में Cloud Functions के लिए, Firebase SDK टूल का रनटाइम सेट कर सकते हैं:

  {
    "functions": {
      "runtime": "nodejs18" // or nodejs14, nodejs16 or nodejs20
    }
  }

सीएलआई, firebase.json में सेट की गई वैल्यू का इस्तेमाल, package.json में अलग से सेट की गई किसी वैल्यू या रेंज की जगह करता है.

अपना Node.js रनटाइम अपग्रेड करें

अपने Node.js रनटाइम को अपग्रेड करने के लिए:

1. पक्का करें कि आपका प्रोजेक्ट ब्लेज़ प्राइसिंग प्लान पर हो.
2. पक्का करें कि Firebase CLI v11.18.0 या इसके बाद के वर्शन का इस्तेमाल किया जा रहा हो.
3. शुरू करने की प्रोसेस के दौरान, आपकी functions/ डायरेक्ट्री में बनाई गई package.json फ़ाइल में, engines की वैल्यू बदलें. उदाहरण के लिए, अगर आपको वर्शन 16 से वर्शन 18 पर अपग्रेड करना है, तो एंट्री कुछ इस तरह दिखेगी: "engines": {"node": "18"}
4. इसके अलावा, Firebase लोकल एम्युलेटर सुइट का इस्तेमाल करके, अपने बदलावों की जांच करें.
5. सभी फ़ंक्शन को फिर से डिप्लॉय करें.

स्केलिंग के व्यवहार को कंट्रोल करें

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

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

कोल्ड स्टार्ट की संख्या कम करें

सोर्स कोड में किसी फ़ंक्शन के लिए, इंस्टेंस की कम से कम संख्या सेट करने के लिए, runWith तरीका इस्तेमाल करें. इस तरीके में, RuntimeOptions इंटरफ़ेस के हिसाब से JSON ऑब्जेक्ट स्वीकार किया जाता है. यह ऑब्जेक्ट minInstances की वैल्यू बताता है. उदाहरण के लिए, यह फ़ंक्शन, वॉर्म बनाए रखने के लिए कम से कम पांच इंस्टेंस सेट करता है:

exports.getAutocompleteResponse = functions
    .runWith({
      // Keep 5 instances warm for this latency-critical function
      minInstances: 5,
    })
    .https.onCall((data, context) => {
      // Autocomplete a user's search term
    });
index.js

minInstances के लिए वैल्यू सेट करते समय, इन बातों का ध्यान रखें:

• अगर 'Firebase के लिए Cloud Functions' आपके ऐप्लिकेशन को minInstances सेटिंग से ज़्यादा बढ़ाता है, तो आपको उस सीमा से ऊपर के हर इंस्टेंस के लिए कोल्ड स्टार्ट का अनुभव मिलेगा.
• कोल्ड स्टार्ट का सबसे गंभीर असर, ज़्यादा ट्रैफ़िक वाले ऐप्लिकेशन पर पड़ता है. अगर आपके ऐप्लिकेशन का ट्रैफ़िक ज़्यादा है और आपने minInstances की वैल्यू को इतना ज़्यादा सेट किया है कि ट्रैफ़िक में होने वाली हर बढ़ोतरी पर कोल्ड स्टार्ट कम हो जाता है, तो आपको इंतज़ार का समय काफ़ी कम दिखेगा. लगातार ट्रैफ़िक वाले ऐप्लिकेशन के लिए, कोल्ड स्टार्ट की वजह से परफ़ॉर्मेंस पर बहुत ज़्यादा असर पड़ने की संभावना नहीं होती.

• कम से कम इंस्टेंस सेट करना प्रोडक्शन एनवायरमेंट के लिए सही विकल्प हो सकता है, लेकिन टेस्टिंग एनवायरमेंट में इनसे बचना चाहिए. अपने टेस्ट प्रोजेक्ट को शून्य तक बढ़ाने और फिर भी अपने प्रोडक्शन प्रोजेक्ट में कोल्ड स्टार्ट को कम करने के लिए, FIREBASE_CONFIG के एनवायरमेंट वैरिएबल के आधार पर minInstances को सेट करें:

  // Get Firebase project id from `FIREBASE_CONFIG` environment variable
  const envProjectId = JSON.parse(process.env.FIREBASE_CONFIG).projectId;
  
  exports.renderProfilePage = functions
      .runWith({
        // Keep 5 instances warm for this latency-critical function
        // in production only. Default to 0 for test projects.
        minInstances: envProjectId === "my-production-project" ? 5 : 0,
      })
      .https.onRequest((req, res) => {
        // render some html
      });
  index.js
  

फ़ंक्शन के लिए, इंस्टेंस की ज़्यादा से ज़्यादा संख्या को सीमित करना

फ़ंक्शन सोर्स कोड में ज़्यादा से ज़्यादा इंस्टेंस सेट करने के लिए, runWith तरीका इस्तेमाल करें. इस तरीके में, RuntimeOptions इंटरफ़ेस के हिसाब से JSON ऑब्जेक्ट स्वीकार किया जाता है. इसमें maxInstances की वैल्यू के बारे में जानकारी दी जाती है. उदाहरण के लिए, यह फ़ंक्शन किसी काल्पनिक लेगसी डेटाबेस पर असर न डालने के लिए, 100 इंस्टेंस की सीमा सेट करता है:

exports.mirrorOrdersToLegacyDatabase = functions
    .runWith({
      // Legacy database only supports 100 simultaneous connections
      maxInstances: 100,
    })
    .firestore.document("orders/{orderId}")
    .onWrite((change, context) => {
      // Connect to legacy database
    });
index.js

अगर किसी एचटीटीपी फ़ंक्शन को maxInstances की सीमा तक बढ़ाया जाता है, तो नए अनुरोधों को 30 सेकंड के लिए सूची में जोड़ दिया जाता है. इसके बाद, अगर उस समय तक कोई अनुरोध मौजूद नहीं होता, तो रिस्पॉन्स कोड 429 Too Many Requests का इस्तेमाल करके उन्हें अस्वीकार कर दिया जाता है.

ज़्यादा से ज़्यादा इंस्टेंस सेटिंग इस्तेमाल करने के सबसे सही तरीकों के बारे में ज़्यादा जानने के लिए, maxInstances इस्तेमाल करने के सबसे सही तरीके देखें.

टाइम आउट और मेमोरी ऐलोकेशन सेट करें

कुछ मामलों में, लंबी टाइम आउट वैल्यू या ज़्यादा मेमोरी के लिए, आपके फ़ंक्शन की खास ज़रूरतें हो सकती हैं. ये वैल्यू, Google Cloud Console या फ़ंक्शन सोर्स कोड (सिर्फ़ Firebase) में सेट की जा सकती हैं.

फ़ंक्शन के सोर्स कोड में, मेमोरी का बंटवारा और टाइम आउट सेट करने के लिए, runWith का इस्तेमाल करें. इसे Cloud Functions 2.0.0 के लिए, Firebase SDK टूल में लॉन्च किया गया है. यह रनटाइम विकल्प, RuntimeOptions इंटरफ़ेस के मुताबिक JSON ऑब्जेक्ट स्वीकार करता है. इससे timeoutSeconds और memory की वैल्यू के बारे में पता चलता है. उदाहरण के लिए, यह स्टोरेज फ़ंक्शन 1 जीबी की मेमोरी का इस्तेमाल करता है और 300 सेकंड के बाद समय खत्म हो जाता है:

exports.convertLargeFile = functions
    .runWith({
      // Ensure the function has enough memory and time
      // to process large files
      timeoutSeconds: 300,
      memory: "1GB",
    })
    .storage.object()
    .onFinalize((object) => {
      // Do some complicated things that take a lot of memory and time
    });
index.js

timeoutSeconds के लिए ज़्यादा से ज़्यादा मान 540 या 9 मिनट हो सकता है. किसी फ़ंक्शन को दी गई मेमोरी, फ़ंक्शन के लिए तय किए गए सीपीयू से मेल खाती है. इस सूची में, memory के लिए मान्य वैल्यू दी गई हैं:

• 128MB — 200 मेगाहर्ट्ज़
• 256MB — 400 मेगाहर्ट्ज़
• 512MB — 800 मेगाहर्ट्ज़
• 1GB — 1.4 गीगाहर्ट्ज़
• 2GB — 2.4 गीगाहर्ट्ज़
• 4GB — 4.8 गीगाहर्ट्ज़
• 8GB — 4.8 गीगाहर्ट्ज़

Google Cloud Console में, मेमोरी का बंटवारा और टाइम आउट सेट करने के लिए:

1. Google Google Cloud Console में, बाएं मेन्यू से Cloud Functions चुनें.
2. फ़ंक्शन सूची में किसी फ़ंक्शन के नाम पर क्लिक करके उसे चुनें.
3. सबसे ऊपर मौजूद मेन्यू में, बदलाव करें आइकॉन पर क्लिक करें.
4. असाइन की गई मेमोरी लेबल वाले ड्रॉप-डाउन मेन्यू से, मेमोरी का बंटवारा चुनें.
5. बेहतर विकल्प दिखाने के लिए, ज़्यादा पर क्लिक करें. इसके बाद, समय खत्म टेक्स्ट बॉक्स में सेकंड की संख्या डालें.
6. फ़ंक्शन को अपडेट करने के लिए, सेव करें पर क्लिक करें.