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


คุณสามารถทำให้ฟังก์ชันใช้งานได้ ลบ และแก้ไขฟังก์ชันโดยใช้ Firebase คำสั่ง CLI หรือโดยการตั้งค่าตัวเลือกรันไทม์ในซอร์สโค้ดของฟังก์ชัน

ทำให้ฟังก์ชันใช้งานได้

หากต้องการทำให้ฟังก์ชันใช้งานได้ ให้เรียกใช้คำสั่ง Firebase CLI นี้

firebase deploy --only functions

โดยค่าเริ่มต้น CLI ของ Firebase จะทำให้ฟังก์ชันทั้งหมดภายในใช้งานได้ แหล่งที่มาของคุณไปพร้อมๆ กันด้วย หากโปรเจ็กต์มีฟังก์ชันมากกว่า 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 จะแยกวิเคราะห์แหล่งที่มาและนำฟังก์ชันที่นําออกจากไฟล์ออกจากเวอร์ชันที่ใช้งานจริง

แก้ไขชื่อ ภูมิภาค หรือทริกเกอร์ของฟังก์ชัน

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

เปลี่ยนชื่อฟังก์ชัน

หากต้องการเปลี่ยนชื่อฟังก์ชัน ให้สร้างฟังก์ชันที่มีการเปลี่ยนชื่อใหม่ในแหล่งที่มา จากนั้นเรียกใช้คำสั่งการติดตั้งใช้งาน 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

เปลี่ยนภูมิภาคหรือภูมิภาคของฟังก์ชัน

หากคุณเปลี่ยนภูมิภาคที่ระบุสำหรับ ที่จัดการกับการรับส่งข้อมูลที่ใช้งานจริง คุณจะป้องกันการสูญเสียเหตุการณ์ได้โดย โปรดปฏิบัติตามขั้นตอนเหล่านี้ตามลำดับ

  1. เปลี่ยนชื่อฟังก์ชันและเปลี่ยนภูมิภาคของฟังก์ชันตามที่คุณต้องการ
  2. ติดตั้งใช้งานฟังก์ชันที่เปลี่ยนชื่อ ซึ่งจะทําให้เรียกใช้โค้ดเดียวกันในทั้ง 2 ชุดของภูมิภาคชั่วคราว
  3. ลบฟังก์ชันก่อนหน้า

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

คุณไม่สามารถเปลี่ยนประเภทเหตุการณ์ของฟังก์ชันโดยการเปลี่ยนแปลงฟังก์ชัน ซอร์สโค้ดและการเรียกใช้ firebase deploy หากต้องการหลีกเลี่ยงข้อผิดพลาด ให้เปลี่ยนประเภททริกเกอร์ของฟังก์ชันตามขั้นตอนต่อไปนี้

  1. แก้ไขซอร์สโค้ดให้รวมฟังก์ชันใหม่ที่มีประเภททริกเกอร์ที่ต้องการ
  2. ทำให้ฟังก์ชันใช้งานได้ ซึ่งจะทําให้ทั้งฟังก์ชันเก่าและใหม่ทํางานร่วมกันชั่วคราว
  3. ลบฟังก์ชันเก่าออกจากเวอร์ชันที่ใช้งานจริงอย่างชัดเจนโดยใช้ 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 Console) หรือ gcloud CLI)

หากเวิร์กโฟลว์การพัฒนาของคุณเกี่ยวข้องกับการตั้งค่าตัวเลือกรันไทม์ด้วยตนเองผ่านคอนโซล Google Cloud หรือ gcloud CLI และคุณไม่ต้องการให้ระบบลบล้างค่าเหล่านี้ในการทำให้ใช้งานได้แต่ละครั้ง ให้ตั้งค่าตัวเลือก preserveExternalChanges เป็น true เมื่อตั้งค่าตัวเลือกนี้เป็น true Firebase จะผสานตัวเลือกรันไทม์ที่ตั้งไว้ในโค้ดเข้ากับการตั้งค่าของฟังก์ชันเวอร์ชันที่ใช้งานอยู่ในปัจจุบันโดยให้ความสำคัญตามลำดับต่อไปนี้

  1. มีการตั้งค่าตัวเลือกในโค้ดฟังก์ชัน: ลบล้างการเปลี่ยนแปลงภายนอก
  2. ตัวเลือกได้รับการตั้งค่าเป็น RESET_VALUE ในโค้ดฟังก์ชัน: ลบล้างการเปลี่ยนแปลงภายนอกด้วยค่าเริ่มต้น
  3. ไม่ได้ตั้งค่าตัวเลือกในโค้ดฟังก์ชัน แต่ตั้งค่าไว้ในฟังก์ชันที่ใช้งานอยู่ในปัจจุบัน: ใช้ตัวเลือกที่ระบุไว้ในฟังก์ชันที่ใช้งานอยู่

