จัดการฟังก์ชัน (รุ่นที่ 1)

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

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

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

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

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

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

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

หากต้องการเปลี่ยนชื่อฟังก์ชัน ให้สร้างฟังก์ชันเวอร์ชันใหม่ที่เปลี่ยนชื่อแล้วในซอร์สโค้ด จากนั้นเรียกใช้คำสั่งการทำให้ใช้งานได้ 2 คำสั่งแยกกัน คำสั่งแรกจะทำให้ฟังก์ชันที่มีชื่อใหม่ใช้งานได้ และคำสั่งที่ 2 จะนำฟังก์ชันเวอร์ชันที่ทำให้ใช้งานได้ก่อนหน้านี้ออก ตัวอย่างเช่น หากคุณมีฟังก์ชัน Node.js ที่ชื่อว่า webhook ซึ่งคุณต้องการ เปลี่ยนเป็น webhookNew ให้แก้ไขโค้ดดังนี้

// before
const functions = require('firebase-functions/v1');

exports.webhook = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

// after
const functions = require('firebase-functions/v1');

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

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

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

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

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

// before
const functions = require('firebase-functions/v1');

exports.webhook = functions
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

// after
const functions = require('firebase-functions/v1');

exports.webhookAsia = functions
    .region('asia-northeast1')
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

จากนั้นทำให้ใช้งานได้โดยเรียกใช้คำสั่งต่อไปนี้

firebase deploy --only functions:webhookAsia

ตอนนี้มีฟังก์ชันที่เหมือนกัน 2 รายการทำงานอยู่ โดย webhook ทำงานใน us-central1, และ webhookAsia ทำงานใน asia-northeast1

จากนั้นลบ webhook

firebase functions:delete webhook

ตอนนี้มีฟังก์ชันเพียงรายการเดียวคือ webhookAsia ซึ่งทำงานใน asia-northeast1

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

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

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

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

ตัวอย่างเช่น หากคุณมีฟังก์ชัน Node.js ที่ชื่อว่า objectChanged ซึ่งมีประเภทเหตุการณ์ onChange แบบเดิม และต้องการเปลี่ยนเป็น onFinalize ให้เปลี่ยนชื่อฟังก์ชันก่อน แล้วแก้ไขให้มีประเภทเหตุการณ์ onFinalize

// before
const functions = require('firebase-functions/v1');

exports.objectChanged = functions.storage.object().onChange((object) => {
    return console.log('File name is: ', object.name);
});

// after
const functions = require('firebase-functions/v1');

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

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

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

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

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

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

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

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

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

  "engines": {"node": "22"}

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

  {
    "functions": {
      "runtime": "nodejs22"
    }
  }

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

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

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

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

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

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

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

const functions = require("firebase-functions/v1");

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

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

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

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

import functions from "firebase-functions/v1";

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

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

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

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

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

ลดจำนวน 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

หมายเหตุ: การเก็บอินสแตนซ์ขั้นต่ำให้ทำงานอยู่จะทำให้เกิดค่าใช้จ่ายในการเรียกเก็บเงินตามอัตราการใช้งานน้อย โดยทั่วไป การเก็บอินสแตนซ์ฟังก์ชันที่ไม่มีการใช้งาน 1 รายการให้พร้อมใช้งานจะมีค่าใช้จ่ายน้อยกว่า $6.00 ต่อเดือน Firebase CLI จะแสดงค่าใช้จ่ายโดยประมาณเมื่อทำให้ฟังก์ชันที่มีอินสแตนซ์ขั้นต่ำที่สงวนไว้ใช้งานได้ โปรดดูราคาของ Cloud Functions เพื่อคำนวณค่าใช้จ่าย

สิ่งที่คุณควรพิจารณาเมื่อตั้งค่า minInstances มีดังนี้

หาก Cloud Functions for Firebase ปรับขนาดแอปของคุณให้สูงกว่าการตั้งค่า minInstances คุณจะพบ Cold Start สำหรับแต่ละอินสแตนซ์ที่สูงกว่าเกณฑ์นั้น
Cold Start ส่งผลกระทบมากที่สุดต่อแอปที่มีการรับส่งข้อมูลเป็นช่วงๆ หากแอปของคุณมีการรับส่งข้อมูลเป็นช่วงๆ และคุณตั้งค่า minInstances ให้สูงพอที่จะลด Cold Start ในแต่ละครั้งที่การรับส่งข้อมูลเพิ่มขึ้น คุณจะเห็นเวลาในการตอบสนองลดลงอย่างมาก สำหรับแอปที่มีการรับส่งข้อมูลคงที่ Cold Start ไม่น่าจะส่งผลกระทบอย่างมากต่อประสิทธิภาพ
การตั้งค่าอินสแตนซ์ขั้นต่ำอาจสมเหตุสมผลสำหรับสภาพแวดล้อมที่ใช้งานจริง แต่โดยปกติแล้วควรหลีกเลี่ยงในสภาพแวดล้อมการทดสอบ หากต้องการปรับขนาดเป็น 0 ในโปรเจ็กต์ทดสอบ แต่ยังคงลด Cold Start ในโปรเจ็กต์ที่ใช้งานจริง คุณสามารถตั้งค่า 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

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

บัญชีบริการเริ่มต้นสำหรับฟังก์ชันรุ่นที่ 1 PROJECT_ID@appspot.gserviceaccount.com (ชื่อ App Engine default service account) มีสิทธิ์ที่หลากหลายเพื่อให้คุณโต้ตอบกับ บริการอื่นๆ ของ Firebase และ Google Cloud ได้

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

const functions = require("firebase-functions/v1");

exports.helloWorld = functions
    .runWith({
        // 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"
    })
    .https.onRequest((request, response) => {
        response.send("Hello from Firebase!");
    });

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

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

หากต้องการตั้งค่าการจัดสรรหน่วยความจำและระยะหมดเวลาในซอร์สโค้ดของฟังก์ชัน ให้ใช้ runWith พารามิเตอร์ที่เปิดตัวใน Firebase SDK สำหรับ Cloud Functions 2.0.0 ตัวเลือกการรันไทม์นี้ยอมรับ ออบเจ็กต์ JSON ที่เป็นไปตาม RuntimeOptions อินเทอร์เฟซ ซึ่งกำหนดค่าสำหรับ timeoutSeconds และ memory ตัวอย่างเช่น ฟังก์ชัน Storage นี้ใช้หน่วยความจำ 1 GB และหมดเวลาหลังจากผ่านไป 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 GHz
2GB — 2.4 GHz
4GB — 4.8 GHz
8GB — 4.8 GHz

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

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