微服务负载均衡器Ribbon&LoadBalancer实战

负载均衡介绍

负载均衡（Load Balance），其含义就是指将负载（工作任务）进行平衡、分摊到多个操作单元上 进行运行，例如FTP服务器、Web服务器、企业核心应用服务器和其它主要任务服务器等，从而协 同完成工作任务。

思考： 如果有多个provider实例，consumer应该如何调用呢？
目前主流的负载均衡方案分为以下两种：

集中式负载均衡：在消费者和服务提供方中间使用独立的代理方式进行负载，有 硬件的（比如 F5），也有软件的（比如 Nginx）。
客户端负载均衡：客户端根据自己的请求情况做负载均衡，Ribbon 就属于客户端自己做负载均衡

客户端的负载均衡

例如spring cloud中的ribbon，客户端会有一个服务器地址列表，在发送请求前通过负载 均衡算法选择一个服务器，然后进行访问，这是客户端负载均衡；即在客户端就进行负载均 衡算法分配。

服务端的负载均衡

例如Nginx，通过Nginx进行负载均衡，先发送请求，然后通过负载均衡算法，在多个服务 器之间选择一个进行访问；即在服务器端再进行负载均衡算法分配。

常见负载均衡算法

算法	描述
随机	通过随机选择服务进行执行，一般这种方式使用较少
轮训	负载均衡默认实现方式，请求来之后排队处理
加权轮训	通过对服务器性能的分型，给高配置，低负载的服务器分配更高的权 重，均衡各个服务器的压力
地址hash	通过客户端请求的地址的hash值取模映射进行服务器调度
最小连接数	即使请求均衡了，压力不一定会均衡，最小连接数法就是根据服务 器的情况，比如请求积压数等参数，将请求分配到当前压力最小服务器上

什么是Ribbon

Spring Cloud Ribbon是基于Netflix Ribbon 实现的一套客户端的负载均衡工具，Ribbon 客户端组件提供一系列的完善的配置，如超时，重试等。通过Load Balancer获取到服务提 供的所有机器实例，Ribbon会自动基于某种规则(轮询，随机)去调用这些服务。Ribbon也可以实现我们自己的负载均衡算法

Spring Cloud Alibaba整合Ribbon快速开始

引入ribbon依赖

<!‐‐添加ribbon的依赖‐‐>
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring‐cloud‐starter‐netflix‐ribbon</artifactId>
</dependency>

RestTemplate 添加@LoadBalanced注解

让RestTemplate在请求时拥有客户端负载均衡的能力

