การเพิ่มประสิทธิภาพเครือข่าย

ความเรียบง่ายของ Cloud Functions ทำให้คุณสามารถพัฒนาโค้ดและเรียกใช้ใน แบบ Serverless ในระดับปานกลาง ต้นทุนของฟังก์ชันที่ทำงานอยู่ต่ำ และการเพิ่มประสิทธิภาพโค้ด อาจดูเหมือนไม่ใช่สิ่งสำคัญ เป็นการติดตั้งใช้งาน ขยายตัวมากขึ้น แต่การเพิ่มประสิทธิภาพโค้ดก็มีความสำคัญเพิ่มขึ้นเรื่อยๆ

เอกสารนี้อธิบายวิธีเพิ่มประสิทธิภาพเครือข่ายให้กับฟังก์ชันของคุณ บางส่วนของ ประโยชน์ของการเพิ่มประสิทธิภาพเครือข่ายมีดังนี้

• ลดเวลา CPU ที่ใช้ในการสร้างการเชื่อมต่อขาออกใหม่ในแต่ละช่วง การเรียกฟังก์ชัน
• ลดโอกาสการเชื่อมต่อหรือ DNS กำลังจะหมด โควต้า

รักษาการเชื่อมต่ออย่างต่อเนื่อง

ส่วนนี้จะแสดงตัวอย่างวิธีรักษาการเชื่อมต่อแบบถาวรใน ไม่เช่นนั้นอาจทำให้โควต้าการเชื่อมต่อหมดอย่างรวดเร็ว

สถานการณ์ต่อไปนี้กล่าวถึงในส่วนนี้

• HTTP/S
• Google APIs

คำขอ HTTP/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!")
    

ฟังก์ชัน HTTP นี้ใช้พูลการเชื่อมต่อเพื่อสร้างคำขอ HTTP รับออบเจ็กต์คำขอ (flask.Request) และส่งคืน ข้อความตอบกลับ หรือชุดค่าใดๆ ที่เปลี่ยนเป็น Response ออบเจ็กต์กำลังใช้ make_response

การเข้าถึง Google APIs

ตัวอย่างด้านล่างใช้ Cloud Pub/Sub แต่ วิธีการนี้ยังใช้กับไลบรารีของไคลเอ็นต์อื่นๆ ได้ด้วย เช่น Cloud Natural Language หรือ Cloud Spanner โปรดทราบว่าประสิทธิภาพ อาจขึ้นอยู่กับการใช้งานปัจจุบันของลูกค้าบางราย ห้องสมุด

การสร้างออบเจ็กต์ไคลเอ็นต์ Pub/Sub จะส่งผลให้เกิดการเชื่อมต่อ 1 รายการและคำขอ DNS 2 รายการ ต่อการเรียกใช้ เพื่อหลีกเลี่ยงการเชื่อมต่อและการค้นหา DNS ที่ไม่จำเป็น ให้สร้าง ออบเจ็กต์ไคลเอ็นต์ 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")
    

ฟังก์ชัน HTTP นี้ใช้อินสแตนซ์ไลบรารีของไคลเอ็นต์ที่แคชไว้เพื่อ ลดจำนวนการเชื่อมต่อที่ต้องใช้ต่อการเรียกใช้ฟังก์ชัน รับออบเจ็กต์คำขอ (flask.Request) และส่งคืน ข้อความตอบกลับ หรือชุดค่าใดๆ ที่เปลี่ยนเป็น Response ออบเจ็กต์กำลังใช้ make_response

ตัวแปรสภาพแวดล้อม GCP_PROJECT ได้รับการตั้งค่าโดยอัตโนมัติใน Python 3.7 รันไทม์ ในรันไทม์ต่อๆ มา อย่าลืมระบุในรันไทม์ การทำให้ฟังก์ชันใช้งานได้ โปรดดู กำหนดค่าตัวแปรสภาพแวดล้อม

รีเซ็ตการเชื่อมต่อขาออกแล้ว

สตรีมการเชื่อมต่อจากฟังก์ชันไปยังทั้ง VPC และอินเทอร์เน็ตได้ ถูกยุติและถูกแทนที่เป็นครั้งคราวเมื่อมีการรีสตาร์ทโครงสร้างพื้นฐานที่สำคัญ หรืออัปเดตแล้ว หากแอปพลิเคชันของคุณใช้การเชื่อมต่อที่มีระยะเวลานาน เราจะ ขอแนะนำให้คุณกำหนดค่าแอปพลิเคชันเพื่อสร้างการเชื่อมต่ออีกครั้งกับ หลีกเลี่ยงการนำการเชื่อมต่อที่ใช้งานไม่ได้กลับมาใช้ซ้ำ

การทดสอบโหลดฟังก์ชันของคุณ

หากต้องการวัดจำนวนการเชื่อมต่อที่ฟังก์ชันทำได้โดยเฉลี่ย เพียงติดตั้งใช้งาน เป็นฟังก์ชัน HTTP และใช้เฟรมเวิร์กการทดสอบประสิทธิภาพเพื่อเรียกใช้ที่ QPS บางอย่าง ตัวเลือกหนึ่งที่เป็นไปได้คือ Artillery สามารถเรียกใช้ด้วยบรรทัดเดียว:

$ artillery quick -d 300 -r 30 URL

คำสั่งนี้จะดึง URL ที่ระบุที่ 30 QPS เป็นเวลา 300 วินาที

หลังจากดำเนินการทดสอบแล้ว ให้ตรวจสอบการใช้งานโควต้าการเชื่อมต่อของคุณใน หน้าโควต้า API Cloud Functions ใน Cloud Console หากการใช้งานอยู่ที่ประมาณ 30 (หรือหลายเท่า) อย่างสม่ำเสมอ กำลังสร้างการเชื่อมต่อ 1 รายการ (หรือหลายรายการ) ในทุกการเรียกใช้ หลังจากที่คุณ ในการเพิ่มประสิทธิภาพโค้ด คุณควรเห็นการเชื่อมต่อ 2-3 รายการ (10-30 รายการ) ในช่วงต้นของการทดสอบเท่านั้น

คุณสามารถเปรียบเทียบต้นทุนของ CPU ก่อนและหลังการเพิ่มประสิทธิภาพบน CPU ได้ แผนภูมิโควต้าบนหน้าเดียวกัน