程序博客网 > c语言编程步骤

Flume之Failover和Load balancing原理及实例

来源：互联网 发布：c语言编程步骤 编辑：程序博客网 时间：2024/05/11 11:21

Failover Sink Processor

Failover Sink Processor维护了一个sink的优先级列表，具有故障转移的功能，具体的配置如下（加粗的必须配置）：

属性名称默认值描述sinks–多个sink用空格分开。processor.typedefault组件的名称，必须是：failoverprocessor.priority.<sinkName>–优先级值。<sinkName> 必须是sinks中有定义的。优先级值高Sink会更早被激活。值越大，优先级越高。
注：多个sinks的话，优先级的值不要相同，如果优先级相同的话，只会有一个生效。且failover时，同优先级的不会Failover，就算是同优先级的还存在也会报All sinks failed to process。processor.maxpenalty30000失败的Sink最大的退避时间(单位：毫秒)（退避算法(退避算法为我们在解决重试某项任务的时候，提供了一个比较好的等待思想。)，参考：http://qiuqiang1985.iteye.com/blog/1513049）

示例：

a1.sinkgroups = g1a1.sinkgroups.g1.sinks = k1 k2a1.sinkgroups.g1.processor.type = failovera1.sinkgroups.g1.processor.priority.k1 = 5a1.sinkgroups.g1.processor.priority.k2 = 10a1.sinkgroups.g1.processor.maxpenalty = 10000

Load balancing Sink Processor

Load balancing sink processor 提供了多个sinks负载均衡的能力。它维护了一个active sinks列表，该列表中的负载必须是分布式的。实现了round_robin(轮询调度) 或者 random（随机） 的选择机制，默认是：round_robin(轮询调度)。也可以通过继承AbstractSinkSelector类来实现自定义的选择机制。
当被调用时，选择器根据配置文件的选择机制挑选下一个sink，并且调用该sink。如果所选的Sink传递Event失败，则通过选择机制挑选下一个可用的Sink，以此类推。

属性名称默认描述processor.sinks–多个sink用空格分开。processor.typedefault组件的名称，必须是：load_balanceprocessor.backofffalse是否以指数的形式退避失败的Sinks。processor.selectorround_robin选择机制。必须是round_robin, random 或者自定义的类，该类继承了AbstractSinkSelectorprocessor.selector.maxTimeOut30000默认是30000毫秒，屏蔽故障sink的时间

示例：

a1.sinkgroups = g1a1.sinkgroups.g1.sinks = k1 k2a1.sinkgroups.g1.processor.type = load_balancea1.sinkgroups.g1.processor.backoff = truea1.sinkgroups.g1.processor.selector = random

Failover和Load balancing实例

测试环境：

10.0.1.76（Client）

10.0.1.68 （Failover和Load balancing）

10.0.1.70

10.0.1.77

10.0.1.85

10.0.1.86

10.0.1.87

以10.0.1.76作为客户端，通过exec获取nginx的日志信息，然后将数据传到10.0.1.68（配置了Failover和Load balancing）的节点，最后10.0.1.68将数据发送的10.0.1.70，77，85，86，87节点，这些节点最终将数据写到本地硬盘。

10.0.1.76的配置：

[java] view plain copy
  1. a1.channels.c1.type = memory  
  2. a1.channels.c1.capacity = 1000  
  3. a1.channels.c1.transactionCapacity = 100  
  4.         
  5. a1.sources.r1.channels = c1  
  6. a1.sources.r1.type = exec  
  7. a1.sources.r1.command = tail -n 0 -F /home/nginx/logs/access.log   
  8.   
  9. a1.sinks.k1.type = avro  
  10. a1.sinks.k1.channel = c1  
  11. a1.sinks.k1.hostname = 10.0.1.68  
  12. a1.sinks.k1.port = 41415  
  13.   
  14. a1.channels = c1  
  15. a1.sources = r1  
  16. a1.sinks = k1  
