Cloud Functions आसान है. इससे आपको तुरंत कोड डेवलप करने और उसे बिना सर्वर वाला एनवायरमेंट. तो सामान्य स्तर पर, रनिंग फ़ंक्शन की लागत कम होती है. और आपके कोड को ऑप्टिमाइज़ करना ज़्यादा प्राथमिकता वाला काम न हो. आपके डिप्लॉयमेंट के तौर पर बड़े पैमाने पर इस्तेमाल किया जा सकता है. हालांकि, अपने कोड को ऑप्टिमाइज़ करना ज़्यादा ज़रूरी हो जाता है.
इस दस्तावेज़ में आपके फ़ंक्शन के लिए नेटवर्किंग को ऑप्टिमाइज़ करने का तरीका बताया गया है. कुछ नेटवर्किंग को ऑप्टिमाइज़ करने के फ़ायदे नीचे दिए गए हैं:
- हर डिवाइस पर नए आउटबाउंड कनेक्शन बनाने में लगने वाला सीपीयू समय कम करें फ़ंक्शन कॉल.
- कनेक्शन या डीएनएस खत्म होने की संभावना को कम करें कोटा में शामिल हैं.
दर्शकों के साथ लगातार जुड़े रहना
इस सेक्शन में, उदाहरण के तौर पर बताया गया है कि Google Analytics 4 प्रॉपर्टी में, फ़ंक्शन का इस्तेमाल करना होगा. ऐसा न करने पर कनेक्शन कोटा जल्द ही खत्म हो सकता है.
इस सेक्शन में, इन स्थितियों की जानकारी दी गई है:
- एचटीटीपी/एस
- Google API
एचटीटीपी/S अनुरोध
नीचे दिया गया ऑप्टिमाइज़ किया गया कोड स्निपेट एक स्थायी कनेक्शन को बनाए रखने का तरीका दिखाता है हर फ़ंक्शन को शुरू करने पर एक नया कनेक्शन बनाने के बजाय:
Node.js
const http = require('http'); const functions = require('firebase-functions'); // Setting the `keepAlive` option to `true` keeps // connections open between function invocations const agent = new http.Agent({keepAlive: true}); exports.function = functions.https.onRequest((request, response) => { req = http.request({ host: '', port: 80, path: ' ', method: 'GET', agent: agent, // Holds the connection open after the first invocation }, res => { let rawData = ''; res.setEncoding('utf8'); res.on('data', chunk => { rawData += chunk; }); res.on('end', () => { response.status(200).send(`Data: ${rawData}`); }); }); req.on('error', e => { response.status(500).send(`Error: ${e.message}`); }); req.end(); });
Python
from firebase_functions import https_fn import requests # Create a global HTTP session (which provides connection pooling) session = requests.Session() @https_fn.on_request() def connection_pooling(request): # The URL to send the request to url = "http://example.com" # Process the request response = session.get(url) response.raise_for_status() return https_fn.Response("Success!")
यह एचटीटीपी फ़ंक्शन, एचटीटीपी अनुरोध करने के लिए कनेक्शन पूल का इस्तेमाल करता है.
यह अनुरोध ऑब्जेक्ट (flask.Request
) लेता है और वापस लौटता है
जवाब टेक्स्ट या वैल्यू का कोई भी सेट जिसे
Response
ऑब्जेक्ट, इसका इस्तेमाल कर रहा है
make_response
.
Google API को ऐक्सेस करना
नीचे दिए गए उदाहरण में Cloud Pub/Sub का इस्तेमाल किया गया है, लेकिन यह तरीका अन्य क्लाइंट लाइब्रेरी के लिए भी काम करता है—उदाहरण के लिए, Cloud Natural Language या क्लाउड स्पैनर. ध्यान दें कि परफ़ॉर्मेंस किसी क्लाइंट की परफ़ॉर्मेंस बेहतर करने के लिए, लाइब्रेरी.
Pub/Sub क्लाइंट ऑब्जेक्ट बनाने से, एक कनेक्शन और दो डीएनएस क्वेरी बनती हैं शुरू करने के लिए कहा जा सकता है. ग़ैर-ज़रूरी कनेक्शन और डीएनएस क्वेरी से बचने के लिए, दुनिया भर के स्कोप में Pub/Sub क्लाइंट ऑब्जेक्ट की इमेज, जैसा कि नीचे दिए गए सैंपल में दिखाया गया है:
node.js
const PubSub = require('@google-cloud/pubsub'); const functions = require('firebase-functions'); const pubsub = PubSub(); exports.function = functions.https.onRequest((req, res) => { const topic = pubsub.topic(''); topic.publish('Test message', err => { if (err) { res.status(500).send(`Error publishing the message: ${err}`); } else { res.status(200).send('1 message published'); } }); });
Python
import os from firebase_functions import https_fn from google.cloud import pubsub_v1 # from firebase_functions import https_fn # Create a global Pub/Sub client to avoid unneeded network activity pubsub = pubsub_v1.PublisherClient() @https_fn.on_request() def gcp_api_call(request): project = os.getenv("GCP_PROJECT") request_json = request.get_json() topic_name = request_json["topic"] topic_path = pubsub.topic_path(project, topic_name) # Process the request data = b"Test message" pubsub.publish(topic_path, data=data) return https_fn.Response("1 message published")
यह एचटीटीपी फ़ंक्शन, कैश मेमोरी में सेव की गई क्लाइंट लाइब्रेरी के इंस्टेंस का इस्तेमाल करता है, ताकि
हर फ़ंक्शन को शुरू करने के लिए ज़रूरी कनेक्शन की संख्या कम करना.
यह अनुरोध ऑब्जेक्ट (flask.Request
) लेता है और वापस लौटता है
जवाब टेक्स्ट या वैल्यू का कोई भी सेट जिसे
Response
ऑब्जेक्ट, इसका इस्तेमाल कर रहा है
make_response
.
GCP_PROJECT
एनवायरमेंट वैरिएबल, Python में अपने-आप सेट हो जाता है
3.7 रनटाइम. बाद के रनटाइम में, इसे चालू करना न भूलें
फ़ंक्शन डिप्लॉयमेंट. यहां जाएं:
एनवायरमेंट वैरिएबल कॉन्फ़िगर करना.
आपके फ़ंक्शन की लोड टेस्टिंग
यह मापने के लिए कि आपका फ़ंक्शन औसतन कितने कनेक्शन परफ़ॉर्म करता है, बस इसे एचटीटीपी फ़ंक्शन के तौर पर इस्तेमाल किया जा सकता है और परफ़ॉर्मेंस-टेस्टिंग फ़्रेमवर्क का इस्तेमाल करके तय क्यूपीएस. ऐसा करने का एक विकल्प आर्टिलरी है. इसे एक लाइन से शुरू किया जा सकता है:
$ artillery quick -d 300 -r 30 URL
यह निर्देश दिए गए यूआरएल को 30 क्यूपीएस पर 300 सेकंड के लिए फ़ेच करता है.
परीक्षण करने के बाद, Cloud Functions API का कोटा पेज Cloud Console में जाकर. अगर लगातार 30 या इससे ज़्यादा बार इस्तेमाल किया जाता है, तो हर शुरू करने पर एक या कई कनेक्शन जोड़ रहे होते हैं. आपके बाद तो आपको कुछ (10-30) कनेक्शन दिखेंगे यह सिर्फ़ टेस्ट की शुरुआत में दिखता है.
सीपीयू पर ऑप्टिमाइज़ेशन से पहले और बाद में, सीपीयू की कीमत की तुलना भी की जा सकती है कोटा प्लॉट होगा.