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

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

ปรับใช้ฟังก์ชัน

ในการปรับใช้ฟังก์ชัน ให้รันคำสั่ง Firebase CLI นี้:

firebase deploy --only functions

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

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

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

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

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

ลบฟังก์ชั่น

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

• อย่างชัดเจน ใน Firebase CLI ด้วย functions:delete
• อย่างชัดเจน ใน Google Cloud Console
• โดยนัย โดยการลบฟังก์ชันออกจาก index.js ก่อนปรับใช้

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

การลบฟังก์ชันอย่างชัดเจนใน 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 วิเคราะห์ index.js และลบฟังก์ชันใดๆ ที่ถูกนำออกจากไฟล์ออกจากการผลิต

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

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

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

หากต้องการเปลี่ยนชื่อฟังก์ชัน ให้สร้างฟังก์ชันเวอร์ชันที่เปลี่ยนชื่อใหม่ใน index.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

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

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

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

ตัวอย่างเช่น หากคุณมีฟังก์ชันชื่อ 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

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

จากนั้น ลบ webhook :

firebase functions:delete webhook

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

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

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

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

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

ตัวอย่างเช่น หากคุณมี function 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

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

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

ตามแนวทางปฏิบัติที่ดีที่สุด ตัวเลือกเหล่านี้ (ยกเว้นเวอร์ชัน Node.js) ควรตั้งค่าในออบเจกต์การกำหนดค่าภายในโค้ดฟังก์ชัน ออบเจ็กต์ RuntimeOptions นี้เป็นแหล่งที่มาของความจริงสำหรับตัวเลือกรันไทม์ของฟังก์ชัน และจะแทนที่ตัวเลือกที่ตั้งค่าด้วยวิธีอื่น (เช่น ผ่าน Google Cloud Console หรือ gcloud CLI)

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

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

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

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

Firebase SDK สำหรับ Cloud Functions 2.0.0 และสูงกว่าช่วยให้สามารถเลือกรันไทม์ Node.js ได้ คุณสามารถเลือกที่จะเรียกใช้ฟังก์ชันทั้งหมดในโครงการเฉพาะบนสภาพแวดล้อมรันไทม์ที่สอดคล้องกับ Node.js รุ่นใดรุ่นหนึ่งที่รองรับเหล่านี้:

• Node.js 18
• Node.js 16
• Node.js14

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

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

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

ต้องระบุฟิลด์ engines ต้อง ระบุ Node.js รุ่นใดรุ่นหนึ่งที่รองรับเพื่อให้คุณปรับใช้และเรียกใช้ฟังก์ชันได้

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

ควบคุมพฤติกรรมการปรับสเกล

ตามค่าเริ่มต้น Cloud Functions สำหรับ Firebase จะปรับขนาดจำนวนอินสแตนซ์ที่รันอยู่ตามจำนวนคำขอที่เข้ามา ซึ่งอาจลดจำนวนอินสแตนซ์ลงเป็นศูนย์ในเวลาที่มีปริมาณการใช้งานลดลง อย่างไรก็ตาม หากแอปของคุณต้องการเวลาแฝงที่ลดลงและคุณต้องการจำกัดจำนวนของ 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
    });
index.js

ต่อไปนี้คือสิ่งที่ควรพิจารณาเมื่อตั้งค่าสำหรับ minInstances :

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

• การตั้งค่าอินสแตนซ์ขั้นต่ำอาจเหมาะสมสำหรับสภาพแวดล้อมการผลิต แต่โดยปกติแล้วควรหลีกเลี่ยงในสภาพแวดล้อมการทดสอบ หากต้องการปรับขนาดเป็นศูนย์ในโครงการทดสอบของคุณ แต่ยังคงลดการเริ่มเย็นในโครงการการผลิตของคุณ คุณสามารถตั้ง 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
      });
  index.js
  

จำกัดจำนวนอินสแตนซ์สูงสุดสำหรับฟังก์ชัน

ในการตั้งค่าอินสแตนซ์สูงสุดในซอร์สโค้ดของฟังก์ชัน ให้ใช้เมธอด 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
    });
index.js

หากฟังก์ชัน HTTP ปรับขนาดได้ถึงขีดจำกัด maxInstances คำขอใหม่จะถูกจัดคิวเป็นเวลา 30 วินาที จากนั้นจึงปฏิเสธด้วยรหัสตอบกลับ 429 Too Many Requests หากไม่มีอินสแตนซ์ที่พร้อมใช้งานในขณะนั้น

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

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

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

หากต้องการตั้งค่าการจัดสรรหน่วยความจำและการหมดเวลาในซอร์สโค้ดของฟังก์ชัน ให้ใช้พารามิเตอร์ runWith ที่แนะนำใน Firebase SDK สำหรับ Cloud Functions 2.0.0 ตัวเลือกรันไทม์นี้ยอมรับวัตถุ JSON ที่สอดคล้องกับอินเทอร์เฟ RuntimeOptions ซึ่งกำหนดค่าสำหรับ timeoutSeconds และ memory ตัวอย่างเช่น ฟังก์ชันการจัดเก็บนี้ใช้หน่วยความจำ 1GB และหมดเวลาหลังจาก 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
    });
index.js

ค่าสูงสุดสำหรับ timeoutSeconds คือ 540 หรือ 9 นาที จำนวนหน่วยความจำที่มอบให้กับฟังก์ชันจะสอดคล้องกับ CPU ที่จัดสรรให้กับฟังก์ชัน ตามรายละเอียดในรายการค่าที่ถูกต้องสำหรับ memory นี้ :

• 128MB — 200MHz
• 256MB — 400MHz
• 512MB — 800MHz
• 1GB — 1.4 กิกะเฮิรตซ์
• 2GB — 2.4 กิกะเฮิรตซ์
• 4GB — 4.8 กิกะเฮิรตซ์
• 8GB — 4.8 กิกะเฮิรตซ์

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

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