微服务保护(熔断)和阿里Sentinel

雪崩问题

微服务调用链路中的某个服务故障，引起整个链路中的所有微服务都不可用，这就是雪崩。

解决雪崩问题的常见方式有四种

超时处理：设定超时时间，请求超过一定时间没有响应就返回错误信息，不会无休止等待

舱壁模式：限定每个业务能使用的线程数，避免耗尽整个tomcat的资源，因此也叫线程隔离。

熔断降级：由断路器统计业务执行的异常比例，如果超出阈值则会熔断该业务，拦截访问该业务的一切请求。


流量控制：限制业务访问的QPS，避免服务因流量的突增而故障。

如何避免因瞬间高并发流量而导致服务故障？
流量控制

如何避免因服务故障引起的雪崩问题？

• 超时处理
• 线程隔离
• 降级熔断

服务保护技术

分为阿里的Sentinel和SpringCloud自带的Hystrix，我们这里主要介绍阿里的Sentinel。

主要区别：

大家去GitHub下载jar包,就是一个SpringBoot项目，放在没有中文的目录中在控制台使用命令启动一下就行

启动完后访问localhost:8080，默认的账户和密码都是sentinel，默认端口是8080，要是被占了，手动 kill 一下

用这个就不用写代码了，直接界面操作

入门案例

创建一个简单的订单微服务

order
controller层：

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private IOrderService orderService;

    @GetMapping("/{orderId}")
    public Order getById(@PathVariable("orderId") Long id){
        return orderService.getById(id);
    }
}

serviceImpl层：

@Service
public class OrderServiceImpl implements IOrderService {

    @Autowired
    private UserClient userClient;

    @Override
    public Order getById(Long id) {
        Order order = new Order();
        order.setId(id);
        // 为方便测试,假设用户id和订单id一致
        order.setUserId(id);
        order.setName("iphone13 Pro Max");
        order.setPrice(9999L);
        order.setNum(2);
        // 查询订单中的用户
        User user = userClient.getById(id);
        order.setUser(user);
        return order;
    }
}

feign接口

@FeignClient(value = "user-service")
public interface UserClient {
    /**
     * 根据id查询用户
     *
     * @param id
     * @return
     */
    @GetMapping("/user/{id}")
    public User getById(@PathVariable("id") Long id);
}

yml配置文件

server:
  port: 9001
spring:
  application:
    name: order-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

User

controller层：

@RestController
@RequestMapping("/user")
public class UserController {

    /**
     * 根据id查询用户
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public User getById(@PathVariable("id") Long id) {
        User user = new User(id, "tom", "beijing");
        return user;
    }
}

需要到的实体：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    /**
     * id
     */
    private Long id;
    /**
     * 用户名
     */
    private String username;
    /**
     * 地址
     */
    private String address;
}

@Data
public class Order {
    /**
     * 订单id
     */
    private Long id;
    /**
     * 用户id
     */
    private Long userId;
    /**
     * 商品名称
     */
    private String name;
    /**
     * 商品单价
     */
    private Long price;
    /**
     * 商品数量
     */
    private Integer num;
    /**
     * 客户
     */
    private User user;
    /**
     * 创建时间
     */
    private Date createTime;
}

yml文件

server:
  port: 8001
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

需要的依赖：
子工程：

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
    </dependencies>

父工程

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.8.RELEASE</version>
        <relativePath/>
    </parent>
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR6</spring-cloud.version>
        <com.alibaba.cloud>2.2.5.RELEASE</com.alibaba.cloud>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.76</version>
		</dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${com.alibaba.cloud}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

网关：

