नेटवर्किंग को ऑप्टिमाइज़ किया जा रहा है

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

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

• हर फ़ंक्शन कॉल पर, नए आउटबाउंड कनेक्शन बनाने में लगने वाला सीपीयू का समय कम करें.
• कनेक्शन या डीएनएस के कोटे खत्म होने की संभावना कम हो जाती है.

परसिस्टेंट कनेक्शन बनाए रखना

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

इस सेक्शन में इन स्थितियों के बारे में बताया गया है:

• एचटीटीपी/एस
• Google API

एचटीटीपी/एस अनुरोध

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

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

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!")
    

Google API ऐक्सेस करना

नीचे दिए गए उदाहरण में Cloud Pub/Sub का इस्तेमाल किया गया है. हालांकि, यह तरीका अन्य क्लाइंट लाइब्रेरी के लिए भी काम करता है. उदाहरण के लिए, Cloud Natural Language या Cloud Spanner. ध्यान दें कि परफ़ॉर्मेंस में सुधार, कुछ क्लाइंट लाइब्रेरी के मौजूदा तरीके पर निर्भर कर सकता है.

Pub/Sub क्लाइंट ऑब्जेक्ट बनाने पर, हर बार एक कनेक्शन और दो डीएनएस क्वेरी जनरेट होती हैं. ज़रूरत से ज़्यादा कनेक्शन और डीएनएस क्वेरी से बचने के लिए, Pub/Sub क्लाइंट ऑब्जेक्ट को ग्लोबल स्कोप में बनाएं. इसके लिए, यहां दिया गया सैंपल देखें:

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

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")
    

आउटबाउंड कनेक्शन

आउटबाउंड अनुरोधों का समय खत्म होना

आपके फ़ंक्शन से वीपीसी नेटवर्क पर किए गए अनुरोधों के लिए, 10 मिनट तक कोई गतिविधि न होने पर टाइम आउट हो जाता है. आपके फ़ंक्शन से इंटरनेट पर किए जाने वाले अनुरोधों के लिए, 20 मिनट तक कोई गतिविधि न होने पर टाइमआउट हो जाता है.

आउटबाउंड कनेक्शन रीसेट किए गए

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

फ़ंक्शन की लोड-टेस्टिंग करना

यह मेज़र करने के लिए कि आपका फ़ंक्शन औसतन कितने कनेक्शन बनाता है, इसे एचटीटीपी फ़ंक्शन के तौर पर डिप्लॉय करें. साथ ही, परफ़ॉर्मेंस की जांच करने वाले फ़्रेमवर्क का इस्तेमाल करके, इसे कुछ क्यूपीएस पर चालू करें. Artillery एक विकल्प है. इसे एक लाइन में इस तरह से लागू किया जा सकता है:

$ artillery quick -d 300 -r 30 URL

यह कमांड, दिए गए यूआरएल को 300 सेकंड के लिए 30 क्यूपीएस पर फ़ेच करती है.

जांच करने के बाद, Cloud Console में Cloud Functions एपीआई कोटे वाले पेज पर जाकर, कनेक्शन के कोटे के इस्तेमाल की जानकारी देखें. अगर इस्तेमाल लगातार 30 (या इसके कई गुना) के आस-पास है, तो इसका मतलब है कि हर बार अनुरोध करने पर एक (या कई) कनेक्शन बनाए जा रहे हैं. कोड को ऑप्टिमाइज़ करने के बाद, आपको टेस्ट की शुरुआत में सिर्फ़ कुछ (10 से 30) कनेक्शन दिखने चाहिए.

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