为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 Sentinel限流教程：新手必读指南

Sentinel限流教程：新手必读指南

标签：
Spring Cloud 微服务
概述

本文详细介绍了Sentinel限流教程，涵盖限流的基本原理、支持的模式及如何配置限流规则。通过实战演练部分，展示了如何在Sentinel控制台和代码中动态创建和修改限流规则，并通过实验对比不同参数设置下的效果。

Sentinel简介
什么是Sentinel

Sentinel 是阿里巴巴开源的一款分布式服务保护组件，它能够保护服务免于过载和异常流量的影响，从而确保系统的稳定性和可用性。Sentinel 提供了一套完整的流量控制、熔断降级、系统保护等功能，帮助开发者轻松应对各种复杂的流量场景。

Sentinel的作用和应用场景

Sentinel 的主要作用在于保护微服务的访问流量，防止过载和异常流量导致服务崩溃。具体的应用场景包括：

  • 流量控制：根据需要限制某个接口的访问速率，避免流量突增导致服务过载。
  • 熔断降级：当某个接口出现异常时，可以迅速熔断该接口，防止故障扩散，并通过降级策略来保证系统的整体稳定。
  • 系统保护：当系统负载过高时，Sentinel 可以自动限流，避免系统过载崩溃。
Sentinel的核心概念和特点
  • 资源：Sentinel 中的核心概念是“资源”，它可以是一个接口、一个方法，也可以是任意业务语义的代码块。例如，可以将某个API定义为资源，对其进行限流保护。
  • 规则：限流、熔断降级等行为的实现依赖于规则。规则可以是静态配置的，也可以通过控制台动态添加和修改。
  • 监控与告警：Sentinel 提供了强大的监控和告警功能，可以实时监控资源的调用情况，当出现异常时可以及时告警，甚至自动触发降级熔断。
安装Sentinel
准备工作

在安装Sentinel之前，需要确保已经搭建好了Java开发环境，并且熟悉Java项目的基本开发流程。Sentinel支持多种开发环境和框架，包括Spring Boot、Spring Cloud等。

在本地环境中安装Sentinel

安装Java环境

确保你的系统中已经安装了Java环境。可以通过运行以下命令来检查Java环境是否已经安装：

java -version

如果没有安装Java，可以从Oracle官网或OpenJDK官网下载并安装Java。

下载Sentinel

前往Sentinel的GitHub仓库页面，下载最新的源码包或JAR包。你可以选择Clone仓库到本地开发环境，或者直接下载压缩包。

添加Sentinel依赖

在你的Java项目中添加Sentinel的依赖。例如，在Spring Boot项目中，可以在pom.xml文件中添加如下依赖：

<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</artifactId>
    <version>1.8.4</version>
</dependency>

启动Sentinel控制台

Sentinel提供了一个控制台，可以通过控制台来管理规则和监控数据。启动控制台的命令如下：

java -jar sentinel-dashboard-1.8.4.jar

默认情况下，控制台会在http://localhost:8080上运行。

运行示例代码

以下是一个简单的Java代码示例，用于测试Sentinel是否成功安装：

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 SentinelDemo {
    public static void main(String[] args) {
        // 配置限流规则
        FlowRule flowRule = new FlowRule();
        flowRule.setResource("example-resource");
        flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        flowRule.setCount(10);
        List<FlowRule> rules = new ArrayList<>();
        rules.add(flowRule);
        FlowRuleManager.loadRules(rules);

        // 调用资源
        try (Entry entry = SphU.entry("example-resource")) {
            System.out.println("Accessing resource: example-resource");
        } catch (BlockException e) {
            System.out.println("Blocked by Sentinel: example-resource");
        }
    }
}
在项目中集成Sentinel

在实际的项目开发中，通常需要将Sentinel集成到应用框架中。下面以Spring Boot为例，展示如何将Sentinel集成到项目中。

引入Sentinel依赖

首先，确保已经在pom.xml中引入了Sentinel的依赖。

配置Sentinel

在Spring Boot项目中，可以通过配置文件来配置Sentinel。例如，配置Sentinel控制台的地址：

sentinel:
  transport:
  dashboard: localhost:8080

自动装配Sentinel

在Spring Boot项目中，可以通过添加@EnableSentinel注解来自动装配Sentinel相关的配置和组件：

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

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

@SpringBootApplication
@EnableSentinel
public class SentinelApplication {
    public static void main(String[] args) {
        SpringApplication.run(SentinelApplication.class, args);
    }
}

为方法添加Sentinel注解

