首页 > 代码库 > Spring Cloud Netflix负载均衡组件Ribbon介绍

Spring Cloud Netflix负载均衡组件Ribbon介绍

Netflix:[‘netfli?ks]

ribbon:[?r?b?n][?r?b?n]
n. 带; 绶带; (打印机的) 色带; 带状物;
v. 把…撕成条带; 用缎带装饰; 形成带状;

  

LB方案分类

  目前主流的LB方案可分成两类:

  • 一种是集中式LB, 即在服务的消费方和提供方之间使用独立的LB设施(可以是硬件,如F5, 也可以是软件,如nginx), 由该设施负责把访问请求通过某种策略转发至服务的提供方;
  • 另一种是进程内LB,将LB逻辑集成到消费方,消费方从服务注册中心获知有哪些地址可用,然后自己再从这些地址中选择出一个合适的服务器。Ribbon就属于后者,它只是一个类库,集成于消费方进程,消费方通过它来获取到服务提供方的地址。

Ribbon介绍

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

Ribbon的主要组件与工作流程

Ribbon的核心组件(均为接口类型)有以下几个:

  • ServerList 
    用于获取地址列表。它既可以是静态的(提供一组固定的地址),也可以是动态的(从注册中心中定期查询地址列表)。

  • ServerListFilter 
    仅当使用动态ServerList时使用,用于在原始的服务列表中使用一定策略过虑掉一部分地址。

  • IRule 
    选择一个最终的服务地址作为LB结果。选择策略有轮询、根据响应时间加权、断路器(当Hystrix可用时)等。

Ribbon在工作时首选会通过ServerList来获取所有可用的服务列表,然后通过ServerListFilter过虑掉一部分地址,最后在剩下的地址中通过IRule选择出一台服务器作为最终结果。

与Eureka结合使用

当与Eureka组合使用Ribbon时,ServerList接口会使用DiscoveryEnabledNIWSServerList实现,该实现会通过 EurekaClient 向Eureka服务器获取可用的服务列表。ServerListFilter默认实现为ZonePreferenceServerListFilter,其作用是过虑掉不同zone下的服务(即优先选择同一个zone下的地址)。IRule使用ZoneAvoidanceRule实现,它是一种复合策略,同时使用ZoneAvoidancePredicateAvailabilityPredicate来判断是否选择某个server,前者以一个区域为单位判断可用性,对于不可用的区域整个丢弃,从剩下区域中选可用的server;后者用于过滤掉连接数过多和断路器处于打开状态的server。该复合策略经过上述两次过虑后最终选择出一个地址作为LB结果。

Ribbon提供的主要负载均衡策略介绍

简单轮询负载均衡(RoundRobin)

以轮询的方式依次将请求调度不同的服务器,即每次调度执行i = (i + 1) mod n,并选出第i台服务器。

Java代码  技术分享
  1.     Server server = null;  
  2.     int count = 0;  
  3.     while (server == null && count++ < 10) {  
  4.         List<Server> reachableServers = lb.getReachableServers();  
  5.         List<Server> allServers = lb.getAllServers();  
  6.         int upCount = reachableServers.size();  
  7.         int serverCount = allServers.size();  
  8.   
  9.         if ((upCount == 0) || (serverCount == 0)) {  
  10.             log.warn("No up servers available from load balancer: " + lb);  
  11.             return null;  
  12.         }  
  13.   
  14.         int nextServerIndex = incrementAndGetModulo(serverCount);  
  15.         server = allServers.get(nextServerIndex);  
  16.   
  17.         if (server == null) {  
  18.             /* Transient. */  
  19.             Thread.yield();  
  20.             continue;  
  21.         }  
  22.   
  23.         if (server.isAlive() && (server.isReadyToServe())) {  
  24.             return (server);  
  25.         }  
  26.   
  27.         // Next.  
  28.         server = null;  
  29.     }  
  30.   
  31.     if (count >= 10) {  
  32.         log.warn("No available alive servers after 10 tries from load balancer: "  
  33.                 + lb);  
  34.     }  
  35.     return server;  
  36.   
  37. ///////////////////////////////////////////////////////////////////  
  38. /** 
  39.  * Inspired by the implementation of {@link AtomicInteger#incrementAndGet()}. 
  40.  * 
  41.  * @param modulo The modulo to bound the value of the counter. 
  42.  * @return The next value. 
  43.  */  
  44. private int incrementAndGetModulo(int modulo) {  
  45.     for (;;) {  
  46.         int current = nextServerCyclicCounter.get();  
  47.         int next = (current + 1) % modulo;  
  48.         if (nextServerCyclicCounter.compareAndSet(current, next))  
  49.             return next;  
  50.     }  
  51. }  

 

