TH ▾
รับคีย์ API

ข้อผิดพลาด LLM API 429: สาเหตุและวิธีแก้ไข

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

อัปเดต

แพ็กเก็ตแสงที่รออยู่ที่ประตูที่มีแปดช่อง แสดงถึงขีดจำกัดอัตราของ API

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

ประเภทของ 429 ทั้งสามแบบ

HTTP 429 คือสถานะมาตรฐาน "คำขอมากเกินไป" ที่นี่ครอบคลุมสามสถานการณ์ และส่วนเนื้อหาข้อผิดพลาด JSON บอกคุณว่าคุณอยู่ในสถานการณ์ใด

รหัสข้อผิดพลาดความหมายวิธีแก้ไขทั่วไป
rate_limitedคำขอเกินต่อนาทีลดความเร็วลง โดยกระจายคำขอตลอดทั้งนาที
concurrencyคำขอที่ทำงานพร้อมกันมากเกินไปลดความพร้อมกันลง รอให้ช่องว่างว่างลง
โอเวอร์โหลด พร้อม Retry-After: 5โหลดชั่วคราวบนบริการ ไม่ใช่ความผิดของคุณรอจำนวนวินาทีในเฮดเดอร์ แล้วลองใหม่

อ่านโค้ดก่อน เพราะการแก้ไขสาเหตุหนึ่งอาจไม่ช่วยอีกสาเหตุหนึ่ง การลดคำขอต่อนาทีลงครึ่งหนึ่งจะไม่ช่วยหากปัญหาจริงคือ 20 เวิร์กเกอร์ที่ทำงานพร้อมกัน

รู้ขีดจำกัดของคุณ

ขีดจำกัดขึ้นอยู่กับประเภทคีย์:

  • คีย์เต็ม: คำขอพร้อมกันได้ 8 คำขอ และ 300 คำขอต่อนาที
  • คีย์ทดลอง: คำขอพร้อมกันได้ 2 คำขอ และ 60 คำขอต่อนาที

ทุกการตอบกลับมี X-RateLimit-Limit-Requests และ X-RateLimit-Limit-Concurrency เพื่อให้ไคลเอนต์ของคุณอ่านค่าสูงสุดได้แทนการกำหนดตายตัว คีย์ทดลองเป็นสาเหตุทั่วไปสำหรับผู้ใช้ใหม่: สคริปต์ที่ทำงานได้ปกติเมื่อทำ 1 คำขอต่อครั้งจะเริ่มล้มเหลวเมื่อคุณเพิ่มพูลเธรดขนาด 4 การทดลองใช้มีไว้สำหรับการทดสอบ และคีย์เต็มจะมาพร้อมกับการเติมเงินขั้นต่ำ $20 (ดูรายละเอียดจำนวนเงินและโบนัสใน หน้าราคา)

ตัวเลขข้างต้นเป็นต่อคีย์ หากคีย์หนึ่งถูกแชร์โดยเว็บแอป งานครอน และโน้ตบุ๊กของเพื่อนร่วมทีม พวกเขาทั้งหมดใช้พูลเดียวกัน และรหัส 429 จะดูสุ่มจนกว่าคุณจะรวมภาระงานทั้งสามเข้าด้วยกัน

เหตุใดสตรีมมิงจึงทำให้ข้อผิดพลาดความพร้อมกันเกิดขึ้นบ่อยขึ้น

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

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

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

โค้ดลองใหม่ใน Python พร้อม backoff

รูปแบบนั้นง่าย: จับ 429 อ่านโค้ด รอ ลองใหม่ด้วยความล่าช้าที่เพิ่มขึ้นและความสุ่มเล็กน้อย และยอมแพ้หลังจากลองไม่กี่ครั้ง เวอร์ชันนี้ใช้แพ็คเกจ openai กับ URL ฐานของบริการ:

import random
import time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.onekeyllmapi.com/v1",
    api_key="YOUR_KEY",
    max_retries=0,  # we handle retries ourselves
)

def chat(messages, attempts=5):
    for i in range(attempts):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=messages,
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            headers = e.response.headers
            wait = float(headers.get("Retry-After", 0))
            if not wait:
                wait = min(30, 2 ** i)  # 1, 2, 4, 8, 16 seconds
            wait += random.uniform(0, 1)  # jitter
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

print(chat([{"role": "user", "content": "Reply with the word ok."}]))

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

จำกัดการเรียกพร้อมกันเพื่อลดโอกาสเห็น 429

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

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.onekeyllmapi.com/v1",
    api_key="YOUR_KEY",
)
sem = asyncio.Semaphore(6)  # full key allows 8; use 1 on a trial key

