Spring Cloud (4) —— Ribbon + RestTemplate 调用 provider 和 负载均衡

关于RestTemplate

是 spring 提供的一种简单便捷的模板类来进行 Http 操作。

关于Ribbon

  1. 是一个 http、tcp 负载均衡
  2. 需要连接到注册中心,下载服务列表到本地,之后才可负载均衡
  3. eureka-client 依赖了 ribbon ,所以项目不需要显示引用 ribbon

Ribbon 的使用

  1. 新建模块 spring-cloud.s03.store-ribbon
  2. 在 pom 中添加依赖

        <dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>
        <dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
  3. 添加配置文件
    application.yml

    server:
      port: 31001
    spring:
      application:
        name: store-ribbon
    eureka:
      client:
        service-url:
          defaultZone: http://user:123123@eureka-server-1:34001/eureka/
      instance:
        instance-id: ${spring.cloud.client.ip-address}:${server.port}
        prefer-ip-address: true
        lease-renewal-interval-in-seconds: 10
        lease-expiration-duration-in-seconds: 30
    info:
      app.name: ${spring.application.name}
      compony.name: me.xhy
      build.artifactId: $project.artifactId$
      build.modelVersion: $project.modelVersion$
  4. 创建启动类...StroeRibbon.java

    @SpringBootApplication
    @EnableEurekaClient
    public class StoreRibbon {
      public static void main(String[] args) {
        SpringApplication.run(StoreRibbon.class, args);
      }
    
      @Bean // 向 IOC 容器注入一个 bean,名字是 restTemplate
      @LoadBalanced // restTemplate 开启负载均衡的功能
      RestTemplate restTemplate() {
        return new RestTemplate();
      }
    }
  5. 创建程序访问入口 ..StoreRibbonController

    @RestController
    @RequestMapping("/store-ribbon")
    public class StoreRibbonController {
    
      @Autowired
      RestTemplate restTemplate;
    
      @RequestMapping("/album-provider-port")
      public String getProviderPort() {
        return restTemplate.getForObject("http://album-provider/album/server-port", String.class);
      }
    }
  6. 启动 store-ribbon ,访问 http://localhost:31001/store-ribbon/album-provider-port , 不停刷新页面观察服务提供者返回信息中的端口号, ribbon 默认的负载均衡策略是轮训。

Ribbon 负载均衡策略

  • RoundRobinRule
    轮询策略。Ribbon 默认采用的策略。
  • RandomRule
    随机策略,从所有可用的 provider 中随机选择一个。
  • RetryRule
    先按照 RoundRobinRule 策略访问 provider ,若获取失败,则在指定的时限内重试。默认的时限为500毫秒。
  • BestAvailableRule
    选择并发量最小的 provider,即连接的消费者数量最少的 provider 。
  • AvailabilityFilteringRule
    过滤掉处于断路器跳闸状态的 provider,或已经超过连接极限的 provider,对剩余 provider 采用轮询策略。

    (1)在默认情况下,这台服务器如果3次连接失败,这台服务器就会被设置为“短路”状态。短路状态将持续30秒,如果再次连接失败,短路的持续时间就会几何级地增加。

    注意:可以通过修改配置 loadbalancer.<clientName>.connectionFailureCountThreshold 来修改连接失败多少次之后被设置为短路状态。默认是3次。

    (2)并发数过高的服务器。如果一个服务器的并发连接数过高,配置了 AvailabilityFilteringRule 规则的客户端也会将其忽略。并发连接数的上线,可以由客户端的 <clientName>.<clientConfigNameSpace>.ActiveConnectionsLimit 属性进行配置。

  • ZoneAvoidanceRule
    复合判断provider所在区域的性能及provider的可用性选择服务器。
  • WeightedResponseTimeRule
    “权重响应时间”策略。根据每个provider的平均响应时间计算其权重,响应时间越快权重越大,被选中的机率就越高。在刚启动时采用轮询策略。后面就会根据权重进行选择

Ribbon 全局 负载均衡策略的修改

默认情况下,Ribbon 的默认负载均衡策略是轮训,并且他的影响范围是全局的。

  1. 在 spring component scan 可以到达的地方声明负载均衡策略,这里定义在启动类 ..StroeRibbon 中

      @Bean
      public IRule ribbonRule() {
        return new
            RandomRule() // 随机分配
            /*RoundRobinRule(); // 轮询*/
            /*RetryRule(); // 重试*/
            /*BestAvailableRule() // 最低并发*/
            /*AvailabilityFilteringRule() // 可用过滤*/
            /*ResponseTimeWeightedRule() // 响应时间加权*/
            /*ZoneAvoidanceRule() // 区域权衡*/
            ;
      }

    这里更换了 ribbon 的默认负载均衡策略为 RandomRule() 随机分配 。

  2. 重启项目,访问 http://localhost:31001/store-ribbon/album-provider-port ,通过不停刷新验证负载均衡策略。

