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

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

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

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

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

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

समय के साथ, जैसे-जैसे 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 कंसोल के ज़रिए) से सेट किए गए विकल्प बदलें या gcloud CLI).

अगर आपके डेवलपमेंट वर्कफ़्लो में, इसके ज़रिए रनटाइम के विकल्पों को मैन्युअल तौर पर सेट करना शामिल है, तो 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 22 (झलक)
• Node.js 20
• Node.js 18

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

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

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

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

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

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

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

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

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

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

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 से 1,000 के बीच के किसी भी पूर्णांक पर सेट करें.

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

इस आसान स्थिति में, बेहतर परफ़ॉर्मेंस के नतीजों के बारे में जानकारी मिलती है एक साथ कई वैल्यू इस्तेमाल की जा सकती हैं. असल में, परफ़ॉर्मेंस को ऑप्टिमाइज़ करने और कम करने के लिए व्यवहार का आकलन करना एक साथ कई काम करना ज़्यादा मुश्किल होता है. कॉन करंसी में Firebase 2nd gen के लिए Cloud Functions, 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 फ़ंक्शन 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 Console में, मेमोरी का बंटवारा और टाइम आउट सेट करने के लिए:

1. Google Cloud Console में, नीचे दिए गए विकल्पों से 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