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

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

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

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

# 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 จะแยกวิเคราะห์แหล่งที่มาและ นำฟังก์ชันที่นำออกจากไฟล์ออกจากการใช้งานจริง

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

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

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

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

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

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

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

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

1. แก้ไขซอร์สโค้ดให้มีฟังก์ชันใหม่ที่มีประเภททริกเกอร์ที่ต้องการ
2. ทําให้ฟังก์ชันใช้งานได้ ซึ่งจะส่งผลให้ฟังก์ชันเก่าและใหม่ทํางานพร้อมกันชั่วคราว
3. ลบฟังก์ชันเก่าออกจากเวอร์ชันที่ใช้งานจริงอย่างชัดเจนโดยใช้ 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 Console หรือ gcloud CLI)

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

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

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

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

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

• Node.js 20
• Node.js 18 (เลิกใช้งานแล้ว)

ดูกำหนดเวลาการสนับสนุนเพื่อดูข้อมูลสำคัญเกี่ยวกับการสนับสนุน 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"
    }
  }

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

ควบคุมลักษณะการทำงานของการปรับขนาด

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

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

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

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

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

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

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