GuidesOneMux

ข้อผิดพลาด OpenAI API ในระบบจริง: วินิจฉัย ลองใหม่ และกู้คืนอย่างปลอดภัย

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

AI

สรุป · TL;DR

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

ประเด็นสำคัญ

  • อย่าลองใหม่เมื่อเกิดข้อผิดพลาดด้านการยืนยันตัวตน สิทธิ์ คำขอมีรูปแบบไม่ถูกต้อง หรือเครดิตหมด จนกว่าจะแก้ไขสาเหตุ
  • เมื่อถูกจำกัดอัตราหรือระบบรับภาระมากเกินไป ให้ทำตาม Retry-After หากมี และจำกัดจำนวนครั้งที่ลองใหม่ด้วย exponential backoff และ jitter
  • คำขอหมดเวลาไม่ได้ยืนยันว่าการทำงานล้มเหลว อย่าส่งงานที่ไม่รองรับ idempotency ซ้ำโดยไม่ตรวจสอบ
  • ตรวจสอบการตอบกลับที่สำเร็จก่อนบันทึกสถานะเวิร์กโฟลว์ขั้นถัดไป และเก็บข้อมูลที่เพียงพอสำหรับการกู้คืนอย่างปลอดภัย
ในหน้านี้ (6)

กฎสำหรับระบบจริง: จำแนกก่อนลองใหม่

เมื่อการเรียก OpenAI API ล้มเหลว คำถามที่เป็นประโยชน์ไม่ใช่แค่ “ควรลองใหม่ไหม” แต่คือ “มีหลักฐานอะไรบ่งชี้ว่าความล้มเหลวนี้เกิดขึ้นชั่วคราว และหากส่งคำขอซ้ำจะเกิดอะไรขึ้น” เวิร์กโฟลว์สำหรับระบบจริงควรจำแนกข้อผิดพลาด กำหนดการดำเนินการที่มีขอบเขต และรักษาสถานะของงานไว้หากไม่สามารถทำงานต่อได้อย่างปลอดภัย

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

คัดแยกตามประเภทความล้มเหลว

อาการแนวทางที่น่าจะเหมาะสมควรลองใหม่ไหม?
ข้อผิดพลาดการยืนยันตัวตน 401ตรวจสอบว่า API key ถูกต้องและยังใช้งานได้ รวมถึงใช้องค์กรที่ต้องการหรือไม่ หากตั้งค่า IP allowlisting ไว้ ให้ตรวจสอบการตั้งค่านั้นด้วยไม่ จนกว่าจะแก้ไขข้อมูลรับรองหรือสิทธิ์การเข้าถึง
คำขอไม่ถูกต้อง 400ตรวจสอบข้อความและพารามิเตอร์ของคำขอ รวมถึงอินพุตที่จำเป็น การเข้ารหัส รูปแบบ และขนาดไม่ จนกว่าจะแก้ไขคำขอ
429 จากการจำกัดอัตราหรือข้อความ “slow down”ลด concurrency หรืออัตราการส่งคำขอ ทำตาม Retry-After หากมี แล้วค่อย ๆ เพิ่มปริมาณการใช้งานได้ โดยใช้นโยบายลองใหม่ที่มีขอบเขต
429 จากเครดิต การใช้จ่าย หรือขีดจำกัดการใช้งานตรวจสอบ error.code เติมเครดิตหรือแก้ไขขีดจำกัดที่เกี่ยวข้องไม่ การส่งคำขอเดิมซ้ำไม่ได้ทำให้กลับมาเข้าถึงได้
ข้อผิดพลาดเซิร์ฟเวอร์ 500 หรือระบบรับภาระมากเกินไป 503รอสักครู่ ทำตาม Retry-After หากมี และลองใหม่ภายในจำนวนครั้งที่กำหนดโดยทั่วไปทำได้ แต่ต้องมีมาตรการป้องกัน
Client timeout หรือข้อผิดพลาดการเชื่อมต่อตรวจสอบเครือข่าย พร็อกซี TLS และไฟร์วอลล์ รวมถึงพิจารณาว่าคำขออาจทำงานเสร็จแล้วหรือไม่บางกรณีได้ แต่ต้องคำนึงถึงผลจากการทำซ้ำก่อน
สถานะสำเร็จแต่การตอบกลับใช้งานไม่ได้ตรวจสอบโครงสร้างการตอบกลับและฟิลด์ที่จำเป็นก่อนดำเนินเวิร์กโฟลว์ต่อไม่ควรลองใหม่โดยอัตโนมัติ ให้จัดการเป็นปัญหาคุณภาพข้อมูลหรือโปรโตคอลแยกต่างหาก

