सलाह और सुझाव

इस दस्तावेज़ में वेबसाइट डिज़ाइन करने, उसे लागू करने, उसकी जांच करने, और Cloud Functions को डिप्लॉय कर रहा है.

सही जानकारी

इस सेक्शन में, कैंपेन डिज़ाइन करने और उसे लागू करने के सबसे सही तरीकों के बारे में बताया गया है Cloud Functions.

स्थायी फलन लिखना

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

बैकग्राउंड में होने वाली गतिविधियां शुरू न करें

बैकग्राउंड में होने वाली गतिविधि, वह होता है जो आपके फ़ंक्शन के बंद होने के बाद होता है. फ़ंक्शन के वापस आने या सिग्नल के अलग-अलग होने पर, फ़ंक्शन शुरू करने की प्रोसेस खत्म हो जाती है पूरा करना, जैसे कि Node.js इवेंट-ड्रिवन में callback आर्ग्युमेंट को कॉल करके फ़ंक्शन. सही तरीके से खत्म होने के बाद चलने वाला कोई भी कोड, सीपीयू को ऐक्सेस नहीं कर सकता कोई प्रोग्रेस नहीं होगी.

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

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

कुछ समय के लिए सेव की गई फ़ाइलें हमेशा मिटाएं

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

किसी फ़ंक्शन में इस्तेमाल की गई मेमोरी को देखने के लिए, फ़ंक्शन की सूची में शामिल Google Cloud Console और मेमोरी के इस्तेमाल वाला प्लॉट चुनना.

अस्थायी डायरेक्ट्री के बाहर लिखने की कोशिश न करें. साथ ही, प्लैटफ़ॉर्म/ओएस-इंडिपेंडेंट तरीकों का इस्तेमाल करके फ़ाइल पाथ बनाया जा सकता है.

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

फ़ंक्शन फ़्रेमवर्क

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

ऐसा करने के लिए, सही लॉक फ़ाइल में अपना पसंदीदा वर्शन शामिल करें (उदाहरण के लिए, Node.js के लिए package-lock.json या Python के लिए requirements.txt).

टूल

इस सेक्शन में, टूल को इस्तेमाल करने के तरीकों के बारे में दिशा-निर्देश दिए गए हैं. इन दिशा-निर्देशों की मदद से, Cloud Functions के साथ इंटरैक्ट करें.

लोकल डेवलपमेंट

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

ईमेल भेजने के लिए Sendgrid का इस्तेमाल करना

Cloud Functions पोर्ट 25 पर आउटबाउंड कनेक्शन की अनुमति नहीं देता है, इसलिए आप ऐसा नहीं कर सकते किसी SMTP सर्वर से असुरक्षित कनेक्शन बनाएं. ईमेल भेजने का सुझाया गया तरीका ईमेल SendGrid का इस्तेमाल करना है. आपको अन्य विकल्प दिखेंगे में ईमेल भेजने के लिए किसी इंस्टेंस से ईमेल भेजना Google Compute Engine का ट्यूटोरियल.

परफ़ॉर्मेंस

इस सेक्शन में, परफ़ॉर्मेंस को ऑप्टिमाइज़ करने के सबसे सही तरीकों के बारे में बताया गया है.

डिपेंडेंसी का समझदारी से इस्तेमाल करना

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

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

आने वाले समय के न्योते में ऑब्जेक्ट का फिर से इस्तेमाल करने के लिए, ग्लोबल वैरिएबल का इस्तेमाल करें

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

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

console.log('Global scope');
const perInstance = heavyComputation();
const functions = require('firebase-functions');

exports.function = functions.https.onRequest((req, res) => {
  console.log('Function invocation');
  const perFunction = lightweightComputation();

  res.send(`Per instance: ${perInstance}, per function: ${perFunction}`);
});

import time

from firebase_functions import https_fn

# Placeholder
def heavy_computation():
  return time.time()

# Placeholder
def light_computation():
  return time.time()

# Global (instance-wide) scope
# This computation runs at instance cold-start
instance_var = heavy_computation()

@https_fn.on_request()
def scope_demo(request):

  # Per-function scope
  # This computation runs every time this function is called
  function_var = light_computation()
  return https_fn.Response(f"Instance: {instance_var}; function: {function_var}")
  

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

ग्लोबल वैरिएबल के लिए लेज़ी इनिशलाइज़ेशन करना

ग्लोबल स्कोप में वैरिएबल शुरू करने पर, शुरू करने वाला कोड हमेशा कोल्ड स्टार्ट इनवोकेशन के ज़रिए एक्ज़ीक्यूट किया जाना चाहिए. इससे आपके फ़ंक्शन की लेटेंसी बढ़ जाती है. कुछ मामलों में, इसकी वजह से कॉल की जा रही सेवाओं के लिए, थोड़ी-थोड़ी देर में टाइम आउट हो जाता है अगर उन्हें try/catch ब्लॉक में सही तरीके से हैंडल नहीं किया जाता है. अगर आपने कुछ ऑब्जेक्ट सभी कोड पाथ में इस्तेमाल नहीं किए जाते हैं. इसलिए, उन्हें लेज़ी तरीके से शुरू करें मांग पर:

const functions = require('firebase-functions');
let myCostlyVariable;

exports.function = functions.https.onRequest((req, res) => {
  doUsualWork();
  if(unlikelyCondition()){
      myCostlyVariable = myCostlyVariable || buildCostlyVariable();
  }
  res.status(200).send('OK');
});

from firebase_functions import https_fn

# Always initialized (at cold-start)
non_lazy_global = file_wide_computation()

# Declared at cold-start, but only initialized if/when the function executes
lazy_global = None

@https_fn.on_request()
def lazy_globals(request):

  global lazy_global, non_lazy_global

  # This value is initialized only if (and when) the function is called
  if not lazy_global:
      lazy_global = function_specific_computation()

  return https_fn.Response(f"Lazy: {lazy_global}, non-lazy: {non_lazy_global}.")
  

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

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

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

अन्य संसाधन

"Google Cloud की परफ़ॉर्मेंस" में जाकर, परफ़ॉर्मेंस को ऑप्टिमाइज़ करने के बारे में ज़्यादा जानें एटलस" वीडियो Cloud Functions कोल्ड बूट टाइम.