Redis의 현재 제한 전략에 대해 설명하는 기사

이 기사에서는 Redis의 전류 제한을 이해하고 간단한 전류 제한 전략과 퍼널 전류 제한을 소개합니다. 이 글이 모든 사람에게 도움이 되기를 바랍니다.

1. 단순 전류 제한

기본 원칙

시스템 처리 용량이 제한될 때 계획되지 않은 요청을 정리하여 시스템에 압력을 가하는 방법. 먼저, 무차별 대입 공격을 방지하기 위한 몇 가지 간단한 전류 제한 전략을 살펴보겠습니다. 예를 들어, 특정 IP에 접근을 원할 경우 5초에 10번만 접근이 가능하며, 한도를 초과하면 차단됩니다. [관련 추천 : Redis 영상 튜토리얼]

위에서 보듯이 슬라이딩 윈도우는 일반적으로 간격 내 방문 횟수를 계산하는 데 사용됩니다. zset를 사용하여 IP 방문 횟수를 기록하세요. 각 IP는 key와 score 현재 타임스탬프를 저장합니다. <code>값은 타임스탬프 또는 UUIDzset 记录 IP 访问次数，每个 IP 通过 key 保存下来，score 保存当前时间戳，value 唯一用时间戳或者UUID来实现

代码实现

public class RedisLimiterTest {
    private Jedis jedis;

    public RedisLimiterTest(Jedis jedis) {
        this.jedis = jedis;
    }

    /**
     * @param ipAddress Ip地址
     * @param period    特定的时间内，单位秒
     * @param maxCount  最大允许的次数
     * @return
     */
    public boolean isIpLimit(String ipAddress, int period, int maxCount) {
        String key = String.format("ip:%s", ipAddress);
        // 毫秒时间戳
        long currentTimeMillis = System.currentTimeMillis();
        Pipeline pipe = jedis.pipelined();
        // redis事务，保证原子性
        pipe.multi();
        // 存放数据，value 和 score 都使用毫秒时间戳
        pipe.zadd(key, currentTimeMillis, "" + UUID.randomUUID());
        // 移除窗口区间所有的元素
        pipe.zremrangeByScore(key, 0, currentTimeMillis - period * 1000);
        // 获取时间窗口内的行为数量
        Response<Long> count = pipe.zcard(key);
        // 设置 zset 过期时间，避免冷用户持续占用内存，这里宽限1s
        pipe.expire(key, period + 1);
        // 提交事务
        pipe.exec();
        pipe.close();
        // 比较数量是否超标
        return count.get() > maxCount;
    }

    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        RedisLimiterTest limiter = new RedisLimiterTest(jedis);
        for (int i = 1; i <= 20; i++) {
            // 验证IP  10秒钟之内只能访问5次
            boolean isLimit = limiter.isIpLimit("222.73.55.22", 10, 5);
            System.out.println("访问第" + i + "次, 结果：" + (isLimit ? "限制访问" : "允许访问"));
        }
    }
}

执行结果

访问第1次, 结果：允许访问
访问第2次, 结果：允许访问
访问第3次, 结果：允许访问
访问第4次, 结果：允许访问
访问第5次, 结果：允许访问
访问第6次, 结果：限制访问
访问第7次, 结果：限制访问
... ...

缺点：要记录时间窗口所有的行为记录，量很大，比如，限定60s内不能超过100万次这种场景，不太适合这样限流，因为会消耗大量的储存空间。

二、漏斗限流

基本原理

• 漏斗的容量是限定的，如果满了，就装不进去了。
• 如果将漏嘴放开，水就会往下流，流走一部分之后，就又可以继续往里面灌水。
• 如果漏嘴流水的速率大于灌水的速率，那么漏斗永远都装不满。
• 如果漏嘴流水速率小于灌水的速率，那么一旦漏斗满了，灌水就需要暂停并等待漏斗腾空。

示例代码

public class FunnelLimiterTest {

    static class Funnel {
        int capacity; // 漏斗容量
        float leakingRate; // 漏嘴流水速率
        int leftQuota; // 漏斗剩余空间
        long leakingTs; // 上一次漏水时间

        public Funnel(int capacity, float leakingRate) {
            this.capacity = capacity;
            this.leakingRate = leakingRate;
            this.leftQuota = capacity;
            this.leakingTs = System.currentTimeMillis();
        }

