SpringCloud与微服务Ⅵ --- Ribbon负载均衡

一.Ribbon是什么

Sping Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具。

简单的说,Ribbon是Netflix发布的开源项目,主要功能是提供客户端的软件负载均衡算法,将Netflix的中间层服务链接在一块儿。Ribbon客户端组件提供一系列完整的配置项如链接超时，重试等。简单地说,就是在配置文件中列出Load Balancer(简称LB) 后面全部的机器, Ribbon会自动的帮助你基于某种规则(如简单轮询,随机链接等)去链接这些机器。咱们也很容易使用Ribbon实现自定义的负载均衡算法。

负载均衡

LB，即负载均衡(Load Balancer),在微服务或分布式集群中常常用的一种应用。

负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA(高可用)。

常见的负载均衡软件有Nginx,LVS,硬件F5等。

相应的中间件,例如:dubbo和SpringCloud中均给咱们提供了负载均衡,SpringCloud的负载均衡算法能够自定义。

• 集中式LB

  即在服务的消费方和提供方之间使用独立的LB设施(能够是硬件F5(好用可是贵)，也能够说软件,如nginx),由该设施负责把访问请求经过某种策略转发至服务的提供方。

• 进程内LB

  将LB逻辑集成到消费方,消费方从服务注册中心获知有哪些地址可用,而后本身再从这些地址中选择出一个合适的服务器。Ribbon就属于进程内LB，它只是一个类库,集成消费方进程,消费方经过它来获取到服务提供方的地址。

官网资料:https://github.com/Netflix/ribbon/wiki

 

二.Ribbon的初步配置

修改microservice-consumer-dept-80项目。

1.修改pom文件:

<!-- 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.修改yml配置文件:

eureka: client: register-with-eureka: false service-url: #defaultZone: http://localhost:7001/eureka
      defaultZone: http://localhost:7001/eureka,http://localhost:7002/eureka,http://localhost:7002/eureka

3.在RestTemplate上标注@LoadBalanced:

实现负载均衡

@Configuration public class MyApplicationConfig { @Bean @LoadBalanced //负载均衡
    public RestTemplate getRestTemplate(){ return new RestTemplate(); } } 

4.主启动类注解@EnableEurekaClient

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

5.修改微服务访问地址

修改DeptController类中的REST_URL_PREFIX，使得消费端经过微服务名称来访问提供端的接口。

//private static final String REST_URL_PREFIX = "http://localhost:8001";
 private static final String REST_URL_PREFIX = "http://MICROSERVICE-DEPT";

结论:Ribbon和Eureka整合后Consumer能够直接调用服务而不用再关心地址和端口号。

 

三.Ribbon的负载均衡

架构图:

Ribbon在工做时分为两步

第一步先选择EurekaServer,它优先选择在同一个区域内负载较少的server。

第二步再根据用户指定的策略,在从server取到的服务注册列表中选择一个地址。

其中Ribbon提供了多种策略:好比轮询、随机和根据响应时间加权。

搭建步骤:

1.新建两个服务提供者microservice-provider-dept-800二、microservice-provider-dept-8003,项目能够参考microservice-provider-dept-8001。

2.新建两个数据库cloudDB02,cloudDB03，表结构与cloudDB01数据库一致