Ribbon 基于注解的 局部 策略配置

通过上一节的代码可以发现,只要 spring 会将扫描到的 IRule 类型对象加入容器,并应用他到全局。如果扫描到多个 IRule 类型对象,则会在向 provider 发起请求时报错(启动项目不会报错):Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'ribbonLoadBalancingHttpClient' defined in org.springframework.cloud.netflix.ribbon.apache.HttpClientRibbonConfiguration: Unsatisfied dependency expressed through method 'ribbonLoadBalancingHttpClient' parameter 2; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'ribbonLoadBalancer' defined in org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration: Unsatisfied dependency expressed through method 'ribbonLoadBalancer' parameter 3; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.netflix.loadbalancer.IRule' available: expected single matching bean but found 2: ribbonRule,ribbonRule1

所以,非全局的 IRule 策略对象,就不要让 spring 扫描到。

  1. 先创建一个注解,用于标记 class ,告诉 spring ,带有此注解的 class 不要托管

    public @interface IgnoreScan {
    }
  2. 创建自定义负载均衡策略类 RibbonPartialStrategyRoundRobin,并标记上 @IgnoreScan

    @IgnoreScan
    public class RibbonPartialStrategyRoundRobin {
      @Bean
      public IRule ribbonRule() {
        return new RoundRobinRule(); // 轮询
      }
    }

    spring 将不会托管该类,该类就不会出现在容器中,也就不会对全局策略有影响。

  3. 改造启动类 ..StoreRibbon , 增加两个注解

    @SpringBootApplication
    @EnableEurekaClient
    /*
    @ComponentScan 应用 IgnoreScan , 排除我们定义的局部负载均衡策略
    @RibbonClient 针对 client 指定负载均衡策略。 name 是请求服务提供方的 ${spring.application.name}  ,configuration 是该客户端应用各种策略
     */
    @ComponentScan(excludeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, value = IgnoreScan.class))
    @RibbonClient(name = "album-provider", configuration = RibbonPartialStrategyRoundRobin.class)
    public class StoreRibbon {
      public static void main(String[] args) {
        SpringApplication.run(StoreRibbon.class, args);
      }
    
      @Bean // 向 IOC 容器注入一个 bean,名字是 restTemplate
      @LoadBalanced // restTemplate 开启负载均衡的功能
      RestTemplate restTemplate() {
        return new RestTemplate();
      }
    
      @Bean
      public IRule ribbonRule() {
        return new
            RandomRule() // 随机分配
            /*RoundRobinRule(); // 轮询*/
            /*RetryRule(); // 重试*/
            /*BestAvailableRule() // 最低并发*/
            /*AvailabilityFilteringRule() // 可用过滤*/
            /*ResponseTimeWeightedRule() // 响应时间加权*/
            /*ZoneAvoidanceRule() // 区域权衡*/
            ;
      }
    }

    这样,就可以根据要请求的 provider 来分别设置负载均衡策略了。

    现在,全局策略为 随机分配,请求 album-provider 的策略为 轮询。重启 store-ribbon ,访问 http://localhost:31001/store-ribbon/album-provider-port 进行验证。

小结 访问 album-provider 的负载均衡略变化过程

  1. 最初 在 Ribbon 的使用 章节创建项目时,使用的是 ribbon 的默认全局策略 ①轮询
  2. 接着 在 Ribbon 全局负载均衡策略的修改 章节指定了全局策略为 ②随机
  3. 最后 在 Ribbon 基于注解的局部策略配置 通过局部策略将访问 album-provider 的 ribbon 策略改成了 ③轮询

Ribbon 其他配置 —— 谜之配置

给 provider 的代码制造延迟

先给 album-provider 的 ServicePortController 增加延迟代码,测试程序会访问这个资源。

@RestController
@RequestMapping("/album")
public class ServerPortController {

  @Autowired
  ServerPortConfiguration serverPortConfiguration;

