วิธีวิเคราะห์ข้อผิดพลาด OpenAI API ด้านการยืนยันตัวตน การจำกัดอัตรา คำขอหมดเวลา และการตอบกลับผิดรูปแบบอย่างปลอดภัย
คู่มือเชิงปฏิบัติที่คำนึงถึงความเป็นส่วนตัว สำหรับวิเคราะห์ข้อผิดพลาดด้านการยืนยันตัวตน การจำกัดอัตรา คำขอหมดเวลา และการตอบกลับผิดรูปแบบของ OpenAI API โดยไม่เปิดเผยข้อมูลรับรองหรือข้อมูลผู้ใช้
สรุป · TL;DR
วิธีที่ปลอดภัยที่สุดในการแก้ปัญหา OpenAI API คือจำแนกประเภทข้อผิดพลาดก่อนลองส่งคำขอซ้ำ ข้อผิดพลาดด้านการยืนยันตัวตนมักต้องแก้ไข key, องค์กร, โปรเจกต์ หรือการตั้งค่า IP ส่วนข้อผิดพลาดด้านอัตราและโควตาต้องปรับจังหวะการส่งคำขอหรือเปลี่ยนการตั้งค่าทางผู้ดูแลระบบ การหมดเวลาอาจเกิดขึ้นชั่วคราว ส่วนการตอบกลับผิดรูปแบบควรแยกวิเคราะห์ในฐานะปัญหาการรับส่งข้อมูล พร็อกซี หรือการแยกวิเคราะห์ ให้บันทึกข้อมูลเมตาสำหรับวิเคราะห์ ไม่ใช่ข้อมูลรับรองหรือเนื้อหาดิบจากผู้ใช้
ประเด็นสำคัญ
- อย่าส่งคำขอซ้ำเมื่อเกิดข้อผิดพลาดการยืนยันตัวตน 401 หรือข้อผิดพลาดด้านการเรียกเก็บเงินและโควตา ราวกับว่าเป็นข้อผิดพลาดเครือข่ายชั่วคราว
- สำหรับการจำกัดอัตรา 429 และการตอบกลับเซิร์ฟเวอร์ทำงานหนักเกินไป 503 ให้ทำตาม Retry-After หากมี และใช้ exponential backoff ที่กำหนดขอบเขตไว้
- ห้ามเก็บ API key ไว้ในซอร์สโค้ด บันทึก ข้อความข้อยกเว้น หรือแอปพลิเคชันฝั่งไคลเอนต์
- แยกกรณีตอบกลับที่ไม่ใช่ JSON หรือแยกวิเคราะห์ JSON ไม่สำเร็จออกเป็นปัญหาการรับส่งข้อมูลหรือพร็อกซี และบันทึกข้อมูลวินิจฉัยที่ปกปิดข้อมูลและจำกัดความยาวเท่านั้น
- เมื่อแจ้งปัญหาที่เกิดขึ้นต่อเนื่อง ให้ระบุโมเดล รหัสข้อผิดพลาด วันเวลา เขตเวลา และรายละเอียดคำขอที่ผ่านการลบข้อมูลสำคัญแล้ว
ในหน้านี้ (7)
การแก้ข้อผิดพลาด OpenAI API ทำได้ง่ายขึ้นเมื่อแยกประเภทให้ชัดเจนระหว่าง ข้อผิดพลาดจากการตั้งค่า, ข้อผิดพลาดด้านขีดความสามารถ, ปัญหาเครือข่าย และ ปัญหาการแยกวิเคราะห์การตอบกลับ คำถามแรกที่ควรถามเพื่อวินิจฉัยคือ การส่งคำขอซ้ำมีแนวโน้มทำให้ผลลัพธ์เปลี่ยนไปหรือไม่?
โดยทั่วไป การลองซ้ำจะไม่ช่วยให้ข้อผิดพลาด 401 ดีขึ้น ส่วน 429 ที่เกิดจากความเร็วในการส่งคำขออาจดีขึ้นหากเว้นช่วงให้เหมาะสม แต่ 429 ที่เกิดจากเครดิตหมดหรือถึงขีดจำกัดค่าใช้จ่ายต้องแก้ไขที่บัญชีหรือโปรเจกต์ การหมดเวลาอาจเกิดขึ้นชั่วคราว แต่หากเกิดซ้ำก็อาจบ่งชี้ถึงปัญหาเครือข่าย พร็อกซี หรือขนาดคำขอ
ขั้นตอนด้านล่างใช้ JavaScript และแนวคิดของไลบรารี OpenAI อย่างเป็นทางการตามที่อธิบายไว้ใน คู่มือรหัสข้อผิดพลาด OpenAI โค้ดนี้เป็นรูปแบบตัวอย่างประกอบ ไม่ใช่การผสานรวมระบบจริงที่ผ่านการทดสอบแล้ว
ก่อนเริ่มแก้ปัญหา: ปกป้องข้อมูลรับรองและข้อมูลผู้ใช้
ก่อนจำลองข้อผิดพลาด ให้ปฏิบัติตามข้อกำหนดเบื้องต้นเหล่านี้:
- เก็บ API key ไว้ในตัวจัดการความลับฝั่งเซิร์ฟเวอร์หรือตัวแปรสภาพแวดล้อม ห้ามใส่ไว้ในโค้ดเบราว์เซอร์ แอปมือถือ ระบบควบคุมเวอร์ชัน หรือทิกเก็ตขอความช่วยเหลือ
- บันทึกเวลาที่ส่งคำขอ หมวดหมู่ endpoint ตัวระบุโมเดล สถานะ HTTP และรหัสข้อผิดพลาดแบบมีโครงสร้างเมื่อมีข้อมูลดังกล่าว
- ห้ามบันทึกเฮดเดอร์
Authorizationเนื้อหาคำขอทั้งหมด เนื้อหาการตอบกลับดิบ หรือพรอมป์ต์ที่มีข้อมูลส่วนบุคคล - หากจำเป็นต้องใช้พรอมป์ต์เพื่อวิเคราะห์ ให้บันทึกตัวอย่างที่ปกปิดข้อมูลแล้วหรือตัวระบุคำขอภายในที่คงที่ แทนข้อความต้นฉบับ
- จำกัดความยาวของข้อมูลวินิจฉัย พร็อกซีอาจส่งหน้าข้อผิดพลาด HTML ขนาดใหญ่กลับมา และข้อผิดพลาดจากระบบต้นทางอาจมีข้อมูลที่คุณไม่ได้ตั้งใจเก็บไว้
หลักปฏิบัติที่เป็นประโยชน์คือ ทำให้บันทึกช่วยตอบได้ว่า อะไรผิดพลาดและเกิดขึ้นที่ใด โดยไม่บันทึกว่า ผู้ใช้พูดอะไร หรือ ใช้ข้อมูลใดในการยืนยันตัวตน
วิเคราะห์ข้อผิดพลาดการยืนยันตัวตน 401 ก่อน
กรณี 401 ที่มีการระบุไว้ ได้แก่ การยืนยันตัวตนไม่ถูกต้อง การใช้ API key ผิด ไม่มีสมาชิกภาพในองค์กร และที่อยู่ IP ไม่ได้รับอนุญาต ส่วน 403 อาจหมายถึงประเทศ ภูมิภาค หรือดินแดนที่ไม่รองรับ
ตรวจสอบรายการต่อไปนี้ตามลำดับ:
- ยืนยันว่าเซิร์ฟเวอร์กำลังอ่าน secret ที่ถูกต้อง และ secret ไม่ได้ถูกตัดทอน หมดอายุ เพิกถอน หรือแทนที่ไปแล้ว
- ยืนยันว่าคำขอส่งไปยัง API endpoint และโปรเจกต์ที่ต้องการ
- หากการตั้งค่าของคุณใช้ตัวระบุองค์กรหรือรายการอนุญาต IP ให้ตรวจสอบทั้งสองรายการกับการตั้งค่าโปรเจกต์
- ตรวจสอบว่าคำขอมาจาก IP ขาออกอื่นในสภาพแวดล้อมการพัฒนา คอนเทนเนอร์ หรือสภาพแวดล้อมโฮสต์หรือไม่
- ลบค่าข้อมูลรับรองทั้งหมดออกจากผลลัพธ์การดีบักก่อนแชร์บันทึก
อย่าใช้การลองซ้ำอัตโนมัติกับ 401 หรือ 403 การส่งข้อมูลรับรองเดิมที่ไม่ถูกต้องซ้ำอาจเพิ่มสัญญาณรบกวนและทำให้วิเคราะห์เหตุการณ์ได้ยากขึ้น ให้แก้การตั้งค่าแล้วส่งคำขอใหม่
แยกการจำกัดอัตรา 429 ออกจากปัญหาโควตาและการเรียกเก็บเงิน
429 ไม่ได้หมายความว่า “ลองใหม่เร็ว ๆ นี้” เสมอไป คู่มือ OpenAI แยกกรณีต่าง ๆ ดังนี้:
| ประเภทข้อผิดพลาด | การดำเนินการที่เป็นไปได้ | ลองซ้ำอัตโนมัติหรือไม่? |
|---|---|---|
| ถึงขีดจำกัดอัตรา | เว้นช่วงการส่งคำขอและทำตาม Retry-After หากมี | ได้ โดยกำหนดขอบเขต |
slow_down | ลดอัตราการส่งคำขอและเพิ่มขึ้นทีละน้อย | ได้ แต่ทำอย่างระมัดระวัง |
| ยอดเครดิตหมด | เพิ่มเครดิต | ไม่ได้ |
| ถึงขีดจำกัดค่าใช้จ่ายขององค์กรหรือโปรเจกต์ | เปลี่ยนขีดจำกัดที่เกี่ยวข้อง | ไม่ได้ |
| ถึงขีดจำกัดการใช้งานขององค์กร | ขอเพิ่มขีดจำกัดโดยได้รับอนุมัติ หรือ ติดต่อฝ่ายสนับสนุน | ไม่ได้ |
ลูปการลองซ้ำควรตรวจสอบสถานะ HTTP และรหัสข้อผิดพลาดเฉพาะ แทนที่จะจัดการ 429 ทุกกรณีเหมือนกัน ใช้จำนวนครั้งสูงสุด การหน่วงแบบ exponential backoff และ jitter เพื่อไม่ให้หลาย worker ลองส่งคำขอซ้ำพร้อมกัน หากมี Retry-After ให้ใช้ระยะเวลาหน่วงนั้น โดยอยู่ภายใต้เวลารอสูงสุดที่คุณกำหนดเอง
ให้คำนึงถึงการตอบกลับ 503 ด้วย เอกสารต้นทางระบุว่ากรณีโมเดลทำงานหนักเกินไปใช้รหัส server_is_overloaded และแนะนำให้ทำตาม Retry-After หากมี ก่อนลองใหม่ ในไลบรารี Python กรณีระบบทำงานหนักเกินไปอาจแสดงเป็น InternalServerError ขณะที่การตอบกลับ 429 ใช้ RateLimitError ตัวจัดการข้อผิดพลาดจึงไม่ควรตั้งสมมติฐานว่ากรณีระบบทำงานหนักเกินไปจะมาในรูปแบบ 429 เสมอ
ตรวจสอบคำขอหมดเวลาและปัญหาการเชื่อมต่อ
ไลบรารี Python อย่างเป็นทางการระบุ APITimeoutError สำหรับคำขอที่หมดเวลา และ APIConnectionError สำหรับปัญหาการเชื่อมต่อ ขอบเขตการตรวจสอบทั่วไปมีดังนี้:
- หมดเวลาก่อนมีการตอบกลับ: ตรวจสอบการตั้งค่า timeout ของไคลเอนต์ เส้นทางเครือข่าย พร็อกซี ไฟร์วอลล์ และขนาดคำขอ
- การเชื่อมต่อล้มเหลว: ตรวจสอบ DNS ใบรับรอง TLS กฎไฟร์วอลล์ขาออก และการตั้งค่าพร็อกซี
- ข้อผิดพลาดฝั่งเซิร์ฟเวอร์ที่เกิดซ้ำ: ตรวจสอบหน้าสถานะบริการ และเก็บวันเวลาที่ผ่านการลบข้อมูลสำคัญแล้วไว้สำหรับแจ้งฝ่ายสนับสนุน
การหมดเวลาไม่ได้ยืนยันว่าเซิร์ฟเวอร์ไม่ได้ประมวลผลคำขอ สำหรับการทำงานที่การประมวลผลซ้ำมีผลสำคัญ ให้ออกแบบแอปพลิเคชันเพื่อให้ตรวจสอบและจัดการการลองซ้ำได้อย่างปลอดภัย เช่น ผูกการทำงานเข้ากับระเบียนคำขอของคุณเอง อย่าแก้ปัญหาการหมดเวลาด้วยการเพิ่ม timeout ไปเรื่อย ๆ หรือส่งคำขอซ้ำโดยไม่มีขีดจำกัด
จัดการการตอบกลับผิดรูปแบบโดยไม่เปิดเผยเนื้อหา
“การตอบกลับผิดรูปแบบ” อาจหมายถึงปัญหาหลายประเภท ได้แก่ คำขอไม่ถูกต้องที่ทำให้เกิด BadRequestError การตอบกลับไม่ตรงกับสคีมาที่คาดไว้ หรือพร็อกซีส่ง HTML หรือข้อมูลที่ถูกตัดทอนมาแทน JSON คู่มือ OpenAI อธิบายว่า BadRequestError เกิดจากคำขอที่ผิดรูปแบบหรือไม่สมบูรณ์ และแนะนำให้ตรวจสอบพารามิเตอร์ที่จำเป็น การเข้ารหัส รูปแบบ และขนาด
สำหรับไคลเอนต์ HTTP แบบดิบหรือมิดเดิลแวร์ ให้ตรวจสอบแต่ละรายการแยกกันดังนี้:
- ตรวจสอบสถานะ HTTP และ
Content-Typeก่อนแยกวิเคราะห์ - แยกวิเคราะห์ JSON ภายในบล็อกที่มีการจัดการข้อผิดพลาด
- ตรวจสอบว่ามีฟิลด์ที่จำเป็นก่อนนำไปใช้
- บันทึกเฉพาะสถานะ ประเภทเนื้อหา ความยาวของการตอบกลับ และข้อความบางส่วนที่ผ่านการปกปิดและจำกัดความยาวแล้ว หากนโยบายอนุญาต
- ห้ามใส่ API key พรอมป์ต์ทั้งหมด หรือการตอบกลับทั้งหมดลงในข้อความข้อผิดพลาดจากการแยกวิเคราะห์
ตัวห่อหุ้มตัวอย่างอาจมีลักษณะดังนี้:
async function parseSafeResponse(response) {
const contentType = response.headers.get("content-type") || "";
const body = await response.text();
if (!contentType.toLowerCase().includes("application/json")) {
throw new Error(`Unexpected response type: ${contentType}; length=${body.length}`);
}
try {
return JSON.parse(body);
} catch {
throw new Error(`Invalid JSON response; length=${body.length}`);
}
}
ตัวอย่างนี้ตั้งใจไม่ใส่เนื้อหาลงในข้อผิดพลาดที่ส่งออก ในระบบจริง ให้เพิ่มการตรวจสอบสคีมาที่เหมาะกับ endpoint และเก็บข้อมูลดิบไว้เฉพาะในกระบวนการวินิจฉัยที่มีการควบคุมและผ่านการทบทวนด้านความเป็นส่วนตัวแล้ว
รูปแบบตัวจัดการข้อผิดพลาดที่คำนึงถึงความเป็นส่วนตัว
ตัวอย่าง JavaScript อย่างเป็นทางการแยกข้อผิดพลาดด้านการเชื่อมต่อ ข้อผิดพลาดการจำกัดอัตรา และข้อผิดพลาด API ประเภทอื่น ๆ นำแนวคิดนี้ไปต่อยอดโดยจำแนกข้อผิดพลาดโดยไม่พิมพ์ข้อมูลลับหรือข้อมูลจากผู้ใช้:
import OpenAI from "openai";
const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
try {
const response = await client.responses.create({
model: process.env.OPENAI_MODEL,
input: "Redacted diagnostic input"
});
console.log({ ok: true, hasOutput: Boolean(response.output_text) });
} catch (error) {
const details = {
name: error?.name,
status: error?.status,
code: error?.code
};
if (error instanceof OpenAI.AuthenticationError) {
console.error("Authentication failed", details);
} else if (error instanceof OpenAI.RateLimitError) {
console.error("Rate limit or quota response", details);
} else if (error instanceof OpenAI.APIConnectionError) {
console.error("Connection failed", details);
} else if (error instanceof OpenAI.APIError) {
console.error("OpenAI API error", details);
} else {
console.error("Unexpected local error", { name: details.name });
}
}
ตรวจสอบชื่อคลาสและพฤติกรรมของ endpoint เทียบกับ SDK เวอร์ชันที่คุณนำไปใช้งาน อย่าคิดว่า endpoint ที่รองรับผู้ให้บริการหลายรายจะรองรับพารามิเตอร์หรือฟิลด์การตอบกลับของ SDK ได้ทั้งหมด
ควรส่งต่อปัญหาเมื่อใด
หากเกิดข้อผิดพลาดต่อเนื่อง คู่มือ OpenAI แนะนำให้แจ้งโมเดล ข้อความและรหัสข้อผิดพลาด ข้อมูลคำขอและเฮดเดอร์ วันเวลา เขตเวลา และรายละเอียดอื่น ๆ ที่เกี่ยวข้อง ให้ลบข้อมูลสำคัญออกจากชุดข้อมูลดังกล่าวก่อน โดยแทนที่ข้อมูลรับรอง ลบคุกกี้ ปกปิดข้อมูลส่วนบุคคล และสรุปเนื้อหาคำขอเมื่อทำได้ ห้ามโพสต์ข้อมูลที่ละเอียดอ่อนในฟอรัมสาธารณะ
แนวทางตัดสินใจทำได้ง่าย ๆ: แก้ปัญหาการยืนยันตัวตนและโควตา หน่วงการส่งคำขอเมื่อมีการจำกัดอัตราหรือระบบทำงานหนักเกินไป ตรวจสอบขอบเขตเครือข่ายเมื่อเกิด timeout และแยกวิเคราะห์ปัญหาการประมวลผลโดยไม่เก็บข้อมูลส่วนตัว
คำถามที่พบบ่อย
ควรลองส่งคำขอซ้ำกับการตอบกลับ OpenAI 429 ทุกครั้งหรือไม่?
ไม่ควร ลองซ้ำอย่างระมัดระวังเมื่อเป็นกรณีอัตราการส่งคำขอหรือ slow-down โดยใช้ backoff และทำตาม Retry-After หากมี การลองซ้ำไม่ช่วยแก้ปัญหาเครดิตหมด ขีดจำกัดค่าใช้จ่าย หรือขีดจำกัดการใช้งานขององค์กร
เหตุใดข้อผิดพลาดระบบทำงานหนักเกินไปของ OpenAI จึงอาจแสดงเป็น 503 แทน 429?
คู่มือข้อผิดพลาด OpenAI ระบุว่ากรณีโมเดลทำงานหนักเกินไปจะแสดงเป็น 503 พร้อมรหัส server_is_overloaded ตัวจัดการข้อผิดพลาดควรตรวจสอบทั้งสถานะและรหัส แทนที่จะคิดว่ากรณีระบบทำงานหนักเกินไปเป็นการตอบกลับจากการจำกัดอัตราเสมอ
ควรบันทึกข้อมูลใดเมื่อเกิดข้อผิดพลาดการยืนยันตัวตน OpenAI?
บันทึกวันเวลา สภาพแวดล้อม หมวดหมู่ endpoint สถานะ และรหัสข้อผิดพลาดที่ลบข้อมูลสำคัญแล้ว ห้ามบันทึก API key เฮดเดอร์ Authorization เนื้อหาคำขอทั้งหมด หรือพรอมป์ต์ดิบของผู้ใช้
จะแก้ปัญหาการตอบกลับ JSON ที่ไม่ถูกต้องได้อย่างไร?
ตรวจสอบสถานะ HTTP และ Content-Type ก่อนแยกวิเคราะห์ บันทึกเฉพาะข้อมูลวินิจฉัยที่จำกัดความยาวและปกปิดข้อมูลแล้วหากนโยบายอนุญาต และตรวจสอบพร็อกซีหรือมิดเดิลแวร์ที่อาจส่ง HTML กลับมา ตัดทอนข้อมูล หรือเปลี่ยนแปลงการตอบกลับ
บทความที่เกี่ยวข้อง
Guides
วิเคราะห์ปัญหา OpenAI API ในระบบตอบคำถามจากเอกสาร
คู่มือแก้ปัญหาการยืนยันตัวตน การจำกัดอัตราคำขอ การหมดเวลา และคำตอบที่อ้างอิงแหล่งข้อมูลไม่ถูกต้อง
Guides
ปกป้อง OpenAI API Keys สำหรับการคัดแยกคำร้องฝ่ายบริการลูกค้า
แนวทางรักษาความปลอดภัยเชิงปฏิบัติสำหรับใช้ OpenAI ในการคัดแยกคำร้องฝ่ายบริการลูกค้า: ปกป้อง API keys ปกปิดข้อมูลในล็อก จำกัดสิทธิ์ หมุนเวียนข้อมูลรับรอง และกำหนดให้มนุษย์อนุมัติ
Guides
วินิจฉัยเหตุขัดข้องของ OpenAI API โดยไม่เปิดเผยข้อมูลรับรอง
คู่มือภาคปฏิบัติสำหรับวินิจฉัยปัญหา OpenAI API ด้วยสัญญาณที่เป็นประโยชน์ พร้อมปกป้อง API key จำกัดสิทธิ์ และวางแผนหมุนเวียนข้อมูลรับรอง
Guides
การประเมินค่าใช้จ่าย GPT Image 2.6 API สำหรับงานที่คำนึงถึงความเป็นส่วนตัว
ประเมินค่าใช้จ่ายงาน GPT Image 2.6 ด้วยสมมติฐานจำนวนโทเคนและอัตราการยอมรับผลงานที่ชัดเจน พร้อมแนวทางวัดผลที่คำนึงถึงความเป็นส่วนตัว