Sentinel限流学习入门教程-原创手记-慕课网

概述

本文将带你深入了解Sentinel限流学习入门，涵盖Sentinel的基本概念、环境搭建、核心功能以及实战案例。通过本文，你将学会如何使用Sentinel进行流量控制、熔断降级和系统保护，构建高可用的服务架构。Sentinel限流学习入门将帮助你掌握服务治理的关键工具。

Sentinel限流学习入门教程

Sentinel简介

Sentinel是什么

Sentinel是阿里巴巴开源的一款轻量级、高性能的Java服务治理与防护组件。它可以帮助开发者保护微服务的稳定性，通过灵活的规则定义来实现流量控制、熔断降级和系统保护等功能。Sentinel支持多种应用场景，如服务的流量控制、热点数据防护、系统负载保护等，是构建高可用系统的关键工具。

Sentinel的主要功能

流量控制：通过设置不同的流量控制规则，实现对服务调用的流量限制。例如，可以限制每秒请求的数量，避免服务因请求量过大而崩溃。
熔断降级：当服务调用出现异常时，Sentinel可以自动进行熔断降级，防止错误传播。例如，当调用远程服务失败率达到阈值时，可以自动停止调用，避免服务雪崩现象。
系统保护：根据系统负载情况动态调整流量，实现系统级别的保护。例如，当系统CPU使用率过高时，可以自动减少流量，保证系统的稳定性。

Sentinel的核心在于通过灵活的规则配置，实现对服务的精细化治理。它提供了丰富的API接口，使得用户能够方便地集成Sentinel到现有项目中，实现功能强大的服务治理。

Sentinel的应用场景

高并发场景：在电商、金融等高并发场景中，可以利用Sentinel对服务进行流量控制，防止因流量过大导致系统崩溃。
系统稳定性保障：通过设定系统保护规则，确保系统在高负载情况下能够自动调整，防止系统过载崩溃。
服务治理：在微服务架构中，Sentinel可以帮助治理服务间的调用关系，实现熔断降级，减少故障传播。
流量测试：在系统上线前，可以利用Sentinel进行流量测试，模拟高并发环境下的系统表现，提前发现潜在问题。

环境搭建与快速上手

Sentinel的下载与安装

为了使用Sentinel，首先需要下载并安装Sentinel的Java客户端。你可以从GitHub仓库下载最新的稳定版，或者使用Maven或Gradle等构建工具直接将Sentinel依赖添加到项目中。

Maven

在项目的pom.xml文件中添加如下依赖：

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

Gradle

在项目的build.gradle文件中添加如下依赖：

dependencies {
    implementation 'com.alibaba.csp:sentinel-core:1.8.0'
    implementation 'com.alibaba.csp:sentinel-transport-simple-http:1.8.0'
}

快速搭建一个Sentinel的测试环境

为了快速搭建测试环境，我们可以创建一个简单的Java应用，集成Sentinel并配置基本的限流规则。

创建Java应用

import com.alibaba.csp.sentinel.init.InitFunc;
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.init.PropertyRule;
import com.alibaba.csp.sentinel.init.PropertyRuleLoader;
import com.alibaba.csp.sentinel.init.SentinelInitializer;

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

public class SentinelDemo {

    public static void main(String[] args) {
        SentinelInitializer.init();

        // 初始化限流规则
        initFlowRules();
    }

    private static void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("HelloWorld");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}

第一个Sentinel限流示例

示例代码

为了演示Sentinel的基本限流功能，我们可以创建一个简单的服务，并设置限流规则，当调用次数超过规则设定的阈值时，Sentinel将拒绝多余的请求。

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;

public class HelloWorldService {

    @SentinelResource(value = "HelloWorld", blockHandler = "blockHandler")
    public String helloWorld(String name) {
        System.out.println("Hello, " + name);
        return "Hello, " + name;
    }

    public String blockHandler(String name, BlockException e) {
        System.out.println("Blocked: " + name);
        return "Blocked: " + name;
    }

