首页手记 Sentinel限流资料入门详解

Sentinel限流资料入门详解

标签：

Spring Cloud 运维工具中间件

概述

本文介绍了Sentinel限流资料，包括Sentinel的基本概念、主要功能和应用场景，详细讲解了Sentinel的限流配置教程、实战案例及常见问题的解决方法。Sentinel是一款由阿里巴巴开源的轻量级分布式服务保护框架，广泛应用于微服务架构中的流量控制和系统保护。

Sentinel简介

什么是Sentinel

Sentinel是阿里巴巴开源的一款轻量级分布式服务保护框架，主要用于保障高可用性。它能够对微服务架构中的流量进行控制和保护。Sentinel具有广泛的适用范围，适用于各种微服务架构和不同规模的应用场景。Sentinel的设计目标是提供简单易用、高可用且高性能的流量控制和系统保护功能。

Sentinel的主要功能

Sentinel的主要功能包括流量控制、系统负载保护、热点防护和异常检测。在流量控制方面，Sentinel可以根据流量大小、请求频率和时间窗口等因素限制流量，避免服务因过载请求而崩溃；在系统负载保护方面，Sentinel可以根据CPU使用率和内存使用率等系统负载指标保护系统，防止系统资源耗尽；在热点防护方面，Sentinel可以根据热点数据的访问频率限制热点数据的访问，避免其被频繁访问导致系统负载过高；在异常检测方面，Sentinel可以监控服务调用链路中的异常情况并采取保护措施，防止异常影响整个系统的可用性。

Sentinel应用场景

Sentinel在微服务架构中有着广泛的应用场景。例如，在电商网站中，Sentinel可以用来保护商品详情页的访问，在大促期间防止因访问量过大导致服务器过载。在金融行业中，Sentinel可以用来保护交易系统的流量，在交易高峰期防止因流量过大导致系统不可用。在物流行业中，Sentinel可以用来保护订单系统的流量，在订单高峰期防止因流量过大导致系统崩溃。

Sentinel的应用场景还包括但不限于：

保护服务接口免受异常请求的冲击。
限制服务接口的流量，避免因流量过大导致系统过载。
实现热点数据访问控制，防止热点数据被频繁访问导致系统负载过高。
监控服务调用链路中的异常情况并采取保护措施，防止异常影响整个系统的可用性。
实现负载均衡，确保各服务节点之间的负载均衡。

Sentinel限流基础概念

限流的目的和意义

限流的主要目的是保护系统，在流量突然增大时防止系统崩溃。通过合理设置流量限制，可以有效地保护系统资源，防止资源耗尽。限流还可以提高系统的稳定性，防止因流量过大导致的系统不可用。通过合理的流量限制，可以有效地控制系统的流量，避免系统因流量过大而过载。

常见的限流策略介绍

常见的限流策略包括：

令牌桶算法：令牌桶算法是一种常用的限流算法，其核心思想是在令牌桶中预先存储一定量的令牌，令牌的生成速度固定。当请求到来时，如果桶中有令牌，则允许请求通过并消耗一个令牌，否则拒绝请求。
漏桶算法：漏桶算法也是一种常用的限流算法，其核心思想是令牌的生成速度固定，当请求到来时，如果桶中有令牌，则允许请求通过并消耗一个令牌，否则拒绝请求。
计数器算法：计数器算法是一种简单的限流算法，其核心思想是维护一个计数器，当请求到来时，计数器的值加1，当计数器的值超过阈值时，拒绝请求。
滑动窗口算法：滑动窗口算法是一种基于时间窗口的限流算法，其核心思想是在每个时间窗口内统计请求的数量，当请求的数量超过阈值时，拒绝请求。

限流策略代码示例

以下是一些限流策略的代码示例：

