Ribbon负载均衡服务调用-摩杜云开发者社区

Ribbon负载均衡服务调用

1、Ribbon概述

1.1 什么是Ribbon?
1.2 Ribbon项目
1.3 Ribbon能干什么？

1.3.1 Load Balance(负载均衡)

2、Ribbon负载均衡演示

2.1 架构说明
2.2 RestTemplate服务调用测试

2.2.1 服务提供者
2.2.2 服务消费者
2.2.3 服务调用测试

3、Ribbon核心组件IRule

3.1 如何替换默认的轮询负载均衡算法？

3.1.1 配置细节
3.1.2 在myrule包中新建MySelfRule规则类
3.1.3 主启动类添加@RibbonClient注解
3.1.4 启动服务并测试

4、负载均衡算法原理

1、Ribbon概述

1.1 什么是Ribbon?

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

简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法和服务调用。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer（简称LB）后面所有的机器，Ribbon会自动的帮助你基于某种规则（如简单轮询，随机连接等）去连接这些机器。我们很容易使用Ribbon实现自定义的负载均衡算法。

1.2 Ribbon项目

官网：https://github.com/Netflix/ribbon/wiki/Getting-Started

该项目目前处于维护模式。

Ribbon负载均衡服务调用_ribbon

SpringCloud团队打算使用SpringCloud Loadbalancer替代Ribbon。

1.3 Ribbon能干什么？

1.3.1 Load Balance(负载均衡)

负载均衡：简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HA（高可用）。常见的负载均衡有软件Nginx，LVS，硬件 F5等。

Ribbon本地负载均衡客户端 VS Nginx服务端负载均衡区别：Nginx是服务器负载均衡，客户端所有请求都会交给nginx，然后由nginx实现转发请求。即负载均衡是由服务端实现的。

Ribbon本地负载均衡，在调用微服务接口时候，会在注册中心上获取注册信息服务列表之后缓存到JVM本地，从而在本地实现RPC远程服务调用技术。

负载均衡分为集中式负载均衡和进程内负载均衡：

集中式LB：即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件，如F5, 也可以是软件，如nginx), 由该设施负责把访问请求通过某种策略转发至服务的提供方；

进程内LB:将LB逻辑集成到消费方，消费方从服务注册中心获知有哪些地址可用，然后自己再从这些地址中选择出一个合适的服务器。

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

我在eureka服务注册与发现的那篇文章中已经测试过了轮询负载访问的方式。

2、Ribbon负载均衡演示

2.1 架构说明

这里还是先使用eureka服务注册中心，后面换Nacos

Ribbon负载均衡服务调用_java_02

Ribbon在工作时分成两步
第一步先选择 EurekaServer ,它优先选择在同一个区域内负载较少的server.
第二步再根据用户指定的策略，在从server取到的服务注册列表中选择一个地址。
其中Ribbon提供了多种策略：比如轮询、随机和根据响应时间加权。

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

由于eureka组件中已经包含了Ribbon依赖，所以我们不需要单独引入，当然，单独引入也没有错。

Ribbon负载均衡服务调用_spring boot_03

可以看到spring-cloud-starter-netflix-eureka-client 确实引入了Ribbon

2.2 RestTemplate服务调用测试

官网文档：https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html

现在我们在订单服务中调用支付服务测试

Ribbon负载均衡服务调用_java_04

Ribbon负载均衡服务调用_java_05

也就是说，我们在CLOUD-ORDER-SERVICE服务中调用CLOUD-PAYMENT-SERVICE服务，由于CLOUD-PAYMENT-SERVICE节点有两台，测试负载均衡的轮询算法实现服务调用。

2.2.1 服务提供者

application.yml:

server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包 com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.159.33:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456
  thymeleaf:
    cache: false
  freemarker:
    cache: false
  groovy:
    template:
      cache: false
eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版
  instance:
    instance-id: payment8001
    prefer-ip-address: true #访问路径可以显示IP地址



