YARN的内存和CPU配置

最新推荐文章于 2024-04-29 09:56:41 发布
最新推荐文章于 2024-04-29 09:56:41 发布
阅读量1k 收藏 3
点赞数
分类专栏： Hadoop


2016年11月21日 09:50:07
阅读数：267

Hadoop YARN同时支持内存和CPU两种资源的调度，本文介绍如何配置YARN对内存和CPU的使用。

YARN作为一个资源调度器，应该考虑到集群里面每一台机子的计算资源，然后根据application申请的资源进行分配Container。Container是YARN里面资源分配的基本单位，具有一定的内存以及CPU资源。

在YARN集群中，平衡内存、CPU、磁盘的资源的很重要的，根据经验，每两个container使用一块磁盘以及一个CPU核的时候可以使集群的资源得到一个比较好的利用。

内存配置

关于内存相关的配置可以参考hortonwork公司的文档Determine HDP Memory Configuration Settings来配置你的集群。

YARN以及MAPREDUCE所有可用的内存资源应该要除去系统运行需要的以及其他的hadoop的一些程序，总共保留的内存=系统内存+HBASE内存。

可以参考下面的表格确定应该保留的内存：

每台机子内存系统需要的内存HBase需要的内存
4GB1GB1GB
8GB2GB1GB
16GB2GB2GB
24GB4GB4GB
48GB6GB8GB
64GB8GB8GB
72GB8GB8GB
96GB12GB16GB
128GB24GB24GB
255GB32GB32GB
512GB64GB64GB

计算每台机子最多可以拥有多少个container，可以使用下面的公式:

containers = min (2*CORES, 1.8*DISKS, (Total available RAM) / MIN_CONTAINER_SIZE)

说明：

  • CORES为机器CPU核数
  • DISKS为机器上挂载的磁盘个数
  • Total available RAM为机器总内存
  • MIN_CONTAINER_SIZE是指container最小的容量大小，这需要根据具体情况去设置，可以参考下面的表格：
每台机子可用的RAMcontainer最小值
小于4GB256MB
4GB到8GB之间512MB
8GB到24GB之间1024MB
大于24GB2048MB

每个container的平均使用内存大小计算方式为：

RAM-per-container = max(MIN_CONTAINER_SIZE, (Total Available RAM) / containers))

通过上面的计算，YARN以及MAPREDUCE可以这样配置：

配置文件配置设置默认值计算值
yarn-site.xmlyarn.nodemanager.resource.memory-mb8192 MB= containers * RAM-per-container
yarn-site.xmlyarn.scheduler.minimum-allocation-mb1024MB= RAM-per-container
yarn-site.xmlyarn.scheduler.maximum-allocation-mb8192 MB= containers * RAM-per-container
yarn-site.xml (check)yarn.app.mapreduce.am.resource.mb1536 MB= 2 * RAM-per-container
yarn-site.xml (check)yarn.app.mapreduce.am.command-opts-Xmx1024m= 0.8 * 2 * RAM-per-container
mapred-site.xmlmapreduce.map.memory.mb1024 MB= RAM-per-container
mapred-site.xmlmapreduce.reduce.memory.mb1024 MB= 2 * RAM-per-container
mapred-site.xmlmapreduce.map.java.opts = 0.8 * RAM-per-container
mapred-site.xmlmapreduce.reduce.java.opts = 0.8 * 2 * RAM-per-container

举个例子：对于128G内存、32核CPU的机器，挂载了7个磁盘，根据上面的说明，系统保留内存为24G，不适应HBase情况下，系统剩余可用内存为104G，计算containers值如下：

containers = min (2*32, 1.8* 7 , (128-24)/2) = min (64, 12.6 , 51) = 13

计算RAM-per-container值如下：

RAM-per-container = max (2, (124-24)/13) = max (2, 8) = 8

