Giriş: Proxy üzerinden akış HTTP neden kitlesel bir sorun haline geldi

Hayal edin: bir dil modeline istek gönderdiniz ve token'ların alışıldık şekilde "yazılması" yerine ekran kırk saniye sessiz kalıyor, sonra tüm yanıtı tek parça halinde kusuyor. Ya da her saniye güncellenmesi gereken izleme panosu, verileri yarım dakikalık gecikmeyle gösteriyor. Ya da bir borsanın olay akışını dinleyen ayrıştırıcı, düzgün bir dere yerine yüz olaylık demetler alıyor. On vakanın dokuzunda suçlu sunucu ya da istemci değil. Arada duran suçlu: proxy, dengeleyici, CDN veya kurumsal geçit — "yardım etmeye" karar verip yanıtı bir bütün olarak biriktiren ve ancak ondan sonra ileten.

Ara düğümler üzerinden akış HTTP yanıtları uzun süre niş bir konu olarak görüldü. 2026'da kitlesel hale geldi. LLM API'lerinden token akışı, web arayüzlerinde sunucu olayları, mesajlaşma uygulamaları ve botlarda long-polling, uzun dışa aktarımlarda ilerleme çubukları, ayrıştırma sonuçlarının akış halinde sunulması — hepsi en sıradan HTTP üzerinden çalışıyor; HTTP ki yanıtı kapatmakta acele etmiyor. Ve tüm bunlar, yolda tamponlama açık bir düğüm belirdiğinde bozuluyor.

Bu rehberde üç klasik mekanizmayı — chunked transfer encoding, Server-Sent Events ve long-polling — tam da proxy'den geçiş açısından ele alacağız. Önemli bir uyarı hemen baştan: burada WebSocket ve gRPC olmayacak. Onlara ayrı bir materyal ayrıldı ve fark esasa dayanıyor. Orada protokol yükseltmesi yapılır veya HTTP/2 üzerinde ikili çerçeveleme kullanılır, proxy bu yükseltmeyi tanıyıp geçirmelidir. Buradaysa — Content-Length başlığı olmayan ve sunucunun açık tuttuğu sıradan bir HTTP yanıtı var. Ne el sıkışma, ne başka bir protokole geçiş. Görünüşe göre bundan basiti yok. Ama tam da bu basitlik sorunu yaratıyor: proxy özel bir şey görmüyor ve kısa yanıtlar için hazırlanmış standart tamponlama kurallarını uyguluyor.

Bu materyalden elde edecekleriniz: akışın bayt ve başlık düzeyinde nasıl işlediğini anlamak; yanıtın takılabileceği tüm noktaların haritası; nginx, HAProxy, Envoy ve istemci kütüphaneleri için hazır yapılandırmalar; üç mekanizma arasında seçim yapma çerçevesi; teşhis kontrol listeleri; sayılarla gerçek vaka incelemeleri. Materyal, API'lerle çalışan, ayrıştırma ve otomasyon yapan geliştiricilere, DevOps mühendislerine ve proxy kullanan herkese yöneliktir.

Temeller: sıradan bir HTTP yanıtı nasıl akışa dönüşür

Yanıt uzunluğunu bildirmenin iki yolu

HTTP/1.1'de istemciye yanıt gövdesinin nerede bittiğini söylemenin iki temel yolu vardır. Birincisi Content-Length başlığı: sunucu önceden kesin bayt sayısını bildirir. İkincisi Transfer-Encoding: chunked: sunucu gövdeyi porsiyonlar halinde gönderir, her porsiyon kendi boyutunu onaltılık biçimde başlatır ve her şey sıfır chunk ile biter. Üçüncü, arkaik bir varyant daha vardır — son bayttan sonra bağlantıyı kapatmak; ama keep-alive ile neredeyse hiç kullanılmaz.

Bu akış için neden önemli? Çünkü Content-Length boyutu önceden bilmeyi gerektirir. Sunucu yanıtı kademeli olarak üretiyorsa — token token, olay olay — iletim başlamadan önce uzunluğu hesaplayamaz. HTTP/1.1'de tek seçenek chunked'dır. HTTP/2 ve HTTP/3'te chunked kodlaması olduğu gibi yoktur: orada gövde zaten DATA çerçeveleriyle iletilir ve son, END_STREAM bayrağıyla belirtilir. Ama mantık aynıdır: bildirilmemiş uzunlukta, istediği kadar sürebilecek bir yanıt.

"Yanıtı kapatmamak" ne demek

Bir benzetme. Sıradan bir HTTP yanıtı bir koli gibidir: üzerinde ağırlığı yazılı bir kutu alırsınız, açarsınız ve içindekinin tamamını bilirsiniz. Akış yanıtı ise konveyör bandıdır: kutular birbiri ardına gelir ve bandın ne zaman duracağını bilemezsiniz. Sunucu başlıkları 200 durumuyla gönderdi, ilk chunk'ı gönderdi — ve bekliyor. Yeni veri geldi — bir sonrakini gönderdi. Bağlantı dakikalarca, saatlerce, bazen günlerce açık kalır.

TCP açısından olağandışı hiçbir şey olmuyor: aynı soket, aynı segmentler. HTTP açısından — tek bir istek ve tek bir yanıt, sadece çok uzun. İşte proxy ile tüm sorunların kökü burada yatıyor: ara düğüm yanıtın başlangıcını görüyor, sonunu görmüyor ve gelen baytlarla ne yapacağına karar vermesi gerekiyor. Hemen iletmeli mi? Yoksa bekleyip biraz daha biriktirip daha verimli mi göndermeli? Varsayılan olarak çoğu proxy ikincisini seçer.

Üç mekanizma: ortak noktalar ve farklar

  • Chunked streaming — en düşük seviyeli olanı. Sunucu gövdeye baytları yazar ve flush çağırır. İçerik biçimi serbesttir: metin, NDJSON, ikili veri. Nasıl ayrıştıracağına istemci karar verir.
  • Server-Sent Events — chunked akış üzerinde standartlaştırılmış metin biçimi. Content-Type: text/event-stream, olaylar boş satırlarla ayrılır, data, event, id, retry alanları vardır. Tarayıcı EventSource aracılığıyla yerel olarak destekler ve otomatik yeniden bağlanır.
  • Long-polling — kesin konuşmak gerekirse akış değildir. İstemci istek yapar, sunucu veri gelene veya zaman aşımına kadar onu açık tutar, yanıtlar ve kapatır. İstemci hemen bir sonraki isteği yapar. Bu, her biri Content-Length'e sahip olabilen sıradan yanıtlar dizisiyle akışı taklit etmektir.

