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

หน้านี้แสดงรายละเอียดขีดจำกัดตามการใช้งานที่รองรับการปรับขนาดสำหรับ 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 ที่ทำให้ใช้งานได้ ไม่ ต่อภูมิภาค
ขนาดการทำให้ใช้งานได้สูงสุด ขนาดสูงสุดของการใช้งานฟังก์ชันเดียว 100 MB (บีบอัด) สำหรับแหล่งที่มา
500 MB (ไม่บีบอัด) สำหรับแหล่งที่มาและโมดูล
ไม่มี ไม่ ต่อฟังก์ชัน
ขนาดคำขอ HTTP สูงสุดที่ไม่มีการบีบอัด ข้อมูลที่ส่งไปยังฟังก์ชัน HTTP ในคําขอ HTTP 10MB 32MB ไม่ ต่อคำขอ
ขนาดการตอบกลับ HTTP สูงสุดที่ไม่มีการบีบอัด ข้อมูลที่ส่งจากฟังก์ชัน HTTP ในการตอบกลับ HTTP 10MB 10 MB สําหรับการสตรีมคําตอบ
32 MB สําหรับคําตอบแบบไม่สตรีม
ไม่ ต่อคำขอ
ขนาดเหตุการณ์สูงสุดสำหรับฟังก์ชันที่ขับเคลื่อนด้วยเหตุการณ์ ข้อมูลที่ส่งในเหตุการณ์ไปยังฟังก์ชันในเบื้องหลัง 10MB 512 KB สำหรับเหตุการณ์ Eventarc
10 MB สำหรับกิจกรรมเดิม
ไม่ ต่อเหตุการณ์
หน่วยความจำของฟังก์ชันสูงสุด จำนวนหน่วยความจำที่อินสแตนซ์ฟังก์ชันแต่ละรายการใช้ได้ 8 GB 32 GB ไม่ ต่อฟังก์ชัน
หน่วยความจำสูงสุดของโปรเจ็กต์ ปริมาณหน่วยความจำในหน่วย "โดย" ที่โปรเจ็กต์สามารถใช้ได้ ซึ่งจะวัดจากผลรวมของหน่วยความจำที่ผู้ใช้ขอในอินสแตนซ์ของฟังก์ชันต่างๆ ในช่วงเวลา 1 นาที ขึ้นอยู่กับภูมิภาคที่เลือก ขีดจำกัดนี้อาจสูงขึ้นในภูมิภาคที่มีความจุสูงหรือต่ำกว่าในภูมิภาคที่เพิ่งเปิด ไม่มี ใช่ ต่อโปรเจ็กต์และภูมิภาค
CPU ของโปรเจ็กต์สูงสุด จำนวน CPU ในหน่วยมิลลิวินาที vCPU ที่โปรเจ็กต์สามารถใช้ได้ ซึ่งจะวัดจากผลรวมทั้งหมดของ CPU ที่ผู้ใช้ขอในอินสแตนซ์ฟังก์ชันต่างๆ ในช่วงเวลา 1 นาที ขึ้นอยู่กับภูมิภาคที่เลือก ขีดจํากัดนี้อาจสูงกว่าในภูมิภาคที่มีขีดจํากัดสูง หรือต่ำกว่าในภูมิภาคที่เพิ่งเปิด ไม่มี ใช่ ต่อโปรเจ็กต์และภูมิภาค

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

โควต้า คำอธิบาย ขีดจำกัด (รุ่นที่ 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 "call" 16 ครั้งต่อ 100 วินาที ไม่มี ไม่ 2 ต่อโปรเจ็กต์

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

Cloud Functions ที่เรียกใช้โดย HTTP เพิ่มทรัพยากรอย่างรวดเร็วเพื่อจัดการการรับส่งข้อมูลขาเข้า ขณะที่ฟังก์ชันพื้นหลังจะค่อยๆ ปรับขนาดมากขึ้น ความสามารถในการปรับขนาดของฟังก์ชันขึ้นอยู่กับปัจจัยหลายประการ ซึ่งรวมถึง

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

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

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

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

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

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

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

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

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

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

ดูเอกสารอ้างอิง Firebase CLI เพิ่มเติม