你也可以使用脚本yarn-utils.py来计算上面的值：

  1. #!/usr/bin/env python
  2. import optparse
  3. from pprint import pprint
  4. import logging
  5. import sys
  6. import math
  7. import ast
  9. ''' Reserved for OS + DN + NM, Map: Memory => Reservation '''
  10. reservedStack = { 4 : 1 , 8 : 2 , 16 : 2 , 24 : 4 , 48 : 6 , 64 : 8 , 72 : 8 , 96 : 12 ,
  11. 128 : 24 , 256 : 32 , 512 : 64 }
  12. ''' Reserved for HBase. Map: Memory => Reservation '''
  14. reservedHBase = { 4 : 1 , 8 : 1 , 16 : 2 , 24 : 4 , 48 : 8 , 64 : 8 , 72 : 8 , 96 : 16 ,
  15. 128 : 24 , 256 : 32 , 512 : 64 }
  16. GB = 1024
  18. def getMinContainerSize ( memory ):
  19. if ( memory <= 4 ):
  20. return 256
  21. elif ( memory <= 8 ):
  22. return 512
  23. elif ( memory <= 24 ):
  24. return 1024
  25. else :
  26. return 2048
  27. pass
  29. def getReservedStackMemory ( memory ):
  30. if ( reservedStack . has_key ( memory )):
  31. return reservedStack [ memory ]
  32. if ( memory <= 4 ):
  33. ret = 1
  34. elif ( memory >= 512 ):
  35. ret = 64
  36. else :
  37. ret = 1
  38. return ret
  40. def getReservedHBaseMem ( memory ):
  41. if ( reservedHBase . has_key ( memory )):
  42. return reservedHBase [ memory ]
  43. if ( memory <= 4 ):
  44. ret = 1
  45. elif ( memory >= 512 ):
  46. ret = 64
  47. else :
  48. ret = 2
  49. return ret
  51. def main ():
  52. log = logging . getLogger ( __name__ )
  53. out_hdlr = logging . StreamHandler ( sys . stdout )
  54. out_hdlr . setFormatter ( logging . Formatter ( ' %(message) s' ))
  55. out_hdlr . setLevel ( logging . INFO )
  56. log . addHandler ( out_hdlr )
  57. log . setLevel ( logging . INFO )
  58. parser = optparse . OptionParser ()
  59. memory = 0
  60. cores = 0
  61. disks = 0
  62. hbaseEnabled = True
  63. parser . add_option ( '-c' , '--cores' , default = 16 ,
  64. help = 'Number of cores on each host' )
  65. parser . add_option ( '-m' , '--memory' , default = 64 ,
  66. help = 'Amount of Memory on each host in GB' )
  67. parser . add_option ( '-d' , '--disks' , default = 4 ,
  68. help = 'Number of disks on each host' )
  69. parser . add_option ( '-k' , '--hbase' , default = "True" ,
  70. help = 'True if HBase is installed, False is not' )
  71. ( options , args ) = parser . parse_args ()
  73. cores = int ( options . cores )
  74. memory = int ( options . memory )
  75. disks = int ( options . disks )
  76. hbaseEnabled = ast . literal_eval ( options . hbase )
  78. log . info ( "Using cores=" + str ( cores ) + " memory=" + str ( memory ) + "GB" +
  79. " disks=" + str ( disks ) + " hbase=" + str ( hbaseEnabled ))
  80. minContainerSize = getMinContainerSize ( memory )
  81. reservedStackMemory = getReservedStackMemory ( memory )
  82. reservedHBaseMemory = 0
  83. if ( hbaseEnabled ):
  84. reservedHBaseMemory = getReservedHBaseMem ( memory )
  85. reservedMem = reservedStackMemory + reservedHBaseMemory
  86. usableMem = memory - reservedMem
  87. memory -= ( reservedMem )
  88. if ( memory < 2 ):
  89. memory = 2
  90. reservedMem = max ( 0 , memory - reservedMem )
  92. memory *= GB
  94. containers = int ( min ( 2 * cores ,
  95. min ( math . ceil ( 1.8 * float ( disks )),
  96. memory / minContainerSize )))
  97. if ( containers <= 2 ):
  98. containers = 3
  100. log . info ( "Profile: cores=" + str ( cores ) + " memory=" + str ( memory ) + "MB"
  101. + " reserved=" + str ( reservedMem ) + "GB" + " usableMem="
  102. + str ( usableMem ) + "GB" + " disks=" + str ( disks ))
  104. container_ram = abs ( memory / containers )
  105. if ( container_ram > GB ):
  106. container_ram = int ( math . floor ( container_ram / 512 )) * 512
  107. log . info ( "Num Container=" + str ( containers ))
  108. log . info ( "Container Ram=" + str ( container_ram ) + "MB" )
  109. log . info ( "Used Ram=" + str ( int ( containers * container_ram / float ( GB ))) + "GB" )
  110. log . info ( "Unused Ram=" + str ( reservedMem ) + "GB" )
  111. log . info ( "yarn.scheduler.minimum-allocation-mb=" + str ( container_ram ))
  112. log . info ( "yarn.scheduler.maximum-allocation-mb=" + str ( containers * container_ram ))
  113. log . info ( "yarn.nodemanager.resource.memory-mb=" + str ( containers * container_ram ))
  114. map_memory = container_ram
  115. reduce_memory = 2 * container_ram if ( container_ram <= 2048 ) else container_ram
  116. am_memory = max ( map_memory , reduce_memory )
  117. log . info ( "mapreduce.map.memory.mb=" + str ( map_memory ))
  118. log . info ( "mapreduce.map.java.opts=-Xmx" + str ( int ( 0.8 * map_memory )) + "m" )
  119. log . info ( "mapreduce.reduce.memory.mb=" + str ( reduce_memory ))
  120. log . info ( "mapreduce.reduce.java.opts=-Xmx" + str ( int ( 0.8 * reduce_memory )) + "m" )
  121. log . info ( "yarn.app.mapreduce.am.resource.mb=" + str ( am_memory ))
  122. log . info ( "yarn.app.mapreduce.am.command-opts=-Xmx" + str ( int ( 0.8 * am_memory )) + "m" )
  123. log . info ( "mapreduce.task.io.sort.mb=" + str ( int ( 0.4 * map_memory )))
  124. pass
  126. if __name__ == '__main__' :
  127. try :
  128. main ()
  129. except ( KeyboardInterrupt , EOFError ):
  130. print ( " \n Aborting ... Keyboard Interrupt." )
  131. sys . exit ( 1 )

