亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

為了賬號安全，請及時綁定郵箱和手機立即綁定

Sentinel不同的流控模式學習

概述

本文详细介绍了Sentinel的不同流控模式，包括单一阈值模式和复合流控模式的学习，帮助开发者更好地理解和应用Sentinel的流量控制功能。通过具体示例和配置方法，深入讲解了如何在实际项目中实现QPS控制、并发线程数控制和请求量控制，确保系统在高并发场景下的稳定性和可用性。Sentinel不同的流控模式学习涵盖了从基础概念到复杂场景的应用，旨在提升系统的整体性能和可靠性。

引入Sentinel及其重要性

Sentinel 是阿里巴巴开源的一款分布式服务治理与限流系统，为微服务架构提供全面的流量控制、熔断降级、系统负载保护等功能。Sentinel 主要应用于服务治理、服务监控以及高并发场景下的请求控制等方面。Sentinel 的设计目标是提供简单易用的接口，便于开发者快速集成和配置，同时具备强大的功能和灵活性，以应对复杂的分布式环境。

Sentinel 的优势主要体现在以下几点：

  • 流量控制：通过实时监控服务的请求量，根据预设的规则进行流量控制，避免服务因过载而崩溃。
  • 熔断降级：当某个服务因故障而影响整个系统时，Sentinel 可以迅速采取熔断措施，隔离故障服务，保障系统的稳定。
  • 系统自适应：Sentinel 提供了一个系统指标，可以根据系统的实时负载情况动态调整流量，实现自适应保护。
  • 广泛的生态支持：支持多种主流编程语言和框架，如 Java、Spring Boot、Dubbo、Spring Cloud 等，易于集成。

通过一个简单的电商系统示例，Sentinel 在实际项目中的应用价值和重要性可以得到体现。在该系统中，商品服务、订单服务和用户服务分别受到Sentinel的流量控制，确保在高峰期服务的稳定性和响应速度。

Sentinel的基础概念和安装

在引入 Sentinel 之前，了解其基本概念是至关重要的。Sentinel 主要由几个核心概念组成：

  1. 资源：资源是指需要进行控制的对象，可以是方法、HTTP 请求、RPC 接口等。
  2. 规则：规则定义了对资源的控制策略，包括流量控制规则、熔断降级规则、系统保护规则等。
  3. 统计：统计模块负责收集和处理资源的实时数据，以便进行流量控制。
  4. 适配器：适配器允许 Sentinel 与不同的框架（如 Spring Boot、Dubbo）进行集成，提供统一的接口。

接下来，我们将详细介绍如何在项目中安装和配置 Sentinel 的基础环境。

安装 Sentinel

Maven 依赖配置

为了在 Java 项目中使用 Sentinel，首先需要在 pom.xml 文件中添加相应的 Maven 依赖。以下是一个示例配置：

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel</artifactId>
    <version>1.8.4</version>
</dependency>
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-slf4j-log</artifactId>
    <version>1.8.4</version>
</dependency>

以上配置中，sentinel 依赖提供了 Sentinel 的核心功能，而 sentinel-slf4j-log 依赖则用于日志记录。版本号可以根据最新的版本进行相应调整。

引入 Sentinel Starter（以 Spring Boot 为例）

如果你正在使用 Spring Boot，可以引入 Sentinel 的 Starter 依赖，以简化集成过程。以下是 pom.xml 中的配置：

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

此依赖会自动配置 Sentinel 并与 Spring Boot 进行集成，使得你在项目中能够直接使用 Sentinel 的各种功能。

配置 Sentinel

完成依赖引入后，需要进行一些基本配置，以确保 Sentinel 能够正常运行。在 application.properties 或 application.yml 中添加以下配置：

spring.cloud.sentinel.transport.server-port=8719
spring.cloud.sentinel.transport.server-namespace=my-namespace

这些配置指定了 Sentinel 的监控端口和命名空间。命名空间可以用来区分不同的应用实例或环境。

启动应用

在项目启动时，Sentinel 会自动初始化，并通过配置文件中的参数进行相应的配置。下面是一个简单的 Spring Boot 应用程序示例：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;

