MapReduce第四天：Hadoop数据压缩、四种压缩方式、压缩参数、压缩案例、yarn资源调度器、yarn工作机制

接上篇第3章的3.10MapReduce第三天：MapTask、ReduceTask机制、OutputFormat数据输出、Join应用、MapReduce Join、计数器应用、数据清洗ETL、MapReduce开发总结

本文目录
第4章Hadoop数据压缩
4.1概述
4.2MR支持的压缩编码

4.3压缩方式选择
4.3.1Gzip压缩
4.3.2Bzip2压缩
4.3.3Lzo压缩
4.3.4Snappy压缩

4.4压缩位置选择
4.5压缩参数配置

4.6压缩实操案例
4.6.1数据流的压缩和解压缩
4.6.2Map输出端采用压缩
4.6.3 Reduce输出端采用压缩

第5章yarn资源调度器
5.1Yarn基本架构
5.3Yarn工作机制
5.4作业提交全过程
5.5资源调度器
5.6任务的推测执行

第4章 Hadoop数据压缩

4.1 概述

压缩技术能够有效减少底层存储系统（HDFS）读写字节数。压缩提高了网络带宽和磁盘空间的效率。在运行MR程序时，I/O操作、网络数据传输、Shuffle和Merge要花大量的时间，尤其是数据规模很大和工作负载密集的情况下，因此，使用数据压缩显得非常重要。

鉴于磁盘IVO和网络带宽是Hadoop]宝贵资源，数据压缩对于节省资源、最小化磁盘I/o和网络传输非常有帮助。可以在任意MapReduce阶段启用压缩。不过，尽管压缩与解压操作的CPU开销不高，其性能的提升和资源的节省并非没有代价。

压缩是提高Hadoop运行效率的一种优化策略。

通过对Mapper、Reducer运行过程的数据进行压缩，以减少磁盘IO，提高MR程序运行速度。

注意：采用压缩技术减少了磁盘I0，但同时增加了CPU运算负担。所以，压缩持性运用得当能提高性能，但运用不当也可能降低性能。

压缩基本原则：

（1）运算密集型的job，少用压缩
（2）IO密集型的job，多用压缩

4.2 MR支持的压缩编码

表4-7

为了支持多种压缩/解压缩算法，Hadoop引入了编码/解码器，如下表所示。

表4-8

压缩性能的比较

表4-9

http://google.github.io/snappy/

On a single core of a Core i7 processor in 64-bit mode, Snappy compresses at about 250 MB/sec or more and decompresses at about 500 MB/sec or more.

4.3 压缩方式选择

4.3.1 Gzip压缩

优点：压宿率比较高，而且压宿/解压速度也比较快；Hadoop本身支持，在应用中处理Gzip格式的文件就和直接处理文本一样；大部分Linug系统都自带Gzip命令，使用方便。

缺点：不支持Split。

应用场景：当每个文件压宿之后在130M以内的（1个块大小内），都可以考虑用Gzip压宿格式。例如说一天或者一个小时的日志压缩成一个Gzip文件。

4.3.2 Bzip2压缩

优点：支持Split；具有很高的压宿率，t比Gzip压宿率都高；Hadoop本身自带，使用方便。

缺点：压/解压速度慢。

应用场景：适合对速度要求不高，但需要较高的压宿率的时候；或者输出之后的数据比较大，处理之后的数据需要压宿存档成少磁盘空间并且以后数据用得比较少的情兄；或者对单个很大的文本文件想压宿减少存储空间，同时又需要支持Split，而且非吞之前的应用程序的情兄。

4.3.3 Lzo压缩

优点：压缩/解压速度也比较快，合理的压宿率；支持Split，是Hadoop中最流行的压宿格式；可以在Limg系统下安装lzop命令，使用方便。

缺点：压宿率t比Gzip要低一些；Hadoop本身不支持，需要安装；在应用中又对Lz0格式的文件需要做一些特殊处理（为了支持Split需要建素引，还需要指定lnputF ormat为Lzo格式）。

应用场累：一个很大的文本文件，压宿之后还大于200M以上的可以考虑，而且单个文件越大，Lz0优点越越明显。

4.3.4 Snappy压缩

优点：高速压宿速度和合理的压宿率。

缺点：不支持Split；压宿比Gzip要低；Hadoop本身不支持，需要安装。应用场景：当MapReduce作l的Map输出的数据比较大的时候，作为Map到Reduce的中间数据的压宿格式；或者作为一个MapReduce作业的输出和另外一个MapReduce作业的输入。

4.4 压缩位置选择

压缩可以在MapReduce作用的任意阶段启用，如图4-22所示。

