โควต้าและขีดจำกัด

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

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

โควต้าสำหรับ Google Cloud Functions ครอบคลุม 3 ด้านต่อไปนี้

  • ขีดจำกัดทรัพยากร

    ปัจจัยเหล่านี้มีผลต่อจำนวนทรัพยากรรวมที่ฟังก์ชันใช้ได้

  • ขีดจำกัดเวลา

    ปัจจัยเหล่านี้มีผลต่อระยะเวลาที่ทำงานได้

  • ขีดจำกัดอัตรา

    ซึ่งจะส่งผลต่ออัตราที่คุณจะเรียกใช้ Cloud Functions API เพื่อจัดการฟังก์ชันได้

ขีดจำกัดประเภทต่างๆ มีรายละเอียดเพิ่มเติมด้านล่าง เราจะระบุความแตกต่างระหว่างขีดจำกัดสำหรับ Cloud Functions (รุ่นที่ 1) และ Cloud Functions (รุ่นที่ 2) หากมี

ขีดจำกัดทรัพยากร

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

โควต้า คำอธิบาย จำกัด (รุ่นที่ 1) จำกัด (รุ่นที่ 2) เพิ่มได้ ขอบเขต
จำนวนฟังก์ชัน จำนวนฟังก์ชันทั้งหมดที่ใช้งานได้ในแต่ละภูมิภาค 1,000 ราย 1,000 ลบจำนวนบริการ Cloud Run ที่ทำให้ใช้งานได้ ไม่ได้ ต่อภูมิภาค
ขนาดการทำให้ใช้งานได้สูงสุด ขนาดสูงสุดของการทำให้ฟังก์ชันใช้งานได้ 1 รายการ 100 MB (บีบอัด) สําหรับแหล่งที่มา
500 MB (ไม่บีบอัด) สำหรับแหล่งที่มาและโมดูล
ไม่มี ไม่ได้ ต่อฟังก์ชัน
ขนาดสูงสุดของคำขอ HTTP ที่ไม่ได้บีบอัด ข้อมูลที่ส่งไปยังฟังก์ชัน HTTP ในคำขอ HTTP 10 MB 32MB ไม่ได้ ต่อการเรียกใช้
ขนาดการตอบสนอง HTTP สูงสุดที่ไม่ได้บีบอัด ข้อมูลที่ส่งจากฟังก์ชัน HTTP ในการตอบสนอง HTTP 10 MB 10 MB สำหรับการสตรีมคำตอบ
32 MB สำหรับคำตอบที่ไม่ใช่สตรีมมิง
ไม่ได้ ต่อการเรียกใช้
ขนาดเหตุการณ์สูงสุดสําหรับฟังก์ชันที่ขับเคลื่อนด้วยเหตุการณ์ ข้อมูลที่ส่งในเหตุการณ์ไปยังฟังก์ชันเบื้องหลัง 10 MB 512KB สำหรับกิจกรรม Eventarc
10 MB สำหรับกิจกรรมเดิม
ไม่ได้ ต่อเหตุการณ์
หน่วยความจำฟังก์ชันสูงสุด จำนวนหน่วยความจำที่อินสแตนซ์ของฟังก์ชันแต่ละรายการใช้ได้ 8 GB 32 GB ไม่ได้ ต่อฟังก์ชัน

ขีดจำกัดเวลา

โควต้า คำอธิบาย จำกัด (รุ่นที่ 1) จำกัด (รุ่นที่ 2) เพิ่มได้ ขอบเขต
ระยะเวลาสูงสุดของฟังก์ชัน ระยะเวลาสูงสุดที่ฟังก์ชันทำงานได้ก่อนที่จะถูกบังคับให้สิ้นสุด 540 วินาที 60 นาทีสำหรับฟังก์ชัน HTTP
9 นาทีสำหรับฟังก์ชันที่ขับเคลื่อนด้วยเหตุการณ์
ไม่ได้ ต่อการเรียกใช้

ขีดจำกัดอัตรา

โควต้า คำอธิบาย จำกัด (รุ่นที่ 1) จำกัด (รุ่นที่ 2) เพิ่มได้ ขอบเขต
การเรียก API (READ) การเรียกใช้เพื่ออธิบายหรือแสดงรายการฟังก์ชันผ่าน Cloud Functions API 5,000 ต่อ 100 วินาที 1200 ต่อ 60 วินาที สำหรับรุ่นที่ 1 เท่านั้น ต่อโปรเจ็กต์ (รุ่นที่ 1)
ต่อภูมิภาค (รุ่นที่ 2)
การเรียก API (เขียน) การเรียกใช้ฟังก์ชันหรือลบฟังก์ชันผ่าน Cloud Functions API 80 ต่อ 100 วินาที 60 ต่อ 60 วินาที ไม่ 1 ต่อโปรเจ็กต์ (รุ่นที่ 1)
ต่อภูมิภาค (รุ่นที่ 2)
การเรียก API (CALL) การเรียก API "เรียกใช้" 16 ต่อ 100 วินาที ไม่มี ไม่ 2 ต่อโปรเจ็กต์

ความสามารถในการปรับขนาด

