架构师学习第17周-分布式接口幂等性,分布式限流

接口设计与重试机制引发的问题

1. 提交订单按钮如何防止重复提交?
2. 表单录入页如何防止重复提交?

接口幂等性

什么情况下需要幂等性

1. 重复提交、接口重试、前端操作抖动等。
2. 业务场景:用户多次点击提交订单,后台应只生成一个订单。
3. 业务场景:支付时,由于网络问题重发,应该只扣一次钱。
4. 并不是所有的接口都要求幂等性,要根据业务而定。

幂等性的核心思想:通过唯一的业务单号保证幂等。

## Delete操作的幂等性

Update操作的幂等性

1. 根据唯一业务号去更新数据的情况。
2. 用户查询出要修改的数据,系统将数据返回页面,将数据版本号放入隐藏域。
3. 后台使用版本号作为更新条件。
4. update set version=version+1,xxx=${xxx} where id = xxx and version = ${version}gengin。
5. 使用乐观锁与update行锁,保持幂等性(在提交的时候附带当前的版本号,因为当前页面的版本号是不会随着提交次数变化的,而后台只要成功更新一次版本号就会加一,后面的提交就不会成功)。
6. 更新操作没有唯一业务号,可使用Token机制。

Insert操作的幂等性

1. 有唯一业务号的Insert操作,例如:秒杀,商品ID+用户ID
2. 可通过分布式锁,保证接口幂等
3. 业务执行完成后,不进行锁释放,让其过期自动释放
4. 没有唯一业务号的Insert操作,比如:用户注册,点击多次
5. 使用Token机制,保证幂等性
6. 进入到注册页时,后台统一生成Token,返回前台隐藏域
7. 用户在页面点击提交时,将Token一同传入后台
8. 使用Token获取分布式锁,完成Insert操作
9. 执行成功后,不释放锁,等待的不过过期自动释放
10. 混合操作也是使用Token机制
    简述Token机制:当我们需要实现注册幂等时,当同一个页面提交多次请求,我们的后台一般需要在刚打开注册页面是给前端返回一个token值,然后提交的时候附带上这个token,在后台通过token去获取在Zookeeper中的分布式锁,当我们注册成功时也不要释放锁,等待自动过期,这样我们后面的请求也无法进入到锁,无法重复添加用户了。

分布式限流

使用Guava实现非阻塞限流，限定时间的非阻塞限流，以及同步阻塞限流。

@RestController
@Slf4j
public class Controller {
	//每秒产生的令牌数
    RateLimiter limiter = RateLimiter.create(2.0);

    //非阻塞限流
    @GetMapping("/tryAcquire")
    public String tryAcquire(Integer count)
    {
        if(limiter.tryAcquire(count)){
            log.info("success, rate is {}",limiter.getRate());
            return "success";
        }else
        {
            log.info("fail,rate is {}",limiter.getRate());
            return "fail";
        }
    }

    //限定时间的非阻塞限流
    @GetMapping("/tryAcquireWithTimeout")
    public String tryAcquireWithTimeout(Integer count,Integer timeout)
    {
        if(limiter.tryAcquire(count,timeout, TimeUnit.SECONDS)){
            log.info("success, rate is {}",limiter.getRate());
            return "success";
        }else
        {
            log.info("fail,rate is {}",limiter.getRate());
            return "fail";
        }
    }

    //同步阻塞限流
    @GetMapping("/acquire")
    public String acquire(Integer count){
        limiter.acquire(count);
        log.info("success,rate is {}",limiter.getRate());
        return "success";
    }

}

1. 非阻塞限流：此次请求是否能够获取到足够的令牌来满足此次请求,如果不满足,则马上返回false。
2. 限定时间的非阻塞限流:限定时间内如果能够产生足够的令牌则待产生到足够的令牌之后会返回true,如果当前时间是不可能产生足够的令牌则立刻返回false。
3. 同步阻塞限流:若此次请求不能够获得足够的令牌,则原地等待到能够获得足够令牌再返回true。

基于Nginx的IP限流

1. 添加Controller方法
2. 网关层配置(修改Host文件和Nginx文件)
3. 配置限流规则

nginx.conf配置示例

#根据IP地址限制速度
#1) 第一个参数$binary_remote_addr
#	binary_目的是缩写内存占用,remote_addr表示通过IP地址来限流
#2) 第二个参数zone=iplimit:20m
#    iplimit是一块内存区域(记录访问频率信息),20m是指这块内存区域的大小
#3) 第三个参数 rate=1r/s
#	比如100r/m,标识访问的限流频率,表示每分钟100个请求
	limit_req_zone $binary_remote_addr zone=iplimit:20m rate=10r/s;