获取nginx产生的日志，然后通过avro发送的10.0.1.68


10.0.1.68配置（配置A）：

[java] view plain copy
  1. a1.channels = c1  
  2. a1.sources = r1  
  3. a1.sinks = k70 k77 k85 k86 k87  
  4.   
  5. a1.sinkgroups = g1 g2 g3  
  6. a1.sinkgroups.g1.sinks = k70 k85  
  7. a1.sinkgroups.g1.processor.type = load_balance  
  8. a1.sinkgroups.g1.processor.selector = round_robin  
  9. a1.sinkgroups.g1.processor.backoff = true  
  10.   
  11. a1.sinkgroups.g2.sinks = k70 k86  
  12. a1.sinkgroups.g2.processor.type = failover    
  13. a1.sinkgroups.g2.processor.priority.k70 = 20  
  14. a1.sinkgroups.g2.processor.priority.k86 = 10  
  15. a1.sinkgroups.g2.processor.maxpenalty = 10000   
  16.   
  17. a1.sinkgroups.g3.sinks = k85 k87 k77  
  18. a1.sinkgroups.g3.processor.type = failover  
  19. a1.sinkgroups.g3.processor.priority.k85 = 20  
  20. a1.sinkgroups.g3.processor.priority.k87 = 10  
  21. a1.sinkgroups.g3.processor.priority.k77 = 5  
  22. a1.sinkgroups.g3.processor.maxpenalty = 10000  
  23.   
  24. a1.channels.c1.type = memory  
  25. a1.channels.c1.capacity = 1000  
  26. a1.channels.c1.transactionCapacity = 100  
  27.   
  28. a1.sources.r1.channels = c1  
  29. a1.sources.r1.type = avro  
  30. a1.sources.r1.bind = 0.0.0.0  
  31. a1.sources.r1.port = 41415  
  32.   
  33. a1.sinks.k87.channel = c1  
  34. a1.sinks.k87.type = avro  
  35. a1.sinks.k87.hostname = 10.0.1.87  
  36. a1.sinks.k87.port = 41414  
  37.   
  38. a1.sinks.k86.channel = c1  
  39. a1.sinks.k86.type = AVRO  
  40. a1.sinks.k86.hostname = 10.0.1.86  
  41. a1.sinks.k86.port = 41414  
  42.   
  43. a1.sinks.k85.channel = c1  
  44. a1.sinks.k85.type = AVRO  
  45. a1.sinks.k85.hostname = 10.0.1.85  
  46. a1.sinks.k85.port = 41414  
  47.   
  48. a1.sinks.k77.channel = c1  
  49. a1.sinks.k77.type = AVRO  
  50. a1.sinks.k77.hostname = 10.0.1.77  
  51. a1.sinks.k77.port = 41414  
  52.   
  53. a1.sinks.k70.channel = c1  
  54. a1.sinks.k70.type = AVRO  
  55. a1.sinks.k70.hostname = 10.0.1.70  
  56. a1.sinks.k70.port = 41414  
10.0.1.70和10.0.1.85Load balancing，均衡的方式为轮询调用。10.0.1.70和10.0.1.86为Failover，10.0.1.70和10.0.1.87为Failover


10.0.1.70，77，85，86，87配置：

[java] view plain copy
  1. a1.channels = c1  
  2. a1.sources = r1  
  3. a1.sinks = k1  
  4.         
  5. a1.channels.c1.type = memory  
  6. a1.channels.c1.capacity = 1000  
  7. a1.channels.c1.transactionCapacity = 100  
  8.   
  9. a1.sources.r1.channels = c1  
  10. a1.sources.r1.type = AVRO  
  11. a1.sources.r1.bind = 0.0.0.0  
  12. a1.sources.r1.port = 41414  
  13.   
  14. a1.sinks.k1.channel = c1  
  15. a1.sinks.k1.type = file_roll  
  16. a1.sinks.k1.sink.directory = /data/load/  
  17. a1.sinks.k1.sink.rollInterval = 0  
