如何处理HDFS大量小文件问题

处理 HDFS 大量小文件问题是一个非常重要且常见的运维挑战。小文件会导致 NameNode 内存压力过大、元数据操作缓慢、MapReduce 任务效率低下等问题。

一、小文件问题的根源与影响
问题根源
bash
# 查看小文件分布
hdfs fsck / -files -blocks -locations | awk '{if ($5 < 1048576) print $0}' | wc -l

# 检查NameNode内存使用
hdfs dfsadmin -report | grep "Heap Memory"
影响分析
NameNode 内存压力：每个文件约占用 150-300 字节内存
读写性能下降：大量随机 I/O 操作
计算效率低下：MapReduce 任务启动开销大

二、预防策略：从源头解决
1. 数据摄入时合并
java
// Spark 写入时合并小文件
df.repartition(10)  // 控制输出文件数量
  .write()
  .option("maxRecordsPerFile", 1000000)  // 控制每个文件记录数
  .parquet("/output/path");

// Flink 写入优化
stream.addSink(new StreamingFileSink<String>()
    .withBucketCheckInterval(1000)
    .withBucketAssigner(new DateTimeBucketAssigner<>())
    .withRollingPolicy(new DefaultRollingPolicy(128, 60000, 60000))
);
2. 消息队列批量处理
java
// Kafka 消费者批量处理
Properties props = new Properties();
props.put("max.partition.fetch.bytes", 1048576);    // 1MB
props.put("fetch.max.bytes", 5242880);              // 5MB
props.put("max.poll.records", 1000);                // 批量拉取

三、解决方案：已存在小文件的处理
1. Hadoop Archive (HAR) - 官方归档方案
bash
# 创建 HAR 文件
hadoop archive -archiveName data.har -p /source/data /target/archive

# 查看 HAR 内容
hdfs dfs -ls har:///target/archive/data.har

# 从 HAR 读取文件
hdfs dfs -cat har:///target/archive/data.har/file1.txt

# 删除原文件（归档后）
hdfs dfs -rm -r /source/data
优缺点：
减少 NameNode 内存占用
保持文件系统兼容性
访问需要额外路径前缀
归档后不可修改

2. SequenceFile 合并方案
java
// 使用 MapReduce 合并小文件为 SequenceFile
public class SmallFilesToSequenceFile extends Configured implements Tool {
    
    public static class SequenceFileMapper 
        extends Mapper<NullWritable, BytesWritable, Text, BytesWritable> {
        
        private Text filenameKey = new Text();
        
        @Override
        protected void map(NullWritable key, BytesWritable value, Context context) 
            throws IOException, InterruptedException {
            String filename = ((FileSplit) context.getInputSplit()).getPath().getName();
            filenameKey.set(filename);
            context.write(filenameKey, value);
        }
    }
    
    public int run(String[] args) throws Exception {
        Job job = Job.getInstance(getConf(), "smallfiles-to-sequencefile");
        job.setJarByClass(SmallFilesToSequenceFile.class);
        
        job.setInputFormatClass(WholeFileInputFormat.class);
        job.setOutputFormatClass(SequenceFileOutputFormat.class);
        
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(BytesWritable.class);
        job.setMapperClass(SequenceFileMapper.class);
        job.setNumReduceTasks(0);
        
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        
        return job.waitForCompletion(true) 0 : 1;
    }
}
3. Spark 合并方案（推荐）
scala
// 读取小文件并重新分区写入
val spark = SparkSession.builder()
  .appName("SmallFileCompaction")
  .config("spark.sql.adaptive.enabled", "true")
  .config("spark.sql.adaptive.coalescePartitions.enabled", "true")
  .config("spark.sql.adaptive.advisoryPartitionSizeInBytes", "128MB")
  .getOrCreate()

// 方法1：直接读取合并
spark.read.parquet("/input/small/files/*")
  .repartition(10)  // 根据数据量调整分区数
  .write
  .option("compression", "snappy")
  .parquet("/output/compacted/files")

// 方法2：按日期分区合并
spark.read.parquet("/input/small/files/*")
  .repartition(col("date"), 5)  // 按日期字段分区
  .write
  .partitionBy("date")
  .parquet("/output/compacted/files")

// 方法3：使用 coalesce 避免 shuffle
spark.read.parquet("/input/small/files/*")
  .coalesce(8)  // 合并分区，无 shuffle
  .write
  .parquet("/output/compacted/files")
  
4. Hive 表合并方案
sql
-- 创建表时指定合并参数
CREATE TABLE compacted_table (
    id BIGINT,
    name STRING,
    value DOUBLE
) STORED AS PARQUET
TBLPROPERTIES (
    'parquet.block.size'='268435456',
    'parquet.page.size'='1048576'
);

-- 启用小文件合并
SET hive.merge.mapfiles=true;
SET hive.merge.mapredfiles=true;
SET hive.merge.size.per.task=268435456;
SET hive.merge.smallfiles.avgsize=134217728;

-- 插入数据自动合并
INSERT OVERWRITE TABLE compacted_table
SELECT * FROM source_table;

-- 手动合并已有表
ALTER TABLE existing_table CONCATENATE;

四、自动化处理脚本
1. 小文件检测脚本
bash
#!/bin/bash
# find_small_files.sh

HDFS_PATH=$1
SIZE_THRESHOLD=${2:-1048576}  # 默认 1MB

echo "Scanning for small files in: $HDFS_PATH"
echo "Size threshold: $((SIZE_THRESHOLD / 1024)) KB"