ฟังก์ชันระบบคลาวด์ที่เรียกใช้โดย HTTP จะปรับขนาดอย่างรวดเร็วเพื่อจัดการการรับส่งข้อมูลขาเข้า ขณะที่ฟังก์ชันในเบื้องหลังจะค่อยๆ ปรับขนาดมากขึ้น ความสามารถในการปรับขนาดของฟังก์ชัน จะกำหนดโดยปัจจัย 2-3 อย่าง ได้แก่

  • ระยะเวลาที่ต้องใช้เพื่อให้ฟังก์ชันดำเนินการเสร็จสมบูรณ์ (โดยทั่วไปฟังก์ชันการใช้งานสั้นๆ จะเพิ่มทรัพยากรเพื่อรองรับคำขอหลายรายการพร้อมกันมากขึ้น)
  • ระยะเวลาที่ฟังก์ชันใช้ในการเริ่มต้นใช้งานบน Cold Start
  • อัตราข้อผิดพลาดของฟังก์ชัน
  • ปัจจัยชั่วคราว เช่น ภาระงานระดับภูมิภาคและความจุของศูนย์ข้อมูล

ฟังก์ชันเบื้องหลังมีขีดจำกัดเพิ่มเติมตามที่อธิบายไว้ด้านล่าง ขีดจำกัดเหล่านี้ไม่มีผลกับฟังก์ชัน HTTP รุ่นที่ 1

โควต้าเพิ่มเติมสำหรับฟังก์ชันในเบื้องหลัง

โควต้า คำอธิบาย ขีดจำกัด เพิ่มได้ ขอบเขต เวอร์ชันผลิตภัณฑ์
จำนวนการเรียกใช้พร้อมกันสูงสุด จำนวนการเรียกใช้พร้อมกันสูงสุดของฟังก์ชันเดียว
ตัวอย่าง: หากการจัดการแต่ละเหตุการณ์ใช้เวลา 100 วินาที อัตราการเรียกใช้จะจำกัดอยู่ที่ 30 ต่อวินาทีโดยเฉลี่ย
3,000 ได้ ต่อฟังก์ชัน รุ่นที่ 1 เท่านั้น
อัตราการเรียกใช้สูงสุด อัตราสูงสุดของเหตุการณ์ที่จัดการโดยฟังก์ชันเดียว
ตัวอย่าง: หากการจัดการเหตุการณ์ใช้เวลา 100 มิลลิวินาที อัตราการเรียกใช้จะจำกัดอยู่ที่ 1,000 ต่อวินาทีแม้ว่าจะมีการจัดการคำขอเพียง 100 คำขอโดยเฉลี่ยโดยเฉลี่ยก็ตาม
1,000 ต่อวินาที ไม่ได้ ต่อฟังก์ชัน รุ่นที่ 1 เท่านั้น
ขนาดสูงสุดของข้อมูลเหตุการณ์ที่เกิดขึ้นพร้อมกัน ขนาดรวมสูงสุดของเหตุการณ์ขาเข้าต่อการเรียกใช้ฟังก์ชันเดียวพร้อมกัน
ตัวอย่าง: หากเหตุการณ์มีขนาด 1 MB และประมวลผลใช้เวลา 10 วินาที อัตราเฉลี่ยจะเป็น 1 เหตุการณ์ต่อวินาที เนื่องจากระบบจะไม่ประมวลผลเหตุการณ์ที่ 11 จนกว่าเหตุการณ์ 11 ใน 10 เหตุการณ์แรกจะเสร็จสิ้น
10 MB ไม่ได้ ต่อฟังก์ชัน รุ่นที่ 1 และรุ่นที่ 2
อัตราการส่งข้อมูลสูงสุดของเหตุการณ์ขาเข้า อัตราการส่งข้อมูลสูงสุดของเหตุการณ์ขาเข้าไปยังฟังก์ชันเดียว
ตัวอย่าง: หากเหตุการณ์มีขนาด 1 MB อัตราการเรียกใช้จะได้สูงสุด 10 ต่อวินาที แม้ว่าฟังก์ชันจะเสร็จสิ้นภายใน 100 มิลลิวินาที
10 MB ต่อวินาที ไม่ได้ ต่อฟังก์ชัน รุ่นที่ 1 และรุ่นที่ 2

เมื่อถึงขีดจำกัดโควต้า

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

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

ขีดจำกัดโควต้าสำหรับการทำให้ใช้งานได้ของ Firebase CLI

สำหรับแต่ละฟังก์ชันที่ Firebase CLI ใช้งานได้ อัตราและขีดจำกัดเวลาประเภทต่อไปนี้จะได้รับผลกระทบ

  • การเรียก API (READ) - 1 การเรียกต่อการทำให้ใช้งานได้ 1 ครั้ง ไม่ว่าจะมีฟังก์ชันใดก็ตาม
    • ขีดจำกัด: 5,000 ต่อ 100 วินาที
  • การเรียก API (WRITE) - การเรียก 1 รายการต่อฟังก์ชัน
    • ขีดจำกัด: 80 ต่อ 100 วินาที

โปรดดูข้อมูลอ้างอิง Firebase CLI