学习链接：https://www.bilibili.com/video/BV1Qp4y1n7EN?p=125&spm_id_from=pageDriver

Yarn资源调度器

Yarn是一个资源调度平台，负责为运算程序提供服务器运算资源，相当于一个分布式的操作平台，MapReduce等运算程序相当于运行于操作系统之上的应用程序。

Yarn基础架构

YARN主要由ResourceManager、NodeManager、ApplicationMaster和Container等组件构成。
QQ截图20220511172022.png

Yarn工作机制

QQ截图20220511172116.png

  1. MR程序提交到客户端所在的节点
  2. YarnRunner向ResourceManager申请一个Application
  3. RM将该应用程序的资源路径返回给YarnRunner
  4. 该程序将运行所需资源提交到HDFS上
  5. 程序资源提交完毕后，申请运行mrAppMaster
  6. RM将用户的请求初始化成一个Task
  7. 其中一个NodeManager领取到Task任务
  8. 该NodeManager创建容器Container，并产生MRAppmaster
  9. Container从HDFS上拷贝资源到本地
  10. MRAppmaster向RM 申请运行MapTask资源
  11. RM将运行MapTask任务分配给另外两个NodeManager，另两个NodeManager分别领取任务并创建容器
  12. MR向两个接收到任务的NodeManager发送程序启动脚本，这两个NodeManager分别启动MapTask，MapTask对数据分区排序
  13. MrAppMaster等待所有MapTask运行完毕后，向RM申请容器，运行ReduceTask
  14. ReduceTask向MapTask获取相应分区的数据。

  15. 程序运行完毕后，MR会向RM申请注销自己

    作业提交全过程

    QQ截图20220511172748.png

    1. 作业提交

    1. Client调用job.waitForCompletion方法，向整个集群提交MapReduce作业
    2. Client向RM申请一个作业id
    3. RM给Client返回该job资源的提交路径和作业id
    4. Client提交jar包、切片信息和配置文件到指定的资源提交路径

    5. Client提交完资源后，向RM申请运行MrAppMaster。

      2. 作业初始化

    6. 当RM收到Client的请求后，将该job添加到容量调度器中

    7. 某一个空闲的NM领取到该Job
    8. 该NM创建Container，并产生MRAppmaster

    9. 下载Client提交的资源到本地

      3. 任务分配

    10. MrAppMaster向RM申请运行多个MapTask任务资源

    11. RM将运行MapTask任务分配给另外两个NodeManager，另两个NodeManager分别领取任务并创建容器

      4. 任务运行

    12. MR向两个接收到任务的NodeManager发送程序启动脚本，这两个NodeManager分别启动MapTask，MapTask对数据分区排序

    13. MrAppMaster等待所有MapTask运行完毕后，向RM申请容器，运行ReduceTask
    14. ReduceTask向MapTask获取相应分区的数据
    15. 程序运行完毕后，MR会向RM申请注销自己。

      5. 进度和状态更新

      YARN中的任务将其进度和状态(包括counter)返回给应用管理器, 客户端每秒(通过mapreduce.client.progressmonitor.pollinterval设置)向应用管理器请求进度更新, 展示给用户。

      6. 作业完成

      除了向应用管理器请求作业进度外, 客户端每5秒都会通过调用waitForCompletion()来检查作业是否完成。时间间隔可以通过mapreduce.client.completion.pollinterval来设置。作业完成之后, 应用管理器和Container会清理工作状态。作业的信息会被作业历史服务器存储以备之后用户核查。

      Yarn调度器和调度算法

      1. 先进先出调度器（FIFO）

      QQ截图20220511174101.png
      单队列，根据提交作业的先后顺序，先来先服务
      优点：简单易懂
      缺点：不支持多队列，生产环境很少用

      2. 容量调度器（Capacity Scheduler）

      QQ截图20220511174317.png
      Apache Hadoop3.1.3默认的资源调度器，多用户调度器
  • 多队列：每个队列可配置一定的资源量，每个队列采用FIFO调度策略
  • 容量保证：管理员可为每个队列设置资源最低保证和资源使用上限
  • 灵活性：如果一个队列中的资源有剩余，可以暂时共享给那些需要资源的队列，而一旦该队列有新的应用程序提交，则其他队列借调的资源会归还给该队列

  • 多租户：支持多用户共享集群和多应用程序同时运行，为了防止同一个用户的作业独占队列中的资源，该调度器会对同一用户提交的作业所占资源量进行限定

    容量调度器资源分配算法

    QQ截图20220511174724.png
    root
    |—-queueA 20%
    |—-queueB 50%
    |—-queueC 30%
    |—-user1 50%
    |—-user2 50%
    （1）队列资源分配：从root开始，使用深度优先算法，优先选择资源占用率最低的队列分配资源
    （2）作业资源分配：默认按照提交作业的优先级和提交时间顺序分配资源
    （3）容器资源分配：按照容器的优先级分配资源；如果优先级相同，按照数据本地性原则：
    3.1 任务和数据在同一节点
    3.2 任务和数据在同一机架
    3.3 任务和数据不在同一节点也不在同一机架

    3. 公平调度器（Fair Scheduler）

    Fair Schedulere是Facebook开发的多用户调度器，CDH框架默认调度器。
    QQ截图20220511175518.png
    image.png

    缺额

    image.png

    公平调度器队列资源分配方式

  • FIFO策略，公平调度器每个队列资源分配策略如果选择FIFO的话，此时公平调度器相当于上面讲过的容量调度器。

  • Fair策略，Fair 策略（默认）是一种基于最大最小公平算法实现的资源多路复用方式，默认情况下，每个队列内部采用该方式分配资源。这意味着，如果一个队列中有两个应用程序同时运行，则每个应用程序可得到1/2的资源；如果三个应用程序同时运行，则每个应用程序可得到1/3的资源。

