当前位置：自学咖网 > 技术教程 > 编程最新 > 架构高可用之限流-抽刀断水水更流
wenwen 编程最新

架构高可用之限流-抽刀断水水更流

架构高可用之限流-抽刀断水水更流

file

上图中是一个水坝泄洪的图，那么，对于软件系统，如何使用最方便的可编程的方式增加服务限流能力呢？

下面我结合一个常规的springCloud项目实践了一把，希望他山之石可以攻玉。

背景

简单使用jmeter，压20个并发，访问 列表查询接口 /worksheet/findInfo, 对应的服务崩溃。【apprun,common】

架构复杂度的一个种类是： 保护API和服务端点免受攻击，

比如：拒绝服务，级联失败，或者 超额使用资源。

限流是一种技术，来控制API或者服务的消费速度，在分布式系统中，没有比集中式的配置和管理API的消费速度更好的选择，

只有这些请求在限定的速度内访问，才能保证API的正常，更多的将会产生Http的 请求频繁错误。

交互模型图：

file

SpringCloudGateway是一个简单和轻量级的组件，也是一种管理限制API的消费速度有效的方式。

springCloudGateway的限流模型：

file

目标

当前企业600人，按照两倍估算，即1200人使用，高频接口秒并发限制为20， 即有20个人同时使用同一个接口操作数据。

file

需要增加限流和熔断的点：

组件 增加限制 业务说明
openresty 限流，熔断 【统一】 保证流量再nginx的处理阈值，参考数据：5W/S
gateway 限流，熔断 【统一】 保证每个API的访问速度在20/S 峰值40 ；
apprun 高频接口限流，每个接口统一分类定制熔断逻辑 限流可以复用封装的组件，熔断采用最简单的hystix ;
devops 高频接口限流，每个接口统一分类定制熔断逻辑 限流可以复用封装的组件，熔断采用最简单的hystix ;
common 高频接口限流，每个接口统一分类定制熔断逻辑，feign定制熔断逻辑 限流可以复用封装的组件，熔断采用最简单的hystix ;
job 高频接口限流，每个接口统一分类定制熔断逻辑，feign定制熔断逻辑 限流可以复用封装的组件，熔断采用最简单的hystix ;

实现路径

网关做整体限制，接口由业务来增加限流。

gateway

gateway自带过滤器

RequestRateLimiter GatewayFilter工厂使用了RateLimiter实现来决定当前的并发请求是否允许处理，

如果不能处理，默认返回状态码 429 – 太多请求；

这个过滤器采用了可选的KeyResolver参数和对于速度限制的特殊参数，下面会介绍。

keyResolver是一个实体实现了KeyResolver接口，配置指向一个bean的名字，

使用SpEL表达式。 #{@myKeyResolver} 是一个SPEL表达式指向了一个叫做myKeyResolver的bean,下面展示了 KeyResolver接口；

public interface KeyResolver {
    Mono<String> resolve(ServerWebExchange exchange);
}

keyResolver接口是的插件策略驱动请求限制，再未来的里程碑版本，将会由一些KeyResolver的实现。

默认实现KeyResolver的类是 PrincipalNameKeyResolver， 会接受ServerWebExchange的Principal参数， 并且会调用 Principal.getName()方法。

默认的，如果KeyResolver没有找到key, 请求会被拒绝，你可以配置这个行为。

spring.cloud.gateway.filter.request-rate-limiter.deny-empty-key=true
spring.cloud.gateway.filter.request-rate-limiter.empty-key-status-code=xxxx

注意： RequestRateLimiter没有配置短注解，下面的例子是非法的。

spring.cloud.gateway.routes[0].filters[0]=RequestRateLimiter=2, 2, #{@userkeyresolver}

RedisLimiter介绍

Redis实现是基于Stripe . 它需要使用 spring-boot-starter-data-redis-reactive 这个starter ;

算法使用的是令牌桶。

key 业务含义 用途
redis-rate-limiter.replenishRate 一个用户每秒多少请求数，不包含丢弃的请求，这个速度就是令牌桶的数量。 补充速度
redis-rate-limiter.burstCapacity 用户每秒允许最大的请求数量，这个令牌数量就是令牌桶可以持有的数量，设置为0标识阻塞所有请求 突增容量
redis-rate-limiter.requestedTokens 单个请求消耗多少令牌，这个数量就是从令牌桶中每个请求获取令牌的数量，默认是1 请求消耗令牌数量

如果你把 replenishRate 和 burstCapacity值设置为一样，则完成了一个稳定的速度设置。

临时突增流量可以允许设置 burstCapacity > replenishRate ，

