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

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

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

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

firebase deploy --only functions

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

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

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

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

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

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

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

• Firebase सीएलआई में functions:delete के साथ साफ़ तौर पर
• साफ़ तौर पर, 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 आपके सोर्स को पार्स करता है. साथ ही, फ़ाइल से हटाए गए किसी भी फ़ंक्शन को प्रोडक्शन से हटा देता है.

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

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

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

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

// before
const {onRequest}  = require('firebase-functions/v2/https');

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

// after
const {onRequest}  = require('firebase-functions/v2/https');

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

# before
from firebase_functions import https_fn

@https_fn.on_request()
def webhook(req: https_fn.Request) -> https_fn.Response:
    return https_fn.Response("Hello world!")

# after
from firebase_functions import https_fn

@https_fn.on_request()
def webhook_new(req: https_fn.Request) -> https_fn.Response:
    return https_fn.Response("Hello world!")

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

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

# Wait until deployment is done; now both functions are running

# Delete webhook
firebase functions:delete webhook

किसी फ़ंक्शन का क्षेत्र या इलाका बदलना

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

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

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

// before
exports.firestoreTrigger = onDocumentCreated(
  "my-collection/{docId}",
  (event) => {},
);

// after
exports.firestoreTriggerAsia = onDocumentCreated(
  {
    document: "my-collection/{docId}",
    region: "asia-northeast1",
  },
  (event) => {},
);

# Before
@firestore_fn.on_document_created("my-collection/{docId}")
def firestore_trigger(event):
    pass

# After
@firestore_fn.on_document_created("my-collection/{docId}",
                                  region="asia-northeast1")
def firestore_trigger_asia(event):
    pass

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

firebase deploy --only functions:firestoreTriggerAsia

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

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

firebase functions:delete firestoreTrigger

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

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

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

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

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

उदाहरण के लिए, अगर आपके पास कोई ऐसा फ़ंक्शन था जो किसी ऑब्जेक्ट को मिटाए जाने पर ट्रिगर होता था, लेकिन आपने ऑब्जेक्ट का वर्शन चालू करने के बजाय संग्रहित इवेंट की सदस्यता ली थी, तो सबसे पहले फ़ंक्शन का नाम बदलें और उसमें बदलाव करके, नया ट्रिगर टाइप जोड़ें.

// before
const {onObjectDeleted} = require("firebase-functions/v2/storage");

exports.objectDeleted = onObjectDeleted((event) => {
    // ...
});

// after
const {onObjectArchived} = require("firebase-functions/v2/storage");

exports.objectArchived = onObjectArchived((event) => {
    // ...
});

# before
from firebase_functions import storage_fn

@storage_fn.on_object_deleted()
def object_deleted(event):
  # ...

# after 
from firebase_functions import storage_fn

@storage_fn.on_object_archived()
def object_archived(event):
  # ...

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

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

# Wait until deployment is done; now both objectDeleted and objectArchived are running

# Delete objectDeleted
firebase functions:delete objectDeleted

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

'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 20 (झलक)
• Node.js 18
• Node.js 16
• Node.js 14

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

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

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

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

Python वर्शन सेट करें

Cloud Functions के 12.0.0 और उसके बाद के वर्शन के लिए Firebase SDK टूल, Python रनटाइम को चुनने की अनुमति देता है. रनटाइम वर्शन को firebase.json में, इस तरह सेट करें:

  {
    "functions": {
      "runtime": "python310" // or python311
    }
  }

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

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

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

हर इंस्टेंस पर concurrency सेटिंग (new 2nd gen में) के साथ इन सेटिंग का इस्तेमाल करके, अपने फ़ंक्शन के लिए स्केलिंग के व्यवहार को कंट्रोल और ट्यून किया जा सकता है. आपके ऐप्लिकेशन और फ़ंक्शन के स्वरूप से यह तय होगा कि कौनसी सेटिंग सबसे ज़्यादा असरदार हैं और जिनसे सबसे अच्छी परफ़ॉर्मेंस होगी.

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

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

एक साथ किए जाने वाले अनुरोधों को अनुमति दें