    public static void main(String[] args) {
        HelloWorldService service = new HelloWorldService();

        // 设置限流规则
        FlowRuleManager.loadRules(loadFlowRules());

        // 测试调用
        for (int i = 0; i < 15; i++) {
            try {
                System.out.println(service.helloWorld("User" + i));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private static List<FlowRule> loadFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("HelloWorld");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rules.add(rule);
        return rules;
    }
}

运行结果

运行以上代码后，前10次调用会正常返回，从第11次开始，Sentinel将拒绝多余的请求，返回"Blocked"信息。

Sentinel的核心概念

流控规则

流控规则是Sentinel中最基础的规则之一，用于控制资源的访问流量。它通过限制资源调用的QPS（每秒查询量）或并发数来防止服务因流量过大而崩溃。

流控规则的类型

QPS流控：根据每秒请求的数量进行限制。
并发数流控：限制某个资源同时能被多少个线程访问。
关联流控：对于两个相互关联的资源，可以基于关联资源的调用量来限制主资源的访问量。

示例代码

以下是一个QPS流控规则的示例：

FlowRule rule = new FlowRule();
rule.setResource("HelloWorld");
rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
rule.setCount(10);

熔断降级规则

熔断降级规则用于在服务调用出现失败时，自动切断调用链路，防止错误传播，保护系统稳定性。

熔断降级的类型

异常比例：达到一定异常比例后触发熔断降级。
异常数：达到设定的异常数后触发熔断降级。
平均响应时间：当平均响应时间超过设定阈值后触发熔断降级。

示例代码

以下是一个基于异常比例的熔断降级规则示例：

DegradeRule rule = new DegradeRule();
rule.setResource("HelloWorld");
rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO);
rule.setCount(0.05);
rule.setTimeWindow(10);

系统保护规则

系统保护规则用于在系统负载过重时，自动调整流量，避免系统崩溃。

系统保护的类型

CPU使用率：当CPU使用率过高时触发保护。
系统负载：当系统负载过重时触发保护。
内存使用率：当内存使用率过高时触发保护。

示例代码

以下是一个基于CPU使用率的系统保护规则示例：

SystemRule rule = new SystemRule();
rule.setClusterMode(true);
rule.setGrade(RuleConstant.SYSTEM_PROTECT_GRADE_CPU);
rule.setCount(0.8);

限流实战

基础限流规则配置

为了实现基础的限流功能，我们需要配置一个简单的QPS流控规则。

示例代码

以下是一个基于QPS的流控规则配置示例：

FlowRule rule = new FlowRule();
rule.setResource("HelloWorld");
rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
rule.setCount(10);
FlowRuleManager.loadRules(Arrays.asList(rule));

短路降级机制

短路降级机制可以在服务调用失败时，自动切断调用链路，防止错误传播。通过设置熔断降级规则，可以实现这一功能。

示例代码

以下是一个基于异常比例的短路降级机制示例：

DegradeRule rule = new DegradeRule();
rule.setResource("HelloWorld");
rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO);
rule.setCount(0.05);
rule.setTimeWindow(10);
DegradeRuleManager.loadRules(Arrays.asList(rule));

动态规则推送

动态规则推送允许我们在运行时动态修改规则，而不需要重启应用。Sentinel提供了HTTP接口，可以方便地推送新的规则。

示例代码

以下是一个通过HTTP接口动态推送规则的示例：

import com.alibaba.fastjson.JSON;
import com.alibaba.csp.sentinel.cluster.ClusterHttpTransport;
import com.alibaba.csp.sentinel.cluster.ClusterProperties;
import com.alibaba.csp.sentinel.cluster.constant.ClusterHttpTransportProperties;
import com.alibaba.csp.sentinel.cluster.constant.ClusterPropertiesConstant;
import com.alibaba.csp.sentinel.cluster.server.ClusterServerProperties;
import com.alibaba.csp.sentinel.cluster.server.ClusterServerTransport;
import com.alibaba.csp.sentinel.cluster.server.TransportHandler;

public class DynamicRulePushExample {

    public static void main(String[] args) {
        // 初始化集群服务器配置
        ClusterProperties clusterProperties = ClusterPropertiesBuilder.build();
        ClusterHttpTransportProperties transportProperties = new ClusterHttpTransportProperties();
        transportProperties.setHttpPort(8080);
        transportProperties.setHttpPath("/sentinel-api");
        clusterProperties.set(ClusterPropertiesConstant.HTTP_TRANSPORT, transportProperties);

        // 初始化集群服务器传输
        ClusterServerProperties serverProperties = ClusterServerPropertiesBuilder.build(clusterProperties);
        ClusterServerTransport clusterServerTransport = new ClusterHttpTransport(serverProperties);
        clusterServerTransport.init();

        // 推送规则
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("HelloWorld");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rules.add(rule);
        String jsonRules = JSON.toJSONString(rules);

        // 通过HTTP接口推送规则
        TransportHandler transportHandler = clusterServerTransport.getHandler();
        transportHandler.send("/sentinel-api/rule", jsonRules);
    }
}