加权响应时间负载均衡 (WeightedResponseTime)

Html代码  技术分享
  1. The basic idea for weighted round robin has been obtained from JCS  
  2.   The implementation for choosing the endpoint from the list of endpoints  
  3.   is as follows:Let‘s assume 4 endpoints:A(wt=10), B(wt=30), C(wt=40),   
  4.   D(wt=20).   
  5.     
  6.   Using the Random API, generate a random number between 1 and10+30+40+20.  
  7.   Let‘s assume that the above list is randomized. Based on the weights, we  
  8.   have intervals as follows:  
  9.     
  10.   1-----10 (A‘s weight)  
  11.     
  12.   11----40 (A‘s weight + B‘s weight)  
  13.     
  14.   41----80 (A‘s weight + B‘s weight + C‘s weight)  
  15.     
  16.   81----100(A‘s weight + B‘s weight + C‘s weight + D‘s weight)  
  17.     
  18.   Here‘s the psuedo code for deciding where to send the request:  
  19.     
  20.   if (random_number between 1 &amp; 10) {send request to A;}  
  21.     
  22.   else if (random_number between 11 &amp; 40) {send request to B;}  
  23.     
  24.   else if (random_number between 41 &amp; 80) {send request to C;}  
  25.     
  26.   else if (random_number between 81 &amp; 100) {send request to D;}  
  27.     

 

随机负载均衡 (Random)

随机选择状态为UP的Server

Java代码  技术分享
  1. int index = rand.nextInt(serverCount);  
  2. server = upList.get(index);  

 

区域感知轮询负载均衡(ZoneAware)

区域感知负载均衡内置电路跳闸逻辑,可被配置基于区域同源关系(Zone Affinity,也就是更倾向于选择发出调用的服务所在的托管区域内,这样可以降低延迟,节省成本)选择目标服务实例。它监控每个区域中运行实例的行为,而且能够实时的快速丢弃一整个区域。这样在面对整个区域故障时,帮我们提升了弹性。

Java代码  技术分享
  1. The key metric used to measure the zone condition is Average Active Requests,  
  2. which is aggregated per rest client per zone. It is the  
  3. total outstanding requests in a zone divided by number of available targeted instances (excluding circuit breaker tripped instances).  
  4. This metric is very effective when timeout occurs slowly on a bad zone.  
  5.   
  6. The  LoadBalancer will calculate and examine zone stats of all available zones. If the Average Active Requests for any zone has reached a configured threshold, this zone will be dropped from the active server list. In case more than one zone has reached the threshold, the zone with the most active requests per server will be dropped.  
  7. Once the the worst zone is dropped, a zone will be chosen among the rest with the probability proportional to its number of instances.  
  8. A server will be returned from the chosen zone with a given Rule (A Rule is a load balancing strategy, for example {@link AvailabilityFilteringRule})  
  9. For each request, the steps above will be repeated. That is to say, each zone related load balancing decisions are made at real time with the up-to-date statistics aiding the choice.  

 

具体实现:

