Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

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

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

คุณสามารถปรับใช้ ลบ และแก้ไขฟังก์ชันโดยใช้คำสั่ง 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 หรือ preserveExternalChanges CLI และคุณ ไม่ ต้องการให้ค่าเหล่านี้ถูกแทนที่ในการปรับใช้แต่ละครั้ง ให้ตั้งค่า 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 16
  • Node.js14

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

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

  "engines": {"node": "16"}

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

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

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

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

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

ตามค่าเริ่มต้น Cloud Functions for 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
    });

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

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

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

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

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

หากฟังก์ชัน 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
    });

ค่าสูงสุดสำหรับ 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. คลิก บันทึก เพื่ออัปเดตฟังก์ชัน