1. API速率限制的基本概念

API速率限制（Rate Limiting）是控制用户访问API的请求速率的一种机制，防止系统被过多请求淹没。通过对用户的请求进行计数与限制，API能够在高并发情况下维持性能与稳定性。
速率限制的主要目的是：

• 防止过多请求导致服务器负载过高。
  
• 限制恶意或非正常行为。
  
• 提高API的可用性，确保公平分配资源。
  

常见的速率限制算法
1.漏桶算法（Leaky Bucket Algorithm）
漏桶算法在一定时间窗口内以固定速率处理请求，若请求速率超过预定限度，则会被丢弃或延迟。
2.令牌桶算法（Token Bucket Algorithm）
令牌桶算法是一种灵活的速率控制机制，适合处理突发流量。每个请求都需要获取一个令牌，如果令牌桶为空，则请求被丢弃。
3.固定窗口计数法（Fixed Window Counter）
在固定时间窗口内，计数器记录请求的次数，一旦请求超出限制，后续请求将被拒绝。
4.滑动窗口计数法（Sliding Window Counter）
滑动窗口比固定窗口更加精细，每个请求都在一个滑动的时间窗口内进行计数，能平滑流量控制。
通过这些算法，API能够控制不同用户或客户端在指定时间内发起的请求数量，确保系统的平稳运行。

2. Redis实现分布式速率限制

Redis是一个高性能的键值数据库，广泛用于缓存、消息队列和分布式速率限制等场景。在分布式系统中，Redis提供了高效的数据存储和共享机制，可以帮助不同服务器实例共享请求计数信息，从而实现跨服务器的速率限制。
Redis的实现思路
我们使用Redis的SETEX命令设置一个键值对，其中键为用户标识（例如IP或用户ID），值为请求计数。每次用户发起请求时，我们先检查该键是否存在。如果存在，检查其值是否超过限额；如果不存在，设置新的键并开始计数。通过设置键的过期时间，可以实现速率限制。
示例代码

1. from fastapi import FastAPI, Request, HTTPException
   
2. import redis
   
3. import time
   
4. 
   
5. app = FastAPI()
   
6. 
   
7. # 连接Redis服务器
   
8. r = redis.Redis(host='localhost', port=6379, db=0)
   
9. 
   
10. # 限制参数
    
11. LIMIT = 100  # 每分钟100次请求
    
12. TIME_WINDOW = 60  # 1分钟
    
13. 
    
14. @app.middleware("http")
    
15. async def rate_limit(request: Request, call_next):
    
16.     ip_address = request.client.host
    
17.     current_time = int(time.time())
    
18.    
    
19.     # 构造Redis的键
    
20.     redis_key = f"rate_limit:{ip_address}:{current_time // TIME_WINDOW}"
    
21.    
    
22.     # 使用Redis的INCR命令增加计数
    
23.     request_count = r.incr(redis_key)
    
24.    
    
25.     if request_count == 1:
    
26.         # 设置过期时间为60秒（时间窗口大小）
    
27.         r.expire(redis_key, TIME_WINDOW)
    
28.    
    
29.     if request_count > LIMIT:
    
30.         raise HTTPException(status_code=429, detail="Too many requests")
    
31.    
    
32.     response = await call_next(request)
    
33.     return response

复制代码

代码解析

• r.incr(redis_key)：Redis的INCR命令可以原子性地递增键的值。如果键不存在，它会先创建键并设置初值为1。
  
• r.expire(redis_key, TIME_WINDOW)：设置键的过期时间，使得计数在每个时间窗口内自动重置。
  
• 429 Too Many Requests：当请求次数超过限制时，返回429状态码表示超出请求频率限制。
  

这种方式可以有效防止单个IP地址在短时间内发送过多请求，保障API的可用性与性能。

3. 防止DDoS攻击的常见策略