Sentinel与其他框架的集成

Sentinel与Spring Boot集成

Sentinel可以方便地集成到Spring Boot应用中，通过配置文件来定义规则。

示例代码

以下是一个简单的Spring Boot应用集成Sentinel的示例：

# application.yml
spring:
  cloud:
   sentinel:
      transport:
         port: 8719
         dashboard: localhost:8080

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableDiscoveryClient
public class SentinelSpringBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(SentinelSpringBootApplication.class, args);
    }

    @RestController
    static class HelloController {

        @SentinelResource(value = "helloWorld", blockHandler = "blockHandler")
        public String helloWorld() {
            return "Hello, World!";
        }

        public String blockHandler(BlockException e) {
            return "Blocked: " + e.getMessage();
        }
    }
}

Sentinel与Dubbo集成

Sentinel可以与Dubbo框架集成，实现对Dubbo服务的流量控制、熔断降级等功能。

示例代码

以下是一个简单的Dubbo服务集成Sentinel的示例：

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.MethodConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.config.ServiceConfig;
import org.apache.dubbo.config.annotation.DubboService;
import org.apache.dubbo.rpc.service.GenericService;

@DubboService
public class HelloServiceImpl implements HelloService {

    @SentinelResource(value = "helloWorld", blockHandler = "blockHandler")
    public String helloWorld(String name) {
        System.out.println("Hello, " + name);
        return "Hello, " + name;
    }

    public String blockHandler(BlockException e) {
        System.out.println("Blocked: " + e.getMessage());
        return "Blocked: " + e.getMessage();
    }

    public static void main(String[] args) {
        ApplicationConfig application = new ApplicationConfig();
        application.setName("sentinel-dubbo-provider");

        RegistryConfig registry = new RegistryConfig();
        registry.setAddress("zookeeper://127.0.0.1:2181");

        ServiceConfig<HelloService> service = new ServiceConfig<>();
        service.setApplication(application);
        service.setRegistry(registry);

        // 设置Dubbo方法级别的限流规则
        service.setMethods(new MethodConfig[] {
            new MethodConfig("helloWorld")
        });

        // 配置并发布服务
        service.setInterface(HelloService.class);
        service.export();
    }
}

Sentinel与Seata集成

Sentinel可以与分布式事务框架Seata集成，实现对分布式事务的流量控制和熔断降级。

示例代码

以下是一个简单的Seata服务集成Sentinel的示例：

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.stereotype.Component;

@Component
public class OrderService {

    @SentinelResource(value = "createOrder", blockHandler = "blockHandler")
    public void createOrder(String userId, String productId) {
        // 业务逻辑
    }

    public void blockHandler(BlockException e) {
        // 处理被限流或熔断的情况
    }
}

常见问题与解决方案

Sentinel配置无效的原因排查

依赖冲突：检查项目中的依赖是否正确，确保没有与其他库的版本冲突。
初始化顺序：检查是否在应用启动时正确初始化了Sentinel。
配置文件错误：检查配置文件中的规则是否正确。

示例代码

以下是一个简单的初始化检查示例：

import com.alibaba.csp.sentinel.init.InitFunc;

public class SentinelInitializer {

    public static void init() {
        InitFunc.init();
    }
}

Sentinel限流策略失效的排查

规则未生效：检查是否正确加载了规则。
规则配置错误：检查规则的参数是否正确。
规则未生效：检查规则是否被正确应用到资源上。

示例代码

以下是一个简单的规则加载检查示例：

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 FlowRuleManagerExample {

    public static void main(String[] args) {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("HelloWorld");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}

常见错误代码解析

BlockException：当请求被Sentinel拒绝时，会抛出BlockException。
IllegalArgumentException：当参数不合法时，会抛出IllegalArgumentException。

示例代码

以下是一个简单的异常处理示例：

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 HelloController {

    @SentinelResource(value = "helloWorld", blockHandler = "blockHandler")
    public String helloWorld() {
        return "Hello, World!";
    }

    public String blockHandler(BlockException e) {
        return "Blocked: " + e.getMessage();
    }
}