0%

Koa服务限流方法实践

最近接了一个需求,很简单,就是起一个server,收到请求时调用某个提供好的接口,然后把结果返回。因为这个接口的性能问题,同时在请求的不能超过特定数目,要在服务中进行限流。

限流的要求是,限制同时执行的数目,超出这个数目后要在一个队列中进行缓存。

koa 中间件不调用 next

最初的想法是在 koa 中间件中进行计数,超过6个时将next函数缓存下来。等正在进行中的任务结束时,调用next继续其他请求。

之后发现 koa 中间件中,不执行next函数请求并不会停下,而是不再调用之后的中间件,直接返回内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const Koa = require('koa');
const app = new Koa();

app.use((ctx, next) => {
console.log('middleware 1');
setTimeout(() => {
next();
}, 3000);
ctx.body = 'hello';
});

app.use((ctx, next) => {
console.log('middleware 2');
});

app.listen(8989);

以上代码首先在控制台打出 ‘middleware 1’ => 浏览器收到 ‘hello’ => 控制台打出 ‘middleware 2’。

这里还有一个要注意的地方,就是一个请求已经结束(finish)后,他的next方法还是可以继续调用,之后的middleware还是继续运行的(但是对ctx的修改不会生效,因为请求已经返回了)。同样,关闭的请求(close)也是同样的表现。

使用 await 让请求进行等待

延迟next函数执行不能达到目的。接下来自然想到的就是使用await让当前请求等待。await的函数返回一个Promise,我们将这个Promise中的resolve函数存储到队列中,延迟调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const Koa = require('koa');
const app = new Koa();

const queue = [];

app.use(async (ctx, next) => {
setTimeout(() => {
queue.shift()();
}, 3000);
await delay();
ctx.body = 'hello';
});

function delay() {
return new Promise((resolve, reject) => {
queue.push(resolve);
});
}
app.listen(8989);

上面这段代码,在delay函数中返回一个PromisePromiseresolve函数存入队列中。设置定时3s后执行队列中的resolve函数,使请求继续执行。

针对路由进行限流,还是针对请求进行限流?

限流的基本原理实现后,下面一个问题就是限流代码该写在哪里?基本上,有两个位置:

针对接口进行限流

由于我们的需求中,限流是因为要请求接口的性能有限。所以我们可以单独针对这个请求进行限流:

1
2
3
4
5
6
7
8
9
10
11
async function requestSomeApi() {
// 如果已经超过了最大并发
if (counter > maxAllowedRequest) {
await delay();
}
counter++;
const result = await request('http://some.api');
counter--;
queue.shift()();
return result;
}

下面还有一个方便复用的版本。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
async function limitWrapper(func, maxAllowedRequest) {
const queue = [];
const counter = 0;
return async function () {
if (counter > maxAllowedRequest) {
await new Promise((resolve, reject) => {
queue.push(resolve);
});
}
counter++;
const result = await func();
counter--;
queue.shift()();
return result;
}
}

针对路由进行限流

这种方式是写一个koa中间件,在中间件中进行限流:

1
2
3
4
5
6
7
8
9
10
11
12
13
async function limiter(ctx, next) => {
// 如果超过了最大并发数目
if (counter >= maxAllowedRequest) {
// 如果当前队列中已经过长
await new Promise((resolve, reject) => {
queue.push(resolve);
});
}
store.counter++;
await next();
store.counter--;
queue.shift()();
};

之后针对不同路由在router中使用这个中间件就好了:

1
router.use('/api', rateLimiter);

比较

实现了针对接口进行限流,觉得逻辑有些乱,于是改用了针对路由进行限流,一切运行的很完美。

直到我又接了个需求,是要请求三次这个接口返回三次请求的结果数组。现在问题来了,我们不能直接调用接口,因为要限流。也不能直接调用请求接口的函数因为我们的限流是以路由为单位的。那怎么办呢?我们只有请求这个路由了,自己请求自己。。。

需要注意的地方

  • 监听close事件,将请求从队列中移出

已经存储在队列中的请求,有可能遇到用户取消的情况。前面说过koa中即使请求取消,之后的中间件还是会运行,也就是还会执行需要限流的接口,造成浪费。

可以监听close事件来达到这个目的,每个请求我们需要用hash值来标记:

1
2
3
4
5
6
ctx.res.on('close', () => {
const index = queue.findIndex(item => item.hash === hash);
if (index > -1) {
queue.splice(index, 1);
}
});
  • 设置超时时间

为了防止用户等待过长时间,需要设置超时时间,这在koa中很容易实现:

1
2
const server = app.listen(config.port);
server.timeout = DEFAULT_TIMEOUT;
  • 当前队列已经过长

如果当前队列已经过长了,即使加入队列中也会超时。因此我们还需要处理队列过长的情况:

1
2
3
4
if (queue.length > maxAllowedRequest) {
ctx.body = 'error message';
return;
}
梅旭光 wechat
欢迎扫码关注我的公众号