通过Avro获取到Event，存放到文件中。


每次往nginx发2w个请求，然后查看10.0.1.70，77，85，86，87四台服务器接受数据的情况。我们做几组测试：

注：表格中的 * 表示关闭关闭该服务器Flume进程。

测试一：

发送2w个请求到Nginx中，查看各个节点接受数据的行数：

服务器
10.0.1.70
10.0.1.77
10.0.1.85
10.0.1.86
10.0.1.87
总计
数据行数
3400
0
3459
6778
6363
20000

其实无论测试2w次请求，还是测试100w次请求，10.0.1.77都无法接受到数据。

测试二：

服务器
10.0.1.70
10.0.1.77
10.0.1.85
10.0.1.86
10.0.1.87(*)
总计
数据行数
6619
6300
6840
13878
6363
40000

问题1: 作为Failover的节点86，87为何可以接受数据，而77没有将接收数据呢？

作为failover，我们会认为只有一个节点生效，其他节点只有在优先级节点down掉才能替补上去，在Flume中关于failover的实现，首先我们要了解Flume加载配置文件是有顺序的。如果配置文件的顺序不同，会导致failover出乎我们的意料，现在我们把上面的（配置A）关于failover和load_balance修改成如下（部分代码）：

[java] view plain copy
  1. ......  
  2. a1.sinkgroups = g2 g1 g3  
  3. a1.sinkgroups.g3.sinks = k70 k85  
  4. a1.sinkgroups.g3.processor.type = load_balance  
  5. a1.sinkgroups.g3.processor.selector = round_robin  
  6. a1.sinkgroups.g3.processor.backoff = true  
  7.   
  8. a1.sinkgroups.g2.sinks = k70 k86  
  9. a1.sinkgroups.g2.processor.type = failover    
  10. a1.sinkgroups.g2.processor.priority.k70 = 20  
  11. a1.sinkgroups.g2.processor.priority.k86 = 10  
  12. a1.sinkgroups.g2.processor.maxpenalty = 10000   
  13.   
  14. a1.sinkgroups.g1.sinks = k85 k87 k77  
  15. a1.sinkgroups.g1.processor.type = failover  
  16. a1.sinkgroups.g1.processor.priority.k85 = 20  
  17. a1.sinkgroups.g1.processor.priority.k87 = 10  
  18. a1.sinkgroups.g1.processor.priority.k77 = 5  
  19. a1.sinkgroups.g1.processor.maxpenalty = 10000  
  20. ......  
如果修改成如下的配置，启动时报如下错误：

[java] view plain copy
  1. WARN 2015-10-22 14:22:01 [org.apache.flume.conf.FlumeConfiguration] - Could not configure sink group g3 due to: No available sinks for sinkgroup: g3. Sinkgroup will be removed  
  2. org.apache.flume.conf.ConfigurationException: No available sinks for sinkgroup: g3. Sinkgroup will be removed  
  3.     at org.apache.flume.conf.FlumeConfiguration$AgentConfiguration.validateGroups(FlumeConfiguration.java:754)  
  4.     at org.apache.flume.conf.FlumeConfiguration$AgentConfiguration.isValid(FlumeConfiguration.java:348)  
  5.     at org.apache.flume.conf.FlumeConfiguration$AgentConfiguration.access$0(FlumeConfiguration.java:313)  
  6.     at org.apache.flume.conf.FlumeConfiguration.validateConfiguration(FlumeConfiguration.java:127)  
  7.     at org.apache.flume.conf.FlumeConfiguration.<init>(FlumeConfiguration.java:109)  
  8. 。。。。。。  
报异常的原因，我们可以查看源码，找到答案，FlumeConfiguration类的isValid()方法：