Java代码  技术分享
  1. @Override  
  2. protected void setServerListForZones(Map<String, List<Server>> zoneServersMap) {  
  3.     super.setServerListForZones(zoneServersMap);  
  4.     if (balancers == null) {  
  5.         balancers = new ConcurrentHashMap<String, BaseLoadBalancer>();  
  6.     }  
  7.     for (Map.Entry<String, List<Server>> entry: zoneServersMap.entrySet()) {  
  8.         String zone = entry.getKey().toLowerCase();  
  9.         getLoadBalancer(zone).setServersList(entry.getValue());  
  10.     }  
  11.     // check if there is any zone that no longer has a server  
  12.     // and set the list to empty so that the zone related metrics does not  
  13.     // contain stale data  
  14.     for (Map.Entry<String, BaseLoadBalancer> existingLBEntry: balancers.entrySet()) {  
  15.         if (!zoneServersMap.keySet().contains(existingLBEntry.getKey())) {  
  16.             existingLBEntry.getValue().setServersList(Collections.emptyList());  
  17.         }  
  18.     }  
  19. }      
  20.       
  21. @Override  
  22. public Server chooseServer(Object key) {  
  23.     if (!ENABLED.get() || getLoadBalancerStats().getAvailableZones().size() <= 1) {  
  24.         logger.debug("Zone aware logic disabled or there is only one zone");  
  25.         return super.chooseServer(key);  
  26.     }  
  27.     Server server = null;  
  28.     try {  
  29.         LoadBalancerStats lbStats = getLoadBalancerStats();  
  30.         Map<String, ZoneSnapshot> zoneSnapshot = ZoneAvoidanceRule.createSnapshot(lbStats);  
  31.         logger.debug("Zone snapshots: {}", zoneSnapshot);  
  32.         if (triggeringLoad == null) {  
  33.             triggeringLoad = DynamicPropertyFactory.getInstance().getDoubleProperty(  
  34.                     "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".triggeringLoadPerServerThreshold", 0.2d);  
  35.         }  
  36.   
  37.         if (triggeringBlackoutPercentage == null) {  
  38.             triggeringBlackoutPercentage = DynamicPropertyFactory.getInstance().getDoubleProperty(  
  39.                     "ZoneAwareNIWSDiscoveryLoadBalancer." + this.getName() + ".avoidZoneWithBlackoutPercetage", 0.99999d);  
  40.         }  
  41.         Set<String> availableZones = ZoneAvoidanceRule.getAvailableZones(zoneSnapshot, triggeringLoad.get(), triggeringBlackoutPercentage.get());  
  42.         logger.debug("Available zones: {}", availableZones);  
  43.         if (availableZones != null &&  availableZones.size() < zoneSnapshot.keySet().size()) {  
  44.             String zone = ZoneAvoidanceRule.randomChooseZone(zoneSnapshot, availableZones);  
  45.             logger.debug("Zone chosen: {}", zone);  
  46.             if (zone != null) {  
  47.                 BaseLoadBalancer zoneLoadBalancer = getLoadBalancer(zone);  
  48.                 server = zoneLoadBalancer.chooseServer(key);  
  49.             }  
  50.         }  
  51.     } catch (Throwable e) {  
  52.         logger.error("Unexpected exception when choosing server using zone aware logic", e);  
  53.     }  
  54.     if (server != null) {  
  55.         return server;  
  56.     } else {  
  57.         logger.debug("Zone avoidance logic is not invoked.");  
  58.         return super.chooseServer(key);  
  59.     }  
  60. }  
  61.    
  62. @VisibleForTesting  
  63. BaseLoadBalancer getLoadBalancer(String zone) {  
  64.     zone = zone.toLowerCase();  
  65.     BaseLoadBalancer loadBalancer = balancers.get(zone);  
  66.     if (loadBalancer == null) {  
  67.         // We need to create rule object for load balancer for each zone  
  68.         IRule rule = cloneRule(this.getRule());  
  69.         loadBalancer = new BaseLoadBalancer(this.getName() + "_" + zone, rule, this.getLoadBalancerStats());  
  70.         BaseLoadBalancer prev = balancers.putIfAbsent(zone, loadBalancer);  
  71.         if (prev != null) {  
  72.             loadBalancer = prev;  
  73.         }  
  74.     }   
  75.     return loadBalancer;          
  76. }  
  77.   
  78. private IRule cloneRule(IRule toClone) {  
  79.     IRule rule;  
  80.     if (toClone == null) {  
  81.         rule = new AvailabilityFilteringRule();  
  82.     } else {  
  83.         String ruleClass = toClone.getClass().getName();                  
  84.         try {  
  85. rule = (IRule) ClientFactory.instantiateInstanceWithClientConfig(ruleClass, this.getClientConfig());  
  86.  catch (Exception e) {  
  87. throw new RuntimeException("Unexpected exception creating rule for ZoneAwareLoadBalancer", e);  
  88.   
  89.     }  
  90.     return rule;  
  91. }  
  92.   
  93.      
  94. @Override  
  95. public void setRule(IRule rule) {  
  96.     super.setRule(rule);  
  97.     if (balancers != null) {  
  98.         for (String zone: balancers.keySet()) {  
  99.             balancers.get(zone).setRule(cloneRule(rule));  
  100.         }  
  101.     }  
  102. }  

 

 

Ribbon自带负载均衡策略比较(转)

策略名策略声明策略描述实现说明
BestAvailableRulepublic class BestAvailableRule extends ClientConfigEnabledRoundRobinRule选择一个最小的并发请求的server逐个考察Server,如果Server被tripped了,则忽略,在选择其中ActiveRequestsCount最小的server
AvailabilityFilteringRulepublic class AvailabilityFilteringRule extends PredicateBasedRule过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server,并过滤掉那些高并发的的后端server(active connections 超过配置的阈值)使用一个AvailabilityPredicate来包含过滤server的逻辑,其实就就是检查status里记录的各个server的运行状态
WeightedResponseTimeRulepublic class WeightedResponseTimeRule extends RoundRobinRule根据相应时间分配一个weight,相应时间越长,weight越小,被选中的可能性越低。一个后台线程定期的从status里面读取评价响应时间,为每个server计算一个weight。Weight的计算也比较简单responsetime 减去每个server自己平均的responsetime是server的权重。当刚开始运行,没有形成statas时,使用roubine策略选择server。
RetryRulepublic class RetryRule extends AbstractLoadBalancerRule对选定的负载均衡策略机上重试机制。在一个配置时间段内当选择server不成功,则一直尝试使用subRule的方式选择一个可用的server
RoundRobinRulepublic class RoundRobinRule extends AbstractLoadBalancerRuleroundRobin方式轮询选择server轮询index,选择index对应位置的server
RandomRulepublic class RandomRule extends AbstractLoadBalancerRule随机选择一个server在index上随机,选择index对应位置的server
ZoneAvoidanceRulepublic class ZoneAvoidanceRule extends PredicateBasedRule复合判断server所在区域的性能和server的可用性选择server使用ZoneAvoidancePredicate和AvailabilityPredicate来判断是否选择某个server,前一个判断判定一个zone的运行性能是否可用,剔除不可用的zone(的所有server),AvailabilityPredicate用于过滤掉连接数过多的Server。

 

Ribbon架构图

技术分享 Ribbon使用举例:

1. 创建Maven项目:

Xml代码  技术分享
  1. <dependency>  
  2.     <groupId>com.netflix.ribbon</groupId>  
  3.     <artifactId>ribbon-core</artifactId>  
  4.     <version>2.2.0</version>  
  5. </dependency>  
  6. <dependency>  
  7.     <groupId>com.netflix.ribbon</groupId>  
  8.     <artifactId>ribbon-httpclient</artifactId>  
  9.     <version>2.2.0</version>  
  10. </dependency>  

 

2. 配置properties file (sample-client.properties)

Java代码  技术分享
  1. # Max number of retries   
  2. sample-client.ribbon.MaxAutoRetries=1  
  3.   
  4. # Max number of next servers to retry (excluding the first server)  
  5. sample-client.ribbon.MaxAutoRetriesNextServer=1  
  6.   
  7. # Whether all operations can be retried for this client  
  8. sample-client.ribbon.OkToRetryOnAllOperations=true  
  9.   
  10. # Interval to refresh the server list from the source  
  11. sample-client.ribbon.ServerListRefreshInterval=2000  
  12.   
  13. # Connect timeout used by Apache HttpClient  
  14. sample-client.ribbon.ConnectTimeout=3000  
  15.   
  16. # Read timeout used by Apache HttpClient  
  17. sample-client.ribbon.ReadTimeout=3000  
  18.   
  19. # Initial list of servers, can be changed via Archaius dynamic property at runtime  
  20. sample-client.ribbon.listOfServers=www.sohu.com:80,www.163.com:80,www.sina.com.cn:80  
  21.   
  22. sample-client.ribbon.EnablePrimeConnections=true  

 

3. 代码:

Java代码  技术分享
  1. public static void main( String[] args ) throws Exception {  
  2.     ConfigurationManager.loadPropertiesFromResources("sample-client.properties");  
  3.     System.out.println(ConfigurationManager.getConfigInstance().getProperty("sample-client.ribbon.listOfServers"));  
  4.       
  5.     RestClient client = (RestClient)ClientFactory.getNamedClient("sample-client");  
  6.     HttpRequest request = HttpRequest.newBuilder().uri(new URI("/")).build();  
  7.       
  8.     for(int i = 0; i < 20; i ++) {  
  9.         HttpResponse response = client.executeWithLoadBalancer(request);  
  10.         System.out.println("Status for URI:" + response.getRequestedURI() + " is :" + response.getStatus());  
  11.     }  
  12.       
  13.     ZoneAwareLoadBalancer lb = (ZoneAwareLoadBalancer) client.getLoadBalancer();  
  14.     System.out.println(lb.getLoadBalancerStats());  
  15.       
  16.     ConfigurationManager.getConfigInstance().setProperty("sample-client.ribbon.listOfServers", "www.baidu.com:80,www.linkedin.com:80");  
  17.       
  18.     System.out.println("changing servers ...");  
  19.     Thread.sleep(3000);  
  20.       
  21.     for(int i = 0; i < 20; i ++) {  
  22.         HttpResponse response = client.executeWithLoadBalancer(request);  
  23.         System.out.println("Status for URI:" + response.getRequestedURI() + " is :" + response.getStatus());  
  24.     }  
  25.     System.out.println(lb.getLoadBalancerStats());  
  26. }  

Spring Cloud Netflix负载均衡组件Ribbon介绍