Computer >> Hướng Dẫn Máy Tính >  >> Lập Trình >> Redis

Triển khai Rate Limiting có thể mở rộng với Bucket4J và Redis – Hướng dẫn từng bước

Trong hướng dẫn này chúng ta sẽ học cách triển khai rate limiting trong một dịch vụ đã mở rộng (scaled). Chúng ta sẽ dùng thư viện Bucket4J để triển khai nó và dùng Redis làm distributed cache.

Tại sao cần Rate Limiting?

Hãy bắt đầu với một số kiến thức cơ bản để chắc chắn chúng ta hiểu nhu cầu rate limiting và giới thiệu các công cụ chúng ta sẽ dùng trong hướng dẫn này.

Vấn đề với Unlimited Rates

Nếu một public API như Twitter API cho phép người dùng thực hiện số lượng request không giới hạn mỗi giờ, điều đó có thể dẫn đến:

  • cạn kiệt tài nguyên (resource exhaustion)
  • giảm chất lượng dịch vụ
  • tấn công từ chối dịch vụ (denial of service attacks)

Điều này có thể dẫn đến tình huống dịch vụ không khả dụng hoặc chậm. Nó cũng có thể dẫn đến chi phí không mong đợi được phát sinh bởi dịch vụ.

Rate Limiting giúp như thế nào?

Thứ nhất, rate-limiting có thể ngăn chặn tấn công denial of service. Khi kết hợp với cơ chế deduplication hoặc API keys, rate limiting cũng có thể giúp ngăn chặn distributed denial of service attacks.

Thứ hai, nó giúp ước lượng traffic. Điều này rất quan trọng cho public APIs. Điều này cũng có thể kết hợp với scripts tự động để monitor và scale dịch vụ.

Thứ ba, bạn có thể dùng nó để triển khai định giá theo cấp độ (tier-based pricing). Loại định giá này có nghĩa là người dùng có thể trả phí cho rate request cao hơn. Twitter API là ví dụ của điều này.

Thuật toán Token Bucket

Token Bucket là một thuật toán bạn có thể dùng để triển khai rate limiting. Tóm lại, nó hoạt động như sau:

  1. Một bucket được tạo với dung lượng nhất định (số lượng tokens).
  2. Khi một request đến, bucket được kiểm tra. Nếu đủ dung lượng, request được phép tiếp tục. Ngược lại, request bị từ chối.
  3. Khi request được phép, dung lượng bị giảm.
  4. Sau một khoảng thời gian nhất định, dung lượng được bổ sung (replenished).

Cách triển khai Token Bucket trong Hệ thống Phân tán

Để triển khai thuật toán token bucket trong hệ thống phân tán, chúng ta cần dùng một distributed cache (cache phân tán).

Cache là một key-value store để lưu trữ thông tin bucket. Chúng ta sẽ dùng Redis cache để triển khai điều này.

Bên trong, Bucket4j cho phép chúng ta plug vào bất kỳ triển khai nào của Java JCache API. Redisson client của Redis là triển khai chúng ta sẽ dùng.

Triển khai Dự án

Chúng ta sẽ dùng framework Spring Boot để xây dựng dịch vụ của mình.

Dịch vụ của chúng ta sẽ chứa các thành phần dưới đây:

  1. Một REST API đơn giản.
  2. Redis cache kết nối với dịch vụ – dùng Redisson client.
  3. Thư viện Bucket4J wrap quanh REST API.
  4. Chúng ta sẽ kết nối Bucket4J đến JCache interface sẽ dùng Redisson client làm triển khai trong background.

Đầu tiên, chúng ta sẽ học rate limit API cho tất cả requests. Sau đó chúng ta sẽ học triển khai cơ chế rate limiting phức tạp hơn cho mỗi user hoặc mỗi pricing tier.

Hãy bắt đầu với thiết lập dự án.

Cài đặt Dependencies

Hãy thêm các dependencies dưới đây vào file pom.xml (hoặc build.gradle).

<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>

Cấu hình Cache

Đầu tiên, chúng ta cần khởi động Redis server. Giả sử chúng ta có Redis server chạy trên cổng 6379 trên máy local.

Chúng ta cần thực hiện hai bước:

  1. Tạo kết nối đến server này từ ứng dụng của chúng ta.
  2. Thiết lập JCache để dùng Redisson client làm triển khai.

Tài liệu Redisson cung cấp các bước ngắn gọn để triển khai điều này trong ứng dụng Java thông thường. Chúng ta sẽ triển khai các bước giống nhau, nhưng trong Spring Boot.

Hãy xem mã trước. Chúng ta cần tạo một Configuration class để tạo các bean cần thiết.

@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"));
    }
}

Điều này làm gì?

  1. Tạo object cấu hình để dùng tạo kết nối.
  2. Tạo cache manager dùng object cấu hình. Điều này sẽ nội bộ tạo kết nối đến instance Redis và tạo một hash tên "cache" trên nó.
  3. Tạo proxy manager sẽ được dùng để truy cập cache. Bất cứ thứ gì ứng dụng của chúng ta cố gắng cache dùng JCache API, sẽ được cache trên instance Redis bên trong hash tên "cache".

Xây dựng API

Hãy tạo một REST API đơn giản.

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

Nếu tôi hit API với URL https://localhost:8080/user/1, tôi sẽ nhận phản hồi Hello 1.

Cấu hình Bucket4J

