学习笔记-Sentinel

Sentinel

雪崩问题

简单点来说，雪崩就是，在多个微服务在相互调用方法接口是时候，在其中一个

服务出现了故障，那么改业务依赖于此服务时，那么就会出现堵塞，而线程并

不会结束，当请求越来越多时，那么服务器所支持线程并发资源有限，服务器资源耗尽，那么所有服务都不可用，雪崩就发生了

解决雪崩问题

第一种：超时处理

设定超时的时间，请求当一段时间没用响应，则会报错，就不会发生过久的堵塞

第二种：仓壁模式

可以对每个业务的线程数进行限制，避免耗尽服务器资源，也叫做线程隔离

第三种：断路器

使用断路器统计业务的异常比例，当超出阈值时则会熔断业务，拦截访问该业务的一切请求

简单点来说就是：断路器会对服务的请求做一个判断，当断路器认为某服务的异常过高，认为该服务有雪崩的风险，则会拦下该服务所有请求

第四种：限流

限制业务访问的QPS，就是限制业务的每秒能处理多少个请求，避免服务因流量的突然增加而发生故障

解决雪崩问题的总结

限流是对服务的保护，避免因瞬间高并发流量而导致服务故障，进而避免雪崩。是一种预防措施。

超时处理、线程隔离、降级熔断是在部分服务故障时，将故障控制在一定范围，避免雪崩。是一种补救措施。

认识Sentinel

官网地址：https://sentinelguard.io/zh-cn/index.html

安装Sentinel

下载

GitHub下载：https://github.com/alibaba/Sentinel

运行

java -jar sentinel-dashboard-1.8.1.jar

如果要修改Sentinel的默认端口、账户、密码，可以通过下列配置：

配置项	默认值	说明
server.port	8080	服务端口
sentinel.dashboard.auth.username	sentinel	默认用户名
sentinel.dashboard.auth.password	sentinel	默认密码

比如：

java -Dserver.port=8090 -jar sentinel-dashboard-1.8.1.jar

访问

打开浏览器：http://localhost:8090

账号和密码，默认都是：sentinel

微服务整合Sentinel

1.导入依赖

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

2.配置文件(application.yaml)

spring:
  cloud: 
    sentinel:
      transport:
        dashboard: localhost:8090

簇点链路

当请求进入微服务时，首先会访问DispatcherServlet，然后进入Controller、Service、Mapper，这样的一个调用链就叫做簇点链路。簇点链路中被监控的每一个接口就是一个资源。

默认情况下sentinel会监控SpringMVC的每一个端点（Endpoint，也就是controller中的方法），因此SpringMVC的每一个端点（Endpoint）就是调用链路中的一个资源。

流控、熔断等都是针对簇点链路中的资源来设置的，因此我们可以点击对应资源后面的按钮来设置规则：

• 流控：流量控制
• 降级：降级熔断
• 热点：热点参数限流，是限流的一种
• 授权：请求的权限控制

流控模式

在添加限流规则时，点击高级选项，可以选择三种流控模式：

• 直接：统计当前资源的请求，触发阈值时对当前资源直接限流，也是默认的模式
• 关联：统计与当前资源相关的另一个资源，触发阈值时，对当前资源限流
• 链路：统计从指定链路访问到本资源的请求，触发阈值时，对指定链路限流

直接模式

添加规则时，默认的就是直接，当统计当前资源的请求，一旦触发阈值，就会直接限流

关联模式

当关联资源（/write）请求访问达到阈值时，则会对资源名（/read）资源限流，避免影响到关联资源

使用场景：比如用户支付时需要修改订单状态，同时用户要查询订单。查询和修改操作会争抢数据库锁，产生竞争。业务需求是优先支付和更新订单的业务，因此当修改订单业务触发阈值时，需要对查询订单业务限流。

链路模式

简单点来说就是：看下图

默认情况下Service是不会被Sentinel监控的，需要加注解：@SentinelResource在方法上

链路模式中，是对不同来源的两个链路做监控。但是sentinel默认会给进入SpringMVC的所有请求设置同一个root资源，会导致链路模式失效。