  @RequestMapping("server-port-delay")
  public String serverPortDelay() {
    try {
      TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    return "this is album service running on port " + serverPortConfiguration.getPort();
  }

超时配置 —— 客户端每个请求等待3秒钟返回,也没见超时

# ribbon 全局设置
ribbon:
  ConnectTimeout: 1 # 请求连接的超时时间,#Http请求中的connectTimeout,默认 1000ms
  ReadTimeout: 1 # 请求处理的超时时间,Http请求中的socketTimeout,默认1000ms

当然,这样不好用。

超时配置

//  @Bean // 向 IOC 容器注入一个 bean,名字是 restTemplate
//  @LoadBalanced // restTemplate 开启负载均衡的功能
//  RestTemplate restTemplate() {
//    return new RestTemplate();
//  }

  @Bean
  @LoadBalanced
  RestTemplate restTemplate() {
    HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
    factory.setConnectTimeout(1);
    factory.setReadTimeout(1);
    return new RestTemplate(factory);
  }
  1. 链接超时:
    链接超时

    这个测试最好在不设置 ribbon.eager-load.enable = true 的情况下进行(应采用 false 或者 默认值),在第一次请求时,初始化 ribbon 客户端的耗时会拖延链接的时间,更有可能造成链接超时。
  2. Read timed out:
    Read timed out

失败重试配置 —— 强制下线一个客户端,也没见重试,http code 500

ribbon: # ribbon 全局设置
  OkToRetryOnAllOperations: true
  MaxAutoRetries: 0 # 对当前已失败实例的重试次数
  MaxAutoRetriesNextServer: 1 # 切换实例的重试次数
断路器的超时时间要 大于 ribbon的超时时间,否则不会重试。 Hystrix 时着重说。

如果重试生效了,在只停掉一个点的情况下,每次访问到故障节点,重试机制都会保证客户端得到一个正确的返回。但是这里每次访问到故障点,得到的都是 http code 500 ,明显没有重试。

失败重试配置

  1. pom 中添加依赖

        <dependency>
          <groupId>org.springframework.retry</groupId>
          <artifactId>spring-retry</artifactId>
        </dependency>
  2. 启动类增加注解

    @EnableRetry
  3. 修改配置,时超时时间大于 provider 的延迟 1s

      @Bean
      @LoadBalanced
      RestTemplate restTemplate() {
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(2000);
        factory.setReadTimeout(2000);
        return new RestTemplate(factory);
      }
  4. 验证节点宕机情形

    • provider 延迟 1s 返回; consumer 2s 超时。
    • 当前客户端 ribbon 的策略是轮询,先把3个点都访问一遍验证服务状态都是好的,并记录下端口出现的顺序,比如是 31001 -> 31002 -> 31003
    • 停掉端口为 31003 的服务
    • 继续访问,当下一次应该轮询到 31003 时,等待 1s 出现 31001
    为什么才等短短的 1s,因为 31003 宕机,客户端很快就得到了 500 这个 http 错误码, 接着重试下一个节点,等待 1s 得到返回。
  5. 验证节点处理超时情形

    • 修改 31003 端口的 provider 为 4s ,这样 consumer 访问到该节点就会发生超时
    • 当 consumer 轮询到 31003 节点, consumer 等待 2s 超时,出发重试,到下一节点,等待 1s 返回。
    这种情况就需要 provider 实现幂等了, 其实 31003 具备完成工作的条件,只是返回慢了一些,导致 consumer 又提交相同的请求到其他代偿节点,代偿节点应该返回 31003 对该请求的处理结果,而不是自己重复处理该请求。

并发配置 —— 存疑,怎么测

ribbon: # ribbon 全局设置
  MaxTotalConnections: 500 # 最大连接数
  MaxConnectionsPerHost: 500 # 每个host最大连接数

关于失败重试

自动的失败重试能很大程度的提升成功率,但不是所有场景都适用。如果是查询场景,重试无疑是个好的策略。如果是涉及到“修改”的场景,重试会带来很多问题:

  1. 接口要幂等化,保证每次查询的结果都一直,就算低层数据真的发生了变化。
  2. 对于相同的提交,要防止“修改”操作的请求被重复处理。要有辨别该请求当前处理状态的能力:正在处理、处理成功(幂等返回)、处理失败(幂等返回)

@RibbonClients

@RibbonClient 是定义到类上的,每个类上只能写一次该注解,如果一个类中,需要访问多个服务,就要用到 @RibbonClients 了 。

@RibbonClients(value = {
    @RibbonClient(name = "album-provider", configuration = RibbonPartialStrategyRoundRobin.class),
    @RibbonClient(name = "album-provider1", configuration = RibbonPartialStrategyRoundRobin.class)})
public class StoreRibbon {
}

未完

停掉一台 album-provider ,测试 AvailabilityFilteringRule 策略。

评论

暂无评论