执行下面命令：

python yarn-utils.py -c 32 -m 128 -d 7 -k False

返回结果如下：

  1. Using cores = 32 memory=128GB disks=7 hbase=False
  2. Profile : cores=32 memory=106496MB reserved=24GB usableMem=104GB disks=7
  3. Num Container = 13
  4. Container Ram = 8192MB
  5. Used Ram = 104GB
  6. Unused Ram = 24GB
  7. yarn.scheduler.minimum-allocation- mb = 8192
  8. yarn.scheduler.maximum-allocation- mb = 106496
  9. yarn.nodemanager.resource.memory- mb = 106496
  10. mapreduce.map.memory.mb = 8192
  11. mapreduce.map.java.opts = -Xmx6553m
  12. mapreduce.reduce.memory.mb = 8192
  13. mapreduce.reduce.java.opts = -Xmx6553m
  14. yarn.app.mapreduce.am.resource.mb = 8192
  15. yarn.app.mapreduce.am.command- opts = -Xmx6553m
  16. mapreduce.task.io.sort.mb = 3276

这样的话，每个container内存为8G，似乎有点多，我更愿意根据集群使用情况任务将其调整为2G内存，则集群中下面的参数配置值如下：

配置文件配置设置计算值
yarn-site.xmlyarn.nodemanager.resource.memory-mb= 52 * 2 =104 G
yarn-site.xmlyarn.scheduler.minimum-allocation-mb= 2G
yarn-site.xmlyarn.scheduler.maximum-allocation-mb= 52 * 2 = 104G
yarn-site.xml (check)yarn.app.mapreduce.am.resource.mb= 2 * 2=4G
yarn-site.xml (check)yarn.app.mapreduce.am.command-opts= 0.8 * 2 * 2=3.2G
mapred-site.xmlmapreduce.map.memory.mb= 2G
mapred-site.xmlmapreduce.reduce.memory.mb= 2 * 2=4G
mapred-site.xmlmapreduce.map.java.opts= 0.8 * 2=1.6G
mapred-site.xmlmapreduce.reduce.java.opts= 0.8 * 2 * 2=3.2G

对应的xml配置为：

  1. <property>
  2. <name>yarn.nodemanager.resource.memory-mb </name>
  3. <value>106496 </value>
  4. </property>
  5. <property>
  6. <name>yarn.scheduler.minimum-allocation-mb </name>
  7. <value>2048 </value>
  8. </property>
  9. <property>
  10. <name>yarn.scheduler.maximum-allocation-mb </name>
  11. <value>106496 </value>
  12. </property>
  13. <property>
  14. <name>yarn.app.mapreduce.am.resource.mb </name>
  15. <value>4096 </value>
  16. </property>
  17. <property>
  18. <name>yarn.app.mapreduce.am.command-opts </name>
  19. <value>-Xmx3276m </value>
  20. </property>