@SpringBootApplication
public class SentinelApplication {

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

    @SentinelResource(value = "testResource", blockHandler = "handleBlock")
    public String testResource() {
        return "Hello, Sentinel!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }
}

在这个示例中，@SentinelResource 注解用于标记需要进行流量控制的资源。当调用 testResource 方法时，如果该资源被限流或熔断，会调用 handleBlock 方法返回一个具体的错误信息。

启用管理控制台

为了更好地监控和管理 Sentinel，可以启用 Sentinel 的管理控制台。添加依赖：

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-dashboard</artifactId>
    <version>1.8.4</version>
</dependency>

然后启动管理控制台：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

管理控制台默认启动在 http://localhost:8080，通过浏览器访问该地址，可以看到 Sentinel 的实时监控和管理界面。

通过以上步骤，你已经成功安装并配置了 Sentinel，接下来可以进一步探索 Sentinel 的流控模式，实现更复杂的流量控制和保护策略。

Sentinel的流控模式概述

Sentinel 提供了多种流控模式，可以灵活地应对不同的流量控制需求。理解这些模式有助于开发者根据具体的应用场景选择合适的流控策略，确保系统在高并发负载下的稳定性和可用性。

流控模式分类

单一阈值模式

单一阈值模式是最基础的一种流控模式，它通过设置一个固定的阈值来控制资源的访问量。当资源的访问量达到或超过预设的阈值时，Sentinel 将开始限流，防止服务因过载而崩溃。单一阈值模式可以细分为以下几种：

  • QPS 控制：该模式下，Sentinel 会根据每秒的请求数量进行限流。
  • 并发线程数控制：该模式下，Sentinel 会根据同时访问的线程数进行限流。
  • 请求量控制：该模式下，Sentinel 会根据一段时间内的请求数量进行限流。

复合流控模式

复合流控模式允许开发者对多个维度进行组合控制，实现更复杂的流量管理。这种模式可以细分为：