async def ask(prompt):
    async with sem:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Give one fact about the number {n}." for n in range(50)]
    results = await asyncio.gather(*(ask(p) for p in prompts))
    print(len(results))

asyncio.run(main())

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

จำลองและตรวจสอบ 429 ด้วย curl

ก่อนเปลี่ยนโค้ด ให้ดูการตอบกลับดิบ เพิ่ม -i ใน curl เพื่อให้พิมพ์เฮดเดอร์ และส่งคำขอหลายคำพร้อมกันเพื่อกระตุ้นข้อผิดพลาดโดยเจตนา:

for i in 1 2 3 4; do
  curl -i -s https://api.onekeyllmapi.com/v1/chat/completions     -H "Authorization: Bearer $API_KEY"     -H "Content-Type: application/json"     -d '{"model":"uncensored","messages":[{"role":"user","content":"Count to 200 slowly."}]}' &
done
wait

บนคีย์ทดลองซึ่งอนุญาตให้ทำงาน 2 คำขอพร้อมกัน คำเรียกที่สามและสี่ควรกลับด้วยสถานะ 429 และรหัสข้อผิดพลาดเป็น concurrency บนคีย์เต็มคุณต้องการมากกว่า 8 คำขอพร้อมกัน ดูสามสิ่งในการตอบกลับแต่ละครั้ง: บรรทัดสถานะ เฮดเดอร์ Retry-After หากมี และฟิลด์ error.code ในบอดี้ JSON การทดลองเล็กๆ น้อยนี้บอกคุณมากกว่าการเดาหนึ่งชั่วโมง และให้กรณีที่สามารถทำซ้ำได้เพื่อแสดงฝ่ายสนับสนุนหากมีบางอย่างผิดปกติ

ออกแบบเพื่อรองรับมัน ไม่ใช่เพื่อหลีกเลี่ยงมัน

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

รายการตรวจสอบการแก้ไขข้อผิดพลาดแบบสั้น

  1. บันทึกบอดี้ข้อผิดพลาดทั้งหมดและเฮดเดอร์ X-Request-Id สำหรับแต่ละ 429 ฟิลด์ code จะแยก rate_limited ออกจาก concurrency
  2. ตรวจสอบว่าคีย์ของคุณเป็นคีย์ทดลองหรือไม่ หากใช่ คาดการณ์คำขอพร้อมกันได้ 2 คำขอและ 60 คำขอต่อนาที
  3. นับทุกโปรแกรมที่ใช้คีย์นี้ ไม่ใช่เพียงโปรแกรมที่ล้มเหลวเท่านั้น
  4. มองหาสตรีมที่ยังไม่ปิด และวงวนที่ลองใหม่ทันทีโดยไม่มีการหน่วงเวลา วงวนการลองใหม่แบบทันทีจะเปลี่ยน 429 หนึ่งรายการให้กลายเป็นร้อยรายการ
  5. ยืนยันยอดคงเหลือด้วย X-Balance-USD หรือ GET /v1/balance ยอดคงเหลือว่างเปล่าเป็นปัญหาที่แตกต่างจาก 429 แต่การตรวจสอบใช้เวลาเพียงไม่กี่วินาที

คำขอที่ล้มเหลวจะไม่ถูกเรียกเก็บเงิน ดังนั้นการลองใหม่จึงไม่ทำให้คุณเสียโทเคนสำหรับคำขอที่ถูกปฏิเสธ ดูรายการสถานะโค้ดและเฮดเดอร์ทั้งหมดใน เอกสาร หากคุณต้องการคีย์ที่มีขีดจำกัดสูงกว่าเครดิตทดลองใช้ รับคีย์ API แล้วเติมเงิน

ถาม-ตอบ

429 เป็นความผิดของฉันหรือของผู้ให้บริการ?

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

ฉันควรรอนานแค่ไหนก่อนลองใหม่?

หากการตอบสนองมีเฮดเดอร์ Retry-After ให้รออย่างน้อยตามจำนวนวินาทีนั้น มิฉะนั้นให้เริ่มที่หนึ่งวินาทีแล้วคูณสองเวลาหน่วงในแต่ละครั้ง พร้อมเพิ่มการสุ่มเล็กน้อย

คำขอที่ถูกปฏิเสธคิดเงินหรือไม่?

ไม่ คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน

ฉันเพิ่มขีดจำกัดได้ไหม?

คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกันได้ 8 คำขอและ 300 คำขอต่อนาที เทียบกับ 2 และ 60 สำหรับคีย์ทดลอง หากเกินกว่านั้น ให้กระจายงานผ่านคิวฝั่งของคุณ

คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว

สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด