Go ile Yüksek Performanslı Token Bucket Hız Sınırlayıcı Oluşturma

Ölçeklenebilir mikro servisler geliştiren Go geliştiricileri olarak, trafik artışlarını yönetmek kritik bir zorluktur. Denetimsiz istek hacimleri, sistem bozulmasına, veritabanı bağlantılarının tükenmesine veya zincirleme hatalara yol açabilir. Hız sınırlama stratejileri çok olsa da, Token Bucket Algoritması kısa süreli trafik patlamalarına izin verirken uzun vadeli ortalamaları uygulayabilmesi açısından altın standart olmaya devam ediyor. Bu yazıda, düşük gecikme süresi ve yüksek eşzamanlılık için optimize edilmiş, Go'da sağlam ve iş parçacığı güvenli bir hız sınırlayıcı uygulayacağız.

Neden Token Bucket Algoritması?

Giriş hızından bağımsız olarak katı bir çıkış hızı uygulayan Sızan Kova (Leaky Bucket) algoritmasının aksine, Token Bucket bir "token" tamponuna izin verir. Bir istemci isteklerde ani bir artış yaşarsa, kovanın kapasitesine kadar token tüketebilir. Kovan boşaldığında, tokenlar yeniden doldurulana kadar sonraki istekler reddedilir. Bu yaklaşım, kullanıcı deneyimini (hızlı işlemlere izin vererek) sistem istikrarıyla dengelediği için API'ler için idealdir.

Temel Uygulama Stratejisi

Bunu Go'da uygulamak için üç ana bileşeni ele almamız gerekir:

1. Durum Yönetimi: Token sayısını ve son doldurma zamanını izleme.
2. Eşzamanlılık Güvenliği: Hız sınırlayıcının sync.Mutex kullanarak çok iş parçacıklı ortamlarda doğru çalışmasını sağlama.
3. Efiklilik: Gereksiz ayrılmalardan kaçınma ve kilit rekabetini minimize etme.

Konfigürasyonu (kapasite ve doldurma hızı) ve mevcut durumu tutan bir yapı tanımlayacağız. Temel yöntem, bir token tüketmeye çalışan Allow() olacaktır.

Kodu Yazma

İşte tamamlanmış, üretim ortamına hazır bir uygulama. Hassasiyet için time.Duration kullanımına ve paylaşılan durumu korumak için kullanılan mutex'e dikkat edin.

package ratelimiter

import (
	"sync"
	"time"
)

// TokenBucket iş parçacığı güvenli bir hız sınırlayıcı uygular.
type TokenBucket struct {
	mu         sync.Mutex
	tokens     float64
	maxTokens  float64
	refillRate float64 // saniyedeki token sayısı
	lastRefill time.Time
}

// NewTokenBucket yeni bir hız sınırlayıcı oluşturur.
// capacity maksimum token sayısını belirtir.
// refillRate saniyede eklenen token sayısını belirtir.
func NewTokenBucket(capacity int, refillRate float64) *TokenBucket {
	return &TokenBucket{
		tokens:     float64(capacity),
		maxTokens:  float64(capacity),
		refillRate: refillRate,
		lastRefill: time.Now(),
	}
}

// Allow bir isteğe izin verilip verilmediğini kontrol eder ve izin verilirse bir token tüketir.
func (tb *TokenBucket) Allow() bool {
	tb.mu.Lock()
	defer tb.mu.Unlock()

	// Geçen süreye göre eklenecek tokenları hesapla
	now := time.Now()
	elapsed := now.Sub(tb.lastRefill).Seconds()
	tokensToAdd := elapsed * tb.refillRate

	// Token sayısını güncelle, maksimum kapasite ile sınırla
	tb.tokens += tokensToAdd
	if tb.tokens > tb.maxTokens {
		tb.tokens = tb.maxTokens
	}
	tb.lastRefill = now

	// Bir token tüketmeyi dene
	if tb.tokens >= 1.0 {
		tb.tokens--
		return true
	}

	return false
}

// GetTokens mevcut kullanılabilir token sayısını döndürür.
func (tb *TokenBucket) GetTokens() float64 {
	tb.mu.Lock()
	defer tb.mu.Unlock()
	return tb.tokens
}

Temel Optimizasyon Detayları

Yukarıdaki uygulama basit bir sync.Mutex kullanır. Etkili olsa da, yüksek rekabet senaryolarında okuma işlemleri baskınsa sync.RWMutex faydalı olabilir. Ancak hız sınırlama, tokenları kontrol etme ve tüketme açısından yazma ağırlıklı bir işlemdir; bu nedenle standart bir mutex genellikle yeterlidir ve daha basittir.

Başka bir kritik detay, tokensToAdd hesaplamasıdır. Tokenları sabit bir aralığa göre değil, geçen süreye göre hesaplayarak değişken istek desenlerini sorunsuz bir şekilde yönetiriz. Pasif dönemler boyunca çok sayıda token birikirse, ani trafik artışlarında kötüye kullanımı önlemek için bunlar maxTokens ile sınırlanır.

Bir Web Sunucusunda Pratik Kullanım

Bunu bir Gin veya standart HTTP sunucusuna entegre etmek basittir. İşleyicinizi sınırlayıcıyla sarabilirsiniz:

package main

import (
	"fmt"
	"net/http"
	"your-project/ratelimiter"
)

var limiter = ratelimiter.NewTokenBucket(10, 2) // 10 ani istek, 2 istek/sn sürdürülebilir

func main() {
	http.HandleFunc("/api/data", func(w http.ResponseWriter, r *http.Request) {
		if !limiter.Allow() {
			http.Error(w, "Çok Fazla İstek", http.StatusTooManyRequests)
			return
		}
		fmt.Fprintln(w, "Başarılı: İşte verileriniz")
	})

	http.ListenAndServe(":8080", nil)
}

Sonuç

Bir hız sınırlayıcı uygulamak karmaşık olmak zorunda değildir. Token Bucket algoritması, Go'nun verimli eşzamanlılık ilkeleriyle birleştiğinde, servislerinizi korumak için güçlü bir araç sağlar. Basit veri yapılarına ve minimum kilitlemeye odaklanarak, düşük gecikme süresiyle yüksek veri işleme hızına ulaşabilirsiniz. Bu uygulama, birden fazla servis örneği boyunca hızları uygulamak için dağıtılmış kilit kullanımı (örneğin Redis) ile genişletilebilecek sağlam bir temel sağlar.