# 生成小文件报告
hdfs dfs -ls -R $HDFS_PATH | awk -v threshold=$SIZE_THRESHOLD '
BEGIN { total=0; count=0; }
{
    if ($5 ~ /^[0-9]+$/ && $5 < threshold) {
        count++;
        total += $5;
        print $5 "\t" $8;
    }
}
END { 
    print "=====================================";
    print "Total small files: " count;
    print "Total size: " total/1024/1024 " MB";
    print "Average size: " (count>0 total/count/1024 : 0) " KB";
}'

2. 自动合并脚本
bash
#!/bin/bash
# compact_small_files.sh

INPUT_DIR=$1
OUTPUT_DIR=$2
MAX_FILE_SIZE=134217728  # 128MB

# 使用 Spark 合并小文件
spark-submit \
    --class com.company.SmallFileCompaction \
    --master yarn \
    --deploy-mode cluster \
    --executor-memory 4G \
    --num-executors 10 \
    --conf spark.sql.adaptive.enabled=true \
    --conf spark.sql.adaptive.coalescePartitions.enabled=true \
    --conf spark.sql.adaptive.advisoryPartitionSizeInBytes=$MAX_FILE_SIZE \
    compaction-job.jar \
    $INPUT_DIR \
    $OUTPUT_DIR

# 验证合并结果
echo "Original file count:"
hdfs dfs -count $INPUT_DIR | awk '{print "Files: "$3}'

echo "Compacted file count:"
hdfs dfs -count $OUTPUT_DIR | awk '{print "Files: "$3}'

五、存储格式优化
1. 使用列式存储格式
sql
-- 创建 ORC 格式表（推荐）
CREATE TABLE orc_table (
    id BIGINT,
    name STRING,
    value DOUBLE
) STORED AS ORC
TBLPROPERTIES (
    'orc.compress'='SNAPPY',
    'orc.stripe.size'='268435456',
    'orc.row.index.stride'=10000
);

-- 创建 Parquet 格式表
CREATE TABLE parquet_table (
    id BIGINT,
    name STRING, 
    value DOUBLE
) STORED AS PARQUET
TBLPROPERTIES (
    'parquet.compression'='SNAPPY',
    'parquet.block.size'='268435456'
);
2. 分区和分桶策略
sql
-- 分区表减少扫描范围
CREATE TABLE partitioned_table (
    id BIGINT,
    name STRING,
    value DOUBLE
) PARTITIONED BY (date STRING, hour STRING)
STORED AS ORC;

-- 分桶表优化 JOIN 和采样
CREATE TABLE bucketed_table (
    id BIGINT, 
    name STRING,
    value DOUBLE
) CLUSTERED BY (id) INTO 50 BUCKETS
STORED AS ORC;

六、运维监控和告警
1. NameNode 内存监控
bash
#!/bin/bash
# monitor_nn_memory.sh

MEMORY_USAGE=$(hdfs dfsadmin -report | grep "Heap Memory" | awk '{print $5}')
THRESHOLD=80  # 80%

if (( $(echo "$MEMORY_USAGE > $THRESHOLD" | bc -l) )); then
    echo "ALERT: NameNode memory usage is ${MEMORY_USAGE}%"
    # 发送告警邮件或通知
    echo "High NameNode memory usage detected" | mail -s "HDFS Alert" admin@company.com
fi
2. 小文件数量监控
python
#!/usr/bin/env python3
import subprocess
import smtplib
from email.mime.text import MimeText

def check_small_files():
    """检查小文件数量"""
    cmd = "hdfs fsck / -files"
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
    
    # 解析输出获取文件数量
    lines = result.stdout.split('\n')
    for line in lines:
        if "Total files" in line:
            total_files = int(line.split(':')[1].strip())
            
            if total_files > 1000000:  # 超过100万文件告警
                send_alert(total_files)

def send_alert(file_count):
    """发送告警邮件"""
    msg = MimeText(f"HDFS小文件数量过多: {file_count}个文件")
    msg['Subject'] = 'HDFS小文件告警'
    msg['From'] = 'hdfs-monitor@company.com'
    msg['To'] = 'admin@company.com'
    
    # 发送邮件逻辑
    # ...
七、最佳实践总结
1. 预防为主
数据摄入时合并：在写入前进行批量处理
选择合适格式：使用 ORC/Parquet 列式存储
合理分区：避免过度分区产生小文件

2. 处理已有问题
定期合并：使用 Spark/Hive 定期合并小文件
归档历史数据：对不常访问的数据使用 HAR 归档
监控告警：建立小文件数量监控机制

3. 技术选型建议
graph TD
    A[小文件问题] --> B{处理方案选择}
    B --> C[实时数据]C --> F[Spark Streaming<br>微批处理]
    B --> D[批量数据]D --> G[Spark/Hive<br>定期合并]
    B --> E[历史数据]E --> H[HAR归档<br>冷存储]
    F --> I[目标: 128-256MB/文件]
    G --> I
    H --> J[目标: 减少NN内存压力]

4. 参数调优参考
bash
# Spark 合并参数
spark.sql.adaptive.enabled=true
spark.sql.adaptive.coalescePartitions.enabled=true  
spark.sql.adaptive.advisoryPartitionSizeInBytes=134217728

# Hive 合并参数
hive.merge.mapfiles=true
hive.merge.mapredfiles=true
hive.merge.size.per.task=268435456
hive.merge.smallfiles.avgsize=134217728
通过以上综合方案，可以有效地预防和处理 HDFS 小文件问题，提升集群性能和稳定性。
建议根据实际业务场景选择合适的方案组合使用。