ความเรียบง่ายของ Cloud Functions ช่วยให้คุณพัฒนาโค้ดและเรียกใช้โค้ดในสภาพแวดล้อมแบบเซิร์ฟเวอร์เลสได้อย่างรวดเร็ว เมื่ออยู่ในระดับปานกลาง ค่าใช้จ่ายในการเรียกใช้ฟังก์ชันจะต่ำ และการเพิ่มประสิทธิภาพโค้ดอาจไม่ใช่สิ่งสําคัญมากนัก อย่างไรก็ตาม เมื่อการทําให้ใช้งานได้มีขนาดใหญ่ขึ้น การเพิ่มประสิทธิภาพโค้ดก็จะยิ่งสําคัญมากขึ้น
เอกสารนี้อธิบายวิธีเพิ่มประสิทธิภาพการทํางานของเครือข่าย ประโยชน์บางส่วนของการเพิ่มประสิทธิภาพเครือข่ายมีดังนี้
- ลดเวลา 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 API
ตัวอย่างด้านล่างใช้ Cloud Pub/Sub แต่แนวทางนี้ใช้ได้กับไลบรารีไคลเอ็นต์อื่นๆ ด้วย เช่น Cloud Natural Language หรือ Cloud Spanner โปรดทราบว่าการปรับปรุงประสิทธิภาพอาจขึ้นอยู่กับการใช้งานไลบรารีไคลเอ็นต์ที่เฉพาะเจาะจงในปัจจุบัน
การสร้างออบเจ็กต์ไคลเอ็นต์ Pub/Sub จะส่งผลให้มีการเชื่อมต่อ 1 ครั้งและการค้นหา DNS 2 ครั้งต่อการเรียกใช้ 1 ครั้ง หากต้องการหลีกเลี่ยงการเชื่อมต่อและการค้นหา 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 จะหมดเวลาหลังจากไม่มีการใช้งานเป็นเวลา 10 นาที สําหรับคําขอจากฟังก์ชันของคุณไปยังอินเทอร์เน็ต ระบบจะหมดเวลาหลังจากไม่มีการใช้งานเป็นเวลา 20 นาที
การเชื่อมต่อขาออกถูกรีเซ็ต
สตรีมการเชื่อมต่อจากฟังก์ชันของคุณไปยังทั้งเครือข่าย VPC และอินเทอร์เน็ตอาจสิ้นสุดและแทนที่ในบางครั้งเมื่อมีการรีสตาร์ทหรืออัปเดตโครงสร้างพื้นฐานที่เกี่ยวข้อง หากแอปพลิเคชันของคุณใช้การเชื่อมต่อที่มีอายุการใช้งานยาวนานซ้ำ เราขอแนะนำให้คุณกำหนดค่าแอปพลิเคชันให้สร้างการเชื่อมต่ออีกครั้งเพื่อหลีกเลี่ยงการใช้การเชื่อมต่อที่ตายแล้วซ้ำ
การทดสอบการโหลดฟังก์ชัน
หากต้องการวัดจํานวนการเชื่อมต่อที่ฟังก์ชันทํางานโดยเฉลี่ย ให้ติดตั้งใช้งานเป็นฟังก์ชัน HTTP และใช้เฟรมเวิร์กการทดสอบประสิทธิภาพเพื่อเรียกใช้ที่ QPS หนึ่งๆ ตัวเลือกหนึ่งที่เป็นไปได้คือ Artillery ซึ่งคุณเรียกใช้ได้ด้วยบรรทัดเดียว ดังนี้
$ artillery quick -d 300 -r 30 URL
คำสั่งนี้จะดึงข้อมูล URL ที่ระบุที่ 30 QPS เป็นเวลา 300 วินาที
หลังจากทำการทดสอบแล้ว ให้ตรวจสอบการใช้งานโควต้าการเชื่อมต่อในCloud Functions หน้าโควต้า API ใน Cloud Console หากการใช้งานอยู่ที่ประมาณ 30 (หรือหลายเท่า) อย่างต่อเนื่อง แสดงว่าคุณกำลังสร้างการเชื่อมต่อ 1 (หรือหลาย) ครั้งในการเรียกใช้แต่ละครั้ง หลังจากเพิ่มประสิทธิภาพโค้ดแล้ว คุณควรเห็นการเชื่อมต่อ 2-3 ครั้ง (10-30 ครั้ง) เกิดขึ้นเฉพาะในช่วงเริ่มต้นการทดสอบเท่านั้น
นอกจากนี้ คุณยังเปรียบเทียบต้นทุน CPU ก่อนและหลังการเพิ่มประสิทธิภาพในผังโควต้า CPU ในหน้าเดียวกันได้ด้วย