LoadBalancer负载均衡服务调用

LoadBalancer负载均衡服务调用

1、Ribbon目前也进入维护

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

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

​ 官网：https://github.com/Netflix/ribbon

​ Ribbon未来替换方案就是spring-cloud-loadbalancer

2、spring-cloud-loadbalancer概述

官网地址：Client-Side Load-Balancing with Spring Cloud LoadBalancer Dynamically select correct instance for the request

2.1、LB（Load Balancer）负载均衡是什么？

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

​ spring-cloud-starter-loadbalancer组件是什么?

​ Spring Cloud LoadBalancer是由SpringCloud官方提供的一个开源的、简单易用的客户端负载均衡器，它包含在SpringCloud-commons中用它来替换了以前的Ribbon组件。相比较于Ribbon，SpringCloud LoadBalancer不仅能够支持RestTemplate，还支持WebClient（WeClient是Spring Web Flux中提供的功能，可以实现响应式异步请求）

​ 客户端负载和服务器端负载有什么区别？

​ loadbalancer本地负载均衡客户端 VS Nginx服务端负载均衡区别

• Nginx是服务器端的负载均衡，客户端发过来的所有请求都会交给nginx，然后由nginx实现请求转发，即为负载均衡是由服务端实现的；
• loadbalancer是本地负载均衡，在调用微服务接口时，会在注册中心上获取注册信息的服务列表，然后缓存到JVM本地，从而实现本地RPC远程服务调用技术；

3、负载均衡演示案例

3.1、8002搭建

​ 我们把8001的所有内容全部复制一下放新模块中8002，我们只需要修改application.yml中的端口改成8002就好了。

​ 目录结构

​ 然后启动两个服务，应该都不会报错的

​ 然后我们再启动Consul，我的Consul已经做了持久化处理，开机自启，看到Consul两个服务注册进来就可以了。

​ 由于Consul设置了持久化，原来的key/value也都还在。

​ 现在分别访问一下8001和8002

​ 基本的两个服务提供者都有了，下面开始配置一下消费者80，实现负载均衡访问服务。

3.2、消费者80

​ 订单80模块修改POM并注册进consul，新增LoadBalancer组件

<!--loadbalancer-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

​ RestTemplateConfig中的方法RestTemplate上打上@LoadBalanced注解支持负载均衡。

@Configuration
public class RestTemplateConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

​ 然后在controller上新加请求

//负载均衡测试
@GetMapping("/consumer/pay/getInfo")
public String getInfo(){
    return restTemplate.getForObject(PAY_MAN_SERVER + "/pay/getInfo",String.class);
}

​ 启动80消费者服务，到consul注册中心看到cloud-consumer-order服务在列表当中。

​ 现在访问的就是localhost/consumer/pay/getInfo，刷新几次就会看到端口号8001和8002交替访问，说明请求分摊到了两个服务提供者身上了。

3.3、负载均衡小结

​ 客户端也就是消费者是怎么实现负载均衡的？其实比较简单粗暴，使用DiscoveryClient动态获取从consul注册中心的所有服务列表，然后指定我想要的服务名称列表进行判断，如果列表不为空且包含元素，则返回第一个服务实例的 URL，使用 list.get(0).getUri() 获取。

@Autowired
private DiscoveryClient discoveryClient;

public String serviceUrl() {
    List<ServiceInstance> list = discoveryClient.getInstances("STORES");
    if (list != null && list.size() > 0 ) {
        return list.get(0).getUri();
    }
    return null;
}

​ 我们也可以写一个测试来体验一下这个选择的过程。

@Resource
private DiscoveryClient discoveryClient;
@GetMapping("/consumer/discovery")
public String discovery(){
    //获取注册中心的服务列表
    List<String> services = discoveryClient.getServices();
    
    for (String service : services) {
        System.out.println(service);
    }
    System.out.println("----------------------------");
    List<ServiceInstance> instances = discoveryClient.getInstances("cloud-payment-service");
    for (ServiceInstance instance : instances) {
        System.out.println(instance.getServiceId()+"\t"+instance.getHost()+"\t"+instance.getPort()+"\t"+instance.getUri());
    }
    return instances.get(0).getServiceId()+"--port:"+instances.get(0).getPort();
}

​ 重启服务测试

3.4、负载均衡轮询算法

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

List<ServiceInstance> instances = discoveryClient.getInstances("cloud-payment-service");

假如我们这个服务器集群有三个服务

List[0] = instances	127.0.0.1:8001
List[1] = instances	127.0.0.1:8002
List[2] = instances	127.0.0.1:8003

​ 集群内的服务数为3，按照轮询算法原理：

请求数是1时：1%3 = 1 对应下标位置为1，则获得服务器地址就是 127.0.0.1:8002

请求数是2时：2%3 = 2 对应下标位置为2，则获得服务器地址就是 127.0.0.1:8003

请求数是3时：3%3 = 0 对应下标位置为0，则获得服务器地址就是 127.0.0.1:8001

请求数是4时：4%3 = 1 对应下标位置为1，则获得服务器地址就是 127.0.0.1:8002

请求数是5时：5%3 = 2 对应下标位置为2，则获得服务器地址就是 127.0.0.1:8003

依次类推…

4、负载均衡算法原理

4.1、默认算法是什么？有几种？

​ 默认的算法就是上面介绍的轮询算法，一共就两种算法，一个是轮询一个是随机算法。

源码：

public class CustomLoadBalancerConfiguration {

	@Bean
	ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,LoadBalancerClientFactory loadBalancerClientFactory) {
		String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
		return new RandomLoadBalancer(loadBalancerClientFactory
				.getLazyProvider(name, ServiceInstanceListSupplier.class),
				name);
	}
}

4.2、算法的切换

​ 一般我们使用默认的轮询算法即可，不需要切换成随机，现在演示怎么切换。

​ 负载均衡是从RestTemplate中实现的，所以使用它的时候打上@LoadBalancerClient注解，RestTemplateConfig要对服务cloud-payment-service实现一个新的配置，这个配置使用的是随机算法。

@Configuration
@LoadBalancerClient(
        //下面的value值大小写一定要和consul里面的名字一样
        value = "cloud-payment-service",configuration = RestTemplateConfig.class)
public class RestTemplateConfig
{
    @Bean
    @LoadBalanced //使用@LoadBalanced注解赋予RestTemplate负载均衡的能力
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,
                                                            LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);

        return new RandomLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

​ 重启一下80消费者服务测试一下，之前轮询是8001和8002交替访问，现在是随机的，多刷几次就能看到变化。