这种场景下，RateLimiter需要允许一些时间在 burstCapacity和 replenishRate 之间 。

两种连续的徒增会导致丢弃请求，下面的例子配置了一个 redis-rate-limit.

速度限制在1个请求每秒， replenishRate=1, requestedTokens=60,burstCapacity=60 ;

spring:
  cloud:
    gateway:
      routes:
      - id: requestratelimiter_route
        uri: https://example.org
        filters:
        - name: RequestRateLimiter
          args:
            redis-rate-limiter.replenishRate: 10
            redis-rate-limiter.burstCapacity: 20
            redis-rate-limiter.requestedTokens: 1

上面的配置补充令牌的速度是10， 突增容量是20，但是在下一秒，只有10个请求是可以进入的；

下面的例子配置了一个KeyResolver。简单的从请求参数中获取user(在生产环境不推荐使用)，

@Bean
KeyResolver userKeyResolver() {
    return exchange -> Mono.just(exchange.getRequest().getQueryParams().getFirst("user"));
}

你也可以定义自己的RateLImiter,作为一个bean,实现RateLimiter接口即可，

在下面的配置中。你可以引用一个bean通过名字，使用SpEL表达式。

{@myRateLimiter} 是一个表达式，引用了一个名字叫做 myRateLimiter的bean ,

下面的例子定义了一个rateLimite并且使用自定义的KeyResolver.

spring:
  cloud:
    gateway:
      routes:
      - id: requestratelimiter_route
        uri: https://example.org
        filters:
        - name: RequestRateLimiter
          args:
            rate-limiter: "#{@myRateLimiter}"
            key-resolver: "#{@userKeyResolver}"

魔方的限流配置

对所有的请求，限制如下。

key value 设置值原因
replenishRate 20 每个用户每秒处理请求速度 为20
burstCapacity 40 40，每秒处理请求数量突增容量 ；
requestedTokens 1 每个连接耗费1个令牌；

源代码分析： RequestRateLimiterGatewayFilterFactory

public GatewayFilter apply(Config config) {
		KeyResolver resolver = getOrDefault(config.keyResolver, defaultKeyResolver);
		RateLimiter<Object> limiter = getOrDefault(config.rateLimiter, defaultRateLimiter);
		boolean denyEmpty = getOrDefault(config.denyEmptyKey, this.denyEmptyKey);
		HttpStatusHolder emptyKeyStatus = HttpStatusHolder
				.parse(getOrDefault(config.emptyKeyStatus, this.emptyKeyStatusCode));

		return (exchange, chain) -> resolver.resolve(exchange).defaultIfEmpty(EMPTY_KEY).flatMap(key -> {
			if (EMPTY_KEY.equals(key)) {
				if (denyEmpty) {
					setResponseStatus(exchange, emptyKeyStatus);
					return exchange.getResponse().setComplete();
				}
				return chain.filter(exchange);
			}
			String routeId = config.getRouteId();
			if (routeId == null) {
				Route route = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
				routeId = route.getId();
			}
			return limiter.isAllowed(routeId, key).flatMap(response -> {

				for (Map.Entry<String, String> header : response.getHeaders().entrySet()) {
					exchange.getResponse().getHeaders().add(header.getKey(), header.getValue());
				}

				if (response.isAllowed()) {
					return chain.filter(exchange);
				}

				setResponseStatus(exchange, config.getStatusCode());
				return exchange.getResponse().setComplete();
			});
		});
	}

处理流程如下：

file

单个路由的限流配置：

spring:
  cloud:
    gateway:
      routes:
        - id: account-service
          uri: http://localhost:8090
          predicates:
            - Path=/account/**
          filters:
            - RewritePath=/account/(?<path>.*), /${path}
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 1
                redis-rate-limiter.burstCapacity: 60
                redis-rate-limiter.requestedTokens: 15

重写429的返回值。

package com.zengame.cycube.api.gateway.rest.aspect;

import cn.hutool.json.JSONUtil;
import com.zengame.cycube.api.lib.common.bean.R;
import com.zengame.cycube.api.lib.common.util.UUIDUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.RequestRateLimiterGatewayFilterFactory;
import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.cloud.gateway.filter.ratelimit.RateLimiter;
import org.springframework.cloud.gateway.route.Route;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.stereotype.Component;

import java.util.Map;
import java.util.stream.Stream;

/**
 * 魔方自定义限流
 * @author Carter.li
 * @createtime 2022/8/1 17:30
 */
@Slf4j
@Component
public class CubeRequestLimiterGatewayFilterFactory extends RequestRateLimiterGatewayFilterFactory {

