बकेट4जे और रेडिस के साथ स्केलेबल रेट लिमिटिंग लागू करें - चरण-दर-चरण मार्गदर्शिका

दर सीमित का उपयोग क्यों करें?

असीमित दरों के साथ समस्या

• संसाधन की कमी
• सेवा की गुणवत्ता में कमी
• सेवा हमलों से इनकार

दर सीमित करने से कैसे मदद मिलती है

टोकन बकेट एल्गोरिथम

1. एक बाल्टी एक निश्चित क्षमता (टोकन की संख्या) के साथ बनाई जाती है।
2. जब कोई अनुरोध आता है, तो बकेट की जाँच की जाती है। यदि पर्याप्त क्षमता है, तो अनुरोध को आगे बढ़ने की अनुमति दी जाती है। अन्यथा, अनुरोध अस्वीकार कर दिया जाता है।
3. जब किसी अनुरोध को अनुमति दी जाती है, तो क्षमता कम हो जाती है।
4. एक निश्चित समय के बाद, क्षमता पुनः भर दी जाती है।

वितरित सिस्टम में टोकन बकेट कैसे लागू करें

परियोजना कार्यान्वयन

1. एक सरल REST API।
2. रेडिसन क्लाइंट का उपयोग करके - सेवा से जुड़ा एक रेडिस कैश।
3. Bucket4J लाइब्रेरी REST API के चारों ओर लिपटी हुई है।
4. हम Bucket4J को JCache इंटरफ़ेस से कनेक्ट करेंगे जो पृष्ठभूमि में कार्यान्वयन के रूप में Redisson क्लाइंट का उपयोग करेगा।

निर्भरताएं स्थापित करें

<dependencies>
 <!-- To build the Rest API -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <!-- Redisson Starter = Spring Data Redis starter(excluding other clients) and Redisson client -->
 <dependency>
 <groupId>org.redisson</groupId>
 <artifactId>redisson-spring-boot-starter</artifactId>
 <version>3.17.0</version>
 </dependency>
 <!-- Bucket4J starter = Bucket4J + JCache -->
 <dependency>
 <groupId>com.giffing.bucket4j.spring.boot.starter</groupId>
 <artifactId>bucket4j-spring-boot-starter</artifactId>
 <version>0.5.2</version>
 </dependency>
</dependencies>

कैश कॉन्फ़िगरेशन

1. हमारे एप्लिकेशन से इस सर्वर से एक कनेक्शन बनाएं।
2. Redisson क्लाइंट को कार्यान्वयन के रूप में उपयोग करने के लिए JCache सेट करें।

@Configuration
public class RedisConfig {
 @Bean
 public Config config() {
 Config config = new Config();
 config.useSingleServer().setAddress("redis://localhost:6379");
 return config;
 }
 @Bean
 public CacheManager cacheManager(Config config) {
 CacheManager manager = Caching.getCachingProvider().getCacheManager();
 cacheManager.createCache("cache", RedissonConfiguration.fromConfig(config));
 return cacheManager;
 }
 @Bean
 ProxyManager<String> proxyManager(CacheManager cacheManager) {
 return new JCacheProxyManager<>(cacheManager.getCache("cache"));
 }
}

1. एक कॉन्फ़िगरेशन ऑब्जेक्ट बनाता है जिसका उपयोग हम कनेक्शन बनाने के लिए कर सकते हैं।
2. कॉन्फ़िगरेशन ऑब्जेक्ट का उपयोग करके कैश मैनेजर बनाता है। यह आंतरिक रूप से रेडिस इंस्टेंस से एक कनेक्शन बनाएगा और उस पर "कैश" नामक एक हैश बनाएगा।
3. एक प्रॉक्सी मैनेजर बनाता है जिसका उपयोग कैश तक पहुंचने के लिए किया जाएगा। जो कुछ भी हमारा एप्लिकेशन JCache API का उपयोग करके कैश करने का प्रयास करता है, उसे "कैश" नामक हैश के अंदर रेडिस इंस्टेंस पर कैश किया जाएगा।

एपीआई बनाएं

@RestController
public class RateLimitController {
 @GetMapping("/user/{id}")
 public String getInfo(@PathVariable("id") String id) {
 return "Hello " + id;
 }
}

बकेट4J कॉन्फ़िगरेशन

एक बाल्टी बनाएं

Refill refill = Refill.intervally(10, Duration.ofMinutes(1));
Bandwidth limit = Bandwidth.classic(10, refill);
Bucket bucket = Bucket4j.builder()
 .addLimit(limit)
 .build();

• फिर से भरना – कितने समय बाद बाल्टी दोबारा भर जाएगी.
• बैंडविड्थ – बाल्टी में कितनी बैंडविड्थ है. मूलतः, प्रति रिफिल अवधि के लिए अनुरोध।
• बाल्टी - इन दो मापदंडों का उपयोग करके एक ऑब्जेक्ट कॉन्फ़िगर किया गया है। इसके अतिरिक्त, यह बाल्टी में कितने टोकन उपलब्ध हैं, इसका ट्रैक रखने के लिए एक टोकन काउंटर रखता है।

प्रॉक्सीमैनेजर का उपयोग करके बकेट बनाएं और कैश करें

@Service
public class RateLimiter {
 //autowiring dependencies
 public Bucket resolveBucket(String key) {
 Supplier<BucketConfiguration> configSupplier = getConfigSupplierForUser(key);
 // Does not always create a new bucket, but instead returns the existing one if it exists.
 return buckets.builder().build(key, configSupplier);
 }
 private Supplier<BucketConfiguration> getConfigSupplierForUser(String key) {
 User user = userRepository.findById(userId);
 Refill refill = Refill.intervally(user.getLimit(), Duration.ofMinutes(1));
 Bandwidth limit = Bandwidth.classic(user.getLimit(), refill);
 return () -> (BucketConfiguration.builder()
 .addLimit(limit)
 .build());
 }
}

टोकन का उपभोग कैसे करें और दर सीमित कैसे करें

@GetMapping("/user/{id}")
public String getInfo(@PathVariable("id") String id) {
 // gets the bucket for the user
 Bucket bucket = rateLimiter.resolveBucket(id);
 // tries to consume a token from the bucket
 if (bucket.tryConsume(1)) {
 return "Hello " + id;
 } else {
 return "Rate limit exceeded";
 }
}

हमारी सेवा का परीक्षण कैसे करें

@Test
public void testGetInfo() {
 // calls the method 10 times for user 1
 for (int i = 0; i < 10; i++) {
 rateLimiter.getInfo(1));
 rateLimiter.getInfo(2));
 }
 // verifies that the response is rate limited for user 1
 assertEquals("Rate limit exceeded", rateLimiter.getInfo(1));
 // verifies that the response is successful for user 2
 assertEquals("Hello 2", rateLimiter.getInfo(2));
}

निष्कर्ष