Ortak noktaları ne? Üçünde de tek bir isteğin yanıtı belirsiz süre gecikir ve proxy bunu atlatmalıdır: zaman aşımıyla bağlantıyı koparmamalı ve veriyi tamponda geciktirmemelidir. Fark, her mekanizmanın ara düğümün şeffaflığına ne kadar bağlı olduğundadır. Chunked ve SSE kritik derecede bağlıdır. Long-polling — minimum düzeyde ve bu onun ana avantajıdır.

Zincirdeki proxy'nin rolü

Modern altyapıda istemci ile sunucu arasında nadiren boşluk olur. Tipik zincir: istemci uygulaması — giden proxy (örneğin mobil veya konut) — internet — CDN — bulut dengeleyici — ters proxy — uygulama. Bu düğümlerin her biri potansiyel bir tamponlama noktasıdır. Ve her biri varsayılan olarak kısa yanıtları optimize edecek şekilde ayarlanmıştır: topla, sıkıştır, bir bütün olarak ilet. Akış için bu tür bir optimizasyon felakettir. Bu katmanları sırayla kaldıracağız ve her birinde ne olduğuna bakacağız.

Derinlemesine bakış: akış nerede ve neden ara düğümde takılır

Proxy'ler neden tamponlar

Tamponlamayı eleştirmeden önce mantığını anlamak gerekir. nginx gibi bir ters proxy üç nedenden dolayı tamponlar. Birincisi — backend'i yavaş istemciden korumak: istemci mobil bağlantıda saniyede on kilobayt okuyorsa ve backend yanıtı zaten üretmişse, yanıtın tamamını backend'den bir kerede almak, çalışanını serbest bırakmak ve sonra istemciye tampondan sakin sakin iletmek daha avantajlıdır. İkincisi — sıkıştırma: gzip ve brotli büyük bloklarda daha verimli çalışır. Üçüncüsü — Content-Length belirleme ve istemciye başlıkları göndermeden önce backend hatasını düzgün işleme imkânı.

Birkaç kilobaytlık yanıtlarla tipik bir API için tüm bunlar makul ve kaynak tasarrufu sağlar. Akış için — tam tersi: baytları geciktirerek proxy akışın öz değerini yok eder. Bu değer güncelliktedir, hacimde değil.

Sekiz tamponlama noktasının haritası

Zincir boyunca ilerleyelim ve verilerin takılabileceği her noktayı işaretleyelim. Teşhis sırasında bu listeyi elinizin altında bulundurun.

  1. Uygulama. Framework çıktıyı kendi tamponlayabilir. WSGI sunucuları, output_buffering açık PHP, sıkıştırma middleware'li Node.js framework'leri. Flush çağrılmaz — veri süreç tamponunda bekler.
  2. Uygulamanın önündeki ters proxy. nginx proxy_buffering on (varsayılan açık) ile yanıtı proxy_buffer_size ve proxy_buffers ile belirlenen tamponlarda biriktirir; taşarsa diskte geçici dosyaya yazar. Apache mod_proxy daha az tamponlar ama kendi ayarları vardır. Caddy varsayılan olarak tamponlamaz ama flush_interval kontrol edilmelidir.
  3. Proxy'de sıkıştırma. proxy_buffering off olsa bile açık gzip, veriyi sıkıştırma penceresi boyutuna kadar biriktirir. Bu en sinsi noktalardan biridir: tamponlama resmen kapalı ama akış sarsıntılı gelir.
  4. L7 dengeleyici. HAProxy http modunda, http-buffer-request açık değilse veriyi geldiği gibi iletir ama tune.bufsize ile sınırlıdır. Envoy varsayılan olarak akış yapar, ancak sıkıştırma filtreleri veya Lua gövdeyi biriktirebilir.
  5. CDN ve bulut geçitleri. Çoğu CDN, önbelleğe alma ve sıkıştırma için yanıtları tamponlar. Bazı sağlayıcılar belirli bir süreden uzun akışları desteklemez veya açık ayar gerektirir. Bulut API geçitlerinin genellikle yaklaşık 30 saniyelik katı bir yanıt süresi sınırı vardır ve gövde akışını hiç desteklemez.
  6. İstemci tarafındaki giden proxy. İnternete çıktığınız HTTP proxy — kurumsal, mobil, konut — o da bir HTTP ayrıştırıcısıdır. nginx veya Squid üzerine kurulmuş ve tamponlamaya ayarlanmışsa akış orada takılır. Kaliteli proxy hizmetleri chunked yanıtları şeffaf geçirir ama bu pratikte doğrulanmalıdır.
  7. TLS ve TCP. Veri TLS kayıtlarında gecikebilir, kütüphane 16 kilobayt boyutuna kadar biriktirirse. Nagle algoritması, önceki onaylanmadan küçük TCP segmentlerini geciktirir. Küçük chunk'lardan oluşan akış için bu her birine onlarca milisaniye ekler.
  8. İstemci kütüphanesi. Python'da requests, stream=True verilmezse tüm gövdeyi belleğe okur. Bazı HTTP istemcileri chunk_size boyutuna kadar tamponlar.

Sekiz nokta. En az biri veriyi biriktiriyorsa, akışı sarsıntılar halinde veya sonda tek büyük demet halinde görürsünüz. Ve en tatsızı: davranış hacme bağlıdır. Küçük yanıtlarda her şey normal görünür, yük altında veya uzun yanıtlarda tampon dolar, geçici dosyalara yazma devreye girer ve gecikmeler fırlar. Ekiplerin sorunu yalnızca üretimde keşfetmesi şaşırtıcı değil.

Akış bağlamında HTTP/1.1 ile HTTP/2 karşılaştırması

HTTP/1.1'de bir bağlantı — birim zamanda bir yanıt. Uzun ömürlü yanıt bağlantıyı tamamen işgal eder. Tarayıcı bir ana bilgisayara eşzamanlı bağlantı sayısını altıyla sınırlar, bu yüzden altı açık SSE akışı o ana bilgisayara yapılan diğer tüm istekleri bloke eder. Backend ile HTTP/1.1 üzerinden çalışan proxy de her akış için bir bağlantı tutar.

