Netflix:[‘netfli?ks]

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实现，它是一种复合策略，同时使用ZoneAvoidancePredicate和AvailabilityPredicate来判断是否选择某个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自带负载均衡策略比较（转）

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介绍