สตรีมมิ่งผ่านพร็อกซี: chunked, SSE และ long-polling แบบไม่บัฟเฟอร์
บทความ
- บทนำ: ทำไม http แบบสตรีมมิ่งผ่านพร็อกซีจึงกลายเป็นปัญหากันถ้วนหน้า
- พื้นฐาน: http response ธรรมดา ๆ กลายเป็นสตรีมได้อย่างไร
- เจาะลึก: สตรีมติดขัดที่โหนดกลางตรงไหนและทำไม
- วิธีที่ 1: chunked transfer encoding — สตรีมระดับต่ำแบบไม่มีอะไรห่อหุ้ม
- วิธีที่ 2: server-sent events — มาตรฐานสำหรับส่งเหตุการณ์จากเซิร์ฟเวอร์ไปไคลเอนต์
- วิธีที่ 3: long-polling — สตรีมจากลำดับของคำตอบธรรมดา
- วิธีที่ 4: บริโภคคำตอบแบบสตรีมผ่านพร็อกซีขาออก
- ข้อผิดพลาดทั่วไปในการทำงานกับสตรีมผ่านพร็อกซี
- เครื่องมือและทรัพยากรสำหรับตั้งค่าและวินิจฉัย
- เคสและผลลัพธ์: สิ่งนี้หน้าตาเป็นอย่างไรในโปรเจกต์จริง
- Faq: คำถามเชิงลึกเรื่องการตอบกลับแบบสตรีมผ่านพร็อกซี
- บทสรุป: สรุปและก้าวต่อไป
บทนำ: ทำไม HTTP แบบสตรีมมิ่งผ่านพร็อกซีจึงกลายเป็นปัญหากันถ้วนหน้า
ลองนึกภาพ: คุณส่งคำขอไปยังโมเดลภาษา แล้วแทนที่จะเห็นโทเคนทยอยพิมพ์ออกมา กลับเงียบไปสี่สิบวินาที แล้วปาทั้งคำตอบออกมาเป็นก้อนเดียว หรือแดชบอร์ดที่ต้องอัปเดตทุกวินาที กลับโชว์ข้อมูลช้ากว่าครึ่งนาที หรือตัวดึงข้อมูลที่ฟังสตรีมเหตุการณ์จากตลาดซื้อขาย ได้รับเป็นชุดละร้อยเหตุการณ์แทนที่จะไหลมาเรื่อย ๆ เก้าในสิบครั้งคนที่ผิดไม่ใช่เซิร์ฟเวอร์และไม่ใช่ไคลเอนต์ แต่เป็นคนที่ยืนอยู่กลางระหว่างทั้งสอง: พร็อกซี โหลดบาลานเซอร์ CDN หรือเกตเวย์องค์กรที่ตัดสินใจ "ช่วย" ด้วยการกองคำตอบไว้ให้ครบก่อนส่งต่อ
เรื่องการตอบกลับแบบสตรีมมิ่งผ่านโหนดกลางเคยถูกมองว่าเป็นเรื่องเฉพาะกลุ่ม แต่ในปี 2026 มันกลายเป็นเรื่องที่เจอกันทั่วไปหมด ทั้งการสตรีมโทเคนจาก LLM-API เซิร์ฟเวอร์อีเวนต์ในเว็บอินเทอร์เฟซ long-polling ในแอปแชตและบอต แถบความคืบหน้าของการเอ็กซ์พอร์ตยาว ๆ และการดึงผลลัพธ์แบบสตรีม ทั้งหมดนี้ทำงานบน HTTP ธรรมดา ๆ ที่แค่ไม่รีบปิดคำตอบ และทั้งหมดนี้พังทันทีที่มีโหนดที่เปิดบัฟเฟอร์โผล่มาขวางทาง
ในคู่มือนี้ เราจะเจาะลึกสามกลไกคลาสสิก — chunked transfer encoding, Server-Sent Events และ long-polling — ในมุมของการเดินทางผ่านพร็อกซีโดยเฉพาะ ขอออกตัวก่อนเลยว่า ที่นี่จะไม่มี WebSocket และ gRPC เพราะมีบทความแยกต่างหากสำหรับสองอย่างนั้น และความต่างก็เป็นเรื่องพื้นฐานเลย ที่นั่นมีการอัปเกรดโปรโตคอลหรือใช้เฟรมไบนารีบน HTTP/2 และพร็อกซีต้องรู้จักจับและปล่อยการอัปเกรดนั้นให้ได้ ส่วนที่นี่คือ HTTP response ธรรมดา ๆ ที่ไม่มีคอนเทนต์-เลngth และเซิร์ฟเวอร์เปิดค้างไว้ ไม่มีแฮนด์เชค ไม่มีการสลับโปรโตคอล ฟังดูแล้วน่าจะง่ายที่สุดในโลก แต่ความง่ายนี่แหละที่สร้างปัญหา เพราะพร็อกซีมองไม่เห็นอะไรเป็นพิเศษ จึงใช้กฎบัฟเฟอร์มาตรฐานที่ออกแบบมาสำหรับคำตอบสั้น ๆ
สิ่งที่คุณจะได้จากบทความนี้: เข้าใจว่าสตรีมทำงานอย่างไรในระดับไบต์และเฮดเดอร์ แผนที่ทุกจุดที่คำตอบอาจติดขัด คอนฟิกสำเร็จรูปสำหรับ nginx, HAProxy, Envoy และไลบรารีฝั่งไคลเอนต์ เฟรมเวิร์กการเลือกใช้ระหว่างสามกลไก เช็คลิสต์การวินิจฉัย และเคสจริงพร้อมตัวเลข บทความนี้เขียนสำหรับนักพัฒนา วิศวกร DevOps และทุกคนที่ใช้พร็อกซีทำงานกับ API การดึงข้อมูล และงานอัตโนมัติ
พื้นฐาน: HTTP response ธรรมดา ๆ กลายเป็นสตรีมได้อย่างไร
สองวิธีบอกความยาวของคำตอบ
ใน HTTP/1.1 มีวิธีพื้นฐานสองวิธีในการบอกไคลเอนต์ว่าเนื้อหาคำตอบจบตรงไหน วิธีแรกคือเฮดเดอร์ Content-Length: เซิร์ฟเวอร์ประกาศจำนวนไบต์ที่แน่นอนล่วงหน้า วิธีที่สองคือ Transfer-Encoding: chunked: เซิร์ฟเวอร์ส่งเนื้อหาเป็นท่อน ๆ แต่ละท่อนเริ่มด้วยขนาดของมันในรูปแบบเลขฐานสิบหก และจบทั้งหมดด้วยชังก์ขนาดศูนย์ ยังมีวิธีที่สามแบบโบราณ คือแค่ปิดการเชื่อมต่อหลังไบต์สุดท้าย แต่แทบไม่มีการใช้กับ keep-alive
ทำไมเรื่องนี้ถึงสำคัญกับสตรีม? เพราะ Content-Length ต้องรู้ขนาดล่วงหน้า ถ้าเซิร์ฟเวอร์สร้างคำตอบขึ้นมาทีละนิด — ทีละโทเคน ทีละเหตุการณ์ — มันคำนวณความยาวก่อนเริ่มส่งไม่ได้เลย ทางเดียวใน HTTP/1.1 คือ chunked ส่วนใน HTTP/2 และ HTTP/3 ไม่มีการเข้ารหัสแบบ chunked อยู่แล้ว เพราะเนื้อหาส่งเป็นเฟรม DATA อยู่แล้ว และจุดสิ้นสุดบอกด้วยแฟล็ก END_STREAM แต่ตรรกะก็เหมือนกัน: คำตอบที่ไม่ประกาศความยาวและยืดได้นานเท่าที่ต้องการ
การ "ไม่ปิดคำตอบ" หมายถึงอะไร
อุปมาเทียบให้เห็นภาพ HTTP response ปกติก็เหมือนพัสดุ: คุณได้กล่องที่เขียนน้ำหนักไว้ เปิดออกก็รู้ว่าข้างในมีอะไรครบ ส่วนแบบสตรีมก็เหมือนสายพานลำเลียง: กล่องวิ่งมาเรื่อย ๆ และคุณไม่รู้ว่าสายพานจะหยุดเมื่อไหร่ เซิร์ฟเวอร์ส่งเฮดเดอร์พร้อมสถานะ 200 ส่งชังก์แรก แล้วก็รอ มีข้อมูลใหม่ก็ส่งชังก์ต่อไป การเชื่อมต่อเปิดค้างเป็นนาที เป็นชั่วโมง บางทีเป็นวัน
ในมุมของ TCP ก็ไม่มีอะไรแปลก: ซ็อกเก็ตเดิม เซกเมนต์เดิม แต่ในมุมของ HTTP นี่คือหนึ่งคำขอและหนึ่งคำตอบ แค่ยาวมาก และตรงนี้แหละคือรากของปัญหาทั้งหมดกับพร็อกซี: โหนดกลางเห็นจุดเริ่มต้นของคำตอบ แต่ไม่เห็นจุดจบ จึงต้องตัดสินใจว่าจะทำยังไงกับไบต์ที่มาถึงแล้ว จะส่งต่อทันที? หรือรอ กองเพิ่ม แล้วส่งให้มีประสิทธิภาพกว่า? โดยค่าเริ่มต้น พร็อกซีส่วนใหญ่เลือกอย่างที่สอง
สามกลไก: สิ่งที่เหมือนและต่างกัน
- Chunked streaming — ระดับต่ำสุด เซิร์ฟเวอร์แค่เขียนไบต์ลงในเนื้อหาและเรียก flush รูปแบบเนื้อหาเป็นอะไรก็ได้: ข้อความ, NDJSON, ข้อมูลไบนารี ไคลเอนต์ตัดสินใจเองว่าจะแยกวิเคราะห์ยังไง
- Server-Sent Events — รูปแบบข้อความมาตรฐานบน chunked stream มี Content-Type: text/event-stream แต่ละอีเวนต์คั่นด้วยบรรทัดว่าง มีฟิลด์ data, event, id, retry เบราว์เซอร์รองรับผ่าน EventSource พร้อมเชื่อมต่อใหม่ให้เองอัตโนมัติ
- Long-polling — ถ้าพูดตรง ๆ ไม่ใช่สตรีม ไคลเอนต์ส่งคำขอ เซิร์ฟเวอร์เปิดค้างไว้จนมีข้อมูลหรือจนหมดเวลา แล้วตอบและปิด ไคลเอนต์ก็ยิงคำขอใหม่ทันที เป็นการจำลองสตรีมด้วยลำดับของคำตอบธรรมดา ซึ่งแต่ละอันมี Content-Length ได้
สามอย่างนี้มีอะไรเหมือนกัน? ทั้งสามกรณีคำตอบต่อหนึ่งคำขอถูกหน่วงไว้เป็นเวลาที่ไม่แน่นอน และพร็อกซีต้องทนให้ได้: ห้ามตัดการเชื่อมต่อตาม timeout และห้ามหน่วงข้อมูลไว้ในบัฟเฟอร์ ความต่างอยู่ที่ว่าแต่ละกลไกพึ่งพาความโปร่งใสของโหนดกลางมากแค่ไหน Chunked กับ SSE พึ่งพาอย่างวิกฤต ส่วน long-polling พึ่งน้อยที่สุด และนั่นคือข้อได้เปรียบหลักของมัน
บทบาทของพร็อกซีในห่วงโซ่
ระหว่างไคลเอนต์กับเซิร์ฟเวอร์ในโครงสร้างพื้นฐานสมัยใหม่ แทบไม่เคยว่างเปล่า ห่วงโซ่ทั่วไปคือ: แอปไคลเอนต์ — พร็อกซีขาออก (เช่น พร็อกซีมือถือหรือเรสซิเดนเชียล) — อินเทอร์เน็ต — CDN — โหลดบาลานเซอร์บนคลาวด์ — รีเวิร์สพร็อกซี — แอปพลิเคชัน แต่ละโหนดในนี้คือจุดบัฟเฟอร์ที่เป็นไปได้ และแต่ละโหนดก็ตั้งค่าเริ่มต้นมาเพื่อเพิ่มประสิทธิภาพของคำตอบสั้น: รวม บีบอัด ส่งทั้งก้อน สำหรับสตรีม การเพิ่มประสิทธิภาพแบบนี้คือหายนะ เราจะค่อย ๆ แกะแต่ละชั้นออกมาดูว่าเกิดอะไรขึ้น
เจาะลึก: สตรีมติดขัดที่โหนดกลางตรงไหนและทำไม
ทำไมพร็อกซีถึงบัฟเฟอร์กัน
ก่อนจะด่าบัฟเฟอร์ ควรเข้าใจตรรกะของมันก่อน รีเวิร์สพร็อกซีอย่าง nginx บัฟเฟอร์ด้วยเหตุผลสามข้อ ข้อแรก — ปกป้องแบ็กเอนด์จากไคลเอนต์ที่ช้า: ถ้าไคลเอนต์บนเครือข่ายมือถืออ่านสิบกิโลไบต์ต่อวินาที แต่แบ็กเอนด์สร้างคำตอบเสร็จแล้ว การดึงทั้งหมดจากแบ็กเอนด์ทันที ปลดเวิร์กเกอร์ให้ว่าง แล้วค่อยส่งให้ไคลเอนต์จากบัฟเฟอร์ทีหลังนั้นคุ้มกว่า ข้อที่สอง — การบีบอัด: gzip และ brotli ทำงานได้มีประสิทธิภาพกว่ากับบล็อกใหญ่ ข้อที่สาม — โอกาสตั้ง Content-Length และจัดการข้อผิดพลาดของแบ็กเอนด์ก่อนส่งเฮดเดอร์ให้ไคลเอนต์ได้อย่างถูกต้อง
สำหรับ API ทั่วไปที่ตอบกลับไม่กี่กิโลไบต์ ทั้งหมดนี้สมเหตุสมผลและประหยัดทรัพยากร แต่สำหรับสตรีมกลับตรงกันข้าม: การหน่วงไบต์ไว้ทำลายคุณค่าของสตรีมทิ้งไปเลย คุณค่านั้นอยู่ที่ความทันเวลา ไม่ใช่ปริมาณ
แผนที่แปดจุดบัฟเฟอร์
ไล่ไปตามห่วงโซ่และทำเครื่องหมายทุกจุดที่ข้อมูลอาจติดขัด เก็บลิสต์นี้ไว้ใกล้มือเวลาวินิจฉัย
- แอปพลิเคชัน เฟรมเวิร์กอาจบัฟเฟอร์เอาต์พุตเองได้ WSGI server, PHP ที่เปิด output_buffering, เฟรมเวิร์ก Node.js ที่มีมิดเดิลแวร์บีบอัด ไม่เรียก flush — ข้อมูลก็นอนอยู่ในบัฟเฟอร์ของโปรเซส
- รีเวิร์สพร็อกซีหน้าแอป nginx ที่ proxy_buffering on (เปิดเป็นค่าเริ่มต้น) กองคำตอบในบัฟเฟอร์ที่กำหนดด้วย proxy_buffer_size และ proxy_buffers และเมื่อเต็มก็เขียนลงไฟล์ชั่วคราวบนดิสก์ Apache mod_proxy บัฟเฟอร์น้อยกว่าแต่ก็มีการตั้งค่าของตัวเอง Caddy โดยค่าเริ่มต้นไม่บัฟเฟอร์ แต่ flush_interval ควรเช็กดู
- การบีบอัดบนพร็อกซี แม้ proxy_buffering off แต่ gzip ที่เปิดอยู่จะสะสมข้อมูลจนถึงขนาดหน้าต่างบีบอัด นี่คือหนึ่งในจุดที่ร้ายกาจที่สุด: บัฟเฟอร์ถูกปิดในนาม แต่สตรีมยังไหลเป็นห้วง ๆ
- โหลดบาลานเซอร์ L7 HAProxy ในโหมด http ส่งข้อมูลทันทีที่มาถึง ถ้าไม่เปิด http-buffer-request แต่ถูกจำกัดด้วยขนาด tune.bufsize ส่วน Envoy โดยค่าเริ่มต้นสตรีมอยู่แล้ว แต่ฟิลเตอร์บีบอัดหรือ Lua อาจกองเนื้อหาไว้ได้
- CDN และเกตเวย์คลาวด์ CDN หลายเจ้าบัฟเฟอร์คำตอบเพื่อแคชและบีบอัด ผู้ให้บริการบางรายไม่รองรับสตรีมที่ยาวเกินเวลาที่กำหนด หรือต้องตั้งค่าเฉพาะ API เกตเวย์บนคลาวด์มักมีลิมิตเวลาตอบกลับแข็ง ๆ ราว 30 วินาที และไม่รองรับการสตรีมเนื้อหาเลยด้วยซ้ำ
- พร็อกซีขาออกฝั่งไคลเอนต์ HTTP พร็อกซีที่คุณใช้ออกอินเทอร์เน็ต — ทั้งขององค์กร มือถือ เรสซิเดนเชียล — ก็เป็น HTTP parser เหมือนกัน ถ้าสร้างบน nginx หรือ Squid และตั้งให้บัฟเฟอร์ สตรีมก็จะติดอยู่ตรงนั้น บริการพร็อกซีคุณภาพดีจะปล่อย chunked response ผ่านแบบโปร่งใส แต่ต้องทดสอบจริงถึงจะรู้
- TLS และ TCP ข้อมูลอาจค้างใน TLS record ถ้าไลบรารีรวบรวมจนได้ขนาด 16 กิโลไบต์ อัลกอริทึมของ Nagle หน่วง TCP เซกเมนต์เล็ก ๆ จนได้รับ ack ของอันก่อนหน้า สำหรับสตรีมที่ประกอบด้วยชังก์เล็ก ๆ เรื่องนี้เพิ่มเวลาหลายสิบมิลลิวินาทีต่อชังก์
- ไลบรารีฝั่งไคลเอนต์ requests ใน Python อ่านเนื้อหาทั้งหมดเข้า memory ถ้าไม่ส่ง stream=True HTTP client หลายตัวบัฟเฟอร์จนถึงขนาด chunk_size
แปดจุด ถ้ามีจุดใดจุดหนึ่งกองข้อมูลอยู่ คุณจะเห็นสตรีมเป็นห้วง ๆ หรือเป็นก้อนใหญ่ก้อนเดียวตอนจบ และที่แย่ที่สุดคือ พฤติกรรมขึ้นอยู่กับปริมาณ บนคำตอบเล็ก ๆ ทุกอย่างดูปกติ แต่พอเจอโหลดหนักหรือคำตอบยาว บัฟเฟอร์เต็ม ก็เริ่มเขียนลงไฟล์ชั่วคราว และความหน่วงก็พุ่งพรวด ไม่แปลกใจเลยที่หลายทีมเจอปัญหาเฉพาะในโปรดักชัน
HTTP/1.1 กับ HTTP/2 ในบริบทของสตรีม
ใน HTTP/1.1 หนึ่งการเชื่อมต่อรองรับได้หนึ่งคำตอบในแต่ละขณะ คำตอบอายุยืนก็ยึดการเชื่อมต่อทั้งเส้น เบราว์เซอร์จำกัดจำนวนการเชื่อมต่อพร้อมกันต่อโฮสต์ไว้ที่หกเส้น ดังนั้น SSE stream หกเส้นที่เปิดอยู่ก็บล็อกคำขออื่นทั้งหมดไปยังโฮสต์นั้น พร็อกซีที่คุยกับแบ็กเอนด์ผ่าน HTTP/1.1 ก็ถือหนึ่งการเชื่อมต่อต่อหนึ่งสตรีมเช่นกัน
ใน HTTP/2 การมัลติเพล็กซ์ลบข้อจำกัดนี้ออก: สตรีมร้อยเส้นอยู่ในการเชื่อมต่อ TCP เดียวได้ แต่ก็มีจุดละเอียดตามมา — การควบคุมการไหลในระดับโปรโตคอล ถ้าฝ่ายรับไม่ขยายหน้าต่างผ่าน WINDOW_UPDATE ฝ่ายส่งก็หยุด พร็อกซีบางตัวส่งต่อเฟรมเหล่านี้อย่างไม่ประณีตและสร้างการหยุดชั่วคราวเทียมขึ้นมา
สิ่งสำคัญที่ต้องเข้าใจคือ พร็อกซีอาจรับคำขอจากไคลเอนต์ทาง HTTP/2 แล้วต่อไปยังแบ็กเอนด์ทาง HTTP/1.1 มันจะ repack เฟรม DATA เป็นชังก์และกลับกัน นี่เป็นปฏิบัติการปกติ แต่ตรงรอยต่อการแปลงนี้แหละที่มักเสียการ flush ทันเวลา — พร็อกซีรอจนได้ขนาดเฟรมที่ "สะดวก"
Timeout — ฆาตกรตัวที่สองของสตรีม
บัฟเฟอร์หน่วงข้อมูล ส่วน timeout ตัดการเชื่อมต่อ nginx มี proxy_read_timeout — เวลาสูงสุดระหว่างการอ่านสองครั้งติดกันจากแบ็กเอนด์ ค่าเริ่มต้น 60 วินาที ถ้าเซิร์ฟเวอร์เงียบนานกว่านั้น nginx จะปิดการเชื่อมต่อและคืน 504 ให้ไคลเอนต์ สำหรับ long-polling ที่รอ 90 วินาที นี่คือความล้มเหลวแบบการันตี HAProxy มี timeout server และ timeout tunnel ส่วนโหลดบาลานเซอร์บนคลาวด์มี idle timeout มัก 60 หรือ 350 วินาที และผู้ให้บริการมือถือมี NAT-timeout ที่รีเซ็ตการเชื่อมต่อที่ไม่มีกิจกรรมภายในไม่กี่นาที
จากตรงนี้ได้กฎเหล็กเลย: สตรีมที่ไม่มีความเคลื่อนไหวเป็นระยะถึงวาระแน่นอน การส่ง heartbeat ทุก 15-30 วินาทีไม่ใช่ตัวเลือก แต่เป็นข้อบังคับของคำตอบอายุยืนทุกอัน
เมทริกซ์การเลือกกลไก
ก่อนลงมือปฏิบัติ มาเคลียร์เฟรมเวิร์กการเลือกกันก่อน ตอบสี่คำถามนี้
- คุณควบคุมห่วงโซ่พร็อกซีทั้งหมดไหม? ควบคุมได้ — chunked และ SSE ใช้ได้ ไม่ได้ และมีเกตเวย์ที่ไม่รู้จักในห่วงโซ่ — เริ่มจาก long-polling หรือเตรียมทางถอยไปหามัน
- ไคลเอนต์คือใคร? เบราว์เซอร์ — SSE กับ EventSource ได้การเชื่อมต่อใหม่ฟรี โค้ดของคุณเอง — chunked กับ NDJSON ยืดหยุ่นกว่า
- ข้อมูลมีธรรมชาติเป็นอย่างไร? ชิ้นส่วนของสิ่งเดียวกัน (โทเคนของคำตอบเดียว) — chunked หรือ SSE เหตุการณ์แยกกันอิสระ — SSE หรือ long-polling
- ความถี่เป็นเท่าไร? หลายสิบเหตุการณ์ต่อวินาที — chunked หรือ SSE แบบแบตช์ เหตุการณ์ทุกนาที — long-polling timeout ยาว หรือ SSE พร้อม heartbeat
วิธีที่ 1: chunked transfer encoding — สตรีมระดับต่ำแบบไม่มีอะไรห่อหุ้ม
เมื่อไหร่ควรเลือก chunked ล้วน ๆ
chunked stream ล้วน ๆ เหมาะเมื่อไคลเอนต์เป็นโค้ดของคุณเอง ไม่ใช่เบราว์เซอร์ เมื่อรูปแบบข้อมูลไม่ใช่ข้อความ หรือไม่เข้าทรงกับโมเดลอีเวนต์ เมื่อต้องการควบคุมทุกไบต์อย่างสูงสุด ตัวอย่างทั่วไป: สตรีม NDJSON จาก API, ดึงผลลัพธ์การพาร์สแบบสตรีม, ดาวน์โหลดเอ็กซ์พอร์ตใหญ่พร้อมตัวบ่งชี้ความคืบหน้า, พร็อกซีคำตอบ LLM ในรูปแบบของตัวเอง
ตั้งค่าฝั่งเซิร์ฟเวอร์ทีละขั้น
- ตรวจสอบว่าแอปเขียนทีละส่วน หลังแต่ละส่วนเชิงตรรกะ ให้เรียก flush ใน Python กับ ASGI server นี่คือเจนเนอเรเตอร์ที่ yield ไบต์ ใน Node.js คือ res.write แล้ว flush ถ้ามีการบีบอัด ใน Go คืออินเทอร์เฟซ http.Flusher หลังทุก Write
- อย่าตั้ง Content-Length เฟรมเวิร์กส่วนใหญ่จะสลับเป็น chunked เองถ้าไม่กำหนดความยาว ตรวจสอบว่าคำตอบใน HTTP/1.1 มี Transfer-Encoding: chunked
- ปิดการบีบอัดในระดับแอป สำหรับเส้นทางสตรีม หรือตรวจสอบให้แน่ใจว่ามัน flush พร้อมกับข้อมูล ทางออกประนีประนอมคือ gzip พร้อม flush แบบ synchronous หลังทุกชังก์ วิธีนี้ใช้ได้แต่ลดอัตราการบีบอัด
- ตั้งเฮดเดอร์ X-Accel-Buffering: no นี่คือเฮดเดอร์เฉพาะของ nginx ที่ปิดบัฟเฟอร์สำหรับคำตอบนั้นโดยไม่ต้องแก้คอนฟิกทั้งหมด พร็อกซีบางตัวอื่นก็เข้าใจเฮดเดอร์นี้ด้วย เพิ่ม Cache-Control: no-cache, no-transform อีกด้วย — ค่าที่สองขอให้โหนดกลางอย่าแก้เนื้อหา
- ตั้งค่ารีเวิร์สพร็อกซี สำหรับ nginx ใน location ของเส้นทางสตรีม:
proxy_buffering off; proxy_cache off; proxy_http_version 1.1; proxy_set_header Connection ''; proxy_read_timeout 3600s; gzip off;ไดเรกทีฟ proxy_http_version 1.1 บังคับ เพราะค่าเริ่มต้น nginx คุยกับแบ็กเอนด์ทาง HTTP/1.0 ซึ่งไม่มี chunked และ nginx ต้องบัฟเฟอร์จนกว่าการเชื่อมต่อจะปิด - แยกเส้นทาง ถ้าต้องการบีบอัดสำหรับ API ส่วนอื่น ให้เปิดเฉพาะใน location block ที่ไม่ใช่สตรีม
- ตรวจสอบอัลกอริทึมของ Nagle ใน nginx tcp_nodelay เปิดเป็นค่าเริ่มต้น แต่ในแอปที่มีชังก์เล็ก ๆ ถี่ ๆ อาจต้องตั้ง TCP_NODELAY บนซ็อกเก็ตอย่างชัดเจน
คอนฟิก HAProxy และ Envoy
HAProxy ในเซกชัน backend อย่าใช้ option http-buffer-request ตรวจสอบว่า timeout server ยาวพอสำหรับสถานการณ์ของคุณ และสำหรับสตรีมที่ยาวจริง ๆ ให้ตั้ง timeout tunnel ปิดการบีบอัดสำหรับเส้นทางสตรีมผ่าน ACL หรือพึ่งเฮดเดอร์ no-transform: HAProxy เคารพ Cache-Control: no-transform และจะไม่บีบอัดคำตอบแบบนั้น
Envoy การบัฟเฟอร์ปิดเป็นค่าเริ่มต้น ซึ่งน่าดีใจ แต่เช็ก timeout สองตัว: stream_idle_timeout ใน HTTP connection manager (ค่าเริ่มต้นห้านาที) และ route timeout (ค่าเริ่มต้นสิบห้าวินาที — นี่แหละที่มักตัดสตรีมบ่อยที่สุด) สำหรับเส้นทางสตรีม ตั้ง timeout เป็น 0s ซึ่งหมายถึงไม่มีลิมิต และพึ่ง idle timeout ควบคู่กับ heartbeat
เช็คลิสต์ตรวจสอบ chunked stream
- ในคำตอบมี Transfer-Encoding: chunked หรือใช้ HTTP/2 โดยไม่มี Content-Length
- เฮดเดอร์ X-Accel-Buffering: no ปรากฏในคำตอบของแอป
- ไม่มี Content-Encoding หรือการบีบอัด flush พร้อมกับข้อมูล
- ไบต์แรกของเนื้อหามาถึงภายในหนึ่งวินาทีหลังเฮดเดอร์
- ช่วงห่างระหว่างชังก์ที่ไคลเอนต์ตรงกับช่วงที่เซิร์ฟเวอร์สร้าง ด้วยความคลาดเคลื่อนไม่เกิน 50 มิลลิวินาที
- การเชื่อมต่ออยู่ได้นานกว่าหนึ่งนาทีโดยไม่ขาดเมื่อมี heartbeat
- ไม่มีบันทึกในล็อกพร็อกซีเรื่องการบัฟเฟอร์ลงไฟล์ชั่วคราว
วิธีที่ 2: Server-Sent Events — มาตรฐานสำหรับส่งเหตุการณ์จากเซิร์ฟเวอร์ไปไคลเอนต์
โครงสร้างของรูปแบบ
SSE เป็นข้อตกลงว่าเราจะจัดเรียงเหตุการณ์ในสตรีมข้อความอย่างไร คำตอบมี Content-Type: text/event-stream แต่ละเหตุการณ์คือชุดบรรทัดรูป "ฟิลด์: ค่า" ปิดท้ายด้วยบรรทัดว่าง ฟิลด์มี: data — เพย์โหลด (ซ้ำได้ บรรทัดจะถูกเชื่อมด้วยขึ้นบรรทัดใหม่); event — ชื่อประเภทเหตุการณ์; id — ตัวระบุสำหรับกลับมาต่อ; retry — เวลาหน่วงที่แนะนำก่อนเชื่อมต่อใหม่เป็นมิลลิวินาที บรรทัดที่เริ่มด้วยเครื่องหมายโคลอนคือคอมเมนต์ และนี่คือ heartbeat ที่สมบูรณ์แบบ: เบราว์เซอร์มองข้าม แต่พร็อกซีเห็นว่ามีกิจกรรมบนการเชื่อมต่อ
ความสวยงามของ SSE อยู่ที่ความไม่สมมาตร ความซับซ้อนถูกยกไปไว้ในสเปกและเบราว์เซอร์ ส่วนเซิร์ฟเวอร์ก็เรียบง่าย ไม่มีแฮนด์เชค ไม่มีเฟรมไบนารี แค่ข้อความที่ไหลไป นี่แหละที่ทำให้ SSE กลายเป็นมาตรฐานโดยพฤตินัยสำหรับสตรีมคำตอบของโมเดลภาษา: LLM-API ระดับใหญ่มากมายส่งโทเคนในรูปแบบ text/event-stream น่าทึ่งที่เทคโนโลยีที่ถูกอธิบายในสเปกมานานกว่าสิบห้าปี กลับมาฟื้นตัวครั้งที่สองในปี 2026
ทำไม SSE ถึงไวต่อการบัฟเฟอร์เป็นพิเศษ
เหตุการณ์หนึ่งอันใน SSE หนักตั้งแต่ไม่กี่สิบไบต์ถึงสองสามกิโลไบต์ บัฟเฟอร์เริ่มต้นของ nginx คือ 4 หรือ 8 กิโลไบต์สำหรับบล็อกแรก และอีกแปดบล็อกละ 4-8 กิโลไบต์ต่อจากนั้น นั่นแปลว่าพร็อกซีจะกองตั้งแต่ห้าสิบถึงหลายร้อยเหตุการณ์ก่อนจะปล่อยอันแรกออก สำหรับแชตกับโมเดล อาการคือ: ผู้ใช้รอสิบห้าวินาที แล้วทั้งย่อหน้าปรากฏพรวดทันที ภาพลวงตาของการพิมพ์ทีละตัวพังทลาย ทั้งที่มันคือเหตุผลที่เราติดตั้งสตรีมมิ่งตั้งแต่แรก
ใช้งาน SSE ผ่านพร็อกซีทีละขั้น
- เฮดเดอร์คำตอบ: Content-Type: text/event-stream; charset=utf-8, Cache-Control: no-cache, no-transform, X-Accel-Buffering: no, และสำหรับ HTTP/1.1 เพิ่ม Connection: keep-alive
- Heartbeat ส่งบรรทัดคอมเมนต์แบบ
: pingทุก 15-25 วินาที ซึ่งน้อยกว่า idle-timeout ที่สมเหตุสมผลใด ๆ และรักษาตาราง NAT ของผู้ให้บริการให้ตื่นอยู่ - ตัวระบุเหตุการณ์ ให้ทุกเหตุการณ์มี id เพิ่มขึ้นแบบโมโนโทนิก เมื่อเชื่อมต่อใหม่ เบราว์เซอร์จะส่งเฮดเดอร์ Last-Event-ID มาให้ และเซิร์ฟเวอร์จะส่งย้อนหลังส่วนที่พลาดได้ ถ้าไม่มีเรื่องนี้ การขาดตอนใด ๆ ที่พร็อกซีก็คือข้อมูลหาย
- ฟิลด์ retry ตั้งค่าให้สมเหตุสมผล เช่น 3000 มิลลิวินาที เพื่อไม่ให้ไคลเอนต์ก่อพายุการเชื่อมต่อใหม่ตอนเซิร์ฟเวอร์รีสตาร์ต
- คอนฟิก nginx เหมือนกับ chunked เพิ่มเติมคือตรวจสอบให้แน่ใจว่าไม่ใช้ gzip กับ text/event-stream: ถ้า gzip_types มี text/* ให้เพิ่ม location แยกที่ gzip off
- วางแผนจำนวนการเชื่อมต่อ SSE stream หนึ่งอันที่เปิดอยู่บน HTTP/1.1 คือการเชื่อมต่อหนึ่งเส้นระหว่างพร็อกซีกับแบ็กเอนด์ สำหรับไคลเอนต์หนึ่งพันรายพร้อมกัน ก็ต้องใช้หนึ่งพันการเชื่อมต่อ ให้ใช้ HTTP/2 ฝั่งไคลเอนต์และเซิร์ฟเวอร์แบบอะซิงโครนัสฝั่งแบ็กเอนด์
- จัดการการปิด เซิร์ฟเวอร์ต้องตรวจจับได้ว่าไคลเอนต์ตัดการเชื่อมต่อและหยุดสร้างข้อมูล ผ่านพร็อกซีเรื่องนี้เกิดช้า: เซิร์ฟเวอร์จะรู้ว่าขาดตอนเมื่อลองเขียนเท่านั้น สำหรับงานแพง ๆ อย่างการอนุมานโมเดล นั่นคือวินาทีพิเศษที่ GPU ทำงานทิ้งเปล่า ทางออกคือการเขียน heartbeat เป็นระยะ ซึ่งจะกระตุ้นให้เกิดข้อผิดพลาดในการเขียนเมื่อการเชื่อมต่อขาด
SSE กับ HTTP/2: จุดละเอียด
ผ่าน HTTP/2 SSE ทำงานได้โดยไม่มีข้อจำกัดหกการเชื่อมต่อ — นี่คือเหตุผลหลักที่ควรเปิด HTTP/2 บนพร็อกซีส่วนหน้า อย่างไรก็ตาม เมื่อแปลง HTTP/2 เป็น HTTP/1.1 ไปยังแบ็กเอนด์ พร็อกซีบางตัวเพิ่มความหน่วงเล็กน้อยจากการรวมเฟรม ตรวจสอบให้แน่ใจว่าอีเวนต์แรกออกทันที ไม่รอให้เฟรมเต็ม ถ้าแบ็กเอนด์พูด HTTP/2 ด้วย ความหน่วงก็ต่ำสุด แต่เช็กว่าพร็อกซีส่ง WINDOW_UPDATE ต่อได้อย่างถูกต้องและไม่รัดคอสตรีมด้วยการควบคุมหน้าต่าง
เฟรมเวิร์กออกแบบ SSE stream
- กำหนดประเภทเหตุการณ์และความถี่ เหตุการณ์ที่เกิดน้อยต้องมี heartbeat เหตุการณ์ที่เกิดถี่ควรแบตช์หลายรายการไว้ในเหตุการณ์เดียว
- เลือกกลยุทธ์การกลับมาต่อ: เก็บบัฟเฟอร์วงกลมของเหตุการณ์ล่าสุดบนเซิร์ฟเวอร์เพื่อจัดการ Last-Event-ID หรือพึ่งการซิงก์ใหม่ทั้งหมดเมื่อเชื่อมต่อใหม่
- กำหนดลิมิตอายุของแต่ละสตรีม แนวปฏิบัติที่ดีคือเซิร์ฟเวอร์ปิดสตรีมเองทุก 5-10 นาที แล้วไคลเอนต์เชื่อมต่อใหม่แบบโปร่งใส วิธีนี้ป้องกันการสะสมสถานะและเลี่ยง timeout ที่ซ่อนอยู่ในโครงสร้างพื้นฐาน
- คิดเรื่องทางถอย: ถ้าสตรีมผ่านพร็อกซีไม่ได้ ให้สลับไป long-polling อัตโนมัติ
วิธีที่ 3: long-polling — สตรีมจากลำดับของคำตอบธรรมดา
ทำงานอย่างไรและทำไมยังใช้ได้อยู่
long-polling เป็นเทคนิคที่เก่าแก่ที่สุดในสามอย่าง ไคลเอนต์ส่งคำขอ เซิร์ฟเวอร์ไม่ตอบทันที แต่รอเหตุการณ์จนถึง timeout ที่กำหนด (ปกติ 20-60 วินาที) มีเหตุการณ์มา — เซิร์ฟเวอร์ตอบและปิด ไม่มีอะไรมา — ก็ตอบว่าง ไคลเอนต์ยิงคำขอถัดไปทันที ในมุมมองภายนอกดูเหมือนสตรีมที่มีความหน่วงต่ำสุด แต่คำตอบแต่ละอันเป็นคำตอบธรรมดา มี Content-Length เข้ากันได้เต็มที่กับพร็อกซี แคช และเกตเวย์ทุกชนิด
ทำไมในปี 2026 long-polling ยังสุขภาพดีอยู่? เพราะมันผ่านได้ทุกที่ ผ่านเกตเวย์องค์กรที่ตัด chunked ผ่าน API เกตเวย์บนคลาวด์ที่มีลิมิตเวลาตอบกลับ ผ่านพร็อกซีที่บัฟเฟอร์แบบเดาไม่ได้ ตัวอย่างที่โด่งดังที่สุดคือเมธอดดึงอัปเดตใน Bot API ของแอปแชตยักษ์ใหญ่ ที่พารามิเตอร์ timeout กำหนดระยะเวลารอ บอตส่วนใหญ่ทำงานแบบนี้มาหลายปี ผ่านพร็อกซีหลากหลายแบบ โดยไม่มีปัญหา
ห้ากฎออกแบบ long-polling ผ่านพร็อกซี
- timeout ฝั่งเซิร์ฟเวอร์ต้องน้อยกว่า timeout ที่สั้นที่สุดในห่วงโซ่ ถ้าพร็อกซีมี proxy_read_timeout 60 วินาที การรอฝั่งเซิร์ฟเวอร์ต้องไม่เกิน 50 ถ้าในห่วงโซ่มีเกตเวย์คลาวด์ที่ 30 วินาที ก็ไม่เกิน 25 ไม่งั้นแทนที่จะได้คำตอบว่าง ไคลเอนต์จะได้ 504 และกระแสข้อผิดพลาดจะทำให้ระบบมอนิเตอร์เป็นบ้า
- เคอร์เซอร์หรือ offset ไคลเอนต์ส่งตัวระบุของเหตุการณ์ล่าสุดที่ได้รับ เซิร์ฟเวอร์ส่งทุกอย่างที่เกิดหลังจากนั้น โปรโตคอลกลายเป็น idempotent: คำตอบที่หายไปก็แค่ทำให้ส่งเหตุการณ์เดิมซ้ำ
- jitter ตอนเชื่อมต่อใหม่หลังข้อผิดพลาด การเพิ่มแบบเอกซ์โพเนนเชียล — 1, 2, 4, 8 วินาที — บวกกับค่าสุ่ม ถ้าไม่มี jitter ไคลเอนต์หนึ่งพันรายหลังเหตุขัดข้องจะถล่มเซิร์ฟเวอร์พร้อมกัน
- ไม่หยุดพักหลังคำตอบสำเร็จ คำขอถัดไปออกทันที การหยุดพักตรงนี้คือความหน่วงที่เสียเปล่า
- keep-alive เป็นข้อบังคับ ถ้าไม่มี ทุกคำขอคือ TCP connection ใหม่และ TLS handshake ใหม่ ซึ่งเพิ่ม 50-300 มิลลิวินาทีต่อรอบ และผ่านพร็อกซีระยะไกลยิ่งมากกว่า
ใช้งานทีละขั้น
- เซิร์ฟเวอร์: เอ็นด์พอยต์รับ offset และ timeout รอเหตุการณ์บนคิวภายในหรือผ่านการซับสคริปต์ ตอบกลับเป็นอาร์เรย์เหตุการณ์พร้อม offset ใหม่ อาร์เรย์ว่างคือคำตอบปกติ ไม่ใช่ข้อผิดพลาด
- พร็อกซี: คอนฟิกมาตรฐาน แต่ proxy_read_timeout ต้องไม่น้อยกว่า timeout ฝั่งเซิร์ฟเวอร์บวกสำรองสิบวินาที บัฟเฟอร์เปิดไว้ได้ — คำตอบสั้นและครบถ้วน
- ไคลเอนต์: ลูปจัดการผลลัพธ์สามแบบ — มีข้อมูล, คำตอบว่าง, ข้อผิดพลาด พูลการเชื่อมต่อเดียว, keep-alive, timeout ฝั่งไคลเอนต์มากกว่าฝั่งเซิร์ฟเวอร์
- การมอนิเตอร์: สัดส่วนคำตอบว่าง เวลารอเฉลี่ย ความถี่ของ 5xx และ timeout ฝั่งไคลเอนต์
เมื่อไหร่ long-polling แพ้
เมื่อเหตุการณ์เกิดถี่ ภาระของเฮดเดอร์และรอบคำขอ-ตอบกลับก็เริ่มเห็นได้ชัด เมื่อมีไคลเอนต์พันราย เซิร์ฟเวอร์ต้องถือคำขอที่รออยู่พันอัน — ถ้าไม่มีสแตกแบบอะซิงโครนัสก็ไม่ไหว และแน่นอน long-polling ไม่สะดวกสำหรับสตรีมคำตอบยาวอันเดียว ที่ต้องได้ลำดับของชิ้นส่วนของสิ่งเดียวกัน โทเคนของโมเดลภาษาผ่าน long-polling — ในทางทฤษฎีทำได้ แต่ในทางปฏิบัติเก้งก้าง
วิธีที่ 4: บริโภคคำตอบแบบสตรีมผ่านพร็อกซีขาออก
ลักษณะเฉพาะของสถานการณ์
จนถึงตอนนี้เรามองในมุมของเจ้าของเซิร์ฟเวอร์ ตอนนี้กลับภาพ: คุณคือไคลเอนต์ เข้าถึง API สตรีมของคนอื่นผ่านพร็อกซี และฝั่งที่คุณควบคุมได้มีแค่ไคลเอนต์ งานทั่วไป: เก็บข้อมูลจาก API สตรีมผ่านพูลของแอดเดรส ทำงานกับ LLM สตรีมจากสคริปต์อัตโนมัติ กระจายโหลดไปยัง API ผ่าน IP ต่าง ๆ ติดตามเหตุการณ์บนแพลตฟอร์มแบบเรียลไทม์ ทดสอบบริการของตัวเองจากเครือข่ายต่าง ๆ
ตรงนี้สำคัญสามอย่าง ตัวพร็อกซีต้องปล่อย chunked response ผ่านแบบโปร่งใส ไลบรารีฝั่งไคลเอนต์ต้องอ่านสตรีมตามที่มาถึง และคุณต้องแยกออกได้ว่าปัญหาอยู่ที่พร็อกซีหรือที่เซิร์ฟเวอร์ปลายทาง
ตรวจสอบพร็อกซีว่าสตรีมโปร่งใสไหม
- หาเอ็นด์พอยต์ที่เป็นสตรีมแน่ ๆ — บริการทดสอบสาธารณะที่ส่งบรรทัดแบบหน่วงเวลา หรือเอ็นด์พอยต์ของคุณเองที่มีตารางเวลาชังก์ที่รู้ล่วงหน้า
- ยิงคำขอตรงและผ่านพร็อกซีด้วย curl พร็อกซี -N (ปิดบัฟเฟอร์เอาต์พุตของ curl เอง) และ -–trace-time เพื่อดูเวลาประทับ เปรียบเทียบเวลาที่แต่ละส่วนมาถึง
- ถ้าผ่านพร็อกซีแล้วทุกส่วนมาเป็นก้อนเดียวตอนจบ — พร็อกซีบัฟเฟอร์ทั้งหมด ถ้ามาเป็นช่วง ๆ ละไม่กี่กิโลไบต์ — บัฟเฟอร์บางส่วน ถ้าตรงกับคำขอตรง — โปร่งใส
- ทดสอบสตรีมยาว (5-10 นาที) พร้อม heartbeat การขาดที่เวลาคงที่เผยให้เห็น idle-timeout ของพร็อกซี
- ทดสอบ HTTPS ผ่านพร็อกซีที่ใช้เมธอด CONNECT จะสร้างทันเนล และพร็อกซีไม่แยกวิเคราะห์ HTTP ข้างใน — จะบัฟเฟอร์ระดับ HTTP ไม่ได้ มีแค่ความหน่วงระดับ TCP นี่คือเหตุผลหนึ่งที่ API สตรีมผ่านทันเนล CONNECT มักราบรื่นกว่าผ่าน HTTP พร็อกซีที่แยกวิเคราะห์คำขอ
จุดละเอียดเกี่ยวกับพร็อกซีมือถือ: เครือข่ายเซลลูลาร์เพิ่ม jitter เองอยู่แล้ว และ NAT ของผู้ให้บริการปิดการเชื่อมต่อที่ไม่มีกิจกรรมอย่างดุเดือด สำหรับสตรีมยาวผ่านพร็อกซีมือถือ heartbeat ทุก 15-20 วินาทีคือความจำเป็น การหมุน IP ตามตารางต้องคำนึงถึงสตรีมที่เปิดอยู่: การเปลี่ยนแอดเดรสกลาง SSE connection จะตัดมันทิ้งแน่นอน จัดการหมุนให้สอดคล้องกับวงจรชีวิตของสตรีม — ปิดสตรีม เปลี่ยนแอดเดรส เปิดใหม่พร้อมเคอร์เซอร์
ไลบรารีฝั่งไคลเอนต์: เปิดอะไรบ้าง
- Python, requests: stream=True ในคำเรียก แล้ว iter_lines หรือ iter_content ด้วย chunk_size เล็ก ๆ ตั้ง timeout เป็นทูเพิล (connect, read) โดย read คือเวลาที่ยอมรับได้ระหว่างชังก์ ไม่ใช่เวลารวมของคำตอบ
- Python, httpx: client.stream และ aiter_lines สำหรับโค้ดอะซิงโครนัส สำหรับ SSE มีตัวห่อเฉพาะทางที่แยกวิเคราะห์รูปแบบอีเวนต์
- Python, aiohttp: response.content.iter_any คืนข้อมูลตามที่มาจากซ็อกเก็ตเป๊ะ ๆ โดยไม่ repack — เหมาะที่สุดสำหรับวัดช่วงเวลาจริง
- Node.js: fetch อ่าน response.body เป็น ReadableStream สำหรับ SSE มีไลบรารี parser ของรูปแบบนี้
- Go: http.Client ปกติ อ่าน resp.Body ผ่าน bufio.Scanner ที่มีบัฟเฟอร์ใหญ่พอสำหรับอีเวนต์ขนาดใหญ่
ในทุกกรณี: อย่าเรียกเมธอดที่อ่านเนื้อหาทั้งหมด — text, json, read ที่ไม่มีอาร์กิวเมนต์ ไม่งั้นไคลเอนต์จะรอจนการเชื่อมต่อปิด แล้วคุณก็จะไปโทษพร็อกซีเรื่องบัฟเฟอร์ทั้งที่มันไม่มี
โปรโตคอลวินิจฉัย "สามจุด"
เมื่อสตรีมมีพฤติกรรมแปลก ๆ วัดเวลาถึงไบต์แรกและกระจายช่วงห่างระหว่างชังก์ในสามรูปแบบ: ตรงไปยังเซิร์ฟเวอร์จากเครื่องเดียวกัน ผ่านพร็อกซีไปยังเซิร์ฟเวอร์ และผ่านพร็อกซีไปยังเอ็นด์พอยต์สตรีมมาตรฐาน การเปรียบเทียบจะชี้จุดปัญหาได้อย่างชัดเจน ผ่านพร็อกซีไปยังตัวมาตรฐานดี แต่ไปยังเซิร์ฟเวอร์เป้าหมายแย่ — โครงสร้างพื้นฐานของเซิร์ฟเวอร์เป้าหมายผิด ไปยังตัวมาตรฐานก็แย่ — พร็อกซีผิด ตรงไปก็แย่ — โค้ดคุณหรือเครือข่ายผิด โปรโตคอลนี้ใช้เวลาสิบนาทีและประหยัดการเถียงกันได้หลายวัน
ข้อผิดพลาดทั่วไปในการทำงานกับสตรีมผ่านพร็อกซี
- ปิด proxy_buffering แล้วลืมเรื่อง gzip ข้อผิดพลาดที่พบบ่อยที่สุด สตรีมในนามไม่บัฟเฟอร์ แต่การบีบอัดกองข้อมูลจนถึงขนาดหน้าต่าง อาการ: เป็นห้วง ๆ ละไม่กี่กิโลไบต์
- ปล่อย proxy_http_version 1.0 ไว้ nginx โดยค่าเริ่มต้นคุยกับแบ็กเอนด์ทาง HTTP/1.0 ซึ่งไม่มี chunked จึงต้องรอจนการเชื่อมต่อปิด อาการ: คำตอบทั้งอันมาถึงตอนจบ
- ไม่ส่ง heartbeat สตรีมจะอยู่ได้จนถึง idle-timeout แรกในห่วงโซ่ — 60 วินาทีที่ nginx, 15 ที่ Envoy ตามเส้นทาง, ไม่กี่นาทีที่ NAT อาการ: ขาดตอนที่ช่วงเวลาคงที่
- timeout ของ long-polling ยาวกว่า timeout ของพร็อกซี ไคลเอนต์ได้ 504 แทนคำตอบว่าง มอนิเตอร์ขึ้นแดง และเหตุการณ์อาจซ้ำ
- พึ่งการตั้งค่าพร็อกซีระดับโกลบอล พอย้ายไปสภาพแวดล้อมใหม่หรือเปลี่ยน CDN สตรีมมิ่งก็พังเงียบ ๆ ทางออกคือ X-Accel-Buffering และ no-transform ในระดับคำตอบ: พฤติกรรมกำหนดโดยแอป ไม่ใช่ผู้ดูแลพร็อกซี
- ไม่มี Last-Event-ID และเคอร์เซอร์ ขาดตอนใด ๆ คือข้อมูลหาย ผ่านพร็อกซีการขาดตอนเกิดบ่อยกว่าตรง ๆ อย่างเห็นได้ชัด
- อ่านเนื้อหาทั้งหมดฝั่งไคลเอนต์ ลืม stream=True ไคลเอนต์รอจนจบ แล้วนักพัฒนาก็โทษพร็อกซี
- หมุน IP ระหว่างสตรีมที่เปิดอยู่ การเชื่อมต่อขาด ไม่มีการเชื่อมต่อใหม่ ข้อมูลหาย
- ทดสอบบนคำตอบสั้น บัฟเฟอร์ยังไม่ทันเต็ม ทุกอย่างดูดี ในโปรดักชันบนคำตอบยาวก็เริ่มเขียนลงไฟล์ชั่วคราว และความหน่วงก็พุ่ง
- ผสมเส้นทางสตรีมกับเส้นทางปกติใน location เดียว ไม่ก็ทำสตรีมมิ่งพัง ไม่ก็เสียการบีบอัดและบัฟเฟอร์สำหรับคำตอบปกติ ซึ่งกระทบประสิทธิภาพของ API ทั้งระบบ
- เพิกเฉยการที่ไคลเอนต์ตัดการเชื่อมต่อ ผ่านพร็อกซีเซิร์ฟเวอร์รู้ช้าและทำงานที่แพงต่อไป สำหรับ LLM inference นี่คือเงินสด ๆ
- ใช้ chunked ในที่ที่ควรใช้ long-polling ผ่านเกตเวย์องค์กรหรือ API gateway คลาวด์ที่มีลิมิตเวลาตอบกลับ สตรีมผ่านไม่ได้ แต่ long-polling ผ่านได้ไม่มีปัญหา
เครื่องมือและทรัพยากรสำหรับตั้งค่าและวินิจฉัย
รีเวิร์สพร็อกซีและโหลดบาลานเซอร์
- nginx — มาตรฐานของความยืดหยุ่น ไดเรกทีฟสำคัญ: proxy_buffering, proxy_http_version, proxy_read_timeout, gzip, รองรับเฮดเดอร์ X-Accel-Buffering
- HAProxy — บัฟเฟอร์น้อยที่สุดในกล่อง ระวัง timeout server, timeout tunnel และการบีบอัด
- Envoy — สตรีมเป็นค่าเริ่มต้น สิ่งที่วิกฤตคือ route timeout และ stream_idle_timeout
- Caddy — ไม่บัฟเฟอร์โดยค่าเริ่มต้น flush_interval ที่ค่า -1 กำหนดให้ flush ทันทีอย่างชัดเจน
- Traefik — ส่งสตรีมโปร่งใส timeout ตั้งในระดับ entrypoints
การวินิจฉัย
- curl กับแฟล็ก -N, -v และ --trace-time แสดงเวลาที่แต่ละส่วนมาถึง พารามิเตอร์ -w กับตัวแปร time_starttransfer และ time_total ให้เวลาถึงไบต์แรกและเวลารวม
- tcpdump และ Wireshark — ตรวจว่าไบต์มาช้าที่ระดับเครือข่ายหรือถูกหน่วงอยู่ข้างบน
- mitmproxy — ดูสตรีมโดยรักษาโครงสร้างชังก์ ต้องเปิดโหมดสตรีมมิ่ง ไม่งั้นมันจะกลายเป็นจุดบัฟเฟอร์เอง
- DevTools ของเบราว์เซอร์ — แท็บ EventStream สำหรับ SSE แสดงทุกเหตุการณ์พร้อมเวลาประทับ
เอ็นด์พอยต์ทดสอบและไลบรารี
บริการสาธารณะสำหรับทดสอบ HTTP มีเอ็นด์พอยต์ที่ส่งบรรทัดตามจำนวนที่กำหนดแบบหน่วงเวลา — เหมาะที่สุดสำหรับตรวจความโปร่งใสของพร็อกซี เซิร์ฟเวอร์มินิมอลของคุณเองในภาษาใดก็ได้ที่ส่งชังก์ทุกวินาทีพร้อมเวลาประทับ ยิ่งดีกว่าเพราะคุณควบคุมทั้งสองฝั่ง สำหรับ SSE ฝั่งเซิร์ฟเวอร์ เฟรมเวิร์กอะซิงโครนัสแทบทุกตัวมีคลาสคำตอบสำเร็จรูปสำหรับ text/event-stream สำหรับ SSE ฝั่งไคลเอนต์นอกเบราว์เซอร์ มี parser ของรูปแบบนี้สำหรับ Python, Node.js และ Go สำหรับ long-polling ไม่ต้องใช้ไลบรารีพิเศษ — HTTP client ที่มีพูลการเชื่อมต่อก็พอ
การมอนิเตอร์
เมตริกที่ควรเก็บ: เวลาถึงไบต์แรกของเนื้อหา การกระจายช่วงห่างระหว่างชังก์ที่เปอร์เซ็นไทล์ 50, 95 และ 99 อายุของสตรีมและสาเหตุการปิด จำนวนสตรีมที่ใช้งานอยู่บนพร็อกซีและบนแบ็กเอนด์ สัดส่วนการเชื่อมต่อใหม่พร้อม Last-Event-ID การเพิ่มขึ้นอย่างรวดเร็วของช่วงห่างระหว่างชังก์พร้อมกับปริมาณที่เพิ่มขึ้น คือสัญญาณชัดเจนว่าบัฟเฟอร์เปิดทำงานแล้ว
เคสและผลลัพธ์: สิ่งนี้หน้าตาเป็นอย่างไรในโปรเจกต์จริง
เคสที่ 1. สตรีม LLM ผ่าน nginx: จาก 11 วินาทีเหลือ 310 มิลลิวินาที
ทีมหนึ่งนำแชตบนโมเดลภาษามาใช้ ในเครื่อง โทเคนค่อย ๆ ปรากฏอย่างราบรื่น หลังขึ้น production หลัง nginx ผู้ใช้เห็นหน้าจอว่าง 8-12 วินาที แล้วคำตอบทั้งอันก็โผล่พรวด การวินิจฉัยตามโปรโตคอล "สามจุด" เผยว่า ตรงไปยังแอป โทเคนแรกมาถึงใน 280 มิลลิวินาที ผ่าน nginx ใช้ 11 วินาที สาเหตุคลาสสิก: proxy_buffering on และ proxy_http_version 1.0 เป็นค่าเริ่มต้น หลังเพิ่ม proxy_buffering off, proxy_http_version 1.1, gzip off สำหรับเส้นทางนั้น และเฮดเดอร์ X-Accel-Buffering: no ในคำตอบของแอป เวลาถึงโทเคนแรกผ่านพร็อกซีกลายเป็น 310 มิลลิวินาที สิ่งที่พบเพิ่มเติม: เมื่อปิดแท็บ การ inference ยังทำงานจนจบคำตอบ หลังนำ heartbeat พร้อมตรวจข้อผิดพลาดการเขียนมาใช้ การใช้เวลา GPU กับคำขอที่ถูกทิ้งลดลงประมาณหนึ่งในสี่
เคสที่ 2. แดชบอร์ดบน SSE กับเครือข่ายมือถือ
เซอร์วิสติดตามสถานะส่งเหตุการณ์ผ่าน SSE บนอินเทอร์เน็ตแบบมีสายทุกอย่างปกติ แต่จากอุปกรณ์มือถือสตรีมขาดทุก 2-4 นาที โดยไม่มีข้อผิดพลาดบนเซิร์ฟเวอร์ สาเหตุ — NAT-timeout ของผู้ให้บริการบนการเชื่อมต่อที่ไม่มีกิจกรรม ทางแก้: คอมเมนต์ heartbeat ทุก 20 วินาที บวกกับการบังคับปิดสตรีมจากเซิร์ฟเวอร์ทุก 10 นาทีพร้อม Last-Event-ID ที่ถูกต้อง ข้อร้องเรียนเรื่อง "แดชบอร์ดค้าง" ลดลงจนเกือบเป็นศูนย์ อายุเฉลี่ยของสตรีมต่อเนื่องเพิ่มจาก 3 เป็น 10 นาที (จำกัดด้วยการปิดโดยเจตนาแล้ว) และไม่มีการบันทึกการสูญหายของเหตุการณ์ตอนเชื่อมต่อใหม่
เคสที่ 3. ดึงข้อมูล API สตรีมผ่านพูลพร็อกซีมือถือ
ทีมหนึ่งเก็บเหตุการณ์จากแพลตฟอร์มที่ส่งข้อมูลเป็น NDJSON สตรีม ผ่านพูลพร็อกซีมือถือ พบสองปัญหา: สตรีมบางส่วนมาเป็นห้วง ๆ ละ 8 กิโลไบต์ และบางส่วนขาดตอนเมื่อหมุนแอดเดรส การทดสอบพบว่าสำหรับคำขอที่ไม่เข้ารหัส พร็อกซีแยกวิเคราะห์ HTTP และบัฟเฟอร์คำตอบ แต่ผ่านทันเนล CONNECT ไปยังเอ็นด์พอยต์ HTTPS กลับปล่อยสตรีมโปร่งใส การเปลี่ยนไปใช้ HTTPS แก้ปัญหาที่หนึ่งได้ทั้งหมด ส่วนปัญหาที่สองปิดด้วยการซิงก์: การหมุน IP เกิดขึ้นหลังปิดสตรีมอย่างถูกต้องเท่านั้น และการเชื่อมต่อใหม่ใช้เคอร์เซอร์ของเหตุการณ์ล่าสุด ความครบถ้วนของข้อมูลที่เก็บได้เพิ่มจากประมาณ 91 เป็น 99.7 เปอร์เซ็นต์
เคสที่ 4. บอตบน long-polling ผ่านเกตเวย์ที่มีลิมิต
นักพัฒนาคนหนึ่งรันบอตบนโครงสร้างพื้นฐานที่คำขอขาออกผ่านเกตเวย์องค์กรที่มีลิมิตเวลาตอบกลับ 30 วินาที ตอนแรกใช้ timeout รอ 60 วินาที — ครึ่งหนึ่งของคำขอจบด้วยข้อผิดพลาดเกตเวย์ อัปเดตซ้ำ หลังลด timeout เหลือ 25 วินาทีและเพิ่ม jitter แบบเอกซ์โพเนนเชียลเมื่อเกิดข้อผิดพลาด สัดส่วนข้อผิดพลาดลดจาก 48 เหลือต่ำกว่า 0.5 เปอร์เซ็นต์ ความหน่วงเฉลี่ยในการส่งเหตุการณ์ไม่เปลี่ยน — มันกำหนดจากเวลาที่เหตุการณ์เกิด ไม่ใช่ความยาวของการรอ
เคสที่ 5. เปลี่ยนเป็น HTTP/2 สำหรับ SSE
เว็บแอปเปิด SSE stream 3-4 อันต่อแท็บ พอเปิดหลายแท็บ เบราว์เซอร์ก็ใช้ลิมิตหกการเชื่อมต่อหมด และคำขอปกติก็ต่อคิวหลังสตรีม การเปิด HTTP/2 บนพร็อกซีส่วนหน้าย้ายสตรีมทั้งหมดไปอยู่การเชื่อมต่อเดียว เวลาโหลดหน้าเว็บเมื่อเปิดห้าแท็บลดจาก 9 เหลือ 1.5 วินาที สิ่งที่พบเพิ่มเติม: หลังเปลี่ยนแล้วต้องเพิ่ม stream_idle_timeout เพราะการตั้งค่าเดิมคำนวณมาสำหรับ HTTP/1.1
FAQ: คำถามเชิงลึกเรื่องการตอบกลับแบบสตรีมผ่านพร็อกซี
HTTP แบบสตรีมต่างจาก WebSocket ในมุมของพร็อกซีต่างกันอย่างไร?
WebSocket ต้องมีการอัปเกรดโปรโตคอล: พร็อกซีต้องรู้จักเฮดเดอร์ Upgrade และ Connection สลับไปโหมดทันเนล และเลิกแยกวิเคราะห์ HTTP ส่วน HTTP แบบสตรีมไม่ต้องอะไรเลย — มันคือคำตอบธรรมดาที่จบช้า ความขัดแย้งคือ WebSocket ผ่านพร็อกซีไม่ก็ใช้ได้ หรือใช้ไม่ได้ไปเลย แต่ HTTP แบบสตรีม "ใช้ได้" เสมอ เพียงอาจใช้ได้แย่: ข้อมูลมาถึง แต่ช้า จึงเป็นปัญหาที่สังเกตและวินิจฉัยได้ยากกว่า
ทำไม X-Accel-Buffering: no จึงไม่ช่วยเสมอ?
เฮดเดอร์นี้เข้าใจโดย nginx และพร็อกซีที่เข้ากันได้ CDN, เกตเวย์คลาวด์ หรือพร็อกซีชนิดอื่นจะมองข้าม นอกจากนั้น X-Accel-Buffering ไม่มีผลกับ gzip — การบีบอัดต้องปิดแยก และถ้าระหว่างแอปกับ nginx มีชั้นที่ลบเฮดเดอร์ที่ไม่มาตรฐานออก มันก็ไปไม่ถึง nginx
บีบอัดคำตอบแบบสตรีมได้ไหม?
ในทางเทคนิคได้: gzip รองรับ synchronous flush และเซิร์ฟเวอร์สามารถบีบอัดแต่ละชังก์พร้อมส่งทันที แต่อัตราการบีบอัดจะลดลงเพราะดิกชันนารียังไม่ทันเต็ม ในทางปฏิบัติ สำหรับ SSE และโทเคน LLM เขาปิดการบีบอัด: ประหยัดทราฟฟิกไม่กี่เปอร์เซ็นต์ไม่คุ้มกับความเสี่ยงเรื่องความหน่วง สำหรับสตรีมของ JSON object ขนาดใหญ่ การบีบอัดพร้อม flush อาจให้ผลดีเห็นได้ชัด
เลือกระหว่าง SSE กับ long-polling อย่างไร?
ถ้าไคลเอนต์เป็นเบราว์เซอร์ เหตุการณ์เกิดบ่อยกว่าทุกไม่กี่วินาที และคุณควบคุมรีเวิร์สพร็อกซีอย่างน้อยหนึ่งชั้น — ใช้ SSE ถ้าในห่วงโซ่มีโหนดที่ไม่ควบคุมที่มีลิมิตเวลาตอบกลับ เหตุการณ์เกิดน้อย หรือต้องเข้ากันได้สูงสุด — ใช้ long-polling ระบบที่โตเต็มที่มักทำทั้งสองแบบและสลับอัตโนมัติตามผลของการเชื่อมต่อครั้งแรก
HTTP/3 มีผลกับปัญหาบัฟเฟอร์ไหม?
HTTP/3 ทำงานบน QUIC และลบการบล็อกคิวในระดับทรานสปอร์ต แต่บัฟเฟอร์อยู่สูงกว่า — ในตรรกะของพร็อกซี พร็อกซีที่เข้า HTTP/3 และออก HTTP/1.1 ก็บัฟเฟอร์เหมือนเดิม สิ่งที่เปลี่ยนจริงคือพฤติกรรมในเครือข่ายมือถือ: QUIC ทนการเปลี่ยนเครือข่ายและการสูญเสียแพ็กเก็ตได้ดีกว่า สตรีมผ่าน HTTP/3 จึงขาดตอนฝั่งไคลเอนต์น้อยกว่า
จะรู้ได้อย่างไรว่าที่บัฟเฟอร์คือพร็อกซีขาออก ไม่ใช่เซิร์ฟเวอร์ปลายทาง?
ใช้วิธี "สามจุด": คำขอเดียวกันตรง ๆ ผ่านพร็อกซี และผ่านพร็อกซีไปยังเอ็นด์พอยต์สตรีมมาตรฐาน เพิ่มเติมคือลอง HTTPS ผ่าน CONNECT — ถ้าสตรีมเรียบขึ้น แสดงว่าพร็อกซีแยกวิเคราะห์และบัฟเฟอร์ HTTP ที่ไม่เข้ารหัส
ควรเลือกช่วง heartbeat เท่าไร?
น้อยกว่า timeout ที่สั้นที่สุดในห่วงโซ่ โดยมีสำรองสองเท่า สำหรับโครงสร้างพื้นฐานทั่วไป — 15-25 วินาที สำหรับเครือข่ายมือถือใกล้ 15 heartbeat ถี่เกินไปก็เป็นทราฟฟิกและภาระเกินบนการเชื่อมต่อพันราย ห่างเกินไปก็ขาดตอน
ถ้าสตรีมต้องอยู่หลายชั่วโมงควรทำอย่างไร?
อย่าทำ ออกแบบให้เซิร์ฟเวอร์บังคับปิดทุก 5-15 นาทีพร้อมเคอร์เซอร์สำหรับกลับมาต่อ วิธีนี้ป้องกันการสะสม memory, การรั่ว และ timeout ที่มองไม่เห็น อีกทั้งทำให้ deploy ง่ายขึ้น: คุณรีสตาร์ตเซิร์ฟเวอร์ได้โดยไม่ต้องคิดถึงการเชื่อมต่อรายชั่วโมง
พร็อกซีมีผลกับการตรวจจับการตัดการเชื่อมต่อของไคลเอนต์อย่างไร?
ระหว่างไคลเอนต์กับเซิร์ฟเวอร์ตอนนี้มีการเชื่อมต่อสองเส้น เมื่อไคลเอนต์ตัด พร็อกซีรู้ทันที แต่บอกเซิร์ฟเวอร์ตอนพยายามเขียนครั้งถัดไปหรือตามกฎของตัวเอง เซิร์ฟเวอร์จะรู้ว่าขาดตอนเมื่อเขียนเท่านั้น จากตรงนี้จึงเกิดแนวปฏิบัติการเขียน heartbeat เป็นระยะเพื่อตรวจจับการขาดตอนได้เร็วและหยุดงานที่แพง
พร็อกซีมือถือต้องตั้งค่าพิเศษสำหรับสตรีมไหม?
ในมุมของผู้ใช้ ตัวพร็อกซีมักไม่ได้ตั้งค่าเอง แต่ต้อง: เลือกใช้ HTTPS เพื่อทันเนลโปร่งใส จัดการหมุน IP ให้สอดคล้องกับวงจรชีวิตของสตรีม คุม heartbeat ไม่ห่างกว่า 15-20 วินาที ใช้ keep-alive และพูลการเชื่อมต่อ และทดสอบทุกพูลว่าปล่อยสตรีมโปร่งใสก่อนขึ้นโปรดักชัน
บทสรุป: สรุปและก้าวต่อไป
HTTP แบบสตรีมไม่ใช่ของแปลกและไม่ใช่โปรโตคอลแยก มันคือคำตอบธรรมดาที่ไม่รีบปิดตัว นั่นแหละที่ทำให้มันเปราะบางต่อโหนดกลาง: พร็อกซีมองไม่เห็นอะไรเป็นพิเศษ จึงใช้กฎที่คิดขึ้นมาสำหรับคำตอบสั้น บัฟเฟอร์หน่วงข้อมูล timeout ตัดการเชื่อมต่อ การบีบอัดกลบเกลื่อนบัฟเฟอร์ — และทั้งหมดนี้ในแปดจุดต่าง ๆ ของห่วงโซ่
สามกลไก — chunked, SSE และ long-polling — แก้ปัญหาเดียวกันด้วยระดับการพึ่งพาความโปร่งใสของพร็อกซีที่ต่างกัน chunked ให้การควบคุมสูงสุด แลกกับการจัดการเองบนไคลเอนต์ SSE ให้โมเดลเหตุการณ์สำเร็จรูปและการเชื่อมต่อใหม่ในเบราว์เซอร์ แต่ต้องใส่ใจทุกโหนด long-polling ผ่านได้ทุกอย่าง แต่ต้องจ่ายด้วยภาระของคำขอถี่ ๆ การเลือกกำหนดด้วยสี่คำถาม: คุณควบคุมห่วงโซ่ไหม ใครคือไคลเอนต์ ข้อมูลมีธรรมชาติอย่างไร และเกิดบ่อยแค่ไหน
สิ่งที่ควรทำวันนี้เลย:
- ไล่ผ่านแผนที่แปดจุดบัฟเฟอร์สำหรับโครงสร้างพื้นฐานของคุณ และทำเครื่องหมายว่าจุดไหนคุณควบคุมได้
- เพิ่ม X-Accel-Buffering: no และ Cache-Control: no-cache, no-transform ในคำตอบของเส้นทางสตรีม — โดยไม่สนว่าคอนฟิกพร็อกซีปัจจุบันเป็นอย่างไร
- ตรวจสอบ proxy_http_version, proxy_buffering, gzip และ proxy_read_timeout ใน nginx หรือของเทียบเท่าในพร็อกซีของคุณ แยกเส้นทางสตรีมออกเป็นบล็อกต่างหาก
- ติดตั้ง heartbeat ไม่ห่างกว่า 25 วินาที และบังคับปิดสตรีมทุก 5-15 นาทีพร้อมเคอร์เซอร์
- ถ้าคุณบริโภคสตรีมของคนอื่นผ่านพร็อกซี — รันโปรโตคอล "สามจุด" บนทุกพูลแอดเดรส และย้ายคำขอสตรีมไปใช้ HTTPS
- ตั้งการมอนิเตอร์เวลาถึงไบต์แรกและช่วงห่างระหว่างชังก์ นี่คือวิธีเดียวที่จะรู้เรื่องบัฟเฟอร์ก่อนผู้ใช้
พร็อกซีไม่ใช่ศัตรูของสตรีม พร็อกซีที่ตั้งค่าถูกต้องเพิ่มความทนทาน การกระจายโหลด และการปกป้องแบ็กเอนด์ให้กับสตรีม ภารกิจมีแค่ต้องอธิบายให้มันเข้าใจ: คำตอบนี้พิเศษ ต้องส่งต่อทันทีตามที่มันมา ตอนนี้คุณมีทุกอย่างพร้อมแล้วที่จะทำให้คำอธิบายนั้นดังในภาษาของมัน