具体资源分配流程和容量调度器一致
（1）选择队列（2）选择作业（3）选择容器以上三步，每一步都是按照公平策略分配资源
image.png
QQ截图20220511180100.png

  • DRF策略（Dominant Resource Fairness），资源有很多种，例如内存，CPU，网络带宽等，很难衡量两个应用应该分配的资源比例。在YARN中，用DRF来决定如何调度：假设集群一共有100 CPU和10T 内存，而应用A需要（2 CPU, 300GB），应用B需要（6 CPU，100GB）。则两个应用分别需要A（2%CPU, 3%内存）和B（6%CPU, 1%内存）的资源，这就意味着A是内存主导的, B是CPU主导的，针对这种情况，可以选择DRF策略对不同应用进行不同资源（CPU和内存）的一个不同比例的限制。

    公平调度器资源分配算法

    （1）队列资源分配
    需求
    集群总资源100，有3个队列，对资源的需求是：

    • queueA->20
    • queueB->50
    • queueC->30

第一次算：100/3=33.33

  • queueA：分33.33->多13.33
  • queueB：分33.33->少16.67
  • queueC：分33.33->多3.33

第二次算：（13.33+3.33）/1 = 16.66

  • queueA：分20
  • queueB：分33.33+16.67
  • queueC：分30

（2）作业资源分配

  1. 不加权

需求
有一条队列总资源12个，有4个job，对资源的需求分别是 ：

  1.   - job1->1
  2.   - job2->2
  3.   - job3->6
  4.   - job4->5
  • 第一次算 12/4=3
    • job1：分3 ->多2个
    • job2：分3 ->多1个
    • job3：分3 ->差3个
    • job4：分3 ->差2个
  • 第二次算 3/2=1.5
    • job1：分1
    • job2：分2
    • job3：分3 ->差3个 -> 分1.5 ->最终4.5
    • job4：分3 ->差2个 -> 分1.5 ->最终4.5
  • 第n次算：一直到没有空闲资源
  1. 加权

需求
有一条队列总资源16个，有4个job，对资源的需求分别是 ：

  1.   - job1->4
  2.   - job2->2
  3.   - job3->10
  4.   - job4->4