เราไม่แนะนําให้ใช้ตัวเลือก preserveExternalChanges: true ในสถานการณ์ส่วนใหญ่ เนื่องจากโค้ดของคุณจะไม่เป็นแหล่งข้อมูลทั้งหมดที่ถูกต้องสําหรับตัวเลือกรันไทม์ของฟังก์ชันอีกต่อไป หากคุณใช้ ให้ตรวจสอบคอนโซล Google Cloud หรือใช้ gcloud CLI เพื่อดูการกำหนดค่าแบบเต็มของฟังก์ชัน

ตั้งค่าเวอร์ชัน Node.js

SDK Firebase สำหรับ 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 คุณสามารถตั้งค่ารันไทม์ของ SDK Firebase ให้กับ Cloud Functions ได้ใน firebase.json แทน:

  {
    "functions": {
      "runtime": "nodejs18" // or nodejs20
    }
  }

CLI จะใช้ค่าที่ตั้งไว้ใน firebase.json แทนค่าหรือช่วงที่คุณตั้งค่าแยกต่างหากใน package.json

อัปเกรดรันไทม์ของ Node.js

วิธีอัปเกรดรันไทม์ของ Node.js

  1. ตรวจสอบว่าโปรเจ็กต์อยู่ในแพ็กเกจราคา Blaze
  2. ตรวจสอบว่าคุณใช้ Firebase CLI v11.18.0 ขึ้นไป
  3. เปลี่ยนค่า engines ในไฟล์ package.json ที่สร้างใน ไดเรกทอรี functions/ ของคุณระหว่างการเริ่มต้น ตัวอย่างเช่น หากคุณจะอัปเกรดจากเวอร์ชัน 18 เป็นเวอร์ชัน 20 รายการดังกล่าวควรมีลักษณะดังนี้ "engines": {"node": "20"}
  4. คุณทดสอบการเปลี่ยนแปลงโดยใช้ Firebase Local Emulator Suite หรือไม่ก็ได้
  5. ทำให้ฟังก์ชันทั้งหมดใช้งานได้อีกครั้ง

ตั้งค่าเวอร์ชัน Python

Firebase SDK สำหรับ Cloud Functions เวอร์ชัน 12.0.0 ขึ้นไปอนุญาตให้เลือกรันไทม์ Python ตั้งค่าเวอร์ชันรันไทม์ใน firebase.json ดังที่แสดงด้านล่างนี้

  {
    "functions": {
      "runtime": "python310" // or python311
    }
  }

ควบคุมลักษณะการปรับขนาด

โดยค่าเริ่มต้น Cloud Functions for Firebase จะปรับขนาดจำนวนอินสแตนซ์ที่ทำงานอยู่ตามจำนวนคำขอขาเข้า และอาจปรับขนาดให้เหลือ 0 อินสแตนซ์เมื่อการรับส่งข้อมูลลดลง อย่างไรก็ตาม หากแอปของคุณต้องการเวลาในการตอบสนองที่ลดลงและคุณต้องการจำกัดจำนวนการเริ่มต้นแบบเย็น คุณสามารถเปลี่ยนลักษณะการทำงานเริ่มต้นนี้ได้โดยการระบุจำนวนอินสแตนซ์คอนเทนเนอร์ขั้นต่ำที่จะเก็บไว้และพร้อมให้บริการคำขอ

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

การใช้การตั้งค่าเหล่านี้ร่วมกับการตั้งค่าการทำงานพร้อมกันต่ออินสแตนซ์ (ใหม่ในรุ่นที่ 2) จะช่วยให้คุณควบคุมและปรับแต่งลักษณะการปรับขนาดสำหรับฟังก์ชันได้ ลักษณะของแอปพลิเคชันและฟังก์ชันจะเป็นตัวกำหนดการตั้งค่าที่คุ้มค่าที่สุดและส่งผลให้เกิดประสิทธิภาพที่ดีที่สุด

สําหรับแอปบางแอปที่มีการเข้าชมต่ำ ตัวเลือก CPU ที่ต่ำลงโดยไม่มีการทำงานพร้อมกันหลายรายการจะเหมาะที่สุด สําหรับกรณีอื่นๆ ที่การเริ่มต้นแบบ Cold Start เป็นปัญหาร้ายแรง การตั้งค่าการทํางานพร้อมกันสูงและอินสแตนซ์ขั้นต่ำหมายความว่าระบบจะเก็บชุดอินสแตนซ์ไว้เสมอเพื่อจัดการกับการเข้าชมที่เพิ่มขึ้นอย่างรวดเร็ว

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

