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

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

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

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

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

หมายเหตุ: หากคุณทริกเกอร์ฟังก์ชันโดยใช้ Pub/Sub ไม่ว่าจะผ่านทาง ฟังก์ชันที่ขับเคลื่อนด้วยเหตุการณ์ หรือ เป็นเป้าหมาย HTTP ของการพุช โปรดทราบว่าข้อความ Pub/Sub มีการเข้ารหัสฐาน 64 ข้อความ Pub/Sub ขนาด 10 MB - ขนาดสูงสุด รองรับ - มีขนาดใหญ่กว่า 10 MB เมื่อเข้ารหัส จึงอาจมีขนาดเกิน ขนาดสูงสุดที่ Cloud Functions

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

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

¹ คุณไม่สามารถเพิ่มการเขียน โควต้า โควต้าที่ไม่เพียงพอมักเกิดจากสาเหตุใดสาเหตุหนึ่งต่อไปนี้

• การใช้ระบบ CI/CD ที่ติดตั้งใช้งานฟังก์ชันหลายรายการพร้อมกันหรือตามลำดับในอัตราที่สูง
• การใช้ Firebase CLI เพื่อทำให้ฟังก์ชันหลายรายการใช้งานได้พร้อมกัน

ในแต่ละกรณี คุณสามารถหลีกเลี่ยงการถึงโควต้านี้ได้โดยเปลี่ยนอัตรา การใช้งานจริง ตัวอย่างเช่น หากคุณกำลังทำให้ใช้งานได้โดยใช้ Firebase CLI ใช้ แฟล็ก --only เพื่อทำให้ฟังก์ชันแต่ละรายการใช้งานได้

² CALL API มีผลกับ Cloud Functions (รุ่นที่ 1) คุณจะเพิ่มโควต้าการโทรไม่ได้ ไม่เพียงพอ โดยปกติโควต้าจะเกิดขึ้นหากคุณใช้ API นี้เพื่อเรียกใช้ฟังก์ชันโดยไม่ได้ตั้งใจ เวอร์ชันที่ใช้งานจริง โปรดทราบว่า API นี้มีไว้สําหรับการทดสอบผ่าน Cloud Console หรือ gcloud functions call CLI และไม่สามารถรองรับการเข้าชมจำนวนมาก

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

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 เพิ่มเติม