实战系列 - 如何用Spring Cloud Gateway 做一个Api管理器

从上往下顺序递增

IP黑白名单

1. 获取请求头的X-Forwarded-For，如果不存在就获取请求的 RemoteAddress
2. 获取黑白名单过滤策略执行过滤

可通过令牌桶做限流 cloud.gateway.filter.ratelimit

1. 进某一个API进行请求限流
2. 对某一订阅进行请求限流
3. 对IP进行请求限流

令牌桶，tokenBucket

1. 简单来说就是，发送数据的速率永远也不会超过某个峰值，超出的请求会被缓存或丢弃，也就是桶。桶中令牌就是剩余可传输的数据量，当每有一个数据包进行传输时，就需要消耗一定数量令牌。
2. 与漏桶算法强行限制数据的传输速率不同，令牌桶允许一定的突发传输，只要桶中有足够多的令牌。

限流具体处理方式：

1. 从请求参数中获取当前API的对应版本，设置当前过滤策略到请求参数中
2. 请求头中获取到此次请求类型API, IP, Subscribe，根据不同类型对上述策略进行筛选
3. 符合类型的策略，获取到该策略所允许的 单次正常限制数和最大限制数
4. 根据本次请求类型生成 对应的 key， 使用spring stringReactiveRedisTemplate 进行限流。
   1. 通过redis执行脚本：redisRequestRateLimiterScript， 来控制实现令牌桶形式的流量控制。其在META-INF/scripts/request_rate_limiter.lua 下
   2. 当执行redis脚本后，返回一个list<Long>， 第一个是是否允许此次请求，是则为1L。第二个是剩余多少请求可以发送。（本质使用的是tokenBucket来维持限流数）
   3. 最后设置上述信息到 response 头，比如设置到isAllowed
   4. 校验 response 头上 isAllowed参数，不被通过则发送 errorResponse

redisRequestRateLimiterScript解析

脚本参数主要包含两个：

当前流量控制的tokens_key， timestamp_key

1. tokens_key："request_rate_limiter.{" + id + "}.tokens"
2. timestamp_key： "request_rate_limiter.{" + id + "}.timestamp"
   lua脚本的 scriptArgs:
3. local rate = 当前流量限额的三分之一，可根据适当情况定制
4. local capacity = 当前流量限额
5. local now = 当前时间
6. local requested = 一次执行的请求数量

上代码

local tokens_key = KEYS[1]
local timestamp_key = KEYS[2]
--redis.log(redis.LOG_WARNING, "tokens_key " .. tokens_key)

local rate = tonumber(ARGV[1])
local capacity = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local requested = tonumber(ARGV[4])

local fill_time = capacity/rate
local ttl = math.floor(fill_time*2)

--redis.log(redis.LOG_WARNING, "rate " .. ARGV[1])
--redis.log(redis.LOG_WARNING, "capacity " .. ARGV[2])
--redis.log(redis.LOG_WARNING, "now " .. ARGV[3])
--redis.log(redis.LOG_WARNING, "requested " .. ARGV[4])
--redis.log(redis.LOG_WARNING, "filltime " .. fill_time)
--redis.log(redis.LOG_WARNING, "ttl " .. ttl)

local last_tokens = tonumber(redis.call("get", tokens_key))
if last_tokens == nil then
  last_tokens = capacity
end
--redis.log(redis.LOG_WARNING, "last_tokens " .. last_tokens)

local last_refreshed = tonumber(redis.call("get", timestamp_key))
if last_refreshed == nil then
  last_refreshed = 0
end
--redis.log(redis.LOG_WARNING, "last_refreshed " .. last_refreshed)

local delta = math.max(0, now-last_refreshed)
local filled_tokens = math.min(capacity, last_tokens+(delta*rate))
local allowed = filled_tokens >= requested
local new_tokens = filled_tokens
local allowed_num = 0
if allowed then
  new_tokens = filled_tokens - requested
  allowed_num = 1
end

--redis.log(redis.LOG_WARNING, "delta " .. delta)
--redis.log(redis.LOG_WARNING, "filled_tokens " .. filled_tokens)
--redis.log(redis.LOG_WARNING, "allowed_num " .. allowed_num)
--redis.log(redis.LOG_WARNING, "new_tokens " .. new_tokens)

redis.call("setex", tokens_key, ttl, new_tokens)
redis.call("setex", timestamp_key, ttl, now)

return { allowed_num, new_tokens }

使用redis做读缓存

1. ReadResponseFromCache
   1. 判断该请求是否需要缓存
   2. 通过当前请求的API方法和URI生成 cache 的 Key
   3. 设置cacheKey，读取redis当前的cache，设置 response 中

路由跳转

1. 从request获取请求Route
2. 拼接.scheme.host.port.path，将新的url放入request的 gatewayRequestUrl

使用redis做写缓存

2. WiteResponseAndCache
   1. 判断该请求是否需要缓存
   2. 通过当前请求的API方法和URI生成 cache 的 Key
   3. 设置cacheKey，写入cache到redis中，设置 response 中

认证

1. check API 是否正常
   1. 从请求头中获取 token， 获取API 版本
   2. 根据Access-Token和HTTP method获取api列表
   3. 判断accessToken是否不合法或被锁定，是否已取消订阅，api不存在等
2. 验证用户
   1. 查询 设置过的服务器地址和认证类型等信息，放到请求中
   2. 认证方式：
      1. basic：进行des 解密，放置base64加密 用户密码到 request
      2. jwt：进行des 解密，用JwtHelper解密信息，放到request中
      3. oauth2：restTemplate调用认证服务获取accesstoken

断路器

1. 针对转发的服务器地址做熔断
2. 继承com.netflix.hystrix.HystrixObservableCommand ， HystrixCommandKey为转发host+port

websocket连接

1. 做一些头部参数检查，比如ws，wss检查，判断是否已经被路由过了。
2. 转发交给org.springframework.web.reactive.socket.server.WebSocketService来处理