我们需要关闭这种对SpringMVC的资源聚合：

spring:
  cloud:
    sentinel:
      # 关闭context整合
      web-context-unify: false

流控效果

流控效果是指请求达到流控阈值时应该采取的措施，包括三种：

• 快速失败：达到阈值后，新的请求会被立即拒绝并抛出FlowException异常。是默认的处理方式。

• warm up：预热模式，对超出阈值的请求同样是拒绝并抛出异常。但这种模式阈值会动态变化，从一个较小值逐渐增加到最大阈值。

• 排队等待：让所有的请求按照先后次序排队执行，两个请求的间隔不能小于指定时长. 超过则拒绝

warm up

阈值一般是一个微服务能承担的最大QPS，但是一个服务刚刚启动时，一切资源尚未初始化（冷启动），如果直接将QPS跑到最大值，可能导致服务瞬间宕机。

warm up也叫预热模式，是应对服务冷启动的一种方案。请求阈值初始值是 maxThreshold(最大阈值) / coldFactor(冷因子)，持续指定时长后，逐渐提高到maxThreshold值。而coldFactor的默认值是3.

例如，我设置QPS的maxThreshold为10，预热时间为5秒，那么初始阈值就是 10 / 3 ，也就是3，然后在5秒后逐渐增长到10.

排队等待

而排队等待则是让所有请求进入一个队列中，然后按照阈值允许的时间间隔依次执行。后来的请求必须等待前面执行完成，如果请求预期的等待时间超出最大时长，则会被拒绝。

热点参数限流

热点参数限流是分别统计参数值相同的请求，判断是否超过QPS阈值。

全局参数限流

简单的来说就是：对hot这个资源的0号参数（第一个参数）做统计，每1秒相同参数值的请求数不能超过5

热点参数限流对默认的SpringMVC资源无效，需要利用@SentinelResource注解标记资源

隔离和降级

熔断降级

限流是一种预防措施，虽然限流可以尽量避免因高并发而引起的服务故障，但服务还会因为其它原因而故障。

而要将这些故障控制在一定范围，避免雪崩，就要靠线程隔离（舱壁模式）和熔断降级手段了。

SpringCloud中，微服务调用都是通过Feign来实现的，因此做客户端保护必须整合Feign和Sentinel。

添加依赖

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <!--spring boot版本为2.3.9-->
        <version>2.3.9.RELEASE</version>
    </parent>

    <properties>
        <!--spring cloud版本为SR8-->
        <spring.cloud-version>Hoxton.SR8</spring.cloud-version>
        .........
    </properties>
    ....
    <dependencyManagement>
        <dependencies>
             ...
            <!--引入SpringCloudAlibaba的依赖-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <!-- SpringCloudAlibaba的依赖改为2.2.5.RELEASE -->
                <version>2.2.5.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

修改配置（yml）

feign:
  sentinel:
    enabled: true # 开启feign对sentinel的支持

编写失败降级逻辑

业务失败后，不能直接报错，而应该返回用户一个友好提示或者默认结果，这个就是失败降级逻辑。

给FeignClient编写失败后的降级逻辑

①方式一：FallbackClass，无法对远程调用的异常做处理

②方式二：FallbackFactory【推荐】，可以对远程调用的异常做处理，我们选择这种

自定义失败加急处理

/**
 * 自定义失败降级处理
 */
@Slf4j
@Component
public class UserClientFallbackFactory implements FallbackFactory<UserClient> {

    /**
     * 业务处理
     * @param throwable
     * @return
     */
    @Override
    public UserClient create(Throwable throwable) {
        return new UserClient() {
            @Override
            public User one(Long id) {
                log.error("查询用户异常", throwable);
                User user = new User();
                user.setAddress("xx");
                user.setUsername("yu");
                return user;
            }
        };
    }
}