令牌桶算法示例

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class TokenBucketExample {

    static {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("exampleService");
        rule.setGrade(RuleConstant.FLOW_GRADE_TOKEN_BUCKET);
        rule.setCount(10);
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule);

        FlowRuleManager.loadRules(rules);
    }

    public void exampleService() throws BlockException {
        try (Entry entry = SphU.entry("exampleService")) {
            // 业务逻辑代码
            System.out.println("Service is called.");
        }
    }
}

漏桶算法示例

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class LeakyBucketExample {

    static {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("exampleService");
        rule.setGrade(RuleConstant.FLOW_GRADE_LEAKY_BUCKET);
        rule.setCount(10);
        rule.setBurstCount(20);
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule);

        FlowRuleManager.loadRules(rules);
    }

    public void exampleService() throws BlockException {
        try (Entry entry = SphU.entry("exampleService")) {
            // 业务逻辑代码
            System.out.println("Service is called.");
        }
    }
}

计数器算法示例

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class CounterExample {

    static {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("exampleService");
        rule.setGrade(RuleConstant.FLOW_GRADE_CIRCUIT);
        rule.setCount(10);
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule);

        FlowRuleManager.loadRules(rules);
    }

    public void exampleService() throws BlockException {
        try (Entry entry = SphU.entry("exampleService")) {
            // 业务逻辑代码
            System.out.println("Service is called.");
        }
    }
}

滑动窗口算法示例

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

public class SlidingWindowExample {

    static {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("exampleService");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule);

        FlowRuleManager.loadRules(rules);
    }

    public void exampleService() throws BlockException {
        try (Entry entry = SphU.entry("exampleService")) {
            // 业务逻辑代码
            System.out.println("Service is called.");
        }
    }
}

Sentinel限流配置教程

初始环境搭建与依赖配置

为了使用Sentinel进行限流配置，首先需要在项目中引入Sentinel的依赖。

使用Maven引入依赖：

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.8.4</version>
</dependency>
<dependency>
    <groupId>com.alibaba.csp</groupId>
   .<artifactId>sentinel-transport-simple-http</artifactId>
    <version>1.8.4</version>
</dependency>

使用Gradle引入依赖：

implementation 'com.alibaba.csp:sentinel-core:1.8.4'
implementation 'com.alibaba.csp:sentinel-transport-simple-http:1.8.4'

实战：使用Sentinel进行简单的限流配置

接下来，通过一个简单的示例演示如何使用Sentinel进行限流配置。假设我们有一个服务需要对某个接口进行限流，以防止在流量过大时服务崩溃。

创建一个简单的服务：

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

import java.util.ArrayList;
import java.util.List;

public class SimpleService {

    static {
        // 初始化限流规则
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("testService");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule);

        FlowRuleManager.loadRules(rules);
    }

    public void testService() throws BlockException {
        try (Entry entry = SphU.entry("testService")) {
            // 业务逻辑代码
            System.out.println("Service is called.");
        }
    }

    public static void main(String[] args) throws BlockException {
        SimpleService service = new SimpleService();
        service.testService();
    }
}

解释代码：
- FlowRule：定义限流规则，包括资源名称、限流类型、限流阈值等。
- FlowRuleManager.loadRules(rules)：加载限流规则。
- SphU.entry("testService")：进入资源，如果超出限流阈值，会抛出BlockException。
运行代码：
当请求量超过QPS（每秒请求数）阈值时，请求会被阻塞。例如，如果设置的阈值为每秒10个请求，那么每秒超过10个请求时，请求会被拒绝。

更复杂的配置示例

除了简单的限流配置，还可以进行更复杂的配置，例如配置不同的限流规则和集成到不同框架中。

配置不同的限流规则：

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

import java.util.ArrayList;
import java.util.List;

public class ComplexConfigExample {

    static {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule1 = new FlowRule();
        rule1.setResource("resource1");
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule1.setCount(15);
        rule1.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule1);