在Spring Boot项目中，可以通过@SentinelResource注解来保护方法。例如：

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SentinelController {
    @GetMapping("/hello")
    @SentinelResource(value = "hello", blockHandler = "handleException")
    public String hello() {
        return "Hello World!";
    }

    public String handleException(BlockException e) {
        return "Blocked by Sentinel";
    }
}
Sentinel限流基础
限流的基本原理

限流的基本原理是通过限制单位时间内访问资源的最大请求数量来防止服务过载。Sentinel提供了多种限流模式，可以根据不同的需求选择合适的限流策略。

  • 令牌桶算法：通过一个桶来存储令牌，当请求到来时，如果桶中有足够的令牌，则可以放行该请求，否则会阻塞该请求。
  • 滑动窗口算法：通过一个滑动窗口来统计单位时间内的请求数量，当请求数量超过设定的最大值时会进行限流。
Sentinel支持的限流模式

Sentinel支持多种限流模式，常见的包括：

  • QPS限流：限制每秒最多能够通过的请求数量。
  • 并发数限流：限制某个资源在单位时间内允许的最大并发数。
  • 链路限流：限制某个服务调用的链路，确保链路上的服务不会出现过载。
如何配置限流规则

配置Sentinel的限流规则有两种方式：通过控制台界面配置和通过代码动态配置。

通过控制台界面配置

  1. 打开Sentinel控制台页面。
  2. 在左侧导航栏中选择“规则管理” -> “流控规则”。
  3. 点击“新增”按钮，填写资源名称、阈值类型、QPS/并发数等参数。
  4. 点击“保存”按钮，完成规则配置。

通过代码动态配置

可以在代码中动态地配置限流规则。例如，以下代码示例展示了如何在代码中配置一个QPS限流规则：

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 com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;

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

public class SentinelConfig {
    public static void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("example-resource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }

    public static void main(String[] args) {
        initFlowRules();
        try (Entry entry = SphU.entry("example-resource")) {
            System.out.println("Accessing resource: example-resource");
        } catch (BlockException e) {
            System.out.println("Blocked by Sentinel: example-resource");
        }
    }
}

QPS限流示例

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 com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;

public class QpsRuleExample {
    public static void main(String[] args) {
        // 配置QPS限流规则
        List<FlowRule> rules = new ArrayList<>();
        FlowRule qpsRule = new FlowRule();
        qpsRule.setResource("example-api");
        qpsRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        qpsRule.setCount(10);
        rules.add(qpsRule);
        FlowRuleManager.loadRules(rules);

        // 测试QPS限流
        for (int i = 0; i < 15; i++) {
            try (Entry entry = SphU.entry("example-api")) {
                System.out.println("Accessing resource: example-api");
            } catch (BlockException e) {
                System.out.println("Blocked by Sentinel: example-api");
            }
        }
    }
}

并发数限流示例

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 com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrencyRuleExample {
    public static void main(String[] args) {
        // 配置并发数限流规则
        List<FlowRule> rules = new ArrayList<>();
        FlowRule concurrencyRule = new FlowRule();
        concurrencyRule.setResource("example-api");
        concurrencyRule.setGrade(RuleConstant.FLOW_GRADE_THREAD);
        concurrencyRule.setCount(10);
        rules.add(concurrencyRule);
        FlowRuleManager.loadRules(rules);

        // 测试并发数限流
        ExecutorService executor = Executors.newFixedThreadPool(20);
        for (int i = 0; i < 20; i++) {
            executor.submit(() -> {
                try (Entry entry = SphU.entry("example-api")) {
                    System.out.println("Accessing resource: example-api");
                } catch (BlockException e) {
                    System.out.println("Blocked by Sentinel: example-api");
                }
            });
        }
        executor.shutdown();
    }
}
实战演练：创建限流规则
使用控制台界面创建限流规则
  1. 打开Sentinel控制台页面。
  2. 在左侧导航栏中选择“规则管理” -> “流控规则”。
  3. 点击“新增”按钮，填写资源名称、阈值类型、QPS/并发数等参数。
  4. 点击“保存”按钮，完成规则配置。
  5. 可以通过观察控制台中的监控数据，验证规则是否生效。

创建QPS限流规则示例

假设要限制某个接口每秒最多允许10次请求，可以通过控制台界面添加如下规则：

  • 资源名称：example-api
  • 阈值类型：QPS
  • QPS：10
通过API动态创建和修改限流规则

在代码中可以通过API动态地创建和修改限流规则。以下代码示例展示了如何在代码中动态添加一个QPS限流规则：

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 com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;

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

public class DynamicRuleConfig {
    public static void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("example-api");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }

