SpringCloud Ribbon 负载均衡

 

Spring Cloud Ribbon 是一个基于 HTTP 和 TCP 的客户端负载均衡工具。可以将面向服务的 REST 模板请求自动转化成客户端负载均衡的服务调用。Spring Cloud Ribbon 虽然是一个工具类框架，但它不像服务注册中心、配置中心、API网关那样需要独立部署。但是它几乎存在于每一个 Spring Cloud 构建的微服务和基础设置中。因为微服务间的调用，API 网关的请求转发等内容，实际上都是通过 Ribbon 来实现的，包括 Feign 它也是基于 Ribbon 实现的工具。所以 Spring Cloud Ribbon 的理解和使用，对于我们使用 Spring Cloud 来构建微服务非常重要。

一、概述

---

【1】是什么：Spring Cloud Ribbon 是基于 Netflix Ribbon实现的一套客户端的负载均衡的工具。简单的说，Ribbon是 Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将 Netflix 的中间层服务连接在一起。Ribbon 客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说就是在配置文件中列出 Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮你基于某种规则（如单轮询，随机连接等）去连接这些机器。我们也很容易使用 Ribbon实现自定义的负载均衡算法。
【2】作用：LB，即负载平衡（Load Balance）在微服务或分布式集群中经常用的一种应用。负载平衡简单的说，就是将用户的请求平摊的分配到多个服务，而达到服务的HA（高可用）。常见的负载均衡软件Nginx，LVS，硬件F5等。相应的中间件，例如：Dubbo 和 SpringCloud 中均给我们提供了负载均衡，SpinrgCloud 的负载均衡算法可以自定义。
【3】主要分为两种：1）、集中式LB：偏硬件，即在服务的消费方和提供方之间使用独立的LB设施（可以是硬件F5，也可以是软件Nginx），由该设置负责把访问请求通过某种策略转发至服务的提供方； 2）、进程内LB：将 LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。

Ribbon 就属于进程内 LB，它只是一个库，集成于消费方进程，消费方通过它来获取到服务提供方的地址。 

二、Ribbon 初步配置

---

【1】修改客户端，例如：microservicecloud-consumer-dept-80 工程的 pom.xml 文件；

<!-- Ribbon相关 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-ribbon</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

【2】修改 application.yml，追加 eureka 的服务注册地址；

eureka:
  client:
    register-with-eureka: false
    service-url: 
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/  

【3】对 ConfigBean 配置类，添加新注解 @LoadBalance 获得 RestTemplate 时，加入 Ribbon 的配置；

@LoadBalanced//Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端       负载均衡的工具。
public RestTemplate getRestTemplate()
{
    return new RestTemplate();
}

【4】主启动类 DeptConsumer80_App 添加 @EnableEurekaClient；

@EnableEurekaClient
public class DeptConsumer80_App
{

【5】修改 deptController_Consumer 客户端访问类；

//微服务的名称MICROSERVICECLOUD-DEPT
private static final String REST_URL_PREFIX = "http://MICROSERVICECLOUD-DEPT";

@RequestMapping(value="/comsumer/dept/add")
public boolean add(Consumer comsumer){
    return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",comsumer,Boolean.class);
}

【6】先启动3个 eureka 集群后，在启动 microservicecloud-provider-dept-8001 并注册进 eureka；
【7】启动 microservicecloud-consumer-dept-80；
【8】小结：Ribbon 和 Eureka 整合后 Consumer 可以直接调用服务而不用关心服务和端口号。

三、Ribbon 负载均衡

---

【1】Ribbon 在工作时分为两步：
   ①、先选择EurekaServer，它优先选择在同一个区域内负载较少的server；
   ②、根据用户指定的策略，再从 server取到的服务注册列表中选择一个地址；
【2】实操：①、参考 microservicecloud-provide-dept-8001，创建 microservicecloud-provide-dept-8002 和 8003；
   ②、新建 8002/8003数据库，各微服务分别连各自的数据库；
   ③、修改 8002/8003 各自的 yml：修改端口和数据库连接，对外暴露的统一的服务实例名不能修改；
   ​
   ④、启动3个 eureka 集群配置区；
   ⑤、启动3个 Dept 微服务并各自测试通过；
   ⑥、启动 microservicecloud-consumer-dept-80；
   ⑦、客户端通过 Ribbo 完成负载均衡并访问上一步的 Dept微服务；
总结：Ribbo 其实是一个软负载均衡的客户端组件，它可以和其它请求的客户端结合使用，获取 Eureka 中一个实例；

四、Ribbon 核心组件 IRule

---

Irule：根据特定算法从服务中选取一个要访问的服务。
【1】RoundRobinRule：轮询；
【2】RandomRule：随机；
【3】AvaliabilityFilteringRule：会先过滤掉由于多次访问故障而处于熔断器跳闸状态的服务，还有并发的连接数量超过阈值的服务，然后对剩余的服务列表按照轮询策略进行访问；
【4】WeightedResponseTimeRule：根据平均响应时间计算所有服务的权重，响应时间越快权重越大被选中的概率就越高，刚启动时统计信息不足时，则使用 RoundRobinRule 策略，等统计信息足够，则会切换到 WeightedResponseTimeRule；
【5】RetryRule：先按照 roundRobinRule 的策略获取服务，如果获取失败则会在指定时间内进行重试，获取可用服务；
【6】BestAvailableRule：会过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务；
【7】ZoneAvoidanceRule：默认规则，复合判断 server 所在区域的性能和 server 的可用性选择器；