#根据服务器级别做限流
	limit_req_zone $server_name zone=serverlimit:10m rate 100r/s;
#基于链接数的配置
	limit_conn_zone $binary_remote_addr zone=perip:20m;
	limit_conn_zone $server_name zone=perserver:20m;
	
	server {
		server_name www.imooc-training.com;
		location /access-limit {
			proxy_pass http://127.0.0.1:10086/;
			#基于IP地址的限制
			#1)第一个参数zone=iplimit => 引用limit_req_zone中的变量
			#2)第二个参数burst=2,设置一个大小为2的缓冲区域,当大量请求到来,请求数量超过限流频率时,将其放入缓冲区域。
			#3)第三个参数nodelay=>缓冲区满了以后,直接返回503异常
			limit_req zone=iplimit burst=2 nodelay;

			# 基于服务器级别的限制
			#通常情况下,server级别的限流速率是最大的
			limit_req zone=serverlimit burst=100 nodelay;

			#每个server最多保持100个连接
			limit_conn perserver 100;
			#每个IP地址最多保持5个连接
			limit_conn perip 5;
			
			#异常情况,返回504(默认503)
			#limit_req_status 504;
			limit_conn_status 504;
			}
			
			#彩蛋
			location /download/ {
				下载速度限制再256k
				limit_rate 256k;
				limit_rate_after 100m;
			}
		}

Lua介绍和基本用法

-- 模拟限流(假的)

--用作限流的Key
local key = 'My Key'

--限流的最大阈值=2
local limit = 2

--当前流量大小
local currentLimit = 2

-- 是否超出限流标准
if currentLimit + 1 > limit then
	print 'reject'
 	return false
else
	print 'accept'
	return true
end

Redis预加载Lua

限流组件封装——Redis+Lua

其实使用Redis+Lua最大的与Nginx的区别是一个在网管对IP层面进行限流,而Redis+Lua是在服务层进行逻辑层面上的限流,相比与网关层的限流,服务层的限流方式是会真正到达我们的服务器的,但是也能够根据不同的Service做出更灵活的限流。

下面是放在Redis中预编译的Lua脚本

-- 获取方法签名特征
local methodKey = KEYS[1]
redis.log(redis.LOG_DEBUG, 'key is', methodKey)

-- 调用脚本传入的限流大小
local limit = tonumber(ARGV[1])

-- 获取当前流量大小
local count = tonumber(redis.call('get', methodKey) or "0")

-- 是否超出限流阈值
if count + 1 > limit then
    -- 拒绝服务访问
    return false
else
    -- 没有超过阈值
    -- 设置当前访问的数量+1
    redis.call("INCRBY", methodKey, 1)
    -- 设置过期时间
    redis.call("EXPIRE", methodKey, 1)
    -- 放行
    return true
end

简述一下这里的思想:假设我们现在要给一个方法进行限流,我们可以利用特定的方法设定属于这个方法唯一的Key存在Redis中,并给这个Key设置一定的过期时间,这个过期时间意思是在这个时间内访问的数量不能超过设定最大值,每来一个请求就给这个Key的Value值加1,当某一刻加入某个请求时,通过Lua脚本判断是否超过了我们所设定的最大值，则返回false。

在IDEA中调用实现Redis+Lua限流的简单demo

@Service
@Slf4j
@Deprecated
public class AccessLimiter {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisScript<Boolean> rateLimitLua;

    public void limitAccess(String key, Integer limit) {
        // step 1 : request Lua script
        boolean acquired = stringRedisTemplate.execute(
                rateLimitLua, // Lua script的真身
                Lists.newArrayList(key), // Lua脚本中的Key列表
                limit.toString() // Lua脚本Value列表
        );

        if (!acquired) {
            log.error("your access is blocked, key={}", key);
            throw new RuntimeException("Your access is blocked");
        }
    }

Configure配置

@Configuration
public class RedisConfiguration {

    // 如果本地也配置了StringRedisTemplate，可能会产生冲突
    // 可以指定@Primary，或者指定加载特定的@Qualifier
    @Bean
    public RedisTemplate<String, String> redisTemplate(
            RedisConnectionFactory factory) {
        return new StringRedisTemplate(factory);
    }

    @Bean
    public DefaultRedisScript loadRedisScript() {
        DefaultRedisScript redisScript = new DefaultRedisScript();
        redisScript.setLocation(new ClassPathResource("ratelimiter.lua"));
        redisScript.setResultType(java.lang.Boolean.class);
        return redisScript;
    }

}