我是如何利用Hadoop做大规模日志压缩的

背景

刚毕业那几年有幸进入了当时非常热门的某社交网站，在数据平台部从事大数据开发相关的工作。从日志收集、存储、数据仓库建设、数据统计、数据展示都接触了一遍，比较早的赶上了大数据热这波浪潮。虽然今天的人工智能的热度要远高于大数据，但是大家还是不能否定大数据在人工智能中不可取代的地位。

话回正题，当时遇到了一个需要解决的问题就是如何快速对日志进行压缩。那时一天的日志量大概是3TB左右，共100+种日志，最大的一个日志一天要1TB，最小的日志只有几十M。统计需求大部分是用HIVE完成，HIVE中的表每天建立一个分区，每个分区对应一种日志的压缩文件（有天级和小时级）。

当时日志压缩方式是一个日志一个日志进行压缩，利用crontab进行任务并行，效率非常低。经常出现的情况是到了第二天中午12点钟，前一天的日志还没有压缩完，统计需求就没法用hive去做，报表数据就出不来，给我们的压力很大。

也许有小伙伴说，hive可以利用前一天不经过压缩的日志进行统计，后台慢慢进行日志压缩，压缩完成后在重新load一下分区不就ok了吗？这个方案确实可行。但是当时的实际情况是，有好多的表load的都是压缩后的数据，修改成本比较高（几百张表）。不得已还是得尽量缩短压缩时间，这个问题经过我的一番折腾，终于把日志压缩完成时间提前到凌晨1点钟之前，各种报表数据的统计可以在早晨八点钟之前完成。接下来我就把详细做法介绍给大家。

Hadoop并行压缩

压缩格式

首先我们就要讨论压缩格式，我们选择的压缩格式是bz2，原因是bz2算法支持分片压缩合并：即每个小bz2文件头尾相连拼接到一起就是一个大的bz2文件。map/reduce也支持对bz2文件的分块：即利用多个map同时对压缩文件的不同部分进行处理。当时也试过gzip算法，但是gzip没法分片，hive生成的任务只会有一个map，统计效率低下。

压缩方案

如图所示，有两个日志文件A.log和B.log需要压缩，利用map/reduce并行处理这两个日志。假设map/reduce自动为A.log和B.log分别生成3个map任务同时进行压缩，每个map任务读取日志文件的一部分并用bz2算法进行压缩后写入到集群的HDFS中。A.log通过map端压缩生成了3个压缩文件：A.log.1.bz2，A.log.2.bz2，A.log.3.bz2，之后map通过k-v对把<源文件名称，压缩文件名称>发送给reduce，这样相同日志就会分配到同一个reduce上。reduce做的事情很简单，首先根据压缩文件编号从小到大排序，然后从hadoop上读取压缩文件并merge到一起，最后在HDFS上生成一个新的压缩文件。

注：这里每个日志分成1,2,3三个块是为了描述方便，实际上使用的是map处理文件块时文件的偏移量。

存在的问题

• reduce性能瓶颈  这么做之后reduce就成为性能瓶颈了，因为一个日志最终都交给一个reduce进行合并，还是比较慢。解决方案是压缩前的日志不能按天存放，需要按小时存放，这样大日志可以分批次压缩合并到天级别的压缩文件中。由于我们只是保证在第二天及时产生前一天的压缩文件，我们在前一天就可以对已存在的部分日志进行分批压缩，而只在每天零点对前一天最后面几个小时的日志进行压缩合并，缩短延迟。当时我采用每6个小时压缩一次，这样一天的日志分四次压缩完成，每天凌晨只对前一天最后6小时日志压缩，延迟保证在一小时之内。
• 集群流量风暴 这个方案会大量的从HDFS上读写数据，非常容易造成集群流量风暴，导致集群上其它计算任务失败。解决方案是每次读写一定大小的数据后sleep几秒。
• map端读数据优化 我们知道map/reduce默认是按行读取数据并处理，这对于我们来说效率很低。比如一个大的日志可能有几亿条日志，那么就要调用map几亿次，而我们的map只对数据进行压缩，不要求按行传递，最好的方式是按块。解决方案是重写RecordReader类，实现自己的读数据方案。
• 如何让一个Reduce只merge一种日志 如果只按文件名进行reduce路由，就会出现有两种日志都分配到一个reduce上merge的情况。因为选择reduce的时候，默认行为是根据key计算哈希值后对reduce数取模得到编号，这样就有可能两个不同的key的哈希值是相同的。如果两个日志都分配到同一个reduce上，那么排在后面的日志必须等前面的日志merge完之后才能merge，效率不高。解决方案是：设置reduce数为日志种类数，覆写Partitioner类，把日志种类与reduce编号一一对应，这样就能达到所有日志不用排队同时merge的效果。