  以上算法要使用则需要在 customer 端得 configBean.java 配置文件中添加（重要）：

@Bean
public IRule myRule()
{
      //return new RoundRobinRule();
      //return new RandomRule();//达到的目的，用我们重新选择的随机算法替代默认的轮询。
      return new RetryRule();
}

五、Ribbon 自定义

---

【1】修改 microservicecloud-consumer-dept-80；
【2】主启动类添加注解 @RibbonClient：在启动该微服务的时候就能去加载我们的自定义 Ribbon 配置类，从而使配置生效，如：@RibbonClient(name = "MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)

@RibbonClient(name="MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)
public class DeptConsumer80_App
{

【3】警告：这个配置类不能放在 @ComponentScan（主启动Java文件的包下面）所扫描的当前包以及子包下，否则我们自定义的这个配置类就会被所有的 Ribbon 客户端共享，也就是说我们达不到特殊化定制的目的。自定义 myrule：（不能和主启动类同一个 package）。不同之处就在于这个类不会扫描到，而是通过 @RibbonClient 注解将其与固定的服务进行绑定。达到与其他微服务不一样的负载均衡算法的目的。

@Configuration
public class MySelfRule
{
     @Bean
     public IRule myRule()
     {
          //return new RandomRule();// Ribbon默认是轮询，我自定义为随机
      //return new RoundRobinRule();// Ribbon默认是轮询，我自定义为随机
      return new RandomRule_ZY();// 我自定义为每台机器5次
     }
}

【4】深度解析：问题：依旧是轮询策略，但是新需求，每个服务器要求被调用5次。即以前是每台机器一次，现在5次。对随机算法源码进行了修改。继承 AbstractLoadBalancerRule 实现负载均衡算法。详细学习，可以参考 GitHub 上 Ribbon 源码。

public class RandomRule_ZY extends AbstractLoadBalancerRule {
    // total = 0 // 当total==5以后，我们指针才能往下走，
    // index = 0 // 当前对外提供服务的服务器地址，
    // total需要重新置为零，但是已经达到过一个5次，我们的index = 1
    // 分析：我们5次，但是微服务只有8001 8002 8003 三台，OK？
    private int total = 0;// 总共被调用的次数，目前要求每台被调用5次
    private int currentIndex = 0; // 当前提供服务的机器号

    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        }
        Server server = null;

        while (server == null) {
            if (Thread.interrupted()) {
                return null;
            }
            List<Server> upList = lb.getReachableServers();
            List<Server> allList = lb.getAllServers();

            int serverCount = allList.size();
            if (serverCount == 0) {
                /*
                 * 没有服务器。结束而不管通过，因为后续的通过只会得到更多
                 * 限制性的。
                 */
                return null;
            }

//            int index = rand.nextInt(serverCount);// java.util.Random().nextInt(3);
//            server = upList.get(index);

//            private int total = 0;             // 总共被调用的次数，目前要求每台被调用5次
//            private int currentIndex = 0;    // 当前提供服务的机器号
            if (total < 5) {
                server = upList.get(currentIndex);
                total++;
            } else {
                total = 0;
                currentIndex++;
                if (currentIndex >= upList.size()) {
                    currentIndex = 0;
                }
            }

            if (server == null) {
                /*
                 * 只有当服务器列表以某种方式被修剪时，才会发生这种情况。
                 * 这是暂时的情况。屈服后重试。
                 */
                Thread.yield();
                continue;
            }

            if (server.isAlive()) {
                return (server);
            }

            // 不应该真的发生。。但必须是暂时的或是一个错误。
            server = null;
            Thread.yield();
        }
        return server;
    }

    public Server choose(Object key) {
        return choose(getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
        // TODO Auto-generated method stub
    }
}