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

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

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

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

firebase deploy --only functions

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

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

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

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

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

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

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

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

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

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 है, क्योंकि आपके फ़ंक्शन का नया वर्शन और पुराना वर्शन, दोनों एक ही समय पर चालू करें.

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

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

// 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

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

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

firebase functions:delete firestoreTrigger

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

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

समय के साथ Cloud Functions for Firebase डिप्लॉयमेंट को डेवलप करने पर, आपको कई वजहों से फ़ंक्शन के ट्रिगर टाइप को बदलना पड़ सकता है. उदाहरण के लिए, आप शायद एक तरह के Firebase Realtime Database से बदलना चाहें या किसी अन्य टाइप के लिए 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

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

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

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

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

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

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

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

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

• Node.js 22 (झलक)
• Node.js 20
• Node.js 18

Node.js के 14 और 16 वर्शन का इस्तेमाल बंद कर दिया गया है. इन्हें 2025 की शुरुआत में बंद कर दिया जाएगा. इन वर्शन का इस्तेमाल करके डिप्लॉयमेंट करने की सुविधा बंद कर दी गई है.

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

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

  "engines": {"node": "20"}

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

  {
    "functions": {
      "runtime": "nodejs18" // or nodejs20
    }
  }

सीएलआई, firebase.json में सेट की गई वैल्यू को किसी भी वैल्यू या जिसकी सीमा आपने package.json में अलग से सेट की है.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• एक साथ कई टास्क करने की ज़्यादा सेटिंग के लिए, बेहतर परफ़ॉर्मेंस पाने के लिए ज़्यादा सीपीयू और रैम की ज़रूरत पड़ सकती है. हालांकि, यह सीमा तय नहीं की जा सकती. एक ऐसा फ़ंक्शन जो उदाहरण के लिए, हो सकता है कि इमेज या वीडियो को प्रोसेस करने के लिए संसाधनों की कमी हो एक साथ 1,000 अनुरोध स्वीकार किए जाते हैं. ऐसा तब भी होता है, जब इसकी सीपीयू और रैम की सेटिंग बड़ी की गई हों.
• Cloud Functions for Firebase (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:

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

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

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

  Node.js

  const functions = require('firebase-functions/v1');
  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 कंसोल या फ़ंक्शन सोर्स कोड में (सिर्फ़ Firebase).

फ़ंक्शन के सोर्स कोड में, मेमोरी का ऐलोकेशन और टाइम आउट सेट करने के लिए, इसका इस्तेमाल करें मेमोरी और टाइम आउट सेकंड के लिए ग्लोबल विकल्प का इस्तेमाल करें. उदाहरण के लिए, यह Cloud Storage फ़ंक्शन 1 जीबी मेमोरी और समय का इस्तेमाल करता है 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 कंसोल में, मेमोरी का बंटवारा और टाइम आउट सेट करने के लिए:

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

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

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

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

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

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

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

// 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