คู่มือของ OpenAI ระบุว่า RateLimitError ของ Python สอดคล้องกับ 429 และ InternalServerError สอดคล้องกับ 503 ดังนั้นกรณีโหลดเกินอาจได้รับรหัสสถานะที่ต่างจากที่ตัวจัดการเคยคาดไว้ ในไคลเอ็นต์ทุกประเภท ให้พิจารณาทั้งสถานะและรายละเอียดข้อผิดพลาด แทนการสันนิษฐานว่าการโหลดเกินทุกกรณีจะเป็น 429

รูปแบบการลองใหม่ด้วย JavaScript แบบมีขอบเขต

ข้อกำหนดเบื้องต้น: OpenAI JavaScript SDK เวอร์ชันปัจจุบัน มีการตั้งค่า API key แล้ว และเวิร์กโฟลว์สามารถตัดสินใจได้อย่างปลอดภัยว่าจะยอมรับการส่งคำขอซ้ำหรือไม่ ตัวอย่างประกอบนี้ลองใหม่เฉพาะข้อผิดพลาดชั่วคราวบางประเภทเท่านั้น และไม่ได้ยืนยันว่าคำขอที่หมดเวลาจะไม่ถูกประมวลผล

import OpenAI from "openai";

const client = new OpenAI();

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

function retryAfterMs(error) {
  const value = error.headers?.get?.("retry-after");
  if (!value) return null;

  const seconds = Number(value);
  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);

  const dateMs = Date.parse(value);
  return Number.isNaN(dateMs) ? null : Math.max(0, dateMs - Date.now());
}

function isRetryable(error) {
  const code = error.code;
  if ([
    "credit_balance_exhausted",
    "organization_spend_limit_exceeded",
    "project_spend_limit_exceeded",
    "organization_usage_limit_exceeded",
  ].includes(code)) return false;

  return error instanceof OpenAI.RateLimitError ||
    (error instanceof OpenAI.APIError &&
      [500, 503].includes(error.status));
}

async function createResponseWithRetry(input, maxRetries = 3) {
  for (let attempt = 0; ; attempt++) {
    try {
      return await client.responses.create({
        model: "YOUR_MODEL",
        input,
      });
    } catch (error) {
      if (!isRetryable(error) || attempt >= maxRetries) throw error;

      const exponentialMs = Math.min(10_000, 500 * 2 ** attempt);
      const jitterMs = Math.floor(Math.random() * 250);
      const delayMs = retryAfterMs(error) ?? exponentialMs + jitterMs;
      await sleep(delayMs);
    }
  }
}

YOUR_MODEL เป็นเพียงตัวแทน ไม่ใช่คำแนะนำให้เลือกใช้โมเดล ตัวอย่างนี้แสดงวิธีควบคุมการลองใหม่ ไม่ใช่พฤติกรรมที่ผ่านการทดสอบกับ SDK หรือ endpoint ทุกเวอร์ชัน ตรวจสอบว่า SDK แสดง response headers ตามตัวอย่างนี้ในเวอร์ชันที่ติดตั้งหรือไม่ หากไม่รองรับ ให้ใช้วิธีที่รองรับสำหรับอ่านค่าเหล่านั้น กำหนด deadline ระดับเวิร์กโฟลว์ควบคู่กับจำนวนครั้งที่ลองใหม่ เพื่อไม่ให้งานที่ค้างรออย่างไม่มีกำหนด

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

กำหนดกฎการกู้คืนสำหรับ timeout และการตอบกลับที่มีรูปแบบไม่ถูกต้อง

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

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

