【隐藏技巧】用前置过滤器给Laf云函数加限制IP访问次数

Night

这个又是隐藏的云函数，跟WebSocket一样，这个云函数是运行在所有的云函数之前的，return true 才会去请求实际的云函数

1、新建云函数，固定命名为：`interceptor`

2、添加依赖 `nw-laf` 查看使用nw-laf文档

该NPM依赖已经升级为nw-lafjs 后续nw-laf将不再升级：https://forum.laf.run/d/280

3、替换云函数代码

import cloud from '@lafjs/cloud'
const nw = require('nw-laf')
const db = cloud.database()
const _ = db.command
const $ = _.aggregate

export async function main(ctx: FunctionContext) {
    // 请求的实际IP
    const ip = ctx.headers['x-real-ip']
    // 添加请求IP到数据库，并自动添加 add_time
    let requestIp = await nw.baseDao.add({
        cloud:cloud,
        dbName:"requestIp",
        dataJson:{
            ip:ip
        },
    })
    //获取当前IP的时间段的访问次数
    const Interval = 1 // 间隔分钟
    const times = 60 // 间隔Interval分钟内限制最大访问次数
    let timesRes = await nw.baseDao.select({
        cloud: cloud,
        dbName: 'requestIp',
        // 主表where条件
        whereJson: {
            _add_time : _.and(_.gte(Date.now()-Interval*60*1000), _.lte(Date.now()))
        }
    })
    // console.log(timesRes);
    if(timesRes.total <= times){
        // 返回 true 则会去继续请求实际的云函数
        return true
    }else{
        // 返回 false 则不会去继续请求实际的云函数
        return false
    }
}

4、修改参数

修改Interval 和 times，示例代码意为1分钟内同一个IP最多可以访问60次

5、发布云函数

大功告成！！后面请求任何其他的云函数都会去判断一下IP是否超过次数！

Laf 文档补全师

好！

Night

前置过滤器应用的场景比较多，比如AccessToken的刷新，发挥想象力去实现更多的功能吧！

西瓜没有皮

interceptor可以设置不允许请求方法

西瓜没有皮

import cloud from '@lafjs/cloud'
const db = cloud.database()
const _ = db.command
const $ = _.aggregate

export async function main(ctx: FunctionContext) {
    const sys_requestIp = db.collection("sys_requestIp");
    // 请求的实际IP
    const ip = ctx.headers['x-real-ip']
    const requestId = ctx.requestId
    const func = ctx.request.params.name
    console.log(func)
    // 添加请求IP到数据库，并自动添加 add_time
    let requestIp = await sys_requestIp.add({
        req_id: requestId,
        ip: ip,
        func: func,
        req_time: Date.now()
    })

    //获取当前IP的时间段的访问次数
    const Interval = 1 // 间隔分钟
    const times = 60 // 间隔Interval分钟内限制最大访问次数
    let timesRes = await sys_requestIp.where({
        // 主表where条件
        req_time: _.and(_.gte(Date.now() - Interval * 60 * 1000), _.lte(Date.now()))
    }).count()
    console.log(timesRes)
    if (timesRes.total <= times) {
        // 返回 true 则会去继续请求实际的云函数
        return true
    } else {
        // 返回 false 则不会去继续请求实际的云函数
        return false
    }
}

我修改了一下自己的，这个拦截器还可以加很多功能，比如webhook等等

西瓜没有皮

ctx.response.status(403);
    ctx.response.json({"error":"Forbidden","message":"黑名单用户","requestId":"d4166b52-0ac9-490b-a7eb-e88c26179b15"} )
    return false

优化错误提示，然后return false

Night

西瓜没有皮挺好的

DogeJian

太秀了，高！！

懒洋君

贡献一下我的，在前辈基础上，改了点适用于自己的

import cloud from '@lafjs/cloud'
import nw from 'nw-lafjs'

export default async function (ctx: FunctionContext) {
  const db = cloud.database()
  const _ = db.command
  // 请求的实际IP
  const ip = ctx.headers['x-real-ip']
  const requestId = ctx.requestId
  const func = ctx.request.params.name
  // 添加请求IP到数据库，并自动添加 add_time
  await db.collection('requestIp').add({
    requestId: requestId,
    ip: ip,
    func: func,
    createdTime: new Date().toISOString(),
    createdTimestmp: Date.now(),
    lastModifiedTime: new Date().toISOString()
  })
  //获取当前IP的时间段的访问次数
  const interval = 1 // 间隔分钟
  const times = 100 // 间隔Interval分钟内限制最大访问次数
  let timesRes = await nw.db.select({
    dbName: 'requestIp',
    getCount: true,
    pageIndex: 1,
    pageSize: times,
    // 主表where条件
    whereJson: {
      createdTimestmp: _.and(_.gte(Date.now() - interval * 60 * 1000), _.lte(Date.now()))
    }
  })
  if (timesRes.total <= times) {
    // 返回 true 则会去继续请求实际的云函数
    return true
  } else {
    // 返回 false 则不会去继续请求实际的云函数
    ctx.response.status(200);
    ctx.response.json({ "code": 403, "msg": "访问受限，请稍后尝试" })
    return false
  }
}

juukee

import cloud from '@lafjs/cloud'
import moment from 'moment'
const db = cloud.database()
const _ = db.command
const $ = _.aggregate

export async function main(ctx: FunctionContext) {
    const { headers, query, body, params, user, requestId, method, request } = ctx
    // 获取请求的实际IP 
    const ip = headers['x-real-ip'] ? headers['x-real-ip'] : headers['x-forwarded-for']
    if (ip == "null") return false
    // 判断是否在黑名单表，如果在的话直接拒绝请求
    const sys_banIp = db.collection("sys_banIp");
    let banRes = await sys_banIp.where({
        ip: _.eq(ip)
    }).getOne()
    if (banRes.data !== null) {
        ctx.response.status(401)
        ctx.response.json({ "success": false, "message": "黑名单用户，禁止登陆！！！如有问题，请联系管理员！！！", "data": { "error": "Forbidden", "requestId": requestId } })
        return false
    }
    // 获取请求信息
    const user_agent = headers['user-agent']
    const host = headers['host']
    const referer = headers['referer']
    const func = request.params.name
    const sys_requestIp = db.collection("sys_requestIp");
    // 添加请求IP到数据库，并自动添加 add_time
    let requestIp = await sys_requestIp.add({
        req_id: requestId,
        ip: ip,
        host: host,
        user_agent: user_agent,
        referer: referer,
        func: func,
        query: query,
        body: body,
        params: params,
        user: user,
        method: method,
        req_time: moment(new Date()).utcOffset(8).format('YYYY/MM/DD HH:mm:ss')
    })
     // console.log(requestIp)
    //获取当前IP的时间段的访问次数
    const Interval = 1 // 间隔分钟
    const times = 60 // 间隔Interval分钟内限制最大访问次数
    let timesRes = await sys_requestIp.where({
        // 主表where条件
        req_time: _.and(_.gte(Date.now() - Interval * 60 * 1000), _.lte(Date.now()))
    }).count()
    // console.log(timesRes)
    if (timesRes.total <= times) {
        // 返回 true 则会去继续请求实际的云函数
        return true
    } else {
        // 返回 false 则不会去继续请求实际的云函数
        return false
    }
}

更新一下

whhfly2003

juukee 能不能再加个缓存呢？这样每次请求都会去访问数据库，然后才放行吧