输入端采用压缩

在有大量数据并计划重复处理的情况下，应该考虑对输入进行压缩。然而，你无须显示指定使用的编解码方式。

Hadoop自动检查文件扩展名，如果扩展名能够匹配，就会用恰当的编解码方式对文件进行压缩和解压。否则，Hadoop就不会使用任何编解码器。

Mapper输出采用压缩

当Map任务输出的中间数据量很大时，应考虑在此阶段采用压缩技术。这能显著改善内部数据Shuffle过程，而Shuffle过程在Hadoop处理过程中是资源消耗最多的环节。如果发现数据量大造成网络传输缓慢，应该考虑使用压缩技术。可用于压缩Mapper输出的快速编解码器包括LZO或者Snappy。

注：LZO是供Hadoop压缩数据用的通用压缩编解码器。其设计目标是达到与硬盘读取速度相当的压缩速度，因此速度是优先考虑的因素，而不是压缩率。与Gzip编解码器相比，它的压缩速度是Gzip的5倍，而解压速度是Gzip的2倍。同一个文件用LZO压缩后比用Gzip压缩后大50%，但比压缩前小25%~50%。这对改善性能非常有利，Map阶段完成时间快4倍。

Reducer输出采用压缩
在此阶段启用压缩技术能够减少要存储的数据量，因此降低所需的磁盘空间。当MapReduce作业形成作业链条时，因为第二个作业的输入也已压缩，所以启用压缩同样有效。

4.5 压缩参数配置

要在Hadoop中启用压缩，可以配置如下参数：

表4-10 配置参数

4.6 压缩实操案例

4.6.1 数据流的压缩和解压缩

CompressionCodec有两个方法可以用于轻松地压缩或解压缩数据。

要想对正在被写入一个输出流的数据进行压缩，我们可以使用
createOutputStream（OutputStreamout）方法创建一个CompressionOutputStream，将其以压缩格式写入底层的流。

相反，要想对从输入流读取而来的数据进行解压缩，则调用
createInputStreamdnputStreamin）函数，从而获得一个CompressionInputstream，从而从底层的流读取未压缩的数据。

测试一下如下压缩方式：
表4-11

package com.atguigu.mapreduce.compress;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.compress.CompressionCodec;
import org.apache.hadoop.io.compress.CompressionCodecFactory;
import org.apache.hadoop.io.compress.CompressionInputStream;
import org.apache.hadoop.io.compress.CompressionOutputStream;
import org.apache.hadoop.util.ReflectionUtils;

public class TestCompress {

public static void main(String[] args) throws Exception {
		compress("e:/hello.txt","org.apache.hadoop.io.compress.BZip2Codec");
//		decompress("e:/hello.txt.bz2");
}

// 1、压缩
private static void compress(String filename, String method) throws Exception {
	
	// （1）获取输入流
	FileInputStream fis = new FileInputStream(new File(filename));
	
	Class codecClass = Class.forName(method);
	
	CompressionCodec codec = (CompressionCodec) ReflectionUtils.newInstance(codecClass, new Configuration());
	
	// （2）获取输出流
	FileOutputStream fos = new FileOutputStream(new File(filename + codec.getDefaultExtension()));
	CompressionOutputStream cos = codec.createOutputStream(fos);
	
	// （3）流的对拷
	IOUtils.copyBytes(fis, cos, 1024*1024*5, false);
	
// （4）关闭资源
		cos.close();
		fos.close();
fis.close();
}

	// 2、解压缩
	private static void decompress(String filename) throws FileNotFoundException, IOException {
		
	// （0）校验是否能解压缩
	CompressionCodecFactory factory = new CompressionCodecFactory(new Configuration());

	CompressionCodec codec = factory.getCodec(new Path(filename));
	
	if (codec == null) {
		System.out.println("cannot find codec for file " + filename);
		return;
	}
	
	// （1）获取输入流
	CompressionInputStream cis = codec.createInputStream(new FileInputStream(new File(filename)));
	
	// （2）获取输出流
	FileOutputStream fos = new FileOutputStream(new File(filename + ".decoded"));
	
	// （3）流的对拷
	IOUtils.copyBytes(cis, fos, 1024*1024*5, false);
	
	// （4）关闭资源
	cis.close();
	fos.close();
}
}

4.6.2 Map输出端采用压缩

即使你的MapReduce的输入输出文件都是未压缩的文件，你仍然可以对Map任务的中间结果输出做压缩，因为它要写在硬盘并且通过网络传输到Reduce节点，对其压缩可以提高很多性能，这些工作只要设置两个属性即可，我们来看下代码怎么设置。

