Technical Tutorials

Hız sınırlama, modern yazılım mimarisinde hizmetlerinizi kötüye kullanımdan koruyan, trafik artışlarını yöneten ve istemciler arasında adil kullanım sağlayan kritik bir bileşendir. Birçok geliştirici basit sayaç tabanlı çözümlere yönelse de, Token Bucket Algoritması özellikle Go uygulamalarında bulunan yüksek eşzamanlı ortamlarda üstün esneklik ve performans sunar.

Bu kılavuzda, Go'da sağlam ve iş parçacığı güvenli (thread-safe) bir hız sınırlayıcı uygulayacağız. Token bucket'ın mekaniklerini keşfedecek, zaman işleme ve bellek güvenliği konusundaki yaygın tuzakları ele alacak ve üretim ortamına hazır bir kod örneği sunacağız.

Neden Token Bucket Algoritmasını Seçmeliyiz?

Koda dalmadan önce, token bucket'ın sabit pencere sayaçları veya kayan log pencereleri yerine neden sıklıkla tercih edildiğini anlamak önemlidir. Temel fikir basittir: Bir "kova" tokenları barındırır. Tokenlar sabit bir hızla eklenir. Her istek bir token tüketir. Eğer mevcut token yoksa, istek reddedilir.

Sabit pencere sayaçlarının aksine, iki pencerenin sınırında izin verilen trafiğin iki katının geçmesine neden olan "sınır sorunu"ndan muzdarip değildir; token bucket pürüzsüz bir hız sınırlama sağlar. Ayrıca "burst" (ani artış) yapmaya da olanak tanır. Kova dolu başlarsa, bir istemci bir dizi istek yapabilir, ancak hemen ardından dengeli duruma (steady-state) uygun hızda yavaşlaması gerekir. Bu davranış çoğu API tüketici için sezgiseldir ve HTTP semantiğiyle iyi uyum sağlar.

Çekirdek Yapının Uygulanması

Go'da eşzamanlılık, gorutinler ve kanallar aracılığıyla yönetilir. Ancak, bir hız sınırlayıcı için genellikle bir mutex ile korunmuş paylaşılan bir duruma ihtiyacımız vardır. Uygulamanın hem verimli hem de race condition (yarış durumu)lara karşı güvenli olduğundan emin olmalıyız.

İşte durumumuzu korumak için sync.Mutex kullanan temel bir yapı:

package ratelimit

import (
	"sync"
	"time"
)

// RateLimiter token bucket algoritmasını uygular.
type RateLimiter struct {
	tokens     float64
	maxTokens  float64
	refillRate float64 // saniye başına token
	lastRefill time.Time
	mu         sync.Mutex
}

// NewRateLimiter, belirtilen burst boyutu ve yenileme hızıyla yeni bir örnek oluşturur.
func NewRateLimiter(burstSize int, refillRate float64) *RateLimiter {
	return &RateLimiter{
		tokens:     float64(burstSize),
		maxTokens:  float64(burstSize),
		refillRate: refillRate,
		lastRefill: time.Now(),
	}
}

Allow Yöntemi: Zaman ve Eşzamanlılığın Yönetimi

Hız sınırlayıcının kalbi, bir isteğin devam edip edemeyeceğini belirleyen Allow yöntemidir. Bu yöntem, son kontrolden bu yana ne kadar token yenilendiğini hesaplamak ve bir token tüketmeyi denemek üzere iki ayrı işlemi ele almalıdır. Her iki işlem de atomik olarak gerçekleşmelidir.

İşte Allow yönteminin uygulaması:

// Allow, mevcut hız sınırı altında bir isteğin izin verilip verilmediğini kontrol eder.
func (r *RateLimiter) Allow() bool {
	r.mu.Lock()
	defer r.mu.Unlock()

	now := time.Now()
	elapsed := now.Sub(r.lastRefill).Seconds()
	
	// Geçen süreye göre yeni tokenları hesapla
	newTokens := elapsed * r.refillRate
	r.tokens = math.Min(r.maxTokens, r.tokens+newTokens)
	
	// Son yenileme zamanını güncelle
	r.lastRefill = now

	// Yeterli tokenımız olup olmadığını kontrol et
	if r.tokens >= 1.0 {
		r.tokens--
		return true
	}
	
	return false
}

Yüksek Geçiş Kapasitesi İçin Optimizasyonlar

Yukarıdaki uygulama doğru ve güvenlidir, ancak yüksek geçiş kapasiteli sistemlerde her istekte bir sync.Mutex edinmek darboğaz haline gelebilir. Mutex, bağlam değiştirme (context switching) ve potansiyel rekabet (contention) getirir.

Aşırı performans gereksinimleri için şu optimizasyonları düşünün:

Kilitsiz Algoritmalar: Mantığınız izin veriyorsa atomik işlemler (örn. sync/atomic) kullanın. Ancak, token bucket'ın geçen süreyi hesaplaması, önemli bir yük olmadan tamamen atomik hale getirmek için karmaşıktır.
İstemci Başına Kovalar: Kullanıcı başına hız sınırlaması yapıyorsanız, global bir mutex'ten kaçının. Bunun yerine, kilit rekabetini önemli ölçüde azaltmak için kullanıcı başına kovaları saklamak üzere bir sync.Map kullanın.
Tahmini Yenileme: Kesin geçen süreyi hesaplamak yerine, tokenları sabit bir aralığa göre (örn. her 100 ms'de bir) yenileyebilir, küçük bir doğruluk kaybı karşılığında hız kazanabilirsiniz.

Pratik Kullanım Örneği

Bu hız sınırlayıcıyı bir HTTP işleyicisine nasıl entegre edebileceğinize dair bir örnek:

func MyHandler(limiter *ratelimit.RateLimiter) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if !limiter.Allow() {
			http.Error(w, "Hız sınırı aşıldı", http.StatusTooManyRequests)
			return
		}
		// İsteği işle...
		w.Write([]byte("Başarılı"))
	}
}

Sonuç

Go'da token bucket algoritmasını kullanarak bir hız sınırlayıcı uygulamak, sistem kaynaklarını yönetmek için basit ancak güçlü bir tekniktir. Go'nun standart kütüphanesinden yararlanarak ve eşzamanlılığın nüanslarını anlayarak, hem verimli hem de güvenilir bir çözüm oluşturabilirsiniz. Mutex rekabetinizi izlemeyi ve birden fazla sunucu örneği üzerinde çalışıyorsanız dağıtık çözümleri (Redisson ile Redis gibi) düşünmeyi unutmayın.

İster genel bir API ister dahili bir mikro hizmet geliştiriyor olun, hız sınırlamayı ustalaşmak, her orta düzeyden ileri düzey Go geliştiricisi için hayati bir beceridir.