รายการตรวจสอบสำหรับการปฏิบัติงาน

  1. บันทึกเวลาและเขตเวลา endpoint โมเดล สถานะ HTTP ประเภทและรหัสข้อผิดพลาด รวมถึงตัวระบุสำหรับติดตามคำขอที่ปลอดภัย
  2. ห้ามบันทึก API keys หรืออินพุตที่ละเอียดอ่อน เก็บเฉพาะรายละเอียดคำขอที่จำเป็นต่อการจำลองข้อผิดพลาดอย่างปลอดภัย
  3. ลองใหม่เฉพาะความล้มเหลวชั่วคราว โดยกำหนดจำนวนครั้งสูงสุด ระยะหน่วง jitter และ deadline โดยรวม
  4. ทำตาม Retry-After เมื่อมี หากยังถูกจำกัดอัตรา ให้ลดความเร็วลงอีก
  5. แยกกรณีลองใหม่ครบจำนวนแล้วออกจากความล้มเหลวถาวร เพื่อให้ผู้ปฏิบัติงานตรวจสอบและเล่นงานที่เข้าเกณฑ์ซ้ำได้
  6. หากเกิดข้อผิดพลาดต่อเนื่อง ให้รวบรวมโมเดล ข้อความและรหัสข้อผิดพลาด ข้อมูลคำขอและ headers ที่นำข้อมูลลับออกแล้ว เวลาและเขตเวลา รวมถึงบริบทที่เกี่ยวข้องอื่น ๆ OpenAI แนะนำให้แจ้งรายละเอียดเหล่านี้แก่ฝ่ายสนับสนุน

สรุป

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

คำถามที่พบบ่อย

ควรลองใหม่ทุกครั้งที่ได้รับ OpenAI API 429 หรือไม่?

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

เวิร์กโฟลว์ควรจัดการ OpenAI API timeout อย่างไร?

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

ควรทำอย่างไรเมื่อ API ส่งการตอบกลับที่มีรูปแบบไม่ถูกต้อง?

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

503 มีความหมายเหมือน 429 หรือไม่?

ไม่ แนวทางของ OpenAI ที่ให้มาระบุว่าการตอบกลับ 429 จากการจำกัดอัตราและ 503 จากโมเดลมีภาระงานมากเกินไปเป็นคนละกรณี ไคลเอ็นต์ควรตรวจสอบสถานะและรายละเอียดข้อผิดพลาด และจัดการทั้งสองกรณีตามความเหมาะสม แทนการสันนิษฐานว่าการโหลดเกินจะแสดงเป็น 429 เสมอ

บทความที่เกี่ยวข้อง

Guides

รีวิว GPT-5.6 Sol: ใครบ้างที่ต้องใช้โมเดลเรือธงของ OpenAI เมื่อเทียบกับ DeepSeek และ Qwen

รีวิว GPT-5.6 Sol เชิงปฏิบัติ เปรียบเทียบโมเดลเรือธงของ OpenAI กับ DeepSeek V4 และ Qwen ครอบคลุมราคา การใช้งานร่วมกับ OpenAI API และใครควรใช้โมเดลนี้

阅读全文 →

Guides

การควบคุมต้นทุนAPI AI ด้วย GPT-5.6 Sol: คู่มือปฏิบัติสำหรับนักพัฒนา

เรียนรู้วิธีการจัดการต้นทุน OpenAI API อย่างมีประสิทธิภาพด้วย GPT-5.6 Sol ผ่าน OneMux สำรวจรายละเอียดราคา กลยุทธ์การประหยัดต้นทุน และการเปรียบเทียบโมเดล

阅读全文 →

Guides

ทำไม Claude Opus 4.7 ถึงเป็นโมเดล AI ที่ดีที่สุดสำหรับการเขียนโค้ดในตอนนี้

เปรียบเทียบ Claude Opus 4.7 กับ GPT-5.4 สำหรับการเขียนโปรแกรม: คุณภาพโค้ด การใช้เหตุผล และต้นทุน ดูว่า OneMux ช่วยให้คุณเข้าถึงทั้งสองโมเดลผ่าน API ของ OpenAI ได้อย่างไร

阅读全文 →

Guides

Claude Opus 4.7 vs GPT-5.5 vs Gemini 3.1 Pro: โมเดลไหนชนะในงานวิศวกรรมซอฟต์แวร์?

เปรียบเทียบ OpenAI GPT-5.5, Claude Opus 4.7 และ Google Gemini 3.1 Pro ตาม benchmark, ราคา และงานจริง ค้นพบว่าเหตุใด Opus 4.7 จึงครองงานวิศวกรรมซอฟต์แวร์ และ OneMux ช่วยให้คุณเข้าถึงได้แบบรวมศูนย์

阅读全文 →