1．给大家提供的Hadoop源码支持的压缩格式有：BZip2Codec 、DefaultCodec

package com.atguigu.mapreduce.compress;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.compress.BZip2Codec;	
import org.apache.hadoop.io.compress.CompressionCodec;
import org.apache.hadoop.io.compress.GzipCodec;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class WordCountDriver {

public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {

	Configuration configuration = new Configuration();

	// 开启map端输出压缩
configuration.setBoolean("mapreduce.map.output.compress", true);
	// 设置map端输出压缩方式
configuration.setClass("mapreduce.map.output.compress.codec", BZip2Codec.class, CompressionCodec.class);

	Job job = Job.getInstance(configuration);

	job.setJarByClass(WordCountDriver.class);

	job.setMapperClass(WordCountMapper.class);
	job.setReducerClass(WordCountReducer.class);

	job.setMapOutputKeyClass(Text.class);
	job.setMapOutputValueClass(IntWritable.class);

	job.setOutputKeyClass(Text.class);
	job.setOutputValueClass(IntWritable.class);

	FileInputFormat.setInputPaths(job, new Path(args[0]));
	FileOutputFormat.setOutputPath(job, new Path(args[1]));

	boolean result = job.waitForCompletion(true);

	System.exit(result ? 1 : 0);
}
}

2．Mapper保持不变

package com.atguigu.mapreduce.compress;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable>{

Text k = new Text();
IntWritable v = new IntWritable(1);

@Override
protected void map(LongWritable key, Text value, Context context)throws IOException, InterruptedException {

	// 1 获取一行
	String line = value.toString();

	// 2 切割
	String[] words = line.split(" ");

	// 3 循环写出
	for(String word:words){
k.set(word);
			context.write(k, v);
		}
	}
}

3．Reducer保持不变

package com.atguigu.mapreduce.compress;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable>{

	IntWritable v = new IntWritable();

@Override
protected void reduce(Text key, Iterable<IntWritable> values,
		Context context) throws IOException, InterruptedException {
	
	int sum = 0;

	// 1 汇总
	for(IntWritable value:values){
		sum += value.get();
	}
	
    v.set(sum);

    // 2 输出
	context.write(key, v);
}
}

4.6.3 Reduce输出端采用压缩

基于WordCount案例处理。

1．修改驱动

package com.atguigu.mapreduce.compress;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.compress.BZip2Codec;
import org.apache.hadoop.io.compress.DefaultCodec;
import org.apache.hadoop.io.compress.GzipCodec;
import org.apache.hadoop.io.compress.Lz4Codec;
import org.apache.hadoop.io.compress.SnappyCodec;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class WordCountDriver {

public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
	
	Configuration configuration = new Configuration();
	
	Job job = Job.getInstance(configuration);
	
	job.setJarByClass(WordCountDriver.class);
	
	job.setMapperClass(WordCountMapper.class);
	job.setReducerClass(WordCountReducer.class);
	
	job.setMapOutputKeyClass(Text.class);
	job.setMapOutputValueClass(IntWritable.class);
	
	job.setOutputKeyClass(Text.class);
	job.setOutputValueClass(IntWritable.class);
	
	FileInputFormat.setInputPaths(job, new Path(args[0]));
	FileOutputFormat.setOutputPath(job, new Path(args[1]));
	
	// 设置reduce端输出压缩开启
	FileOutputFormat.setCompressOutput(job, true);
	
	// 设置压缩的方式
    FileOutputFormat.setOutputCompressorClass(job, BZip2Codec.class); 
//	    FileOutputFormat.setOutputCompressorClass(job, GzipCodec.class); 
//	    FileOutputFormat.setOutputCompressorClass(job, DefaultCodec.class); 
	boolean result = job.waitForCompletion(true);
	System.exit(result?1:0);
}
}

2．Mapper和Reducer保持不变（详见4.6.2）

第5章 Yarn资源调度器

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

5.1 Yarn基本架构

YARN主要由ResourceManager、NodeManager、ApplicationMaster和Container等组件构成，如图4-23所示。

1）ResourceManager（RM）主要作用如下

（1）处理客户端请求
（2）监控NodeManager
（3）启动或监控ApplicationMaster
（4）资源的分配与调度

2）NodelManager（NM）主要作用如下

（1）管理单个节点上的资源
（2）处理来自ResourceManager的命令
（3）处理来自ApplicationMaster的命令

3）ApplicationMaster（AM）作用如下

（1）负责数据的切分
（2）为应用程序申请资源并分配给内部的任务
（3）任务的监控与容错

