Sentinel限流资料：新手入门教程

Sentinel 是一款开源的流量控制组件，广泛应用于微服务架构中，帮助治理流量和保障服务的高可用性。本文详细介绍了 Sentinel 的多种功能，包括流量控制、实时监控和异常检测，并深入探讨了 Sentinel 限流的基本概念和应用场景。文章还提供了详细的 Sentinel 限流资料，包括安装配置和规则详解。

Sentinel 是什么

Sentinel 是一款开源的流量控制组件，主要用于治理流量，保障微服务架构的高可用性。它支持多种维度的流量控制、实时监控、流量趋势分析、故障降级等功能，能够帮助开发人员有效管理和控制流量，防止服务因突发高流量而被压垮。

Sentinel 的主要功能

Sentinel 提供了多种核心功能，包括但不限于：

• 流量控制：通过规则配置，限制进入系统的请求流量，防止服务因流量过大而崩溃。
• 实时监控与统计：提供实时的监控和统计功能，帮助开发人员了解系统的运行状况。
• 异常检测：能够自动检测服务调用链路中的异常，及时进行降级处理。
• 系统保护：提供对系统资源的保护机制，避免系统在高负载情况下被压垮。

Sentinel 的应用场景

Sentinel 适用于多种场景，包括但不限于：

• 微服务架构：在微服务架构中，通过 Sentinel 控制各个服务之间的流量，保证系统稳定运行。
• API网关：在 API 网关中，通过 Sentinel 控制对各个 API 的访问频率，防止滥用。
• 高并发场景：在高并发场景下，通过 Sentinel 控制请求流量，避免服务器过载。

什么是限流

限流是指通过设置规则，限制系统所能处理的最大流量，从而防止系统因流量过大而崩溃。限流的主要目的是保护系统的稳定性和可用性，避免在突发流量突增时造成系统瘫痪。

为什么需要限流

在网络环境中，服务可能会因为突发流量突增而崩溃。例如，一个服务可能在正常情况下能够处理 QPS（每秒查询率）为100的请求，但当遇到流量突增，例如 QPS 突破到1000时，服务可能会崩溃，导致服务不可用或响应慢。通过设置限流规则，可以有效地控制流量，保证系统在高负载情况下仍能稳定运行。

Sentinel如何实现限流

Sentinel 实现限流的主要方式是通过规则配置。开发人员可以配置不同的限流规则，例如直接限流规则、带宽限流规则等，来控制进入系统的请求流量。当请求流量超过设置的阈值时，Sentinel 将会阻止多余的流量，从而保护系统。

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.Sentinel;

public class BasicFlowRuleExample {
    public static void main(String[] args) {
        try (Entry entry = Sentinel.of("example-resource").entry()) {
            // 保护资源访问的代码
            System.out.println("资源访问成功");
        } catch (BlockException e) {
            System.out.println("资源访问被阻塞");
        }
    }
}

安装Sentinel

要安装 Sentinel，首先需要在项目中引入 Sentinel 的依赖。对于 Maven 项目，可以在 pom.xml 文件中添加如下依赖：

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.8.2</version>
</dependency>

对于 Gradle 项目，可以在 build.gradle 文件中添加如下依赖：

dependencies {
    implementation 'com.alibaba.csp:sentinel-core:1.8.2'
}

配置Sentinel

配置 Sentinel 包括两个步骤：配置 Sentinel 的核心配置和配置限流规则。

核心配置

核心配置主要是配置 Sentinel 的运行时参数。例如，在 Java 代码中可以通过 ConfigManager 类来配置参数：

import com.alibaba.csp.sentinel.config.ConfigManager;

public class SentinelConfigExample {
    public static void main(String[] args) {
        ConfigManager.newInstance().init();
        // 设置流控规则存储路径
        ConfigManager.getConfig().setFlowRuleStorePath("my-flow-rules");
        // 设置其他配置参数
        // ...
    }
}

配置限流规则

配置限流规则主要包括直接限流规则、带宽限流规则等。例如，配置一个直接限流规则：

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;