    private final RateLimiter redisRateLimiter;
    private final KeyResolver keyResolver;
    private final boolean denyEmptyKey = true;
    private static final String EMPTY_KEY = "____EMPTY_KEY__";


    public CubeRequestLimiterGatewayFilterFactory(RateLimiter redisRateLimiter, KeyResolver keyResolver) {
        super(redisRateLimiter, keyResolver);
        this.redisRateLimiter = redisRateLimiter;
        this.keyResolver = keyResolver;
    }

    @Override
    public GatewayFilter apply(Config config) {
        KeyResolver resolver = getOrDefault(config.getKeyResolver(), keyResolver);
        RateLimiter<Object> limiter = getOrDefault(config.getRateLimiter(), redisRateLimiter);
        boolean denyEmpty = getOrDefault(config.getDenyEmptyKey(), this.denyEmptyKey);

        return (exchange, chain) -> resolver.resolve(exchange).defaultIfEmpty(EMPTY_KEY).flatMap(key -> {
            if (EMPTY_KEY.equals(key)) {
                if (denyEmpty) {
                    return TokenCheckGatewayFilterFactory.generateJson(exchange, R.error(9998, "请求key为空"));
                }
                return chain.filter(exchange);
            }
            String routeId = config.getRouteId();
            if (routeId == null) {
                Route route = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
                routeId = route.getId();
            }
            return limiter.isAllowed(routeId, key).flatMap(response -> {

                for (Map.Entry<String, String> header : response.getHeaders().entrySet()) {
                    exchange.getResponse().getHeaders().add(header.getKey(), header.getValue());
                }

                if (response.isAllowed()) {
                    return chain.filter(exchange);
                }

                R<String> r = R.error(9998, "请求太频繁");
                r.setData(key);
                r.setGuid("请控制请求速度");
                r.setTraceId(Stream.of(exchange.getRequest().getHeaders().getFirst("requestId"), exchange.getRequest().getQueryParams().getFirst("requestId")).filter(StringUtils::isNotBlank).findFirst().orElse(UUIDUtils.uuid()));
                log.warn("too many requests: {}", JSONUtil.toJsonStr(r));
                return TokenCheckGatewayFilterFactory.generateJson(exchange, r);

            });
        });
    }

    private <T> T getOrDefault(T configValue, T defaultValue) {
        return (configValue != null) ? configValue : defaultValue;
    }
}

测试

jmeter脚本

线程配置：
file

接口配置：

file

经过测试，对高频接口增加了限流能力，而且限流能力是可以设定的。

小结

在网关添加了最低限度的保护限流策略。

企业用户数量有限，可以使用最小的资源满足软件系统的需求；

原创不易，关注诚可贵，转发价更高！转载请注明出处，让我们互通有无，共同进步，欢迎沟通交流。

hmoban主题是根据ripro二开的主题，极致后台体验，无插件，集成会员系统
自学咖网 » 架构高可用之限流-抽刀断水水更流

wen 普通

分享到：

相关推荐

php循环语句

1、while循环 当指定的条件为真时循环执行代码块   while 语法： while (condition) { 　　statement; } 比如： <?php $i=1; while($i<...

PHP原生图片验证码转base64格式

1.简介 最近有个需求，就是把图片验证码转化为base64格式，tp5框架自带的think-captcha扩展包可以实现。但是，它有个缺点，不能获取验证码的值。在做前后端分离项目的时候，验证码检测有两种方式，各有利弊。 ...

 Spring的加载过程-配置文件加载过程（一）

1、原因 不知不觉已经从事java开发好几年了，成了人们口中的老司机。但是一直都是恍恍惚惚过来，对于框架底层实现一直都没有怎么了解过，只是在面试的时候背些面试题。慢慢地发现不能这样，需要振作，笑~~~~。从这篇开始，记录...

02.关于线程你必须知道的8个问题（上）

大家好，我是王有志，欢迎来到《Java面试都问啥？》的第一篇技术文章。 这个系列会从Java部分开始，接着是MySQL和Redis的内容，同时会继续更新数据结构与算法的部分，这样在第一阶段，我们就完成了面试“三幻神”的挑...

mysql相关知识点

mysql常用的两个存储引擎  MyISAM和InnoDB mysql 不支持full outer join（外连接） 可以使用左连接+union+右连接实现 union的意思是 合并加去重

总结php artisan module常用命令

module:make 创建一个新模块module:use 使用一个模块（这允许执行其他命令时不用输入模块名）module:unuse 和上面相反module:list 列出所有可用模块module:migrate 执行...