另外，还有一下几个参数：

  • yarn.nodemanager.vmem-pmem-ratio：任务每使用1MB物理内存，最多可使用虚拟内存量，默认是2.1。
  • yarn.nodemanager.pmem-check-enabled：是否启动一个线程检查每个任务正使用的物理内存量，如果任务超出分配值，则直接将其杀掉，默认是true。
  • yarn.nodemanager.vmem-pmem-ratio：是否启动一个线程检查每个任务正使用的虚拟内存量，如果任务超出分配值，则直接将其杀掉，默认是true。

第一个参数的意思是当一个map任务总共分配的物理内存为2G的时候，该任务的container最多内分配的堆内存为1.6G，可以分配的虚拟内存上限为2*2.1=4.2G。另外，照这样算下去，每个节点上YARN可以启动的Map数为104/2=52个。

CPU配置

YARN中目前的CPU被划分成虚拟CPU（CPU virtual Core），这里的虚拟CPU是YARN自己引入的概念，初衷是，考虑到不同节点的CPU性能可能不同，每个CPU具有的计算能力也是不一样的，比如某个物理CPU的计算能力可能是另外一个物理CPU的2倍，这时候，你可以通过为第一个物理CPU多配置几个虚拟CPU弥补这种差异。用户提交作业时，可以指定每个任务需要的虚拟CPU个数。

在YARN中，CPU相关配置参数如下：

  • yarn.nodemanager.resource.cpu-vcores：表示该节点上YARN可使用的虚拟CPU个数，默认是8，注意，目前推荐将该值设值为与物理CPU核数数目相同。如果你的节点CPU核数不够8个，则需要调减小这个值，而YARN不会智能的探测节点的物理CPU总数。
  • yarn.scheduler.minimum-allocation-vcores：单个任务可申请的最小虚拟CPU个数，默认是1，如果一个任务申请的CPU个数少于该数，则该对应的值改为这个数。
  • yarn.scheduler.maximum-allocation-vcores：单个任务可申请的最多虚拟CPU个数，默认是32。

对于一个CPU核数较多的集群来说，上面的默认配置显然是不合适的，在我的测试集群中，4个节点每个机器CPU核数为31，留一个给操作系统，可以配置为：

  1. <property>
  2. <name>yarn.nodemanager.resource.cpu-vcores </name>
  3. <value>31 </value>
  4. </property>
  5. <property>
  6. <name>yarn.scheduler.maximum-allocation-vcores </name>
  7. <value>124 </value>
  8. </property>