4）Container Container是YARN中的资源抽象，它封装了某个节点上的多维度资源，如内存、CPU、磁盘、网络等。

5.3 Yarn工作机制

1．Yarn运行机制，如图4-24所示。

图4-24 Yarn工作机制

2．工作机制详解

（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申请注销自己。

5.4 作业提交全过程

1．作业提交过程之YARN，如图4-25所示。

图4-25 作业提交过程之Yarn

作业提交全过程详解
（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会清理工作状态。作业的信息会被作业历史服务器存储以备之后用户核查。

2．作业提交过程之MapReduce，如图4-26所示

图4-26 作业提交过程之MapReduce

5.5 资源调度器

目前，Hadoop作业调度器主要有三种：FIFO、Capacity Scheduler和Fair Scheduler。Hadoop2.7.2默认的资源调度器是Capacity Scheduler。

具体设置详见：yarn-default.xml文件

<property>
    <description>The class to use as the resource scheduler.</description>
    <name>yarn.resourcemanager.scheduler.class</name>
<value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value>
</property>

1．先进先出调度器（FIFO），如图4-27所示

图4-27 FIFO调度器
2．容量调度器（Capacity Scheduler），如图4-28所示

1、支持多个队列，每个队列可配置一定的资源量，每个队列采用FIFO调度策略。

2、为了防止同一个用户的作业独占队列中的资源，该调度器会对同一用户提交的作业所占资源量进行限定。

3、首先，计算每个队列中正在运行的任务数与其应该分得的计算资源之间的比值，选择一个该比值最小的队列—最闲的。

4、其次，按照作业优先级和提交时间顺序，同时考虑用户资源量限制和内存限制对队列内任务排序。

5、三个队列同时按照任务的先后顺序依次执行，比如，job11、job21和job31分别排在队列最前面，先运行，也是并行运行。

3．公平调度器（Fair Scheduler），如图4-29所示

支持多队列多用户，每个队列中的资源量可以配置，同一队列中的作业公平共享队列中所有资源。

比如有三个队列：queueA、queueB和queueC，每个队列中的job按照优先级分配贪原，优先级越高分配的资源越多，但是每个job都会分到资源以确保公平。

在资源有限的情况下，每个job理想情况下获得的计算资源与实际获得的计算资源存在一种差距，这个差距就叫做缺额。

在同一个队列中，job的资源缺额越大，越先获得资源优先执行。作业是按照缺额的高低来先后执行的，而且可以看到上图有多个作业同时运行。

5.6 任务的推测执行

1．作业完成时间取决于最慢的任务完成时间

一个作业由若干个Map任务和Reduce任务构成。因硬件老化、软件Bug等，某些任务可能运行非常慢。

思考：系统中有99%的Map任务都完成了，只有少数几个Map老是进度很慢，完不成，怎么办？

2．推测执行机制

发现拖后腿的任务，比如某个任务运行速度远慢于任务平均速度。为拖后腿任务启动一个备份任务，同时运行。谁先运行完，则采用谁的结果。

3．执行推测任务的前提条件

（1）每个Task只能有一个备份任务
（2）当前Job已完成的Task必须不小于0.05（5%）
（3）开启推测执行参数设置。mapred-site.xml文件中默认是打开的。

<property>
  	<name>mapreduce.map.speculative</name>
  	<value>true</value>
  	<description>If true, then multiple instances of some map tasks may be executed in parallel.</description>
</property>

<property>
  	<name>mapreduce.reduce.speculative</name>
  	<value>true</value>
  	<description>If true, then multiple instances of some reduce tasks may be executed in parallel.</description>
</property>

4．不能启用推测执行机制情况

（1）任务间存在严重的负载倾斜；
（2）特殊任务，比如任务向数据库中写数据。

5．算法原理，如图4-20所示

假设某一时刻，任务T的执行进度为progress，则可通过一定的算法推测出该任务的最终完成时刻estimateEndTime。另一方面，如果此刻为该任务启动一个备份任务，则可推断出它可能的完成时刻estimateEndTime’，于是可得出以下几个公式：

1）MR总是选择（estimateEndTime-estimateEndTime）差值最大的任务，并为之启动备份任务。

2）为了防止大量任务同时启动备份任务造成的资源浪费，MR为每个作业设置了同时启动的备份任务数目上限。

3）推测执行机制实际上采用了经典的优化算法：以空间换时间，它同时启动多个相同任务处理相同的数据，并让这些任务竞争以缩短数据处理时间。显然，这种方法需要占用更多的计算资源。在集群资源紧缺的情况下，应合理使用该机制，争取在多用少量资源的情况下，减少作业的计算时间。