        FlowRule rule2 = new FlowRule();
        rule2.setResource("resource2");
        rule2.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule2.setCount(20);
        rule2.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule2);

        FlowRuleManager.loadRules(rules);
    }

    public void exampleService() throws BlockException {
        try (Entry entry = SphU.entry("resource1")) {
            // 业务逻辑代码
            System.out.println("Service is called.");
        }
    }

    public static void main(String[] args) throws BlockException {
        ComplexConfigExample example = new ComplexConfigExample();
        example.exampleService();
    }
}

集成到Spring Boot中：

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

import java.util.ArrayList;
import java.util.List;

@RestController
public class SpringBootExampleController {

    @SentinelResource(value = "exampleService", blockHandler = "handleBlock")
    public String exampleService() {
        // 业务逻辑代码
        return "Service is called.";
    }

    public String handleBlock(BlockException ex) {
        return "Blocked by Sentinel, cause: " + ex;
    }

    static {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("exampleService");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule);

        FlowRuleManager.loadRules(rules);
    }
}

Sentinel限流实战案例

异常峰值限流

异常峰值限流是指在异常请求量激增时，通过限流来保护系统，避免服务崩溃。假设我们有一个服务，需要在异常请求量激增时进行限流。

创建一个服务：

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

import java.util.ArrayList;
import java.util.List;

public class AnomalyPeakService {

    static {
        // 初始化限流规则
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("testService");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule);

        FlowRuleManager.loadRules(rules);
    }

    public void testService() throws BlockException {
        try (Entry entry = SphU.entry("testService")) {
            // 业务逻辑代码
            System.out.println("Service is called.");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        AnomalyPeakService service = new AnomalyPeakService();
        for (int i = 0; i < 20; i++) {
            service.testService();
            Thread.sleep(100); // 模拟请求间隔
        }
    }
}

解释代码：
- FlowRule：设置每秒请求量阈值为10。
- SphU.entry("testService")：进入资源，如果超出阈值，会抛出BlockException。
- Thread.sleep(100)：模拟请求间隔，每100毫秒发送一次请求。
运行代码：
当请求量超过每秒10次时，多余的请求会被拒绝。例如，在上述代码中，每秒发送20次请求，超过阈值的10次请求会被拒绝。

流量入口限流

流量入口限流是指在流量入口处进行限流，以防止流量过大导致服务崩溃。假设我们有一个服务，需要在流量入口处进行限流。

创建一个服务：

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;

import java.util.ArrayList;
import java.util.List;

public class EntryTrafficService {

    static {
        // 初始化限流规则
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("entryService");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        rules.add(rule);

        FlowRuleManager.loadRules(rules);
    }

    public void entryService() throws BlockException {
        try (Entry entry = SphU.entry("entryService")) {
            // 业务逻辑代码
            System.out.println("Service is called.");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        EntryTrafficService service = new EntryTrafficService();
        for (int i = 0; i < 20; i++) {
            service.entryService();
            Thread.sleep(100); // 模拟请求间隔
        }
    }
}

解释代码：
- FlowRule：设置每秒请求量阈值为10。
- SphU.entry("entryService")：进入资源，如果超出阈值，会抛出BlockException。
- Thread.sleep(100)：模拟请求间隔，每100毫秒发送一次请求。
运行代码：
当请求量超过每秒10次时，多余的请求会被拒绝。例如，在上述代码中，每秒发送20次请求，超过阈值的10次请求会被拒绝。

Sentinel与其他限流工具对比

Sentinel与Resilience4j对比

Resilience4j是一个轻量级的容错库，用于构建容错性应用程序，提供了断路器、重试、速率限制和熔断等功能。Sentinel是一个轻量级的分布式服务保护框架，主要功能包括流量控制、系统负载保护、热点防护和异常检测。

功能对比：
- Sentinel：具有流量控制、系统负载保护、热点防护和异常检测等功能。
- Resilience4j：具有断路器、重试、速率限制和熔断等功能。
使用场景对比：
- Sentinel：适用于微服务架构中的流量控制和系统保护。
- Resilience4j：适用于构建容错性应用程序，适用于微服务架构中的容错处理。
性能对比：
- Sentinel：性能高，适用于高并发场景。
- Resilience4j：性能适中，适用于一般场景。

Sentinel与Hystrix对比

Hystrix是Netflix开源的一个容错库，用于构建容错性应用程序，提供了断路器、线程池隔离和熔断等功能。Sentinel是一个轻量级的分布式服务保护框架，主要功能包括流量控制、系统负载保护、热点防护和异常检测。

功能对比：
- Sentinel：具有流量控制、系统负载保护、热点防护和异常检测等功能。
- Hystrix：具有断路器、线程池隔离和熔断等功能。
使用场景对比：
- Sentinel：适用于微服务架构中的流量控制和系统保护。
- Hystrix：适用于构建容错性应用程序，适用于微服务架构中的容错处理。
性能对比：
- Sentinel：性能高，适用于高并发场景。
- Hystrix：性能适中，适用于一般场景。

代码示例对比

以下是一些代码示例，展示了如何使用Resilience4j和Hystrix与Sentinel进行对比。

Resilience4j示例

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
import io.github.resilience4j.circuitbreaker.CircuitBreakerState;

public class Resilience4jExample {