/**
 * 将String url = "http://itheima-user/user/"+orderInfo.getUserId();
 * 替换成当前接口
 * 1.通过@FeignClient("被调用的服务名称")
 * 2.定义方法 需要跟 被调用的微服务要一样
 *  2.1.路径必须是被调用微服务的完整路径
 *  2.2.参数一定要加别名
 */
@FeignClient(value = "itheima-user",fallbackFactory = UserClientFallbackFactory.class)
public interface UserClient {

    /***
     * 根据id查询用户详情
     */
    @GetMapping(value = "/user/{id}")
    public User one(@PathVariable(value = "id") Long id);
}

线程隔离（舱壁模式）

线程隔离的实现方式

线程池隔离：给每个服务调用业务分配一个线程池，利用线程池本身实现隔离效果

信号量隔离：不创建线程池，而是计数器模式，记录业务使用的线程数量，达到信号量上限时，禁止新的请求。

信号量隔离

优点：轻量级，无额外开销

缺点：不支持主动超时、不支持异步调用

场景：高频调用、高扇出（请求到A服务，A微服务依赖于N个微服务，请求到A就会扇出N个微服务）

线程池隔离

优点：支持主动超时、支持异步调用

缺点：线程的额外开销比较大

场景：低扇出

用法说明：

在添加限流规则时，可以选择两种阈值类型：

• QPS：就是每秒的请求数，在快速入门中已经演示过

• 线程数：是该资源能使用用的tomcat线程数的最大值。也就是通过限制线程数量，实现线程隔离（舱壁模式）。

熔断降级

熔断降级是解决雪崩问题的重要手段。其思路是由断路器统计服务调用的异常比例、慢请求比例，如果超出阈值则会熔断该服务。即拦截访问该服务的一切请求；而当服务恢复时，断路器会放行访问该服务的请求。

断路器控制熔断和放行是通过状态机来完成的：

状态机包括三个状态：

• closed：关闭状态，断路器放行所有请求，并开始统计异常比例、慢请求比例。超过阈值则切换到open状态
• open：打开状态，服务调用被熔断，访问被熔断服务的请求会被拒绝，快速失败，直接走降级逻辑。Open状态5秒后会进入half-open状态
• half-open：半开状态，放行一次请求，根据执行结果来判断接下来的操作。
  • 请求成功：则切换到closed状态
  • 请求失败：则切换到open状态

断路器熔断策略有三种：慢调用、异常比例、异常数

慢调用

在请求时长大于设定的RT阈值（50ms），统计时间为一秒，最小请求数量为5，失败的阈值比例达到设定多少比如0.4，则进行熔断，进入Open状态，熔断时间若为五秒，则五秒后进入Half-Open，放行一个请求尝试

异常比例、异常数

异常比例或异常数：统计指定时间内的调用，如果调用次数超过指定请求数，并且出现异常的比例达到设定的比例阈值（或超过指定异常数），则触发熔断。

授权规则

基本规则

授权规则可以对调用方的来源做控制，有白名单和黑名单两种方式。

• 白名单：来源（origin）在白名单内的调用者允许访问

• 黑名单：来源（origin）在黑名单内的调用者不允许访问

点击左侧菜单的授权，可以看到授权规则：

• 资源名：就是受保护的资源，例如/order/{id}

• 流控应用：是来源者的名单，

  • 如果是勾选白名单，则名单中的来源被许可访问。
  • 如果是勾选黑名单，则名单中的来源被禁止访问。

如何获取origin

Sentinel是通过RequestOriginParser这个接口的parseOrigin来获取请求的来源的。

public interface RequestOriginParser {
    /**
     * 从请求request对象中获取origin，获取方式自定义
     */
    String parseOrigin(HttpServletRequest request);
}

这个方法的作用就是从request对象中，获取请求者的origin值并返回。

默认情况下，sentinel不管请求者从哪里来，返回值永远是default，也就是说一切请求的来源都被认为是一样的值default。

因此，我们需要自定义这个接口的实现，让不同的请求，返回不同的origin。

例如order-service服务中，我们定义一个RequestOriginParser的实现类：

package com.itheima.order.sentinel;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.RequestOriginParser;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;