  • 关联维度：可以将多个资源关联起来，比如通过请求链路的方式将多个服务之间的调用关系关联起来。
  • 混合维度：可以同时考虑多个维度，比如在 QPS 限制的同时，结合请求量控制，实现更全面的流量管理。

流控模式的配置方法

单一阈值模式的配置

单一阈值模式的配置相对简单，只需通过 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 TestController {

    @GetMapping("/test")
    @SentinelResource(value = "testResource", blockHandler = "handleBlock")
    public String testResource() {
        return "Hello, Sentinel!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }

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

在上述示例中，@SentinelResource 注解定义了一个名为 testResource 的资源。当该资源被限流时，会调用 handleBlock 方法处理异常。

复合流控模式的配置

复合流控模式需要通过 Sentinel 的配置文件或 API 进行详细配置，可以细分为以下几种方式：

  • 关联维度配置：可以通过 RuleManager 类动态添加规则，实现多个资源之间的关联控制。
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
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 TestController {

    @GetMapping("/test")
    @SentinelResource(value = "testResource", blockHandler = "handleBlock")
    public String testResource() {
        return "Hello, Sentinel!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }

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

在该示例中，通过 FlowRuleManager 动态加载规则，配置了一个 QPS 为 10 的流控规则。

  • 混合维度配置：可以结合多个维度进行复合控制。
public static void main(String[] args) {
    List<FlowRule> rules = new ArrayList<>();
    FlowRule rule1 = new FlowRule();
    rule1.setResource("testResource1");
    rule1.setCount(10);
    rule1.setGrade(FlowRuleManager.GRADER_QPS);
    rule1.setStrategy(FlowRuleManager.STATEGY_ALL);
    FlowRule rule2 = new FlowRule();
    rule2.setResource("testResource2");
    rule2.setCount(20);
    rule2.setGrade(FlowRuleManager.GRADER_REQUEST);
    rule2.setStrategy(FlowRuleManager.STATEGY_ALL);
    rules.add(rule1);
    rules.add(rule2);
    FlowRuleManager.loadRules(rules);
}

上述配置中，定义了两个资源，一个是以 QPS 为10进行控制，另一个是以请求量为20进行控制。

通过以上配置，开发者可以灵活地选择和组合不同的流控模式，以满足各种应用场景的需求。接下来，我们将进一步详细学习单一阈值模式的具体应用和配置方法。

详细学习单一阈值模式

单一阈值模式是 Sentinel 提供的最基本也是最直观的流控模式之一，主要用于根据预设的单一阈值进行流量控制。通过这种方式，Sentinel 可以有效地保护服务，防止因过载而引发的系统崩溃。在本节中，我们将详细介绍单一阈值模式的几种类型及其配置方法。

单一阈值模式的类型

单一阈值模式主要包括以下几种类型：

  1. QPS (每秒请求数) 控制
  2. 并发线程数 控制
  3. 请求量 控制

QPS 控制配置示例

接下来，我们通过一个具体的示例来演示如何配置 QPS 控制。

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

    @GetMapping("/test")
    @SentinelResource(value = "testResource", blockHandler = "handleBlock")
    public String testResource() {
        return "Hello, Sentinel!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }

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

并发线程数控制配置示例

接下来，我们通过一个具体的示例来演示如何配置并发线程数控制。

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

    @GetMapping("/test")
    @SentinelResource(value = "testResource", blockHandler = "handleBlock")
    public String testResource() {
        return "Hello, Sentinel!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }

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

请求量控制配置示例

接下来，我们通过一个具体的示例来演示如何配置请求量控制。

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

    @GetMapping("/test")
    @SentinelResource(value = "testResource", blockHandler = "handleBlock")
    public String testResource() {
        return "Hello, Sentinel!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }

    public static void main(String[] args) {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("testResource");
        rule.setCount(100);
        rule.setGrade(FlowRuleManager.GRADER_REQUEST);
        rule.setStrategy(FlowRuleManager.STATEGY_ALL);
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}

通过上述示例，可以看到单一阈值模式的配置相对简单，但其灵活性和适用性使得它成为微服务架构中流量控制的重要工具。接下来，我们将深入探讨复合流控模式的更多细节。

深入理解复合流控模式

复合流控模式允许开发者通过多个维度进行组合控制，实现更复杂的流量管理策略。这种模式适用于需要从多个角度保护服务的场景，能够更好地应对复杂的服务治理需求。

复合流控模式的类型

复合流控模式主要包括以下几种类型：

  1. 关联维度：通过关联不同的资源，实现更全面的流量控制。
  2. 混合维度：结合多个维度进行复合控制，如 QPS 和请求量的组合控制。

关联维度配置示例

关联维度配置允许开发者将多个资源关联起来，实现更复杂的流量管理。这种方式适用于需要考虑请求链路的服务。

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

@RestController
public class TestController {

    @GetMapping("/test1")
    @SentinelResource(value = "testResource1", blockHandler = "handleBlock")
    public String testResource1() {
        return "Hello, Test1!";
    }

    @GetMapping("/test2")
    @SentinelResource(value = "testResource2", blockHandler = "handleBlock")
    public String testResource2() {
        return "Hello, Test2!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }

    public static void main(String[] args) {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule1 = new FlowRule();
        rule1.setResource("testResource1");
        rule1.setCount(10);
        rule1.setGrade(FlowRuleManager.GRADER_QPS);
        rule1.setStrategy(FlowRuleManager.STATEGY_ALL);
        FlowRule rule2 = new FlowRule();
        rule2.setResource("testResource2");
        rule2.setCount(20);
        rule2.setGrade(FlowRuleManager.GRADER_REQUEST);
        rule2.setStrategy(FlowRuleManager.STATEGY_ALL);
        rules.add(rule1);
        rules.add(rule2);
        FlowRuleManager.loadRules(rules);
    }
}

通过这种配置，可以实现对不同资源的独立控制，同时结合关联维度，实现更复杂的流量管理。

混合维度配置示例

混合维度配置允许开发者结合多个维度进行复合控制，实现更全面的流量保护。这种方式适用于需要从多个角度考虑流量控制的服务。

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

@RestController
public class TestController {

    @GetMapping("/test")
    @SentinelResource(value = "testResource", blockHandler = "handleBlock")
    public String testResource() {
        return "Hello, Sentinel!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }

    public static void main(String[] args) {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("testResource");
        rule.setCount(10);
        rule.setGrade(FlowRuleManager.GRADER_QPS);
        rule.setStrategy(FlowRuleManager.STATEGY_ALL);
        FlowRule rule2 = new FlowRule();
        rule2.setResource("testResource");
        rule2.setCount(20);
        rule2.setGrade(FlowRuleManager.GRADER_REQUEST);
        rule2.setStrategy(FlowRuleManager.STATEGY_ALL);
        rules.add(rule);
        rules.add(rule2);
        FlowRuleManager.loadRules(rules);
    }
}

通过这种配置，可以实现对单一资源的多维度控制，确保在不同场景下都能有效保护服务。

实践案例：应用流控模式解决实际问题

在实际的微服务架构中，经常会遇到高并发场景，此时通过正确的流控策略来保护服务显得尤为重要。本节将以一个具体的案例来展示如何通过 Sentinel 的流控模式解决实际问题，确保服务在高并发负载下的稳定性和可用性。

案例背景

假设我们正在开发一个电商系统，该系统包含多个服务模块，如商品服务、订单服务、用户服务等。在高峰期，大量的请求可能会导致服务过载，进而影响整个系统的性能。我们需要通过 Sentinel 实现对这些服务的流量控制，确保在高并发场景下服务的稳定性和响应速度。

商品服务的流量控制

配置商品服务的 QPS 控制

假设商品服务的接口为 /product/query，我们需要限制每秒查询请求量为 30 次。

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

    @GetMapping("/product/query")
    @SentinelResource(value = "productQuery", blockHandler = "handleBlock")
    public String productQuery() {
        return "Product Query Success!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }

    public static void main(String[] args) {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("productQuery");
        rule.setCount(30);
        rule.setGrade(FlowRuleManager.GRADER_QPS);
        rule.setStrategy(FlowRuleManager.STATEGY_ALL);
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}

订单服务的流量控制

配置订单服务的请求量控制

假设订单服务的接口为 /order/submit，我们需要限制每秒提交订单请求量为 20 次。

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

@RestController
public class OrderController {

    @PostMapping("/order/submit")
    @SentinelResource(value = "orderSubmit", blockHandler = "handleBlock")
    public String orderSubmit() {
        return "Order Submit Success!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }

    public static void main(String[] args) {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("orderSubmit");
        rule.setCount(20);
        rule.setGrade(FlowRuleManager.GRADER_REQUEST);
        rule.setStrategy(FlowRuleManager.STATEGY_ALL);
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}

用户服务的流量控制

配置用户服务的并发线程数控制

假设用户服务的接口为 /user/info，我们需要限制同时查询用户信息的线程数为 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 UserController {

    @GetMapping("/user/info")
    @SentinelResource(value = "userInfo", blockHandler = "handleBlock")
    public String userInfo() {
        return "User Info Success!";
    }

    public String handleBlock(BlockException ex) {
        return "Block Exception: " + ex.getMessage();
    }

    public static void main(String[] args) {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("userInfo");
        rule.setCount(5);
        rule.setGrade(FlowRuleManager.GRADER_THREAD);
        rule.setStrategy(FlowRuleManager.STATEGY_ALL);
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
}

通过上述配置，我们可以有效地保护各个服务模块，在高并发场景下确保系统的稳定性和响应速度。这些示例展示了如何通过 Sentinel 的流控模式实现不同服务模块的流量控制，确保服务在复杂场景下的稳定运行。

點擊查看更多內容
為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

作者其他優質文章

正在加載中
  • 推薦
  • 評論
  • 收藏
  • 共同學習，寫下你的評論
感謝您的支持，我會繼續努力的～
掃碼打賞，你說多少就多少
贊賞金額會直接到老師賬戶
支付方式
打開微信掃一掃，即可進行掃碼打賞哦
今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與 放棄機會
微信客服

購課補貼
聯系客服咨詢優惠詳情

 幫助反饋 APP下載

慕課網APP
您的移動學習伙伴

 公眾號

掃描二維碼
關注慕課網微信公眾號

舉報

0/150
提交
取消