Firebase के लिए Cloud Functions (1st gen) में, हर इंस्टेंस एक बार में एक अनुरोध को हैंडल कर सकता है. इसलिए, स्केलिंग व्यवहार को कम से कम और ज़्यादा से ज़्यादा इंस्टेंस सेटिंग के हिसाब से ही सेट किया गया. 'Firebase के लिए Cloud Functions' (2nd gen) में इंस्टेंस की संख्या को कंट्रोल करने के अलावा, आप यह भी कंट्रोल कर सकते हैं कि हर इंस्टेंस एक ही समय पर कितने अनुरोध कर सकता है. इसके लिए, concurrency विकल्प का इस्तेमाल करें. समवर्ती के लिए डिफ़ॉल्ट मान 80 है, लेकिन आप इसे 1 से 1000 के बीच के किसी भी पूर्णांक पर सेट कर सकते हैं.

ज़्यादा सहमति वाली सेटिंग वाले फ़ंक्शन, ट्रैफ़िक में बढ़ोतरी को बिना किसी रुकावट के प्रोसेस कर सकते हैं. ऐसा इसलिए, क्योंकि हर इंस्टेंस के लिए हेडरूम की संभावना होती है. अगर किसी इंस्टेंस को एक साथ 50 अनुरोधों को हैंडल करने के लिए कॉन्फ़िगर किया गया है, लेकिन फ़िलहाल वह सिर्फ़ 25 पर ही कार्रवाई कर रहा है, तो यह 25 और अनुरोधों की बढ़ोतरी को हैंडल कर सकता है. इसके लिए, कोल्ड स्टार्ट के लिए नए इंस्टेंस की ज़रूरत नहीं होती. वहीं दूसरी ओर, सिर्फ़ 1 की एक साथ कई सेटिंग लागू करने पर, अनुरोधों की संख्या में बढ़ोतरी से 25 कोल्ड स्टार्ट हो सकते हैं.

इस आसान तरीके से, एक साथ कई काम करने के संभावित नतीजों के बारे में पता चलता है. असल में, एक साथ काम करने की प्रोसेस से परफ़ॉर्मेंस को ऑप्टिमाइज़ करने और कोल्ड स्टार्ट को कम करने के लिए, व्यवहार को स्केल करना ज़्यादा मुश्किल होता है. 'Firebase के लिए Cloud Functions' 2nd gen में एक साथ काम करने की सुविधा, Cloud Run की मदद से काम करती है और कंटेनर इंस्टेंस ऑटोस्केलिंग के Cloud Run के नियमों का पालन करती है.

'Firebase के लिए Cloud Functions (2nd gen)' में बेहतर एक साथ काम करने वाली सेटिंग के साथ प्रयोग करते समय, इन बातों का ध्यान रखें:

• बेहतर परफ़ॉर्म करने के लिए, एक साथ कई काम करने वाली सेटिंग में ज़्यादा सीपीयू और रैम की ज़रूरत हो सकती है. उदाहरण के लिए, इमेज या वीडियो पर बहुत ज़्यादा प्रोसेसिंग करने वाला फ़ंक्शन, हो सकता है कि एक साथ 1,000 अनुरोधों को हैंडल करने के लिए संसाधनों की कमी हो. भले ही, इसकी सीपीयू और रैम सेटिंग ज़्यादा से ज़्यादा हों.
• 'Firebase के लिए Cloud Functions' (2nd gen) Cloud Run की मदद से काम करता है. इसलिए, एक साथ काम करने की सुविधा को ऑप्टिमाइज़ करने के लिए, Google Cloud के दिशा-निर्देशों को भी देखा जा सकता है.
• प्रोडक्शन में एक साथ काम करने वाली दूसरी मुद्रा पर स्विच करने से पहले, टेस्ट एनवायरमेंट में एक साथ कई क्रम में चलने की जांच करना न भूलें.

कम से कम इंस्टेंस को गर्म रखें

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

const { onCall } = require("firebase-functions/v2/https");

