使用spring-cloud-zuul-rate-limit在zuul中为服务限流

迷南。 2022-09-07 14:39 167阅读 0赞

### 文章目录 ###

*   *  前言
     *  spring cloud eureka server注册中心
     *   *  pom文件
         *  启动类
         *  配置文件
     *  srping cloud eureka client业务服务
     *   *  pom文件
         *  启动类
         *  controller
         *  配置文件
     *  springcloud zuul
     *   *  pom文件
         *  启动类
         *  配置文件
         *  cache配置类
         *  过滤器
     *  功能验证
     *   *  验证limit
         *  验证refresh-interval
         *  验证type
         *  url\_pattern
     *  补充说明

--------------------

## 前言 ##

几个月前做过一个springCloud服务限流的任务，当时选定的技术是spring-cloud-zuul-rate-limit。  
之所以选这个而不是别的，是因为项目本身使用了zuul，而且业务需求上spring-cloud-zuul-rate-limit的功能刚好都可以满足，在这种情况下就可以在符合要求的同时尽可能快的完成。

这个任务实际上只相当于一个技术调研，只要在现有技术框架的基础上能够集成和实现需求，并且成功测试就可以了。  
和当时在公司略有不同的是，公司是直接使用内部maven仓库，springcloud依赖的版本号基本都是原始的。  
而在我自己电脑上重新写的时候，是使用的aliyun的maven仓库，springcloud版本经过了一定的加工处理。  
两个电脑不互通，也不能互传数据，所以在自己电脑上就要手动重来一遍。  
于是，因为这个版本问题，再加上自己的不小心，在自己电脑上一开始无法触发限流。  
我一度以为就是版本不同导致的，结果绞尽脑汁后才发现是因为自己敲错了一个符号。

言归正传，这里的集成分为了三个简单的服务，一个模拟业务服务的server，一个注册中心eureka，还有一个springcloud zuul。以下是代码示例：

## spring cloud eureka server注册中心 ##

### pom文件 ###

### 启动类 ###

@EnableEurekaServer
    @SpringBootApplication
    public class CloudEurekaApplication {
       public static void main(String[] args) {
          SpringApplication.run(CloudEurekaApplication.class, args);
       }
    }

### 配置文件 ###

spring.application.name=eureka-server
    server.port=1000
    eureka.client.register-with-eureka=false
    eureka.client.fetch-registry=false
    eureka.client.serviceUrl.defaultZone=http://127.0.0.1:1000/eureka/

可以看到，这里其实就是一个极简的eureka的微服务注册中心，所以其实没有太多需要额外解释的内容。

## srping cloud eureka client业务服务 ##

### pom文件 ###

### 启动类 ###

@EnableDiscoveryClient
    @SpringBootApplication
    public class CloudServer1Application {
       public static void main(String[] args) {
          SpringApplication.run(CloudServer1Application.class, args);
       }
    }

### controller ###

@RestController
    public class TestController {
       @GetMapping("/hello")
       public String hello(){
          return "hello";
       }
       @GetMapping("/hello1")
       public String hello1(){
          return "hello1";
       }
       @GetMapping("/hello2")
       public String hello2(){
          return "hello2";
       }
    }

### 配置文件 ###

server.port=1001
    spring.application.name=hello-service
    #name
    eureka.client.service-url.defaultZone=http://127.0.0.1:1000/eureka

可以看出，上边也就是一个极简的springcloud eureka的客户端服务，加上了一些非常简单的api接口。

## springcloud zuul ##

springcloud zuul ratelimit实际支持很多种数据存储方式，比如redis、jpa、jcache等，由于项目中没有使用redis，也没有使用jpa，然后当时的电脑又不能随便安装软件，所以就只能选用jcache存储，结合bucket4j一起使用。

### pom文件 ###

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
        <relativePath/> 
    </parent>
    ......
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        <version>2.1.1.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        <version>2.1.1.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>com.netflix.servo</groupId>
        <artifactId>servo-core</artifactId>
        <version>0.9.4-rc.1</version>
    </dependency>
    <dependency>
        <groupId>com.marcosbarbero.cloud</groupId>
        <artifactId>spring-cloud-zuul-ratelimit</artifactId>
        <version>2.2.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>com.github.vladimir-bukhtoyarov</groupId>
        <artifactId>bucket4j-core</artifactId>
        <version>6.2.0</version>
    </dependency>
    <dependency>
        <groupId>com.github.vladimir-bukhtoyarov</groupId>
        <artifactId>bucket4j-jcache</artifactId>
        <version>6.2.0</version>
    </dependency>
    <dependency>
        <groupId>javax.cache</groupId>
        <artifactId>cache-api</artifactId>
        <version>1.1.1</version>
    </dependency>
    <dependency>
        <groupId>com.github.vladimir-bukhtoyarov</groupId>
        <artifactId>bucket4j-hazelcast</artifactId>
        <version>6.2.0</version>
    </dependency>
    <dependency>
        <groupId>com.hazelcast</groupId>
        <artifactId>hazelcast</artifactId>
        <version>4.2</version>
    </dependency>