@Configuration
public class RestConfig {
    @Bean
    @LoadBalanced //开启负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

使用微服务名发起调用

@Autowired
private RestTemplate restTemplate;

@RequestMapping(value = "/findOrderByUserId/{id}")
public R findOrderByUserId(@PathVariable("id") Integer id) {
    // ribbon实现，restTemplate需要添加@LoadBalanced注解
    String url = "http://mall‐order/order/findOrderByUserId/"+id;
    R result = restTemplate.getForObject(url,R.class);

    return result;
}

Ribbon内核原理

模拟ribbon实现

客户端负载均衡调用：

@Autowired
private RestTemplate restTemplate;

@RequestMapping(value = "/findOrderByUserId/{id}")
    public R  findOrderByUserId(@PathVariable("id") Integer id) {
    //模拟ribbon实现
    String url = getUri("mall-order")+"/order/findOrderByUserId/"+id;
    R result = restTemplate.getForObject(url,R.class);
    return result;
}

通过服务名获取ip:port

@Autowired
private DiscoveryClient discoveryClient;
// 根据服务名获取ServiceInstance
public String getUri(String serviceName) {
    // 根据服务名获取ServiceInstance
    List<ServiceInstance> serviceInstances = discoveryClient.getInstances(serviceName);
    if (serviceInstances == null || serviceInstances.isEmpty()) {
        return null;
    }
    int serviceSize = serviceInstances.size();
    //轮询
    int indexServer = incrementAndGetModulo(serviceSize);
    return serviceInstances.get(indexServer).getUri().toString();
}

轮训算法：

private AtomicInteger nextIndex = new AtomicInteger(0);
private int incrementAndGetModulo(int modulo) {
    for (;;) {
        int current = nextIndex.get();
        int next = (current + 1) % modulo;
        if (nextIndex.compareAndSet(current, next) && current < modulo){
            return current;
        }
    }
}

@LoadBalanced 注解原理

参考源码： LoadBalancerAutoConfiguration
@LoadBalanced使用了@Qualifier，spring中@Qualifier用于筛选限定注入Bean。
@LoadBalanced利用@Qualifier作为restTemplates注入的筛选条件，筛选出具有负载均衡标识的RestTemplate

@LoadBalanced
@Autowired( required = false )
private List<RestTemplate> restTemplates = Collections.emptyList();

被@LoadBalanced注解的restTemplate会被定制，添加LoadBalancerInterceptor拦截器

注意： SmartInitializingSingleton是在所有的bean都实例化完成之后才会调用的，所以在 bean的实例化期间使用@LoadBalanced修饰的restTemplate是不具备负载均衡作用的。

如果不使用@LoadBalanced注解，也可以通过添加LoadBalancerInterceptor拦截器让 restTemplate起到负载均衡器的作用。

@Bean
public RestTemplate restTemplate(LoadBalancerInterceptor loadBalancerInterceptor) {
    RestTemplate restTemplate = new RestTemplate();
    //注入loadBalancerInterceptor拦截器
    restTemplate.setInterceptors(Arrays.asList(loadBalancerInterceptor));
    return restTemplate;
}

Ribbon扩展功能

Ribbon相关接口

参考： org.springframework.cloud.netflix.ribbon.RibbonClientConfiguration

类型	描述
IClientConfig	Ribbon的客户端配置，默认采用DefaultClientConfigImpl实现
IRule	Ribbon的负载均衡策略，默认采用ZoneAvoidanceRule实现，该策略能够在多区 域环境下选出最佳区域的实例进行访问
IPing	Ribbon的实例检查策略，默认采用DummyPing实现，该检查策略是一个特殊的 实现，实际上它并不会检查实例是否可用，而是始终返回true，默认认为所有服实例都是可用的。
ServerList	服务实例清单的维护机制，默认采用ConfigurationBasedServerList实现
ServerListFilter	服务实例清单过滤机制，默认采ZonePreferenceServerListFilter，该策略能够优先过滤出与请求方处于同区域的服务实例
ILoadBalancer	负载均衡器，默认采用ZoneAwareLoadBalancer实现，它具备了区域 感知的能力

Ribbon负载均衡策略

策略	描述
RandomRule	随机选择一个Server
RetryRule	对选定的负载均衡策略机上重试机制，在一个配置时间段内当选择 Server不成功，则一直尝试使用subRule的方式选择一个可用server
RoundRobinRule	轮询选择， 轮询index，选择index对应位置的Server
AvailabilityFilteringRule	过滤掉一直连接失败的被标记为circuit tripped的 后端Server，并过滤掉那些高并发的后端Server或者使用一个AvailabilityPredicate 来包含过滤server的逻辑，其实就是检查status里记录的各个Server的运行状态
BestAvailableRule	选择一个最小的并发请求的Server，逐个考察Server，如果Server被tripped了，则跳过
WeightedResponseTimeRule	根据响应时间加权，响应时间越长，权重越小，被选中的可能性越低
ZoneAvoidanceRule	默认的负载均衡策略，即复合判断Server所在区域的性 能和Server的可用性选择Server，在没有区域的环境下，类似于轮询
NacosRule	优先调用同一集群的实例，基于随机权重

修改默认负载均衡策略

全局配置

调用的微服务，一律使用指定的负载均衡策略

@Configuration
public class RibbonConfig {

    /**
     * 全局配置
     * 指定负载均衡策略
     * @return
     */
    @Bean
    public IRule ribbonRule() {
        // 指定使用Nacos提供的负载均衡策略（优先调用同一集群的实例，基于随机权重）
        return new NacosRule();
    }
}

局部配置

调用指定微服务时，使用对应的负载均衡策略，修改application.yml：

# 被调用的微服务名
mall‐order:
 ribbon:
 # 指定使用Nacos提供的负载均衡策略（优先调用同一集群的实例，基于随机&权重）
 NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule

自定义负载均衡策略

实现基于Nacos权重的负载均衡策略

通过实现 IRule 接口可以自定义负载策略，主要的选择服务逻辑在 choose 方法中

@Slf4j
public class NacosRandomWithWeightRule extends AbstractLoadBalancerRule {

    @Autowired
    private NacosDiscoveryProperties nacosDiscoveryProperties;

    @Override
    public Server choose(Object key) {
        DynamicServerListLoadBalancer loadBalancer = (DynamicServerListLoadBalancer) getLoadBalancer();
        String serviceName = loadBalancer.getName();
        NamingService namingService = nacosDiscoveryProperties.namingServiceInstance();

        try {
            //nacos基于随机权重的算法
            Instance instance = namingService.selectOneHealthyInstance(serviceName);
            log.info(instance.getIp()+":"+instance.getPort());
            return new NacosServer(instance);
        } catch (NacosException e) {
            log.error("获取服务实例异常：{}", e.getMessage());
            e.printStackTrace();
        }

        return null;
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {

    }

}

配置自定义的策略

全局配置：

@Configuration
public class RibbonConfig {

