ฟังก์ชันเดียวกัน ฝั่งฟรอนต์เอนด์ต้องเรียกสี่โมเดล: GPT-4o รับหน้าที่เป็นตัวสำรอง DeepSeek รันการอนุมานหลัก Qwen จัดการข้อความยาวภาษาจีน Doubao รับสายบทสนทนาบริการลูกค้า สี่ SDK สี่ชุดการยืนยันตัวตน สี่ชุดเอกสาร สัปดาห์แรกที่ออนไลน์ แค่การปรับความแตกต่างเหล่านี้ให้ตรงกันก็กินเวลาไปสองคน-วันแล้ว
นี่ไม่ใช่การพูดเกินจริง เราสถิติมาแล้ว หลังจากเชื่อมต่อสี่เจ้าของโมเดล ส่วนที่เกี่ยวข้องกับการเรียกใช้โมเดลในโค้ดธุรกิจพองขึ้นเกือบสามเท่า ทุกครั้งที่เปลี่ยนโมเดล ต้องแก้วิธีเรียก ตรรกะการแยกวิเคราะห์ และการจัดการข้อผิดพลาดใหม่ทั้งหมด ที่น่ารำคาญกว่าคือ ทุกครั้งที่ผู้ให้บริการอัปเกรด SDK ต้องทดสอบใหม่ทั้งหมด บทความนี้รวบรวมหลุมที่เราเคยตกหล่นและโซลูชันเกตเวย์ที่ลงเอยด้วยการใช้งานจริงไว้อย่างครบถ้วน หวังว่าจะช่วยทีมที่กำลังดิ้นรนระหว่างหลายโมเดลเช่นเดียวกันได้
หนึ่ง: การยืนยันตัวตน — สี่ระบบ สี่วิธีเขียน
การยืนยันตัวตนเป็นสิ่งแรกที่ชนเข้าให้ OpenAI ใช้ Bearer Token ใส่ Authorization: Bearer sk-xxx ในหัวข้อคำขอก็ใช้ได้ Qwen ต้องใช้ลายเซ็น AccessKey ทุกคำขอต้องใช้ AK/SK คำนวณ HMAC และต้องประกอบ timestamp กับสตริงสุ่ม Doubao ใช้ AK/SK บวก timestamp แต่อัลกอริทึมลายเซ็นต่างจาก Qwen DeepSeek แม้จะเข้ากันได้กับรูปแบบ OpenAI แต่ก็มี base_url และการแมปชื่อโมเดลของตัวเอง วิธีเริ่มต้นก็ไม่ตรงกับ SDK อย่างเป็นทางการเสียทีเดียว
ผลลัพธ์คือในโค้ดมี if-else อยู่ทุกที่ แต่ละผู้ให้บริการมีหนึ่งอินสแตนซ์ client แต่ละอินสแตนซ์มีหนึ่งชุดการตั้งค่า การจัดการคีย์ยิ่งปวดหัว — คีย์ของสี่ผู้ให้บริการเก็บไว้สี่ที่ เวลาหมุนเวียนต้องแก้สี่ที่ พลาดที่เดียวก็เกิดอุบัติเหตุออนไลน์ได้
ภายหลังเราทำการรวมศูนย์ที่ชั้นเชื่อมต่อ: ภายนอกเปิดเผยเพียง API Key เดียว ภายในทำการแปลโปรโตคอล วิธีทำคือชั้นเชื่อมต่อดูแลตารางเส้นทางผู้ให้บริการ แต่ละผู้ให้บริการมีอะแดปเตอร์ยืนยันตัวตนของตัวเอง ฝั่งธุรกิจถือคีย์เดียว คำขอวิ่งไปที่ชั้นเชื่อมต่อ ชั้นเชื่อมต่อหาผู้ให้บริการที่ตรงกันตามชื่อโมเดล ใช้อะแดปเตอร์ทำลายเซ็นและส่งต่อให้เสร็จ
ภายหลังเรารวม base_url ไปที่ token8341 แล้วลองดู คีย์เดียวก็เรียก GPT-4o, Claude, Gemini, DeepSeek, Qwen, ERNIE, Doubao ได้ เข้ากันได้กับ OpenAI SDK แก้ base_url บรรทัดเดียวก็สลับได้ งานสกปรกของการยืนยันตัวตนถูกกั้นไว้นอกชั้นเชื่อมต่อ โค้ดธุรกิจสะอาดขึ้นเยอะ การหมุนเวียนคีย์ก็กลายเป็นการดำเนินการที่เดียว ต้นทุนปฏิบัติการลดลงหนึ่งลำดับขนาดเลย
สอง: การแบ่งบล็อกแบบ SSE สตรีมมิ่ง — สี่รูปแบบ หนึ่งการเรนเดอร์
การแบ่งบล็อกแบบ SSE สตรีมมิ่งเป็นหลุมที่สอง และซ่อนเร้นกว่าการยืนยันตัวตน ใน chunk ของ GPT-4o นั้น delta.content อาจเป็น null โดยเฉพาะ chunk แรกและ chunk สุดท้าย ถ้าฝั่งฟรอนต์เอนด์ไม่ตรวจค่าว่างแล้วเรนเดอร์ตรง ๆ ก็จะกระพริบ undefined ออกมา DeepSeek จะมี usage ใน chunk สุดท้าย และโครงสร้างฟิลด์ usage ของมันก็ไม่ตรงกับ OpenAI เสียทีเดียว ประเภท event ของ Qwen แบ่งละเอียดกว่า มีทั้ง add, finish, error และอื่น ๆ โครงสร้าง payload ของแต่ละ event ก็ต่างกัน ตัวบ่งชี้การสิ้นสุดของ Doubao ก็ต่างออกไป มันใช้ฟิลด์ finish_reason พิเศษเพื่อระบุการสิ้นสุดของสตรีม
ฟรอนต์เอนด์ได้รับสี่รูปแบบ ตรรกะการเรนเดอร์ก็แตกออกทันที วิธีแรกของเราคือทำอะแดปเตอร์ที่ฟรอนต์เอนด์ เขียนฟังก์ชันแยกวิเคราะห์สี่ตัว ผลคือทุกครั้งที่เพิ่มโมเดลใหม่ต้องแก้ฟรอนต์เอนด์ ภายหลังเปลี่ยนเป็นทำการปรับมาตรฐานที่ชั้นเกตเวย์: รวมเป็นโครงสร้าง chunk ของ OpenAI กรอง delta ว่างออกโดยตรง แยก usage ออกมาสะสมแยกต่างหาก กฎเฉพาะคือ — การตอบกลับสตรีมมิ่งของผู้ให้บริการทุกรายแปลงเป็นรูปแบบ data: {"choices":[{"delta":{"content":"..."}}]} การสิ้นสุดใช้เครื่องหมาย data: [DONE] เป็นมาตรฐาน usage ส่งกลับในรูปแบบ OpenAI ใน chunk สุดท้าย
ฟรอนต์เอนด์รู้จักเพียงรูปแบบเดียว ไม่ต้องสนใจว่าฝั่งหลังต่อกับใคร การเปลี่ยนแปลงนี้ทำให้โค้ดที่เกี่ยวข้องกับโมเดลของฟรอนต์เอนด์ลดจากกว่าสี่ร้อยบรรทัดเหลือประมาณแปดสิบบรรทัด และเมื่อเพิ่มโมเดลใหม่ฟรอนต์เอนด์ไม่ต้องแก้อะไรเลย
สาม: รหัสข้อผิดพลาด — ข้อผิดพลาดซ่อนใน HTTP 200
ความวุ่นวายของรหัสข้อผิดพลาดเกินคาด เรื่องการจำกัดอัตราก็เหมือนกัน OpenAI ส่งกลับ 429 พร้อม rate_limit_exceeded Qwen ส่งกลับข้อผิดพลาดธุรกิจที่มีฟิลด์ code Doubao ยัดข้อผิดพลาดไว้ใน body ของ HTTP 200 ตรง ๆ — สถานะคือ 200 แต่ใน body มีฟิลด์ error DeepSeek ส่วนใหญ่ตรงกับ OpenAI แต่บางครั้งก็ส่งกลับโครงสร้างข้อผิดพลาดที่กำหนดเอง
การแจ้งเตือนมอนิเตอร์รวมศูนย์ไม่ได้เลย คุณเขียนกฎว่า "429 ก็แจ้งเตือน" ไม่ได้ เพราะบาง provider จำกัดอัตราแล้วไม่ส่ง 429 กลับ คุณดูแค่ HTTP status code ก็ไม่ได้ เพราะ 200 ของ Doubao อาจเป็นข้อผิดพลาด
เราสร้างตารางแมปที่ชั้นเชื่อมต่อ รวบรหัสข้อผิดพลาดของแต่ละเจ้าให้เป็นระบบข้อผิดพลาดภายในชุดเดียว: จำกัดอัตรา, หมดเวลา, ยืนยันตัวตนล้มเหลว, ตรวจสอบเนื้อหา, บริการไม่พร้อมใช้งาน ตรรกะการแมปเฉพาะคือ — ดูก่อนที่ HTTP status code แล้วดู error code ใน body ประกอบกันตัดสิน ตัวอย่างเช่น Doubao ส่ง 200 แต่ใน body มี error ก็แมปตาม error code; Qwen ส่ง 400 พร้อมรหัสธุรกิจ ก็แมปตาม code กฎการแจ้งเตือนเขียนแค่ชุดเดียว เวลาตรวจสอบค่อยดูรหัสข้อผิดพลาดดั้งเดิม
ตารางแมปนี้เรา maintain ไว้ประมาณหกสิบกว่ากฎ ครอบคลุมสถานการณ์ข้อผิดพลาดทั่วไปของผู้ให้บริการสี่ราย หลังออนไลน์ความแม่นยำการแจ้งเตือนเพิ่มจากประมาณ 60% เป็นกว่า 95% การแจ้งเตือนผิดหายไปแทบหมด
สี่: สถิติการใช้งาน — สี่ตัวเลขไม่ตรงกัน
มาตรฐานการวัดสถิติการใช้งานที่ต่างกันเป็นสิ่งที่ถูกละเลยง่ายที่สุด แต่จะถูกเปิดเผยแน่นอนเวลาการเงินกระทบยอด การนับ token ของ GPT-4o รวม system prompt ด้วย token ที่แคชฮิตของ DeepSeek คิดราคาแยก Qwen คิดแยกอินพุตเอาต์พุต หน่วยคิดเงินของ Doubao ก็ต่างออกไป เวลาการเงินกระทบยอดสี่ตัวเลขไม่ตรงกัน คำนวณต้นทุนจริงของแต่ละโมเดลไม่ได้เลย
โซลูชันการรวบรวมคือบันทึก model, input_tokens, output_tokens, cache_hit ของทุกคำขอที่ชั้นเกตเวย์ ลงฐานข้อมูลตามมาตรฐานการคิดเงินแบบ token เดียวกัน วิธีทำคือ — เกตเวย์บันทึกเวลาเริ่มและสิ้นสุดคำขอขณะส่งต่อคำขอ ดึงฟิลด์ usage ของแต่ละเจ้าจากการตอบกลับ แปลงเป็นรูปแบบมาตรฐานเดียวกัน สำหรับผู้ให้บริการที่หน่วยคิดเงินต่างกัน แปลงหนึ่งครั้งที่ชั้นเกตเวย์ แปลงทั้งหมดเป็นต้นทุนต่อ token
วิธีนี้ไม่ว่าฝั่งหลังต่อกับเจ้าไหน ต้นทุนก็ปรับให้เท่ากันดูในตารางเดียวกันได้ ภายหลังเรายังทำแดชบอร์ดต้นทุนจากตารางนี้ แยกดูตามโมเดล ตามสายธุรกิจ ตามรายวันได้หมด ครั้งหนึ่งพบว่าต้นทุนของสายธุรกิจหนึ่งพุ่งขึ้น 40% กะทันหัน ตรวจสอบแล้วพบว่ากลยุทธ์เส้นทางส่งคำขอจำนวนมากไปที่ GPT-4o ปรับเส้นทางแล้วต้นทุนก็ลดลงทันที ถ้าไม่มีการรวบรวมการใช้งานแบบรวมศูนย์ ปัญหาแบบนี้ตรวจไม่พบเลย
ห้า: สถาปัตยกรรมสี่ชั้นของเกตเวย์โมเดล
เกตเวย์โมเดลควรรับผิดชอบชั้นไหนบ้าง วิธีแบ่งของผมคือสี่ชั้น
ชั้นที่หนึ่ง การแปลโปรโตคอล รวมรูปแบบคำขอ-ตอบกลับของแต่ละเจ้าเป็นอินเทอร์เฟซที่เข้ากันได้กับ OpenAI ชั้นนี้เป็นชั้นเดียวที่โค้ดธุรกิจสัมผัสโดยตรง มันรับผิดชอบแปลคำขอรูปแบบ OpenAI มาตรฐานเป็นรูปแบบของผู้ให้บริการแต่ละราย แล้วแปลการตอบกลับกลับมา
ชั้นที่สอง การกำหนดเส้นทาง เลือกโมเดลตามประเภทงาน เช่นข้อความยาวภาษาจีนไป Qwen โค้ดไป DeepSeek ตัวสำรองไป GPT-4o กลยุทธ์เส้นทางตั้งค่าได้ รองรับหลายมิติทั้งตามประเภทงาน ตามลำดับความสำคัญ ตามต้นทุน เรายังเพิ่มตรรกะการลดระดับ — ถ้าโมเดลหลักหมดเวลาหรือถูกจำกัดอัตรา สลับไปโมเดลสำรองอัตโนมัติ
ชั้นที่สาม การรวบรวมการใช้งาน การคิดเงินและโควตารวมศูนย์ การใช้ token การแคชฮิต เวลาตอบกลับของทุกคำขอถูกบันทึกที่ชั้นนี้ เปิดอินเทอร์เฟซสอบถามการใช้งานรวมศูนย์ให้ภายนอก
ชั้นที่สี่ การสังเกตได้ ล็อก การติดตามเส้นทาง การรวมรหัสข้อผิดพลาด ทุกคำขอมี trace_id ติดตามได้ตลอดสายตั้งแต่ทางเข้าถึงทางออก รหัสข้อผิดพลาดแมปรวมศูนย์ที่ชั้นนี้ กฎการแจ้งเตือนก็ตั้งค่าที่ชั้นนี้เท่านั้น
โค้ดธุรกิจเรียกแค่อินเทอร์เฟซของชั้นแรก สามชั้นที่เหลือโปร่งใสต่อมัน ข้อดีของวิธีนี้คือ — เปลี่ยนโมเดลไม่ต้องแก้โค้ดธุรกิจ เพิ่มโมเดลไม่ต้องแก้โค้ดธุรกิจ ปรับกลยุทธ์เส้นทางก็ไม่ต้องแก้โค้ดธุรกิจ ทีมธุรกิจแค่ต้องสนใจว่า "ฉันจะเรียกโมเดลหนึ่ง" ที่เหลือยกให้เกตเวย์
หก: ข้อเตือนให้ระวังหลุม
อย่า import SDK ของแต่ละเจ้าโดยตรงในโค้ดธุรกิจ เมื่อผู้ให้บริการอัปเกรดอินเทอร์เฟซหรือคุณจะเปลี่ยนโมเดล พื้นที่ที่ต้องแก้จะแผ่กว้างมาก เราเคยเห็นทีมที่เรียก SDK โดยตรงในโค้ดธุรกิจ ภายหลังเปลี่ยนโมเดลต้องแก้กว่าสามสิบไฟล์ ทดสอบหนึ่งสัปดาห์ถึงออนไลน์ได้
ชั้นเชื่อมต่อเพิ่มเวลาสองวัน ประหยัดได้สองสัปดาห์ภายหลัง อัตราส่วนผลตอบแทนการลงทุนนี้พิสูจน์แล้วจริง ๆ ในที่ของเรา — หลังเกตเวย์ออนไลน์ การเพิ่มโมเดลใหม่แค่ต้องเพิ่มอะแดปเตอร์หนึ่งตัวที่ชั้นเกตเวย์ โค้ดธุรกิจไม่ต้องแก้อะไรเลย ครึ่งวันก็เชื่อมต่อและทดสอบเสร็จ
อีกสองคำแนะนำเล็ก ๆ: หนึ่งคือทำการรวบรวมการใช้งานให้เร็วที่สุด อย่ารอจนการเงินกระทบยอดถึงพบว่าคำนวณไม่ชัดเจน สองคือตารางแมปรหัสข้อผิดพลาดต้อง maintain ต่อเนื่อง สิ่งแรกที่ต้องทำเมื่อผู้ให้บริการใหม่เชื่อมต่อคือเติมการแมปรหัสข้อผิดพลาดให้ครบ
ผู้เขียน: ซุนฮ่าวหราน
วันที่เผยแพร่: 9 พฤศจิกายน 2026