Nodejs Nestjs限流插件rate-limiter-flexible的使用

Nodejs Nestjs限流插件rate-limiter-flexible的使用
rate-limiter-flexible 是一个非常灵活和强大的限流库，可以用于NestJS应用中以限制请求速率。下面是一个简单的示例，展示如何在NestJS应用中使用rate-limiter-flexible。

首先，你需要安装必要的依赖包：

npm install rate-limiter-flexible
npm install @nestjs/common

然后，在你的NestJS项目中创建一个中间件来应用限流逻辑：

import { Injectable, NestMiddleware } from '@nestjs/common';
import RateLimiterRedis from 'rate-limiter-flexible';
import Redis from 'ioredis';

const redisClient = new Redis();

@Injectable()
export class RateLimitMiddleware implements NestMiddleware {
  private readonly limiter: RateLimiterRedis;

  constructor() {
    this.limiter = new RateLimiterRedis({
      storeClient: redisClient,
      keyPrefix: 'ratelimit:',
      points: 100, // 每个IP允许的请求数
      duration: 60, // 重置时间（秒）
    });
  }

  async use(req: Request, res: Response, next: NextFunction) {
    try {
      await this.limiter.consume(req.ip);
      next();
    } catch (err) {
      res.status(429).json({ error: 'Too Many Requests' });
    }
  }
}

接下来，在你的模块文件中注册这个中间件：

import { Module, MiddlewareConsumer } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { RateLimitMiddleware } from './rate-limit.middleware';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(RateLimitMiddleware)
      .forRoutes('*'); // 对所有路由应用限流
  }
}

这个例子中，我们定义了一个名为RateLimitMiddleware的中间件，它使用了rate-limiter-flexible的Redis存储实现。每个IP地址在60秒内只能发送100个请求，否则将返回HTTP状态码429（Too Many Requests）。

确保你已经在你的环境中配置了Redis服务器，并且redis-client能够连接到它。如果你不需要使用Redis，也可以选择其他存储选项，如内存存储等。

以上就是在NestJS中使用rate-limiter-flexible的基本步骤。你可以根据自己的需求调整限流规则和存储方式。


3 回复

当然，要给你的NestJS应用加上rate-limiter-flexible这个强大的限流插件，就像给蛋糕加糖一样简单（但别加太多，不然会甜到齁）！

首先，你需要安装它：

npm install --save rate-limiter-flexible

然后，在你的服务或全局中间件中设置它。比如，为一个控制器方法添加限流：

import { HttpException, HttpStatus } from '@nestjs/common';
import RateLimiterRedis from 'rate-limiter-flexible';
import { NestMiddleware } from '@nestjs/common';

const rateLimiter = new RateLimiterRedis({
  storeClient: redisClient, // 你的Redis客户端
  keyPrefix: 'ratelimit:',
  points: 10, // 每个IP每秒可以访问10次
  duration: 1, // 重置周期为1秒
});

export class RateLimitMiddleware implements NestMiddleware {
  async use(req: Request, res: Response, next: Function) {
    try {
      await rateLimiter.consume(req.ip);
      next();
    } catch (err) {
      throw new HttpException('Too Many Requests', HttpStatus.TOO_MANY_REQUESTS);
    }
  }
}

最后，在你的模块里注册这个中间件：

import { Module, MiddlewareConsumer } from '@nestjs/common';
import { YourController } from './your.controller';
import { RateLimitMiddleware } from './rate-limit.middleware';

@Module({
  controllers: [YourController],
})
export class AppModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(RateLimitMiddleware).forRoutes('*'); // 应用于所有路由
  }
}

这样，你就成功地给你的API加了一层防护网，防止被不速之客淹没啦！


当然可以。rate-limiter-flexible 是一个非常强大的限流库，可以与 NestJS 结合使用来限制请求速率。下面我将展示如何在 NestJS 应用中集成 rate-limiter-flexible。

1. 安装必要的包

首先，你需要安装 rate-limiter-flexible 和 @nestjs/core 相关的依赖：

npm install rate-limiter-flexible @nestjs/common @nestjs/core

2. 创建限流器服务

接下来，创建一个服务来封装 rate-limiter-flexible 的逻辑。例如，创建一个名为 RateLimiterService 的服务：

import { Injectable } from '@nestjs/common';
import { RateLimiterMemory } from 'rate-limiter-flexible';

@Injectable()
export class RateLimiterService {
  private rateLimiter: RateLimiterMemory;

  constructor() {
    // 设置每个IP地址每秒最多10个请求
    this.rateLimiter = new RateLimiterMemory({
      points: 10, // 每秒允许的请求数量
      duration: 1, // 时间窗口（秒）
    });
  }

  async consume(ip: string): Promise<void> {
    await this.rateLimiter.consume(ip);
  }
}

3. 创建限流守卫

然后，创建一个守卫来应用限流逻辑。例如，创建一个名为 RateLimitGuard 的守卫：

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { RateLimiterService } from './rate-limiter.service';

@Injectable()
export class RateLimitGuard implements CanActivate {
  constructor(private readonly rateLimiterService: RateLimiterService) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const ip = request.ip; // 获取客户端IP

    try {
      await this.rateLimiterService.consume(ip);
      return true;
    } catch (err) {
      return false;
    }
  }
}

4. 使用限流守卫

最后，在控制器或特定路由上应用限流守卫：

import { Controller, Get, UseGuards } from '@nestjs/common';
import { RateLimitGuard } from './rate-limit.guard';

@Controller('api')
export class ApiController {
  @Get('data')
  @UseGuards(RateLimitGuard)
  getData() {
    return { message: 'This is protected data' };
  }
}

以上就是在 NestJS 中使用 rate-limiter-flexible 进行限流的基本步骤。你可以根据需要调整限流规则和参数。

rate-limiter-flexible 是一个强大的限流插件，适用于NestJS应用。首先，你需要安装它：

npm install rate-limiter-flexible

然后，在你的服务或全局中间件中配置和使用它。例如，限制每个IP每秒只能请求3次：

import { RateLimiterMemory } from 'rate-limiter-flexible';
import { Injectable, NestMiddleware } from '@nestjs/common';

@Injectable()
export class RateLimitMiddleware implements NestMiddleware {
  private readonly rateLimiter = new RateLimiterMemory({
    points: 3,
    duration: 1,
  });

  use(req: Request, res: Response, next: NextFunction) {
    this.rateLimiter.consume(req.ip)
      .then(() => {
        next();
      })
      .catch(() => {
        res.status(429).send('Too Many Requests');
      });
  }
}

最后，在你的模块中应用这个中间件。

回到顶部