server:
  port: 8888
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    gateway:
      routes:
      # 订单服务
      - id: order
        uri: lb://order-service
        predicates:
        - Path=/order/**

簇点链路

就是项目内的调用链路，链路中被监控的每个接口就是一个资源。默认情况下sentinel会监控SpringMVC的每一个端点（Endpoint），因此SpringMVC的每一个端点（Endpoint）就是调用链路中的一个资源。
流控、熔断等都是针对簇点链路中的资源来设置的，因此我们可以点击对应资源后面的按钮来设置规则：

入门：
最大QPS为5

使用apache-jmeter进行压力测试：

每秒请求15次

流控模式

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

直接：统计当前资源的请求，触发阈值时对当前资源直接限流，也是默认的模式。

关联：统计与当前资源相关的另一个资源，触发阈值时，对当前资源限流。

链路：统计从指定链路访问到本资源的请求，触发阈值时，对指定链路限流。

流控模式->关联
关联模式：统计与当前资源相关的另一个资源，触发阈值时,对当前资源限流
使用场景：比如用户支付时需要修改订单状态，同时用户要查询订单。查询和修改操作会争抢数据库锁，产生竞争。业务需求是有限支付和更新订单的业务，因此当修改订单业务触发阈值时，需要对查询订单业务限流。

结果：

但是同时访问query，就会被限制

流控模式-链路
链路模式：只针对从指定链路访问到本资源的请求做统计，判断是否超过阈值。

需求：有查询订单和创建订单业务，两者都需要查询商品。针对从查询订单进入到查询商品的请求统计，并设置限流。
步骤：

1在OrderService中添加一个queryGoods方法，不用实现业务

2在OrderController中，改造/order/query端点，调用OrderService中的queryGoods方法

3在OrderController中添加一个/order/save的端点，调用OrderService的queryGoods方法

4给queryGoods设置限流规则，从/order/query进入queryGoods的方法限制QPS必须小于2

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

我们调用了两个good，但是只显示了一个，我们需要加配置。
我们需要关闭这种对SpringMVC的资源聚合，修改order-service服务的application.yml文件：

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

结果：
/order/save

/order/query

总结
流控模式有哪些？
直接：对当前资源限流
关联：高优先级资源触发阈值，对低优先级资源限流。
链路：阈值统计时，只统计从指定资源进入当前资源的请求，是对请求来源的限流

流控效果解释

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

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

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

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

流控效果-》warm up
warm up也叫预热模式，是应对服务冷启动的一种方案。请求阈值初始值是 threshold / coldFactor，持续指定时长后，逐渐提高到threshold值。而coldFactor的默认值是3.
例如，我设置QPS的threshold为10，预热时间为5秒，那么初始阈值就是 10 / 3 ，也就是3，然后在5秒后逐渐增长到10.

结果：


流控效果-》排队等待

当请求超过QPS阈值时，快速失败和warm up 会拒绝新的请求并抛出异常。而排队等待则是让所有请求进入一个队列中，然后按照阈值允许的时间间隔依次执行。后来的请求必须等待前面执行完成，如果请求预期的等待时间超出最大时长，则会被拒绝。
例如：QPS = 5，意味着每200ms处理一个队列中的请求；timeout = 2000，意味着预期等待超过2000ms的请求会被拒绝并抛出异常

没超过5s

超过5s

总结
流控效果有哪些？
快速失败：QPS超过阈值时，拒绝新的请求
warm up： QPS超过阈值时，拒绝新的请求；QPS阈值是逐渐提升的，可以避免冷启动时高并发导致服务宕机。
排队等待：请求会进入队列，按照阈值允许的时间间隔依次执行请求；如果请求预期等待时长大于超时时间，直接拒绝

热点参数限流

之前的限流是统计访问某个资源的所有请求，判断是否超过QPS阈值。而热点参数限流是分别统计参数值相同的请求，判断是否超过QPS阈值。

如：

代表的含义是：对order这个资源的0号参数（第一个参数）做统计，每1秒相同参数值的请求数不能超过10

高级选项：可对特殊的编号，进行特殊处理

案例：
给/order/{orderId}这个资源添加热点参数限流，规则如下：
默认的热点参数规则是每1秒请求量不超过2
给102这个参数设置例外：每1秒请求量不超过4
给103这个参数设置例外：每1秒请求量不超过10

这里有个BUG,你要是在簇点链路点新增的话，你会看不见自己设置的参数

我们需要在热点限流，自己手动添加

结果：
101

102

103

隔离和降级

虽然限流可以尽量避免因高并发而引起的服务故障，但服务还会因为其它原因而故障（如编写代码时出现的异常）。而要将这些故障控制在一定范围，避免雪崩，就要靠线程隔离（舱壁模式）和熔断降级手段了。

Feign与Sentinel整合

不管是线程隔离还是熔断降级，都是对客户端（调用方）的保护，而我们的微服务远程调用都是基于Feign来完成的，因此我们需要将Feign与Sentinel整合，在Feign里面实现线程隔离和服务熔断。

如：
我在user-service中，手动写一个异常

在order-serivce中，实现feign接口

最后添加fallback = UserClientImpl.class

即可显示默认值，而不是在页面抛500异常

结果：

第二种方式：
实现FallbackFactory

@Slf4j
public class UserClientFallback implements FallbackFactory<UserClient> {
    @Override
    public UserClient create(Throwable throwable) {
        log.error("查询用户失败",throwable);
        return id -> new User(id,"顶真","理塘");
    }
}

为UserClientFallback 创建bean

@Configuration
public class DefaultFeignConfiguration {
    @Bean
    public UserClientFallback userClientFallback(){
        return new UserClientFallback();
    }
}

将UserClient换成fallbackFactory

@FeignClient(value = "user-service",fallbackFactory = UserClientFallback.class)
public interface UserClient {
    /**
     * 根据id查询用户
     *
     * @param id
     * @return
     */
    @GetMapping("/user/{id}")
   User getById(@PathVariable("id") Long id);
}