exports.getAutocompleteResponse = onCall(
  {
    // Keep 5 instances warm for this latency-critical function
    minInstances: 5,
  },
  (event) => {
    // Autocomplete user’s search term
  }
);

@https_fn.on_call(min_instances=5)
def get_autocomplete_response(event: https_fn.CallableRequest) -> https_fn.Response:

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

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

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

  Node.js के लिए

  const functions = require('firebase-functions');
  const { defineInt, defineString } = require('firebase-functions/params');
  
  // Define some parameters
  const minInstancesConfig = defineInt('HELLO_WORLD_MININSTANCES');
  const welcomeMessage = defineString('WELCOME_MESSAGE');
  
  // To use configured parameters inside the config for a function, provide them 
  // directly. To use them at runtime, call .value() on them.
  export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
    (req, res) => {
      res.send(`${welcomeMessage.value()}! I am a function.`);
    }
  );
  

  Python

  MIN_INSTANCES = params.IntParam("HELLO_WORLD_MININSTANCES")
  WELCOME_MESSAGE = params.StringParam("WELCOME_MESSAGE")
  
  @https_fn.on_request(min_instances=MIN_INSTANCES.value())
  def get_autocomplete_response(event: https_fn.Request) -> https_fn.Response:
      return https_fn.Response(f"{WELCOME_MESSAGE.value()} I'm a function.")
  

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

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

const { onMessagePublished } = require("firebase-functions/v2/pubsub");

exports.mirrorevents = onMessagePublished(
  { topic: "topic-name", maxInstances: 100 },
  (event) => {
    // Connect to legacy database
  }
);

@pubsub_fn.on_message_published(topic="topic-name", max_instances=100)
def mirrorevents(event: pubsub_fn.CloudEvent):
#  Connect to legacy database

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

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

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

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

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

exports.convertLargeFile = onObjectFinalized({
  timeoutSeconds: 300,
  memory: "1GiB",
}, (event) => {
  // Do some complicated things that take a lot of memory and time
});

@storage_fn.on_object_finalized(timeout_sec=300, memory=options.MemoryOption.GB_1)
def convert_large_file(event: storage_fn.CloudEvent):
# Do some complicated things that take a lot of memory and time.

टाइम आउट सेकंड का अधिकतम मान 540 या 9 मिनट है.

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

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

सीपीयू की डिफ़ॉल्ट सेटिंग बदलें

2 जीबी तक की मेमोरी, 'Firebase के लिए Cloud Functions' (2nd gen) में हर फ़ंक्शन के लिए डिफ़ॉल्ट रूप से एक सीपीयू पर सेट हो जाती है. इसके बाद, 4 और 8 जीबी के लिए दो सीपीयू हो जाते हैं. ध्यान दें कि यह 1st gen के डिफ़ॉल्ट व्यवहार से काफ़ी अलग है. इसकी वजह से, लो-मेमोरी फ़ंक्शन के लिए कुछ ज़्यादा खर्च करना पड़ सकता है, जैसा कि नीचे दी गई टेबल में बताया गया है:

अगर आपको 2nd gen के फ़ंक्शन के लिए, 1st gen की डिफ़ॉल्ट वैल्यू सेट करनी है, तो ग्लोबल विकल्प के तौर पर 1st gen की डिफ़ॉल्ट सेटिंग सेट करें:

// Turn off Firebase defaults
setGlobalOptions({ cpu: 'gcf_gen1' });

# Use 1st gen behavior
set_global_options(cpu="gcf_gen1")

सीपीयू-इंटेसिव फ़ंक्शन के लिए 2nd gen, अतिरिक्त सीपीयू को कॉन्फ़िगर करने की सुविधा देता है. हर फ़ंक्शन के हिसाब से सीपीयू को बूस्ट किया जा सकता है, जैसा कि यहां दिखाया गया है:

// Boost CPU in a function:
export const analyzeImage = onObjectFinalized({ cpu: 2 }, (event) => {
  // computer vision goes here
});

# Boost CPU in a function:
@storage_fn.on_object_finalized(cpu=2)
def analyze_image(event: storage_fn.CloudEvent):
# computer vision goes here