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

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

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

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

// 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");
});

# 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. ปรับใช้ฟังก์ชันที่เปลี่ยนชื่อ ซึ่งส่งผลให้มีการเรียกใช้โค้ดเดียวกันชั่วคราวในทั้งสองชุดของภูมิภาค
3. ลบฟังก์ชั่นก่อนหน้า

ตัวอย่างเช่น หากคุณมีฟังก์ชันที่เรียกใช้ Cloud Firestore ซึ่งขณะนี้อยู่ในขอบเขตฟังก์ชันเริ่มต้นของ us-central1 และคุณต้องการย้ายไปยัง asia-northeast1 คุณต้องแก้ไขซอร์สโค้ดของคุณก่อนเพื่อเปลี่ยนชื่อฟังก์ชันและแก้ไข ศาสนา.

// before
exports.firestoreTrigger = onDocumentCreated(
  "my-collection/{docId}",
  (event) => {},
);

// after
exports.firestoreTriggerAsia = onDocumentCreated(
  {
    document: "my-collection/{docId}",
    region: "asia-northeast1",
  },
  (event) => {},
);

# 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

ขณะนี้มีสองฟังก์ชันที่เหมือนกันที่ทำงานอยู่: firestoreTrigger ทำงานใน us-central1 และ firestoreTriggerAsia ทำงานใน asia-northeast1

จากนั้นลบ firestoreTrigger :

firebase functions:delete firestoreTrigger

ขณะนี้มีเพียงฟังก์ชันเดียวเท่านั้น - firestoreTriggerAsia ซึ่งทำงานใน asia-northeast1

เปลี่ยนประเภททริกเกอร์ของฟังก์ชัน

เมื่อคุณพัฒนา Cloud Functions สำหรับการปรับใช้ Firebase เมื่อเวลาผ่านไป คุณอาจต้องเปลี่ยนประเภททริกเกอร์ของฟังก์ชันด้วยเหตุผลหลายประการ ตัวอย่างเช่น คุณอาจต้องการเปลี่ยนจากเหตุการณ์ Firebase Realtime Database หรือ Cloud Firestore ประเภทหนึ่งไปเป็นประเภทอื่น

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

1. แก้ไขซอร์สโค้ดเพื่อรวมฟังก์ชันใหม่เข้ากับประเภททริกเกอร์ที่ต้องการ
2. ปรับใช้ฟังก์ชัน ซึ่งส่งผลให้มีการเรียกใช้ฟังก์ชันทั้งเก่าและใหม่เป็นการชั่วคราว
3. ลบฟังก์ชันเก่าออกจากการผลิตอย่างชัดเจนโดยใช้ Firebase CLI

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

// before
const {onObjectDeleted} = require("firebase-functions/v2/storage");

exports.objectDeleted = onObjectDeleted((event) => {
    // ...
});

// after
const {onObjectArchived} = require("firebase-functions/v2/storage");

exports.objectArchived = onObjectArchived((event) => {
    // ...
});

# 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 หรือ 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 สำหรับฟังก์ชันคลาวด์อนุญาตให้เลือกรันไทม์ Node.js ได้ คุณสามารถเลือกที่จะรันฟังก์ชันทั้งหมดในโปรเจ็กต์เฉพาะบนสภาพแวดล้อมรันไทม์ที่สอดคล้องกับเวอร์ชัน Node.js ที่รองรับเหล่านี้:

• Node.js 20 (ดูตัวอย่าง)
• โหนด js 18
• โหนด js16
• โหนด js 14

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

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

  "engines": {"node": "18"}

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

  {
    "functions": {
      "runtime": "nodejs18" // or nodejs14, nodejs16 or nodejs20
    }
  }

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

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

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

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

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

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

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

ควบคุมพฤติกรรมการปรับขนาด

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

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

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

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

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

อนุญาตการร้องขอที่เกิดขึ้นพร้อมกัน

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

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

สถานการณ์จำลองที่เรียบง่ายนี้แสดงให้เห็นถึงประสิทธิภาพที่อาจเกิดขึ้นจากการทำงานพร้อมกัน ในความเป็นจริง พฤติกรรมการปรับขนาดเพื่อปรับประสิทธิภาพให้เหมาะสมและลดการสตาร์ทขณะทำงานพร้อมกันนั้นซับซ้อนกว่า ความสอดคล้องกันในฟังก์ชันคลาวด์สำหรับ Firebase รุ่นที่ 2 ขับเคลื่อนโดย Cloud Run และเป็นไปตามกฎของ Cloud Run เกี่ยวกับ การปรับขนาดอินสแตนซ์คอนเทนเนอร์ อัตโนมัติ

เมื่อทดลองการตั้งค่าการทำงานพร้อมกันที่สูงขึ้นในฟังก์ชันคลาวด์สำหรับ Firebase (รุ่นที่ 2) โปรดคำนึงถึงสิ่งต่อไปนี้:

