45.限流Throttling及源码解析

什么是限流？

限流类似于权限机制，它也决定是否接受当前请求,用于控制客户端在某段时间内允许向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 None

SimpleRateThrottle

频率控制类,继承了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进行配置或者局部配置