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

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

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

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

firebase deploy --only functions

โดยค่าเริ่มต้น Firebase CLI จะทำให้ฟังก์ชันทั้งหมดภายในแหล่งที่มาใช้งานได้พร้อมกัน หากโปรเจ็กต์มีฟังก์ชันมากกว่า 5 รายการ เราขอแนะนำให้ใช้แฟล็ก --only กับชื่อฟังก์ชันที่เฉพาะเจาะจงเพื่อทำให้ใช้งานได้เฉพาะฟังก์ชันที่คุณแก้ไขเท่านั้น การติดตั้งใช้งานฟังก์ชันที่เฉพาะเจาะจงด้วยวิธีนี้จะช่วยเร่งกระบวนการติดตั้งใช้งานและช่วยให้คุณหลีกเลี่ยงการใช้โควต้าการติดตั้งใช้งานจนหมด เช่น

firebase deploy --only functions:addMessage,functions:makeUppercase

เมื่อติดตั้งใช้งานฟังก์ชันจำนวนมาก คุณอาจใช้โควต้าเกินมาตรฐานและได้รับข้อความแสดงข้อผิดพลาด HTTP 429 หรือ 500 วิธีแก้ไขปัญหานี้คือให้ติดตั้งใช้งานฟังก์ชันเป็นกลุ่มๆ ละไม่เกิน 10 รายการ

ดูรายการคำสั่งทั้งหมดที่ใช้ได้ในข้อมูลอ้างอิง CLI ของ Firebase

โดยค่าเริ่มต้น Firebase CLI จะค้นหาซอร์สโค้ดในโฟลเดอร์ functions/ หากต้องการ คุณสามารถจัดระเบียบฟังก์ชันในฐานของโค้ดหรือชุดไฟล์หลายชุดได้

ล้างอาร์ติแฟกต์การติดตั้งใช้งาน

อิมเมจคอนเทนเนอร์จะสร้างขึ้นและจัดเก็บไว้ใน Artifact Registry โดยเป็นส่วนหนึ่งของการทำให้ฟังก์ชันใช้งานได้ รูปภาพเหล่านี้ไม่จำเป็นสำหรับการเรียกใช้ฟังก์ชันที่ติดตั้งใช้งาน Cloud Functions จะดึงข้อมูลและเก็บสำเนารูปภาพไว้ในการติดตั้งใช้งานครั้งแรก แต่อาร์ติแฟกต์ที่จัดเก็บไว้ไม่จำเป็นสำหรับการทำงานของฟังก์ชันในรันไทม์

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

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

คุณตั้งค่าหรือแก้ไขนโยบายการล้างข้อมูลด้วยตนเองได้โดยใช้คำสั่ง functions:artifacts:setpolicy ดังนี้

firebase functions:artifacts:setpolicy

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

คุณสามารถปรับแต่งระยะเวลาเก็บรักษาได้โดยใช้ตัวเลือก --days ดังนี้

firebase functions:artifacts:setpolicy --days 7  # Delete images older than 7 days

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

$ firebase functions:artifacts:setpolicy --location europe-west1

เลือกไม่ใช้การล้างข้อมูลอาร์ติแฟกต์

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

$ firebase functions:artifacts:setpolicy --none

คำสั่งนี้จะนำนโยบายการล้างข้อมูลที่มีอยู่ซึ่ง Firebase CLI ได้ตั้งค่าไว้ออก และป้องกันไม่ให้ Firebase ตั้งค่านโยบายการล้างข้อมูลหลังจากการติดตั้งใช้งานฟังก์ชัน

ลบฟังก์ชัน

คุณลบฟังก์ชันที่ติดตั้งใช้งานก่อนหน้านี้ได้ด้วยวิธีต่อไปนี้

  • อย่างชัดแจ้งใน Firebase CLI ด้วย functions:delete
  • อย่างชัดเจนในคอนโซล Google Cloud
  • โดยนัยโดยการนำฟังก์ชันออกจากแหล่งที่มาก่อนการทำให้ใช้งานได้

การดำเนินการลบทั้งหมดจะแจ้งให้คุณยืนยันก่อนนำฟังก์ชันออกจากเวอร์ชันที่ใช้งานจริง

การลบฟังก์ชันอย่างชัดแจ้งใน Firebase CLI รองรับอาร์กิวเมนต์หลายรายการ รวมถึงกลุ่มฟังก์ชัน และช่วยให้คุณระบุฟังก์ชันที่ทำงานในภูมิภาคหนึ่งๆ ได้ นอกจากนี้ คุณยังลบล้างข้อความแจ้งให้ยืนยันได้ด้วย

  • ลบฟังก์ชันทั้งหมดที่ตรงกับชื่อที่ระบุในทุกภูมิภาค 

    firebase functions:delete FUNCTION-1_NAME

  • ลบฟังก์ชันที่ระบุซึ่งทำงานในภูมิภาคที่ไม่ใช่ค่าเริ่มต้น 

    firebase functions:delete FUNCTION-1_NAME --region REGION_NAME

  • ลบฟังก์ชันมากกว่า 1 รายการ 

    firebase functions:delete FUNCTION-1_NAME FUNCTION-2_NAME

  • ลบกลุ่มฟังก์ชันที่ระบุ: 

    firebase functions:delete GROUP_NAME

  • ข้ามข้อความแจ้งให้ยืนยัน: 

    firebase functions:delete FUNCTION-1_NAME --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

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

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

  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 หรือ gcloud CLI)

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

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