/**
 * 自定义接口的实现，让不同的请求，返回不同的origin
 */
@Component
public class HeaderOriginParser implements RequestOriginParser {

    /**
     * 获取请求头值 为空返回blank
     * @param httpServletRequest
     * @return
     */
    @Override
    public String parseOrigin(HttpServletRequest httpServletRequest) {
        // 1.获取请求头
        String origin = httpServletRequest.getHeader("origin");
        // 2.非空判断
        if(StringUtils.isEmpty(origin)){
            origin = "blank";
        }
        return origin;
    }
}

我们会尝试从request-header中获取origin值。

给网关添加请求头

既然获取请求origin的方式是从reques-header中获取origin值，我们必须让所有从gateway路由到微服务的请求都带上origin头。

这个需要利用之前学习的一个GatewayFilter来实现，AddRequestHeaderGatewayFilter。

修改gateway服务中的application.yml，添加一个defaultFilter：

spring:
  application:
    name: gateway
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: SZ #集群设置名称
        namespace: devnamespace #环境隔离 命名空间ID
    gateway:
      default-filters: #全局过滤器配置 针对所有的微服务
        - AddRequestHeader=Heima,shenzheima nb!!!
        - AddRequestHeader=origin,gateway
      routes:
       # ...略

从gateway路由的所有请求都会带上origin头，值为gateway。而从其它地方到达微服务的请求则没有这个头。

注意：删除eureka配置

添加nacos起步依赖

<!--nacos起步依赖-->
    <dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

注意：删除eureka依赖

配置授权规则

接下来，我们添加一个授权规则，放行origin值为gateway的请求。

配置如下：

自定义异常结果

默认情况下，发生限流、降级、授权拦截时，都会抛出异常到调用方。异常结果都是flow limmiting（限流）。这样不够友好，无法得知是限流还是降级还是授权拦截。

异常类型

而如果要自定义异常时的返回结果，需要实现BlockExceptionHandler接口：

public interface BlockExceptionHandler {
    /**
     * 处理请求被限流、降级、授权拦截时抛出的异常：BlockException
     */
    void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception;
}

这个方法有三个参数：

• HttpServletRequest request：request对象
• HttpServletResponse response：response对象
• BlockException e：被sentinel拦截时抛出的异常

这里的BlockException包含多个不同的子类：

异常	说明
FlowException	限流异常
ParamFlowException	热点参数限流的异常
DegradeException	降级异常
AuthorityException	授权规则异常
SystemBlockException	系统规则异常

自定义异常处理

下面，我们就在order-service定义一个自定义异常处理类：

package com.itheima.order.sentinel;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class SentinelExceptionHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception {
        String msg = "未知异常";
        int status = 429;

        if (e instanceof FlowException) {
            msg = "请求被限流了";
        } else if (e instanceof ParamFlowException) {
            msg = "请求被热点参数限流";
        } else if (e instanceof DegradeException) {
            msg = "请求被降级了";
        } else if (e instanceof AuthorityException) {
            msg = "没有权限访问";
            status = 401;
        }

        response.setContentType("application/json;charset=utf-8");
        response.setStatus(status);
        response.getWriter().println("{\"msg\": " + msg + ", \"status\": " + status + "}");
    }
}

规则持久化(这个就了解一下，具体操作，我也没试过)

现在，sentinel的所有规则都是内存存储，重启后所有规则都会丢失。在生产环境下，我们必须确保这些规则的持久化，避免丢失。

规则管理模式

规则是否能持久化，取决于规则管理模式，sentinel支持三种规则管理模式：

• 原始模式：Sentinel的默认模式，将规则保存在内存，重启服务会丢失。
• pull模式
• push模式

pull模式

pull模式：控制台将配置的规则推送到Sentinel客户端，而客户端会将配置规则保存在本地文件或数据库中。以后会定时去本地文件或数据库中查询，更新本地规则。

push模式

push模式：控制台将配置规则推送到远程配置中心，例如Nacos。Sentinel客户端监听Nacos，获取配置变更的推送消息，完成本地配置更新。