    CircuitBreakerRegistry registry = CircuitBreakerRegistry.ofDefaults();
    CircuitBreaker circuitBreaker = registry.circuitBreaker("exampleService");

    public void exampleService() {
        if (circuitBreaker.isClosed()) {
            // 执行业务逻辑
            System.out.println("Service is called.");
        } else {
            System.out.println("Service is blocked.");
        }
    }

    public static void main(String[] args) {
        Resilience4jExample example = new Resilience4jExample();
        example.exampleService();
    }
}

Hystrix示例

import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;

public class HystrixExample extends HystrixCommand<String> {

    public HystrixExample() {
        super(HystrixCommandGroupKey.Factory.asKey("exampleService"));
    }

    @Override
    protected String run() throws Exception {
        // 执行业务逻辑
        return "Service is called.";
    }

    public static void main(String[] args) {
        HystrixExample example = new HystrixExample();
        System.out.println(example.execute());
    }
}

Sentinel限流常见问题与解决办法

常见问题汇总

请求被阻塞：请求超过限流阈值时会被阻塞。
流量统计不准确：流量统计可能存在延迟或误差。
限流规则配置不当：限流规则配置不当可能导致服务崩溃。
系统资源占用过高：系统资源占用过高可能导致服务不可用。

解决方案与技巧分享

请求被阻塞：
- 检查限流规则：检查限流规则是否设置合理，例如，每秒请求量阈值是否设置过高。
- 优化业务逻辑：优化业务逻辑，减少不必要的请求。
- 增加资源预留量：增加资源预留量，预留一部分资源用于高峰时段。
流量统计不准确：
- 增加统计频率：增加流量统计频率，提高统计精度。
- 优化统计算法：优化统计算法，减少统计误差。
限流规则配置不当：
- 调整限流阈值：根据实际情况调整限流阈值。
- 增加缓冲区：增加缓冲区，预留一部分资源用于高峰时段。
- 调整调度策略：调整调度策略，优化资源分配。
系统资源占用过高：
- 优化资源分配：优化资源分配策略，减少系统资源占用。
- 增加系统资源：增加系统资源，提高系统资源利用率。
- 调整服务架构：调整服务架构，优化服务架构，减少系统资源占用。

通过以上解决方案和技巧分享，可以有效地解决Sentinel在使用过程中遇到的常见问题，提高系统的稳定性和可用性。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

繁花如伊

手记
篇

粉丝

39

获赞与收藏

295

关注作者，订阅最新文章

阅读免费教程

Spring Cloud Hystrix

15个小节 6172 121

后端通用面试教程

41个小节 30828 345

网络编程入门教程

20个小节 12721 239

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空