ไม่แนะนำให้ใช้ตัวเลือก 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 เวอร์ชันเหล่านี้

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

คุณสามารถตั้งค่าเวอร์ชันในช่อง engines ในไฟล์ package.json ที่สร้างขึ้นในไดเรกทอรี functions/ ระหว่างการเริ่มต้นได้ เช่น หากต้องการใช้เฉพาะเวอร์ชัน 20 ให้แก้ไขบรรทัดนี้ใน package.json

  "engines": {"node": "20"}

หากคุณใช้เครื่องมือจัดการแพ็กเกจ Yarn หรือมีข้อกำหนดเฉพาะอื่นๆ สำหรับ ช่อง engines คุณสามารถตั้งค่ารันไทม์สำหรับ SDK ของ Firebase สำหรับ Cloud Functions ใน firebase.json แทนได้ ดังนี้

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

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. ทำให้ฟังก์ชันทั้งหมดใช้งานได้อีกครั้ง

เลือกระบบโมดูล Node.js

ระบบโมดูลเริ่มต้นใน Node.js คือ CommonJS (CJS) แต่ Node.js เวอร์ชันปัจจุบันยังรองรับโมดูล ECMAScript (ESM) ด้วย Cloud Functions รองรับทั้ง 2 แบบ

โดยค่าเริ่มต้น ฟังก์ชันจะใช้ CommonJS ซึ่งหมายความว่าการนำเข้าและส่งออกจะมีลักษณะดังนี้

const {onRequest} = require("firebase-functions/https");

exports.helloWorld = onRequest(async (req, res) => res.send("Hello from Firebase!"));

หากต้องการใช้ ESM แทน ให้ตั้งค่าช่อง "type": "module" ในไฟล์ package.json ดังนี้ 

  {
   ...
   "type": "module",
   ...
  }

เมื่อตั้งค่าแล้ว ให้ใช้ไวยากรณ์ ESM import และ export ดังนี้

import {onRequest} from "firebase-functions/https";

export const helloWorld = onRequest(async (req, res) => res.send("Hello from Firebase!"));

ระบบรองรับทั้ง 2 ระบบโมดูลอย่างเต็มรูปแบบ คุณเลือกวิธีที่เหมาะกับโปรเจ็กต์มากที่สุดได้ ดูข้อมูลเพิ่มเติมได้ในเอกสารประกอบของ Node.js เกี่ยวกับโมดูล

ตั้งค่าเวอร์ชัน 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 ไม่น่าจะส่งผลกระทบต่อประสิทธิภาพอย่างรุนแรง

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

    Node.js

    const { onRequest } = require('firebase-functions/https');
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 = onRequest(
  { minInstances: minInstancesConfig },
(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 หากไม่มีอินสแตนซ์ที่พร้อมใช้งานในขณะนั้น

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

ตั้งค่าบัญชีบริการ

บัญชีบริการเริ่มต้นสำหรับฟังก์ชันมีชุดสิทธิ์ที่ครอบคลุมเพื่อให้คุณโต้ตอบกับบริการอื่นๆ ของ Firebase และ Google Cloud ได้ ดังนี้

  • ฟังก์ชันรุ่นที่ 2: PROJECT_NUMBER-compute@developer.gserviceaccount.com (ชื่อ Compute Engine default service account)
  • ฟังก์ชันรุ่นที่ 1: PROJECT_ID@appspot.gserviceaccount.com (ชื่อบัญชีบริการเริ่มต้นของ App Engine)

คุณอาจต้องการลบล้างบัญชีบริการเริ่มต้นและจำกัดฟังก์ชันให้เข้าถึงเฉพาะทรัพยากรที่จำเป็นเท่านั้น ซึ่งทำได้โดยการสร้างบัญชีบริการที่กำหนดเองและกำหนดให้กับฟังก์ชันที่เหมาะสมโดยใช้ค่าการกำหนดค่า serviceAccount ดังนี้

const { onRequest } = require("firebase-functions/https");

exports.helloWorld = onRequest(
    {
        // This function doesn't access other Firebase project resources, so it uses a limited service account.
        serviceAccount:
            "my-limited-access-sa@", // or prefer the full form: "my-limited-access-sa@my-project.iam.gserviceaccount.com"
    },
    (request, response) => {
        response.send("Hello from Firebase!");
    },
);

หากต้องการตั้งค่าบัญชีบริการเดียวกันสำหรับฟังก์ชันทั้งหมด คุณสามารถทำได้ด้วยฟังก์ชัน setGlobalOptions

ตั้งค่าการหมดเวลาและการจัดสรรหน่วยความจำ

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

  • ฟังก์ชัน HTTP และฟังก์ชันที่เรียกใช้ได้: 3,600 วินาที (60 นาที)
  • ฟังก์ชันคิวงาน/ตามกำหนดเวลา: 1,800 วินาที (30 นาที)
  • ฟังก์ชันอื่นๆ ที่ขับเคลื่อนด้วยเหตุการณ์: 540 วินาที (9 นาที)

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

วิธีตั้งค่าการจัดสรรหน่วยความจำและระยะหมดเวลาในคอนโซล Google Cloud

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

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

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

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

หากต้องการให้ฟังก์ชันรุ่นที่ 2 ทำงานเหมือนรุ่นที่ 1 ให้ตั้งค่าเริ่มต้นของรุ่นที่ 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