    public static void main(String[] args) {
        initFlowRules();
        try (Entry entry = SphU.entry("example-api")) {
            System.out.println("Accessing resource: example-api");
        } catch (BlockException e) {
            System.out.println("Blocked by Sentinel: example-api");
        }
    }
}
实验分析：不同参数设置下的效果对比

在实际使用中，可以通过不同的参数设置来观察限流规则的效果。例如，可以尝试以下几种设置：

  • QPS限流：10 vs 20
  • 并发数限流：10 vs 20
  • 滑动窗口大小：5s vs 10s

通过对比不同设置下的系统表现，可以选择最适合自身业务需求的限流策略。

QPS限流：10 vs 20

将限流规则的QPS值设置为10和20，通过发送不同的请求数量来观察限流效果：

public class QpsComparison {
    public static void main(String[] args) {
        List<FlowRule> rules10 = new ArrayList<>();
        FlowRule rule10 = new FlowRule();
        rule10.setResource("example-api");
        rule10.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule10.setCount(10);
        rules10.add(rule10);
        FlowRuleManager.loadRules(rules10);

        List<FlowRule> rules20 = new ArrayList<>();
        FlowRule rule20 = new FlowRule();
        rule20.setResource("example-api");
        rule20.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule20.setCount(20);
        rules20.add(rule20);
        FlowRuleManager.loadRules(rules20);

        long startTime10 = System.currentTimeMillis();
        for (int i = 0; i < 15; i++) {
            try (Entry entry = SphU.entry("example-api")) {
                System.out.println("Accessing resource: example-api");
            } catch (BlockException e) {
                System.out.println("Blocked by Sentinel: example-api");
            }
        }
        long endTime10 = System.currentTimeMillis();

        long startTime20 = System.currentTimeMillis();
        for (int i = 0; i < 30; i++) {
            try (Entry entry = SphU.entry("example-api")) {
                System.out.println("Accessing resource: example-api");
            } catch (BlockException e) {
                System.out.println("Blocked by Sentinel: example-api");
            }
        }
        long endTime20 = System.currentTimeMillis();

        System.out.println("Time taken with QPS 10: " + (endTime10 - startTime10) + "ms");
        System.out.println("Time taken with QPS 20: " + (endTime20 - startTime20) + "ms");
    }
}

并发数限流：10 vs 20

将限流规则的并发数设置为10和20，通过并发请求来观察限流效果：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConcurrencyComparison {
    public static void main(String[] args) {
        List<FlowRule> rules10 = new ArrayList<>();
        FlowRule rule10 = new FlowRule();
        rule10.setResource("example-api");
        rule10.setGrade(RuleConstant.FLOW_GRADE_THREAD);
        rule10.setCount(10);
        rules10.add(rule10);
        FlowRuleManager.loadRules(rules10);

        List<FlowRule> rules20 = new ArrayList<>();
        FlowRule rule20 = new FlowRule();
        rule20.setResource("example-api");
        rule20.setGrade(RuleConstant.FLOW_GRADE_THREAD);
        rule20.setCount(20);
        rules20.add(rule20);
        FlowRuleManager.loadRules(rules20);

        ExecutorService executor = Executors.newFixedThreadPool(30);

        for (int i = 0; i < 30; i++) {
            executor.submit(() -> {
                try (Entry entry = SphU.entry("example-api")) {
                    System.out.println("Accessing resource: example-api");
                } catch (BlockException e) {
                    System.out.println("Blocked by Sentinel: example-api");
                }
            });
        }

        executor.shutdown();
    }
}

滑动窗口大小：5s vs 10s

通过改变滑动窗口的大小来观察不同的限流效果：

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 com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;

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

public class SlidingWindowComparison {
    public static void main(String[] args) {
        List<FlowRule> rules5s = new ArrayList<>();
        FlowRule rule5s = new FlowRule();
        rule5s.setResource("example-api");
        rule5s.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule5s.setCount(10);
        rule5s.setWarmUpPeriodMs(5000);
        rules5s.add(rule5s);
        FlowRuleManager.loadRules(rules5s);

        List<FlowRule> rules10s = new ArrayList<>();
        FlowRule rule10s = new FlowRule();
        rule10s.setResource("example-api");
        rule10s.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule10s.setCount(10);
        rule10s.setWarmUpPeriodMs(10000);
        rules10s.add(rule10s);
        FlowRuleManager.loadRules(rules10s);

        long startTime5s = System.currentTimeMillis();
        for (int i = 0; i < 15; i++) {
            try (Entry entry = SphU.entry("example-api")) {
                System.out.println("Accessing resource: example-api");
            } catch (BlockException e) {
                System.out.println("Blocked by Sentinel: example-api");
            }
            Thread.sleep(1000);
        }
        long endTime5s = System.currentTimeMillis();

        long startTime10s = System.currentTimeMillis();
        for (int i = 0; i < 15; i++) {
            try (Entry entry = SphU.entry("example-api")) {
                System.out.println("Accessing resource: example-api");
            } catch (BlockException e) {
                System.out.println("Blocked by Sentinel: example-api");
            }
            Thread.sleep(1000);
        }
        long endTime10s = System.currentTimeMillis();

        System.out.println("Time taken with sliding window 5s: " + (endTime5s - startTime5s) + "ms");
        System.out.println("Time taken with sliding window 10s: " + (endTime10s - startTime10s) + "ms");
    }
}
监控与告警
Sentinel的监控功能介绍