具体实现

在这里把需要实现的代码简要的列出来，这里面以java版本为例。

• FileInputFormat类：必须自己写一个类继承该类，覆写其createRecordReader方法。这个方法是一个工厂方法，告诉map/reduce需要一个什么样的RecordReader，RecordReader就是map读取数据所用到的类。

• public class CompressMergeInputFormat extends
          FileInputFormat<FileAndPos, ByteBuffer> {
  
      @Override
      public RecordReader<FileAndPos, ByteBuffer> createRecordReader(
              InputSplit split, TaskAttemptContext context) throws IOException,
              InterruptedException {
          return new CompressMergeRecordReader();
      }
  
      /**
       * 由于数据量较大，默认以8个blockSize作为一个Split分配给一个map。hadoop默认一个blockSize是64M，当日志量太大时会产生很多小压缩文件。
       * */
      @Override
      protected long computeSplitSize(long blockSize, long minSize, long maxSize) {
          return 8 * blockSize;
      }
  }

• RecordReader<KEY, VALUE>类：必须自己写一个类继承该类，该类是一个模板类，模板参数分别由Key和Value类型指定，实际上是kv对。map/reduce默认key是当前读取数据在文件中的偏移量，value是内容。我们必须覆写其initialize，nextKeyValue，getCurrentKey，getCurrentValue方法，并且实现KEY和VALUE。

• public class CompressMergeRecordReader extends
          RecordReader<FileAndPos, ByteBuffer> {
      private Path file;
      private long pos;
      private long readed = 0;
      private long length;
  
      private FileSystem fs;
      private FSDataInputStream in;
      private Configuration config = null;
  
      private FileAndPos currentKey = new FileAndPos();
      private ByteBuffer currentValue = new ByteBuffer();
  
      @Override
      public void initialize(InputSplit split, TaskAttemptContext context){
  
          FileSplit filesplit = (FileSplit) split;
          file = filesplit.getPath();       //获取文件路径
          pos = filesplit.getStart();       //获取split块偏移，每个split都会被map压缩成1个单独的文件
          length = filesplit.getLength();
          currentKey.setFile(file.toString());
          currentKey.setPos(pos);
          config = context.getConfiguration();
          fs = file.getFileSystem(context.getConfiguration());
          in = fs.open(file);
          in.seek(pos);
      }
  
      @Override
      public boolean nextKeyValue(){   //读取下一个k-v
          if (readed >= length) {
              return false;
          }
          int once = in.read(currentValue.buffer);
          currentValue.length = once;
          if (once == -1) {
              return false;
          }
          if(readed + once > length){   //如果大于本文件块则要少读一些
             currentValue.length = (int)(length - readed);
             readed = length;
          } else {
             readed += once;
          }
          return true;
      }
  
      @Override
      public FileAndPos getCurrentKey() throws IOException, InterruptedException {
          return currentKey;
      }
  
      @Override
      public ByteBuffer getCurrentValue() throws IOException,
              InterruptedException {
          return currentValue;
      }
      //... 其它省略
  }

• 实现KEY：必须是一个Writable对象，实现readFields和write和compareTo方法。我们的key中记录文件路径以及当前数据偏移量。