อนุญาตคำขอหลายรายการพร้อมกัน

ใน Cloud Functions for Firebase (รุ่นที่ 1) แต่ละอินสแตนซ์จะจัดการคำขอได้ครั้งละ 1 รายการเท่านั้น ระบบจึงตั้งค่าลักษณะการปรับขนาดด้วยการตั้งค่าอินสแตนซ์ขั้นต่ำและสูงสุดเท่านั้น นอกจากการควบคุมจำนวนอินสแตนซ์แล้ว ใน Cloud Functions for Firebase (รุ่นที่ 2) คุณยังควบคุมจำนวนคำขอที่อินสแตนซ์แต่ละรายการจะให้บริการพร้อมกันได้ด้วยตัวเลือก concurrency ค่าเริ่มต้นของการเกิดขึ้นพร้อมกันคือ 80 แต่คุณสามารถ ตั้งค่าเป็นจำนวนเต็มใดก็ได้ระหว่าง 1 ถึง 1000

ฟังก์ชันที่มีการตั้งค่าการเรียกใช้พร้อมกันสูงกว่าจะรองรับการเข้าชมที่เพิ่มขึ้นได้โดยไม่ต้องเริ่มทำงานใหม่ เนื่องจากอินสแตนซ์แต่ละรายการมี Headroom อยู่บ้าง หากอินสแตนซ์ได้รับการกำหนดค่าให้จัดการคำขอพร้อมกันได้สูงสุด 50 รายการ แต่ปัจจุบันจัดการได้เพียง 25 รายการ อินสแตนซ์จะจัดการคำขอที่เพิ่มขึ้นอีก 25 รายการได้โดยไม่ต้องทำให้อินสแตนซ์ใหม่เริ่มทำงานเย็น ในทางตรงกันข้าม หากมีการตั้งค่าเกิดขึ้นพร้อมกันแค่ 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 ในโปรเจ็กต์ทดสอบแต่ยังคงลดการเริ่มต้นระบบใหม่ในโปรเจ็กต์เวอร์ชันที่ใช้งานจริง คุณสามารถกําหนดค่าอินสแตนซ์ขั้นต่ำในการกําหนดค่าที่มีพารามิเตอร์ ดังนี้

    Node.js

    const functions = require('firebase-functions/v1');
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 นี้ใช้หน่วยความจํา 1GiB และหมดเวลาหลังจาก 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

  1. ในคอนโซล Google Cloud ให้เลือก Cloud Functions for Firebase จาก เมนูด้านซ้าย
  2. เลือกฟังก์ชันโดยคลิกที่ชื่อในรายการฟังก์ชัน
  3. คลิกไอคอนแก้ไขในเมนูด้านบน
  4. เลือกการจัดสรรหน่วยความจำจากเมนูแบบเลื่อนลงที่มีป้ายกำกับว่าการจัดสรรหน่วยความจำ
  5. คลิกเพิ่มเติมเพื่อแสดงตัวเลือกขั้นสูง แล้วป้อนจำนวนวินาทีในกล่องข้อความหมดเวลา
  6. คลิกบันทึกเพื่ออัปเดตฟังก์ชัน

ลบล้างค่าเริ่มต้นของ CPU

หน่วยความจําสูงสุด 2 GB แต่ละฟังก์ชันใน Cloud Functions for Firebase (รุ่นที่ 2) จะเริ่มต้นด้วย CPU 1 ตัว จากนั้นจะเพิ่มเป็น 2 CPU สําหรับ 4 และ 8 GB โปรดทราบว่า ซึ่งแตกต่างจากลักษณะการทำงานเริ่มต้นของรุ่นที่ 1 อย่างมากในด้านที่อาจ จะทําให้มีค่าใช้จ่ายสูงขึ้นเล็กน้อยสําหรับฟังก์ชันที่มีหน่วยความจําต่ำ ดังที่แสดงไว้ใน ตารางต่อไปนี้

จัดสรร RAM แล้ว CPU เริ่มต้นของเวอร์ชัน 1 (เศษส่วน) CPU เริ่มต้นเวอร์ชัน 2 การขึ้นราคาต่อมิลลิวินาที
128MB 12/1 1 10.5 เท่า
256 MB 1/6 1 5.3 เท่า
512 MB 1/3 1 2.7 เท่า
1GB 12/7 1 1.6x
2GB 1 1 1x
4 GB 2 2 1x
8 GB 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