บทความ

บทนำ: ทำไม 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 ทั่วไปที่ตอบกลับไม่กี่กิโลไบต์ ทั้งหมดนี้สมเหตุสมผลและประหยัดทรัพยากร แต่สำหรับสตรีมกลับตรงกันข้าม: การหน่วงไบต์ไว้ทำลายคุณค่าของสตรีมทิ้งไปเลย คุณค่านั้นอยู่ที่ความทันเวลา ไม่ใช่ปริมาณ

แผนที่แปดจุดบัฟเฟอร์

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

  1. แอปพลิเคชัน เฟรมเวิร์กอาจบัฟเฟอร์เอาต์พุตเองได้ WSGI server, PHP ที่เปิด output_buffering, เฟรมเวิร์ก Node.js ที่มีมิดเดิลแวร์บีบอัด ไม่เรียก flush — ข้อมูลก็นอนอยู่ในบัฟเฟอร์ของโปรเซส
  2. รีเวิร์สพร็อกซีหน้าแอป nginx ที่ proxy_buffering on (เปิดเป็นค่าเริ่มต้น) กองคำตอบในบัฟเฟอร์ที่กำหนดด้วย proxy_buffer_size และ proxy_buffers และเมื่อเต็มก็เขียนลงไฟล์ชั่วคราวบนดิสก์ Apache mod_proxy บัฟเฟอร์น้อยกว่าแต่ก็มีการตั้งค่าของตัวเอง Caddy โดยค่าเริ่มต้นไม่บัฟเฟอร์ แต่ flush_interval ควรเช็กดู
  3. การบีบอัดบนพร็อกซี แม้ proxy_buffering off แต่ gzip ที่เปิดอยู่จะสะสมข้อมูลจนถึงขนาดหน้าต่างบีบอัด นี่คือหนึ่งในจุดที่ร้ายกาจที่สุด: บัฟเฟอร์ถูกปิดในนาม แต่สตรีมยังไหลเป็นห้วง ๆ
  4. โหลดบาลานเซอร์ L7 HAProxy ในโหมด http ส่งข้อมูลทันทีที่มาถึง ถ้าไม่เปิด http-buffer-request แต่ถูกจำกัดด้วยขนาด tune.bufsize ส่วน Envoy โดยค่าเริ่มต้นสตรีมอยู่แล้ว แต่ฟิลเตอร์บีบอัดหรือ Lua อาจกองเนื้อหาไว้ได้
  5. CDN และเกตเวย์คลาวด์ CDN หลายเจ้าบัฟเฟอร์คำตอบเพื่อแคชและบีบอัด ผู้ให้บริการบางรายไม่รองรับสตรีมที่ยาวเกินเวลาที่กำหนด หรือต้องตั้งค่าเฉพาะ API เกตเวย์บนคลาวด์มักมีลิมิตเวลาตอบกลับแข็ง ๆ ราว 30 วินาที และไม่รองรับการสตรีมเนื้อหาเลยด้วยซ้ำ
  6. พร็อกซีขาออกฝั่งไคลเอนต์ HTTP พร็อกซีที่คุณใช้ออกอินเทอร์เน็ต — ทั้งขององค์กร มือถือ เรสซิเดนเชียล — ก็เป็น HTTP parser เหมือนกัน ถ้าสร้างบน nginx หรือ Squid และตั้งให้บัฟเฟอร์ สตรีมก็จะติดอยู่ตรงนั้น บริการพร็อกซีคุณภาพดีจะปล่อย chunked response ผ่านแบบโปร่งใส แต่ต้องทดสอบจริงถึงจะรู้
  7. TLS และ TCP ข้อมูลอาจค้างใน TLS record ถ้าไลบรารีรวบรวมจนได้ขนาด 16 กิโลไบต์ อัลกอริทึมของ Nagle หน่วง TCP เซกเมนต์เล็ก ๆ จนได้รับ ack ของอันก่อนหน้า สำหรับสตรีมที่ประกอบด้วยชังก์เล็ก ๆ เรื่องนี้เพิ่มเวลาหลายสิบมิลลิวินาทีต่อชังก์
  8. ไลบรารีฝั่งไคลเอนต์ 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 ในรูปแบบของตัวเอง

