了解 2023 年 Google I/O 大会上介绍的 Firebase 亮点。了解详情

इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

Node.js के लिए

// 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");
});

Python

# 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

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

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

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

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

Node.js के लिए

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

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

अपडेट किए गए कोड में, क्षेत्र के साथ-साथ सही इवेंट फ़िल्टर (इस मामले में document) भी बताया जाना चाहिए. ज़्यादा जानकारी के लिए, Cloud Functions की जगह की जानकारी देखें.

Python

# 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 में चल रहा है और asia-northeast1 में firestoreTriggerAsia चल रहा है.

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

firebase functions:delete firestoreTrigger

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

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

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

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

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

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

Node.js के लिए

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

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

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

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

Python

# 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 आपके कोड में सेट किए गए रनटाइम विकल्पों को नीचे दी गई प्राथमिकता के साथ आपके फ़ंक्शन के डिप्लॉय किए गए मौजूदा वर्शन की सेटिंग के साथ मर्ज कर देता है:

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

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

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 वर्शन को सेट करने के लिए:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Node.js के लिए

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
  }
);

Python

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

ध्यान दें: इस्तेमाल न किए जाने की दर पर, लगातार होने वाले मामलों में बिलिंग की लागत, तय की गई कम से कम संख्या पर लागू होती है. 1st gen के लिए डिफ़ॉल्ट रूप से 256MiB मेमोरी असाइन करने की सुविधा के साथ, उसकी कीमत करीब 3 डॉलर/महीना होगी (gcf_gen_1 सीपीयू असाइन होने के साथ और एक साथ काम करने की सुविधा बंद होने पर) या 1 सीपीयू और कंcurrency की सुविधा के साथ, करीब 8 डॉलर/महीना. Firebase सीएलआई, रिज़र्व किए गए कम से कम इंस्टेंस वाले फ़ंक्शन के लिए डिप्लॉयमेंट के समय लागत का अनुमान देता है. लागत का हिसाब लगाने के लिए, Cloud Run की कीमत देखें.

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

अगर '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 इंस्टेंस की सीमा सेट करता है:

Node.js के लिए

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

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

Python

@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 सेकंड के बाद समय खत्म हो जाता है:

Node.js के लिए

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

Python

@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 में, मेमोरी का बंटवारा और टाइम आउट सेट करने के लिए:

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

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

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

तय की गई रैम	वर्शन 1 का डिफ़ॉल्ट सीपीयू (आंशिक)	वर्शन 2 का डिफ़ॉल्ट सीपीयू	हर मिलीसेकंड पर कीमत में बढ़ोतरी
128 एमबी	12/1	1	10.5 गुना
256 एमबी	6/1	1	5.3 गुना
512 एमबी	1/3	1	2.7 गुना
1 जीबी	12/7	1	1.6 गुना
2 जीबी	1	1	1x
4 जीबी	2	2	1x
8 जीबी	2	2	1x
16 जीबी	लागू नहीं	4	लागू नहीं

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

Node.js के लिए

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

Python

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

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

Node.js के लिए

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

Python

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