Kotlin में Rate Limiting: लाइब्रेरीज़ और उदाहरण

Kotlin में Rate Limiting: लाइब्रेरीज़, स्ट्रेटेजी और व्यावहारिक उदाहरण

Rate limiting (अनुरोध दर सीमित करना) API, माइक्रोसर्विसेज़ और वेब एप्लिकेशन को अत्यधिक लोड, DDoS हमलों और ट्रैफिक के अचानक उछाल से बचाने के लिए एक महत्वपूर्ण तंत्र है। JVM के ऊपर काम करने वाले Kotlin इकोसिस्टम में कई परिपक्व लाइब्रेरीज़ मौजूद हैं जो इस लॉजिक को लचीले ढंग से लागू करने की अनुमति देती हैं। इस लेख में हम तीन मुख्य दृष्टिकोणों और टूल्स पर चर्चा करेंगे: Bucket4j, Resilience4j और Guava का अंतर्निहित RateLimiter।

1. Bucket4j — Token Bucket का उन्नत कार्यान्वयन

Bucket4j एक Java लाइब्रेरी है जो Kotlin के साथ पूरी तरह से संगत है। यह Token Bucket एल्गोरिदम को लागू करती है और स्थानीय और वितरित (Redis, Hazelcast, Infinispan के माध्यम से) दोनों प्रकार की सीमाओं का समर्थन करती है।

मुख्य विशेषताएं:

टोकन की संख्या और उनकी पुनःपूर्ति दर को कॉन्फ़िगर करना।
टोकन संचय के माध्यम से "burst" (अल्पकालिक उछाल) का समर्थन।
बिना लॉक के मल्टी-थ्रेडेड वातावरण में काम करना।
bucket4j-spring-boot-starter स्टार्टर के माध्यम से Spring Boot के साथ एकीकरण।

Kotlin में सरल rate limiter का उदाहरण:

import io.github.bucket4j.Bandwidth
import io.github.bucket4j.Bucket
import io.github.bucket4j.Refill
import java.time.Duration

fun main() {
    // प्रति मिनट 10 अनुरोध, अधिकतम 20 टोकन तक संचय की क्षमता
    val limit = Bandwidth.classic(20, Refill.greedy(10, Duration.ofMinutes(1)))
    val bucket = Bucket.builder()
        .addLimit(limit)
        .build()

    // टोकन की उपलब्धता जांचें
    if (bucket.tryConsume(1)) {
        println("✅ अनुरोध स्वीकृत")
    } else {
        println("❌ सीमा पार, बाद में प्रयास करें")
    }
}

वितरित परिदृश्य के लिए (जैसे, माइक्रोसर्विस के कई इंस्टेंस) Redis के साथ Bucket4j का उपयोग करें:

import io.github.bucket4j.distributed.proxy.ProxyManager
import io.github.bucket4j.redis.lettuce.Bucket4jLettuce
import io.lettuce.core.RedisClient

val redisClient = RedisClient.create("redis://localhost:6379")
val proxyManager: ProxyManager<String> = Bucket4jLettuce
    .builder(redisClient)
    .build()

val bucket = proxyManager.builder()
    .build("user:123", Bucket4jConfiguration(
        Bandwidth.classic(100, Refill.intervally(100, Duration.ofMinutes(1)))
    ))

2. Resilience4j — Circuit Breaker के भाग के रूप में RateLimiter

Resilience4j Java/Kotlin के लिए एक लोकप्रिय स्थिरता लाइब्रेरी है, जिसमें rate limiter के अलावा circuit breaker, retry और bulkhead भी शामिल हैं। इसका RateLimiter मॉड्यूल Sliding Window एल्गोरिदम पर आधारित है।

विशेषताएं:

suspend फंक्शन के माध्यम से Kotlin कोरूटीन के साथ आसान एकीकरण।
विंडो अवधि और अनुरोध सीमा का कॉन्फ़िगरेशन।
विफलता प्रबंधन: अपवाद लौटाना, फ़ॉलबैक या प्रतीक्षा करना।

कोरूटीन के साथ उदाहरण:

import io.github.resilience4j.ratelimiter.RateLimiter
import io.github.resilience4j.ratelimiter.RateLimiterConfig
import io.github.resilience4j.kotlin.ratelimiter.awaitRateLimiter
import java.time.Duration
import kotlinx.coroutines.runBlocking

val config = RateLimiterConfig.custom()
    .limitForPeriod(10)           // 10 अनुरोध
    .limitRefreshPeriod(Duration.ofSeconds(1)) // 1 सेकंड में
    .timeoutDuration(Duration.ofMillis(500))   // प्रतीक्षा समय सीमा
    .build()

val rateLimiter = RateLimiter.of("api-limiter", config)

suspend fun fetchData(): String {
    return awaitRateLimiter(rateLimiter) {
        // आपका API कॉल
        "डेटा प्राप्त हुआ"
    }
}

fun main() = runBlocking {
    val result = fetchData()
    println(result)
}