ลองใช้ฟังก์ชันแบบอะซิงโครนัสอีกครั้ง

เอกสารนี้อธิบายวิธีขอแบบอะซิงโครนัส (ไม่ใช่ HTTPS) ฟังก์ชันพื้นหลังเพื่อลองใหม่เมื่อล้มเหลว

ความหมายของการลองอีกครั้ง

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

สำหรับฟังก์ชันรุ่นที่ 2 กรอบเวลาการลองใหม่นี้จะหมดอายุหลังจากผ่านไป 24 ชั่วโมง รหัสจะหมดอายุสำหรับฟังก์ชันรุ่นที่ 1 หลังผ่านไป 7 วัน Cloud Functions ทดลองใช้ฟังก์ชันที่ขับเคลื่อนด้วยเหตุการณ์ที่สร้างขึ้นใหม่ซ้ำโดยใช้ กลยุทธ์ Backoff แบบทวีคูณซึ่งมี Backoff เพิ่มขึ้นระหว่าง 10 และ 600 วินาที นโยบายนี้จะใช้กับฟังก์ชันใหม่ ครั้งแรกที่ทำให้ใช้งานได้ จะไม่มีผลย้อนหลังกับ ที่มีการทำให้ใช้งานได้ครั้งแรก ก่อนการเปลี่ยนแปลงที่อธิบายไว้ใน บันทึกประจำรุ่นนี้ จะมีผล แม้ว่าคุณจะทำให้ฟังก์ชันใช้งานได้อีกครั้งก็ตาม

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

เหตุใดฟังก์ชันที่ขับเคลื่อนด้วยเหตุการณ์จึงไม่สําเร็จ

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

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

• ฟังก์ชันดังกล่าวมีข้อบกพร่องและรันไทม์จะส่งข้อยกเว้น
• ฟังก์ชันเข้าถึงปลายทางของบริการไม่ได้ หรือหมดเวลาขณะพยายาม แบบนั้น
• ฟังก์ชันตั้งใจจะส่งข้อยกเว้น (ตัวอย่างเช่น เมื่อพารามิเตอร์ ไม่ผ่านการตรวจสอบ)
• ฟังก์ชัน Node.js แสดงผลสัญญาที่ถูกปฏิเสธ หรือส่งค่าที่ไม่ใช่ null ไปยัง Callback

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

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

เปิดหรือปิดใช้การลองใหม่

กำหนดค่าการลองใหม่จากคอนโซล

หากคุณกำลังสร้างฟังก์ชันใหม่ ให้ทำดังนี้

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

หากคุณกำลังอัปเดตฟังก์ชันที่มีอยู่ ให้ทำดังนี้

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

กำหนดค่าการลองใหม่จากโค้ดฟังก์ชัน

เมื่อใช้ Cloud Functions for Firebase คุณจะเปิดใช้การลองใหม่ในโค้ดได้ ในการดำเนินการนี้สำหรับฟังก์ชันพื้นหลัง เช่น functions.foo.onBar(myHandler); ใช้ runWith และกำหนดค่านโยบายความล้มเหลว

functions.runWith({failurePolicy: true}).foo.onBar(myHandler);

การตั้งค่า true ตามที่แสดงจะกําหนดค่าฟังก์ชันให้ลองอีกครั้งเมื่อล้มเหลว

แนวทางปฏิบัติแนะนำ

ส่วนนี้จะอธิบายแนวทางปฏิบัติแนะนำสำหรับการลองใหม่

ใช้การลองอีกครั้งเพื่อจัดการข้อผิดพลาดชั่วคราว

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

กำหนดเงื่อนไขสิ้นสุดเพื่อหลีกเลี่ยงการวนลูปซ้ำแบบไม่สิ้นสุด

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

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

ตัวอย่างเช่น ข้อมูลโค้ดนี้จะทิ้งเหตุการณ์ทั้งหมดที่เก่ากว่า 10 วินาที

const eventAgeMs = Date.now() - Date.parse(event.timestamp);
const eventMaxAgeMs = 10000;
if (eventAgeMs > eventMaxAgeMs) {
  console.log(`Dropping event ${event} with age[ms]: ${eventAgeMs}`);
  callback();
  return;
}

ใช้ catch พร้อมสัญญา

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

ตัวอย่างสิ่งที่คุณควรทำมีดังนี้

return doFooAsync().catch((err) => {
    if (isFatal(err)) {
        console.error(`Fatal error ${err}`);
    }
    return Promise.reject(err);
});

กำหนดให้ฟังก์ชันที่ขับเคลื่อนด้วยเหตุการณ์ซึ่งลองอีกครั้งได้เป็นเอกลักษณ์

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

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

กำหนดค่านโยบายการลองอีกครั้ง

คุณอาจต้องการกำหนดค่าฟังก์ชัน โดยขึ้นอยู่กับความต้องการสำหรับฟังก์ชัน การลองอีกครั้งโดยตรง ซึ่งจะช่วยให้คุณตั้งค่าชุดค่าผสมของ ดังต่อไปนี้:

• ลดกรอบเวลาการลองใหม่จาก 7 วันให้เหลือเพียง 10 นาที
• เปลี่ยนเวลา Backoff ต่ำสุดและสูงสุดสำหรับ Exponential Backoff กลยุทธ์การลองอีกครั้ง
• โปรดเปลี่ยนกลยุทธ์การลองใหม่เพื่อลองอีกครั้ง
• กําหนดค่า หัวข้อจดหมายที่ส่งไม่ได้
• กำหนดจำนวนครั้งสูงสุดและต่ำสุดในการนำส่ง

วิธีกำหนดค่านโยบายการลองอีกครั้ง

1. เขียนฟังก์ชัน HTTP
2. ใช้ Pub/Sub API เพื่อสร้างการสมัครใช้บริการ Pub/Sub โดยระบุ URL ของ เป็นเป้าหมาย

ดูเอกสารประกอบ Pub/Sub เกี่ยวกับการจัดการความล้มเหลว เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับการกำหนดค่า Pub/Sub โดยตรง