HTTP/2'de çoklama bu sınırı kaldırır: yüz akış tek TCP bağlantısında yaşar. Ama bir incelik ortaya çıkar — protokol düzeyinde akış kontrolü. Alıcı pencereyi WINDOW_UPDATE ile genişletmezse gönderici durur. Bazı proxy'ler bu çerçevelerin iletilmesini özensiz uygular ve yapay duraklamalar yaratır.

Şunu anlamak önemli: proxy, istemciden gelen isteği HTTP/2 ile alıp backend'e HTTP/1.1 ile gidebilir. DATA çerçevelerini chunk'lara ve geri dönüştürür. Bu normal bir işlemdir ama tam da dönüşüm sınırında çoğu zaman zamanında flush kaybolur — proxy "uygun" çerçeve boyutu dolana kadar bekler.

Zaman aşımları — akışların ikinci katili

Tamponlama veriyi geciktirir. Zaman aşımları bağlantıyı koparır. nginx'te proxy_read_timeout vardır — backend'den iki ardışık okuma işlemi arasındaki maksimum süre, varsayılan 60 saniye. Sunucu bir dakikadan uzun süre sessiz kalırsa nginx bağlantıyı kapatır ve istemciye 504 döner. 90 saniye bekleyen long-polling için bu garantili bir başarısızlıktır. HAProxy'de timeout server ve timeout tunnel. Bulut dengeleyicilerde idle timeout, sıklıkla 60 veya 350 saniye. Mobil operatörlerde NAT zaman aşımları, etkin olmayan bağlantıları birkaç dakikada sıfırlar.

Buradan katı bir kural çıkar: periyodik etkinliği olmayan akış mahkûmdur. Her 15-30 saniyede heartbeat mesajı — bir seçenek değil, uzun ömürlü her yanıtın zorunlu gereğidir.

Mekanizma seçim matrisi