ตั้งค่าฝั่งเซิร์ฟเวอร์ทีละขั้น

  1. ตรวจสอบว่าแอปเขียนทีละส่วน หลังแต่ละส่วนเชิงตรรกะ ให้เรียก flush ใน Python กับ ASGI server นี่คือเจนเนอเรเตอร์ที่ yield ไบต์ ใน Node.js คือ res.write แล้ว flush ถ้ามีการบีบอัด ใน Go คืออินเทอร์เฟซ http.Flusher หลังทุก Write
  2. อย่าตั้ง Content-Length เฟรมเวิร์กส่วนใหญ่จะสลับเป็น chunked เองถ้าไม่กำหนดความยาว ตรวจสอบว่าคำตอบใน HTTP/1.1 มี Transfer-Encoding: chunked
  3. ปิดการบีบอัดในระดับแอป สำหรับเส้นทางสตรีม หรือตรวจสอบให้แน่ใจว่ามัน flush พร้อมกับข้อมูล ทางออกประนีประนอมคือ gzip พร้อม flush แบบ synchronous หลังทุกชังก์ วิธีนี้ใช้ได้แต่ลดอัตราการบีบอัด
  4. ตั้งเฮดเดอร์ X-Accel-Buffering: no นี่คือเฮดเดอร์เฉพาะของ nginx ที่ปิดบัฟเฟอร์สำหรับคำตอบนั้นโดยไม่ต้องแก้คอนฟิกทั้งหมด พร็อกซีบางตัวอื่นก็เข้าใจเฮดเดอร์นี้ด้วย เพิ่ม Cache-Control: no-cache, no-transform อีกด้วย — ค่าที่สองขอให้โหนดกลางอย่าแก้เนื้อหา
  5. ตั้งค่ารีเวิร์สพร็อกซี สำหรับ 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 ต้องบัฟเฟอร์จนกว่าการเชื่อมต่อจะปิด
  6. แยกเส้นทาง ถ้าต้องการบีบอัดสำหรับ API ส่วนอื่น ให้เปิดเฉพาะใน location block ที่ไม่ใช่สตรีม
  7. ตรวจสอบอัลกอริทึมของ 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 ผ่านพร็อกซีทีละขั้น

  1. เฮดเดอร์คำตอบ: Content-Type: text/event-stream; charset=utf-8, Cache-Control: no-cache, no-transform, X-Accel-Buffering: no, และสำหรับ HTTP/1.1 เพิ่ม Connection: keep-alive
  2. Heartbeat ส่งบรรทัดคอมเมนต์แบบ : ping ทุก 15-25 วินาที ซึ่งน้อยกว่า idle-timeout ที่สมเหตุสมผลใด ๆ และรักษาตาราง NAT ของผู้ให้บริการให้ตื่นอยู่
  3. ตัวระบุเหตุการณ์ ให้ทุกเหตุการณ์มี id เพิ่มขึ้นแบบโมโนโทนิก เมื่อเชื่อมต่อใหม่ เบราว์เซอร์จะส่งเฮดเดอร์ Last-Event-ID มาให้ และเซิร์ฟเวอร์จะส่งย้อนหลังส่วนที่พลาดได้ ถ้าไม่มีเรื่องนี้ การขาดตอนใด ๆ ที่พร็อกซีก็คือข้อมูลหาย
  4. ฟิลด์ retry ตั้งค่าให้สมเหตุสมผล เช่น 3000 มิลลิวินาที เพื่อไม่ให้ไคลเอนต์ก่อพายุการเชื่อมต่อใหม่ตอนเซิร์ฟเวอร์รีสตาร์ต
  5. คอนฟิก nginx เหมือนกับ chunked เพิ่มเติมคือตรวจสอบให้แน่ใจว่าไม่ใช้ gzip กับ text/event-stream: ถ้า gzip_types มี text/* ให้เพิ่ม location แยกที่ gzip off
  6. วางแผนจำนวนการเชื่อมต่อ SSE stream หนึ่งอันที่เปิดอยู่บน HTTP/1.1 คือการเชื่อมต่อหนึ่งเส้นระหว่างพร็อกซีกับแบ็กเอนด์ สำหรับไคลเอนต์หนึ่งพันรายพร้อมกัน ก็ต้องใช้หนึ่งพันการเชื่อมต่อ ให้ใช้ HTTP/2 ฝั่งไคลเอนต์และเซิร์ฟเวอร์แบบอะซิงโครนัสฝั่งแบ็กเอนด์
  7. จัดการการปิด เซิร์ฟเวอร์ต้องตรวจจับได้ว่าไคลเอนต์ตัดการเชื่อมต่อและหยุดสร้างข้อมูล ผ่านพร็อกซีเรื่องนี้เกิดช้า: เซิร์ฟเวอร์จะรู้ว่าขาดตอนเมื่อลองเขียนเท่านั้น สำหรับงานแพง ๆ อย่างการอนุมานโมเดล นั่นคือวินาทีพิเศษที่ GPU ทำงานทิ้งเปล่า ทางออกคือการเขียน heartbeat เป็นระยะ ซึ่งจะกระตุ้นให้เกิดข้อผิดพลาดในการเขียนเมื่อการเชื่อมต่อขาด

SSE กับ HTTP/2: จุดละเอียด

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

เฟรมเวิร์กออกแบบ SSE stream

  1. กำหนดประเภทเหตุการณ์และความถี่ เหตุการณ์ที่เกิดน้อยต้องมี heartbeat เหตุการณ์ที่เกิดถี่ควรแบตช์หลายรายการไว้ในเหตุการณ์เดียว
  2. เลือกกลยุทธ์การกลับมาต่อ: เก็บบัฟเฟอร์วงกลมของเหตุการณ์ล่าสุดบนเซิร์ฟเวอร์เพื่อจัดการ Last-Event-ID หรือพึ่งการซิงก์ใหม่ทั้งหมดเมื่อเชื่อมต่อใหม่
  3. กำหนดลิมิตอายุของแต่ละสตรีม แนวปฏิบัติที่ดีคือเซิร์ฟเวอร์ปิดสตรีมเองทุก 5-10 นาที แล้วไคลเอนต์เชื่อมต่อใหม่แบบโปร่งใส วิธีนี้ป้องกันการสะสมสถานะและเลี่ยง timeout ที่ซ่อนอยู่ในโครงสร้างพื้นฐาน
  4. คิดเรื่องทางถอย: ถ้าสตรีมผ่านพร็อกซีไม่ได้ ให้สลับไป long-polling อัตโนมัติ

วิธีที่ 3: long-polling — สตรีมจากลำดับของคำตอบธรรมดา

ทำงานอย่างไรและทำไมยังใช้ได้อยู่

long-polling เป็นเทคนิคที่เก่าแก่ที่สุดในสามอย่าง ไคลเอนต์ส่งคำขอ เซิร์ฟเวอร์ไม่ตอบทันที แต่รอเหตุการณ์จนถึง timeout ที่กำหนด (ปกติ 20-60 วินาที) มีเหตุการณ์มา — เซิร์ฟเวอร์ตอบและปิด ไม่มีอะไรมา — ก็ตอบว่าง ไคลเอนต์ยิงคำขอถัดไปทันที ในมุมมองภายนอกดูเหมือนสตรีมที่มีความหน่วงต่ำสุด แต่คำตอบแต่ละอันเป็นคำตอบธรรมดา มี Content-Length เข้ากันได้เต็มที่กับพร็อกซี แคช และเกตเวย์ทุกชนิด

ทำไมในปี 2026 long-polling ยังสุขภาพดีอยู่? เพราะมันผ่านได้ทุกที่ ผ่านเกตเวย์องค์กรที่ตัด chunked ผ่าน API เกตเวย์บนคลาวด์ที่มีลิมิตเวลาตอบกลับ ผ่านพร็อกซีที่บัฟเฟอร์แบบเดาไม่ได้ ตัวอย่างที่โด่งดังที่สุดคือเมธอดดึงอัปเดตใน Bot API ของแอปแชตยักษ์ใหญ่ ที่พารามิเตอร์ timeout กำหนดระยะเวลารอ บอตส่วนใหญ่ทำงานแบบนี้มาหลายปี ผ่านพร็อกซีหลากหลายแบบ โดยไม่มีปัญหา

ห้ากฎออกแบบ long-polling ผ่านพร็อกซี

  1. timeout ฝั่งเซิร์ฟเวอร์ต้องน้อยกว่า timeout ที่สั้นที่สุดในห่วงโซ่ ถ้าพร็อกซีมี proxy_read_timeout 60 วินาที การรอฝั่งเซิร์ฟเวอร์ต้องไม่เกิน 50 ถ้าในห่วงโซ่มีเกตเวย์คลาวด์ที่ 30 วินาที ก็ไม่เกิน 25 ไม่งั้นแทนที่จะได้คำตอบว่าง ไคลเอนต์จะได้ 504 และกระแสข้อผิดพลาดจะทำให้ระบบมอนิเตอร์เป็นบ้า
  2. เคอร์เซอร์หรือ offset ไคลเอนต์ส่งตัวระบุของเหตุการณ์ล่าสุดที่ได้รับ เซิร์ฟเวอร์ส่งทุกอย่างที่เกิดหลังจากนั้น โปรโตคอลกลายเป็น idempotent: คำตอบที่หายไปก็แค่ทำให้ส่งเหตุการณ์เดิมซ้ำ
  3. jitter ตอนเชื่อมต่อใหม่หลังข้อผิดพลาด การเพิ่มแบบเอกซ์โพเนนเชียล — 1, 2, 4, 8 วินาที — บวกกับค่าสุ่ม ถ้าไม่มี jitter ไคลเอนต์หนึ่งพันรายหลังเหตุขัดข้องจะถล่มเซิร์ฟเวอร์พร้อมกัน
  4. ไม่หยุดพักหลังคำตอบสำเร็จ คำขอถัดไปออกทันที การหยุดพักตรงนี้คือความหน่วงที่เสียเปล่า
  5. keep-alive เป็นข้อบังคับ ถ้าไม่มี ทุกคำขอคือ TCP connection ใหม่และ TLS handshake ใหม่ ซึ่งเพิ่ม 50-300 มิลลิวินาทีต่อรอบ และผ่านพร็อกซีระยะไกลยิ่งมากกว่า

ใช้งานทีละขั้น

  1. เซิร์ฟเวอร์: เอ็นด์พอยต์รับ offset และ timeout รอเหตุการณ์บนคิวภายในหรือผ่านการซับสคริปต์ ตอบกลับเป็นอาร์เรย์เหตุการณ์พร้อม offset ใหม่ อาร์เรย์ว่างคือคำตอบปกติ ไม่ใช่ข้อผิดพลาด
  2. พร็อกซี: คอนฟิกมาตรฐาน แต่ proxy_read_timeout ต้องไม่น้อยกว่า timeout ฝั่งเซิร์ฟเวอร์บวกสำรองสิบวินาที บัฟเฟอร์เปิดไว้ได้ — คำตอบสั้นและครบถ้วน
  3. ไคลเอนต์: ลูปจัดการผลลัพธ์สามแบบ — มีข้อมูล, คำตอบว่าง, ข้อผิดพลาด พูลการเชื่อมต่อเดียว, keep-alive, timeout ฝั่งไคลเอนต์มากกว่าฝั่งเซิร์ฟเวอร์
  4. การมอนิเตอร์: สัดส่วนคำตอบว่าง เวลารอเฉลี่ย ความถี่ของ 5xx และ timeout ฝั่งไคลเอนต์

เมื่อไหร่ long-polling แพ้

เมื่อเหตุการณ์เกิดถี่ ภาระของเฮดเดอร์และรอบคำขอ-ตอบกลับก็เริ่มเห็นได้ชัด เมื่อมีไคลเอนต์พันราย เซิร์ฟเวอร์ต้องถือคำขอที่รออยู่พันอัน — ถ้าไม่มีสแตกแบบอะซิงโครนัสก็ไม่ไหว และแน่นอน long-polling ไม่สะดวกสำหรับสตรีมคำตอบยาวอันเดียว ที่ต้องได้ลำดับของชิ้นส่วนของสิ่งเดียวกัน โทเคนของโมเดลภาษาผ่าน long-polling — ในทางทฤษฎีทำได้ แต่ในทางปฏิบัติเก้งก้าง

วิธีที่ 4: บริโภคคำตอบแบบสตรีมผ่านพร็อกซีขาออก

ลักษณะเฉพาะของสถานการณ์

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

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

ตรวจสอบพร็อกซีว่าสตรีมโปร่งใสไหม

  1. หาเอ็นด์พอยต์ที่เป็นสตรีมแน่ ๆ — บริการทดสอบสาธารณะที่ส่งบรรทัดแบบหน่วงเวลา หรือเอ็นด์พอยต์ของคุณเองที่มีตารางเวลาชังก์ที่รู้ล่วงหน้า
  2. ยิงคำขอตรงและผ่านพร็อกซีด้วย curl พร็อกซี -N (ปิดบัฟเฟอร์เอาต์พุตของ curl เอง) และ -–trace-time เพื่อดูเวลาประทับ เปรียบเทียบเวลาที่แต่ละส่วนมาถึง
  3. ถ้าผ่านพร็อกซีแล้วทุกส่วนมาเป็นก้อนเดียวตอนจบ — พร็อกซีบัฟเฟอร์ทั้งหมด ถ้ามาเป็นช่วง ๆ ละไม่กี่กิโลไบต์ — บัฟเฟอร์บางส่วน ถ้าตรงกับคำขอตรง — โปร่งใส
  4. ทดสอบสตรีมยาว (5-10 นาที) พร้อม heartbeat การขาดที่เวลาคงที่เผยให้เห็น idle-timeout ของพร็อกซี
  5. ทดสอบ 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 ที่ไม่มีอาร์กิวเมนต์ ไม่งั้นไคลเอนต์จะรอจนการเชื่อมต่อปิด แล้วคุณก็จะไปโทษพร็อกซีเรื่องบัฟเฟอร์ทั้งที่มันไม่มี

โปรโตคอลวินิจฉัย "สามจุด"

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

ข้อผิดพลาดทั่วไปในการทำงานกับสตรีมผ่านพร็อกซี

  1. ปิด proxy_buffering แล้วลืมเรื่อง gzip ข้อผิดพลาดที่พบบ่อยที่สุด สตรีมในนามไม่บัฟเฟอร์ แต่การบีบอัดกองข้อมูลจนถึงขนาดหน้าต่าง อาการ: เป็นห้วง ๆ ละไม่กี่กิโลไบต์
  2. ปล่อย proxy_http_version 1.0 ไว้ nginx โดยค่าเริ่มต้นคุยกับแบ็กเอนด์ทาง HTTP/1.0 ซึ่งไม่มี chunked จึงต้องรอจนการเชื่อมต่อปิด อาการ: คำตอบทั้งอันมาถึงตอนจบ
  3. ไม่ส่ง heartbeat สตรีมจะอยู่ได้จนถึง idle-timeout แรกในห่วงโซ่ — 60 วินาทีที่ nginx, 15 ที่ Envoy ตามเส้นทาง, ไม่กี่นาทีที่ NAT อาการ: ขาดตอนที่ช่วงเวลาคงที่
  4. timeout ของ long-polling ยาวกว่า timeout ของพร็อกซี ไคลเอนต์ได้ 504 แทนคำตอบว่าง มอนิเตอร์ขึ้นแดง และเหตุการณ์อาจซ้ำ
  5. พึ่งการตั้งค่าพร็อกซีระดับโกลบอล พอย้ายไปสภาพแวดล้อมใหม่หรือเปลี่ยน CDN สตรีมมิ่งก็พังเงียบ ๆ ทางออกคือ X-Accel-Buffering และ no-transform ในระดับคำตอบ: พฤติกรรมกำหนดโดยแอป ไม่ใช่ผู้ดูแลพร็อกซี
  6. ไม่มี Last-Event-ID และเคอร์เซอร์ ขาดตอนใด ๆ คือข้อมูลหาย ผ่านพร็อกซีการขาดตอนเกิดบ่อยกว่าตรง ๆ อย่างเห็นได้ชัด
  7. อ่านเนื้อหาทั้งหมดฝั่งไคลเอนต์ ลืม stream=True ไคลเอนต์รอจนจบ แล้วนักพัฒนาก็โทษพร็อกซี
  8. หมุน IP ระหว่างสตรีมที่เปิดอยู่ การเชื่อมต่อขาด ไม่มีการเชื่อมต่อใหม่ ข้อมูลหาย
  9. ทดสอบบนคำตอบสั้น บัฟเฟอร์ยังไม่ทันเต็ม ทุกอย่างดูดี ในโปรดักชันบนคำตอบยาวก็เริ่มเขียนลงไฟล์ชั่วคราว และความหน่วงก็พุ่ง
  10. ผสมเส้นทางสตรีมกับเส้นทางปกติใน location เดียว ไม่ก็ทำสตรีมมิ่งพัง ไม่ก็เสียการบีบอัดและบัฟเฟอร์สำหรับคำตอบปกติ ซึ่งกระทบประสิทธิภาพของ API ทั้งระบบ
  11. เพิกเฉยการที่ไคลเอนต์ตัดการเชื่อมต่อ ผ่านพร็อกซีเซิร์ฟเวอร์รู้ช้าและทำงานที่แพงต่อไป สำหรับ LLM inference นี่คือเงินสด ๆ
  12. ใช้ 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 ผ่านได้ทุกอย่าง แต่ต้องจ่ายด้วยภาระของคำขอถี่ ๆ การเลือกกำหนดด้วยสี่คำถาม: คุณควบคุมห่วงโซ่ไหม ใครคือไคลเอนต์ ข้อมูลมีธรรมชาติอย่างไร และเกิดบ่อยแค่ไหน

สิ่งที่ควรทำวันนี้เลย:

  1. ไล่ผ่านแผนที่แปดจุดบัฟเฟอร์สำหรับโครงสร้างพื้นฐานของคุณ และทำเครื่องหมายว่าจุดไหนคุณควบคุมได้
  2. เพิ่ม X-Accel-Buffering: no และ Cache-Control: no-cache, no-transform ในคำตอบของเส้นทางสตรีม — โดยไม่สนว่าคอนฟิกพร็อกซีปัจจุบันเป็นอย่างไร
  3. ตรวจสอบ proxy_http_version, proxy_buffering, gzip และ proxy_read_timeout ใน nginx หรือของเทียบเท่าในพร็อกซีของคุณ แยกเส้นทางสตรีมออกเป็นบล็อกต่างหาก
  4. ติดตั้ง heartbeat ไม่ห่างกว่า 25 วินาที และบังคับปิดสตรีมทุก 5-15 นาทีพร้อมเคอร์เซอร์
  5. ถ้าคุณบริโภคสตรีมของคนอื่นผ่านพร็อกซี — รันโปรโตคอล "สามจุด" บนทุกพูลแอดเดรส และย้ายคำขอสตรีมไปใช้ HTTPS
  6. ตั้งการมอนิเตอร์เวลาถึงไบต์แรกและช่วงห่างระหว่างชังก์ นี่คือวิธีเดียวที่จะรู้เรื่องบัฟเฟอร์ก่อนผู้ใช้

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