        void makeSpace() {
            long nowTs = System.currentTimeMillis();
            long deltaTs = nowTs - leakingTs; // 距离上一次漏水过去了多久
            int deltaQuota = (int) (deltaTs * leakingRate); // 腾出的空间 = 时间*漏水速率
            if (deltaQuota < 0) { // 间隔时间太长，整数数字过大溢出
                this.leftQuota = capacity;
                this.leakingTs = nowTs;
                return;
            }
            if (deltaQuota < 1) { // 腾出空间太小 就等下次，最小单位是1
                return;
            }
            this.leftQuota += deltaQuota; // 漏斗剩余空间 = 漏斗剩余空间 + 腾出的空间
            this.leakingTs = nowTs;
            if (this.leftQuota > this.capacity) { // 剩余空间不得高于容量
                this.leftQuota = this.capacity;
            }
        }

        boolean watering(int quota) {
            makeSpace();
            if (this.leftQuota >= quota) { // 判断剩余空间是否足够
                this.leftQuota -= quota;
                return true;
            }
            return false;
        }
    }

    // 所有的漏斗
    private Map<String, Funnel> funnels = new HashMap<>();

    /**
     * @param capacity    漏斗容量
     * @param leakingRate 漏嘴流水速率 quota/s
     */
    public boolean isIpLimit(String ipAddress, int capacity, float leakingRate) {
        String key = String.format("ip:%s", ipAddress);
        Funnel funnel = funnels.get(key);
        if (funnel == null) {
            funnel = new Funnel(capacity, leakingRate);
            funnels.put(key, funnel);
        }
        return !funnel.watering(1); // 需要1个quota
    }

    public static void main(String[] args) throws Exception{
        FunnelLimiterTest limiter = new FunnelLimiterTest();
        for (int i = 1; i <= 50; i++) {
            // 每1s执行一次
            Thread.sleep(1000);
            // 漏斗容量是2 ，漏嘴流水速率是0.5每秒，
            boolean isLimit = limiter.isIpLimit("222.73.55.22", 2, (float)0.5/1000);
            System.out.println("访问第" + i + "次, 结果：" + (isLimit ? "限制访问" : "允许访问"));
        }
    }
}

执行结果

访问第1次, 结果：允许访问    # 第1次，容量剩余2，执行后1
访问第2次, 结果：允许访问    # 第2次，容量剩余1，执行后0
访问第3次, 结果：允许访问    # 第3次，由于过了2s, 漏斗流水剩余1个空间，所以容量剩余1，执行后0
访问第4次, 结果：限制访问    # 第4次，过了1s, 剩余空间小于1， 容量剩余0
访问第5次, 结果：允许访问    # 第5次，由于过了2s, 漏斗流水剩余1个空间，所以容量剩余1，执行后0
访问第6次, 结果：限制访问    # 以此类推...
访问第7次, 结果：允许访问
访问第8次, 结果：限制访问
访问第9次, 结果：允许访问
访问第10次, 结果：限制访问

• 我们观察 Funnel 对象的几个字段，我们发现可以将 Funnel 对象的内容按字段存储到一个 hash 结构中，灌水的时候将 hash 结构的字段取出来进行逻辑运算后，再将新值回填到 hash 结构中就完成了一次行为频度的检测。
• 但是有个问题，我们无法保证整个过程的原子性。从 hash 结构中取值，然后在内存里运算，再回填到 hash 结构，这三个过程无法原子化，意味着需要进行适当的加锁控制。而一旦加锁，就意味着会有加锁失败，加锁失败就需要选择重试或者放弃。
• 如果重试的话，就会导致性能下降。如果放弃的话，就会影响用户体验。同时，代码的复杂度也跟着升高很多。这真是个艰难的选择，我们该如何解决这个问题呢？Redis-Cell 救星来了！

Redis-Cell

Redis 4.0 提供了一个限流 Redis 模块，它叫 redis-cell

cl.throttle，它的参数和返回值都略显复杂，接下来让我们来看看这个指令具体该如何使用。

> cl.throttle key:xxx 15 30 60 1

• 15 : 15 capacity 这是漏斗容量
• 30 60 : 30 operations / 60 seconds 这是漏水速率
• 1 : need 1 quota (可选参数，默认值也是1)