王树民
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手工计算YARN和MapReduce、tez内存配置设置
涂作权的博客
10-02 1153
1.1.HDP YARN MapReduce参数调优建议 转自：https://blog.csdn.net/mnasd/article/details/81202908 1.1.1.RM的内存资源配置，配置的是资源调度相关 RM1：yarn.scheduler.minimum-allocation-mb 分配给AM单个容器可申请的最小内存（默认是1G） RM2：yarn.scheduler.maximum-allocation-mb 分配给AM单个容器可申请的最大内存（默认是yarn.nodemanager
Yarn下Mapreduce的内存参数理解&xml参数配置
热门推荐
z3935212的专栏
11-26 1万+
Hadoop&yarn内存参数解析&性能调优
修改hadoop集群的yarn.nodemanager.resource.cpu-vcores值
最新发布
qq_37263429的博客
04-29 132
修改数讯hadoop集群yarn.nodemanager.resource.cpu-vcores
YARN的Memory和CPU调优配置详解
01-05 521
Hadoop YARN同时支持内存和CPU两种资源的调度，本文介绍如何配置YARN对内存和CPU的使用。 YARN作为一个资源调度器，应该考虑到集群里面每一台机子的计算资源，然后根据application申请的资源进行分配Container。Container是YARN里面资源分配的基本单位，具有一定的内存以及CPU资源。 在YARN集群中，平衡内存、CPU、磁盘的资源的很重要的，根据经验，每...
YARN和MapReduce内存分配计算公式
TomAndersen的博客
06-08 2607
前言 hadoop：2.7.7 本文内容均来自：HDP Command Line Installation 2.6.5 中第1.10节 HDP（Hortonworks Data Platform）是最常见的Hadoop的第三方发行版之一，类似的Hadoop发行版还有CDH、MapR等 计算YARN和MapReduce的内存需求 在Hadoop集群中，YARN管理着集群中的每个节点上的可用资源，并为运行在集群中的应用程序（如MapReduce）提供需要的资源，其中Container是YARN中最小的资源
yarn内存和CPU配置
03-19
Yarn的内存和CPU配置宝典 ，帮助你理解并解决配置问题，优化配置
23、hadoop集群中yarn运行mapreduce的内存、CPU分配调度计算与优化
05-29
在Hadoop集群中，YARN（Yet Another Resource Negotiator）作为资源管理器，负责调度MapReduce任务的内存和CPU资源。YARN支持基于内存和CPU的两种资源调度策略，以确保集群资源的有效利用。在非默认配置下，合理地...
YARN内存配置计算脚本
07-14
一个计算yarn内存配置的python脚本yarn-util.py，该脚本有四个参数 参数 描述 -c CORES 每个节点CPU核数 -m MEMORY 每个节点内存总数（单位G） -d DISKS 每个节点的硬盘个数 -k HBASE 如果安装了Hbase则为True，...
hadoop yarn优化配置项生成工具
06-06
5. **yarn.app.mapreduce.am.resource.mb** 和 **yarn.app.mapreduce.am.resource.cpu-vcores**：应用程序管理器（Application Master）的内存和CPU资源需求。 6. **yarn.scheduler.capacity.root.default capacitiy...
YARN
01-20
5. Container：Container是YARN中的资源抽象，代表了一个计算单元，封装了节点上的内存、CPU、磁盘和网络等资源。当ApplicationMaster需要运行任务时，它会向ResourceManager申请Container，ResourceManager根据调度...
详解 YARN的内存和CPU配置
qq_43688472的博客
06-18 5671
一：简单介绍 Hadoop YARN同时支持内存和CPU两种资源的调度，本文介绍如何配置YARN对内存和CPU的使用。 YARN作为一个资源调度器，应该考虑到集群里面每一台机子的计算资源，然后根据application申请的资源进行分配Container。Container是YARN里面资源分配的基本单位，具有一定的内存以及CPU资源。 在YARN集群中，平衡内存、CPU、磁盘的资源的很重要的，根...
Hadoop基础教程-第5章 YARN：资源调度平台（5.2 YARN参数解读与调优）
与其临渊羡鱼 不如退而结网
06-30 309
第5章 YARN：资源调度平台 5.2 YARN参数解读与调优 yarn-site.xml文件默认参数：http://hadoop.apache.org/docs/r2.7.3/hadoop-yarn/hadoop-yarn-common/yarn-default.xml 5.2.1 ResourceManager相关配置参数 参数 默认值 说明 yarn.resourc...
MapReduce 从作业、任务（task）、管理员角度调优
iteye_14580的博客
10-14 547
【摘自hyj博主】 Hadoop为用户作业提供了多种可配置的参数，以允许用户根据作业特点调整这些参数值使作业运行效率达到最优。 一 应用程序编写规范 1.设置Combiner 对于一大批MapReduce程序，如果可以设置一个Combiner,那么对于提高作业性能是十分有帮助的。Combiner可减少Map Task中间输出的结果，从而减少各个Reduce Task的远程拷...
YARN资源配置
wflh323的专栏
02-15 1902
Yarn资源配置需要平衡服务器cpu，内存，磁盘资源。Hortonworks推荐两个Container使用1个cpu，1块磁盘能达到很好平衡。    Hortonworks提供了yarn内存参数设置脚本，执行yarn-utils.sh(下载地址https://docs.hortonworks.com/HDPDocuments/HDP2/HDP-2.1.1/bk_installing_manual...
如何判定并设置YARN 和MapReduce 内存
树蛙PHPER
08-06 5964
11.1. Manually Calculate YARN and MapReduce Memory Configuration Settings This section describes how to manually calculate YARN and MapReduce memory allocation settings based on the node hardware s
通过yarn提交perjob的flink任务设置内存和cpu
03-26
在使用yarn提交perjob的flink任务时，可以通过以下方式设置内存和CPU： 1. 通过--yarn-properties参数设置yarn的参数。示例命令： ``` yarn per-job -m 4g -yD yarn.app.mapreduce.am.resource.cpu-vcores=2 -yD...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值