什么是限流？
- 限流类似于权限机制，它也决定是否接受当前请求,用于控制客户端在某段时间内允许向API发出请求的次数，也就是频率
假设有客户端(比如爬虫程序)短时间发起大量请求，超过了服务器能够处理的能力，将会影响其他用户的正常使用
为了保证服务的稳定性，并防止接口受到恶意用户的攻击，我们可以对接口进行限流
又或者可以对未经身份验证的请求设置访问频率，对经过身份验证的请求不限制访问频率
限流也不止单指限制访问次数的措施,例如付费数据服务的特点访问次数
限流的应用场景
- 区分用户场景,比如匿名和已登录，不同权限的用户不同的限流策略
API的不同,根据不同API设置不同的策略
请求的爆发期和持续期不同的限流策略
可以同时支持使用多个限流策略
限流的机制
限流和权限一样，执行视图前会依次检查所有的限流类,全部通过会执行View，任何一个检查失败,会抛出Exceptions.Throttled异常
在settings中，通过 DEFAULT_THROTTLE_CLASSES 设置限流类,通过DEFAULT_THROTTLE_RATES设置限流频率
DRF提供的两个常用限流类
AnonRateThrottle:对于匿名用户的限流，使用anon设置频率
UserRateThrottle:对于登录用户的限流, 使用user设置频率
全局限流类配置
REST_FRAMEWORK = {
# 全局限流类的配置
'DEFAULT_THROTTLE_CLASSES': (
'rest_framework.throttling.AnonRateThrottle', # 对于匿名用户的限流
'rest_framework.throttling.UserRateThrottle' #对于登录用户的限流
),
# 限流频率的配置
'DEFAULT_THROTTLE_RATES': {
'anon': '100/day', # 未认证用户一天只许访问100次
'user': '1000/day' # 认证用户一天可以访问1000次
}
}DEFAULT_THROTTLE_RATES设置限流频率格式 次数/时间单位
second: 按秒设置频率次数
minute:按分钟设置频率次数
hour:按小时设置频率次数
day: 按天设置频率次数
视图级别限流类配置
#导入限流模块
from rest_framework import throttling
class getInfoList(ModelViewSet):
# 通过throttle_classes 设置该视图的限流类
# 视图指定会覆盖settings设置的全局限流
throttle_classes = (throttling.UserRateThrottle,)
def infoList(self):
...
识别请求的客户端
我们既然要对请求进行限流，那么肯定要失识 别是谁发来的请求,然后进行对应的措施,不然无法确定请求者身份，那么就无法得知是不是需要限制的请求，常见的方法有三种
- drf利用http报头的 x-forwarded-for 或者wsgi中的remote-addr变量来唯一标识客户端的IP地址
如果 存在x-forwarded-for 属性,则使用x-forwarded-for ,否则使用remote-addr
可以使用request.user的属性来标识请求，比如使用request.user.id 来标记唯一请求
使用IP地址对客户端请求进行限流,需要考虑使用伪造代理IP请求的情况
throttling源码解析
throttling源码一共有五个类
- BaseThrottle: 限流基类
SimpleRateThrottle:频率校验类
AnonRateThrottle:匿名用户限流
UserRateThrottle:认证用户限流
ScopedRateThrottle:api视图级别的限流
BaseThrottle限流基类
没有去具体实现某些功能，跟权限类基类似，只是提供了占位方法
class BaseThrottle:
# allow_request源码并没有直接实现功能，只是写好了方法占位，待后续继承实现
# 该方法主要是处理是否允许请求通过
# 如果后续继承基类实现该方法，允许请求通过返回True，不允许请求通过返回False
def allow_request(self, request, view):
raise NotImplementedError('.allow_request() must be overridden')
# 获取IP地址
def get_ident(self, request):
# 获取请求头中真实IP地址
xff = request.META.get('HTTP_X_FORWARDED_FOR')
# 获取代理IP地址
remote_addr = request.META.get('REMOTE_ADDR')
# 获取设置的允许的最大代理数，默认不设置为None
num_proxies = api_settings.NUM_PROXIES
# 如果num_proxies不是None，说明设置了该值
if num_proxies is not None:
# 如果设置为0，或者 xff没有值
if num_proxies == 0 or xff is None:
# 返回代理IP地址
return remote_addr
#使用代理IP的话会有多个地址，使用逗号分割成一个list
addrs = xff.split(',')
'''
通过min函数，拿到允许的代理数和IP地址长度最小的值，使用-变成负数
在addrs列表中通过该下标取对应值
'''
client_addr = addrs[-min(num_proxies, len(addrs))]
return client_addr.strip()
# 如果没有设置允许的代理数 并且xff有值则直接返回，否则返回remote_addr
return ''.join(xff.split()) if xff else remote_addr
# 等待时间,告诉客户端被限流，等待多久可以访问
# 后续继承实现，可选
def wait(self):
return NoneSimpleRateThrottle
频率控制类,继承了BaseThrottle，添加和重写了一些方法，重点是添加了get_cache_key 方法，但必须自己实现该方法
class SimpleRateThrottle(BaseThrottle):
# 限流需要用到缓存，使用drf默认的缓存
# 如果其他继承类想修改缓存机制，cache = caches['缓存名'] 进行修改
cache = default_cache
# time.time方法，但是并没有()进行实例调用
# 类似计时器功能，在这里留好，后续调用
timer = time.time
# 缓存设置，字符串格式化方法后续传参使用
cache_format = 'throttle_%(scope)s_%(ident)s'
# scope默认没有设置,该值是DEFAULT_THROTTLE_RATES中对应限流类的key
scope = None
# 限流频率默认的配置值
THROTTLE_RATES = api_settings.DEFAULT_THROTTLE_RATES
def __init__(self):
if not getattr(self, 'rate', None):
# 从下面get_rate()方法获取访问频率限制的参数
self.rate = self.get_rate()
# 通过self.parse_rate方法获取限制的频率及持续时间赋值给num_requests
self.num_requests, self.duration = self.parse_rate(self.rate)
# 获取当前请求的标识
def get_cache_key(self, request, view):
raise NotImplementedError('.get_cache_key() must be overridden')
# 获取settings频率设置限流类对应的key
def get_rate(self):
# 如果没有scope，抛出异常
if not getattr(self, 'scope', None):
msg = ("You must set either `.scope` or `.rate` for '%s' throttle" %
self.__class__.__name__)
raise ImproperlyConfigured(msg)
try:
# 从 self.THROTTLE_RATES 中获取设置的scope
return self.THROTTLE_RATES[self.scope]
except KeyError:
msg = "No default throttle rate set for '%s' scope" % self.scope
raise ImproperlyConfigured(msg)
# 获取限流频率设置及持续时间
def parse_rate(self, rate):
# 如果没有设置频率限制，直接返回None
if rate is None:
return (None, None)
# 在settings设置频率我们使用 num/type 设置值
# 字符串使用/分割 ，获取两个对应的值
num, period = rate.split('/')
num_requests = int(num)
#settings中设置时间单位以天为单位可以是day也可以是d
# period[0]获取第一个字符为key，以秒为单位换算，秒就1，分就是60，天就是86400
# 如果需要扩展月、年等时间,可以扩展源码
duration = {'s': 1, 'm': 60, 'h': 3600, 'd': 86400}[period[0]]
# 返回频率和持续时间
return (num_requests, duration)
# 是否允许请求通过，运行返回True，否则返回False
def allow_request(self, request, view):
# 如果没有设置限流频率，直接返回True
if self.rate is None:
return True
# 获取用户标识赋值给self.key
self.key = self.get_cache_key(request, view)
# 没有用户标识直接返回True
if self.key is None:
return True
# 获取历史访问时间戳
self.history = self.cache.get(self.key, [])
# 获取当前时间戳
self.now = self.timer()
# while循环，如果历史访问时间戳有值，拿到历史时间戳[-1]的数据，如果小于等于当前时间戳减去持续时间，弹出最后一个时间戳
# 当前时间-持续时间，就相当于需要限制的时间区间，如果历史时间戳小于等于该区间，才不会继续pop
while self.history and self.history[-1] <= self.now - self.duration:
self.history.pop()
# 如果历史访问时间戳的列表长度大于等于我们设置频率数量，说明到了频率上限
if len(self.history) >= self.num_requests:
# 返回self.throttle_failure 对应False
return self.throttle_failure()
# 返回self.throttle_success 对应True
return self.throttle_success()
# 频率未到达上限时返回该方法
def throttle_success(self):
# 在历史请求时间戳列表，将当前时间插入该列表
self.history.insert(0, self.now)
# 更新缓存内容
self.cache.set(self.key, self.history, self.duration)
# 返回True
return True
# 频率到达上限时返回该方法
def throttle_failure(self):
return False
# 返回还需要多长时间可以进行下一次请求，可选方法
def wait(self):
if self.history:
# 如果历史请求时间戳有值，剩余时间等于持续时间减去（当前时间-第一次请求）
remaining_duration = self.duration - (self.now - self.history[-1])
else:
# 剩余的时间等于持续时间
remaining_duration = self.duration
# 允许请求的次数 等于 允许的次数-已请求的次数+1
available_requests = self.num_requests - len(self.history) + 1
# 如果允许请求的次数小于等于0，返回None
if available_requests <= 0:
return None
return remaining_duration / float(available_requests)AnonRateThrottle
匿名限流类:继承了SimpleRateThrottle，重写了 get_cache_key 方法
AnonRateThrottle 只会限制未经身份验证的用户。传入的请求的IP地址用于生成一个唯一的密钥。
允许的请求频率由以下各项之一确定（按优先顺序）：
- 类的 rate 属性，可以通过继承 AnonRateThrottle 并设置该属性来修改这个值，优先级高
settings配置文件中 DEFAULT_THROTTLE_RATES['anon'] 配置项的值。优先级低
anonratetrottle 适用于想限制来自未知用户的请求频率的情况
class AnonRateThrottle(SimpleRateThrottle):
# 设置频率控制的key为anon
scope = 'anon'
# 重写get_cache_key方法
def get_cache_key(self, request, view):
# 如果请求用户是经过认证的用户，不需要进行限流，直接返回None
if request.user.is_authenticated:
return None
# 如果用户是未经认证的用户，将该类的scope和 用户的IP地址传入SimpleRateThrottle的self.cache_format类属性
return self.cache_format % {
'scope': self.scope,
'ident': self.get_ident(request)
}UserRateThrottle
认证用户限流类:继承了SimpleRateThrottle，仅仅是重写了 get_cache_key 方法
UserRateThrottle 用于限制已认证的用户在整个API中的请求频率。用户ID用于生成唯一的密钥。未经身份验证的请求将使用传入的请求的IP地址生成一个唯一的密钥
允许的请求频率由以下各项之一确定（按优先顺序）：
- 类的 rate 属性，可以通过继承 UserRateThrottle 并设置该属性来修改这个值，优先级高
settings配置文件中 DEFAULT_THROTTLE_RATES['user'] 配置项的值。优先级低
# 设置频率控制的key位anon
scope = 'user'
# 重写get_cache_key方法
def get_cache_key(self, request, view):
if request.user.is_authenticated:
# 如果请求用户是认证用户，设置用户的唯一标识赋值给ident
ident = request.user.pk
else:
#如果请求用户是非认证用户，通过get_ident获取请求ip赋值给ident
ident = self.get_ident(request)
# 设置SimpleRateThrottle中self.cache_format的值
return self.cache_format % {
'scope': self.scope,
'ident': ident
}ScopedRateThrottle
用户对于每个视图的访问频次：继承了SimpleRateThrottle，重写了 get_cache_key 和allow_request 方法
ScopedRateThrottle 类用于限制对APIs特定部分的访问，也就是视图级别的限流，不是全局性的
只有当正在访问的视图包含 throttle_scope 属性时，才会应用此限制。然后，通过将视图的“scope”属性值与唯一的用户ID或IP地址连接，生成唯一的密钥。
允许的请求频率由 scope 属性的值在 DEFAULT_THROTTLE_RATES 中的设置确定
class ScopedRateThrottle(SimpleRateThrottle):
scope_attr = 'throttle_scope'
def __init__(self):
pass
def allow_request(self, request, view):
# 从view获取self.scope_attr赋值给scope，如果view中没有指定，设置为None
self.scope = getattr(view, self.scope_attr, None)
# 如果没有设置scope，直接返回True
if not self.scope:
return True
# 获取settings频率设置限流类对应的key
self.rate = self.get_rate()
# 获取频率限制、持续时长
self.num_requests, self.duration = self.parse_rate(self.rate)
# 调用父类的allow_request 返回对应的结果
return super().allow_request(request, view)
# 获取用户唯一标识
def get_cache_key(self, request, view):
# 如果是认证用户 ident=用户唯一标识
if request.user.is_authenticated:
ident = request.user.pk
else:
# 非认证用户返回请求的ip
ident = self.get_ident(request)
# 设置父类的类属性
return self.cache_format % {
'scope': self.scope,
'ident': ident
}
自定义限流类
上面源码的类，我们一般使用的是后三个，如果源码提供的限流类无法满足我们的需求，我们可以写自定义的限流类
自定义限流类的步骤:
- 继承BaseThrottle类或者根据场景继承其他限流类
实现allow_request方法，如果请求被允许，那么返回True，否则返回False
wait方法，是否实现根据自己场景
获取唯一标识的方法可以使用源码自由的，也可以自定义
场景案例1
假设我们的请求需要同时进行多个认证用户的限流措施，比如每小时限制100次，同时每天限制1000次
# 每小时的限流类
class UserHourRateThrottle(UserRateThrottle):
scope = 'userHour'
# 每天的限流类
class UserDayRateThrottle(UserRateThrottle):
scope = 'userDay' # settings中进行配置
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_CLASSES': (
# 配置我们自定义的限流类或者再view中进行局部的配置
'testApi.throttles.UserHourRateThrottle',
'testApi.throttles.UserDayRateThrottle'
),
'DEFAULT_THROTTLE_RATES': {
'userHour': '100/hour', # 每小时最多100次
'userDay': '1000/day' # 每天最多100次
}
}场景案例2
随机限制
import random
class RandomRateThrottle(throttling.BaseThrottle):
def allow_request(self, request, view):
# 如果随机的数字 不等于1，返回True，否则返回False
return random.randint(1, 10) != 1
# 之后在settings进行配置或者局部配置