> cl.throttle laoqian:reply 15 30 60
1) (integer) 0   # 0 表示允许，1表示拒绝
2) (integer) 15  # 漏斗容量capacity
3) (integer) 14  # 漏斗剩余空间left_quota
4) (integer) -1  # 如果拒绝了，需要多长时间后再试(漏斗有空间了，单位秒)
5) (integer) 2   # 多长时间后，漏斗完全空出来(left_quota==capacity，单位秒)

在执行限流指令时，如果被拒绝了，就需要丢弃或重试。cl.throttle 指令考虑的非常周到，连重试时间都帮你算好了，直接取返回结果数组的第四个值进行 sleep코드 구현

rrreee실행 결과

🎜rrreee를 통해서만 구현됩니다. blockquote >🎜단점: 시간 창에 모든 행동 기록을 기록해야 하는데, 이는 매우 큰 시간입니다. 예를 들어 60초에 횟수를 100만 번으로 제한하는 것은 1회를 소모하기 때문에 적합하지 않습니다. 많은 저장 공간. 🎜

2. 퍼널 전류 제한 🎜

🎜기본 원칙🎜🎜

• 깔때기는 제한되어 있어 가득 차면 들어갈 수 없습니다.
• 주둥이를 놓으면 물이 아래로 흘러 일부가 흘러나간 후 계속 물을 채울 수 있습니다.
• 주둥이에서 나오는 물의 유속이 물을 채우는 속도보다 크면 깔때기가 가득 차지 않습니다.
• 깔때기의 유속이 충전 속도보다 낮으면 깔때기가 가득 차면 충전을 일시 중지하고 깔때기가 비워질 때까지 기다려야 합니다.

🎜샘플 코드🎜🎜rrreee🎜🎜실행 결과🎜🎜rrreee

• Funnel을 관찰합니다 object 여러 필드에서 Funnel 개체의 콘텐츠가 필드별로 hash 구조에 저장될 수 있음을 발견했습니다. 논리 연산을 위해 필드를 가져온 후 새 값이 해시 구조에 백필되어 동작 빈도 감지가 완료됩니다.
• 그러나 문제가 있습니다. 전체 프로세스의 원자성을 보장할 수 없다는 점입니다. hash 구조에서 값을 가져온 다음 이를 메모리에서 작동시킨 다음 hash 구조에 다시 채웁니다. 이 세 가지 프로세스는 원자적일 수 없습니다. 즉, 적절한 잠금이 가능합니다. 통제가 필요합니다. 잠금이 잠기면 잠금이 실패한다는 의미입니다. 잠금이 실패하면 다시 시도하거나 포기해야 합니다.
• 다시 시도하면 성능이 저하됩니다. 포기하면 사용자 경험에 영향을 미칩니다. 동시에 코드의 복잡성도 많이 증가했습니다. 이것은 정말 어려운 선택입니다. 이 문제를 어떻게 해결합니까? Redis-Cell 구세주가 여기 있습니다!

🎜Redis-Cell🎜🎜🎜Redis 4.0은 redis-cell이라는 현재 제한된 Redis 모듈을 제공합니다. 이 모듈은 또한 깔대기 알고리즘을 사용하고 원자 전류 제한 지침을 제공합니다. 이 모듈에는 명령 cl.throttle이 하나만 있고 해당 매개변수와 반환 값이 약간 복잡합니다. 다음으로 이 명령을 사용하는 방법을 살펴보겠습니다. 🎜rrreee

• 15 : 15 용량 이게 깔때기 용량이에요
• 30 60 : 30회 작업 / 60초 이게 물이에요 누출률
• 1 : 1개의 할당량이 필요합니다(선택적 매개변수, 기본값도 1입니다)

rrreee🎜현재 제한 명령을 실행할 때, 거부되었습니다. 삭제하거나 다시 시도해야 합니다. cl.throttle 명령은 매우 사려 깊고 재시도 시간까지 계산해 줍니다. 반환된 결과 배열의 네 번째 값을 가져와서 sleep을 수행하세요. 스레드를 차단하고 싶지 않다면 비동기 예약 작업으로 다시 시도할 수도 있습니다. 🎜🎜더 많은 프로그래밍 관련 지식을 보려면 🎜프로그래밍 비디오🎜를 방문하세요! ! 🎜

위 내용은 Redis의 현재 제한 전략에 대해 설명하는 기사의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!