### 启动类 ###

@EnableZuulProxy
    @SpringCloudApplication
    public class CloudZuulApplication {
       public static void main(String[] args) {
          SpringApplication.run(CloudZuulApplication.class, args);
       }
    }

### 配置文件 ###

server.port=5001
    spring.application.name=zuul-service
    zuul.routes.hello-service.path=/hello-service/**
    zuul.routes.hello-service.service-id=hello-service
    eureka.client.service-url.defaultZone=http://127.0.0.1:1000/eureka/
    
    zuul.ratelimit.key-prefix=springcloud-book
    zuul.ratelimit.enabled=true
    zuul.ratelimit.repository=BUCKET4J_JCACHE
    
    zuul.ratelimit.policy-list.hello-service[0].limit=2
    zuul.ratelimit.policy-list.hello-service[0].quota=1
    zuul.ratelimit.policy-list.hello-service[0].refresh-interval=20
    zuul.ratelimit.policy-list.hello-service[0].type[0]=url

**这里配置含义如下：**  
**zuul.ratelimit.key-prefix=springcloud-book**；缓存存储的自定义键前缀  
**zuul.ratelimit.enabled=true**；启用速率限制，即启用ratelimit限流  
**zuul.ratelimit.repository=BUCKET4J\_JCACHE**；指定数据存储方式

下面的就是具体服务的限流规则配置，hello-service是服务id，尽量与eureka-client的服务名保持一致。  
**zuul.ratelimit.policy-list.hello-service\[0\].limit=2**；每个刷新时间窗口对应的请求数限制；  
**zuul.ratelimit.policy-list.hello-service\[0\].quota=1**；每单位时间允许访问的总时间（这个解释来自网上，需要进一步验证。目前多次测试的结果好像和网上解释的含义不太一样）  
**zuul.ratelimit.policy-list.hello-service\[0\].refresh-interval=20**；刷新时间窗口的时间，单位是秒，默认60秒；  
**zuul.ratelimit.policy-list.hello-service\[0\].type\[0\]=url**；支持的限流类型，如ORIGIN、USER、URL、URL\_PATTERN等。

### cache配置类 ###

@Configuration
    public class HazelcastConfiguration {
       @Bean("RateLimit")
       Cache<String, GridBucketState> cache(){
          Config config=new Config();
          config.setLiteMember(false);
          CacheSimpleConfig cacheSimpleConfig=new CacheSimpleConfig();
          cacheSimpleConfig.setName("springcloud-book");
          config.addCacheConfig(cacheSimpleConfig);
          HazelcastInstance hazelcastInstance= Hazelcast.newHazelcastInstance(config);
          ICacheManager cacheManager=hazelcastInstance.getCacheManager();
          Cache<String,GridBucketState> cache=cacheManager.getCache("springcloud-book");
          return cache;
       }
    }

### 过滤器 ###

@Component
    public class ErrorFilter extends ZuulFilter {
       @Override
       public String filterType() {
          return FilterConstants.ERROR_TYPE;
       }
       @Override
       public int filterOrder() {
          return 10;
       }
       @Override
       public boolean shouldFilter() {
          return true;
       }
       @Override
       public Object run()
          throws ZuulException
       {
          RequestContext context=RequestContext.getCurrentContext();
          Throwable throwable=context.getThrowable();
          if(throwable.getCause().getMessage().contains("ZuulException: 429 TOO_MANY_REQUESTS")){
             System.out.println("429 TOO MANY REQUESTS");
          }
          return null;
       }
    }

## 功能验证 ##

上边的服务中，定义了三个api，分别是/hello、/hello1和/hello2。主要验证limit、quota、refresh-interval、type的配置。  
根据上边zuul的配置，目前规则是20秒的刷新时间窗口，20秒内只允许2次请求，否则会触发限流。由于上边配置的类型是url，所以这里更准确的说，是20秒内同一个url只允许2次请求，否则触发限流。  
这里涉及limit、refresh-interval、type三个配置，由于多次验证quota都没效果，所以后续还需要进一步验证。

### 验证limit ###

首先，浏览器访问http://localhost::5001/hello-service/hello，20秒内发起多个请求，会发现前两个请求正常返回，后边的会出现429 TOO\_MANY\_REQUESTS。  
然后，修改limit的值为4，重启zuul，然后浏览器再访问上边的url，20秒内发起多个请求，会看到前4次请求正常返回，后边的会出现429 TOO\_MANY\_REQUESTS。

**以上证明这个参数对限流是生效的。**

### 验证refresh-interval ###

接着上边的测试，修改refresh-interval为10，然后重启zuul。浏览器还是访问上边的url，保证20秒内超过4个请求，但是每10秒内都不超过4个，会看到都会正常返回结果。  
然后，在10秒内发起超过4个的请求，会看到前4个正常返回，后边的就出现429 TOO\_MANY\_REQUESTS。

**以上证明refresh-interval也是生效的。**

### 验证type ###

为了提高效率，把上边limit改回2，refresh-interval改回20，然后重启zuul。  
浏览器访问同一个url，保证20秒内超过2次，会看到不论是http://localhost::5001/hello-service/hello、http://localhost::5001/hello-service/hello1，还是http://localhost::5001/hello-service/hello2，前两次都正常返回，后边的就出现429 TOO\_MANY\_REQUESTS。

然后还是保证20秒内访问超过2次，但是三个url交叉访问，保证每个20秒内不会有同一个url超过两次，会看到全部都是正常返回。

**以上证明当type是url时，针对的就是同一个url。**

修改type为origin并重启zuul，然后20秒内同一个浏览器访问url超过2次，会看到不论是同一个url超过2次，还是不同的url超过2次，都是前两次正常返回，后边就出现429 TOO\_MANY\_REQUESTS。

### url\_pattern ###

type是url其实已经基本能够满足大部分需求了，但是有时候可能就是需要对某一类url进行限流，而不是单纯的针对某一个url，那就可以用到url\_pattern。  
url\_pattern的配置相对于url的稍微复杂一点，为了方便验证，我先增加一些api接口，使他们有一些有相同的部分，修改后如下：

@GetMapping("/hello")
    public String hello(){
       return "hello";
    }
    @GetMapping("/hello1")
    public String hello1(){
       return "hello1";
    }
    @GetMapping("/hello2")
    public String hello2(){
       return "hello2";
    }
    @GetMapping("/test/hello3")
    public String hello3(){
       return "hello3";
    }
    @GetMapping("/test/hello4")
    public String hello4(){
       return "hello4";
    }
    @GetMapping("/test1/hello5")
    public String hello5(){
       return "hello5";
    }
    @GetMapping("/test1/hello6")
    public String hello6(){
       return "hello6";
    }

然后再修改配置，如下：

zuul.ratelimit.policy-list.hello-service[0].limit=2
    zuul.ratelimit.policy-list.hello-service[0].quota=1
    zuul.ratelimit.policy-list.hello-service[0].refresh-interval=20
    zuul.ratelimit.policy-list.hello-service[0].type[0]=url_pattern=/hello-service/test/*
    
    zuul.ratelimit.policy-list.hello-service[0].limit=2
    zuul.ratelimit.policy-list.hello-service[0].quota=1
    zuul.ratelimit.policy-list.hello-service[0].refresh-interval=20
    zuul.ratelimit.policy-list.hello-service[0].type[0]=url_pattern=/hello-service/test1/*
    
    zuul.ratelimit.policy-list.hello-service[0].limit=2
    zuul.ratelimit.policy-list.hello-service[0].quota=1
    zuul.ratelimit.policy-list.hello-service[0].refresh-interval=20
    zuul.ratelimit.policy-list.hello-service[0].type[0]=url_pattern=/hello-service/hello

重启zuul和client服务后，再次测试会看到，没有/test或者/test1开头的url以及/hello这个，无论访问多少次，都会是正常返回，而对于/test开头的，无论是同一个还是不同的url，只要达到限制条件，都会是429，/test1开头的也是一样。  
和type为url时候一样，如果是在/test开头和/test1开头的url之间切换，保证相同前缀的url不触发限制，那么即使不同前缀的看起来超过了次数，最终也不会触发限流。  
以上证明，type为url\_pattern时，可以进一步把限流细化到某一个或者某一类url，可以对不同url进行不同的限制，不会一竿子打死，也能保证互不影响。

## 补充说明 ##

文章开头提到，由于粗心大意，我一度认为是版本问题导致本机无法触发限流，实际只是因为一个符号敲错，那就是其他所有都是对的，但是zuul.ratelimit.enabled=true在最开始被我敲成了zuul-ratelimit.enabled=true。  
这个地方实际我检查了不下5遍，但不知为何始终没有发现问题，直到放了差不多一个月重新再看时，才终于看到了问题所在。  
这是个多么低级的错误，就如同以前遇到的数据库密码多一个末尾空格一样，很有吐血的冲动。