• การตั้งค่าการทำงานพร้อมกันที่สูงขึ้นอาจต้องใช้ CPU และ RAM ที่สูงขึ้นเพื่อประสิทธิภาพสูงสุดจนกว่าจะถึงขีดจำกัดในทางปฏิบัติ ตัวอย่างเช่น ฟังก์ชันที่ประมวลผลรูปภาพหรือวิดีโอจำนวนมากอาจขาดทรัพยากรในการจัดการคำขอพร้อมกัน 1,000 รายการ แม้ว่าการตั้งค่า CPU และ RAM จะถูกขยายให้ใหญ่สุดก็ตาม
• เนื่องจากฟังก์ชันคลาวด์สำหรับ Firebase (รุ่นที่ 2) ขับเคลื่อนโดย Cloud Run คุณจึงสามารถอ้างอิงคำแนะนำของ Google Cloud เพื่อ เพิ่มประสิทธิภาพการทำงาน พร้อมกันได้
• ตรวจสอบให้แน่ใจว่าได้ทดสอบการทำงานพร้อมกันหลายสกุลเงินอย่างละเอียดในสภาพแวดล้อมการทดสอบ ก่อนที่จะสลับไปใช้การทำงานพร้อมกันหลายสกุลเงินในการใช้งานจริง

รักษาความอบอุ่นให้กับอินสแตนซ์ในจำนวนขั้นต่ำ

คุณสามารถกำหนดจำนวนอินสแตนซ์ขั้นต่ำสำหรับฟังก์ชันในซอร์สโค้ดได้ ตัวอย่างเช่น ฟังก์ชันนี้ตั้งค่าอินสแตนซ์อย่างน้อย 5 รายการเพื่อรักษาความอบอุ่น:

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
  }
);

@https_fn.on_call(min_instances=5)
def get_autocomplete_response(event: https_fn.CallableRequest) -> https_fn.Response:

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

• หาก Cloud Functions สำหรับ Firebase ปรับขนาดแอปของคุณให้สูงกว่าการตั้งค่าของคุณ คุณจะพบกับ Cold Start สำหรับแต่ละอินสแตนซ์ที่อยู่เหนือเกณฑ์ดังกล่าว
• การสตาร์ทเย็นมีผลกระทบร้ายแรงที่สุดกับแอปที่มีการรับส่งข้อมูลที่แหลมคม หากแอปของคุณมีการเข้าชมที่รวดเร็วและคุณตั้งค่าสูงพอที่จะทำให้การเริ่มเย็นลดลงตามการเข้าชมที่เพิ่มขึ้นแต่ละครั้ง คุณจะเห็นเวลาในการตอบสนองลดลงอย่างมาก สำหรับแอปที่มีการรับส่งข้อมูลคงที่ การสตาร์ทขณะเย็นไม่น่าจะส่งผลกระทบอย่างรุนแรงต่อประสิทธิภาพการทำงาน

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

  โหนด 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.`);
    }
  );
  

  หลาม

  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 อินสแตนซ์เพื่อไม่ให้ล้นฐานข้อมูลดั้งเดิมสมมุติ:

const { onMessagePublished } = require("firebase-functions/v2/pubsub");

exports.mirrorevents = onMessagePublished(
  { topic: "topic-name", maxInstances: 100 },
  (event) => {
    // Connect to legacy database
  }
);

@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 วินาที:

exports.convertLargeFile = onObjectFinalized({
  timeoutSeconds: 300,
  memory: "1GiB",
}, (event) => {
  // Do some complicated things that take a lot of memory and time
});

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

แทนที่ค่าเริ่มต้นของ CPU

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

หากคุณต้องการลักษณะการทำงานรุ่นที่ 1 สำหรับฟังก์ชันรุ่นที่ 2 ของคุณ ให้ตั้งค่าเริ่มต้นของรุ่นที่ 1 เป็นตัวเลือกส่วนกลาง:

// Turn off Firebase defaults
setGlobalOptions({ cpu: 'gcf_gen1' });

# Use 1st gen behavior
set_global_options(cpu="gcf_gen1")

สำหรับฟังก์ชันที่ใช้ CPU มาก เจนเนอเรชั่น 2 มอบความยืดหยุ่นในการกำหนดค่า CPU เพิ่มเติม คุณสามารถเพิ่ม CPU ได้ตามฟังก์ชันตามที่แสดง:

// Boost CPU in a function:
export const analyzeImage = onObjectFinalized({ cpu: 2 }, (event) => {
  // computer vision goes here
});

# Boost CPU in a function:
@storage_fn.on_object_finalized(cpu=2)
def analyze_image(event: storage_fn.CloudEvent):
# computer vision goes here