mybatis:
  mapperLocations: classpath:mapper/*.xml
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

主启动类：

@SpringBootApplication
@EnableEurekaClient //代表eureka客户端
@EnableDiscoveryClient
public class PaymentMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8001.class,args);
    }
}

Controller:

@GetMapping(value = "/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
    {
        Payment payment = paymentService.getPaymentById(id);
        log.info("*****查询结果:{}",payment);
        if (payment != null) {
            return new CommonResult(200,"查询成功,serverPort:"+serverPort,payment);
        }else{
            return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
        }
    }

这里我只给出了payment8001端口的代码，payment8002端口和payment8001代码基本一致。并且控制层的代码中添加了输出，可以看到是8001和8002端口哪个提供服务。

2.2.2 服务消费者

application.yml:

server:
  port: 80

spring:
  application:
    name: cloud-order-service
eureka:
  client:
    #表示是否将自己注册进EurekaServer默认为true。
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetchRegistry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka  # 集群版

主启动类：

@SpringBootApplication
@EnableEurekaClient //代表eureka客户端
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class,args);
    }
}

Bean配置：

@Configuration
public class ApplicationContextConfig {

    @Bean
    @LoadBalanced//使用@LoadBalanced注解赋予RestTemplate负载均衡的能力
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

}

由于默认使用的就是轮询负载均衡算法，所以不用额外指定。

Controller:

@RestController
@Slf4j
public class OrderController {

    public static final String PAYMENT_URL="http://CLOUD-PAYMENT-SERVICE";

    @Autowired
    private RestTemplate restTemplate;


    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable("id") Long id){
        return restTemplate.getForObject(PAYMENT_URL+"/payment/get/"+id,CommonResult.class);
    }

}

2.2.3 服务调用测试

分别启动CLOUD-ORDER-SERVICE和CLOUD-PAYMENT-SERVICE服务，查看Eureka服务注册中心是否注册成功。

然后访问：http://localhost/consumer/payment/get/31

第一次访问：http://localhost/consumer/payment/get/31

Ribbon负载均衡服务调用_java_06

第二次访问：http://localhost/consumer/payment/get/31

Ribbon负载均衡服务调用_java_07

多刷新几次会发现，服务提供者的端口一直在8001和8002之间轮询，说明负载均衡算法生效了。

3、Ribbon核心组件IRule

IRule：根据特定算法中从服务列表中选取一个要访问的服务。下图中展示了该接口的负载均衡算法。

Ribbon负载均衡服务调用_spring boot_08

Ribbon负载均衡服务调用_spring boot_09

com.netflix.loadbalancer.RoundRobinRule:轮询
com.netflix.loadbalancer.RandomRule：随机
com.netflix.loadbalancer.RetryRule：先按照RoundRobinRule的策略获取服务，如果获取服务失败则在指定时间内会进行重试，获取可用的服务
WeightedResponseTimeRule：对RoundRobinRule的扩展，响应速度越快的实例选择权重越大，越容易被选择。
BestAvailableRule：会先过滤掉由于多次访问故障而处于断路器跳闸状态的服务，然后选择一个并发量最小的服务。
AvailabilityFilteringRule：先过滤掉故障实例，再选择并发较小的实例。
ZoneAvoidanceRule：默认规则,复合判断server所在区域的性能和server的可用性选择服务器。

3.1 如何替换默认的轮询负载均衡算法？

3.1.1 配置细节

官方文档明确给出了警告：这个自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包下，否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，达不到特殊化定制的目的了。

重新建个myrule的包，注意包的位置：

Ribbon负载均衡服务调用_spring cloud_10

3.1.2 在myrule包中新建MySelfRule规则类

@Configuration
public class MySelfRule
{
    @Bean
    public IRule myRule()
    {
        return new RandomRule();//定义为随机
    }
}

这里我们使用随机的负载均衡算法代替轮询算法。

3.1.3 主启动类添加@RibbonClient注解

/**
 * 在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效
 */
@SpringBootApplication
@EnableEurekaClient //代表eureka客户端
@RibbonClient(name = "CLOUD-PAYMENT-SERVICE",configuration= MySelfRule.class)
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class,args);
    }
}

3.1.4 启动服务并测试

重启CLOUD-ORDER-SERVICE服务，并访问：http://localhost/consumer/payment/get/31

第一次访问：

Ribbon负载均衡服务调用_负载均衡_11

第二次访问:

Ribbon负载均衡服务调用_java_12

第三次访问：

Ribbon负载均衡服务调用_ribbon_13

可以看到，已经不是轮询算法了，提供服务的端口已经变成随机的了。

4、负载均衡算法原理

负载均衡算法：rest接口第几次请求数 % 服务器集群总数量 = 实际调用服务器位置下标，每次服务重启动后rest接口计数从1开始。

下面给出轮询算法的原理：

List instances = discoveryClient.getInstances(“CLOUD-PAYMENT-SERVICE”);

如： List [0] instances = 127.0.0.1:8002
　　　List [1] instances = 127.0.0.1:8001

8001+ 8002 组合成为集群，它们共计2台机器，集群总数为2，按照轮询算法原理：

当总请求数为1时： 1 % 2 =1 对应下标位置为1 ，则获得服务地址为127.0.0.1:8001
当总请求数位2时： 2 % 2 =0 对应下标位置为0 ，则获得服务地址为127.0.0.1:8002
当总请求数位3时： 3 % 2 =1 对应下标位置为1 ，则获得服务地址为127.0.0.1:8001
当总请求数位4时： 4 % 2 =0 对应下标位置为0 ，则获得服务地址为127.0.0.1:8002
如此类推…

到此，Ribbon负载均衡组件就介绍完了。