Sentinel 提供了丰富的监控功能，帮助开发者实时了解服务的运行状态。监控数据包括：

  • 流量监控：提供了实时的流量数据，包括每秒访问的请求数量。
  • 异常监控：监控服务的异常情况，例如接口调用失败次数等。
  • 系统监控：监控系统的运行状态，包括CPU占用率、内存使用情况等。
如何配置报警规则

可以通过配置报警规则来设置当监控数据达到某个阈值时，自动发送告警通知。例如，可以配置当某个资源的调用失败率达到一定阈值时，发送告警通知。

通过控制台配置报警规则

  1. 打开Sentinel控制台页面。
  2. 在左侧导航栏中选择“规则管理” -> “流控规则”。
  3. 选择需要配置报警规则的资源。
  4. 在“告警”标签页中配置告警阈值和告警动作。
  5. 点击“保存”按钮，完成报警规则配置。

通过代码配置报警规则

在代码中也可以动态地配置报警规则。例如：

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AlertController {
    @GetMapping("/example-api")
    @SentinelResource(value = "example-api", blockHandler = "handleException")
    public String exampleApi() {
        return "Hello World!";
    }

    public String handleException(BlockException e) {
        return "Blocked by Sentinel";
    }

    public static void initAlertRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("example-api");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setWarmUpPeriodMs(10000);
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}
查看和分析监控数据

可以通过Sentinel控制台实时查看监控数据。监控数据包括访问量、异常情况、系统指标等。通过这些数据可以分析系统的运行状况，并及时调整限流策略。

示例代码：获取监控数据

以下是一个简单的示例代码，展示了如何在代码中获取监控数据：

import com.alibaba.csp.sentinel.datasource.FileDataSource;
import com.alibaba.csp.sentinel.datasource.InitFunc;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.cluster.ClusterManager;
import com.alibaba.csp.sentinel.cluster.ClusterManagerService;
import com.alibaba.csp.sentinel.cluster.ClusterMetric;

import java.util.List;

public class MonitorDataExample {
    public static void main(String[] args) {
        // 初始化数据源
        FileDataSource.initDataSource("file:/path/to/rule.json", new InitFunc() {
            @Override
            public void init() {
                System.out.println("Data source initialized.");
            }
        });

        // 获取所有限流规则
        List<FlowRule> rules = FlowRuleManager.getAllRules();
        for (FlowRule rule : rules) {
            System.out.println("Resource: " + rule.getResource());
            System.out.println("QPS: " + rule.getCount());
        }

        // 获取监控数据
        ClusterManagerService cmService = ClusterManager.getInstance().getClusterManagerService();
        ClusterMetric metric = cmService.getClusterMetric();
        System.out.println("QPS: " + metric.getQps());
        System.out.println("Concurrency: " + metric.getConcurrency());
    }
}
常见问题与解决方案
常见的使用问题和解决方法
  • 规则配置不生效：检查规则配置是否正确，并确保规则已经加载到Sentinel中。可以通过控制台查看规则是否生效。
  • 监控数据不准确：确保监控数据源配置正确，并且监控数据采集没有问题。
  • 报警通知未收到：检查报警规则配置是否正确，并确保告警通知渠道畅通。
Sentinel社区支持和资源推荐
  • GitHub仓库：可以在Sentinel的GitHub仓库中查看最新的源码和文档。
  • 官方文档：Sentinel的官方文档提供了详细的使用指南和示例代码。
  • 社区讨论：加入Sentinel的官方论坛和QQ群，与其他开发者交流经验和解决问题。

通过以上内容，你已经了解了如何在项目中安装和集成Sentinel，如何配置和使用限流规则，以及如何监控和配置报警规则。希望这些内容能帮助你更好地理解和使用Sentinel，确保你的服务在高并发场景下保持稳定和可靠。

点击查看更多内容
发表于 2024.11.08 12:40， 共 121 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

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

评论

作者其他优质文章

正在加载中

jeck猫

手记
篇
粉丝
75
获赞与收藏
402

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消