public class SentinelRuleConfigExample {
    public static void main(String[] args) {
        // 创建一个直接限流规则
        FlowRule rule = new FlowRule();
        rule.setResource("my-resource");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

直接限流规则

直接限流规则是最基本的限流规则，通过设置最大 QPS（每秒查询率）来限制进入系统的请求流量。直接限流规则支持多种维度的限流，例如按资源名称、按 IP 等。

配置直接限流规则

要配置一个直接限流规则，可以使用 FlowRule 类来创建规则对象，并通过 FlowRuleManager 类来加载规则。

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

public class DirectFlowRuleExample {
    public static void main(String[] args) {
        FlowRule rule = new FlowRule();
        rule.setResource("direct-flow-rule-example");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

带宽限流规则

带宽限流规则通过设置带宽来限制进入系统的请求流量。带宽限流规则主要用于控制系统的网络带宽，防止因带宽不足而造成服务不可用。

配置带宽限流规则

要配置一个带宽限流规则，可以使用 FlowRule 类来创建规则对象，并通过 FlowRuleManager 类来加载规则。

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

public class BandwidthFlowRuleExample {
    public static void main(String[] args) {
        FlowRule rule = new FlowRule();
        rule.setResource("bandwidth-flow-rule-example");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        rule.setBurst(10);
        rule.setWarmUpPeriodMs(1000);
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

慢查询规则

慢查询规则用于控制慢查询，避免因慢查询导致服务性能下降。慢查询规则通常用于数据库访问，当查询时间超过预设阈值时，Sentinel 将限制后续的查询请求。

配置慢查询规则

要配置一个慢查询规则，可以使用 FlowRule 类来创建规则对象，并通过 FlowRuleManager 类来加载规则。

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

public class SlowQueryRuleExample {
    public static void main(String[] args) {
        FlowRule rule = new FlowRule();
        rule.setResource("slow-query-rule-example");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        rule.setBurst(10);
        rule.setWarmUpPeriodMs(1000);
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

创建限流规则示例

要创建一个限流规则，首先需要引入 Sentinel 的依赖，然后通过 FlowRule 类创建规则对象，并通过 FlowRuleManager 类加载规则。

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

public class CreateFlowRuleExample {
    public static void main(String[] args) {
        FlowRule rule = new FlowRule();
        rule.setResource("create-flow-rule-example");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        rule.setBurst(10);
        rule.setWarmUpPeriodMs(1000);
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

测试限流效果

要测试限流效果，可以通过模拟高流量请求来观察限流规则的效果。例如，可以通过循环发送请求来模拟高流量场景。

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.Sentinel;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;

public class FlowRuleTestExample {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 100; i++) {
            try (Entry entry = Sentinel.withResource("create-flow-rule-example")) {
                System.out.println("请求通过");
            } catch (BlockException e) {
                System.out.println("请求被阻塞");
            }
            Thread.sleep(100);
        }
    }
}

调整限流策略

要调整限流策略，可以通过修改已存在的限流规则对象，并通过 FlowRuleManager 类重新加载规则。

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

public class AdjustFlowRuleExample {
    public static void main(String[] args) {
        // 获取已存在的限流规则
        List<FlowRule> rules = FlowRuleManager.loadRules();
        FlowRule rule = rules.get(0);
        rule.setCount(20);
        FlowRuleManager.loadRules(rules);
    }
}

Sentinel与Spring Cloud的集成

要将 Sentinel 与 Spring Cloud 集成，可以通过引入 Sentinel 的 Spring Cloud 依赖，并配置相应的限流规则。

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    <version>2.2.3.RELEASE</version>
</dependency>

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 org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringCloudSentinelApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudSentinelApplication.class, args);
        FlowRule rule = new FlowRule();
        rule.setResource("spring-cloud-sentinel");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }

    @SentinelResource(value = "spring-cloud-sentinel", blockHandler = "handleBlock")
    public String handleRequest() {
        return "处理成功";
    }

    public String handleBlock(BlockException e) {
        return "请求被阻塞";
    }
}

Sentinel与Dubbo的集成

要将 Sentinel 与 Dubbo 集成，可以通过引入 Sentinel 的 Dubbo 依赖，并配置相应的限流规则。

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel-dubbo</artifactId>
    <version>2.2.3.RELEASE</version>
</dependency>

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 org.apache.dubbo.config.spring.context.annotation.DubboComponentScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@DubboComponentScan
public class DubboSentinelApplication {
    public static void main(String[] args) {
        SpringApplication.run(DubboSentinelApplication.class, args);
        FlowRule rule = new FlowRule();
        rule.setResource("dubbo-sentinel");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10);
        rule.setLimitApp("default");
        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }

    @SentinelResource(value = "dubbo-sentinel", blockHandler = "handleBlock")
    public String handleRequest() {
        return "处理成功";
    }

    public String handleBlock(BlockException e) {
        return "请求被阻塞";
    }
}

Sentinel集群模式配置

要配置 Sentinel 的集群模式，可以通过配置文件来设置集群模式参数，例如：

spring:
  cloud:
  sentinel:
    transport:
      dashboard: localhost:8080

在集群模式下，Sentinel 会将限流规则等配置同步到各个节点，确保各个节点的配置一致。同时，可以通过 Sentinel 的控制台来管理和查看集群模式下的配置。

import com.alibaba.csp.sentinel.config.SentinelConfig;

public class ClusterModeConfigExample {
    public static void main(String[] args) {
        SentinelConfig config = new SentinelConfig();
        config.setTransportPort(8080);
        config.setTransportIp("localhost");
        config.setTransportDashboard("localhost:8080");
    }
}