结果

总结：
Sentinel支持的雪崩解决方案：
线程隔离（仓壁模式）
降级熔断
Feign整合Sentinel的步骤：
在application.yml中配置：feign.sentienl.enable=true
给FeignClient编写FallbackFactory并注册为Bean
将FallbackFactory配置到FeignClient

线程隔离（舱壁模式）

线程隔离的实现方式
线程隔离有两种方式实现：

• 线程池隔离

• 信号量隔离（Sentinel默认采用）

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

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

两者的优缺点：

案例需求：给 order-service服务中的UserClient的查询用户接口设置流控规则，线程数不能超过 2。然后利用jemeter测试。


结果

总结：
线程隔离的两种手段是？

• 信号量隔离

• 线程池隔离

信号量隔离的特点是？

• 基于计数器模式，简单，开销小

线程池隔离的特点是？

• 基于线程池模式，有额外开销，但隔离控制更强

熔断降级

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

状态机包括三个状态：

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

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

慢调用：
业务的响应时长（RT）大于指定时长的请求认定为慢调用请求。在指定时间内，如果请求数量超过设定的最小数量，慢调用比例大于设定的阈值，则触发熔断

参数解读：

最大RT:请求的响应时间
统计时长:设置需要测试的时间
比例阀值：发生慢调用的比例次数
最少请求次数：没有达到次数，则不会打开熔断器
熔断时长：在规定时间不会在发送请求

案例

需求：给 UserClient的查询用户接口设置降级规则，慢调用的RT阈值为50ms，统计时间为1秒，最小请求数量为5，失败阈值比例为0.4，熔断时长为5

结果：

变成默认值了

5s后：

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

授权规则

授权规则可以对请求方来源（origin）做判断和控制。

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

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

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

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

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

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

@Component
public class HeaderOriginParser implements RequestOriginParser {
    @Override
    public String parseOrigin(HttpServletRequest request) {
        // 1.获取请求头
        String origin = request.getHeader("origin");
        // 2.非空判断
        if (StringUtils.isEmpty(origin)) {
            origin = "blank";
            System.out.println("origin = " + origin);
        }
        System.out.println("origin = " + origin);
        return origin;
    }
}

配置网关：

 default-filters:
      - AddRequestHeader=origin,gateway

当我们设置白名单：

直接访问不行

但是访问网关就行

当我们把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	系统规则异常

自定义异常处理

@Service
public class SentinelExceptionHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, 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);
        Map<String,Object> map = new HashMap<>();
        map.put("msg",msg);
        map.put("status",status);
        String json = JSON.toJSONString(map);
        response.getWriter().println(json);
    }

在不同场景测试

流控：


白名单：

规则持久化

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

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

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

具体操作百度这里我就不演示了