คุณสามารถทำให้ฟังก์ชันใช้งานได้ ลบ และแก้ไขฟังก์ชันโดยใช้คำสั่ง Firebase CLI หรือตั้งค่าตัวเลือกรันไทม์ในซอร์สโค้ดของฟังก์ชันก็ได้
ทำให้ฟังก์ชันใช้งานได้
หากต้องการทำให้ฟังก์ชันใช้งานได้ ให้เรียกใช้คำสั่ง Firebase CLI นี้:
firebase deploy --only functions
โดยค่าเริ่มต้น Firebase CLI จะทำให้ฟังก์ชันทั้งหมดภายในต้นทางใช้งานได้พร้อมกัน หากโปรเจ็กต์มีฟังก์ชันมากกว่า 5 รายการ เราขอแนะนำให้ใช้แฟล็ก --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 จะนำเวอร์ชันที่ทำให้ใช้งานได้ก่อนหน้านี้ออก ตัวอย่างเช่น หากคุณมีฟังก์ชัน Node.js ชื่อ webhook
และต้องการเปลี่ยนเป็น webhookNew
ให้แก้ไขโค้ดดังนี้
// before
const functions = require('firebase-functions');
exports.webhook = functions.https.onRequest((req, res) => {
res.send("Hello");
});
// after
const functions = require('firebase-functions');
exports.webhookNew = functions.https.onRequest((req, res) => {
res.send("Hello");
});
จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อทำให้ฟังก์ชันใหม่ใช้งานได้
# Deploy new function called webhookNew firebase deploy --only functions:webhookNew # Wait until deployment is done; now both webhookNew and webhook are running # Delete webhook firebase functions:delete webhook
เปลี่ยนภูมิภาคของฟังก์ชัน
หากคุณเปลี่ยนภูมิภาคที่ระบุสำหรับฟังก์ชันที่จัดการการรับส่งข้อมูลเวอร์ชันที่ใช้งานจริง คุณจะป้องกันไม่ให้เหตุการณ์สูญหายได้ด้วยการทำตามขั้นตอนต่อไปนี้
- เปลี่ยนชื่อฟังก์ชันและเปลี่ยนภูมิภาคหรือภูมิภาคตามต้องการ
- ทำให้ฟังก์ชันที่เปลี่ยนชื่อแล้วใช้งานได้ ซึ่งจะส่งผลให้เรียกใช้โค้ดเดียวกันเป็นการชั่วคราวในทั้ง 2 ชุดของภูมิภาค
- ลบฟังก์ชันก่อนหน้า
ตัวอย่างเช่น หากคุณมีฟังก์ชันชื่อ webhook
ซึ่งขณะนี้อยู่ในภูมิภาคฟังก์ชันเริ่มต้นของ us-central1
และต้องการย้ายข้อมูลไปยัง asia-northeast1
คุณจะต้องแก้ไขซอร์สโค้ดเพื่อเปลี่ยนชื่อฟังก์ชันและแก้ไขภูมิภาคก่อน
// before
const functions = require('firebase-functions');
exports.webhook = functions
.https.onRequest((req, res) => {
res.send("Hello");
});
// after
const functions = require('firebase-functions');
exports.webhookAsia = functions
.region('asia-northeast1')
.https.onRequest((req, res) => {
res.send("Hello");
});
จากนั้นจึงทำให้ใช้งานได้โดยการเรียกใช้:
firebase deploy --only functions:webhookAsia
ตอนนี้มีฟังก์ชันที่เหมือนกัน 2 ฟังก์ชันทำงานอยู่ นั่นคือ webhook
ทำงานใน us-central1
และ webhookAsia
ทำงานใน asia-northeast1
จากนั้นลบ webhook
:
firebase functions:delete webhook
ตอนนี้มีเพียงฟังก์ชันเดียว คือ webhookAsia
ซึ่งทำงานอยู่ใน asia-northeast1
เปลี่ยนประเภททริกเกอร์ของฟังก์ชัน
เมื่อพัฒนาการทำให้ใช้งานได้ของ Cloud Functions สำหรับ Firebase เมื่อเวลาผ่านไป คุณอาจต้องเปลี่ยนประเภททริกเกอร์ของฟังก์ชันด้วยเหตุผลหลายประการ เช่น คุณอาจต้องการเปลี่ยนจากฐานข้อมูลเรียลไทม์ของ Firebase หรือเหตุการณ์ Cloud Firestore จากประเภทหนึ่งไปเป็นอีกประเภทหนึ่ง
คุณเปลี่ยนประเภทเหตุการณ์ของฟังก์ชันโดยเพียงแค่เปลี่ยนซอร์สโค้ดแล้วเรียกใช้ firebase deploy
ไม่ได้ เพื่อหลีกเลี่ยงข้อผิดพลาด ให้เปลี่ยนประเภททริกเกอร์ของฟังก์ชันตามขั้นตอนนี้
- แก้ไขซอร์สโค้ดให้รวมฟังก์ชันใหม่ที่มีประเภททริกเกอร์ที่ต้องการ
- ทำให้ฟังก์ชันนี้ใช้งานได้ ซึ่งจะส่งผลให้มีการเรียกใช้ทั้งฟังก์ชันเก่าและใหม่เป็นการชั่วคราว
- ลบฟังก์ชันเก่าออกจากเวอร์ชันที่ใช้งานจริงอย่างชัดเจนโดยใช้ Firebase CLI
เช่น หากคุณมีฟังก์ชัน Node.js ชื่อ objectChanged
ซึ่งมีประเภทเหตุการณ์ onChange
เดิม และคุณต้องการเปลี่ยนเป็น onFinalize
ให้เปลี่ยนชื่อฟังก์ชันและแก้ไขให้มีประเภทเหตุการณ์ onFinalize
ก่อน
// before
const functions = require('firebase-functions');
exports.objectChanged = functions.storage.object().onChange((object) => {
return console.log('File name is: ', object.name);
});
// after
const functions = require('firebase-functions');
exports.objectFinalized = functions.storage.object().onFinalize((object) => {
return console.log('File name is: ', object.name);
});
จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างฟังก์ชันใหม่ ก่อนที่จะลบฟังก์ชันเก่า
# Create new function objectFinalized firebase deploy --only functions:objectFinalized # Wait until deployment is done; now both objectChanged and objectFinalized are running # Delete objectChanged firebase functions:delete objectChanged
ตั้งค่าตัวเลือกรันไทม์
Cloud Functions for Firebase ให้คุณเลือกตัวเลือกต่างๆ ของรันไทม์ เช่น เวอร์ชันรันไทม์ของ Node.js และระยะหมดเวลาต่อฟังก์ชัน การจัดสรรหน่วยความจำ และอินสแตนซ์ของฟังก์ชันขั้นต่ำ/สูงสุด
ตามแนวทางปฏิบัติแนะนำ คุณควรตั้งค่าตัวเลือกเหล่านี้ (ยกเว้นเวอร์ชัน Node.js) ในออบเจ็กต์การกำหนดค่าภายในโค้ดฟังก์ชัน ออบเจ็กต์ RuntimeOptions
นี้เป็นแหล่งที่มาที่เชื่อถือได้สำหรับตัวเลือกรันไทม์ของฟังก์ชัน และจะลบล้างตัวเลือกที่ตั้งค่าไว้ผ่านวิธีการอื่น (เช่น ผ่านคอนโซล Google Cloud หรือ gcloud CLI)
หากเวิร์กโฟลว์การพัฒนาเกี่ยวข้องกับการตั้งค่าตัวเลือกรันไทม์ด้วยตนเองผ่านคอนโซล Google Cloud หรือ gcloud CLI และคุณไม่ต้องการให้มีการลบล้างค่าเหล่านี้ในการทำให้ใช้งานได้แต่ละครั้ง ให้ตั้งค่าตัวเลือก preserveExternalChanges
เป็น true
เมื่อใช้ตัวเลือกนี้เป็น true
Firebase จะผสานรวมตัวเลือกรันไทม์ที่ตั้งค่าไว้ในโค้ดกับการตั้งค่าของฟังก์ชันเวอร์ชันที่ใช้อยู่ในปัจจุบันโดยมีลำดับความสำคัญต่อไปนี้
- มีการตั้งค่าตัวเลือกในโค้ดฟังก์ชัน: ลบล้างการเปลี่ยนแปลงภายนอก
- ตั้งค่าตัวเลือกเป็น
RESET_VALUE
ในโค้ดฟังก์ชัน: ลบล้างการเปลี่ยนแปลงภายนอกด้วยค่าเริ่มต้น - ไม่ได้กำหนดตัวเลือกไว้ในโค้ดฟังก์ชัน แต่มีการตั้งค่าในฟังก์ชันที่ทำให้ใช้งานได้แล้วในปัจจุบัน ใช้ตัวเลือกที่ระบุในฟังก์ชันที่ทำให้ใช้งานได้แล้ว
เราไม่แนะนำให้ใช้ตัวเลือก preserveExternalChanges: true
กับสถานการณ์ส่วนใหญ่เนื่องจากโค้ดจะไม่ใช่แหล่งข้อมูลที่เชื่อถือได้ของตัวเลือกรันไทม์สำหรับฟังก์ชันของคุณอีกต่อไป หากคุณใช้งาน ให้ตรวจสอบคอนโซล Google Cloud หรือใช้ gcloud CLI เพื่อดูการกำหนดค่าทั้งหมดของฟังก์ชัน
ตั้งค่าเวอร์ชัน Node.js
Firebase SDK for Cloud Functions อนุญาตให้เลือกรันไทม์ของ Node.js ได้ คุณเลือกเรียกใช้ฟังก์ชันทั้งหมดในโปรเจ็กต์บนสภาพแวดล้อมรันไทม์โดยเฉพาะ ซึ่งสอดคล้องกับเวอร์ชัน Node.js ที่รองรับเวอร์ชันใดเวอร์ชันหนึ่งดังต่อไปนี้
- Node.js 20 (ตัวอย่าง)
- Node.js 18
- Node.js 16
- Node.js 14
วิธีตั้งค่าเวอร์ชัน Node.js
คุณสามารถตั้งค่าเวอร์ชันได้ในช่อง engines
ในไฟล์ package.json
ที่สร้างขึ้นในไดเรกทอรี functions/
ระหว่างการเริ่มต้น
ตัวอย่างเช่น หากต้องการใช้เฉพาะเวอร์ชัน 18 ให้แก้ไขบรรทัดนี้ใน package.json
"engines": {"node": "18"}
หากคุณใช้ตัวจัดการแพ็กเกจของ Yarn หรือมีข้อกำหนดเฉพาะอื่นๆ สำหรับช่อง engines
คุณสามารถตั้งค่ารันไทม์ของ Firebase SDK สำหรับ Cloud Functions ใน firebase.json
แทนได้ ดังนี้
{
"functions": {
"runtime": "nodejs18" // or nodejs14, nodejs16 or nodejs20
}
}
CLI ใช้ค่าที่กำหนดไว้ใน firebase.json
มากกว่าค่าหรือช่วงที่คุณกำหนดแยกต่างหากใน package.json
อัปเกรดรันไทม์ของ Node.js
วิธีอัปเกรดรันไทม์ของ Node.js
- ตรวจสอบว่าโปรเจ็กต์ใช้แผนการตั้งราคา Blaze
- ตรวจสอบว่าคุณใช้ Firebase CLI v11.18.0 ขึ้นไป
- เปลี่ยนค่า
engines
ในไฟล์package.json
ที่สร้างขึ้นในไดเรกทอรีfunctions/
ระหว่างการเริ่มต้น ตัวอย่างเช่น ถ้าคุณอัปเกรดจากเวอร์ชัน 16 เป็นเวอร์ชัน 18 รายการควรมีลักษณะดังนี้"engines": {"node": "18"}
- (ไม่บังคับ) ทดสอบการเปลี่ยนแปลงโดยใช้ Firebase Local Emulator Suite
- ทำให้ฟังก์ชันทั้งหมดใช้งานได้
ควบคุมพฤติกรรมการปรับขนาด
โดยค่าเริ่มต้น Cloud Functions for Firebase จะปรับขนาดจำนวนอินสแตนซ์ที่ทำงานอยู่ตามจำนวนคำขอขาเข้า ซึ่งอาจลดจำนวนอินสแตนซ์ลงเป็น 0 ในช่วงที่การเข้าชมลดลง อย่างไรก็ตาม หากแอปต้องลดเวลาในการตอบสนองและต้องการจำกัดจำนวน Cold Start คุณสามารถเปลี่ยนลักษณะการทำงานเริ่มต้นนี้ได้โดยระบุจำนวนอินสแตนซ์คอนเทนเนอร์ขั้นต่ำเพื่อให้คำขออุ่นและพร้อมแสดงผล
ในทำนองเดียวกัน คุณอาจกำหนดจำนวนสูงสุดเพื่อจำกัดการปรับขนาดของอินสแตนซ์เพื่อตอบสนองต่อคำขอที่เข้ามาใหม่ ใช้การตั้งค่านี้เป็นวิธีควบคุมค่าใช้จ่ายหรือจำกัดจำนวนการเชื่อมต่อกับบริการสำรองข้อมูล เช่น ฐานข้อมูล
ลดจำนวน Cold Start
หากต้องการตั้งค่าจำนวนอินสแตนซ์ขั้นต่ำสำหรับฟังก์ชันในซอร์สโค้ด ให้ใช้เมธอด runWith
เมธอดนี้ยอมรับออบเจ็กต์ JSON ที่สอดคล้องกับอินเทอร์เฟซ RuntimeOptions
ซึ่งกำหนดค่าสำหรับ minInstances
ตัวอย่างเช่น ฟังก์ชันนี้ตั้งค่าอินสแตนซ์อย่างน้อย 5 รายการเพื่อทำให้บรรยากาศอบอุ่น
exports.getAutocompleteResponse = functions
.runWith({
// Keep 5 instances warm for this latency-critical function
minInstances: 5,
})
.https.onCall((data, context) => {
// Autocomplete a user's search term
});
ต่อไปนี้เป็นข้อควรพิจารณาเมื่อตั้งค่าสำหรับ minInstances
- หาก Cloud Functions for Firebase ปรับขนาดแอปให้สูงกว่าการตั้งค่า
minInstances
คุณจะพบ Cold Start สำหรับแต่ละอินสแตนซ์ที่อยู่สูงกว่าเกณฑ์ดังกล่าว - Cold Start จะมีผลร้ายแรงที่สุดกับแอปที่มีการเข้าชมพุ่งสูง หากแอปมีการเข้าชมพุ่งสูงขึ้นและคุณตั้งค่า
minInstances
ไว้สูงพอที่ Cold Start จะลดลงเมื่อการเข้าชมแต่ละครั้งเพิ่มขึ้น คุณจะเห็นว่าเวลาในการตอบสนองลดลงอย่างมาก สำหรับแอปที่มีการเข้าชมตลอดเวลา การ Cold Start ไม่มีแนวโน้มที่จะส่งผลกระทบต่อประสิทธิภาพอย่างมาก การตั้งค่าอินสแตนซ์ขั้นต่ำอาจเหมาะสมสำหรับสภาพแวดล้อมการใช้งานจริง แต่โดยทั่วไปควรหลีกเลี่ยงในสภาพแวดล้อมการทดสอบ หากต้องการปรับขนาดเป็น 0 ในโปรเจ็กต์ทดสอบ แต่ยังคงลด Cold Start ในโปรเจ็กต์ที่ใช้งานจริง ให้ตั้งค่า
minInstances
ตามตัวแปรสภาพแวดล้อมFIREBASE_CONFIG
ดังนี้// Get Firebase project id from `FIREBASE_CONFIG` environment variable const envProjectId = JSON.parse(process.env.FIREBASE_CONFIG).projectId; exports.renderProfilePage = functions .runWith({ // Keep 5 instances warm for this latency-critical function // in production only. Default to 0 for test projects. minInstances: envProjectId === "my-production-project" ? 5 : 0, }) .https.onRequest((req, res) => { // render some html });
จำกัดจำนวนอินสแตนซ์สูงสุดสำหรับฟังก์ชัน
หากต้องการตั้งค่าอินสแตนซ์สูงสุดในซอร์สโค้ดของฟังก์ชัน ให้ใช้เมธอด runWith
เมธอดนี้ยอมรับออบเจ็กต์ JSON ที่สอดคล้องกับอินเทอร์เฟซ RuntimeOptions
ซึ่งกำหนดค่าสำหรับ maxInstances
เช่น ฟังก์ชันนี้กำหนดขีดจำกัดอินสแตนซ์ไว้ที่ 100 รายการเพื่อไม่ให้มีฐานข้อมูลเดิมที่ใช้บ่อยมากเกินไป
exports.mirrorOrdersToLegacyDatabase = functions
.runWith({
// Legacy database only supports 100 simultaneous connections
maxInstances: 100,
})
.firestore.document("orders/{orderId}")
.onWrite((change, context) => {
// Connect to legacy database
});
หากปรับขนาดฟังก์ชัน HTTP ถึงขีดจำกัด maxInstances
คำขอใหม่จะอยู่ในคิวเป็นเวลา 30 วินาที แล้วถูกปฏิเสธด้วยรหัสการตอบกลับ 429 Too Many Requests
หากไม่มีอินสแตนซ์ที่พร้อมใช้งานภายในเวลาดังกล่าว
ดูข้อมูลเพิ่มเติมเกี่ยวกับแนวทางปฏิบัติแนะนำในการใช้การตั้งค่าอินสแตนซ์สูงสุดได้จากแนวทางปฏิบัติแนะนำในการใช้ maxInstances
ตั้งค่าระยะหมดเวลาและการจัดสรรหน่วยความจำ
ในบางกรณี ฟังก์ชันอาจมีข้อกำหนดพิเศษสำหรับค่าการหมดเวลาที่ยาวนานหรือการจัดสรรหน่วยความจำจำนวนมาก คุณตั้งค่าเหล่านี้ได้ในคอนโซล Google Cloud หรือในซอร์สโค้ดของฟังก์ชัน (Firebase เท่านั้น)
หากต้องการตั้งค่าการจัดสรรหน่วยความจำและระยะหมดเวลาในซอร์สโค้ดของฟังก์ชัน ให้ใช้พารามิเตอร์ runWith
ที่ใช้ใน Firebase SDK สำหรับ Cloud Functions 2.0.0 ตัวเลือกรันไทม์นี้ยอมรับออบเจ็กต์ JSON ที่สอดคล้องกับอินเทอร์เฟซ RuntimeOptions
ซึ่งกำหนดค่าสำหรับ timeoutSeconds
และ memory
เช่น ฟังก์ชันพื้นที่เก็บข้อมูลนี้ใช้หน่วยความจำ 1 GB และหมดเวลาหลังจากผ่านไป 300 วินาที
exports.convertLargeFile = functions
.runWith({
// Ensure the function has enough memory and time
// to process large files
timeoutSeconds: 300,
memory: "1GB",
})
.storage.object()
.onFinalize((object) => {
// Do some complicated things that take a lot of memory and time
});
ค่าสูงสุดสำหรับ timeoutSeconds
คือ 540
หรือ 9 นาที
จำนวนหน่วยความจำที่มอบให้ฟังก์ชันจะสอดคล้องกับ CPU ที่จัดสรรไว้สำหรับฟังก์ชัน ตามรายละเอียดในรายการค่าที่ถูกต้องสำหรับ memory
มีดังนี้
128MB
— 200MHz256MB
— 400MHz512MB
— 800MHz1GB
— 1.4 GHz2GB
— 2.4 GHz4GB
— 4.8 GHz8GB
— 4.8 GHz
วิธีตั้งค่าการจัดสรรและระยะหมดเวลาหน่วยความจำในคอนโซล Google Cloud มีดังนี้
- ในคอนโซล Google Cloud ให้เลือก Cloud Functions จากเมนูด้านซ้าย
- เลือกฟังก์ชันโดยคลิกชื่อฟังก์ชันในรายการฟังก์ชัน
- คลิกไอคอนแก้ไขในเมนูด้านบน
- เลือกการจัดสรรหน่วยความจำจากเมนูแบบเลื่อนลงที่มีป้ายกำกับว่าหน่วยความจำที่จัดสรร
- คลิกเพิ่มเติมเพื่อแสดงตัวเลือกขั้นสูง และป้อนจำนวนวินาทีในช่องข้อความระยะหมดเวลา
- คลิกบันทึกเพื่ออัปเดตฟังก์ชัน