[java] view plain copy
  1. sourceSet = validateSources(channelSet);  
  2. sinkSet = validateSinks(channelSet);  
  3. sinkgroupSet = validateGroups(sinkSet);  
上述是主要的源码片段，可以Debug进去看看，大致的流程：以validateGroups为例，Flume根据sinkgroups顺序的解析配置文件，然后把sink放到变量名为usedSinks的Map当中，每个sink只能使用一次，如果sink在前面某个sinkgroups已经使用，那么就会在该sinkgroups中删除这个sink。按上面的配置，Flume开始解析sinkgroups的g1，则g1包含k85，k87和k77三个有效sink；然后解析sinkgroups的g2，则g2包含k70和k86；解析sinkgroups的g3时，因为k70和k85已经在g1和g2存在了，所以g3包含的sink为空，才导致报如上的错误。也就是说Flume是根据usedSinks来实现failover和load_balance的，因为配置的原因，可能会跟你想象的效果相差甚远。

在AbstractConfigurationProvider类的getConfiguration方法，代码片段：

[java] view plain copy
  1.   public MaterializedConfiguration getConfiguration() {  
  2.     MaterializedConfiguration conf = new SimpleMaterializedConfiguration();  
  3.     FlumeConfiguration fconfig = getFlumeConfiguration();//加载和验证配置文件的入口  
  4.     AgentConfiguration agentConf = fconfig.getConfigurationFor(getAgentName());  
  5.     if (agentConf != null) {  
  6.       Map<String, ChannelComponent> channelComponentMap = Maps.newHashMap();  
  7.       Map<String, SourceRunner> sourceRunnerMap = Maps.newHashMap();  
  8.       Map<String, SinkRunner> sinkRunnerMap = Maps.newHashMap();  
  9.       try {  
  10.         loadChannels(agentConf, channelComponentMap);//初始化channel  
  11.         loadSources(agentConf, channelComponentMap, sourceRunnerMap);//初始化source  
  12.         loadSinks(agentConf, channelComponentMap, sinkRunnerMap);//初始化sink  
  13. ......  

验证完之后，加载Channels，Sources，Sinks，根据验证的结果g1，g2，g3的usedSinks分配如下（配置A）：

g1 的usedSinks是：k70和k85

g2 的usedSinks是：k86

g3 的usedSinks是：k87，k77

以loadSinks为例，加载Sink，先调用AbstractConfigurationProvider类的loadSinks方法，然后调用loadSinkGroups方法来初始化Sink，g1的usedSinks有k70和k85，所以k70和k85这两个节点通过round_robin方式balance来接收数据；g2的usedSinks只有k86（由于k70已经在g1中被占用了），所以只有k86接收数据，自然也不会有failover的功能；g3的usedSinks有k87和k77，由于Failover会选取优先级最高的接收数据，所以k87接收数据，当k87挂掉的时候，k77替补上去接收数据。这也就是为何其他节点都可以接收数据，唯独只有k77没有数据的原因。

再者每个sinkgroups都会启动一个SinkRunner线程去调用FailoverSinkProcessor和LoadBalancingSinkProcessor的process()方法去获取数据，这也就是为啥Failover和balance都能接收数据的原因，具体的实现细节，可以自行阅读源码。


2，Failover的情况下，是否优先级越高的就先生效？

是的，同一个Failover下的sink都存放在TreeMap下，然后取最大优先级的Sink作为activeSink。


3，Failover的情况下，如果优先级相同是怎么做失败转移的？

优先级相同的sink节点在failover中只会有一个生效，看源码可以很容易的发现，因为Failover中live的Sink存放在TreeMap中，用优先级作为key，同等优先级的Sink只能保存一个。

[java] view plain copy
  1. @Override  
  2.   public void configure(Context context) {  
  3.     liveSinks = new TreeMap<Integer, Sink>();  //存活的Sink放在TreeMap中，且用priority作为Key  
  4.     failedSinks = new PriorityQueue<FailedSink>();  
  5.     Integer nextPrio = 0;  
  6.     String maxPenaltyStr = context.getString(MAX_PENALTY_PREFIX);  
  7.     if(maxPenaltyStr == null) {  
  8.       maxPenalty = DEFAULT_MAX_PENALTY;  
  9.     } else {  
  10.       try {  
  11.         maxPenalty = Integer.parseInt(maxPenaltyStr);  
  12.       } catch (NumberFormatException e) {  
  13.         logger.warn("{} is not a valid value for {}",  
  14.                 new Object[] { maxPenaltyStr, MAX_PENALTY_PREFIX });  
  15.         maxPenalty  = DEFAULT_MAX_PENALTY;  
  16.       }  
  17.     }  
  18.     for (Entry<String, Sink> entry : sinks.entrySet()) {  
  19.       String priStr = PRIORITY_PREFIX + entry.getKey();  
  20.       Integer priority;  
  21.       try {  
  22.         priority =  Integer.parseInt(context.getString(priStr));  
  23.       } catch (Exception e) {  
  24.         priority = --nextPrio;  
  25.       }  
  26.       if(!liveSinks.containsKey(priority)) {  
  27.         liveSinks.put(priority, sinks.get(entry.getKey()));//priority作为Key  
  28.       } else {  
  29.         logger.warn("Sink {} not added to FailverSinkProcessor as priority" +  
  30.             "duplicates that of sink {}", entry.getKey(),  
  31.             liveSinks.get(priority));  
  32.       }  
  33.     }  
  34.     activeSink = liveSinks.get(liveSinks.lastKey());//获取优先级最高的节点作为active节点  
  35.     

总结

1，load_balance配置中的Sink都可以接收数据。

2，load_balance根据均衡策略接收数据。

3，没有Sink既能failover又能load_balance。

4，failover中的Sink优先级不要设置为相同的值。

5，failover配置中的Sink只有优先级最高及没有被之前加载的sinkgroups占用的Sink接收数据，如果优先级高的Sink挂掉，则转到优先级次之的Sink。

6，failover可以做失败转移，如果因为加载顺序的问题，导致failover的Sink已经被占用，failover会造成配置在failover中的sink都能接收数据的假象，其实只是在剩余的sink中实施failover策略。

阅读全文
0 0
c语言编程步骤 c语言编程步骤
原创粉丝点击
热门IT博客
使命召唤13优化补丁使命召唤13优化补丁
淘宝充气娃娃视频淘宝充气娃娃视频
程序员的团队合作
阿里云销售 区域经理
linux snmp oid
专业seo公司
拒绝网络贷款承诺书
服务器软件
ddiction动作数据
上海网络电视台直播
js json对象作为参数
网络广告词大全2016年
双轨制对碰算法
软件项目管理流程文档
不得不爱c920调试软件
ubuntu 16.04国内镜像
游族网络 权力的游戏
网络存储方案
mysql官网地址
裘德洛妻子知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 云计算运维 远程教育云平台 远程教育云下载 微软云适配 163手机适配 歌词适配app 126适配 适配测试 muiu11适配机型 flyme8适配机型 老爹鞋适不适合配阔腿裤 太子云迟选妃 不思议迷宫出云岛神木选那个 云选房 云通讯录 云通讯邮箱 263企业邮箱云通讯 263云通信企业邮箱 云通信263下载 263企业邮箱云通信 云通关 云海在线连云港教育云通app 保定通公交云卡 云通卡app下载高版本 康熙通宝背云 云通讯平台 云通讯 借云快贷 云速贷app 云速贷 雪铁龙云逸 云汐逸宸618688 云清墨逸 墨逸云清 雪铁龙云逸怎么样 东风雪铁龙云逸 总裁爹地霸道宠 简云逸 云遮月 云门户 云网 云来斯堡酒店

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里