İstemci tarafında rate limit: token bucket, leaky bucket ve host bazlı limitler — uzman rehberi
Makale içeriği
- Giriş: i̇stemcinin neden kendi rate limit'ine ihtiyacı var
- Temeller: i̇stemci tarafında rate limit nedir ve sunucu neden yeterli değildir
- Derinlemesine i̇nceleme: algoritma aileleri ve matematikleri
- Yöntem 1: pratikte token bucket — tuzaklardan uzak uygulama
- Yöntem 2: leaky bucket ve gcra — düzgün akış gerektiğinde
- Yöntem 3: host bazlı limitler — kayıt defteri, hiyerarşi ve kompozisyon
- Yöntem 4: limiter ve ip rotasyonu — adres değişimini modele nasıl dahil ederiz
- İ̇stemci tarafı rate limit'te yaygın tasarım hataları
- Uygulama araçları ve kaynakları
- Vaka ve uygulama senaryoları
- Sss: zor sorulara yanıtlar
- Sonuç: bundan sonra ne yapmalı
Giriş: İstemcinin neden kendi rate limit'ine ihtiyacı var
Tek bir gişenin çalıştığı bir bankaya geldiğinizi ve arkanızda bin kişilik bir kuyruk olduğunu düşünün. İtebilirsiniz, bağırabilirsiniz ama gişenin kapasitesi bundan artmaz. Ya makul bir tempoyla gelirsiniz ya da ret cevabı alırsınız. Sunucu tarafı rate limit (istek sıklığı sınırlaması) — sizi bir noktada hizmet vermeyi kesen o gişe görevlisidir. İstemci tarafı rate limit ise, gişeye fiziksel olarak kaldırabileceğinden daha sık yaklaşmama yönündeki kişisel kararınızdır.
Bu makale tamamen algoritmalara ayrılmıştır. 429 kodunun nasıl işleneceği ve üstel backoff'un nasıl kurulacağı konusundaki içerikleri bilinçli olarak tekrarlamayacağız ve kaç thread çalıştırılacağını tartışmayacağız. Buradaki odak farklı: isteği göndermeden önce, şimdi gönderilip gönderilemeyeceğini ve gönderilemiyorsa ne kadar beklenmesi gerektiğini nasıl hesaplayacağız. İşte bu matematik, "arada sırada ret alan" bir istemciyi, aynı API ile yıllarca sorunsuz çalışan ve sahiplerini rahatsız etmeyen bir istemciden ayıran şeydir.
Bu yazıda neler öğreneceksiniz:
- dört algoritma ailesinin — fixed window, sliding window, token bucket ve leaky bucket — nasıl çalıştığını ve yalnızca isim olarak değil, davranış düzeyinde nasıl farklılaştıklarını;
- token bucket ve GCRA'nın (leaky bucket'ın bir varyantı) neden fiili standart haline geldiğini ve bunları bir akşamda yuvarlama hataları olmadan nasıl uygulayacağınızı;
- bir limit hiyerarşisinin nasıl kurulacağını: küresel bütçe, host başına bütçe, endpoint, yetkilendirme anahtarı ve giden IP adresi başına bütçe;
- IP rotasyonunu ne sunucu kotalarını ne de kendi telemetrinizi bozmadan limiter modeline nasıl entegre edeceğinizi;
- zararsız görünen ancak sonsuz beklemeye, dakika başındaki "patlamalara" ve bellek sızıntısına yol açan hangi tasarım hatalarının olduğunu.
Bir mühendis-mentor dilinde konuşacağız: formüllerle ama anlaşılmazlık olmadan, örneklerle ama lafı uzatmadan. Bir ayrıştırıcı, yabancı bir API için SDK, bir pazaryeri entegrasyonu veya yüzlerce host'a istek atan bir toplayıcı yazıyorsanız — bu rehberi yer imlerinize eklemeye değer.
Temeller: İstemci tarafında rate limit nedir ve sunucu neden yeterli değildir
Aynı soruna iki bakış
Sunucu tarafı rate limit, API sahibinin altyapısını korur: isteklerinizi sayar ve kota dolduğunda ret cevabı verir. İstemci tarafı rate limit ise farklı bir sorunu çözer — ret noktasına varmamak. Fark esastır. Sunucu iş işten sonra tepki verir: istek zaten gönderilmiştir, kanal meşguldür, log kirlenmiştir, istemcinin itibarı bir miktar zedelenmiştir. İstemci ise öngörülü davranır: bütçesini bilir (ya da tahmin eder) ve onu dikkatlice harcar.
Neden sadece sunucu reddine güvenip denemeyi tekrarlayamazsınız? Çünkü her reddedilen deneme, harcanmış bir bağlantı, harcanmış bir yetkilendirme token'ı, başkasının güvenlik günlüğünde bir satır ve genellikle uyarlanabilir koruma sistemlerinde konumunuzun kötüleşmesi demektir. Kendi rejimine uyan bir istemci, sunucu için iyi yetiştirilmiş bir ortak gibi görünür. "Boş yer bulana kadar deneyen" bir istemci ise sorun kaynağı gibi görünür. Bir sonraki politika revizyonunda kimin daha sert sınırlandırılacağını tahmin edin?
Temel terminoloji
- Rate (hız) — yerleşik istek sıklığı, örneğin "saniyede on istek". Bu, sunucunun sonsuza kadar kabul etmeye hazır olduğu şeydir.
- Burst (patlama) — yenilenmeyi beklemeden art arda kaç isteğin anında gönderilebileceği. Sunucular genellikle kısa patlamalara, ortalama hız ihlal edilmediği sürece izin verir.
- Ocak (window) — isteklerin sayıldığı zaman dilimi: saniye, dakika, saat, gün.
- Kota (quota) — bir penceredeki maksimum istek sayısı. Kotanın pencere uzunluğuna bölümü ortalama hızdır.
- Limit anahtarı (limit key) — sunucunun istekleri grupladığı özellik: IP adresi, token, hesap, "host artı endpoint" çifti. Aynı istemci neredeyse her zaman aynı anda birden fazla anahtar altına girer.
- Maliyet (cost) — isteğin ağırlığı. Bazı API'ler aramayı on birim, kayıt okumayı bir birim sayar.
Ana ilke: Limiter "ne kadar" değil, "ne zaman" sorusunu yanıtlar
Yaygın bir yanılgı, limiter'ı semafor ile karıştırmaktır. Semafor eşzamanlı işlemlerin sayısını sınırlar ve "şu anda kaç tanesi uçuşta" sorusunu yanıtlar. Limiter ise sıklığı sınırlar ve "şu anda bir işlem daha başlatılabilir mi, başlatılamıyorsa kaç milisaniye sonra başlatılabilir" sorusunu yanıtlar. Bu iki mekanizma birbirini tamamlar ama birbirinin yerini tutmaz. İstekler kısaysa tek bağlantıyla bile limiti aşabilirsiniz. İstekler yavaşsa yüz bağlantıyla bile limiti tutabilirsiniz.
İyi bir istemci limiter'ın üç özelliği
- Öngörülebilirlik. Aynı girdi için aynı yanıtı verir. "Bazen biraz daha fazla geçirir" yoktur.
- Ucuzluk. Karar sabit zamanda ve anahtar başına sabit bellekle alınır. Binlerce host'unuz varsa limiter tüm isteklerin geçmişini tutamaz.
- Adillik. Birden fazla görev izin bekliyorsa, "kim daha şanslı uyandıysa" değil sıra sırasına izin alırlar.
Bu üç kriteri aklınızda tutun: sonraki bölümde algoritmaları bunlarla karşılaştıracağız.
Derinlemesine İnceleme: Algoritma aileleri ve matematikleri
Fixed window — dürüst ama sinsi bir sayaç
En basit varyant: zamanı sabit uzunlukta pencerelere böleriz, her pencerede bir sayaç tutarız, kota dolduğunda bir sonraki pencerenin başlangıcını bekleriz. Bellek — anahtar başına bir sayı ve bir zaman damgası. Görünüşe göre ideal.
Sorunun adı pencere sınırı etkisi. Kota dakikada yüz istekse, istemci bir pencerenin son saniyesinde yüz istek ve bir sonrakinin ilk saniyesinde yüz istek daha gönderebilir. İstemci açısından her şey yasaldır: her pencerede tam olarak yüz. Sunucu açısından iki saniyede iki yüz istek gelmiştir — herhangi bir makul limit yorumunun iki katı. Sunucu kayan pencere sayıyorsa (modern olanların çoğu öyle yapar), kendinizi masum sayarak ret alırsınız.
İkinci dert — patlama senkronizasyonu. Tüm işçileriniz aynı anda "uyanır" çünkü sayaç tam o zaman sıfırlanır. Bu, ağ üzerinde, proxy'de ve hedef sunucuda yük zirveleri yaratır.
Sliding window log — doğru ama pahalı
Son aralıktaki tüm isteklerin zaman damgalarını saklarız. Göndermeden önce süresi geçenleri atar ve kalanları sayarız. Tamamen doğru muhasebe, pencere sınırı etkisi yok. Ama bellek kotaya doğrusal olarak büyür: saatte on bin istek kotasında her anahtar için on bin damga saklarsınız. Bir host için katlanılır, bin host için değil.
Sliding window counter — bir uzlaşma
İki sayaç tutarız: geçerli pencere ve önceki pencere. Yük tahmini — geçerli sayaç artı önceki sayacın kayan aralığa hâlâ düşen payıyla çarpımı. Geçerli dakikanın yüzde 20'si geçtiyse önceki sayacın yüzde 80'ini alırız. Bu bir yaklaşımdır ama sınırı mükemmel şekilde yumuşatır ve sadece iki değişken gerektirir. Birçok sunucu tarafı uygulama tam da bunu kullanır, bu yüzden bunu istemcide taklit etmek "sunucu gibi düşünmenin" iyi bir yoludur.
Token bucket — jetonlu kova
Kapasitesi B jeton olan bir kova düşünün. Her saniye içine r jeton damlar, fazlası kenardan taşar. Bir istek göndermek için c jeton almanız gerekir. Yoksa — dolana kadar beklersiniz.
İki parametre iki bağımsız özellik verir. r parametresi — yerleşik hız: ne kadar beklerseniz bekleyin, uzun vadeli tempo r istek/saniyeyi geçmez. B parametresi — maksimum patlama: boşta kaldıktan sonra anında B istek gönderebilirsiniz. Bu, gerçek sunucu politikalarının ifade ediliş biçimine mükemmel uyar: "dakikada yüzden fazla değil, seferde en fazla on".
Uygulamadaki kilit nokta — tembel yenileme. Her saniye jeton ekleyen bir arka plan thread'ine gerek yoktur. Her çağrıda son çağrıdan bu yana geçen zamanı hesaplamak ve karşılık gelen miktarı eklemek yeterlidir: tokens = min(B, tokens + elapsed * r). Anahtar başına iki sayı, sabit zamanda hesaplama. Ucuzluk kriterine tamamen uyar.
Leaky bucket — delikli kova
Burada metafor terstir: istekler kovaya dökülür, dipteki delikten sabit hızda r akıp gider. Kova taşarsa — yeni istek reddedilir veya bekler. Çıkış her zaman düzgündür: hiç patlama yok, kesinlikle her 1/r saniyede bir istek. Sunucunun patlamalara toleransı yoksa veya trafik profilinin maksimum düzgün olmasını istiyorsanız, bu sizin seçiminizdir.
Leaky bucket'ın iki yorumu vardır. Birincisi — kuyruk olarak: istekler gerçekten bir tampona yığılır ve ayrı bir süreç bunları zamanlayıcıyla serbest bırakır. İkincisi — sayaç olarak: sadece hayali kovanın taşıp taşmayacağını kontrol ederiz, ya geçiririz ya geçirmeyiz. Telekomünikasyondaki ikinci yorum GCRA (Generic Cell Rate Algorithm) olarak adlandırılır ve matematiksel olarak başka bir parametreleştirmeyle token bucket'a eşdeğerdir. Bu önemli bir gözlemdir: token bucket'ı zaten uyguladıysanız, leaky bucket'ı da yapmayı biliyorsunuz.
GCRA: sayaç yerine tek bir zaman damgası
GCRA tek bir değer saklar — TAT (theoretical arrival time, teorik varış zamanı): bir sonraki "ideal" isteğin bundan önce gelmemesi gereken an. Parametreler: yayılım aralığı T = 1/r ve tolerans τ = (B − 1) * T'ye eşittir. Algoritma:
- Şu anki zaman olarak now'u al.
- TAT, now'dan küçükse, TAT'yi now'a eşitle (kova çoktan boşalmıştır).
- TAT − τ, now'dan büyükse — istek çok erken geldi; bekleme süresi TAT − τ − now'a eşittir.
- Aksi halde isteği onayla ve TAT'yi T kadar ileri kaydır.
Anahtar başına tek sayı, yavaş yavaş birbirinden sapan kayan noktalı sayaçlar yok. Bu nedenle GCRA dağıtık limiter'lar için favori algoritmadır: durumu tek bir anahtar-değer alanında saklamak ve atomik olarak güncellemek kolaydır.
Karşılaştırma tablosu — kelimelerle
- Fixed window: bellek minimum, doğruluk düşük, sınırlarda patlamalar, sadece kaba bir güvence olarak uygun.
- Sliding log: doğruluk mutlak, bellek kotaya doğrusal, küçük kotalı az sayıda anahtar için uygun.
- Sliding counter: bellek iki değişken, doğruluk yaklaşık, sunucu mantığını iyi taklit eder.
- Token bucket: bellek iki değişken, patlamanın açık kontrolü, istemci SDK'ları için standart.
- Leaky bucket / GCRA: bellek tek değişken, mükemmel düzgün çıkış, dağıtık sistemler için standart.
Saatler hakkında: monotonluk ve kayma
Tüm algoritmalar "şu anki zaman"a dayanır. Sistem zamanını değil, monotonik saati (monotonic clock) kullanın. Sistem zamanı senkronizasyon sırasında geriye atlayabilir ve limiter'ınız negatif saniyelerin geçtiğine karar verir, yenilemeyi sıfırlar veya tam tersine devasa bir patlama verir. Monotonik saatlerin geriye gitmeyeceği garantilidir. Tek istisna — ortak bir depodaki dağıtık limiter'dır; orada zaman, makineler arası saat farkına bağlı kalmamak için istemcilerde değil depo tarafında alınır.
Yöntem 1: Pratikte token bucket — tuzaklardan uzak uygulama
Adım 1. Parametre seçimi
Sunucu politikasını bir (r, B) çiftine dönüştürün. Belgeler "dakikada yüz istek" diyorsa, temel hız r = 100/60 jeton/saniyedir. Kapasite B — ayrı bir karardır. Yabancı bir API için güvenli seçim — B, pencere kotasının yüzde beş ile yüzde onu arasında, yani yüz kotasındaki beş ila on jeton. Bu, küçük bir yığını hızlıca işlemeye izin verir ama sunucunun kayan pencereyle ihlal olarak algılayacağı zirveleri yaratmaz.
Daha da iyisi — pay bırakarak hesap yapın: beyan edilen hızın yüzde 80–90'ını kullanın. Sunucu sayaçları, ağ gecikmeleri ve her iki taraftaki yuvarlamalar kaçınılmaz olarak hata payı yaratır ve pay bunu yutar.
Adım 2. Durum yapısı
Her anahtar için saklayın: tokens (kayan nokta, mevcut jeton sayısı), last (monotonik son yeniden hesap damgası), rate, capacity. Durumu mutex ile veya asenkron kodda jetonlara ilişkin tüm isteklerin geçtiği tek bir hakem görev ile koruyun.
Adım 3. acquire(cost) algoritması
- Kilidi alırız.
- now = monotonic(); elapsed = now − last; last = now.
- tokens = min(capacity, tokens + elapsed * rate).
- tokens ≥ cost ise: tokens −= cost; kilidi bırak; "sıfır bekleme" döndür.
- Aksi halde: wait = (cost − tokens) / rate; jetonları eksiye düşür: tokens −= cost; kilidi bırak; wait'i döndür.
- Çağıran taraf wait saniye kadar uyur ve isteği gönderir.
Beşinci maddeye dikkat edin. Eksiye düşürmek bir rezervasyondur. Adilliği garanti eder: bir sonraki çağrı negatif bakiyeyi görür ve daha da uzun bekleme alır, yani öncekilerin arkasına geçer. Rezervasyon olmadan klasik hata ortaya çıkar: on görev aynı anda sıfır jeton görür, hepsi aynı beklemeyi hesaplar, hepsi aynı anda uyanır ve limiter'ın engellemesi gereken bir patlama yaratır.
Adım 4. Rezervasyon derinliğini sınırlama
Eksiye rezervasyon sonsuza dek gidebilir: görevler jetonların yenilenmesinden daha hızlı gelirse bekleyenlerin kuyruğu büyür ve sonuncunun bekleme süresi saatlere yaklaşır. Maksimum gecikmeyi (max_delay) girin. Hesaplanan wait eşiği aşarsa rezervasyon yapmayın, "limiter aşırı yüklü" hatası döndürün. Planlayıcının ne yapacağına karar vermesine izin verin: erteleme, öncelik düşürme, başka host'a geçme. İstemci limiter'ının pasif bir frenden yük yönetimi aracına dönüştüğü nokta tam olarak budur.
Adım 5. Ağırlıklı maliyet
İsteklerin farklı cost'a sahip olmasına izin verin. Arama endpoint'leri, toplu seçimler, yazma işlemleri genellikle sunucu için "daha pahalı"dır ve birçok API bunu politikalarında yansıtır. Belgeler susuyorsa, yanıt süresi gözlemlerinize göre ağırlık atayın: sunucunun daha uzun işlediği istek pahalı sayılmaya uygundur. Bekleme formülü bundan değişmez — cost sadece bir çarpan olarak girer.
Adım 6. Isınma ve soğuk başlangıç
Başlangıç tokens değeri ayrı bir karardır. Başlangıçta tam kova, süreç başlar başlamaz B istekte anlık bir patlama demektir. Dağıtım sonrası onlarca süreç aynı anda başlıyorsa bu istenmeyebilir. Sıfırdan veya kapasitenin yarısından başlamak daha güvenlidir. Sunucunun kotayı başlangıcınıza bağlı olmayan bir pencereyle saydığı biliniyorsa, sıfır başlangıç daha da dürüsttür.
Token bucket kontrol listesi
- Monotonik saatler kullanılıyor.
- Yenileme tembel, zaman farkına göre, arka plan zamanlayıcıları olmadan.
- Adil kuyruk için eksiye rezervasyon.
- max_delay var ve aşırı yükte açık red var.
- Hız, sunucuya göre pay bırakılarak ayarlanmış.
- Kapasite, pencere kotasının makul bir payına sınırlı.
- Ağırlıklı istekler için cost destekleniyor.
- Başlangıç durumu dağıtım sırasında patlama yaratmıyor.
Yöntem 2: Leaky bucket ve GCRA — düzgün akış gerektiğinde
Leaky bucket'ı ne zaman tercih etmeli
Token bucket patlamalara izin verir. Bu kullanışlıdır ama patlamanın kendi başına zararlı olduğu durumlar vardır: sunucu kısa zirvelere agresif tepki veriyor, proxy kanalının bant genişliği sınırlı, trafik deseninin sıradan, telaşsız bir istemci gibi görünmesini istiyorsunuz. Tüm bu durumlarda istekler arasında kesinlikle sabit bir aralıkla çıkış gerekir. Bu da leaky bucket'tır.
Kuyruk olarak uygulama
Klasik varyant: sabit kapasiteli bir tampon ve her T saniyede bir öğeyi çıkarıp gönderen tek bir tüketici. Artısı — sadelik ve anlaşılırlık. Eksisi — ayrı bir thread veya görev gerekir ve tüketici durduğunda tampon "donar". Bu yaklaşım, isteklerin zaten tek tek alındığı açık bir konveyörünüz (görev kuyruğu) varsa uygundur.
GCRA olarak uygulama
Çoğu istemci senaryosu için sayaç yorumu daha uygundur. Algoritmayı yukarıda tanımladık; parametrelerin nasıl ayarlanacağını inceleyelim. Katı bir aralık gerekiyorsa τ = 0 koyun: o zaman tolerans sıfırdır ve istekler T'den sık geçmez. Küçük bir patlamaya izin vermek istiyorsanız, τ'yu artırın. Böylece tek bir uygulama hem katı leaky bucket'ı hem de token bucket'ı kapsar. GCRA tam bu nedenle bir sınırlama kütüphanesi için iyi bir "tek motor"dur.
Rezervasyonlu GCRA adım adım prosedürü
- Anahtar için TAT'yi oku; yoksa TAT = now say.
- new_TAT = max(TAT, now) + T * cost.
- allow_at = new_TAT − τ − T * cost; bu, böyle bir maliyetli isteğin beklemeden gönderilebileceği andır.
- allow_at ≤ now ise: new_TAT'yi yaz, "sıfır bekleme" döndür.
- Aksi halde: wait = allow_at − now; wait max_delay'den büyükse — yazmadan red döndür; değilse new_TAT'yi yaz ve wait'i döndür.
Dağıtık bir depoda birinci ile beşinci adımlar tek bir atomik işlemle — örneğin depo tarafındaki bir betikle — gerçekleştirilir. Böylece iki istemcinin aynı TAT'yi okuyup izni "çiftlememesi" garanti edilir.
Eşdeğerlik ve yük karakterine göre seçim
Şunu anlamak faydalıdır: (r, B) parametreli token bucket ile (T = 1/r, τ = (B − 1)/r) parametreli GCRA tam olarak aynı istek dizilerini geçirir. Fark yalnızca durumun temsilindedir. Bu nedenle "hangisi daha iyi" sorusu aslında şöyle ifade edilir: patlamaya ihtiyacınız var mı. Varsa — B'yi birden büyük yapın. Yoksa — B = 1 (τ = 0) yapın. Gerisi zevk ve saklama kolaylığıdır.
Leaky bucket / GCRA kontrol listesi
- Patlamaya ihtiyaç var mı yoksa kesinlikle düzgün akış mı gerekiyor — karar verildi.
- Durum — anahtar başına tek bir TAT değeri.
- Oku-kontrol et-yaz işlemi atomik.
- max_delay var ve açık red var.
- Dağıtık varyantta zaman depo tarafında alınıyor.
Yöntem 3: Host bazlı limitler — kayıt defteri, hiyerarşi ve kompozisyon
"Her şey için tek limiter" neden işe yaramaz
İstemciniz yalnızca tek bir API'ye gidiyorsa tek bir kova yeterlidir. Ama toplayıcılar, ayrıştırıcılar ve entegrasyon veriyolları onlarca ve yüzlerce host'a başvurur, her birinin kendi politikası vardır. Tek bir küresel limit ya hızlı host'ları eksik kullanır ya da yavaş olanları aşırı yükler. Bir limiter kayıt defterine ihtiyacınız vardır: "limit anahtarı — kova durumu" eşlemesi, anahtarın istek özelliklerinden kurulduğu yer.
Limit anahtarı: host'tan endpoint'e
Minimum anahtar — şema artı host artı port. Aynı sahibin iki alan adı sıklıkla kotayı paylaşır, alt alan adları ayrı sayılabilir; bunu belgelerden veya gözlemle öğrenmek gerekir. Daha ince anahtar — host artı yol kalıbı: örneğin arama endpoint'i ile ürün kartı endpoint'inin farklı kotaları vardır. Daha da incesi — host artı yetkilendirme token'ı, sunucu kotayı API anahtarına göre sayıyorsa ve birden fazlasına sahipseniz.
Pratik kural: anahtarı sunucunun saydığı aynı özelliklerden kurun. Sunucu IP'ye göre sayıyorsa, anahtara giden IP'niz girer. Token'a göre sayıyorsa — token. İkisiyle birlikte sayıyorsa — iki limiter'e ihtiyacınız vardır ve istek ikisini de geçmelidir.
Limit hiyerarşisi
İyi tasarlanmış bir sistem limiter'ları düzeylere göre kurar:
- Küresel — sürecin genel bütçesi. Kendi kaynaklarınızı korur: soketler, bellek, kanal bant genişliği.
- Giden IP başına — belirli bir adres üzerinden kaç istek gidiyor. Adres havuzu üzerinden çalışırken kilit düzey.
- Host başına — hedef sunucunun genel politikası.
- Endpoint başına — pahalı metotlar için ayrı kotalar.
- Kimlik bilgileri başına — token veya hesap başına kotalar.
İstek her düzeyde izin almak zorundadır. Bu da limiter'ların kompozisyonudur.
Karşılıklı kilitlenme olmadan kompozisyon
Naif yaklaşım — her limiter'ın acquire'ını sırayla çağırmak ve beklemeleri toplamaktır. Bu yanlıştır: birinci limiter jetonu zaten harcamıştır, ikinci on saniye bekletir ve birincinin jetonu adalet açısından "bayatlar". Daha kötüsü, iki görev limiter'ları farklı sırayla aldığında sonsuza kadar birbirini engelleyebilir.
Doğru prosedür:
- Her limiter için bekleme süresini harcamadan hesapla (peek işlemi).
- Beklemelerin maksimumunu al — bu toplam wait'tir.
- wait max_delay'i aşarsa — red.
- Aksi halde tüm limiter'larda harcama yap, her birine tek bir varış zamanı now + wait vererek her birinin kaynağı aynı ana rezerve etmesini sağla.
- wait saniye uyu ve gönder.
Limiter'ları her zaman aynı sabit sırada (örneğin küreselden en dağınık olana) dolaşın. Bu, eşzamanlı erişimde karşılıklı kilitlenmeyi önler.
Yapılandırma ve varsayılan değerler
Kayıt defteri daha önce görülmemiş bir host için limiter oluşturabilmelidir. Muhafazakâr bir varsayılan verin: düşük hız, minimum patlama. Bilinen host'lar için — açık yapılandırma. İyi bir uygulama politikayı bildirimsel biçimde saklamaktır: host veya kalıp, rate, burst, yol kalıplarına göre cost, "IP'ye göre say" ve "token'a göre say" işaretleri. Böylece sunucu politikası değiştiğinde kod değil tek bir dosya değişir.
Dışarı atma ve sızıntılar
Binlerce host'lu bir kayıt defteri — bellek sızıntısı adayıdır. Uzun süredir başvurulmayan host'lar dışarı atılmalıdır. Kova durumu uzun boşluktan sonra zaten "dolu" olacağından (veya TAT geçmişte kalacağından), dışarı atma bilgi kaybettirmez: bir sonraki başvuruda limiter aynı durumda yeniden oluşturulur. Boyut sınırlı bir LRU önbellek kullanın veya last'ı birkaç pencereden eski olan kayıtları periyodik olarak temizleyin.
Host bazlı limitler kontrol listesi
- Limit anahtarı sunucunun saydığı özellikleri yansıtır.
- Düzeyler var: küresel, IP, host, endpoint, kimlik bilgileri.
- Kompozisyon peek — maksimum — tek harcama yoluyla.
- Limiter'lar sabit sırada dolaşılır.
- Bilinmeyen host'lar için muhafazakâr varsayılanlar.
- Politikalar yapılandırmaya taşınmış.
- Kayıt defteri boyut sınırlı ve etkin olmayan anahtarları dışarı atıyor.
Yöntem 4: Limiter ve IP rotasyonu — adres değişimini modele nasıl dahil ederiz
Rotasyon naif limiter'ı neden bozar
Hedef sunucu kotayı IP'ye göre sayıyorsa, adres değişimi sunucu tarafındaki limit anahtarını değiştirir. Host başına tek sayaç tutan naif istemci, IP değişiminden sonra sunucu zaten "yeni" bir ziyaretçi gördüğü halde yavaşlamaya devam eder. Ters hata daha tehlikelidir: istemci IP değişiminde token veya hesaba göre sayılanlar dahil tüm limitleri sıfırlar ve IP ile hiç alakası olmayan bir kottan ret alır. Sonuç: rotasyon hiyerarşide yalnızca "giden IP" düzeyini etkilemeli, diğer düzeyler kendi hayatını yaşamalıdır.
Adres değişiminin iki modu
Proxeon altyapısında porttaki IP ya zamanlayıcıyla ya da link/API ile değişir (22.09.2026 verilerine göre). Bunlar limiter için temelde farklı iki senaryodur. Zamanlayıcılı değişimde istemci anı kontrol etmez: adres "dışarıdan" değişir ve IP bazlı limiter bunu öğrenmelidir — bir olay, mevcut adresin yoklanması veya aralık biliniyorsa bir zaman çizelgesiyle. Linkle değişimde ise istemci geçişi kendisi başlatır ve kendi durumuyla senkronize edebilir: uçuştaki isteklerin bitmesini bekleyebilir, anı sabitleyebilir, "host artı IP-epoch" için yeni bir anahtar açabilir.
Her mod ne kadar yaygın? 14.11.2026 verilerine göre, zamanlayıcıyla IP değişiminin payı %51,1'dir, geri kalanı linke/API'ye aittir. Yani her iki strateji yaklaşık olarak eşit sıklıkta görülür ve evrensel bir limiter her ikisini de desteklemelidir.
Anahtarın parçası olarak adres epoch'u
Anahtarda IP'nin kendisini saklamak yerine (önceden bilemeyebilirsiniz), epoch'u kullanın — her değişimde artan bir sayaç. "IP bazlı" düzeyin anahtarı "port artı epoch" çifti olur. Epoch değiştiğinde eski anahtar kullanılmaz olur ve daha sonra kayıt defteri tarafından dışarı atılır, yenisi başlangıç durumunda oluşturulur. Dikkat: başlangıç durumu yine muhafazakâr olmalıdır. Yeni adres sunucu için bir yabancıdır ve göreceği ilk şey sizin trafik deseninizdir.
Limiter penceresini rotasyon zamanlayıcısıyla uyumlama
14.11.2026 verilerine göre, zamanlayıcıyla IP değişimleri arasındaki medyan aralık 120 s'dir ve zamanlayıcı aralıklarının %78,1'i tam olarak bir dakikanın katıdır. Bu tasarım için çok elverişlidir. Host başına kotanız "IP başına dakikada N istek" ise ve adres iki dakika yaşıyorsa, bir adresin bütçesi tam olarak iki penceredir. IP bazlı limiter, hızı N/60 ve kapasitesi adresin ömrü boyunca 2N'yi aşmayacak şekilde hesaplanmış bir token bucket olarak çalışabilir. Kaçırılanı "kapatmamak" önemlidir: ilk dakikada az gönderdiyseniz, ikincisinde iki kat gönderemezsiniz çünkü sunucu epoch'unuza değil dakikalık pencereye göre sayar.
Geçiş sırasında duraklama
Adres değişimi anında olmaz. 14.11.2026 verilerine göre, değişimin kendisinin (komuttan yeni adrese kadar) ortalama süresi 4,56 s'dir ve değişimlerin %80,8'i 5 saniyeye sığar. Bu limiter için ne anlama gelir? Geçiş sırasında istekler ya eski adresten gider ya da hiç gitmez. Doğru strateji — geçişi kısa bir "tahliye" aralığı olarak ele almaktır: değişim komutundan önce limiter yeni izin vermeyi keser, uçuştaki isteklerin bitmesini bekler, değişimi yapar ve ardından yeni epoch'u açar. Her beş geçişten dördü beş saniye içinde tamamlandığından, yeni adresi bekleme zaman aşımını bu eşiğin biraz üzerinde planlamak ve aşılırsa istisna işlemeye geçmek makuldür.
Değişim komutunun frekansını kendiniz sınırlayın
Sıklıkla atlanan bir içgörü: IP değişim komutu da API'ye bir istektir ve o da sınırlanmalıdır. 14.11.2026 verilerine göre, linkle değişimlere ilişkin yinelenen kayıtların (aralık en fazla 2 s, aynı IP) oranı %1,2'dir. Bu, istemcinin linki arka arkaya iki kez tetiklediği durumların izleridir: işçiler arasındaki yarıştan, zaman aşımı nedeniyle tekrardan, tek bir karar noktasının olmadığından. Çözüm — değişim komutu için kapasitesi bir ve aralığı katı ayrı bir kova (τ = 0 ile saf leaky bucket), artı yinelenenleri ayıklama: değişim zaten başlatıldıysa, diğer işçiler yenisini başlatmak yerine onun sonucunu bekler. Hedef host'lar için uyguladığınız ilkenin aynısı, kendi altyapınıza uygulanmış hali.
Ölçek ve bütçe planlaması
Ölçeği hissetmek için: 14.11.2026 verilerine göre, bir günde tüm Proxeon ağında 2.196.242 IP değişimi yapıldı, bunlara 7.924 proxy portu katıldı ve bir modem başına bir günde benzersiz IP'lerin medyanı 95'tir. Bir limiter tasarımcısı için bu, tek bir portun bir günde düzinelerce adres epoch'undan geçtiği anlamına gelir ve "IP başına" durumun hafif ve hızlı dışarı atılabilir olması gerekir: tüm epoch'ların geçmişini tutmanın hiçbir anlamı yoktur, ancak yeni bir epoch oluşturmanın sabit maliyetini garanti etmek zorunludur.
Protokoller ve port adresleme
Yapılandırmayı kolaylaştıran bir ayrıntı: Proxeon'da SOCKS5 portu HTTP portu artı bire eşittir (22.09.2026 verilerine göre). Aynı kanal için iki protokolü de kullanıyorsanız, IP bazlı limiter bunları iki değil tek anahtar olarak saymalıdır: adresleri ortaktır, dolayısıyla bütçeleri de ortaktır. Kayıt defterine normalizasyonu yazın: anahtar HTTP portuna göre kurulur ve SOCKS5 portu bundan bir çıkarılarak ona getirilir.
Dağıtık IP bazlı limiter
Aynı porttan birden fazla süreç veya makine gidiyorsa, kova ortak olmalıdır. Atomik işlemlere sahip bir depo kullanın, "port artı epoch artı host" anahtarı altında TAT (GCRA) saklayın, depo tarafındaki betikle güncelleyin ve zamanı da oradan alın. Epoch'u da merkezi olarak saklayın ve rotasyon komutuyla birlikte atomik olarak değiştirin — böylece tüm süreçler tutarlı biçimde yeni anahtara geçer.
Rotasyon sırasında limiter kontrol listesi
- Rotasyon yalnızca "IP başına" düzeyi etkiler, diğer düzeyler sıfırlanmaz.
- Her iki mod desteklenir: zamanlayıcı ve link/API ile değişim.
- IP düzeyi anahtarı adres epoch'unu içerir.
- Yeni epoch muhafazakâr durumda başlar.
- IP başına hız, epoch uzunluğuna göre değil sunucu penceresine göre uyumlanmıştır.
- Geçiş sırasında izin verilmesi askıya alınır.
- Rotasyon komutu kendisi sınırlanır ve yinelenenler ayıklanır.
- Aynı kanalın HTTP ve SOCKS5 portları tek anahtara normalleştirilir.
- Çok süreçli senaryolar için durum ortak depoya taşınmıştır.
İstemci tarafı rate limit'te yaygın tasarım hataları
Hata 1. Limiter yerine sleep
"İstekler arasına yüz milisaniye duraklama koyalım" — en sık başvurulan ve en kırılgan çözüm. İsteğin kendi süresini hesaba katmaz, birkaç işçi varken çalışmaz, izin verilen yerlerde patlamaya izin vermez ve yasak olan yerlerde patlamayı önlemez. Duraklama bir limiter değil, onun taklididir.
Hata 2. Sunucu kayan sayarken pencereye göre saymak
Pencere sınırı etkisi yukarıda anlatıldı. Sunucunun nasıl saydığından emin değilseniz, en kötüyü — kayan pencereyi — varsayın ve mütevazı kapasiteli token bucket kullanın.
Hata 3. Rezervasyonsuz yarış
Birkaç görev aynı anda aynı beklemeyi hesaplar, uyur ve birlikte uyanır. Sonuç — limiter'ın önlemesi gereken patlamanın tam kendisidir. Kilit altında rezervasyon (eksiye düşürme veya TAT kaydırma) ile tedavi edilir.
Hata 4. Sonsuz bekleme kuyruğu
max_delay olmadan kuyruk sınırsız büyür ve görevler bellek ve bağlantıları tutarak dakikalar ve saatler bekler. Limiter ret verebilmelidir.
Hata 5. Sistem saati
Senkronizasyon sırasında tek bir zaman atlaması — ve kova ya taşar ya da "donar". İstemcide yalnızca monotonik saatler; dağıtık varyantta yalnızca depo zamanı.
Hata 6. IP değişiminde tüm limitleri sıfırlamak
Token ve hesap kotaları adresten bağımsızdır. Onları sıfırlayarak size hiç dokunmayan bir politikayı hemen ihlal edersiniz.
Hata 7. Başlangıçta tam kova
Dağıtımdan sonra onlarca süreç tam kovalarla başlar ve aynı anda patlama yaratır. Boş kovayla başlayın veya başlangıca rastgele gecikme ekleyin.
Hata 8. Dışarı atmasız kayıt defteri
Her yeni host — sonsuza kadar yeni bir kayıt. Haftalar içinde süreç, bir daha asla ihtiyaç duyulmayacak host'lar için limiter'ları bellekte tutar.
Hata 9. İstek maliyetini yok saymak
Sunucu aramayı on birim, siz bir birim sayıyorsanız, limiter'ınız gerekenden on kat fazla geçirir ve ret karşısında içtenlikle şaşırır.
Hata 10. Sınırsız rotasyon komutu
Zaman aşımı nedeniyle veya birkaç işçiden adres değişim komutunun tekrarlanması, yinelenmelere ve gereksiz geçişlere yol açar. Komut da bir kaynaktır; ona bir kova verin.
Uygulama araçları ve kaynakları
Ekosisteme göre hazır kütüphaneler
- Go: golang.org/x/time/rate paketi — Allow, Reserve ve Wait metotlarıyla token bucket'ın referans uygulaması. Reserve metodu bekleme süresi ve iptal imkânı olan bir nesne döndürür — kompozisyon için tam da ihtiyacınız olan şey.
- Python: limits kütüphanesi farklı backend'lerle fixed window, sliding window ve GCRA sunar; aiolimiter asyncio için leaky bucket uygular; pyrate-limiter aynı anda birkaç pencereyi destekler.
- Java/Kotlin: Bucket4j — dağıtık depoları destekleyen olgun bir token bucket; Resilience4j RateLimiter — sabit yenileme döngüleriyle bir varyant.
- JavaScript/TypeScript: bottleneck anahtar gruplarına göre sınırlama ve ortak depo üzerinden kümeleme yapabilir; p-throttle — basit durumlar için minimal bir varyant.
- Rust: governor — asenkron koda uygun anahtarlı ve anahtarsız GCRA uygulaması.
- .NET: yerleşik System.Threading.RateLimiting ad alanı token bucket, sliding window ve anahtar başına partition'lı limiter'lar sunar.
Dağıtık durum için depolar
Sunucu tarafı betikleri destekleyen Redis ve uyumlu depolar, ortak GCRA için standarttır: tek atomik işlem, zaman depo komutuyla alınır, TTL'li anahtarlar otomatik olarak dışarı atılır. Tek bir uygulama kümesi içindeki senaryolar için atomik işlemli dağıtık önbellekler gibi yerleşik mekanizmalar da işe yarar.
Gözlemlenebilirlik araçları
Metriksiz limiter bir kara kutudur. Şunları dışa aktarın: beklemesiz verilen izin sayısı, bekleme süresi dağılımı, max_delay nedeniyle reddedilme sayısı, anahtarlara göre kovaların mevcut doluluk oranı, adres epoch'larının değişim sıklığı. Host bazlı bekleme histogramı, politikanın nerede çok katı, nerede sınıra dayandığınızı anında gösterir.
Adres altyapısı
Rotasyonlu senaryolar için iki değişim modu — zamanlayıcı ve link/API — sunan ve öngörülebilir port adreslemesi olan bir sağlayıcı gerekir. Proxeon'da her iki mod da mevcuttur ve SOCKS5 portu HTTP portundan tam olarak bir fazladır (22.09.2026 verilerine göre), bu da limiter kayıt defterindeki anahtarların normalleştirilmesini kolaylaştırır.
Ne okumalı
- Telekomünikasyon standartlarındaki GCRA açıklaması — sayaç olarak leaky bucket için birincil kaynak.
- x/time/rate paketi belgeleri — Reserve ve Wait semantiğinin örnek formülasyonu.
- Büyük kamu API'lerinin belgelerindeki limit bölümleri — orada her sayım modeline rastlanır ve politikayı kova parametrelerine çevirmeyi öğrenmenin en iyi yolu budur.
Vaka ve uygulama senaryoları
Senaryo 1. Yüzlerce host için fiyat toplayıcı
Görev: birden fazla pazaryerindeki ürün kartlarını düzenli olarak dolaşmak, her birinin kendi politikası var. Çözüm: "host artı yol kalıbı" anahtarlı limiter kayıt defteri, yeni pazaryerleri için muhafazakâr varsayılan, bilinenler için açık politikalar. Soket sayısına göre küresel limitle kompozisyon. Bu tür sistemlerin ulaştığı sonuç: hızlı olanlarda bekleme olmadan, yavaş olanlarda aşırı yüklenme olmadan tüm host'ların dengeli yüklenmesi; pazaryerinin politikası değiştiğinde yapılandırmadaki tek satırın değişmesi. Ana ders — tek küresel limitten hiyerarşiye geçiş, "boşuna" gönderilen isteklerin oranını keskin şekilde azaltır.
Senaryo 2. Token ve IP kotası olan iş ortağı API'si için SDK
Görev: birden fazla token ve birden fazla giden adrese sahip müşteriler için kütüphane. Çözüm: iki düzeyli limiter — token başına ve adres başına — peek ve tek varış zamanıyla kompozisyon. Planlayıcı en kısa beklemeli "token artı adres" çiftini seçer. Ders — limiter bir yönlendirme aracına dönüşür: "bekle" demek yerine "beklememek için nereye göndermeli" diye işaret eder.
Senaryo 3. Zamanlayıcılı rotasyonlu mobil adreslerde ayrıştırıcı
Görev: port havuzu üzerinden açık sayfaların dolaşılması, adresler zamanlayıcıyla değişir. Çözüm: "port artı epoch" anahtarlı IP bazlı limiter, hız hedef host'un dakikalık penceresiyle uyumlu. 14.11.2026 verilerine göre medyan zamanlayıcı aralığı 120 s ve aralıkların %78,1'i dakikanın katı olduğundan, epoch bütçesi tam sayıda dakikalık pencere olarak hesaplanır. Geçiş sırasında — değişimlerin %80,8'i 5 saniyeye sığıyor (14.11.2026 verilerine göre) — izin verilmesi bu eşiğin biraz üzerinde bir zaman aşımıyla duraklatılır. Ders — limiter penceresini rotasyon ritmiyle uyumlamak, yeni epoch'un başlangıcındaki "yetişmeye çalışan" patlamalardan kurtarır.
Senaryo 4. Linkle rotasyonlu ve yinelenen komutlu işçiler
Görev: birkaç işçi aynı portu paylaşır ve her biri gerektiğinde adres değişimi başlatır. Belirti — günlüklerde tekrarlanan komutların izleri. Çözüm: leaky bucket'lı (τ = 0) tek rotasyon noktası ve yinelenenleri ayıklama: değişim zaten sürüyorsa diğerleri onun bitmesini bekler. 14.11.2026 verilerine göre, ağ genelinde linkle değişimlere ilişkin yinelenen kayıtların oranı %1,2'dir; bu tam olarak tek bir karar noktasının ortadan kaldırdığı durumlardır. Ders — yalnızca yabancı API'lere giden istekleri değil, kendi altyapınıza giden komutları da sınırlamanız gerekir.
Senaryo 5. Tüm düzeyler için GCRA'lı tek motor
Görev: tarihsel olarak fixed window, sleep duraklamaları ve elle yazılmış sayaçların yan yana yaşadığı kod tabanını basitleştirmek. Çözüm: (T, τ) parametreli tek bir GCRA uygulaması, hiyerarşinin tüm düzeylerinde uygulanır, dağıtık anahtarlar için durum ortak depoda, yerel olanlar için bellekte saklanır. Ders — tek bir formül çözüm hayvanat bahçesinin yerini alır ve sistem davranışını öngörülebilir kılar.
SSS: Zor sorulara yanıtlar
Token bucket ve leaky bucket eşdeğerseler, temelde nasıl farklıdır?
Matematiksel nesneler olarak eşdeğerdirler: parametreler doğru eşleştirildiğinde aynı istek dizilerini geçirirler. Fark — sezgide ve doğrudan kontrol ettiğiniz parametrede. Token bucket "hız ve patlama" terimleriyle düşünür, leaky bucket — "aralık ve tolerans" terimleriyle. "Dakikada N, seferde en fazla M" biçimindeki politikalar için birincisi daha uygundur; "tam olarak her T'de bir istek" için ikincisi. GCRA iki sezgiyi tek durumda birleştirir.
Sunucu izin verilen patlamayı yayınlamıyorsa kova kapasitesi nasıl seçilir?
Pencere kotasının küçük bir payıyla — yüzde beş ile on civarı — başlayın ve gözleyin. Ret yoksa ve bekleme süreleri uzunsa, dikkatle artırın. Kayan pencere kullanan sunucunun kısa alt pencerede kotayı aşan patlamalara tolerans göstermediğini unutmayın, dolayısıyla kapasite asla tam kotaya yaklaşmamalıdır.
Yalnızca bir thread'im varsa limiter gerekir mi?
Evet. Kısa istekli tek bir thread kotayı kolayca aşar: yanıt yirmi milisaniyede geliyorsa, düşünmeden saniyede elli istek gönderirsiniz. Limiter thread sayısından bağımsız olarak gereklidir; semaforun çözdüğünden farklı bir sorunu çözer.
Sunucu farklı sayarken farklı maliyetli istekler nasıl sınırlanır?
cost'u acquire'a geçirin. Jetonlar oransal olarak harcanır, bekleme aynı formülle hesaplanır. Maliyet bilinmiyorsa, yanıt süresine veya yanıt boyutuna göre tahmin edin ve gözlemlerle netleştirin. Az tahmin etmektense fazla tahmin etmek daha iyidir.
Bir istek beş limiter'ı geçmeli ve her biri farklı bekleme veriyorsa ne yapmalı?
Önce hepsinden harcamadan bekleme sorusunu sorun, maksimumu alın, sonra hepsinde aynı varış anı için harcama yapın. Limiter'ları her zaman aynı sırada dolaşın. Maksimum eşiği aşarsa — harcamasız red, aksi halde kaynaklar "boşuna" rezerve edilir.
Kesin anını bilmiyorsam limiter zamanlayıcıyla IP değişimine nasıl tepki vermeli?
Olayı veya mevcut adresi yoklamayı kullanın, aralık biliniyorsa paylı bir zaman çizelgesi kullanın. Proxeon'da zamanlayıcıyla ve link/API ile değişim — her iki mod da standarttır (22.09.2026 verilerine göre) ve kesin senkronizasyon gerekiyorsa link modu tercih edilir: o zaman değişim anını siz belirlersiniz ve kayıt defterinizde yeni epoch'u tam da geçiş onaylandığında açarsınız.
Adres değişiminden sonra neden tüm limitleri sıfırlayamazsınız?
Çünkü sunucu kotayı aynı anda birden fazla özelliğe göre sayabilir. Adres değişti — IP kotası yeniden başlar, ama token, hesap veya oturum kotası saymaya devam eder. Her şeyi sıfırlayarak adresten bağımsız politikaları ihlal edersiniz. Rotasyon hiyerarşide yalnızca "IP başına" düzeyi etkilemelidir.
Dağıtık limiter için hangisi daha iyi — token bucket mı GCRA mı?
GCRA. Tek bir durum değeri vardır, atomik güncellemesi ve TTL ile saklanması daha kolaydır. Token bucket iki değer gerektirir ve yenileme mantığı biraz daha karmaşıktır, bu da atomik betiği zorlaştırır. Anlamsal olarak ikisi de aynı sonucu verir.
Limiter'ın doğru çalıştığını canlıya çıkmadan önce nasıl doğrularım?
Sahte saatli bir test yazın: istekleri belirli anlarda verin ve kararları referans diziyle karşılaştırın. Sınır durumlarını test edin: sıfır zaman, uzun boşluk, birçok isteğin aynı anda gelişi, kapasiteden büyük maliyet (sonsuz bekleme değil açık ret olmalı). Kompozisyonu ayrıca test edin: farklı hızlı iki limiter ve hiçbirinin kendi kotasından fazlasını geçirmediğinin doğrulanması.
Sonuç: Bundan sonra ne yapmalı
İstemci tarafı rate limit bir fren değil, bir yönetim sistemidir. Doğru kurulmuş bir limiter üç şey yapar: ret noktasına vardırmaz, mevcut bütçeyi dengeli kullanır ve planlayıcıya bir sonraki isteği nereye ne zaman göndereceğini işaret eder. Temelde — token bucket ya da GCRA olsun, tek bir formül, ama etrafını disiplinle sarmak gerekir: monotonik saatler, kilit altında rezervasyon, maksimum gecikme, anahtar hiyerarşisi ve dışarı atma.
Kısa özet:
- Fixed window basittir ama sınırlarda sinsidir; token bucket veya GCRA'yı tercih edin.
- Token bucket hız ile patlamanın ayrı kontrolünü verir; GCRA — aynısını tek bir durum sayısında.
- Limit anahtarı sunucunun saydığı özellikleri yansıtır; limiter'lar hiyerarşi kurar ve peek — maksimum — tek harcama yoluyla kompoze edilir.
- Adres rotasyonu yalnızca "IP başına" düzeyi değiştirir; rotasyon komutu kendi kovasını hak eder.
- Bekleme ve ret metrikleri, politikanızın sunucuyla ne kadar örtüştüğünü anlamanın tek dürüst yoludur.
Sizin için sonraki adımlar: tek bir motor seçin (biz GCRA'yı öneriyoruz), bilinen host'ların politikalarını yapılandırmada tanımlayın, muhafazakâr bir varsayılan ekleyin, metrikleri açın ve sahte saatle testleri çalıştırın. Bir adres havuzu üzerinden çalışıyorsanız, anahtara epoch'u ve değişim komutuna ayrı bir kova ekleyin. Bundan sonra istemciniz herhangi bir sunucu için en kibar konuk gibi görünecek — kendisine asla ret verilmeyen biri.