DDoS（Distributed Denial of Service）攻击通过大量恶意请求淹没目标服务器，导致系统不可用。为了防止这种攻击，除了传统的防火墙和负载均衡策略外，我们还需要在API层面实现防护。
常见的防御策略
1.IP黑名单/白名单
基于IP的访问控制可以有效阻止已知攻击源的流量。通过将恶意IP加入黑名单，可以防止这些IP的请求进入系统。
2.请求速率限制
利用速率限制算法（如漏桶或令牌桶），控制请求频率，避免单个来源发送过多请求。
3.行为分析与智能防护
通过分析请求的行为模式，识别并阻止异常流量。例如，检测异常的请求头、请求频率、请求路径等。
4.验证码与身份验证
在用户请求的关键环节，如登录、注册、支付等，加入验证码或二次身份验证，防止恶意机器人自动化攻击。
示例代码：基于IP的速率限制和验证码

1. from fastapi import FastAPI, HTTPException, Request
   
2. from fastapi.responses import JSONResponse
   
3. from pydantic import BaseModel
   
4. import redis
   
5. import time
   
6. import random
   
7. 
   
8. app = FastAPI()
   
9. 
   
10. r = redis.Redis(host='localhost', port=6379, db=0)
    
11. LIMIT = 100
    
12. TIME_WINDOW = 60
    
13. CAPTCHA_THRESHOLD = 10
    
14. 
    
15. @app.post("/login")
    
16. async def login(request: Request, user: BaseModel):
    
17.     ip_address = request.client.host
    
18.     current_time = int(time.time())
    
19.    
    
20.     redis_key = f"rate_limit:{ip_address}:{current_time // TIME_WINDOW}"
    
21.     request_count = r.incr(redis_key)
    
22.    
    
23.     if request_count == 1:
    
24.         r.expire(redis_key, TIME_WINDOW)
    
25.    
    
26.     if request_count > LIMIT:
    
27.         # 启动验证码机制
    
28.         captcha = random.randint(1000, 9999)
    
29.         return JSONResponse(content={"captcha_required": True, "captcha": captcha}, status_code=400)
    
30.    
    
31.     return {"message": "Login successful"}

复制代码

代码解析
当请求频率超过限制时，返回一个验证码，用户需要通过验证码验证来继续操作。
这种方式有效阻止了自动化攻击，减少了恶意请求的成功率。

4. 基于IP或用户身份的访问频率控制

除了全局的速率限制外，还可以根据IP地址或用户身份来单独限制访问频率。通过这种方法，可以更精细化地控制API的访问权限，避免某个特定用户或IP占用过多资源。
示例代码：基于用户身份的访问频率控制

1. from fastapi import Depends, HTTPException, Request
   
2. from pydantic import BaseModel
   
3. 
   
4. @app.get("/user_dashboard")
   
5. async def user_dashboard(user_id: str, request: Request):
   
6.     user_limit_key = f"user:{user_id}:rate_limit"
   
7.     ip_limit_key = f"ip:{request.client.host}:rate_limit"
   
8.    
   
9.     # 用户访问频率限制
   
10.     user_request_count = r.incr(user_limit_key)
    
11.     if user_request_count == 1:
    
12.         r.expire(user_limit_key, TIME_WINDOW)
    
13.    
    
14.     if user_request_count > LIMIT:
    
15.         raise HTTPException(status_code=429, detail="User request limit exceeded")
    
16.    
    
17.     # IP访问频率限制
    
18.     ip_request_count = r.incr(ip_limit_key)
    
19.     if ip_request_count == 1:
    
20.         r.expire(ip_limit_key, TIME_WINDOW)
    
21.    
    
22.     if ip_request_count > LIMIT:
    
23.         raise HTTPException(status_code=429, detail="IP request limit exceeded")
    
24.    
    
25.     return {"message": "Welcome to the user dashboard"}

复制代码

代码解析
user_id：每个用户有独立的请求计数，防止某个用户滥用API。
request.client.host：IP地址的请求计数，防止同一个IP地址滥用API。
根据用户和IP的访问频率分别设置限制，提高了控制精度。
到此这篇关于使用Redis实现请求限制与速率限制的文章就介绍到这了,更多相关Redis请求限制与速率限制内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：https://www.jb51.net/database/3393576ft.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！