每个job的权重为：

  1.   - job1->5
  2.   - job2->8
  3.   - job3->1
  4.   - job4->2
  • 第一次算：16/（5+8+1+2）=1
    • job1：分5 -> 多1
    • job2：分8 -> 多6
    • job3：分1 -> 少9
    • job4：分2 -> 少2
  • 第二次算：7/（1+2）=7/3
    • job1：分4
    • job2：分2
    • job3：分1 -> 分7/3 -> 少6.67
    • job4：分2 -> 分14/3 -> 多2.66
  • 第三次算：2.66/1=2.66
    • job1：分4
    • job2：分2
    • job3：分1 -> 分2.66/1 -> 分2.66
    • job4：分4
  • 第n次算：一直到没有空闲资源

    Yarn常用命令

    Yarn状态查询：（1）在hadoop103:8088 （2）命令操作
    执行WordCount案例，用Yarn命令查看运行情况
    1. [qtbhy@hadoop102 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount /input /output1

    yarn application查看任务

  1. 列出所有Application

    1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn application -list

    QQ截图20220512101215.png

  2. 根据Application状态过滤

yarn application -list -appStates <状态>
所有状态：ALL、NEW、NEW_SAVING、SUBMITTED、ACCEPTED、RUNNING、FINISHED、FAILED、KILLED

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn application -list -appStates FINISHED

QQ截图20220512101426.png

  1. kill掉Application

    1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn application -kill application_1651747672583_0001

    QQ截图20220512102019.png

    yarn logs查看日志

  2. 查询Application日志：yarn logs -applicationId 

    1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn logs -applicationId application_1651747672583_0001

  3. 查询Container日志

yarn logs -applicationId -containerId 

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn logs -applicationId application_1651747672583_0002 -containerId container_1651747672583_0002_01_000001

yarn applicationattempt 查看尝试运行的任务

  1. 列出所有Application尝试的列表

yarn applicationattempt -list 

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn applicationattempt -list application_1651747672583_0002
  2. 2022-05-12 10:58:01,778 INFO client.RMProxy: Connecting to ResourceManager at hadoop103/192.168.10.103:8032
  3. Total number of application attempts :1
  4.          ApplicationAttempt-Id                   State                        AM-Container-Id                           Tracking-URL
  5. appattempt_1651747672583_0002_000001                FINISHED    container_1651747672583_0002_01_000001    http://hadoop103:8088/proxy/application_1651747672583_0002/
  1. 打印ApplicationAttempt状态

yarn applicationattempt -status 

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn applicationattempt -status appattempt_1651747672583_0002_000001
  2. 2022-05-12 11:00:34,201 INFO client.RMProxy: Connecting to ResourceManager at hadoop103/192.168.10.103:8032
  3. Application Attempt Report : 
  4.     ApplicationAttempt-Id : appattempt_1651747672583_0002_000001
  5.     State : FINISHED
  6.     AMContainer : container_1651747672583_0002_01_000001
  7.     Tracking-URL : http://hadoop103:8088/proxy/application_1651747672583_0002/
  8.     RPC Port : 42469
  9.     AM Host : hadoop104
  10.     Diagnostics :

yarn container查看容器

  1. 列出所有Container

yarn container -list 

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn container -list appattempt_1651747672583_0002_000001
  2. 2022-05-12 11:47:27,477 INFO client.RMProxy: Connecting to ResourceManager at hadoop103/192.168.10.103:8032
  3. Total number of containers :0
  4.                   Container-Id              Start Time             Finish Time                   State                    Host       Node Http Address                                LOG-URL
  1. 打印Container状态

yarn container -status
只有在任务跑的途中才能看到container的状态

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn container -status container_1651747672583_0002_01_000001

yarn node查看节点状态

列出所有节点 yarn node -list -all

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn node -list -all
  2. 2022-05-12 11:05:46,513 INFO client.RMProxy: Connecting to ResourceManager at hadoop103/192.168.10.103:8032
  3. Total Nodes:3
  4.          Node-Id         Node-State    Node-Http-Address    Number-of-Running-Containers
  5.  hadoop102:37310            RUNNING       hadoop102:8042                               0
  6.  hadoop103:44485            RUNNING       hadoop103:8042                               0
  7.  hadoop104:34452            RUNNING       hadoop104:8042                               0

yarn rmadmin更新配置

加载队列配置：yarn rmadmin -refreshQueues

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn rmadmin -refreshQueues
  2. 2022-05-12 11:07:40,602 INFO client.RMProxy: Connecting to ResourceManager at hadoop103/192.168.10.103:8033

yarn queue查看队列

打印队列信息：yarn queue -status 

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn queue -status default
  2. 2022-05-12 11:09:32,156 INFO client.RMProxy: Connecting to ResourceManager at hadoop103/192.168.10.103:8032
  3. Queue Information : 
  4. Queue Name : default
  5.     State : RUNNING
  6.     Capacity : 100.0%
  7.     Current Capacity : .0%
  8.     Maximum Capacity : 100.0%
  9.     Default Node Label expression : <DEFAULT_PARTITION>
  10.     Accessible Node Labels : *
  11.     Preemption : disabled
  12.     Intra-queue Preemption : disabled

YARN生产环境核心配置参数

image.png

  1. ResourceManager相关

yarn.resourcemanager.scheduler.class 配置调度器，apache默认的时容量调度器
yarn.resourcemanager.scheduler.client.thread-count ResourceManager处理调度器请求的线程数量，默认50

  1. NodeManager相关

yarn.nodemanager.resource.detect-hardware-capabilities 是否让yarn自己检测硬件进行配置，默认false
yarn.nodemanager.resource.count-logical-processors-as-cores 是否将虚拟核数当作CPU核数，默认false
yarn.nodemanager.resource.pcores-vcores-multiplier 虚拟核数和物理核数乘数，例如：4核8线程，该参数就应设为2，默认1.0
yarn.nodemanager.resource.memory-mb NodeManager使用内存，默认8G
yarn.nodemanager.resource.system-reserved-memory-mb NodeManager为系统保留多少内存
以上二个参数配置一个即可
yarn.nodemanager.resource.cpu-vcores NodeManager使用CPU核数，默认8个
yarn.nodemanager.pmem-check-enabled 是否开启物理内存检查限制container，默认打开
yarn.nodemanager.vmem-check-enabled 是否开启虚拟内存检查限制container，默认打开
yarn.nodemanager.vmem-pmem-ratio 虚拟内存物理内存比例，默认2.1

  1. Container相关

yarn.scheduler.minimum-allocation-mb 容器最最小内存，默认1G
yarn.scheduler.maximum-allocation-mb 容器最最大内存，默认8G
yarn.scheduler.minimum-allocation-vcores 容器最小CPU核数，默认1个yarn.scheduler.maximum-allocation-vcores 容器最大CPU核数，默认4个

Yarn实例

准备
拍摄Linux快照
QQ截图20220513095531.png
恢复快照
QQ截图20220513095804.png

Yarn生产环境核心参数配置

需求

从1G数据中，统计每个单词出现次数。服务器3台，每台配置4G内存，4核CPU，4线程
1G/128m=8个MapTask；1个ReduceTask；1个mrAppMaster
平均每个节点运行10个/3台≈3个任务

修改yarn-site.xml配置参数如下

  1. <!-- 选择调度器，默认容量 -->
  2. <property>
  3.   <description>The class to use as the resource scheduler.</description>
  4.   <name>yarn.resourcemanager.scheduler.class</name>
  5.   <value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value>
  6. </property>
  8. <!-- ResourceManager处理调度器请求的线程数量,默认50；如果提交的任务数大于50，可以增加该值，但是不能超过3台 * 4线程 = 12线程（去除其他应用程序实际不能超过8） -->
  9. <property>
  10.   <description>Number of threads to handle scheduler interface.</description>
  11.   <name>yarn.resourcemanager.scheduler.client.thread-count</name>
  12.   <value>8</value>
  13. </property>
  15. <!-- 是否让yarn自动检测硬件进行配置，默认是false，如果该节点有很多其他应用程序，建议手动配置。如果该节点没有其他应用程序，可以采用自动 -->
  16. <property>
  17.   <description>Enable auto-detection of node capabilities such as
  18.     memory and CPU.
  19.   </description>
  20.   <name>yarn.nodemanager.resource.detect-hardware-capabilities</name>
  21.   <value>false</value>
  22. </property>
  24. <!-- 是否将虚拟核数当作CPU核数，默认是false，采用物理CPU核数 -->
  25. <property>
  26.   <description>Flag to determine if logical processors(such as
  27.     hyperthreads) should be counted as cores. Only applicable on Linux
  28.     when yarn.nodemanager.resource.cpu-vcores is set to -1 and
  29.     yarn.nodemanager.resource.detect-hardware-capabilities is true.
  30.   </description>
  31.   <name>yarn.nodemanager.resource.count-logical-processors-as-cores</name>
  32.   <value>false</value>
  33. </property>
  35. <!-- 虚拟核数和物理核数乘数，默认是1.0 -->
  36. <property>
  37.   <description>Multiplier to determine how to convert phyiscal cores to
  38.     vcores. This value is used if yarn.nodemanager.resource.cpu-vcores
  39.     is set to -1(which implies auto-calculate vcores) and
  40.     yarn.nodemanager.resource.detect-hardware-capabilities is set to true. The    number of vcores will be calculated as    number of CPUs * multiplier.
  41.   </description>
  42.   <name>yarn.nodemanager.resource.pcores-vcores-multiplier</name>
  43.   <value>1.0</value>
  44. </property>
  46. <!-- NodeManager使用内存数，默认8G，修改为4G内存 -->
  47. <property>
  48.   <description>Amount of physical memory, in MB, that can be allocated 
  49.     for containers. If set to -1 and
  50.     yarn.nodemanager.resource.detect-hardware-capabilities is true, it is
  51.     automatically calculated(in case of Windows and Linux).
  52.     In other cases, the default is 8192MB.
  53.   </description>
  54.   <name>yarn.nodemanager.resource.memory-mb</name>
  55.   <value>4096</value>
  56. </property>
  58. <!-- nodemanager的CPU核数，不按照硬件环境自动设定时默认是8个，修改为4个 -->
  59. <property>
  60.   <description>Number of vcores that can be allocated
  61.     for containers. This is used by the RM scheduler when allocating
  62.     resources for containers. This is not used to limit the number of
  63.     CPUs used by YARN containers. If it is set to -1 and
  64.     yarn.nodemanager.resource.detect-hardware-capabilities is true, it is
  65.     automatically determined from the hardware in case of Windows and Linux.
  66.     In other cases, number of vcores is 8 by default.</description>
  67.   <name>yarn.nodemanager.resource.cpu-vcores</name>
  68.   <value>4</value>
  69. </property>
  71. <!-- 容器最小内存，默认1G -->
  72. <property>
  73.   <description>The minimum allocation for every container request at the RM    in MBs. Memory requests lower than this will be set to the value of this    property. Additionally, a node manager that is configured to have less memory    than this value will be shut down by the resource manager.
  74.   </description>
  75.   <name>yarn.scheduler.minimum-allocation-mb</name>
  76.   <value>1024</value>
  77. </property>
  79. <!-- 容器最大内存，默认8G，修改为2G -->
  80. <property>
  81.   <description>The maximum allocation for every container request at the RM    in MBs. Memory requests higher than this will throw an    InvalidResourceRequestException.
  82.   </description>
  83.   <name>yarn.scheduler.maximum-allocation-mb</name>
  84.   <value>2048</value>
  85. </property>
  87. <!-- 容器最小CPU核数，默认1个 -->
  88. <property>
  89.   <description>The minimum allocation for every container request at the RM    in terms of virtual CPU cores. Requests lower than this will be set to the    value of this property. Additionally, a node manager that is configured to    have fewer virtual cores than this value will be shut down by the resource    manager.
  90.   </description>
  91.   <name>yarn.scheduler.minimum-allocation-vcores</name>
  92.   <value>1</value>
  93. </property>
  95. <!-- 容器最大CPU核数，默认4个，修改为2个 -->
  96. <property>
  97.   <description>The maximum allocation for every container request at the RM    in terms of virtual CPU cores. Requests higher than this will throw an
  98.     InvalidResourceRequestException.</description>
  99.   <name>yarn.scheduler.maximum-allocation-vcores</name>
  100.   <value>2</value>
  101. </property>
  103. <!-- 虚拟内存检查，默认打开，修改为关闭 -->
  104. <property>
  105.   <description>Whether virtual memory limits will be enforced for
  106.     containers.</description>
  107.   <name>yarn.nodemanager.vmem-check-enabled</name>
  108.   <value>false</value>
  109. </property>
  111. <!-- 虚拟内存和物理内存设置比例,默认2.1 -->
  112. <property>
  113.   <description>Ratio between virtual memory to physical memory when    setting memory limits for containers. Container allocations are    expressed in terms of physical memory, and virtual memory usage    is allowed to exceed this allocation by this ratio.
  114.   </description>
  115.   <name>yarn.nodemanager.vmem-pmem-ratio</name>
  116.   <value>2.1</value>
  117. </property>
  • 关闭虚拟内存检查原因

QQ截图20220513112558.png

Ratio between virtual memory to physical memory when setting memory limits for containers. Container allocations are expressed in terms of physical memory, and virtual memory usage is allowed to exceed this allocation by this ratio. yarn.nodemanager.vmem-pmem-ratio 2.1

分发配置

  1. [qtbhy@hadoop102 hadoop]$ xsync yarn-site.xml

重启集群

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ sbin/stop-yarn.sh
  2. Stopping nodemanagers
  3. Stopping resourcemanager
  4. [qtbhy@hadoop102 hadoop-3.1.3]$ sbin/start-yarn.sh
  5. Starting resourcemanager
  6. Starting nodemanagers

执行WordCount程序

  1. [qtbhy@hadoop102 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount /input /output

观察Yarn任务执行页面

http://hadoop103:8088/cluster
QQ截图20220513101856.png

容量调度器多队列提交

  1. 在生产环境怎么创建队列？

调度器默认就1个default队列，不能满足生产要求

  1. 创建多队列好处

    1. 避免递归死循环代码把所有资源全部耗尽
    2. 任务降级使用，特殊时期保证重要的任务队列资源充足

      需求

  2. default队列占总内存的40%，最大资源容量占总资源60%，hive队列占总内存的60%，最大资源容量占总资源80%

  3. 配置队列优先级

    配置多队列的容量调度器

  4. 在capacity-scheduler.xml中配置

    1. 下载到windows

      1. [qtbhy@hadoop102 hadoop]$ sz capacity-scheduler.xml

    2. 修改配置 ```xml

      yarn.scheduler.capacity.root.hive.capacity 60
yarn.scheduler.capacity.root.hive.user-limit-factor 1 yarn.scheduler.capacity.root.hive.maximum-capacity 80 yarn.scheduler.capacity.root.hive.state RUNNING yarn.scheduler.capacity.root.hive.acl_submit_applications * yarn.scheduler.capacity.root.hive.acl_administer_queue * yarn.scheduler.capacity.root.hive.acl_application_max_priority * yarn.scheduler.capacity.root.hive.maximum-application-lifetime -1 yarn.scheduler.capacity.root.hive.default-application-lifetime -1 3. 删除原配置文件，上传到hadoop102shell [qtbhy@hadoop102 hadoop]$ rm -rf capacity-scheduler.xml 2. 分发配置文件shell [qtbhy@hadoop102 hadoop]$ xsync capacity-scheduler.xml 3. 重启Yarn或yarn rmadmin -refreshQueues刷新队列shell [qtbhy@hadoop102 hadoop]$ yarn rmadmin -refreshQueues ![QQ截图20220513115606.png](https://cdn.nlark.com/yuque/0/2022/png/26273875/1652414177260-c3404e25-3b34-428c-820d-8845a455ec53.png#clientId=ue0066147-9759-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=u0f490f6a&margin=%5Bobject%20Object%5D&name=QQ%E6%88%AA%E5%9B%BE20220513115606.png&originHeight=96&originWidth=206&originalType=binary&ratio=1&rotation=0&showTitle=false&size=5381&status=done&style=none&taskId=u59a8d24b-5361-40df-9f8b-8f58284d2a7&title=) <a name="bxbEr"></a> ### 向Hive队列提交任务 1. hadoop jar提交任务shell [qtbhy@hadoop102 hadoop-3.1.3]$ hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar wordcount -D mapreduce.job.queuename=hive /input /output8 ![QQ截图20220513120000.png](https://cdn.nlark.com/yuque/0/2022/png/26273875/1652414415206-c5b2e611-521d-4e9c-8ec9-cc392359c41f.png#clientId=ue0066147-9759-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=uf69653d9&margin=%5Bobject%20Object%5D&name=QQ%E6%88%AA%E5%9B%BE20220513120000.png&originHeight=183&originWidth=585&originalType=binary&ratio=1&rotation=0&showTitle=false&size=17749&status=done&style=none&taskId=u0ee30918-c1ea-4e6c-8ab0-a0194092e5c&title=) 2. jar包 默认是default，向其他队列提交任务，要在Driver中声明java Configuration conf = new Configuration(); conf.set(“mapreduce.job.queuename”,”hive”); <a name="gMFZ8"></a> ### 任务优先级 容量调度器，支持任务优先级的配置，在资源紧张时，优先级高的任务将优先获取资源。默认情况，Yarn将所有任务的优先级限制为0，若想使用任务的优先级功能，需开放该限制 1. 修改yarn-site.xml文件，增加参数xml yarn.cluster.max-application-priority 5 2. 分发配置并重启集群shell [qtbhy@hadoop102 hadoop]$ xsync yarn-site.xml [qtbhy@hadoop102 hadoop-3.1.3]$ sbin/stop-yarn.sh Stopping nodemanagers Stopping resourcemanager [qtbhy@hadoop102 hadoop-3.1.3]$ sbin/start-yarn.sh Starting resourcemanager Starting nodemanagers 3. 模拟资源紧张，连续提交任务shell [qtbhy@hadoop102 hadoop-3.1.3]$ hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar pi 5 2000000 ![QQ截图20220513120952.png](https://cdn.nlark.com/yuque/0/2022/png/26273875/1652415135474-b8c050a9-0f0f-4b8c-8919-0c574a19245f.png#clientId=ue0066147-9759-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=u00045c59&margin=%5Bobject%20Object%5D&name=QQ%E6%88%AA%E5%9B%BE20220513120952.png&originHeight=481&originWidth=1085&originalType=binary&ratio=1&rotation=0&showTitle=false&size=31582&status=done&style=none&taskId=u6e977627-4349-4415-86c0-74d96b4ca41&title=) <a name="fWAu8"></a> ## 公平调度器 <a name="WLMmY"></a> ### 需求 创建两个队列，test和qtbhy。 - 若用户提交任务时指定队列，则任务提交到指定队列运行 - 若未指定队列，test用户提交的任务到root.group.test队列运行，qtbhy提交的任务到root.group.qtbhy队列运行 公平调度器的配置涉及到两个文件：yarn-site.xml，另一个时公平调度器队列分配文件fair-scheduler.xml <a name="BqHRT"></a> ### 配置多队列的公平调度器 1. 修改yarn-site.xml文件，加入以下参数xml yarn.resourcemanager.scheduler.class org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler 配置使用公平调度器 yarn.scheduler.fair.allocation.file /opt/module/hadoop-3.1.3/etc/hadoop/fair-scheduler.xml 指明公平调度器队列分配配置文件

yarn.scheduler.fair.preemption false 禁止队列间资源抢占 

  2. 2. 配置fair-scheduler.xml
  3. ```xml
  4. <?xml version="1.0"?>
  5. <allocations>
  6.   <!-- 单个队列中Application Master占用资源的最大比例,取值0-1 ，企业一般配置0.1 -->
  7.   <queueMaxAMShareDefault>0.5</queueMaxAMShareDefault>
  8.   <!-- 单个队列最大资源的默认值 test qtbhydefault -->
  9.   <queueMaxResourcesDefault>4096mb,4vcores</queueMaxResourcesDefault>
  11.   <!-- 增加一个队列test -->
  12.   <queue name="test">
  13.     <!-- 队列最小资源 -->
  14.     <minResources>2048mb,2vcores</minResources>
  15.     <!-- 队列最大资源 -->
  16.     <maxResources>4096mb,4vcores</maxResources>
  17.     <!-- 队列中最多同时运行的应用数，默认50，根据线程数配置 -->
  18.     <maxRunningApps>4</maxRunningApps>
  19.     <!-- 队列中Application Master占用资源的最大比例 -->
  20.     <maxAMShare>0.5</maxAMShare>
  21.     <!-- 该队列资源权重,默认值为1.0 -->
  22.     <weight>1.0</weight>
  23.     <!-- 队列内部的资源分配策略 -->
  24.     <schedulingPolicy>fair</schedulingPolicy>
  25.   </queue>
  26.   <!-- 增加一个队列qtbhy-->
  27.   <queue name="qtbhy" type="parent">
  28.     <!-- 队列最小资源 -->
  29.     <minResources>2048mb,2vcores</minResources>
  30.     <!-- 队列最大资源 -->
  31.     <maxResources>4096mb,4vcores</maxResources>
  32.     <!-- 队列中最多同时运行的应用数，默认50，根据线程数配置 -->
  33.     <maxRunningApps>4</maxRunningApps>
  34.     <!-- 队列中Application Master占用资源的最大比例 -->
  35.     <maxAMShare>0.5</maxAMShare>
  36.     <!-- 该队列资源权重,默认值为1.0 -->
  37.     <weight>1.0</weight>
  38.     <!-- 队列内部的资源分配策略 -->
  39.     <schedulingPolicy>fair</schedulingPolicy>
  40.   </queue>
  42.   <!-- 任务队列分配策略,可配置多层规则,从第一个规则开始匹配,直到匹配成功 -->
  43.   <queuePlacementPolicy>
  44.     <!-- 提交任务时指定队列,如未指定提交队列,则继续匹配下一个规则; false表示：如果指定队列不存在,不允许自动创建-->
  45.     <rule name="specified" create="false"/>
  46.     <!-- 提交到root.group.username队列,若root.group不存在,不允许自动创建；若root.group.user不存在,允许自动创建 -->
  47.     <rule name="nestedUserQueue" create="true">
  48.         <rule name="primaryGroup" create="false"/>
  49.     </rule>
  50.     <!-- 最后一个规则必须为reject或者default。Reject表示拒绝创建提交失败，default表示把任务提交到default队列 -->
  51.     <rule name="reject" />
  52.   </queuePlacementPolicy>
  53. </allocations>
  1. 分发配置并重启Yarn ```shell [qtbhy@hadoop102 hadoop]$ xsync yarn-site.xml [qtbhy@hadoop102 hadoop]$ xsync fair-scheduler.xml

[qtbhy@hadoop102 hadoop]$ sbin/stop-yarn.sh [qtbhy@hadoop102 hadoop]$ sbin/start-yarn.sh

  1. ![QQ截图20220513172322.png](https://cdn.nlark.com/yuque/0/2022/png/26273875/1652443049720-65445aae-0530-4f6a-8e3d-59ba2af82e00.png#clientId=ue0ac5a2b-e3fe-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=u4940dc2d&margin=%5Bobject%20Object%5D&name=QQ%E6%88%AA%E5%9B%BE20220513172322.png&originHeight=216&originWidth=742&originalType=binary&ratio=1&rotation=0&showTitle=false&size=19937&status=done&style=none&taskId=u5a95d6ab-ccb6-42f1-adfb-685cf7cda47&title=)
  2. <a name="rrHRN"></a>
  3. ### 测试
  5. 1. 提交任务时指定队列，按照配置规则，任务会到指定的root.test队列
  6. ```shell
  7. [qtbhy@hadoop102 hadoop-3.1.3]$ hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar pi -Dmapreduce.job.queuename=root.test 1 1

QQ截图20220513172454.png

  1. 提交任务时不指定队列，任务回到root.root.qtbhy队列

    1. [qtbhy@hadoop102 hadoop-3.1.3]$ hadoop jar /opt/module/hadoop-3.1.3/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar pi 1 1

    QQ截图20220513172537.png

    Yarn的Tool接口

    1. [qtbhy@hadoop102 hadoop-3.1.3]$ hadoop jar wc.jar com.example.mapreduce.wordcount.WordCountDriver -Dmapreduce.job.queuename=root.test /input /output1

    QQ截图20220513175759.png
    需求：动态修改参数，编写Yarn的Tool接口
    步骤：

  2. 新建Maven项目

    1. <dependencies>
    2. <dependency>
    3.  <groupId>org.apache.hadoop</groupId>
    4.  <artifactId>hadoop-client</artifactId>
    5.  <version>3.1.3</version>
    6. </dependency>
    7. </dependencies>

  3. 新建com.example.yarn包

  4. 创建WordCount并实现Tool接口

    1. public class WordCount implements Tool {
    2.  private Configuration conf;
    4.  // 核心驱动
    5.  @Override
    6.  public int run(String[] strings) throws Exception {
    7.      Job job = Job.getInstance(conf);
    9.      job.setJarByClass(WordCountDriver.class);
    11.      job.setMapperClass(WordCountMapper.class);
    13.      job.setReducerClass(WordCountReducer.class);
    15.      job.setMapOutputKeyClass(Text.class);
    16.      job.setMapOutputValueClass(IntWritable.class);
    17.      job.setOutputKeyClass(Text.class);
    18.      job.setOutputValueClass(IntWritable.class);
    20.      FileInputFormat.setInputPaths(job, new Path(strings[0]));
    21.      FileOutputFormat.setOutputPath(job, new Path(strings[1]));
    22.      return job.waitForCompletion(true) ? 0 : 1;
    23.  }
    25.  @Override
    26.  public void setConf(Configuration configuration) {
    27.      this.conf = configuration;
    28.  }
    30.  @Override
    31.  public Configuration getConf() {
    32.      return conf;
    33.  }
    35.  // mapper
    36.  public static class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {
    37.      private Text outK = new Text();
    38.      private IntWritable outV = new IntWritable(1);
    40.      @Override
    41.      protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
    42.          // 获取一行
    43.          String line = value.toString();
    45.          // 切割
    46.          String[] words = line.split(" ");
    48.          // 循环遍历写出
    49.          for (String word : words) {
    50.              outK.set(word);
    51.              context.write(outK, outV);
    52.          }
    53.      }
    54.  }
    56.  // reducer
    57.  public static class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
    58.      private IntWritable outV = new IntWritable();
    60.      @Override
    61.      protected void reduce(Text key, Iterable<IntWritable> values, Reducer<Text, IntWritable, Text, IntWritable>.Context context) throws IOException, InterruptedException {
    62.          int sum = 0;
    63.          for (IntWritable value : values) {
    64.              sum += value.get();
    65.          }
    66.          outV.set(sum);
    67.          context.write(key, outV);
    68.      }
    69.  }
    70. }

  5. 新建WordCountDriver

    1. public class WordCountDriver {
    2.  private static Tool tool;
    3.  public static void main(String[] args) throws Exception {
    4.      // 创建配置
    5.      Configuration conf = new Configuration();
    6.      switch (args[0]) {
    7.          case "wordcount":
    8.              tool = new WordCount();
    9.              break;
    10.          default:
    11.              throw new RuntimeException("no such tool " + args[0]);
    12.      }
    14.      // 执行程序
    15.      int run = ToolRunner.run(conf, tool, Arrays.copyOfRange(args, 1, args.length));
    16.      System.exit(run);
    17.  }
    18. }

  6. 打包，上传到Hadoop102

    1. [qtbhy@hadoop102 hadoop-3.1.3]$ yarn jar yarn_test.jar com.example.yarn.WordCountDriver wordcount -Dmapreduce.job.queuename=root.test /input /output2