คุณทำให้ใช้งานได้ ลบ และแก้ไขฟังก์ชันโดยใช้คำสั่ง Firebase CLI หรือโดยการตั้งค่าตัวเลือกรันไทม์ในซอร์สโค้ดของฟังก์ชัน
ทำให้ฟังก์ชันใช้งานได้
หากต้องการทำให้ฟังก์ชันใช้งานได้ ให้เรียกใช้คำสั่ง Firebase CLI ดังนี้
firebase deploy --only functions
โดยค่าเริ่มต้น Firebase CLI จะทำให้ฟังก์ชันทั้งหมดภายในใช้งานได้
แหล่งที่มาของคุณไปพร้อมๆ กันด้วย หากโปรเจ็กต์มีฟังก์ชันมากกว่า 5 รายการ
เราขอแนะนำให้ใช้ Flag --only
ที่มีชื่อฟังก์ชันที่เฉพาะเจาะจง
เพื่อติดตั้งใช้งานเฉพาะฟังก์ชัน
ที่คุณได้แก้ไข การทำให้ฟังก์ชันบางอย่างใช้งานได้
วิธีนี้จะทำให้กระบวนการติดตั้งใช้งานเร็วขึ้น และช่วยให้คุณหลีกเลี่ยง
โควต้าการทำให้ใช้งานได้ เช่น
firebase deploy --only functions:addMessage,functions:makeUppercase
เมื่อทำให้ฟังก์ชันใช้งานได้จำนวนมาก ฟังก์ชันของคุณอาจเกินขีดจำกัด มาตรฐานและรับข้อความแสดงข้อผิดพลาด HTTP 429 หรือ 500 วิธีแก้โจทย์ ทำให้ฟังก์ชันใช้งานได้เป็นกลุ่มไม่เกิน 10 รายการ
ดูข้อมูลอ้างอิง Firebase CLI สำหรับรายการที่มีอยู่ทั้งหมด คำสั่ง
โดยค่าเริ่มต้น Firebase CLI จะดูในโฟลเดอร์ functions/
สำหรับพารามิเตอร์
ซอร์สโค้ด คุณสามารถจัดระเบียบฟังก์ชันได้หากต้องการ
ในฐานของโค้ดหรือไฟล์หลายๆ ชุด
ลบฟังก์ชัน
คุณลบฟังก์ชันที่ใช้งานก่อนหน้านี้ได้ด้วยวิธีต่อไปนี้
- อย่างชัดแจ้งใน Firebase CLI ด้วย
functions:delete
- อย่างชัดเจนในคอนโซล Google Cloud
- โดยปริยาย โดยนำฟังก์ชันออกจากซอร์สก่อนทำให้ใช้งานได้
การดำเนินการลบทั้งหมด ให้คุณยืนยันก่อนที่จะนำฟังก์ชันออกจากเวอร์ชันที่ใช้งานจริง
การลบฟังก์ชันที่ชัดแจ้งใน Firebase CLI รองรับอาร์กิวเมนต์หลายตัว ตลอดจนฟังก์ชัน กลุ่ม และช่วยให้คุณระบุฟังก์ชันที่จะทำงานในภูมิภาคหนึ่งๆ ได้ นอกจากนี้ คุณยังลบล้างข้อความแจ้งให้ยืนยันได้ด้วย
# Delete all functions that match the specified name in all regions. firebase functions:delete myFunction
# Delete a specified function running in a specific region. firebase functions:delete myFunction --region us-east-1
# Delete more than one function firebase functions:delete myFunction myOtherFunction
# Delete a specified functions group. firebase functions:delete groupA
# Bypass the confirmation prompt. firebase functions:delete myFunction --force
เมื่อใช้การลบฟังก์ชันโดยนัย firebase deploy
จะแยกวิเคราะห์แหล่งที่มาและ
จะลบฟังก์ชันใดๆ ที่ถูกนำออกจากไฟล์ในเวอร์ชันที่ใช้งานจริง
แก้ไขชื่อ ภูมิภาค หรือทริกเกอร์ของฟังก์ชัน
หากคุณเปลี่ยนชื่อหรือเปลี่ยนภูมิภาคหรือทริกเกอร์สำหรับฟังก์ชันที่ จัดการการรับส่งข้อมูลเวอร์ชันที่ใช้งานจริง โปรดทำตามขั้นตอนในส่วนนี้เพื่อไม่ให้สูญเสียข้อมูล เหตุการณ์ระหว่างการแก้ไข ก่อนที่จะทำตามขั้นตอนเหล่านี้ โปรดตรวจสอบให้แน่ใจว่า คือ idempotent เนื่องจาก ทั้งเวอร์ชันใหม่และเวอร์ชันเก่าของฟังก์ชันจะทำงานที่ ในช่วงเวลาที่เปลี่ยน
เปลี่ยนชื่อฟังก์ชัน
หากต้องการเปลี่ยนชื่อฟังก์ชัน ให้สร้างฟังก์ชันที่มีการเปลี่ยนชื่อใหม่ในแหล่งที่มา จากนั้นเรียกใช้คำสั่งการติดตั้งใช้งาน 2 อย่างแยกกัน คำสั่งแรกจะทำให้ฟังก์ชัน และคำสั่งที่ 2 จะนำฟังก์ชันที่ทำให้ใช้งานได้ก่อนหน้านี้ออก เวอร์ชัน ตัวอย่างเช่น หากคุณมีเว็บฮุคที่ทริกเกอร์ HTTP และต้องการ เปลี่ยนชื่อ ให้แก้ไขโค้ดดังนี้:
Node.js
// before
const {onRequest} = require('firebase-functions/v2/https');
exports.webhook = onRequest((req, res) => {
res.send("Hello");
});
// after
const {onRequest} = require('firebase-functions/v2/https');
exports.webhookNew = onRequest((req, res) => {
res.send("Hello");
});
Python
# before
from firebase_functions import https_fn
@https_fn.on_request()
def webhook(req: https_fn.Request) -> https_fn.Response:
return https_fn.Response("Hello world!")
# after
from firebase_functions import https_fn
@https_fn.on_request()
def webhook_new(req: https_fn.Request) -> https_fn.Response:
return https_fn.Response("Hello world!")
จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อทำให้ฟังก์ชันใหม่ใช้งานได้:
# Deploy new function firebase deploy --only functions:webhookNew # Wait until deployment is done; now both functions are running # Delete webhook firebase functions:delete webhook
เปลี่ยนภูมิภาคหรือภูมิภาคของฟังก์ชัน
หากคุณเปลี่ยนภูมิภาคที่ระบุสำหรับ ที่จัดการกับการรับส่งข้อมูลที่ใช้งานจริง คุณจะป้องกันการสูญเสียเหตุการณ์ได้โดย โปรดปฏิบัติตามขั้นตอนเหล่านี้ตามลำดับ
- เปลี่ยนชื่อฟังก์ชัน แล้วเปลี่ยนภูมิภาคหรือภูมิภาคตามต้องการ
- ทำให้ฟังก์ชันที่เปลี่ยนชื่อใช้งานได้ ซึ่งจะส่งผลให้การเรียกใช้โค้ดเดียวกันชั่วคราวในภูมิภาคทั้ง 2 ชุด
- ลบฟังก์ชันก่อนหน้า
เช่น หากคุณมีฟังก์ชันที่ทริกเกอร์ใน Cloud Firestore
ซึ่งขณะนี้อยู่ใน
ภูมิภาคของฟังก์ชันเริ่มต้นของ us-central1
และคุณต้องการย้ายข้อมูลไป
asia-northeast1
คุณต้องแก้ไขซอร์สโค้ดก่อนเพื่อเปลี่ยนชื่อ
อีกครั้ง และแก้ไขภูมิภาค
Node.js
// before
exports.firestoreTrigger = onDocumentCreated(
"my-collection/{docId}",
(event) => {},
);
// after
exports.firestoreTriggerAsia = onDocumentCreated(
{
document: "my-collection/{docId}",
region: "asia-northeast1",
},
(event) => {},
);
โค้ดที่อัปเดตควรระบุตัวกรองเหตุการณ์ที่ถูกต้อง (ในกรณีนี้
document
) พร้อมกับภูมิภาค โปรดดู
ตำแหน่งของ Cloud Functions สำหรับข้อมูลเพิ่มเติม
Python
# Before
@firestore_fn.on_document_created("my-collection/{docId}")
def firestore_trigger(event):
pass
# After
@firestore_fn.on_document_created("my-collection/{docId}",
region="asia-northeast1")
def firestore_trigger_asia(event):
pass
จากนั้นทำให้ใช้งานได้โดยการเรียกใช้:
firebase deploy --only functions:firestoreTriggerAsia
ตอนนี้มีฟังก์ชันที่เหมือนกันทุกประการซึ่งทำงานอยู่ 2 รายการ นั่นคือ firestoreTrigger
กำลังทำงาน
us-central1
และ firestoreTriggerAsia
กำลังทำงานใน asia-northeast1
จากนั้นลบ firestoreTrigger
firebase functions:delete firestoreTrigger
ตอนนี้มีเพียงฟังก์ชันเดียว คือ firestoreTriggerAsia
ซึ่งกำลังทำงาน
asia-northeast1
.
เปลี่ยนประเภททริกเกอร์ของฟังก์ชัน
ขณะที่คุณพัฒนา Cloud Functions สำหรับการทำให้ Firebase ใช้งานได้เมื่อเวลาผ่านไป คุณอาจ จำเป็นต้องเปลี่ยนประเภททริกเกอร์ของฟังก์ชันด้วยเหตุผลหลายประการ ตัวอย่างเช่น คุณอาจต้องการเปลี่ยนจากฐานข้อมูลเรียลไทม์ของ Firebase ประเภทใดประเภทหนึ่ง หรือ เหตุการณ์ Cloud Firestore เป็นประเภทอื่น
คุณไม่สามารถเปลี่ยนประเภทเหตุการณ์ของฟังก์ชันโดยการเปลี่ยนแปลงฟังก์ชัน
ซอร์สโค้ดและการเรียกใช้ firebase deploy
เพื่อหลีกเลี่ยงข้อผิดพลาด
เปลี่ยนประเภททริกเกอร์ของฟังก์ชันตามขั้นตอนนี้
- แก้ไขซอร์สโค้ดให้รวมฟังก์ชันใหม่ที่มีประเภททริกเกอร์ที่ต้องการ
- ทำให้ฟังก์ชันใช้งานได้ ซึ่งจะส่งผลให้มีการเรียกใช้ทั้งฟังก์ชันเก่าและใหม่ชั่วคราว
- ลบฟังก์ชันเก่าออกจากเวอร์ชันที่ใช้งานจริงอย่างชัดเจนโดยใช้ Firebase CLI
ตัวอย่างเช่น หากคุณมีฟังก์ชันที่ทริกเกอร์เมื่อออบเจ็กต์ ลบแล้ว แต่คุณได้เปิดใช้ การกำหนดเวอร์ชันออบเจ็กต์ และต้องการสมัครรับข้อมูลเหตุการณ์ที่เก็บถาวรแทน ให้เปลี่ยนชื่อ แล้วแก้ไขให้มีประเภททริกเกอร์ใหม่
Node.js
// before
const {onObjectDeleted} = require("firebase-functions/v2/storage");
exports.objectDeleted = onObjectDeleted((event) => {
// ...
});
// after
const {onObjectArchived} = require("firebase-functions/v2/storage");
exports.objectArchived = onObjectArchived((event) => {
// ...
});
Python
# before
from firebase_functions import storage_fn
@storage_fn.on_object_deleted()
def object_deleted(event):
# ...
# after
from firebase_functions import storage_fn
@storage_fn.on_object_archived()
def object_archived(event):
# ...
จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างฟังก์ชันใหม่ก่อนที่จะลบฟังก์ชันเก่า
# Create new function objectArchived firebase deploy --only functions:objectArchived # Wait until deployment is done; now both objectDeleted and objectArchived are running # Delete objectDeleted firebase functions:delete objectDeleted
ตั้งค่าตัวเลือกรันไทม์
ฟังก์ชันระบบคลาวด์สำหรับ Firebase ช่วยให้คุณเลือกตัวเลือกรันไทม์ได้ เช่น Node.js เวอร์ชันรันไทม์และระยะหมดเวลาต่อฟังก์ชัน การจัดสรรหน่วยความจำ และค่าต่ำสุด/สูงสุด อินสแตนซ์ของฟังก์ชัน
แนวทางปฏิบัติแนะนำคือให้ตั้งค่าตัวเลือกเหล่านี้ (ยกเว้นเวอร์ชัน Node.js)
ออบเจ็กต์การกำหนดค่าภายในโค้ดฟังก์ชัน ช่วงเวลานี้
RuntimeOptions
เป็นแหล่งข้อมูลที่ถูกต้องสำหรับตัวเลือกรันไทม์ของฟังก์ชัน และจะ
ลบล้างตัวเลือกที่ตั้งค่าไว้ด้วยวิธีอื่นๆ (เช่น ผ่าน Google Cloud Console)
หรือ gcloud CLI)
หากเวิร์กโฟลว์การพัฒนามีการตั้งค่าตัวเลือกรันไทม์ด้วยตนเองผ่าน
คอนโซล Google Cloud หรือ gcloud CLI และคุณไม่ต้องการให้ค่าเหล่านี้
ในการทำให้ใช้งานได้แต่ละครั้ง ให้ตั้งค่าตัวเลือก preserveExternalChanges
เป็น true
เมื่อใช้ตัวเลือกนี้เป็น true
แล้ว Firebase จะรวมตัวเลือกรันไทม์ที่ตั้งค่าไว้ใน
ที่มีการตั้งค่าฟังก์ชันเวอร์ชันที่ใช้งานได้ในปัจจุบันด้วย
ลำดับความสำคัญต่อไปนี้
- มีการตั้งค่าตัวเลือกในโค้ดฟังก์ชัน: ลบล้างการเปลี่ยนแปลงภายนอก
- ตัวเลือกได้รับการตั้งค่าเป็น
RESET_VALUE
ในโค้ดฟังก์ชัน: ลบล้างการเปลี่ยนแปลงภายนอกด้วยค่าเริ่มต้น - ไม่ได้ตั้งค่าตัวเลือกในโค้ดฟังก์ชัน แต่มีการตั้งค่าไว้ในฟังก์ชันที่ทำให้ใช้งานได้ในปัจจุบัน: ใช้ตัวเลือกที่ระบุไว้ในฟังก์ชันที่ทำให้ใช้งานได้
ไม่แนะนำให้ใช้ตัวเลือก preserveExternalChanges: true
สำหรับสถานการณ์ส่วนใหญ่เนื่องจาก
จะไม่เป็นแหล่งข้อมูลที่ถูกต้องสมบูรณ์สำหรับตัวเลือกรันไทม์สำหรับ
หากคุณใช้ ให้ตรวจสอบคอนโซล Google Cloud หรือใช้ gcloud
CLI เพื่อดูการกำหนดค่าแบบเต็มของฟังก์ชัน
ตั้งค่าเวอร์ชัน Node.js
Firebase SDK สำหรับ Cloud Functions อนุญาตให้เลือกรันไทม์ของ Node.js ได้ คุณเลือกเรียกใช้ฟังก์ชันทั้งหมดในโปรเจ็กต์บนรันไทม์เท่านั้นได้ ที่สอดคล้องกับหนึ่งในเวอร์ชัน Node.js ที่สนับสนุนเหล่านี้:
- Node.js 22 (ตัวอย่าง)
- Node.js 20
- Node.js 18
Node.js เวอร์ชัน 14 และ 16 เลิกใช้งานแล้วและจะหยุดให้บริการในช่วงต้นปี 2025 การทำให้ใช้งานได้ ที่มีเวอร์ชันที่เลิกใช้งานแล้วเหล่านี้ถูกปิดใช้
วิธีตั้งค่าเวอร์ชัน Node.js
คุณตั้งค่าเวอร์ชันได้ในช่อง engines
ใน package.json
ที่สร้างขึ้นในไดเรกทอรี functions/
ระหว่างการเริ่มต้น
เช่น หากต้องการใช้เพียง
เวอร์ชัน 18 ให้แก้ไขบรรทัดนี้ใน package.json
:
"engines": {"node": "20"}
หากคุณใช้ตัวจัดการแพ็กเกจ Yarn หรือมีข้อกำหนดเฉพาะอื่นๆ สำหรับ
ในช่อง engines
คุณสามารถตั้งค่ารันไทม์ของ Firebase SDK สำหรับ Cloud Functions ใน
firebase.json
แทน:
{
"functions": {
"runtime": "nodejs18" // or nodejs20
}
}
CLI ใช้ค่าที่ตั้งไว้ใน firebase.json
เพื่อตั้งเป็นค่าใดก็ได้ หรือ
ช่วงที่คุณตั้งค่าแยกกันใน package.json
อัปเกรดรันไทม์ของ Node.js
วิธีอัปเกรดรันไทม์ของ Node.js
- ตรวจสอบว่าโปรเจ็กต์อยู่ใน แพ็กเกจราคา Blaze
- ตรวจสอบว่าคุณใช้ Firebase CLI เวอร์ชัน 11.18.0 ขึ้นไป
- เปลี่ยนค่า
engines
ในไฟล์package.json
ที่สร้างใน ไดเรกทอรีfunctions/
ของคุณระหว่างการเริ่มต้น ตัวอย่างเช่น ถ้าคุณกำลังอัปเกรดจากเวอร์ชัน 18 เป็นเวอร์ชัน 20 รายการ ควรมีลักษณะเช่นนี้:"engines": {"node": "20"}
- (ไม่บังคับ) ทดสอบการเปลี่ยนแปลงโดยใช้ ชุดโปรแกรมจำลองภายในของ Firebase
- ทำให้ฟังก์ชันทั้งหมดใช้งานได้อีกครั้ง
ตั้งค่าเวอร์ชัน Python
Firebase SDK สำหรับ Cloud Functions เวอร์ชัน 12.0.0 ขึ้นไปช่วยให้เลือก Python ได้
รันไทม์ ตั้งค่าเวอร์ชันรันไทม์ใน firebase.json
ดังที่แสดงด้านล่างนี้
{
"functions": {
"runtime": "python310" // or python311
}
}
ควบคุมลักษณะการทำงานของการปรับขนาด
โดยค่าเริ่มต้น Cloud Functions for Firebase จะปรับขนาดจำนวนอินสแตนซ์ที่ทำงานอยู่ ขึ้นอยู่กับจำนวนคำขอที่เข้ามา ซึ่งอาจลดขนาดลงเป็น 0 ในกรณีที่ปริมาณการเข้าชมลดลง อย่างไรก็ตาม หากแอปต้องมีการลดราคา เวลาในการตอบสนองและคุณต้องการจำกัดจำนวน Cold Start คุณสามารถเปลี่ยนได้ ตามค่าเริ่มต้น โดยระบุจำนวนอินสแตนซ์คอนเทนเนอร์ขั้นต่ำ ทำให้อบอุ่นและพร้อมที่จะทำตามคำขอ
ในทำนองเดียวกัน คุณสามารถตั้งค่าจำนวนสูงสุดเพื่อจำกัดการปรับขนาดของอินสแตนซ์ใน ตอบสนองต่อคำขอที่เข้ามาใหม่ ใช้การตั้งค่านี้เพื่อควบคุมค่าใช้จ่าย หรือเพื่อจำกัดจำนวนการเชื่อมต่อกับบริการสนับสนุน เช่น ฐานข้อมูล
การใช้การตั้งค่าเหล่านี้ร่วมกับการตั้งค่าการเกิดขึ้นพร้อมกันต่ออินสแตนซ์ (ใหม่ ในเวอร์ชันที่ 2) คุณจะควบคุมและปรับแต่งลักษณะการปรับขนาดสำหรับฟังก์ชันได้ ลักษณะแอปพลิเคชันและฟังก์ชันจะ พิจารณา ว่าการตั้งค่าแบบใด คุ้มราคา และจะทำให้ได้ผลลัพธ์ที่ดีที่สุด
สำหรับบางแอปที่มีการเข้าชมต่ำ ตัวเลือก CPU ที่ต่ำกว่าโดยไม่มีการเกิดขึ้นพร้อมกันหลายรายการคือ เหมาะสมที่สุด สำหรับคนอื่นๆ ที่ Cold Start เป็นปัญหาร้ายแรง ให้ตั้งค่าขั้นสูง การเกิดขึ้นพร้อมกันและอินสแตนซ์ขั้นต่ำหมายความว่าระบบจะเก็บชุดอินสแตนซ์ไว้เสมอ อบอุ่นใจในการจัดการกับการเข้าชมที่เพิ่มขึ้นมากอย่างฉับพลัน
สำหรับแอปขนาดเล็กที่ได้รับการเข้าชมน้อยมาก ให้ตั้งค่าค่าสูงสุดในระดับต่ำ อินสแตนซ์ที่มีการเกิดขึ้นพร้อมกันสูง หมายความว่าแอปสามารถจัดการการรับส่งข้อมูลจำนวนมากได้ โดยไม่ทำให้เกิดค่าใช้จ่ายที่มากเกินไป แต่โปรดทราบว่าเมื่อกำหนด อินสแตนซ์ตั้งค่าไว้ต่ำเกินไป คำขออาจถูกปฏิเสธเมื่อใช้จ่ายถึงเพดานที่กำหนด
อนุญาตคำขอหลายรายการพร้อมกัน
ใน Cloud Functions for Firebase (รุ่นที่ 1) แต่ละอินสแตนซ์จะจัดการคำขอได้ครั้งละ 1 รายการ ดังนั้น
มีการกำหนดลักษณะการทำงานของการปรับขนาดด้วยการตั้งค่าอินสแตนซ์ขั้นต่ำและสูงสุดเท่านั้น
นอกจากการควบคุมจำนวนอินสแตนซ์แล้ว คุณยังใช้ Cloud Functions for Firebase (รุ่นที่ 2) ได้
สามารถควบคุมจำนวนคำขอที่แต่ละอินสแตนซ์แสดงพร้อมกันได้ด้วย
ตัวเลือก concurrency
ค่าเริ่มต้นของการเกิดขึ้นพร้อมกันคือ 80 แต่คุณสามารถ
ตั้งค่าเป็นจำนวนเต็มใดก็ได้ระหว่าง 1 ถึง 1000
ฟังก์ชันที่มีการตั้งค่าการเกิดขึ้นพร้อมกันสูงกว่าจะรองรับการรับส่งข้อมูลจำนวนมากได้ Cold Start เนื่องจากแต่ละอินสแตนซ์ อาจมีช่องว่าง หากอินสแตนซ์คือ กำหนดค่าให้สามารถรองรับคำขอหลายรายการพร้อมกันได้สูงสุด 50 รายการ แต่ปัจจุบันจัดการอยู่เท่านั้น 25 สิ่งนี้รองรับคำขอเพิ่มเติมที่เพิ่มขึ้นอย่างฉับพลัน 25 รายการ เป็น Cold Start ในทางตรงกันข้าม หากมีการตั้งค่าเกิดขึ้นพร้อมกันแค่ 1 รายการ คำขอที่พุ่งสูงขึ้นอาจทำให้ Cold Start ถึง 25 ครั้ง
สถานการณ์ง่ายๆ นี้แสดงถึงประสิทธิภาพที่เป็นไปได้ของ การเกิดขึ้นพร้อมกัน ในความเป็นจริง การปรับขนาดพฤติกรรมเพื่อเพิ่มประสิทธิภาพและลด Cold Start และการเกิดขึ้นพร้อมกันนั้นซับซ้อนกว่า เกิดขึ้นพร้อมกันใน Cloud Functions for Firebase รุ่นที่ 2 ขับเคลื่อนโดย Cloud Run และรุ่นต่อๆ ไป กฎของ Cloud Run การปรับขนาดอินสแตนซ์คอนเทนเนอร์อัตโนมัติ
เมื่อทดสอบการตั้งค่าการเกิดขึ้นพร้อมกันที่สูงขึ้นใน Cloud Functions for Firebase (รุ่นที่ 2) โปรดคำนึงถึงสิ่งต่อไปนี้
- การตั้งค่าการเกิดขึ้นพร้อมกันที่สูงขึ้นอาจต้องใช้ CPU และ RAM สูงขึ้นเพื่อประสิทธิภาพสูงสุด ประสิทธิภาพจนกว่าจะถึงขีดจำกัดที่ใช้ได้จริง ฟังก์ชันที่ทำงานหนัก เช่น การประมวลผลรูปภาพหรือวิดีโออาจขาดทรัพยากรในการจัดการ คำขอพร้อมกัน 1, 000 รายการ แม้ว่าการตั้งค่า CPU และ RAM ของคำขอจะเพิ่มสูงสุดก็ตาม
- เนื่องจาก Cloud Functions for Firebase (รุ่นที่ 2) ขับเคลื่อนโดย Cloud Run คุณจึงทำสิ่งต่อไปนี้ได้ โปรดอ่านคำแนะนำของ Google Cloud เกี่ยวกับ เพิ่มประสิทธิภาพการเกิดขึ้นพร้อมกัน
- อย่าลืมทดสอบการเกิดขึ้นพร้อมกันหลายรายการในสภาพแวดล้อมการทดสอบอย่างละเอียดก่อนที่จะ และเปลี่ยนไปใช้การใช้หลายระบบพร้อมกันในการใช้งานจริง
รักษาจำนวนอินสแตนซ์ขั้นต่ำ
คุณกำหนดจำนวนอินสแตนซ์ขั้นต่ำสำหรับฟังก์ชันในซอร์สโค้ดได้ ตัวอย่างเช่น ฟังก์ชันนี้ตั้งค่าอินสแตนซ์อย่างน้อย 5 รายการ ทำให้ร่างกายอบอุ่น:
Node.js
const { onCall } = require("firebase-functions/v2/https");
exports.getAutocompleteResponse = onCall(
{
// Keep 5 instances warm for this latency-critical function
minInstances: 5,
},
(event) => {
// Autocomplete user’s search term
}
);
Python
@https_fn.on_call(min_instances=5)
def get_autocomplete_response(event: https_fn.CallableRequest) -> https_fn.Response:
สิ่งที่ควรพิจารณาเมื่อตั้งค่าอินสแตนซ์ขั้นต่ำมีดังนี้
- หาก Cloud Functions for Firebase ปรับขนาดแอปเหนือการตั้งค่า คุณจะพบ Cold Start สำหรับแต่ละอินสแตนซ์ที่สูงกว่าเกณฑ์ดังกล่าว
- Cold Start จะส่งผลกระทบรุนแรงที่สุดกับแอปที่มีการรับส่งข้อมูลในปริมาณสูง หาก มีการเข้าชมพุ่งสูง และคุณกำหนดค่าไว้สูงพอที่ Cold Start จะลดลงเมื่อการเข้าชมแต่ละครั้งเพิ่มขึ้น คุณจะเห็น เวลาในการตอบสนองที่ลดลง สำหรับแอปที่มีการเข้าชมตลอดเวลา แอป Cold Start มักไม่น่าจะเป็นไปได้ ส่งผลต่อประสิทธิภาพได้อย่างมาก
การตั้งค่าอินสแตนซ์ขั้นต่ำอาจเหมาะสมสำหรับสภาพแวดล้อมการใช้งานจริง แต่ ที่ควรหลีกเลี่ยงในสภาพแวดล้อมการทดสอบ หากต้องการปรับสัดส่วนเป็น 0 ใน แต่ยังคงลด Cold Start ในโปรเจ็กต์ที่ใช้งานจริง สามารถตั้งค่าอินสแตนซ์ขั้นต่ำในการกำหนดค่าที่ทำเป็นพารามิเตอร์ได้ดังนี้
Node.js
const functions = require('firebase-functions'); const { defineInt, defineString } = require('firebase-functions/params'); // Define some parameters const minInstancesConfig = defineInt('HELLO_WORLD_MININSTANCES'); const welcomeMessage = defineString('WELCOME_MESSAGE'); // To use configured parameters inside the config for a function, provide them // directly. To use them at runtime, call .value() on them. export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest( (req, res) => { res.send(`${welcomeMessage.value()}! I am a function.`); } );
Python
MIN_INSTANCES = params.IntParam("HELLO_WORLD_MININSTANCES") WELCOME_MESSAGE = params.StringParam("WELCOME_MESSAGE") @https_fn.on_request(min_instances=MIN_INSTANCES.value()) def get_autocomplete_response(event: https_fn.Request) -> https_fn.Response: return https_fn.Response(f"{WELCOME_MESSAGE.value()} I'm a function.")
จำกัดจำนวนอินสแตนซ์สูงสุดสำหรับฟังก์ชัน
คุณสามารถกำหนดค่าของอินสแตนซ์สูงสุดในซอร์สโค้ดของฟังก์ชัน ตัวอย่างเช่น ฟังก์ชันนี้ตั้งค่าขีดจำกัด 100 อินสแตนซ์เพื่อที่จะไม่ ทำให้ฐานข้อมูลเดิมสมมติได้มากเกินไป:
Node.js
const { onMessagePublished } = require("firebase-functions/v2/pubsub");
exports.mirrorevents = onMessagePublished(
{ topic: "topic-name", maxInstances: 100 },
(event) => {
// Connect to legacy database
}
);
Python
@pubsub_fn.on_message_published(topic="topic-name", max_instances=100)
def mirrorevents(event: pubsub_fn.CloudEvent):
# Connect to legacy database
หากฟังก์ชัน HTTP ได้รับการปรับขนาดเป็นขีดจำกัดอินสแตนซ์สูงสุด ระบบจะส่งคำขอใหม่
รอ 30 วินาที และถูกปฏิเสธโดยมีโค้ดตอบกลับเป็น
429 Too Many Requests
หากไม่มีอินสแตนซ์ที่พร้อมให้บริการภายในเวลาดังกล่าว
ดูข้อมูลเพิ่มเติมเกี่ยวกับแนวทางปฏิบัติแนะนำสำหรับการใช้การตั้งค่าอินสแตนซ์สูงสุดได้ที่ ออก แนวทางปฏิบัติแนะนำสำหรับการตั้งค่าอินสแตนซ์สูงสุด
ตั้งค่าการหมดเวลาและการจัดสรรหน่วยความจำ
ในบางกรณี ฟังก์ชันอาจมีข้อกำหนดพิเศษเป็นระยะเวลานาน หรือการจัดสรรหน่วยความจำในปริมาณมาก คุณสามารถตั้งค่าเหล่านี้ได้ใน คอนโซล Google Cloud หรือในซอร์สโค้ดของฟังก์ชัน (Firebase เท่านั้น)
หากต้องการตั้งค่าการจัดสรรหน่วยความจำและระยะหมดเวลาในซอร์สโค้ดของฟังก์ชัน ให้ใช้ ตัวเลือกส่วนกลางสำหรับหน่วยความจำและระยะหมดเวลาเป็นวินาที เพื่อปรับแต่งเครื่องเสมือนที่เรียกใช้ฟังก์ชันของคุณ ตัวอย่างเช่น ฟังก์ชัน Cloud Storage นี้ใช้หน่วยความจำและเวลา 1 GB ออกหลังจาก 300 วินาที
Node.js
exports.convertLargeFile = onObjectFinalized({
timeoutSeconds: 300,
memory: "1GiB",
}, (event) => {
// Do some complicated things that take a lot of memory and time
});
Python
@storage_fn.on_object_finalized(timeout_sec=300, memory=options.MemoryOption.GB_1)
def convert_large_file(event: storage_fn.CloudEvent):
# Do some complicated things that take a lot of memory and time.
ค่าสูงสุดสำหรับวินาทีการหมดเวลาคือ 540
หรือ 9 นาที
วิธีตั้งค่าการจัดสรรหน่วยความจำและระยะหมดเวลาในคอนโซล Google Cloud
- ในคอนโซล Google Cloud ให้เลือกฟังก์ชันระบบคลาวด์สำหรับ Firebase จาก เมนูด้านซ้าย
- เลือกฟังก์ชันโดยคลิกชื่อฟังก์ชันในรายการฟังก์ชัน
- คลิกไอคอนแก้ไขในเมนูด้านบน
- เลือกการจัดสรรหน่วยความจำจากเมนูแบบเลื่อนลงที่ติดป้ายกำกับ หน่วยความจำที่จัดสรรแล้ว
- คลิกเพิ่มเติมเพื่อแสดงตัวเลือกขั้นสูงและป้อน วินาทีในกล่องข้อความ ระยะหมดเวลา
- คลิกบันทึกเพื่ออัปเดตฟังก์ชัน
ลบล้างค่าเริ่มต้นของ CPU
จัดสรรหน่วยความจำสูงสุด 2 GB แล้ว แต่ละฟังก์ชันใน Cloud Functions for Firebase (รุ่นที่ 2) กำหนดค่าเริ่มต้นเป็น CPU 1 ตัว จากนั้นจะเพิ่ม CPU เป็น 2 ตัวสำหรับ 4 และ 8 GB โปรดทราบว่า ซึ่งแตกต่างจากลักษณะการทำงานเริ่มต้นของรุ่นที่ 1 อย่างมากในด้านที่อาจ จะทําให้มีค่าใช้จ่ายสูงขึ้นเล็กน้อยสําหรับฟังก์ชันที่มีหน่วยความจําต่ำ ดังที่แสดงไว้ใน ตารางต่อไปนี้
จัดสรร RAM แล้ว | CPU เริ่มต้นของเวอร์ชัน 1 (เศษส่วน) | CPU เริ่มต้นของเวอร์ชัน 2 | การขึ้นราคาต่อมิลลิวินาที |
---|---|---|---|
128MB | 12/1 | 1 | 10.5 เท่า |
256MB | 1/6 | 1 | 5.3 เท่า |
512MB | 1/3 | 1 | 2.7 เท่า |
1GB | 12/7 | 1 | 1.6 เท่า |
2GB | 1 | 1 | 1x |
4 GB | 2 | 2 | 1x |
8GB | 2 | 2 | 1x |
16 GB | ไม่มี | 4 | ไม่มี |
หากต้องการใช้การทำงานรุ่นที่ 1 สำหรับฟังก์ชันรุ่นที่ 2 ให้ตั้งค่าเริ่มต้นของรุ่นที่ 1 เป็นตัวเลือกทั่วโลก
Node.js
// Turn off Firebase defaults
setGlobalOptions({ cpu: 'gcf_gen1' });
Python
# Use 1st gen behavior
set_global_options(cpu="gcf_gen1")
สำหรับฟังก์ชันที่ใช้ CPU มาก รุ่นที่ 2 จะมีความยืดหยุ่นในการกำหนดค่า CPU คุณเพิ่ม CPU ได้ทีละฟังก์ชันดังที่แสดงด้านล่างนี้
Node.js
// Boost CPU in a function:
export const analyzeImage = onObjectFinalized({ cpu: 2 }, (event) => {
// computer vision goes here
});
Python
# Boost CPU in a function:
@storage_fn.on_object_finalized(cpu=2)
def analyze_image(event: storage_fn.CloudEvent):
# computer vision goes here