    /**
     * 全局配置
     * 指定负载均衡策略
     * @return
     */
    @Bean
    public IRule ribbonRule() {
        return new NacosRandomWithWeightRule();
    }
}

局部配置：

# 被调用的微服务名
mall‐order:
 ribbon:
 # 指定使用Nacos提供的负载均衡策略（优先调用同一集群的实例，基于随机&权重）
 NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule

饥饿加载

在进行服务调用的时候，如果网络情况不好，第一次调用会超时。Ribbon默认懒加载，意味着只有在发起调用的时候才会创建客户端

开启饥饿加载，解决第一次调用慢的问题：

ribbon:
	eager‐load:
		#开启ribbon的饥饿加载模式
		enabled: true
		# 指定需要饥饿加载的服务名，也就是你需要调用服务，如果有多个服务，则用逗号隔开
		clients: mall‐order 

什么是LoadBalancer

Spring Cloud LoadBalancer是Spring Cloud官方自己提供的客户端负载均衡器, 用来替代Ribbon
Spring官方提供了两种客户端都可以使用loadbalancer：

客户端	描述
RestTemplate	RestTemplate是Spring提供的用于访问Rest服务的客户端，RestTemplate供了多种便 捷访问远程Http服务的方法，能够大大提高客户端的编写效率。默认情况下， RestTemplate默认依赖jdk的HTTP连接工具。
WebClient	WebClient是从Spring WebFlux 5.0版本开始提供的一个非阻塞的基于响应式编程的进行Http请求的客户端工具。它的响应式编程的基于Reactor的。WebClient中提供了标准Http 请求方式对应的get、post、put、delete等方法，可以用来发起相应的请求。

RestTemplate整合LoadBalancer

引入依赖

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

 <!‐‐ 提供了RestTemplate支持 ‐‐>
 <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring‐boot‐starter‐web</artifactId>
 </dependency>

 <!‐‐ nacos服务注册与发现 移除ribbon支持‐‐>
 <dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring‐cloud‐starter‐alibaba‐nacos‐discovery</artifactId>
   <exclusions>
     <exclusion>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring‐cloud‐starter‐netflix‐ribbon</artifactId>
     </exclusion>
   </exclusions>
 </dependency>

注意： nacos-discovery中引入了ribbon，需要移除ribbon的包 如果不移除，也可以在yml中配置不使用ribbon。
默认情况下，如果同时拥有 RibbonLoadBalancerClient和BlockingLoadBalancerClient，为了保持向后兼容性，将使 用RibbonLoadBalancerClient。
要覆盖它，可以设置spring.cloud.loadbalancer.ribbon.enabled属性为false

spring:
  application:
    name: mall-user-loadbalancer-demo  #微服务名称

  #配置nacos注册中心地址
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

    # 不使用ribbon，使用loadbalancer
    loadbalancer:
      ribbon:
        enabled: false

使用@LoadBalanced

使用@LoadBalanced注解修饰RestTemplate，开启客户端负载均衡功能

@Configuration
public class RestConfig {

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

WebClient整合LoadBalancer

引入依赖

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

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

 <!‐‐ nacos服务注册与发现 移除ribbon支持‐‐>
 <dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring‐cloud‐starter‐alibaba‐nacos‐discovery</artifactId>
   <exclusions>
     <exclusion>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring‐cloud‐starter‐netflix‐ribbon</artifactId>
     </exclusion>
   </exclusions>
 </dependency>

配置WebClient作为负载均衡器的client

@Configuration
public class WebClientConfig {

    @LoadBalanced
    @Bean
    WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }

    @Bean
    WebClient webClient() {
        return webClientBuilder().build();
    }

}

使用

@Autowired
private WebClient webClient;

@RequestMapping(value = "/findOrderByUserId2/{id}")
public Mono<R> findOrderByUserIdWithWebClient(@PathVariable("id") Integer id) {

    String url = "http://mall-order/order/findOrderByUserId/"+id;
    //基于WebClient
    Mono<R> result = webClient.get().uri(url).retrieve().bodyToMono(R.class);
    return result;
}

原理： 底层会使用ReactiveLoadBalancer

引入webFlux

@Autowired
private ReactorLoadBalancerExchangeFilterFunction lbFunction;

@RequestMapping(value = "/findOrderByUserId3/{id}")
public Mono<R> findOrderByUserIdWithWebFlux(@PathVariable("id") Integer id) {

    String url = "http://mall-order/order/findOrderByUserId/"+id;
    //基于WebClient+webFlux
    Mono<R> result = WebClient.builder()
    .filter(lbFunction)
    .build()
    .get()
    .uri(url)
    .retrieve()
    .bodyToMono(R.class);
    return result;
}