了解 2023 年 Google I/O 大会上介绍的 Firebase 亮点。了解详情

หน้านี้ได้รับการแปลโดย Cloud Translation API

จัดการฟังก์ชัน

คุณทำให้ใช้งานได้ ลบ และแก้ไขฟังก์ชันโดยใช้คำสั่ง 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 จะนำเวอร์ชันที่ใช้งานก่อนหน้านี้ออก ตัวอย่างเช่น หากคุณมีเว็บฮุคที่ทริกเกอร์ 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 ใช้งานได้เมื่อเวลาผ่านไป คุณอาจต้องเปลี่ยนประเภททริกเกอร์ของฟังก์ชันด้วยเหตุผลหลายประการ เช่น คุณอาจต้องการเปลี่ยนจากเหตุการณ์ฐานข้อมูลเรียลไทม์หรือ Cloud Firestore ของ Firebase ประเภทหนึ่งไปเป็นอีกประเภทหนึ่ง

คุณเปลี่ยนประเภทเหตุการณ์ของฟังก์ชันโดยการเปลี่ยนซอร์สโค้ดและเรียกใช้ 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

ตั้งค่าตัวเลือกรันไทม์

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 Console หรือใช้ 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 ถึง 1, 000

ฟังก์ชันที่มีการตั้งค่าการเกิดขึ้นพร้อมกันสูงกว่าอาจซับการรับส่งข้อมูลที่เพิ่มขึ้นอย่างรวดเร็วได้โดยไม่ต้องเริ่มต้นแบบ Cold เนื่องจากแต่ละอินสแตนซ์มีแนวโน้มที่จะมีช่องว่างอยู่บ้าง หากกำหนดค่าอินสแตนซ์ให้รองรับคำขอหลายรายการพร้อมกันได้สูงสุด 50 รายการ แต่ปัจจุบันจัดการคำขอได้เพียง 25 รายการ จะรองรับคำขอเพิ่มเติมที่เพิ่มขึ้นอย่างฉับพลันถึง 25 รายการได้โดยไม่ต้องใช้อินสแตนซ์ใหม่เป็น Cold Start ในทางตรงกันข้าม หากมีการตั้งค่าเกิดขึ้นพร้อมกันเพียง 1 รายการ คำขอที่พุ่งสูงขึ้นนั้นอาจทำให้เกิด Cold Start ได้ 25 ครั้ง

สถานการณ์ง่ายๆ นี้แสดงให้เห็นถึงประสิทธิภาพที่เพิ่มขึ้นที่เป็นไปได้จากการเกิดขึ้นพร้อมกัน ในความเป็นจริง การปรับขนาดพฤติกรรมเพื่อเพิ่มประสิทธิภาพและลดความเย็นที่เริ่มจากการเกิดขึ้นพร้อมกันนั้นมีความซับซ้อนกว่า การเกิดขึ้นพร้อมกันใน 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:

หมายเหตุ: จำนวนอินสแตนซ์ขั้นต่ำที่ยังคงทำงานต่อไปจะก่อให้เกิดค่าใช้จ่ายการเรียกเก็บเงินในอัตราที่ไม่มีความเคลื่อนไหว ฟังก์ชันที่มีการจัดสรรหน่วยความจำเริ่มต้นของรุ่นที่ 256MiB มีราคาประมาณ $3/เดือน (มีการจัดสรร CPU ด้วย gcf_gen_1 และปิดใช้การทำงานพร้อมกัน) หรือประมาณ $8/เดือนโดยเปิดใช้ 1CPU และการเกิดขึ้นพร้อมกัน Firebase CLI จะแสดงค่าใช้จ่ายโดยประมาณ ณ เวลาที่ทำให้ใช้งานได้สำหรับฟังก์ชันที่มีอินสแตนซ์ขั้นต่ำที่จองไว้ โปรดดูราคาของ Cloud Run เพื่อคำนวณค่าใช้จ่าย

สิ่งที่ควรพิจารณาเมื่อตั้งค่าอินสแตนซ์ขั้นต่ำมีดังนี้

หาก 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 ให้เลือก Cloud Functions for 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