弹性工程中4种不同的速率限制策略

export const rateLimitMiddleware = (
req: express.Request,
res: express.Response,
next: express.NextFunction
) => {
const ip = req.ip
if (!ip) {
  res.status(500).send('No IP address found on request')
  return
}

const currentTime = Date.now()

if (!counters.has(ip)) {
  counters.set(ip, { count: 1, startTime: currentTime })
  next()
  return
}

const windowCounter = counters.get(ip)

if (windowCounter) {
  const difference = currentTime - windowCounter.startTime
  const isGreaterThanWindow = difference > rateLimitWindowInMs

  if (isGreaterThanWindow) {
    // Reset the counter for the new window
    windowCounter.count = 1
    windowCounter.startTime = currentTime
    next()
  } else if (windowCounter.count < requestLimitPerWindow) {
    // Increment the counter and allow the request
    windowCounter.count++
    next()
  } else {
    // Rate limit exceeded
    res.status(429).send('Too Many Requests')
  }
}
}

export const rateLimitMiddleware = (
req: express.Request,
res: express.Response,
next: express.NextFunction
) => {
const ip = req.ip
if (!ip) {
  res.status(500).send('No IP address found on request')
  return
}

if (!requestLogs.has(ip)) {
  requestLogs.set(ip, { timestamps: [Date.now()] })
  next()
  return
}

const currentTime = Date.now()
const log = requestLogs.get(ip)

if (log) {
  log.timestamps = log.timestamps.filter((timestamp) => {
    const difference = currentTime - timestamp
    const isWithinWindow = difference <= slidingWindowInMs

    return isWithinWindow
  })

  if (log.timestamps.length < requestThreshold) {
    // Allow request
    log.timestamps.push(currentTime)

    next()
  } else {
    // Rate limit exceeded
    res.status(429).send('Too Many Requests')
  }
}
}

export const rateLimitMiddleware = (
req: express.Request,
res: express.Response,
next: express.NextFunction
) => {
const ip = req.ip
if (!ip) {
  res.status(500).send('No IP address found on request')
  return
}

if (!requestLogs.has(ip)) {
  requestLogs.set(ip, { counter: 1, lastRequestTimestamp: Date.now() })
  next()
  return
}

const currentTime = Date.now()
const log = requestLogs.get(ip)

if (log) {
  const timeElapsed = currentTime - log.lastRequestTimestamp
  const shouldResetCounter = timeElapsed > slidingWindowInMs

  if (shouldResetCounter) {
    log.counter = 1
  } else {
    // Calculate the decrement amount based on the time elapsed
    // Example: Sliding window is 60 seconds, in milliseconds that is 60000
    // reqThreshold is 10
    // This equals to 60000 / 10 = 6000
    // Let's say timeElapsed is 30000, that means 30 seconds have passed
    // 30000 / 6000 = 5
    // So we decrement the counter by 5
    // This effectively calculates the number of requests that are outside of the sliding window
    // Those requests are no longer counted towards the rate limit (expired)
    const decrementAmount = Math.floor(
      timeElapsed / (slidingWindowInMs / requestThreshold)
    )

    // `Math.max` is used to ensure the counter never goes below 0
    log.counter = Math.max(0, log.counter - decrementAmount)
  }

  log.lastRequestTimestamp = currentTime

  const shouldBlockRequest = log.counter >= requestThreshold
  if (shouldBlockRequest) {
    res.status(429).send('Too many requests')
    return
  }

  log.counter++
  next()
}
}

// Class
export class TokenBucket {
capacity: number
tokens: number
refillRatePerSeconds: number
lastRefill: number

constructor(capacity: number, refillRate: number) {
  this.capacity = capacity
  this.tokens = capacity
  this.refillRatePerSeconds = refillRate
  this.lastRefill = Date.now()
}

refill() {
  const now = Date.now()
  const timeSinceLastRefillInSeconds =
    (now - this.lastRefill) / SECONDS_CONVERSION

  // Add new tokens to the bucket since the last refill
  // Example: 10 tokens per second, 5 seconds since last refill = 50 new tokens
  // But don't exceed the capacity of the bucket
  // This way, if the bucket is not used for a long time, it will not be overflowing with tokens
  const newTokens = timeSinceLastRefillInSeconds * this.refillRatePerSeconds
  this.tokens = Math.min(this.capacity, this.tokens + newTokens)
  this.lastRefill = now
}

allowRequest(): boolean {
  this.refill()
  if (this.tokens >= 1) {
    this.tokens -= 1
    return true
  }
  return false
}
}

// Usage
const buckets = new Map<string, TokenBucket>()

export const rateLimitMiddleware = (
req: express.Request,
res: express.Response,
next: express.NextFunction
) => {
const ip = req.ip

if (!ip) {
  res.status(500).send('No IP address found on request')
  return
}

const hasIpNoBucket = !buckets.has(ip)
if (hasIpNoBucket) {
  buckets.set(ip, new TokenBucket(10, 1)) // Example: 10 tokens, refill 1 token/sec
}

const bucket = buckets.get(ip)
if (bucket && bucket.allowRequest()) {
  next()
} else {
  res.status(429).send('Too Many Requests')
}
}