• public class FileAndPos implements WritableComparable<FileAndPos> {
      private String file;
      private long pos;
  
      @Override
      public void write(DataOutput out) throws IOException {
          out.writeUTF(file);
          out.writeLong(pos);
      }
  
      @Override
      public void readFields(DataInput in) throws IOException {
          file = in.readUTF();
          pos = in.readLong();
      }
  
      @Override
      public int compareTo(FileAndPos o) { //需要自己实现比较函数，map会把读到的一批key-value安装这个顺序排序
          int filecompare = file.compareTo(o.file);
          if (filecompare == 0) {
              if (pos < o.pos) {
                  return -1;
              } else if (pos > o.pos) {
                  return 1;
              } else {
                  return 0;
              }
          } else {
              return filecompare;
          }
      }
      //... 省略
  }

• 实现VALUE：可以实现成一个固定大小的数组（1M），代表调用一次map函数传递多少数据。

• public class ByteBuffer {
      public byte[] buffer = new byte[1024 * 1024];
      public int length = 0;
  }

• 实现Partitioner：当map完成时，在map的cleanup函数中向reduce发送一条kv。Partioner的默认行为是对key计算hash值，根据hash值对reduce数取模得到reduce编号。但是由于我们的key带有文件路径以及偏移信息，直接使用hadoop默认行为会把本应分到同一个reduce上的kv对分配到多个reduce上，造成多个reduce同时写一个文件的问题，所以我们必须重写Partitioner类，对同一个日志的kv对产生固定的reduce编号，这样达到所有种类日志同时merge，并且每个reduce只merge一种日志，不存在一个日志分配到多个reduce上的效果。

• public class CompressMergePartitioner extends Partitioner<Text, Text> {
  
      @Override
      public int getPartition(Text key, Text value, int numPartitions) {
  
          String str = key.toString();
  
          //查表得到日志对应的reduce编号，需要提前做好这张表
  
          return reduceIndex;
      }
  }

• 实现OutputFormat 由于我们的reduce是自己写文件，必须阻止reduce自己的默认行为（把value写入一个part_xxx文件），需要覆写OutputFormat类，使其不产生任何输出文件

• public class CompressMergeOutputFormat<K, V> extends OutputFormat<K, V> {
  
      @Override
      public RecordWriter<K, V> getRecordWriter(TaskAttemptContext context) {
          return new RecordWriter<K, V>() {
              public void write(K key, V value) {
                 //啥都不做
              }
  
              public void close(TaskAttemptContext context) {
              }
          };
      }
      //...其它代码忽略

• map实现

• public class CompressMergeMap extends
          Mapper<FileAndPos, ByteBuffer, Text, Text> {
      //...省略
      private CompressionOutputStream out;
  
      @Override
      protected void setup(Context context) throws IOException,
              InterruptedException {
  
          String buf = null;
          Configuration conf = context.getConfiguration();
          long pos = ((FileSplit) context.getInputSplit()).getStart();
          String path = ((FileSplit) context.getInputSplit()).getPath().toString();
          //....省略
      }
  
      @Override
      protected void cleanup(Context context) throws IOException,
              InterruptedException {        //根据path和pos生成你的key-value，key中包含日志名以及偏移量，value是这个Split的压缩文件路径
          context.write(key,value);
      }
  
      @Override
      protected void map(
              FileAndPos key,
              ByteBuffer value,
              org.apache.hadoop.mapreduce.Mapper<FileAndPos, ByteBuffer, Text, Text>.Context context)
              throws IOException, InterruptedException {
          out.write(value.buffer, 0, value.length);
          delta += value.length;
          if(delta >= 5 * 1024 * 1024){ //写5M休息一会
              Thread.sleep(10);
              delta = 0;
          }
      }
  }

• reduce实现 

• public class CompressMergeReduce extends
          Reducer<Text, Text, NullWritable, NullWritable> {
      private FileSystem fs;
  
      //...省略
  
      @Override
      protected void reduce(
              Text key,
              java.lang.Iterable<Text> values,
              org.apache.hadoop.mapreduce.Reducer<Text, Text, NullWritable, NullWritable>.Context context)
              throws IOException, InterruptedException {
  
          //根据key中的offset排序，然后merge到最终的bz2文件中
      }
  }