Pratiğe geçmeden önce seçim çerçevemizi sabitleyelim. Dört soruya cevap verin.

  • Tüm proxy zincirini kontrol ediyor musunuz? Evet — chunked ve SSE uygundur. Hayır, zincirde bilinmeyen geçitler varsa — long-polling ile başlayın veya ona bozulma (degradasyon) öngörün.
  • İstemci kim? Tarayıcı — SSE, EventSource ile yeniden bağlanmayı bedava verir. Kendi kodunuz — NDJSON'lu chunked daha esnektir.
  • Verinin doğası nedir? Tek bir varlığın parçaları (bir yanıtın token'ları) — chunked veya SSE. Ayrık bağımsız olaylar — SSE veya long-polling.
  • Sıklık nedir? Saniyede onlarca olay — chunked veya toplu SSE. Dakikada bir olay — uzun zaman aşımlı long-polling veya heartbeat'li SSE.

Yöntem 1: chunked transfer encoding — kaplamasız düşük seviyeli akış

Saf chunked ne zaman seçilir

Saf chunked akış, istemci tarayıcı değil kendi kodunuz olduğunda; veri biçimi metinsel değilse veya olay modeline sığmıyorsa; her bayt üzerinde maksimum kontrol gerektiğinde uygundur. Tipik örnekler: API'den NDJSON akışı, ayrıştırma sonuçlarının akış halinde verilmesi, ilerleme göstergeli büyük dışa aktarımların indirilmesi, LLM yanıtlarının kendi biçiminizde proxy'lenmesi.

Sunucu tarafını adım adım yapılandırma

  1. Uygulamanın parça parça yazdığından emin olun. Her mantıksal porsiyondan sonra flush çağırın. ASGI sunuculu Python'da bu, bayt yayan bir üreteçtir; Node.js'te sıkıştırma varsa ardından flush gelen res.write; Go'da her Write'tan sonra http.Flusher arayüzü.
  2. Content-Length ayarlamayın. Çoğu framework, uzunluk verilmezse kendi kendine chunked'a geçer. HTTP/1.1'de yanıtta Transfer-Encoding: chunked olduğunu doğrulayın.
  3. Uygulama düzeyinde sıkıştırmayı akış rotaları için kapatın veya verilerle birlikte flush ettiğinden emin olun. Uzlaşma — her chunk'tan sonra eşzamanlı flush ile gzip; bu çalışır ama sıkıştırma oranını düşürür.
  4. X-Accel-Buffering: no başlığını ekleyin. Bu, nginx'e özgü, genel yapılandırmayı değiştirmeden tek bir yanıt için tamponlamayı kapatan bir başlıktır. Bazı diğer proxy'ler de anlar. Ayrıca Cache-Control: no-cache, no-transform ekleyin — ikinci değer ara düğümlerden gövdeyi değiştirmemelerini ister.
  5. Ters proxy'yi yapılandırın. nginx'te akış rotasının location'ında: 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 yönergesi zorunludur: nginx varsayılan olarak backend'e HTTP/1.0 ile başvurur, orada chunked yoktur ve nginx bağlantı kapanana kadar tamponlamak zorunda kalır.
  6. Rotaları ayırın. Sıkıştırma API'nin geri kalanı için gerekiyorsa yalnızca akış olmayan location bloklarında açın.
  7. Nagle algoritmasını kontrol edin. nginx'te tcp_nodelay varsayılan açıktır ama uygulamada küçük sık chunk'larda sokete açıkça TCP_NODELAY ayarlamak gerekebilir.

HAProxy ve Envoy yapılandırması

HAProxy. Backend bölümünde option http-buffer-request kullanmayın. timeout server'ın senaryonuz için yeterince büyük olduğundan emin olun; gerçekten uzun akışlar için timeout tunnel ayarlayın. Sıkıştırmayı akış yolları için ACL ile kapatın veya no-transform başlığına güvenin: HAProxy Cache-Control: no-transform'a saygı duyar ve bu tür yanıtları sıkıştırmaz.

Envoy. Tamponlama varsayılan olarak kapalıdır, sevindirici. Ama iki zaman aşımını kontrol edin: HTTP connection manager'daki stream_idle_timeout (varsayılan beş dakika) ve route timeout (varsayılan on beş saniye — çoğunlukla akışları kesen odur). Akış rotaları için timeout'u 0s olarak ayarlayın, bu sınırsız anlamına gelir ve heartbeat ile birlikte idle timeout'a güvenin.

Chunked akışı doğrulama kontrol listesi

  • Yanıtta Transfer-Encoding: chunked var veya HTTP/2 Content-Length'siz kullanılıyor.
  • X-Accel-Buffering: no başlığı uygulama yanıtında mevcut.
  • Content-Encoding yok veya sıkıştırma veriyle birlikte flush ediliyor.
  • İlk gövde baytı başlıklardan sonra bir saniye içinde geliyor.
  • İstemcide chunk'lar arası aralıklar sunucudaki üretim aralıklarıyla 50 milisaniyeye kadar sapmayla örtüşüyor.
  • Heartbeat varken bağlantı bir dakikadan uzun süre kopmadan yaşıyor.
  • Proxy günlüklerinde geçici dosyaya tamponlama kaydı yok.

Yöntem 2: Server-Sent Events — sunucudan istemciye olaylar için standart

Biçimin yapısı

SSE, olayların metin akışına nasıl yerleştirileceğine dair bir anlaşmadır. Yanıt Content-Type: text/event-stream taşır. Her olay, "alan: değer" biçiminde satırlar kümesidir ve boş satırla biter. Alanlar: data — faydalı yük (tekrarlanabilir, satırlar satır sonuyla birleştirilir); event — olay türü adı; id — kaldığı yerden devam için tanımlayıcı; retry — önerilen yeniden bağlanma gecikmesi milisaniye cinsinden. İki nokta üst üste ile başlayan satır — yorumdur ve mükemmel bir heartbeat'tir: tarayıcı onu görmezden gelir, proxy ise bağlantıda etkinlik görür.

SSE'nin güzelliği asimetride. Karmaşıklık spesifikasyona ve tarayıcıya taşınmıştır, sunucu ise önemsiz kalır. Ne el sıkışma, ne ikili çerçeveleme. Sadece akan metin. Bu yüzden SSE, dil modeli yanıtlarının akışı için fiili standart haline geldi: büyük LLM API'lerinin ezici çoğunluğu token'ları text/event-stream biçiminde veriyor. On beş yıldan fazla önce spesifikasyonlarda tanımlanmış bir teknolojinin 2026'da ikinci baharını yaşaması şaşırtıcı.

SSE neden tamponlamaya özellikle duyarlı

SSE'de bir olay birkaç düzine bayttan birkaç kilobayta kadar ağırlık taşır. nginx'in varsayılan tamponu — ilk blok için 4 veya 8 kilobayt ve sonra 4-8 kilobaytlık sekiz blok. Yani proxy, ilkini göndermeden önce elli ila birkaç yüz olay biriktirecek. Bir model sohbeti için bu şöyle görünür: kullanıcı on beş saniye bekler, sonra tüm paragraf anında belirir. Yazma illüzyonu yıkıldı, oysa akış tam da bunun için uygulanmıştı.

SSE'yi proxy üzerinden adım adım uygulama

  1. Yanıt başlıkları: Content-Type: text/event-stream; charset=utf-8, Cache-Control: no-cache, no-transform, X-Accel-Buffering: no ve HTTP/1.1 için ayrıca Connection: keep-alive.
  2. Heartbeat. Her 15-25 saniyede bir : ping biçiminde yorum satırı gönderin. Bu makul herhangi bir idle zaman aşımından küçüktür ve operatörlerin NAT tablolarını güncel tutar.
  3. Olay tanımlayıcıları. Her olaya monoton artan bir id atayın. Yeniden bağlanmada tarayıcı Last-Event-ID başlığını gönderir ve sunucu kaçırılanı yeniden gönderebilir. Bu olmadan proxy'deki her kopma — veri kaybıdır.
  4. retry alanı. Makul bir değer ayarlayın, örneğin 3000 milisaniye; böylece istemciler sunucu yeniden başlatıldığında yeniden bağlanma fırtınası yaratmaz.
  5. nginx yapılandırması — chunked ile aynı. Ayrıca text/event-stream için gzip uygulanmadığından emin olun: gzip_types text/* içeriyorsa gzip off ile ayrı bir location ekleyin.
  6. Bağlantı planlaması. HTTP/1.1'de her açık SSE akışı — proxy ile backend arasında ayrı bir bağlantıdır. Bin eşzamanlı istemci için bin bağlantı gerekir. İstemci tarafında HTTP/2 ve backend'de asenkron sunucu kullanın.
  7. Kapanışı işleme. Sunucu, istemcinin bağlantıyı kopardığını algılamalı ve üretimi durdurmalıdır. Proxy üzerinden bu gecikmeyle olur: sunucu kopmayı ancak yazma denemesinde öğrenir. Model çıkarımı gibi pahalı işlemler için bu, fazladan GPU saniyeleridir. Çözüm — bağlantı koptuğunda yazma hatası tetikleyen düzenli heartbeat kayıtları.

SSE ve HTTP/2: incelikler

HTTP/2 üzerinden SSE altı bağlantı sınırı olmadan çalışır — ön uç proxy'de HTTP/2'yi etkinleştirmenin ana nedeni budur. Ancak HTTP/2'yi backend'e HTTP/1.1'e dönüştürürken bazı proxy'ler çerçeve toplama nedeniyle küçük bir gecikme ekler. İlk olayın hemen gittiğinden, çerçeve dolmasını beklemediğinden emin olun. Backend de HTTP/2 konuşuyorsa gecikmeler minimumdur ama proxy'nin WINDOW_UPDATE'i doğru ilettiğini ve akışı pencere kontrolüyle boğmadığını doğrulayın.

SSE akışı tasarım çerçevesi

  1. Olay türlerini ve sıklığını belirleyin. Seyrek olaylar heartbeat gerektirir; sık olanlar — birden çok kaydın tek olay içinde toplanmasını.
  2. Devam stratejisini seçin: Last-Event-ID işleme için sunucuda son olayların halka tamponunu tutmak veya yeniden bağlanmada tam yeniden eşzamanlamaya güvenmek.
  3. Bir akışın süre sınırını belirleyin. İyi uygulama — sunucunun her 5-10 dakikada bir akışı kendisinin kapatması, istemcinin şeffaf şekilde yeniden bağlanması. Bu, durum birikmesine karşı korur ve altyapının gizli zaman aşımlarını atlar.
  4. Bozulmayı düşünün: akış proxy'den geçmiyorsa otomatik olarak long-polling'e geçin.

Yöntem 3: long-polling — sıradan yanıtlar dizisinden akış

Nasıl çalışır ve neden hâlâ güncel

Long-polling üçünün en eski tekniğidir. İstemci istek gönderir, sunucu hemen yanıtlamaz, belirlenen zaman aşımına kadar (genellikle 20-60 saniye) olay bekler. Olay geldi — sunucu yanıtı verir ve kapatır. Hiçbir şey gelmedi — boş yanıt verir. İstemci hemen bir sonraki isteği gönderir. Dışarıdan bakıldığında bu minimum gecikmeli bir akış gibi görünür ama her yanıt — sıradan, Content-Length'li, her proxy, her önbellek ve her geçitle tam uyumlu.

Long-polling 2026'da neden canlı ve sağlıklı? Çünkü her yerden geçer. Chunked'ı kesen kurumsal geçitlerden. Yanıt süresi sınırı olan bulut API geçitlerinden. Öngörülemeyen tamponlamalı proxy sunuculardan. En bilinen örnek, büyük bir mesajlaşma uygulamasının Bot API'sinde güncelleme alma yöntemidir; burada timeout parametresi bekleme süresini belirler. Botların ezici çoğunluğu yıllardır tam da böyle, çok çeşitli proxy'ler üzerinden ve sorunsuz çalışıyor.

Proxy üzerinden long-polling tasarımının beş kuralı

  1. Sunucu zaman aşımı zincirdeki en kısa zaman aşımından küçük. Proxy'de proxy_read_timeout 60 saniyeyse sunucu beklemesi en fazla 50. Zincirde 30 saniyelik bulut geçidi varsa — en fazla 25. Aksi halde boş yanıt yerine istemci 504 alır ve hata akışı izlemeyi çıldırtır.
  2. İmleç veya offset. İstemci son aldığı olayın tanımlayıcısını gönderir. Sunucu ondan sonra gelen her şeyi verir. Protokol idempotent hale gelir: kaybolan yanıt sadece aynı olayların tekrar verilmesine yol açar.
  3. Hata sonrası yeniden bağlanmada jitter. Üstel artış — 1, 2, 4, 8 saniye — artı rastgele ekleme. Jitter olmadan arıza sonrası bin istemci sunucuya aynı anda vurur.
  4. Başarılı yanıttan sonra sıfır duraklama. Sonraki istek derhal gider. Buradaki herhangi bir duraklama — kayıp gecikmedir.
  5. Keep-alive zorunlu. Onsuz her istek — yeni TCP bağlantısı ve yeni TLS el sıkışması. Bu her döngüye 50 ila 300 milisaniye ekler, uzak proxy üzerinden daha da fazla.

Adım adım uygulama

  1. Sunucu: uç nokta offset ve timeout alır, dahili kuyrukta veya abonelikle olay bekler, yeni offset'li olay dizisiyle yanıtlar. Boş dizi — normal yanıt, hata değil.
  2. Proxy: standart yapılandırma, ancak proxy_read_timeout sunucu zaman aşımından az değil, artı on saniye pay. Tamponlama açık kalabilir — yanıt kısa ve bütündür.
  3. İstemci: üç sonucu işleyen döngü — veri, boş yanıt, hata. Tek bağlantı havuzu, keep-alive, sunucu zaman aşımından büyük istemci zaman aşımı.
  4. İzleme: boş yanıt oranı, ortalama bekleme süresi, 5xx ve istemci zaman aşımı sıklığı.

Long-polling ne zaman kaybeder

Yüksek olay sıklığında başlık ek yükü ve istek-yanıt döngüsü belirgin hale gelir. Binlerce istemcide sunucunun binlerce bekleyen istek tutması gerekir — asenkron yığın olmadan olmaz. Ve elbette long-polling, tek bir uzun yanıtın akışı için, tek bir varlığın parça dizisine ihtiyaç duyulduğunda elverişsizdir. Dil modeli token'ları long-polling ile teorik olarak mümkündür ama pratikte hantaldır.

Yöntem 4: Giden proxy üzerinden akış yanıtlarını tüketme

Senaryonun özellikleri

Şimdiye kadar sunucu sahibinin gözünden baktık. Şimdi resmi ters çevirelim: siz — istemci, başkasının akış API'sine proxy sunucu üzerinden başvuruyorsunuz ve yalnızca istemci tarafı sizin elinizde. Tipik görevler: adres havuzu üzerinden akış API'lerinden veri toplama, otomasyon betiklerinden LLM akışıyla çalışma, API yükünü farklı IP'lere dağıtma, platformlardaki olayları gerçek zamanlı izleme, kendi servisinizi farklı ağlardan test etme.

Burada üç şey önemli. Proxy'nin kendisi chunked yanıtları şeffaf geçirmeli. İstemci kütüphanesi akışı geldiği gibi okumalı. Ve proxy'deki sorunu hedef sunucudaki sorundan ayırt edebilmelisiniz.

Proxy'yi akış şeffaflığı açısından doğrulama

  1. Bilinen bir akış uç noktası alın — gecikmeli satırlar veren genel bir test servisi veya chunk takvimi bilinen kendi uç noktanız.
  2. Doğrudan ve proxy üzerinden curl ile -N (curl'ün kendi çıktı tamponlamasını devre dışı bırakır) ve zaman damgaları için --trace-time ile istek yapın. Parçaların geliş anlarını karşılaştırın.
  3. Proxy üzerinden tüm parçalar sonda tek parça halinde geliyorsa — proxy tamamen tamponluyor. Birkaç kilobaytlık porsiyonlarla geliyorsa — kısmen. Doğrudan istekle örtüşüyorsa — şeffaf.
  4. Heartbeat'li uzun bir akışı (5-10 dakika) test edin. Sabit süre sonra kopma, proxy'nin idle zaman aşımını ortaya çıkarır.
  5. HTTPS'i kontrol edin. CONNECT yöntemli proxy üzerinden bir tünel oluşur ve proxy içerideki HTTP'yi ayrıştırmaz — HTTP düzeyinde tamponlama olamaz, sadece TCP gecikmeleri. Akış API'lerinin CONNECT tüneli üzerinden genellikle istekleri ayrıştıran sıradan HTTP proxy'den daha düzgün çalışmasının nedenlerinden biri budur.

Mobil proxy'lerle ilgili incelik: hücresel ağ kendisi jitter ekler ve operatörlerin NAT'ı etkin olmayan bağlantıları agresif kapatır. Mobil proxy üzerinden uzun akışlar için 15-20 saniyede bir heartbeat — gerekliliktir. IP rotasyonu açık akışları hesaba katmalıdır: bir SSE bağlantısının ortasında adres değişikliği onu garantili koparır. Rotasyonu akış yaşam döngüsüyle uyumlayın — akışı kapattınız, adresi değiştirdiniz, imleçle yenisini açtınız.

İstemci kütüphaneleri: neyi etkinleştirmeli

  • Python, requests: çağrıda stream=True, sonra küçük chunk_size ile iter_lines veya iter_content. Zaman aşımını (connect, read) demeti olarak ayarlayın; burada read — chunk'lar arası izin verilen süre, toplam yanıt süresi değil.
  • Python, httpx: asenkron kod için client.stream ve aiter_lines; SSE için olay biçimini ayrıştıran özel sarmalayıcılar.
  • Python, aiohttp: response.content.iter_any veriyi soketten geldiği tam biçimde döndürür, yeniden paketlemez — gerçek aralıkları ölçmek için ideal.
  • Node.js: response.body'yi ReadableStream olarak okuyan fetch; SSE için biçim ayrıştırıcı kütüphaneler.
  • Go: normal http.Client, resp.Body'yi büyük olaylar için yeterli tampon boyutlu bufio.Scanner ile okuma.

Her durumda: gövdeyi baştan sona okuyan yöntemleri çağırmayın — text, json, bağımsız read. Aksi halde istemci bağlantının kapanmasını bekler ve olmayan tamponlama için proxy'yi suçlarsınız.

"Üç nokta" teşhis protokolü

Akış tuhaf davrandığında, ilk bayta kadar geçen süreyi ve chunk'lar arası aralık dağılımını üç yapılandırmada ölçün: aynı makineden doğrudan sunucuya; proxy üzerinden sunucuya; proxy üzerinden referans akış uç noktasına. Karşılaştırma sorunu net şekilde yerelleştirir. Proxy üzerinden referansa iyi, hedef sunucuya kötü — hedef sunucunun altyapısı suçlu. Referansa kötü — proxy suçlu. Doğrudan da kötü — kodunuz veya ağ suçlu. Bu protokol on dakika sürer ve günlerce tartışmayı önler.

Proxy üzerinden akışlarla çalışırken tipik hatalar

  1. proxy_buffering kapatıldı, gzip unutuldu. En yaygın hata. Akış resmen tamponlanmıyor ama sıkıştırma veriyi pencere boyutuna kadar biriktiriyor. Belirti: birkaç kilobaytlık sarsıntılar.
  2. proxy_http_version 1.0 bırakıldı. nginx varsayılan olarak backend'e HTTP/1.0 ile gider, orada chunked yoktur ve bağlantının kapanmasını beklemek zorundadır. Belirti: tüm yanıt sonda gelir.
  3. Heartbeat gönderilmiyor. Akış, zincirdeki ilk idle zaman aşımına kadar yaşar — nginx'te 60 saniye, rotada Envoy'da 15, NAT'ta birkaç dakika. Belirti: aynı aralıklarla kopmalar.
  4. Long-polling zaman aşımı proxy'ninkinden büyük. İstemci boş yanıt yerine 504 alır, izleme kırmızı yanar ve olaylar tekrarlanabilir.
  5. Proxy'nin genel ayarına güveniliyor. Yeni bir ortama taşınınca veya CDN değiştirilince akış sessizce bozulur. Çözüm — yanıt düzeyinde X-Accel-Buffering ve no-transform: davranışı proxy yöneticisi değil uygulama belirler.
  6. Last-Event-ID ve imleç yok. Her kopma — veri kaybı. Proxy üzerinden kopmalar doğrudan olduğundan belirgin şekilde daha sık olur.
  7. İstemcide gövde baştan sona okunuyor. stream=True unutuldu, istemci tamamlanmayı bekliyor, geliştirici proxy'yi suçluyor.
  8. Açık akış sırasında IP rotasyonu. Bağlantı kopar, yeniden bağlanma yok, veri kaybolur.
  9. Kısa yanıtlarda test ediliyor. Tampon dolmaya zaman bulamaz, her şey mükemmel görünür. Üretimde uzun yanıtlarda geçici dosyaya yazma devreye girer ve gecikmeler fırlar.
  10. Akış ve normal rotalar tek location'da karıştırılıyor. Ya akış bozulur ya normal yanıtlar için sıkıştırma ve tamponlama kaybedilir, bu da tüm API performansına vurur.
  11. İstemcinin bağlantıyı koparması görmezden geliniyor. Proxy üzerinden sunucu kopmayı geç öğrenir ve pahalı üretime devam eder. LLM çıkarımı için bu doğrudan paradır.
  12. Long-polling gereken yerde chunked kullanılıyor. Yanıt sınırı olan kurumsal geçit veya bulut API geçidi üzerinden akış geçmez, long-polling ise sorgusuz geçer.

Yapılandırma ve teşhis için araçlar ve kaynaklar

Ters proxy'ler ve dengeleyiciler

  • nginx — esneklik referansı. Anahtar yönergeler: proxy_buffering, proxy_http_version, proxy_read_timeout, gzip, X-Accel-Buffering başlık desteği.
  • HAProxy — kutudan minimal tamponlama. timeout server, timeout tunnel ve sıkıştırmaya dikkat edin.
  • Envoy — varsayılan olarak akış yapar. route timeout ve stream_idle_timeout kritiktir.
  • Caddy — varsayılan olarak tamponlamaz; flush_interval değerini -1 yapmak anında flush'ı açıkça belirler.
  • Traefik — akışları şeffaf geçirir; zaman aşımları entrypoint düzeyinde yapılandırılır.

Teşhis

  • curl -N, -v ve --trace-time bayraklarıyla her parçanın geliş anlarını gösterir. -w parametresi time_starttransfer ve time_total değişkenleriyle ilk bayt zamanı ve toplam süreyi verir.
  • tcpdump ve Wireshark — baytlar ağ düzeyinde mi gecikmeli gidiyor yoksa yukarıda mı geciktiriliyor kontrol edin.
  • mitmproxy — chunk yapısını koruyarak akışları görüntüleme. Mutlaka akış modunu açın, yoksa kendisi tamponlama noktası haline gelir.
  • Tarayıcı geliştirici araçları — SSE için EventStream sekmesi her olayı zaman damgasıyla gösterir.

Test uç noktaları ve kütüphaneler

HTTP testi için genel servislerin, belirli sayıda satırı gecikmeli veren uç noktaları vardır — proxy şeffaflığını doğrulamak için idealdirler. Herhangi bir dilde saniyede bir chunk ve zaman damgası veren kendi minimal sunucunuz daha da iyidir: her iki tarafı da siz kontrol edersiniz. Sunucuda SSE için neredeyse her asenkron framework'ün hazır text/event-stream yanıt sınıfı vardır. Tarayıcı dışında SSE için Python, Node.js ve Go için biçim ayrıştırıcıları vardır. Long-polling için özel kütüphane gerekmez — bağlantı havuzlu HTTP istemcisi yeterlidir.

İzleme

Toplanması gereken metrikler: gövdenin ilk baytına kadar geçen süre; chunk'lar arası aralıkların 50, 95 ve 99. yüzdeleri; akışların yaşam süresi ve kapanma nedeni; proxy'de ve backend'de etkin akış sayısı; Last-Event-ID ile yeniden bağlanma oranı. Chunk'lar arası aralıkta ani artış ve eşzamanlı hacim artışı — devreye giren tamponlamanın kesin sinyalidir.

Vakalar ve sonuçlar: gerçek projelerde nasıl görünüyor

Vaka 1. nginx üzerinden LLM akışı: 11 saniyeden 310 milisaniyeye

Ekip, dil modeline dayalı bir sohbet uyguladı. Yerelde token'lar akıcı beliriyordu. nginx arkasına alındıktan sonra kullanıcılar 8-12 saniye boş ekran gördü, ardından tüm yanıt bir anda geldi. "Üç nokta" protokolüyle teşhis gösterdi: doğrudan uygulamaya ilk token 280 milisaniyede geliyordu, nginx üzerinden — 11 saniyede. Sebepler klasikti: proxy_buffering on ve varsayılan proxy_http_version 1.0. Rota için proxy_buffering off, proxy_http_version 1.1, gzip off ve uygulama yanıtına X-Accel-Buffering: no ekledikten sonra proxy üzerinden ilk token'a kadar geçen süre 310 milisaniye oldu. Yan bulgu: sekme kapatıldığında çıkarım yanıtın sonuna kadar devam ediyordu. Yazma hatasını kontrol eden heartbeat devreye girdikten sonra terk edilen isteklere harcanan GPU süresi yaklaşık dörtte bir azaldı.

Vaka 2. SSE tabanlı pano ve mobil ağlar

İzleme servisi olayları SSE ile veriyordu. Kablolu internette her şey çalışıyordu ama mobil cihazlardan akışlar sunucuda hata olmadan 2-4 dakika sonra kopuyordu. Sebep — operatörlerin etkin olmayan bağlantılardaki NAT zaman aşımları. Çözüm: her 20 saniyede bir heartbeat yorumu artı doğru Last-Event-ID ile her 10 dakikada bir sunucunun akışı zorla kapatması. "Donmuş pano" şikâyetleri neredeyse sıfıra düştü, kesintisiz akışın ortalama süresi 3 dakikadan 10 dakikaya çıktı (artık kasıtlı kapatma ile sınırlı), yeniden bağlanmada olay kaybı kaydedilmedi.

Vaka 3. Mobil proxy havuzu üzerinden akış API'si ayrıştırma

Ekip, NDJSON akışı veren bir platformdan olayları mobil proxy havuzu üzerinden topluyordu. İki sorun görüldü: akışların bir kısmı 8 kilobaytlık sarsıntılarla geliyordu, bir kısmı adres rotasyonunda kopuyordu. Test, şifresiz isteklerde proxy'nin HTTP'yi ayrıştırıp yanıtları tamponladığını, HTTPS uç noktasına CONNECT tüneli üzerinden ise akışı şeffaf geçirdiğini gösterdi. HTTPS'e geçiş birinci sorunu tamamen çözdü. İkincisi senkronizasyonla kapatıldı: IP rotasyonu yalnızca akış düzgün kapatıldıktan sonra yapılıyor ve yeniden bağlanma son olayın imleciyle yapılıyor. Toplanan verinin bütünlüğü yaklaşık yüzde 91'den 99,7'ye çıktı.

Vaka 4. Sınırlı geçit üzerinden long-polling tabanlı bot

Geliştirici, botu giden isteklerin 30 saniyelik yanıt sınırı olan kurumsal bir geçitten geçtiği altyapıda tutuyordu. Başlangıçta 60 saniyelik bekleme zaman aşımı kullanılıyordu — isteklerin yarısı geçit hatasıyla bitiyor, güncellemeler tekrarlanıyordu. Zaman aşımını 25 saniyeye indirip hatalarda üstel jitter ekledikten sonra hata oranı yüzde 48'den yüzde 0,5'in altına düştü. Olay dağıtımındaki ortalama gecikme değişmedi — o, bekleme uzunluğuyla değil olayın gerçekleşme anıyla belirlenir.

Vaka 5. SSE için HTTP/2'ye geçiş

Web uygulaması sekme başına 3-4 SSE akışı açıyordu. Birkaç sekme açıkken tarayıcı altı bağlantı sınırını tüketiyor ve normal istekler akışların arkasında kuyruğa giriyordu. Ön uç proxy'de HTTP/2'yi etkinleştirmek tüm akışları tek bağlantıya taşıdı. Beş sekme açıkken sayfa yükleme süresi 9 saniyeden 1,5 saniyeye düştü. Yan bulgu: geçiş sonrası stream_idle_timeout artırılması gerekti, çünkü önceki ayarlar HTTP/1.1 için hesaplanmıştı.

SSS: Proxy üzerinden akış yanıtları hakkında derin sorular

Proxy açısından akış HTTP'nin WebSocket'ten temel farkı nedir?

WebSocket protokol yükseltmesi gerektirir: proxy Upgrade ve Connection başlıklarını tanımalı, tünel moduna geçmeli ve HTTP'yi ayrıştırmayı bırakmalıdır. Akış HTTP hiçbir şey gerektirmez — uzun süre bitmeyen sıradan bir yanıttır. Paradoks şu ki WebSocket proxy üzerinden ya çalışır ya hiç çalışmaz, akış HTTP ise her zaman "çalışır" ama kötü çalışabilir: veri ulaşır ama gecikmeyle. Bu yüzden akış sorunlarını fark etmek ve teşhis etmek daha zordur.

X-Accel-Buffering: no neden her zaman yardımcı olmaz?

Başlığı nginx ve uyumlu proxy'ler anlar. CDN, bulut geçidi veya farklı türde proxy onu görmezden gelir. Ayrıca X-Accel-Buffering gzip'i etkilemez — sıkıştırma ayrıca kapatılmalıdır. Ve uygulama ile nginx arasında standart dışı başlıkları silen bir katman varsa nginx'e ulaşmaz.

Akış yanıtı sıkıştırılabilir mi?

Teknik olarak evet: gzip eşzamanlı flush'ı destekler ve sunucu her chunk'ı anında iletilerek sıkıştırabilir. Sıkıştırma oranı düşer, çünkü sözlük dolmaya zaman bulamaz. Pratikte SSE ve LLM token'ları için sıkıştırma kapatılır: yüzde birkaç trafik tasarrufu gecikme riskini haklı çıkarmaz. Büyük JSON nesnelerinin akışları için flush'lı sıkıştırma ciddi kazanç sağlayabilir.

SSE ile long-polling arasında nasıl seçim yapılır?

İstemci tarayıcıysa, olaylar birkaç saniyede birden sık geliyorsa ve en azından ters proxy'yi kontrol ediyorsanız — SSE. Zincirde yanıt süresi sınırı olan kontrol edilemeyen düğümler varsa, olaylar seyrekse veya maksimum uyumluluk gerekiyorsa — long-polling. Olgun sistemler her iki varyantı uygular ve ilk bağlantının sonucuna göre otomatik geçiş yapar.

HTTP/3 tamponlama sorununu etkiliyor mu?

HTTP/3 QUIC üzerinde çalışır ve taşıma düzeyindeki sıra bloğunu ortadan kaldırır ama tamponlama yukarıda — proxy'nin mantığındadır. Girişte HTTP/3, çıkışta HTTP/1.1 konuşan proxy tamamen aynı şekilde tamponlar. Gerçekten değişen — mobil ağlardaki davranıştır: QUIC ağ değişimini ve kayıpları daha iyi atlatır, bu yüzden HTTP/3 üzerinden akışlar istemci tarafında daha seyrek kopar.

Tamponlayanın hedef sunucu değil de giden proxy olduğunu nasıl anlarım?

"Üç nokta" yöntemi: aynı istek doğrudan, proxy üzerinden ve referans akış uç noktasına proxy üzerinden. Ayrıca HTTPS'i CONNECT üzerinden deneyin — akış düzleşirse proxy şifresiz HTTP'yi ayrıştırıp tamponluyordu.

Hangi heartbeat aralığı seçilmeli?

Zincirdeki en kısa zaman aşımından, iki katı payla küçük. Tipik altyapı için — 15-25 saniye, mobil ağlar için 15'e yakın. Çok sık heartbeat — fazladan trafik ve binlerce bağlantıda yük, çok seyrek — kopmalar.

Akış saatlerce yaşamak zorundaysa ne yapmalı?

Bunu yapmamalı. Sunucunun her 5-15 dakikada bir kendini zorla kapatmasını ve devam için imleç tutmasını tasarlayın. Bu bellek birikmesine, sızıntılara ve görünmez zaman aşımlarına karşı korur, ayrıca dağıtımı kolaylaştırır: sunucuları saatlik bağlantıları düşünmeden yeniden başlatırsınız.

Proxy istemci bağlantısının kesilmesini algılamayı nasıl etkiler?

İstemci ve sunucu arasında artık iki bağlantı var. İstemci bağlantıyı kestiğinde proxy bunu hemen öğrenir, sunucuya ise bir sonraki yazma denemesinde veya kendi kurallarına göre bildirir. Sunucu kopmayı ancak yazma sırasında fark eder. Buradan, kopmayı erken saptamak ve pahalı işlemleri durdurmak için düzenli heartbeat yazma pratiği doğar.

Akışlar için mobil proxy'nin özel yapılandırması gerekli mi?

Kullanıcı tarafında proxy'nin kendisi genellikle yapılandırılmaz. Ama şunlar gerekir: şeffaf tünel için HTTPS'i tercih etmek; IP rotasyonunu akış yaşam döngüsüyle uyumlamak; heartbeat'i 15-20 saniyeden seyrek olmamak üzere tutmak; keep-alive ve bağlantı havuzu kullanmak; her havuzu üretime almadan önce şeffaflık açısından test etmek.

Sonuç: özet ve sonraki adımlar

Akış HTTP egzotik değil ve ayrı bir protokol de değil. Kapatmakta acele etmeyen sıradan bir yanıt. Bu yüzden ara düğümler karşısında bu kadar kırılgan: proxy özel bir şey görmez ve kısa yanıtlar için tasarlanmış kuralları uygular. Tamponlama veriyi geciktirir, zaman aşımları bağlantıyı koparır, sıkıştırma tamponlamayı maskeler — ve tüm bunlar zincirde sekiz farklı noktada.

Üç mekanizma — chunked, SSE ve long-polling — proxy'nin şeffaflığına farklı derecede bağlı olarak aynı sorunu çözer. Chunked, istemcide işlemeyi kendiniz yapmanız pahasına maksimum kontrol verir. SSE hazır olay modeli ve tarayıcıda yeniden bağlanma sağlar ama her düğüme dikkat ister. Long-polling her şeyden geçer ama sık isteklerin ek yüküyle öder. Seçim dört soruyla belirlenir: zinciri kontrol ediyor musunuz, istemci kim, verinin doğası nedir ve sıklığı nedir.

Bugün yapılacaklar:

  1. Altyapınız için sekiz tamponlama noktasının haritasını çıkarın ve hangilerini kontrol ettiğinizi işaretleyin.
  2. Akış rotalarının yanıtlarına mevcut proxy yapılandırmasından bağımsız olarak X-Accel-Buffering: no ve Cache-Control: no-cache, no-transform ekleyin.
  3. nginx'te proxy_http_version, proxy_buffering, gzip ve proxy_read_timeout'u veya proxy'nizdeki karşılıklarını kontrol edin. Akış rotalarını ayrı bloklara ayırın.
  4. En geç 25 saniyede bir heartbeat ve her 5-15 dakikada imleçli zorla akış kapatma uygulayın.
  5. Başkalarının akışlarını proxy üzerinden tüketiyorsanız — her adres havuzunda "üç nokta" protokolünü çalıştırın ve akış isteklerini HTTPS'e taşıyın.
  6. İlk bayt zamanını ve chunk'lar arası aralıkları izlemeye alın. Tamponlamayı kullanıcılardan önce öğrenmenin tek yolu bu.

Proxy akışın düşmanı değil. Doğru yapılandırılmış proxy akışa hata toleransı, yük dağıtımı ve backend koruması katar. Görev sadece ona şunu anlatmakta: bu yanıt özel, geldiği gibi iletilmeli. Artık bu açıklamayı onun dilinde yapmak için her şeyiniz var.