DROP DATABASE IF EXISTS cloudDB02; CREATE DATABASE cloudDB01 CHARACTER SET UTF8; USE cloudDB01; CREATE TABLE dept ( deptno BIGINT NOT NULL PRIMARY KEY AUTO_INCREMENT, dname VARCHAR(60), db_source VARCHAR(60) ); INSERT INTO dept(dname,db_source) VALUES('开发部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('人事部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('财务部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('市场部',DATABASE()); INSERT INTO dept(dname,db_source) VALUES('运维部',DATABASE());

3.分别修改microservice-provider-dept-800二、microservice-provider-dept-8003的yml文件。

主要修改的是端口号,数据库。

server: port: 8002 spring: application: name: microservice-dept datasource: type: com.alibaba.druid.pool.DruidDataSource #数据源类型 driver-class-name: org.gjt.mm.mysql.Driver #数据库驱动 url: jdbc:mysql://localhost:3306/cloudDB02 #数据库url 

4.启动全部项目,分别访问:

http://localhost:8001/dept/get/1

http://localhost:8002/dept/get/1

http://localhost:8003/dept/get/1

若都能访问，说明全部服务都已经启用。

5.启动客户端项目microservice-consumer-dept-80,访问http://localhost/consumer/dept/list。观察返回的数据，并刷新页面。能够看到刷新后的数据分别来自不一样数据库，说明已经启用了负载均衡。Ribbon默认采用的算法是轮询算法。

总结:Ribbon其实就是一个软负载均衡的客户端组件，他能够和其余所需请求的客户端结合使用，和eureka结合只是其中的一个实例。

 

四.Ribbon的核心组件IRule

Ribbon自带的七种负载均衡算法

1. RoundRobinRule:轮询

2. RandomRule:随机

3. AvailabilityFilteringRule:先过滤因为屡次访问故障而处于断路器跳闸状态的服务，还有并发的链接数量超过阈值的服务，而后对剩余的服务列表按照轮询策略进行访问。

4. WeightedReponseTimeRule:根据平均响应时间计算全部服务的权重，响应时间越短服务权重大被选中的几率高,刚启动时若是统计信息不足,则使用轮询策略,等统计信息足够,会切换到WeightedReponseTimeRule

5. RetryRule:先按照轮询策略获取服务,若是获取服务失败则在指定时间内会进行重试，获取可用的服务

6. BestAvailableRule:先过滤因为屡次访问故障而处于断路器跳闸状态的服务，而后选择一个并发量最小的服务

7. ZoneAvoidanceRule:默认规则，复合判断server所在区域的性能和server的可用性选择服务器

切换成随机的负载均衡算法

须要换哪一种算法，只须要在config类里注入该算法的bean，而后重启服务就会生效了。

@Configuration public class MyApplicationConfig { @Bean @LoadBalanced //负载均衡
    public RestTemplate getRestTemplate(){ return new RestTemplate(); } @Bean public IRule myIRule(){ return new RandomRule(); } }

 经过上面的例子咱们知道,Ribbon默认采用的算法是轮询算法,那么如何配置自定义负载均衡算法呢？

 

五.自定义负载均衡算法

修改microservice-consumer-dept-80项目。

规则描述

要求每台服务器被调用5次，而后轮询以下一台一样被调用5次，全部服务器轮询以后又从最初的服务器开始从新调用五次轮询。

1.自定义算法规则

public class MyRandomRule extends AbstractLoadBalancerRule { // total = 0 // 当total==5之后，咱们指针才能往下走， // index = 0 // 当前对外提供服务的服务器地址， // total须要从新置为零，可是已经达到过一个5次，咱们的index = 1 // 分析：咱们5次，可是微服务只有8001 8002 8003 三台 // 
    
    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) { /* * No servers. End regardless of pass, because subsequent passes only get more * restrictive. */
                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) { /* * The only time this should happen is if the server list were somehow trimmed. * This is a transient condition. Retry after yielding. */ Thread.yield(); continue; } if (server.isAlive()) { return (server); } // Shouldn't actually happen.. but must be transient or a bug.
            server = null; Thread.yield(); } return server; } @Override public Server choose(Object key) { return choose(getLoadBalancer(), key); } @Override public void initWithNiwsConfig(IClientConfig clientConfig) { // TODO Auto-generated method stub
 } }

2.自定义规则的配置类:

@Configuration public class MySelfRule { @Bean public IRule myRule(){ return new MyRandomRule();  //自定义算法策略
 } }

注意:这个自定义配置类MySelfRule.class不能放在@ComponentScan所扫描的包下以及子包下.不然咱们自定义的这个配置类就会被全部Ribbon客户端共享。

3.主启动类添加@RibbonClient

在启动该微服务的时候就能去加载咱们自定义Ribbon配置类，从而使配置生效

@SpringBootApplication @EnableEurekaClient @RibbonClient(name = "MICROSERVICE-DEPT",configuration = MySelfRule.class) public class DeptConsumer80 { public static void main(String[] args) { SpringApplication.run(DeptConsumer80.class,args); } }

以上步骤完成后，重启全部服务器，调用客户端microservice-consumer-dept-80项目的接口。这里须要注意的是,若出现错误，等待一段时间，服务注册的时候会有必定缓冲时间，而后再次访问服务，而后测试负载均衡的策略是否符合自定义的规则。