Để triển khai rate limiting, chúng ta cần cấu hình Bucket4J. May mắn thay, chúng ta không cần viết bất kỳ boilerplate code nào nhờ starter library.

Nó cũng tự động phát hiện bean ProxyManager chúng ta tạo ở bước trước và dùng nó để cache các buckets.

Điều chúng ta cần làm là cấu hình thư viện này quanh API chúng ta tạo.
Lại có nhiều cách để làm điều này.

Chúng ta có thể chọn cấu hình dựa trên property được định nghĩa trong starter library.
Đây là cách thuận tiện nhất cho các trường hợp đơn giản như rate-limiting cho tất cả users hoặc tất cả guest users.

Tuy nhiên, nếu chúng ta muốn triển khai phức tạp hơn như rate limit cho từng user, tốt hơn là viết custom code cho nó.

Chúng ta sẽ triển khai rate limiting per user. Giả sử chúng ta có rate limit cho mỗi user lưu trong database, và chúng ta có thể query nó dùng user id.

Hãy viết mã cho nó từng bước.

Tạo Bucket

Trước khi bắt đầu, hãy xem bucket được tạo như thế nào.

Refill refill = Refill.intervally(10, Duration.ofMinutes(1));
Bandwidth limit = Bandwidth.classic(10, refill);
Bucket bucket = Bucket4j.builder()
    .addLimit(limit)
    .build();
  • Refill – Sau bao lâu bucket sẽ được refill.
  • Bandwidth – Bucket có bao nhiêu bandwidth. Cơ bản là requests per refill period.
  • Bucket – Object được cấu hình dùng hai tham số này. Bên cạnh đó, nó duy trì token counter để theo dõi bao nhiêu tokens có sẵn trong bucket.

Dùng đây như building block, hãy thay đổi vài thứ để làm cho nó phù hợp với use case của chúng ta.

Tạo và Cache Buckets dùng ProxyManager

Chúng ta tạo proxy manager nhằm lưu buckets trên Redis. Khi một bucket được tạo, nó cần được cache trên Redis và không cần tạo lại.

Để làm điều này, chúng ta sẽ thay thế Bucket4j.builder() với proxyManager.builder(). ProxyManager sẽ lo việc cache buckets và không tạo lại chúng.

Builder của ProxyManager nhận hai tham số – một key bucket sẽ được cache dựa trên đó và một configuration object nó sẽ dùng để tạo bucket.

Hãy xem cách chúng ta có thể triển khai nó:

@Service
public class RateLimiter {
    // autowiring dependencies
    public Bucket resolveBucket(String key) {
        Supplier<BucketConfiguration> configSupplier = getConfigSupplierForUser(key);
        // Không luôn tạo bucket mới, mà trả về bucket hiện có nếu tồn tại.
        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());
    }
}

Chúng ta tạo method trả về bucket cho key được cung cấp. Ở bước tiếp theo, chúng ta sẽ xem cách dùng nó.

Cách Consume Tokens và Thiết lập Rate Limiting

Khi một request đến, chúng ta sẽ cố gắng consume một token từ bucket liên quan.
Chúng ta sẽ dùng method tryConsume() của bucket để làm điều này.

@GetMapping("/user/{id}")
public String getInfo(@PathVariable("id") String id) {
    // lấy bucket cho user
    Bucket bucket = rateLimiter.resolveBucket(id);
    // cố gắng consume token từ bucket
    if (bucket.tryConsume(1)) {
        return "Hello " + id;
    } else {
        return "Rate limit exceeded";
    }
}

Method tryConsume() trả về true nếu token được consume thành công hoặc false nếu token không được consume.

Cách Test dịch vụ của chúng ta

Chúng ta có thể test điều này dùng bất kỳ kỹ thuật test tự động nào. Ví dụ, chúng ta có thể dùng JUnit. Hãy viết test case gọi method getInfo() nhiều lần và verify phản hồi đúng.

Giả sử chúng ta có user với id 1 và limit 10 requests mỗi phút. Giả sử chúng ta cũng có user với id 2 và limit 20 requests mỗi phút.

Chúng ta sẽ hit 11 requests cho cả hai user và verify request thất bại cho user id 1 nhưng thành công cho user id 2.

@Test
public void testGetInfo() {
    // gọi method 10 lần cho user 1
    for (int i = 0; i < 10; i++) {
        rateLimiter.getInfo(1));
        rateLimiter.getInfo(2));
    }
    // verify phản hồi bị rate limited cho user 1
    assertEquals("Rate limit exceeded", rateLimiter.getInfo(1));
    // verify phản hồi thành công cho user 2
    assertEquals("Hello 2", rateLimiter.getInfo(2));
}

Khi chúng ta chạy test, chúng ta sẽ thấy test pass.

Kết luận

Trong hướng dẫn này, chúng ta đã bao gồm cách tạo rate limiter dùng Bucket4j và Redis trong ứng dụng Spring Boot. Chúng ta cũng xem cách thiết lập Redisson client với JCache và cách dùng nó để cache buckets.

Cuối cùng, chúng ta triển khai một rate limiter đơn giản có thể dùng để rate limit requests cho user cụ thể.

Hy vọng bạn thích hướng dẫn này. Cảm ơn đã đọc!

Học lập trình miễn phí. Chương trình mở của freeCodeCamp đã giúp hơn 40.000 người tìm được việc làm với tư cách là lập trình viên. Bắt đầu ngay hôm nay.