大数据 on heyaohua's Blog

最佳实践：调优 Impala 与 Hive 的资源竞争关系，避免 Impala 查询 OOM

Tue, 09 Sep 2025 01:00:00 +0800

核心结论： 要有效避免 Impala 查询因资源被批处理（Hive/Tez）占满而导致 OOM，需在集群级和服务级两个维度协同调优，重点在于隔离资源、配置队列及精细化设置查询内存和并发。

一、集群级资源隔离

1. 使用 YARN 容器隔离 Hive（Tez）批处理与 Impala

将 Hive-on-Tez 运行在 YARN 上，通过配置不同的 YARN 队列（Queue）来隔离批处理作业与交互式查询。

示例配置（capacity-scheduler.xml）：


  yarn.scheduler.capacity.root.interactive.capacity
  30


  yarn.scheduler.capacity.root.batch.capacity
  70

如上，Batch 队列占 70%，Interactive（即 Hive LLAP/Impala）队列占 30%，确保 Impala 始终保留至少 30% 资源。

2. Cloudera Manager（或 Ambari）中的 cGroup 资源池

在 Cloudera Manager 上，启用 Impala 服务的 CPU & Memory cGroup 限制
设置 Impala 每台节点最大可用内存比率，以及各服务内不同工作负载（Workload）的最小/最大资源保证

配置步骤：

启用 cGroup 资源管理`bash

在每个节点上启用 cGroup

sudo systemctl enable cgconfig sudo systemctl start cgconfig`

配置资源池`bash

创建 Impala 专用资源池

echo ‘group impala { memory { memory.limit_in_bytes = 32G; } cpu { cpu.shares = 1024; } }’ » /etc/cgconfig.conf`

应用配置bash sudo cgconfigparser -l /etc/cgconfig.conf

二、Impala 层面调优

1. 配置 Admission Control

启用并配置 Impala 的 Admission Control（Impala Daemon → Admission Control）。

关键设置：

Concurrent queries limit（并发查询数）：限制同时执行的查询数量
Queue timeout（排队超时）：避免过多查询长时间排队
Memory limit per pool：针对不同资源池（Pool）设置内存上下限

配置示例：

# 在 Impala 配置文件中添加
--admission_control_slots=16
--admission_control_stale_topic_threshold_ms=30000
--queue_wait_timeout_ms=60000

2. 定义并使用资源池（Resource Pools）

将查询分别分配到不同的资源池（如 high_mem_pool、standard_pool），并在资源池级别配置：

max_requests：同时执行最大请求数
max_mem：最大内存配额
query_timeout_s：超时设置

示例配置：

-- 创建高内存资源池
ALTER RESOURCE POOL high_mem_pool SET MAX_MEM=200GB, MAX_QUERIES=5;

-- 创建标准资源池
ALTER RESOURCE POOL standard_pool SET MAX_MEM=100GB, MAX_QUERIES=10;

-- 创建轻量级资源池
ALTER RESOURCE POOL light_pool SET MAX_MEM=50GB, MAX_QUERIES=20;

使用资源池：

-- 在查询中指定资源池
SET REQUEST_POOL=high_mem_pool;
SELECT * FROM large_table WHERE complex_condition;

-- 或者在连接时指定
-- impala-shell -i hostname:21000 --request_pool=standard_pool

3. 调整单查询内存限制

Impala 默认使用所有可用内存作为单查询内存上限。可通过启动参数或查询选项限制：

-- 设置单查询内存限制
SET MEM_LIMIT=8g;  -- 单查询可用内存上限

-- 设置查询超时
SET QUERY_TIMEOUT_S=3600;  -- 1小时超时

-- 设置批处理大小
SET BATCH_SIZE=1024;

在 Cloudera Manager 中的全局配置：

# Impala Daemon → Configuration → Query Options
--default_query_options=MEM_LIMIT=8GB,QUERY_TIMEOUT_S=3600

4. 优化查询执行参数

-- 启用运行时过滤
SET RUNTIME_FILTER_MODE=GLOBAL;

-- 优化 Join 策略
SET DISABLE_CODEGEN=false;
SET NUM_NODES=0;  -- 自动选择节点数

-- 控制并行度
SET NUM_SCANNER_THREADS=4;
SET MT_DOP=4;  -- 多线程并行度

三、Hive/LLAP 层面调优

1. 限制 LLAP 容器内存

在 Hive LLAP 中，将 LLAP daemon 容器的内存和并发分配合理划分，避免 LLAP 过度消耗 YARN 容器。

关键配置参数：



  hive.llap.daemon.memory.per.instance.mb
  16384  



  hive.llap.daemon.num.executors
  8  



  hive.llap.io.memory.size
  8192  



  hive.llap.daemon.vcpus.per.instance
  8

2. 控制 Hive 并发与队列

在 Hive Server2 或 Tez 上，设置相关参数防止单个大作业占满整个队列。

Tez 配置：



  tez.am.resource.memory.mb
  4096  



  tez.task.resource.memory.mb
  2048  



  tez.am.container.reuse.enabled
  true  



  tez.am.container.idle.release-timeout-min.millis
  10000

YARN 队列配置：



  yarn.scheduler.capacity.root.batch.maximum-applications
  50  



  yarn.scheduler.capacity.root.batch.maximum-am-resource-percent
  0.3  



  yarn.scheduler.capacity.root.interactive.user-limit-factor
  2

3. Hive 查询优化

-- 启用向量化执行
SET hive.vectorized.execution.enabled=true;
SET hive.vectorized.execution.reduce.enabled=true;

-- 优化 Join 策略
SET hive.auto.convert.join=true;
SET hive.mapjoin.smalltable.filesize=25000000;

-- 启用 CBO（基于成本的优化器）
SET hive.cbo.enable=true;
SET hive.compute.query.using.stats=true;

-- 控制并行度
SET hive.exec.parallel=true;
SET hive.exec.parallel.thread.number=8;

四、运维与监控建议

1. 实时监控与告警

利用 Cloudera Manager 监控：

Impala 指标监控：
查询队列长度
内存使用率
查询执行时间

失败查询数量

YARN 队列监控：

队列资源使用率
应用等待时间
容器分配情况

Grafana 监控面板配置：

{
  "dashboard": {
    "title": "Impala & Hive Resource Monitor",
    "panels": [
      {
        "title": "Impala Memory Usage",
        "type": "graph",
        "targets": [
          {
            "expr": "impala_daemon_mem_rss / impala_daemon_mem_limit * 100",
            "legendFormat": "Memory Usage %"
          }
        ]
      },
      {
        "title": "YARN Queue Utilization",
        "type": "graph",
        "targets": [
          {
            "expr": "yarn_queue_used_capacity{queue=\"interactive\"}",
            "legendFormat": "Interactive Queue"
          },
          {
            "expr": "yarn_queue_used_capacity{queue=\"batch\"}",
            "legendFormat": "Batch Queue"
          }
        ]
      }
    ]
  }
}

告警规则配置：

# Prometheus 告警规则
groups:
- name: impala_alerts
  rules:
  - alert: ImpalaHighMemoryUsage
    expr: impala_daemon_mem_rss / impala_daemon_mem_limit > 0.9
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Impala daemon memory usage is high"
      description: "Memory usage is {{ $value }}%"

  - alert: ImpalaQueryQueueHigh
    expr: impala_admission_controller_queue_size > 10
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "Impala query queue is too long"
      description: "Queue size: {{ $value }}"

2. 定期审计大查询

查询性能分析脚本：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Impala 查询性能分析脚本
用于识别和分析耗时/耗内存的查询
"""

import impala.dbapi
import pandas as pd
from datetime import datetime, timedelta

def analyze_slow_queries(host='localhost', port=21000, days=7):
    """
    分析慢查询

    Args:
        host: Impala 主机地址
        port: Impala 端口
        days: 分析最近几天的查询
    """
    conn = impala.dbapi.connect(host=host, port=port)
    cursor = conn.cursor()

    # 查询最近的慢查询
    query = f"""
    SELECT
        query_id,
        user,
        default_db,
        statement,
        start_time,
        end_time,
        duration_ms,
        rows_produced,
        peak_memory_usage
    FROM sys.impala_query_log
    WHERE start_time >= NOW() - INTERVAL {days} DAYS
        AND duration_ms > 60000  -- 超过1分钟的查询
    ORDER BY duration_ms DESC
    LIMIT 50
    """

    cursor.execute(query)
    results = cursor.fetchall()

    # 转换为 DataFrame 进行分析
    df = pd.DataFrame(results, columns=[
        'query_id', 'user', 'default_db', 'statement',
        'start_time', 'end_time', 'duration_ms',
        'rows_produced', 'peak_memory_usage'
    ])

    # 分析结果
    print("=== 慢查询分析报告 ===")
    print(f"分析时间范围: 最近 {days} 天")
    print(f"慢查询总数: {len(df)}")
    print(f"平均执行时间: {df['duration_ms'].mean()/1000:.2f} 秒")
    print(f"最大内存使用: {df['peak_memory_usage'].max()/1024/1024/1024:.2f} GB")

    # 按用户统计
    user_stats = df.groupby('user').agg({
        'query_id': 'count',
        'duration_ms': 'mean',
        'peak_memory_usage': 'max'
    }).round(2)

    print("\n=== 用户查询统计 ===")
    print(user_stats)

    # 识别需要优化的查询
    high_memory_queries = df[df['peak_memory_usage'] > 10*1024*1024*1024]  # 超过10GB
    print(f"\n=== 高内存查询 (>10GB): {len(high_memory_queries)} 条 ===")

    for _, query in high_memory_queries.iterrows():
        print(f"Query ID: {query['query_id']}")
        print(f"User: {query['user']}")
        print(f"Memory: {query['peak_memory_usage']/1024/1024/1024:.2f} GB")
        print(f"Duration: {query['duration_ms']/1000:.2f} seconds")
        print(f"Statement: {query['statement'][:100]}...")
        print("-" * 50)

    conn.close()
    return df

def get_query_profile(query_id, host='localhost', port=21000):
    """
    获取查询的详细执行计划

    Args:
        query_id: 查询ID
        host: Impala 主机地址
        port: Impala 端口
    """
    conn = impala.dbapi.connect(host=host, port=port)
    cursor = conn.cursor()

    cursor.execute(f"PROFILE {query_id}")
    profile = cursor.fetchall()

    print(f"=== Query Profile for {query_id} ===")
    for line in profile:
        print(line[0])

    conn.close()

if __name__ == "__main__":
    # 分析最近7天的慢查询
    df = analyze_slow_queries()

    # 如果有高内存查询，获取详细的执行计划
    if len(df) > 0:
        top_query_id = df.iloc[0]['query_id']
        get_query_profile(top_query_id)

SQL 优化建议脚本：

-- 查询优化检查清单

-- 1. 检查表统计信息是否最新
SHOW TABLE STATS your_table;
COMPUTE STATS your_table;

-- 2. 检查分区剪裁是否生效
EXPLAIN SELECT * FROM partitioned_table WHERE partition_col = 'value';

-- 3. 检查列裁剪是否生效
EXPLAIN SELECT col1, col2 FROM large_table WHERE condition;

-- 4. 检查 Join 策略
SET EXPLAIN_LEVEL=2;
EXPLAIN SELECT * FROM table1 t1 JOIN table2 t2 ON t1.id = t2.id;

-- 5. 优化大表 Join
-- 使用 broadcast join 对小表
SET RUNTIME_FILTER_MODE=GLOBAL;
SELECT /*+ BROADCAST(small_table) */
  *
FROM large_table
JOIN small_table ON large_table.id = small_table.id;

-- 6. 使用分区 Join
SELECT *
FROM partitioned_table1 pt1
JOIN partitioned_table2 pt2
  ON pt1.partition_key = pt2.partition_key
  AND pt1.join_key = pt2.join_key
WHERE pt1.partition_key = 'specific_partition';

3. 版本与补丁管理

版本兼容性检查：

#!/bin/bash
# 检查 Impala 和 Hive 版本兼容性

echo "=== 组件版本信息 ==="
echo "Impala Version:"
impala-shell --version

echo "\nHive Version:"
hive --version

echo "\nHadoop Version:"
hadoop version

echo "\nYARN Version:"
yarn version

# 检查关键配置
echo "\n=== 关键配置检查 ==="
echo "YARN 调度器类型:"
hadoop conf -get yarn.resourcemanager.scheduler.class

echo "\nImpala Admission Control:"
impala-shell -q "SHOW CONFIG" | grep admission

echo "\nHive LLAP 状态:"
hive --service llap --instances

自动化补丁检查脚本：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
自动检查 Impala/Hive 相关组件的补丁状态
"""

import subprocess
import re
from packaging import version

def check_component_version(component_name, current_version, min_recommended_version):
    """
    检查组件版本是否满足最低推荐版本

    Args:
        component_name: 组件名称
        current_version: 当前版本
        min_recommended_version: 最低推荐版本
    """
    try:
        if version.parse(current_version) >= version.parse(min_recommended_version):
            print(f"✅ {component_name}: {current_version} (推荐版本: {min_recommended_version})")
            return True
        else:
            print(f"⚠️  {component_name}: {current_version} (需要升级到: {min_recommended_version})")
            return False
    except Exception as e:
        print(f"❌ {component_name}: 版本检查失败 - {e}")
        return False

def get_impala_version():
    """获取 Impala 版本"""
    try:
        result = subprocess.run(['impala-shell', '--version'],
                              capture_output=True, text=True)
        version_match = re.search(r'version (\d+\.\d+\.\d+)', result.stdout)
        return version_match.group(1) if version_match else "unknown"
    except:
        return "unknown"

def get_hive_version():
    """获取 Hive 版本"""
    try:
        result = subprocess.run(['hive', '--version'],
                              capture_output=True, text=True)
        version_match = re.search(r'Hive (\d+\.\d+\.\d+)', result.stdout)
        return version_match.group(1) if version_match else "unknown"
    except:
        return "unknown"

def main():
    """主函数"""
    print("=== 组件版本检查 ===")

    # 定义最低推荐版本
    min_versions = {
        'Impala': '3.4.0',
        'Hive': '3.1.2',
        'Hadoop': '3.2.0'
    }

    # 检查各组件版本
    impala_version = get_impala_version()
    hive_version = get_hive_version()

    results = []
    results.append(check_component_version('Impala', impala_version, min_versions['Impala']))
    results.append(check_component_version('Hive', hive_version, min_versions['Hive']))

    # 输出总结
    print("\n=== 检查结果 ===")
    if all(results):
        print("✅ 所有组件版本都满足推荐要求")
    else:
        print("⚠️  部分组件需要升级，请参考官方升级指南")
        print("   - Impala: https://impala.apache.org/docs/build.html")
        print("   - Hive: https://hive.apache.org/downloads.html")

if __name__ == "__main__":
    main()

五、故障排查与应急处理

1. 常见 OOM 场景分析

场景一：大表 Join 导致的 OOM

-- 问题查询示例
SELECT *
FROM large_table1 lt1
JOIN large_table2 lt2 ON lt1.id = lt2.id;

-- 优化方案
-- 1. 添加过滤条件
SELECT *
FROM large_table1 lt1
JOIN large_table2 lt2 ON lt1.id = lt2.id
WHERE lt1.date_col >= '2024-01-01';

-- 2. 使用分区 Join
SELECT *
FROM large_table1 lt1
JOIN large_table2 lt2
  ON lt1.id = lt2.id
  AND lt1.partition_col = lt2.partition_col
WHERE lt1.partition_col = 'specific_partition';

-- 3. 分阶段处理
CREATE TABLE temp_result AS
SELECT lt1.id, lt1.col1, lt2.col2
FROM large_table1 lt1
JOIN (
  SELECT id, col2
  FROM large_table2
  WHERE filter_condition
) lt2 ON lt1.id = lt2.id;

场景二：聚合查询内存溢出

-- 问题查询
SELECT
  high_cardinality_col,
  COUNT(*),
  SUM(large_numeric_col),
  AVG(another_col)
FROM huge_table
GROUP BY high_cardinality_col;

-- 优化方案
-- 1. 增加预聚合
CREATE TABLE pre_aggregated AS
SELECT
  partition_col,
  high_cardinality_col,
  COUNT(*) as cnt,
  SUM(large_numeric_col) as sum_val
FROM huge_table
WHERE date_col >= '2024-01-01'
GROUP BY partition_col, high_cardinality_col;

-- 2. 使用窗口函数替代
SELECT
  high_cardinality_col,
  COUNT(*) OVER (PARTITION BY high_cardinality_col) as cnt
FROM huge_table
WHERE sample_condition;

2. 应急处理流程

紧急情况处理脚本：

#!/bin/bash
# Impala OOM 应急处理脚本

echo "=== Impala OOM 应急处理 ==="
echo "时间: $(date)"

# 1. 检查当前运行的查询
echo "\n1. 检查当前运行查询..."
impala-shell -q "SHOW QUERIES" | head -20

# 2. 检查资源使用情况
echo "\n2. 检查资源使用情况..."
echo "内存使用:"
free -h
echo "\nCPU 使用:"
top -bn1 | head -10

# 3. 检查 YARN 队列状态
echo "\n3. 检查 YARN 队列状态..."
yarn queue -status interactive
yarn queue -status batch

# 4. 取消长时间运行的查询
echo "\n4. 检查长时间运行的查询..."
impala-shell -q "
SELECT query_id, user, duration_ms/1000 as duration_sec, statement
FROM sys.impala_query_log
WHERE end_time IS NULL
  AND start_time < NOW() - INTERVAL 10 MINUTES
ORDER BY start_time
" | while read query_id user duration statement; do
    if [ "$duration" -gt 600 ]; then  # 超过10分钟
        echo "发现长时间运行查询: $query_id (用户: $user, 时长: ${duration}秒)"
        echo "语句: ${statement:0:100}..."
        read -p "是否取消此查询? (y/N): " confirm
        if [ "$confirm" = "y" ] || [ "$confirm" = "Y" ]; then
            impala-shell -q "CANCEL '$query_id'"
            echo "已取消查询: $query_id"
        fi
    fi
done

# 5. 临时调整资源限制
echo "\n5. 临时调整资源限制..."
read -p "是否临时降低内存限制? (y/N): " adjust_mem
if [ "$adjust_mem" = "y" ] || [ "$adjust_mem" = "Y" ]; then
    echo "设置临时内存限制为 4GB..."
    impala-shell -q "SET MEM_LIMIT=4GB"
fi

# 6. 重启 Impala 服务（最后手段）
echo "\n6. 服务重启选项..."
read -p "是否需要重启 Impala 服务? (y/N): " restart_service
if [ "$restart_service" = "y" ] || [ "$restart_service" = "Y" ]; then
    echo "重启 Impala 服务..."
    sudo systemctl restart impala-server
    sudo systemctl restart impala-state-store
    sudo systemctl restart impala-catalog
    echo "Impala 服务已重启"
fi

echo "\n=== 应急处理完成 ==="

3. 预防性维护

定期维护脚本：

#!/bin/bash
# Impala 预防性维护脚本

echo "=== Impala 预防性维护 ==="
echo "开始时间: $(date)"

# 1. 更新表统计信息
echo "\n1. 更新表统计信息..."
impala-shell -f - <-- 更新所有表的统计信息
SHOW DATABASES;
EOF

# 获取所有数据库和表
impala-shell -q "SHOW DATABASES" --delimited | while read db; do
    if [ "$db" != "_impala_builtins" ]; then
        echo "处理数据库: $db"
        impala-shell -q "USE $db; SHOW TABLES" --delimited | while read table; do
            echo "  更新表统计: $db.$table"
            impala-shell -q "COMPUTE STATS $db.$table" 2>/dev/null || echo "    跳过: $db.$table"
        done
    fi
done

# 2. 清理查询日志
echo "\n2. 清理历史查询日志..."
impala-shell -q "
DELETE FROM sys.impala_query_log
WHERE start_time < NOW() - INTERVAL 30 DAYS
" 2>/dev/null || echo "查询日志清理跳过"

# 3. 检查磁盘空间
echo "\n3. 检查磁盘空间..."
df -h | grep -E '(hdfs|/var|/tmp)'

# 4. 检查服务状态
echo "\n4. 检查服务状态..."
sudo systemctl status impala-server impala-state-store impala-catalog

# 5. 生成维护报告
echo "\n5. 生成维护报告..."
cat > /tmp/impala_maintenance_report_$(date +%Y%m%d).txt <Impala 维护报告
生成时间: $(date)

=== 系统资源状态 ===
$(free -h)

=== 磁盘使用情况 ===
$(df -h)

=== 服务状态 ===
$(sudo systemctl status impala-server --no-pager -l)

=== 最近查询统计 ===
$(impala-shell -q "SELECT COUNT(*) as total_queries, AVG(duration_ms)/1000 as avg_duration_sec FROM sys.impala_query_log WHERE start_time >= NOW() - INTERVAL 1 DAY" --delimited)

EOF

echo "维护报告已生成: /tmp/impala_maintenance_report_$(date +%Y%m%d).txt"
echo "\n=== 预防性维护完成 ==="

总结

通过 YARN 队列隔离、cGroup 限制、Impala Admission Control、资源池及单查询内存上限等多维度设置，可以在集群层面与服务层面同时发力，实现 Hive 批处理与 Impala 交互式查询的平衡，避免 Impala 查询因资源竞争而 OOM。

关键要点总结：

集群级隔离：使用 YARN 队列和 cGroup 进行资源隔离
服务级控制：配置 Admission Control 和资源池
查询级优化：设置内存限制和超时参数
监控告警：建立完善的监控和告警体系
定期维护：执行预防性维护和性能优化

最佳实践建议：

渐进式调优：从保守配置开始，逐步优化
监控驱动：基于监控数据进行调整
文档记录：记录所有配置变更和效果
应急预案：制定完善的故障处理流程
定期评估：定期评估和调整资源配置

通过系统性的资源管理和优化，可以有效避免 Impala 查询 OOM 问题，提升整体集群的稳定性和性能。

Docker Hue 时区修改完整指南

Mon, 08 Sep 2025 10:00:00 +0800

问题描述

使用Docker启动Hue后，发现时区不正确，显示UTC时间而不是中国标准时间(CST)。具体表现为：

HDFS文件时间显示为UTC时间（如06:00-06:01）
实际文件创建时间为中国时间（如14:00-14:01）
Hue日志时间格式混乱

解决方案概述

需要从多个层面修改时区设置：

容器系统时区设置
Hue配置文件时区设置
Django时区设置
文件浏览器模块时区处理

详细修改步骤

1. 检查当前容器状态

# 查看运行中的Hue容器
docker ps -a | grep hue

# 检查容器时区
docker exec  date

# 检查Hue日志时间格式
docker logs  --tail 10

2. 备份原始配置

# 备份Hue配置文件
cp /data/server/hue-server/config/hue.ini /data/server/hue-server/config/hue.ini.backup.$(date +%Y%m%d_%H%M%S)
cp /data/server/hue-server/config/z-hue-overrides.ini /data/server/hue-server/config/z-hue-overrides.ini.backup.$(date +%Y%m%d_%H%M%S)

3. 修改Hue配置文件中的时区设置

3.1 修改主配置文件

# 修改 hue.ini 中的时区设置
sed -i 's/time_zone=America\/Los_Angeles/time_zone=Asia\/Shanghai/g' /data/server/hue-server/config/hue.ini

# 添加Django时区设置
sed -i '/time_zone=Asia\/Shanghai/a use_tz=true' /data/server/hue-server/config/hue.ini

3.2 修改覆盖配置文件

# 修改 z-hue-overrides.ini 中的时区设置
sed -i 's/time_zone=America\/Los_Angeles/time_zone=Asia\/Shanghai/g' /data/server/hue-server/config/z-hue-overrides.ini

4. 重新创建容器（包含时区和DNS设置）

4.1 停止并删除旧容器

docker stop 
docker rm

4.2 创建新容器

docker run -d --name hue_new \
  -p 8888:8888 \
  -e TZ=Asia/Shanghai \
  -v /etc/localtime:/etc/localtime:ro \
  -v /usr/share/zoneinfo/Asia/Shanghai:/etc/timezone:ro \
  -v /data/server/hue-server/config:/usr/share/hue/desktop/conf \
  --dns=100.100.2.136 \
  --dns=8.8.8.8 \
  gethue/hue:latest

5. 修改文件浏览器模块时区处理

5.1 备份原始文件

docker exec hue_new cp /usr/share/hue/apps/filebrowser/src/filebrowser/views.py /usr/share/hue/apps/filebrowser/src/filebrowser/views.py.backup

5.2 修改时区处理代码

# 添加Django时区导入
docker exec hue_new sed -i "s/from datetime import datetime/from datetime import datetime, timezone, timedelta\nfrom django.utils import timezone as django_timezone/g" /usr/share/hue/apps/filebrowser/src/filebrowser/views.py

# 修改时间格式化代码
docker exec hue_new sed -i "s/datetime.fromtimestamp(stats.mtime).strftime('%B %d, %Y %I:%M %p')/django_timezone.make_aware(datetime.fromtimestamp(stats.mtime)).strftime('%B %d, %Y %I:%M %p')/g" /usr/share/hue/apps/filebrowser/src/filebrowser/views.py

5.3 清除Python缓存

docker exec hue_new find /usr/share/hue -name "*.pyc" -path "*/filebrowser/*" -delete
docker exec hue_new find /usr/share/hue -name "__pycache__" -path "*/filebrowser/*" -exec rm -rf {} \; 2>/dev/null || true

6. 重启容器应用修改

docker restart hue_new

7. 验证修改结果

7.1 检查系统时区

# 检查容器系统时间
docker exec hue_new date

# 检查时区环境变量
docker exec hue_new env | grep TZ

# 检查时区文件
docker exec hue_new cat /etc/timezone

7.2 检查Hue应用时区

# 查看Hue日志，确认时间格式
docker logs hue_new --tail 10

# 检查Django时区设置
docker exec hue_new /usr/share/hue/build/env/bin/python3 -c "import os; os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'desktop.settings'); import django; django.setup(); from django.utils import timezone; print('Django timezone:', timezone.get_current_timezone())"

7.3 检查文件浏览器时间显示

访问Hue文件浏览器，查看HDFS文件的时间显示是否正确。

关键配置说明

1. 环境变量设置

TZ=Asia/Shanghai: 设置容器系统时区
-v /etc/localtime:/etc/localtime:ro: 挂载主机时区文件
-v /usr/share/zoneinfo/Asia/Shanghai:/etc/timezone:ro: 挂载时区信息文件

2. DNS设置

--dns=100.100.2.136: 内网DNS服务器
--dns=8.8.8.8: 公共DNS服务器

3. 配置文件修改

hue.ini: 主配置文件中的 time_zone=Asia/Shanghai 和 use_tz=true
z-hue-overrides.ini: 覆盖配置文件中的 time_zone=Asia/Shanghai

4. 代码修改

文件：/usr/share/hue/apps/filebrowser/src/filebrowser/views.py
修改：使用Django的时区设置处理文件时间显示

完整的一键脚本

#!/bin/bash
# Hue时区修改完整脚本

CONTAINER_NAME="hue_new"
CONFIG_PATH="/data/server/hue-server/config"

echo "开始修改Hue时区设置..."

# 1. 备份配置
echo "备份原始配置..."
cp $CONFIG_PATH/hue.ini $CONFIG_PATH/hue.ini.backup.$(date +%Y%m%d_%H%M%S)
cp $CONFIG_PATH/z-hue-overrides.ini $CONFIG_PATH/z-hue-overrides.ini.backup.$(date +%Y%m%d_%H%M%S)

# 2. 修改配置文件
echo "修改时区配置..."
sed -i 's/time_zone=America\/Los_Angeles/time_zone=Asia\/Shanghai/g' $CONFIG_PATH/hue.ini
sed -i 's/time_zone=America\/Los_Angeles/time_zone=Asia\/Shanghai/g' $CONFIG_PATH/z-hue-overrides.ini
sed -i '/time_zone=Asia\/Shanghai/a use_tz=true' $CONFIG_PATH/hue.ini

# 3. 停止旧容器
echo "停止旧容器..."
docker stop $CONTAINER_NAME 2>/dev/null || true
docker rm $CONTAINER_NAME 2>/dev/null || true

# 4. 创建新容器
echo "创建新容器..."
docker run -d --name $CONTAINER_NAME \
  -p 8888:8888 \
  -e TZ=Asia/Shanghai \
  -v /etc/localtime:/etc/localtime:ro \
  -v /usr/share/zoneinfo/Asia/Shanghai:/etc/timezone:ro \
  -v $CONFIG_PATH:/usr/share/hue/desktop/conf \
  --dns=100.100.2.136 \
  --dns=8.8.8.8 \
  gethue/hue:latest

# 5. 等待启动
echo "等待容器启动..."
sleep 20

# 6. 修改文件浏览器代码
echo "修改文件浏览器时区处理..."
docker exec $CONTAINER_NAME cp /usr/share/hue/apps/filebrowser/src/filebrowser/views.py /usr/share/hue/apps/filebrowser/src/filebrowser/views.py.backup
docker exec $CONTAINER_NAME sed -i "s/from datetime import datetime/from datetime import datetime, timezone, timedelta\nfrom django.utils import timezone as django_timezone/g" /usr/share/hue/apps/filebrowser/src/filebrowser/views.py
docker exec $CONTAINER_NAME sed -i "s/datetime.fromtimestamp(stats.mtime).strftime('%B %d, %Y %I:%M %p')/django_timezone.make_aware(datetime.fromtimestamp(stats.mtime)).strftime('%B %d, %Y %I:%M %p')/g" /usr/share/hue/apps/filebrowser/src/filebrowser/views.py

# 7. 清除缓存
echo "清除Python缓存..."
docker exec $CONTAINER_NAME find /usr/share/hue -name "*.pyc" -path "*/filebrowser/*" -delete
docker exec $CONTAINER_NAME find /usr/share/hue -name "__pycache__" -path "*/filebrowser/*" -exec rm -rf {} \; 2>/dev/null || true

# 8. 重启容器
echo "重启容器应用修改..."
docker restart $CONTAINER_NAME

# 9. 等待重启
echo "等待容器重启..."
sleep 25

# 10. 验证结果
echo "验证时区设置..."
echo "系统时间:"
docker exec $CONTAINER_NAME date
echo ""
echo "Hue日志时间格式:"
docker logs $CONTAINER_NAME --tail 3
echo ""
echo "Django时区设置:"
docker exec $CONTAINER_NAME /usr/share/hue/build/env/bin/python3 -c "import os; os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'desktop.settings'); import django; django.setup(); from django.utils import timezone; print('Django timezone:', timezone.get_current_timezone())"

echo "时区修改完成！"
echo "请访问 http://localhost:8888 查看文件浏览器中的时间显示是否正确。"

常见问题排查

1. DNS解析问题

如果出现 Name or service not known 错误：

# 检查DNS配置
docker inspect  | grep -A 5 -B 5 -i dns

# 确保容器有正确的DNS设置
--dns=100.100.2.136 --dns=8.8.8.8

2. 时区仍然不正确

检查所有配置文件中的时区设置：

grep -r -i "time_zone\|timezone" /data/server/hue-server/config/ | grep -v ".backup"

3. 文件浏览器时间显示不正确

检查代码修改是否正确：

docker exec  grep -n -A 2 -B 2 "mtime.*datetime" /usr/share/hue/apps/filebrowser/src/filebrowser/views.py

4. 容器无法启动

检查挂载路径是否正确：

# 确保配置文件路径存在
ls -la /data/server/hue-server/config/

# 检查挂载权限
ls -la /data/server/hue-server/config/hue.ini

验证成功标志

容器系统时间显示：Mon Sep 8 15:08:02 Asia 2025
Hue日志时间格式：[08/Sep/2025 15:08:02 +0800]
环境变量：TZ=Asia/Shanghai
Django时区：Asia/Shanghai
HDFS文件时间显示：正确的中国时间（如14:00-14:01）
HDFS连接正常，无DNS解析错误

注意事项

备份重要: 修改前务必备份原始配置文件和代码文件
DNS设置: 确保容器有正确的DNS配置，否则无法连接HDFS
配置文件: 需要修改两个配置文件：hue.ini 和 z-hue-overrides.ini
代码修改: 需要修改文件浏览器模块的时区处理代码
重启生效: 修改配置和代码后需要重启容器才能生效
权限检查: 确保挂载的配置文件有正确的读写权限
缓存清理: 修改Python代码后需要清除缓存

回滚方法

如果修改后出现问题，可以按以下步骤回滚：

# 1. 恢复配置文件
cp /data/server/hue-server/config/hue.ini.backup.* /data/server/hue-server/config/hue.ini
cp /data/server/hue-server/config/z-hue-overrides.ini.backup.* /data/server/hue-server/config/z-hue-overrides.ini

# 2. 恢复代码文件
docker exec  cp /usr/share/hue/apps/filebrowser/src/filebrowser/views.py.backup /usr/share/hue/apps/filebrowser/src/filebrowser/views.py

# 3. 重启容器
docker restart

HDFS均衡操作快速参考

Wed, 01 May 2024 11:00:00 +0800

快速判断是否需要均衡

# 计算当前均衡度（标准差）
hdfs dfsadmin -report | python3 -c "
import sys, re
used_percents = []
for line in sys.stdin:
    if 'DFS Used%:' in line:
        percent = float(re.search(r'(\d+\.?\d*)%', line).group(1))
        used_percents.append(percent)
if used_percents:
    avg = sum(used_percents) / len(used_percents)
    variance = sum((x - avg) ** 2 for x in used_percents) / len(used_percents)
    std_dev = variance ** 0.5
    print(f'标准差: {std_dev:.2f}%')
    if std_dev > 15:
        print('⚠️  需要立即均衡')
    elif std_dev > 10:
        print('⚠️  建议进行均衡')
    else:
        print('✅ 集群已均衡')
"

常用均衡命令

基本均衡

# 标准均衡（推荐）
nohup hdfs balancer -threshold 10 -policy datanode > /tmp/balancer.log 2>&1 &

# 严格均衡
nohup hdfs balancer -threshold 5 -policy datanode > /tmp/balancer.log 2>&1 &

# 宽松均衡
nohup hdfs balancer -threshold 15 -policy datanode > /tmp/balancer.log 2>&1 &

高级均衡

# 排除特定节点
nohup hdfs balancer -threshold 10 -exclude 192.168.1.100,192.168.1.101 > /tmp/balancer.log 2>&1 &

# 只均衡特定节点
nohup hdfs balancer -threshold 10 -include 192.168.1.102,192.168.1.103 > /tmp/balancer.log 2>&1 &

# 指定源节点
nohup hdfs balancer -threshold 10 -source 192.168.1.100,192.168.1.101 > /tmp/balancer.log 2>&1 &

参数说明

参数	用途	默认值	推荐值
`-threshold`	均衡阈值(%)	10	5-15
`-policy`	均衡策略	datanode	datanode
`-exclude`	排除节点	-	维护节点
`-include`	包含节点	-	特定节点
`-source`	源节点	-	高负载节点
`-idleiterations`	空闲迭代次数	5	3-5

监控命令

检查均衡状态

# 检查均衡进程
ps aux | grep balancer

# 查看均衡日志
tail -f /tmp/balancer.log

# 实时监控均衡进度
python3 /tmp/monitor_hdfs_balancer.py

停止均衡

# 查找并停止均衡进程
pkill -f "hdfs.*balancer"

# 或者通过PID停止
kill $(cat /tmp/balancer.pid)

性能优化

调整均衡带宽



  dfs.datanode.balance.bandwidthPerSec
  52428800

系统优化

# 网络优化
echo 'net.core.rmem_max = 134217728' >> /etc/sysctl.conf
echo 'net.core.wmem_max = 134217728' >> /etc/sysctl.conf
sysctl -p

# 磁盘优化
echo noop > /sys/block/sda/queue/scheduler

故障排除

常见问题

均衡进程无法启动
检查HDFS服务状态：hdfs dfsadmin -report
检查权限：whoami

查看日志：tail -f $HADOOP_LOG_DIR/hadoop-*-balancer-*.log

均衡速度过慢

检查网络：iperf3 -c
检查磁盘I/O：iostat -x 1 5

调整均衡带宽

均衡进程异常退出

检查系统资源：free -h, df -h
查看系统日志：dmesg | tail -50
重新启动均衡

最佳实践

时间选择：在业务低峰期进行均衡
参数设置：生产环境使用5-10%阈值
监控告警：设置自动化监控和告警
分批进行：大型集群可以分批均衡
数据验证：均衡后检查数据完整性

自动化脚本

一键均衡脚本

#!/bin/bash
# 检查均衡度并自动启动均衡

STD_DEV=$(hdfs dfsadmin -report | python3 -c "
import sys, re
used_percents = []
for line in sys.stdin:
    if 'DFS Used%:' in line:
        percent = float(re.search(r'(\d+\.?\d*)%', line).group(1))
        used_percents.append(percent)
if used_percents:
    avg = sum(used_percents) / len(used_percents)
    variance = sum((x - avg) ** 2 for x in used_percents) / len(used_percents)
    std_dev = variance ** 0.5
    print(f'{std_dev:.2f}')
else:
    print('0')
")

echo "当前均衡度: ${STD_DEV}%"

if (( $(echo "$STD_DEV > 10" | bc -l) )); then
    echo "启动均衡..."
    nohup hdfs balancer -threshold 10 > /tmp/balancer.log 2>&1 &
    echo "均衡进程已启动，PID: $!"
else
    echo "集群已均衡，无需操作"
fi

监控脚本

简化监控脚本

#!/bin/bash
# 简化版均衡监控

while true; do
    echo "=== $(date) ==="

    # 检查均衡进程
    if pgrep -f "hdfs.*balancer" > /dev/null; then
        echo "✅ 均衡进程正在运行"
    else
        echo "❌ 均衡进程未运行"
    fi

    # 显示各节点使用率
    echo "各节点使用率:"
    hdfs dfsadmin -report | grep -E "(Name:|DFS Used%:)" | \
        awk 'NR%2==1{name=$0} NR%2==0{print name " " $0}'

    echo "----------------------------------------"
    sleep 60
done

注意：本快速参考适用于日常运维，详细操作请参考完整版文档。

HDFS均衡操作完整指南

Wed, 01 May 2024 10:00:00 +0800

概述

HDFS均衡器（Balancer）是Hadoop分布式文件系统中的一个重要工具，用于重新分布数据块，确保集群中所有DataNode的存储使用率保持相对均衡。当集群中添加新节点或删除节点后，数据分布可能会变得不均匀，这时就需要使用均衡器来重新分布数据。

什么时候需要HDFS均衡

1. 集群扩容后

新增DataNode节点：新节点加入集群后，存储使用率为0%，而原有节点可能已经接近满载
添加存储设备：为现有DataNode添加新的磁盘后

2. 集群缩容后

移除DataNode节点：节点下线前需要将其数据迁移到其他节点
磁盘故障：某个磁盘故障后，需要重新分布数据

3. 数据倾斜

节点间使用率差异过大：标准差超过10-15%
热点数据：某些节点存储了过多的热点数据
写入模式不均：应用写入模式导致的数据分布不均

4. 性能优化

负载均衡：提高集群整体I/O性能
故障恢复：确保数据副本分布合理

判断标准

# 计算节点使用率标准差
# 标准差 > 10%：建议进行均衡
# 标准差 > 20%：强烈建议立即均衡
# 标准差 < 5%：认为已均衡

HDFS均衡原理

1. 均衡策略

DataNode策略：基于整个DataNode的使用率进行均衡
BlockPool策略：基于命名空间的使用率进行均衡（适用于Federation）

2. 均衡算法

识别源节点：使用率高于平均值的节点
识别目标节点：使用率低于平均值的节点
选择数据块：从源节点选择合适的数据块
数据迁移：通过三阶段复制进行数据迁移
验证完整性：确保数据迁移成功

3. 数据迁移过程

源节点 → 中间节点 → 目标节点

避免直接复制，减少网络压力
通过中间节点进行数据转发
确保数据完整性和一致性

均衡参数详解

1. 基本参数

`-threshold`

用途：设置均衡阈值，单位为百分比
默认值：10%
说明：只有当节点使用率差异超过此阈值时才开始均衡
推荐值：
生产环境：5-10%
测试环境：10-15%
紧急情况：20%

# 示例
hdfs balancer -threshold 5    # 5%阈值，更严格的均衡
hdfs balancer -threshold 15   # 15%阈值，更宽松的均衡

`-policy`

用途：指定均衡策略
可选值：
datanode：基于DataNode使用率（默认）
blockpool：基于BlockPool使用率
推荐：一般使用datanode策略

# 示例
hdfs balancer -policy datanode    # DataNode策略
hdfs balancer -policy blockpool   # BlockPool策略

2. 节点选择参数

`-exclude [-f | ]`

用途：排除指定的DataNode节点
使用场景：
节点维护期间
性能较差的节点
网络不稳定的节点

# 排除单个节点
hdfs balancer -exclude 192.168.1.100

# 排除多个节点
hdfs balancer -exclude 192.168.1.100,192.168.1.101

# 从文件读取排除列表
hdfs balancer -exclude -f /path/to/exclude_hosts.txt

`-include [-f | ]`

用途：只对指定的DataNode节点进行均衡
使用场景：
只均衡特定节点
测试环境
部分节点维护

# 只均衡指定节点
hdfs balancer -include 192.168.1.100,192.168.1.101

`-source [-f | ]`

用途：指定源节点（数据来源）
使用场景：
特定节点需要减少负载
节点即将下线

# 指定源节点
hdfs balancer -source 192.168.1.100,192.168.1.101

3. 性能控制参数

`-idleiterations`

用途：设置连续空闲迭代次数
默认值：5
说明：连续N次迭代没有数据移动时退出
推荐值：
生产环境：3-5
测试环境：1-2

# 示例
hdfs balancer -idleiterations 3  # 连续3次无移动则退出

`-runDuringUpgrade`

用途：在HDFS升级期间运行均衡器
默认值：false
说明：通常不建议在升级期间运行

4. 高级参数

`-blockpools`

用途：指定要均衡的BlockPool ID
适用场景：Federation环境

# 示例
hdfs balancer -blockpools BP-REPLACE_WITH_NEW_PASSWORD789-192.168.1.100-REPLACE_WITH_NEW_PASSWORD7890123

操作步骤

1. 环境检查

检查集群状态

# 检查HDFS状态
hdfs dfsadmin -report

# 检查NameNode状态
hdfs haadmin -getServiceState nn1

# 检查DataNode状态
hdfs dfsadmin -printTopology

检查磁盘空间

# 检查各节点磁盘使用情况
for node in $(hdfs dfsadmin -printTopology | grep -o '[0-9]\+\.[0-9]\+\.[0-9]\+\.[0-9]\+'); do
    echo "=== $node ==="
    ssh $node "df -h"
done

检查网络状况

# 检查节点间网络延迟
hdfs dfsadmin -printTopology | grep -o '[0-9]\+\.[0-9]\+\.[0-9]\+\.[0-9]\+' | while read node; do
    echo "Testing $node..."
    ping -c 3 $node
done

2. 均衡前准备

备份重要配置

# 备份HDFS配置
cp -r $HADOOP_CONF_DIR /backup/hdfs_conf_$(date +%Y%m%d)

# 记录当前状态
hdfs dfsadmin -report > /backup/hdfs_report_$(date +%Y%m%d_%H%M%S).txt

设置均衡参数

# 设置均衡带宽（可选）
# 在hdfs-site.xml中添加：
# 
#   dfs.datanode.balance.bandwidthPerSec
#   10485760  
#

3. 执行均衡

基本均衡命令

# 标准均衡命令
nohup hdfs balancer -threshold 10 -policy datanode > /tmp/hdfs_balancer.log 2>&1 &

# 获取进程ID
BALANCER_PID=$!

# 记录PID
echo $BALANCER_PID > /tmp/hdfs_balancer.pid

高级均衡命令

# 排除特定节点的均衡
nohup hdfs balancer -threshold 5 -policy datanode \
    -exclude 192.168.1.100,192.168.1.101 \
    -idleiterations 3 > /tmp/hdfs_balancer.log 2>&1 &

# 只对特定节点进行均衡
nohup hdfs balancer -threshold 10 -policy datanode \
    -include 192.168.1.102,192.168.1.103 > /tmp/hdfs_balancer.log 2>&1 &

4. 监控均衡进度

实时监控脚本

#!/usr/bin/env python3
# monitor_hdfs_balancer.py
import subprocess
import time
import re
from datetime import datetime

def get_hdfs_report():
    try:
        result = subprocess.run(['hdfs', 'dfsadmin', '-report'],
                              stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                              universal_newlines=True, check=True)
        return result.stdout
    except subprocess.CalledProcessError as e:
        print("获取HDFS报告失败: {}".format(e))
        return None

def parse_datanode_info(report):
    datanodes = []
    lines = report.split('\n')

    current_node = {}
    in_datanode_section = False

    for line in lines:
        line = line.strip()

        if line.startswith('Name:'):
            if current_node:
                datanodes.append(current_node)
            current_node = {'name': line.split(':', 1)[1].strip()}
            in_datanode_section = True

        elif in_datanode_section and line.startswith('DFS Used%:'):
            current_node['used_percent'] = float(line.split(':')[1].strip().replace('%', ''))

        elif in_datanode_section and line.startswith('DFS Remaining%:'):
            current_node['remaining_percent'] = float(line.split(':')[1].strip().replace('%', ''))

    if current_node:
        datanodes.append(current_node)

    return datanodes

def calculate_balance_metrics(datanodes):
    if not datanodes:
        return None

    used_percents = [node.get('used_percent', 0) for node in datanodes]
    avg_used_percent = sum(used_percents) / len(used_percents)

    # 计算标准差
    variance = sum((x - avg_used_percent) ** 2 for x in used_percents) / len(used_percents)
    std_dev = variance ** 0.5

    # 找出最高和最低使用率节点
    max_used_node = max(datanodes, key=lambda x: x.get('used_percent', 0))
    min_used_node = min(datanodes, key=lambda x: x.get('used_percent', 0))

    return {
        'avg_used_percent': avg_used_percent,
        'std_dev': std_dev,
        'max_used_node': max_used_node,
        'min_used_node': min_used_node,
        'datanodes': datanodes
    }

def monitor_balancer():
    print("HDFS均衡监控开始...")
    print("=" * 80)

    start_time = datetime.now()

    try:
        while True:
            current_time = datetime.now()
            elapsed = current_time - start_time

            report = get_hdfs_report()
            if not report:
                print("[{}] 无法获取HDFS报告".format(current_time.strftime('%H:%M:%S')))
                time.sleep(30)
                continue

            datanodes = parse_datanode_info(report)
            if not datanodes:
                print("[{}] 无法解析datanode信息".format(current_time.strftime('%H:%M:%S')))
                time.sleep(30)
                continue

            metrics = calculate_balance_metrics(datanodes)
            if not metrics:
                continue

            # 显示当前状态
            print("\n[{}] 运行时间: {}".format(current_time.strftime('%H:%M:%S'), elapsed))
            print("平均使用率: {:.2f}%".format(metrics['avg_used_percent']))
            print("均衡度(标准差): {:.2f}%".format(metrics['std_dev']))
            print("最高使用率节点: {} ({:.2f}%)".format(
                metrics['max_used_node'].get('name', 'N/A'),
                metrics['max_used_node'].get('used_percent', 0)))
            print("最低使用率节点: {} ({:.2f}%)".format(
                metrics['min_used_node'].get('name', 'N/A'),
                metrics['min_used_node'].get('used_percent', 0)))

            print("\n各节点使用率:")
            for node in sorted(metrics['datanodes'], key=lambda x: x.get('used_percent', 0), reverse=True):
                name = node.get('name', 'N/A')
                used_pct = node.get('used_percent', 0)
                remaining_pct = node.get('remaining_percent', 0)
                print("  {}: {:.2f}% (剩余: {:.2f}%)".format(name, used_pct, remaining_pct))

            # 检查是否达到均衡
            if metrics['std_dev'] < 5.0:
                print("\n🎉 均衡完成! 标准差: {:.2f}%".format(metrics['std_dev']))
                break

            print("=" * 80)
            time.sleep(60)

    except KeyboardInterrupt:
        print("\n\n监控已停止")
    except Exception as e:
        print("\n监控出错: {}".format(e))

if __name__ == "__main__":
    monitor_balancer()

手动检查命令

# 检查均衡进程状态
ps aux | grep balancer

# 查看均衡日志
tail -f /tmp/hdfs_balancer.log

# 检查集群状态
hdfs dfsadmin -report | grep -A 20 "Live datanodes"

# 计算当前均衡度
python3 -c "
import subprocess
import re

result = subprocess.run(['hdfs', 'dfsadmin', '-report'],
                       stdout=subprocess.PIPE, universal_newlines=True)
report = result.stdout

used_percents = []
for line in report.split('\n'):
    if 'DFS Used%:' in line:
        percent = float(re.search(r'(\d+\.?\d*)%', line).group(1))
        used_percents.append(percent)

if used_percents:
    avg = sum(used_percents) / len(used_percents)
    variance = sum((x - avg) ** 2 for x in used_percents) / len(used_percents)
    std_dev = variance ** 0.5
    print(f'平均使用率: {avg:.2f}%')
    print(f'标准差: {std_dev:.2f}%')
    print(f'最高使用率: {max(used_percents):.2f}%')
    print(f'最低使用率: {min(used_percents):.2f}%')
"

监控和管理

1. 均衡状态监控

实时监控

# 启动监控脚本
python3 /tmp/monitor_hdfs_balancer.py

# 后台运行监控
nohup python3 /tmp/monitor_hdfs_balancer.py > /tmp/balancer_monitor.log 2>&1 &

定期检查

# 创建定期检查脚本
cat > /tmp/check_balance.sh << 'EOF'
#!/bin/bash
LOG_FILE="/tmp/balance_check.log"
DATE=$(date '+%Y-%m-%d %H:%M:%S')

echo "[$DATE] 开始检查HDFS均衡状态" >> $LOG_FILE

# 检查均衡进程
if pgrep -f "hdfs.*balancer" > /dev/null; then
    echo "[$DATE] 均衡进程正在运行" >> $LOG_FILE
else
    echo "[$DATE] 警告: 均衡进程未运行" >> $LOG_FILE
fi

# 检查集群状态
hdfs dfsadmin -report | grep -A 20 "Live datanodes" >> $LOG_FILE

echo "[$DATE] 检查完成" >> $LOG_FILE
echo "----------------------------------------" >> $LOG_FILE
EOF

chmod +x /tmp/check_balance.sh

# 添加到crontab，每10分钟检查一次
echo "*/10 * * * * /tmp/check_balance.sh" | crontab -

2. 均衡进程管理

启动均衡

# 基本启动
nohup hdfs balancer -threshold 10 > /tmp/balancer.log 2>&1 &

# 高级启动
nohup hdfs balancer -threshold 5 -policy datanode \
    -exclude 192.168.1.100 -idleiterations 3 \
    > /tmp/balancer.log 2>&1 &

停止均衡

# 查找均衡进程
BALANCER_PID=$(pgrep -f "hdfs.*balancer")

# 停止均衡进程
if [ ! -z "$BALANCER_PID" ]; then
    kill $BALANCER_PID
    echo "均衡进程 $BALANCER_PID 已停止"
else
    echo "未找到运行中的均衡进程"
fi

重启均衡

# 停止现有均衡
pkill -f "hdfs.*balancer"

# 等待进程完全停止
sleep 5

# 重新启动均衡
nohup hdfs balancer -threshold 10 > /tmp/balancer.log 2>&1 &

3. 日志分析

均衡日志分析

# 统计移动的数据块数量
grep "Successfully moved" /tmp/hdfs_balancer.log | wc -l

# 统计移动的数据量
grep "Successfully moved" /tmp/hdfs_balancer.log | \
    awk '{sum += $NF} END {print "总移动数据量: " sum/1024/1024/1024 " GB"}'

# 分析移动速度
grep "Successfully moved" /tmp/hdfs_balancer.log | \
    awk '{print $1, $2, $NF}' | \
    tail -100 | \
    awk 'BEGIN{prev_time=""} {
        if(prev_time != "") {
            split($1" "$2, time_arr, ":")
            current_sec = time_arr[1]*3600 + time_arr[2]*60 + time_arr[3]
            split(prev_time, prev_arr, ":")
            prev_sec = prev_arr[1]*3600 + prev_arr[2]*60 + prev_arr[3]
            if(current_sec > prev_sec) {
                speed = $3 / (current_sec - prev_sec)
                print "移动速度: " speed/1024/1024 " MB/s"
            }
        }
        prev_time = $1" "$2
    }'

故障排除

1. 常见问题

均衡进程无法启动

症状：执行均衡命令后立即退出 可能原因：

HDFS服务未正常运行
权限不足
配置错误

解决方法：

# 检查HDFS服务状态
hdfs dfsadmin -report

# 检查权限
whoami
groups

# 检查配置
hdfs getconf -confKey dfs.namenode.rpc-address

# 查看错误日志
tail -f $HADOOP_LOG_DIR/hadoop-*-balancer-*.log

均衡速度过慢

症状：数据移动速度很慢，均衡时间过长 可能原因：

网络带宽限制
磁盘I/O性能差
均衡带宽设置过低

解决方法：

# 检查网络带宽
iperf3 -s &  # 在源节点启动服务器
iperf3 -c  -t 60  # 在目标节点测试

# 检查磁盘I/O
iostat -x 1 5

# 调整均衡带宽
# 在hdfs-site.xml中设置：
# 
#   dfs.datanode.balance.bandwidthPerSec
#   52428800  
# 

# 重启DataNode服务
sudo systemctl restart hadoop-datanode

均衡进程异常退出

症状：均衡进程运行一段时间后自动退出 可能原因：

内存不足
网络中断
磁盘空间不足

解决方法：

# 检查系统资源
free -h
df -h
dmesg | tail -50

# 检查均衡日志
tail -100 /tmp/hdfs_balancer.log

# 检查HDFS日志
tail -100 $HADOOP_LOG_DIR/hadoop-*-balancer-*.log

# 重新启动均衡
nohup hdfs balancer -threshold 10 > /tmp/balancer_retry.log 2>&1 &

2. 性能问题

网络瓶颈

诊断：

# 检查网络使用情况
iftop -i eth0

# 检查网络延迟
ping -c 10 

# 检查网络丢包
mtr -r -c 10

优化：

# 调整网络参数
echo 'net.core.rmem_max = 134217728' >> /etc/sysctl.conf
echo 'net.core.wmem_max = 134217728' >> /etc/sysctl.conf
sysctl -p

磁盘I/O瓶颈

诊断：

# 检查磁盘使用情况
iostat -x 1 10

# 检查磁盘队列
iostat -x 1 10 | grep -E "(Device|sd)"

# 检查磁盘错误
dmesg | grep -i error

优化：

# 调整I/O调度器
echo noop > /sys/block/sda/queue/scheduler

# 调整I/O参数
echo 1024 > /sys/block/sda/queue/nr_requests

3. 数据完整性检查

均衡后验证

# 检查数据块完整性
hdfs fsck / -files -blocks -locations

# 检查副本数量
hdfs fsck / -files -blocks | grep -E "(Missing|Under-replicated)"

# 检查损坏的数据块
hdfs fsck / -files -blocks | grep -i corrupt

数据恢复

# 修复损坏的数据块
hdfs fsck / -delete

# 重新平衡副本
hdfs balancer -threshold 1

最佳实践

1. 均衡策略

时间选择

业务低峰期：选择业务访问量最低的时间段
维护窗口：在计划维护期间进行
分批进行：对于大型集群，可以分批进行均衡

参数设置

# 生产环境推荐参数
hdfs balancer -threshold 5 -policy datanode -idleiterations 3

# 测试环境参数
hdfs balancer -threshold 10 -policy datanode -idleiterations 1

# 紧急情况参数
hdfs balancer -threshold 20 -policy datanode

2. 监控策略

实时监控

# 创建监控脚本
cat > /tmp/balance_monitor.sh << 'EOF'
#!/bin/bash

# 检查均衡进程
if ! pgrep -f "hdfs.*balancer" > /dev/null; then
    echo "$(date): 均衡进程未运行，尝试重启" >> /tmp/balance_monitor.log
    nohup hdfs balancer -threshold 10 > /tmp/balancer.log 2>&1 &
fi

# 检查集群状态
REPORT=$(hdfs dfsadmin -report 2>/dev/null)
if [ $? -ne 0 ]; then
    echo "$(date): HDFS服务异常" >> /tmp/balance_monitor.log
    exit 1
fi

# 计算均衡度
STD_DEV=$(echo "$REPORT" | python3 -c "
import sys
import re

used_percents = []
for line in sys.stdin:
    if 'DFS Used%:' in line:
        percent = float(re.search(r'(\d+\.?\d*)%', line).group(1))
        used_percents.append(percent)

if used_percents:
    avg = sum(used_percents) / len(used_percents)
    variance = sum((x - avg) ** 2 for x in used_percents) / len(used_percents)
    std_dev = variance ** 0.5
    print(f'{std_dev:.2f}')
else:
    print('0')
")

echo "$(date): 当前均衡度: ${STD_DEV}%" >> /tmp/balance_monitor.log

# 如果均衡度过高，启动均衡
if (( $(echo "$STD_DEV > 15" | bc -l) )); then
    echo "$(date): 均衡度过高，启动均衡" >> /tmp/balance_monitor.log
    nohup hdfs balancer -threshold 10 > /tmp/balancer.log 2>&1 &
fi
EOF

chmod +x /tmp/balance_monitor.sh

# 添加到crontab，每30分钟检查一次
echo "*/30 * * * * /tmp/balance_monitor.sh" | crontab -

3. 自动化脚本

完整均衡脚本

cat > /tmp/auto_balance.sh << 'EOF'
#!/bin/bash

# 配置参数
THRESHOLD=10
LOG_FILE="/tmp/auto_balance.log"
BALANCE_LOG="/tmp/hdfs_balancer.log"
MAX_RUNTIME=7200  # 最大运行时间（秒）
CHECK_INTERVAL=300  # 检查间隔（秒）

# 日志函数
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a $LOG_FILE
}

# 检查HDFS状态
check_hdfs_status() {
    if ! hdfs dfsadmin -report > /dev/null 2>&1; then
        log "错误: HDFS服务不可用"
        exit 1
    fi
    log "HDFS服务状态正常"
}

# 计算均衡度
calculate_balance_degree() {
    local report=$(hdfs dfsadmin -report 2>/dev/null)
    if [ $? -ne 0 ]; then
        echo "0"
        return
    fi

    echo "$report" | python3 -c "
import sys
import re

used_percents = []
for line in sys.stdin:
    if 'DFS Used%:' in line:
        percent = float(re.search(r'(\d+\.?\d*)%', line).group(1))
        used_percents.append(percent)

if used_percents:
    avg = sum(used_percents) / len(used_percents)
    variance = sum((x - avg) ** 2 for x in used_percents) / len(used_percents)
    std_dev = variance ** 0.5
    print(f'{std_dev:.2f}')
else:
    print('0')
"
}

# 启动均衡
start_balancer() {
    log "启动HDFS均衡，阈值: ${THRESHOLD}%"
    nohup hdfs balancer -threshold $THRESHOLD -policy datanode > $BALANCE_LOG 2>&1 &
    BALANCER_PID=$!
    echo $BALANCER_PID > /tmp/balancer.pid
    log "均衡进程已启动，PID: $BALANCER_PID"
}

# 停止均衡
stop_balancer() {
    if [ -f /tmp/balancer.pid ]; then
        local pid=$(cat /tmp/balancer.pid)
        if kill -0 $pid 2>/dev/null; then
            kill $pid
            log "均衡进程已停止，PID: $pid"
        fi
        rm -f /tmp/balancer.pid
    fi
}

# 检查均衡进度
check_balance_progress() {
    local current_degree=$(calculate_balance_degree)
    log "当前均衡度: ${current_degree}%"

    if (( $(echo "$current_degree < 5" | bc -l) )); then
        log "均衡完成！"
        return 0
    else
        return 1
    fi
}

# 主函数
main() {
    log "开始自动均衡流程"

    # 检查HDFS状态
    check_hdfs_status

    # 计算初始均衡度
    initial_degree=$(calculate_balance_degree)
    log "初始均衡度: ${initial_degree}%"

    # 如果已经均衡，退出
    if (( $(echo "$initial_degree < $THRESHOLD" | bc -l) )); then
        log "集群已经均衡，无需执行均衡操作"
        exit 0
    fi

    # 启动均衡
    start_balancer

    # 监控均衡进度
    start_time=$(date +%s)
    while true; do
        current_time=$(date +%s)
        elapsed=$((current_time - start_time))

        # 检查是否超时
        if [ $elapsed -gt $MAX_RUNTIME ]; then
            log "均衡超时，停止均衡进程"
            stop_balancer
            exit 1
        fi

        # 检查均衡进程是否还在运行
        if [ -f /tmp/balancer.pid ]; then
            local pid=$(cat /tmp/balancer.pid)
            if ! kill -0 $pid 2>/dev/null; then
                log "均衡进程异常退出"
                break
            fi
        else
            log "均衡进程PID文件不存在"
            break
        fi

        # 检查均衡进度
        if check_balance_progress; then
            stop_balancer
            log "均衡成功完成"
            exit 0
        fi

        # 等待下次检查
        sleep $CHECK_INTERVAL
    done

    # 清理
    stop_balancer
    log "均衡流程结束"
}

# 信号处理
trap 'log "收到中断信号，停止均衡"; stop_balancer; exit 1' INT TERM

# 执行主函数
main "$@"
EOF

chmod +x /tmp/auto_balance.sh

性能优化建议

1. 系统级优化

网络优化

# 调整网络缓冲区
echo 'net.core.rmem_max = 134217728' >> /etc/sysctl.conf
echo 'net.core.wmem_max = 134217728' >> /etc/sysctl.conf
echo 'net.core.rmem_default = 65536' >> /etc/sysctl.conf
echo 'net.core.wmem_default = 65536' >> /etc/sysctl.conf
sysctl -p

磁盘优化

# 调整I/O调度器
echo noop > /sys/block/sda/queue/scheduler

# 调整I/O参数
echo 1024 > /sys/block/sda/queue/nr_requests
echo 0 > /sys/block/sda/queue/add_random

2. HDFS配置优化

均衡带宽设置



  dfs.datanode.balance.bandwidthPerSec
  52428800

复制参数优化



  dfs.replication
  3



  dfs.namenode.replication.work.multiplier.per.iteration
  2

3. 监控和告警

设置告警

# 创建告警脚本
cat > /tmp/balance_alert.sh << 'EOF'
#!/bin/bash

# 配置参数
ALERT_THRESHOLD=20
EMAIL_LIST="admin@company.com"
LOG_FILE="/tmp/balance_alert.log"

# 计算均衡度
STD_DEV=$(hdfs dfsadmin -report | python3 -c "
import sys
import re

used_percents = []
for line in sys.stdin:
    if 'DFS Used%:' in line:
        percent = float(re.search(r'(\d+\.?\d*)%', line).group(1))
        used_percents.append(percent)

if used_percents:
    avg = sum(used_percents) / len(used_percents)
    variance = sum((x - avg) ** 2 for x in used_percents) / len(used_percents)
    std_dev = variance ** 0.5
    print(f'{std_dev:.2f}')
else:
    print('0')
")

# 检查是否需要告警
if (( $(echo "$STD_DEV > $ALERT_THRESHOLD" | bc -l) )); then
    echo "$(date): 警告: HDFS均衡度过高 (${STD_DEV}%)" >> $LOG_FILE

    # 发送邮件告警
    echo "HDFS集群均衡度过高: ${STD_DEV}%" | \
        mail -s "HDFS均衡告警" $EMAIL_LIST

    # 自动启动均衡
    if ! pgrep -f "hdfs.*balancer" > /dev/null; then
        nohup hdfs balancer -threshold 10 > /tmp/balancer.log 2>&1 &
        echo "$(date): 已自动启动均衡进程" >> $LOG_FILE
    fi
fi
EOF

chmod +x /tmp/balance_alert.sh

# 添加到crontab，每小时检查一次
echo "0 * * * * /tmp/balance_alert.sh" | crontab -

总结

HDFS均衡是维护集群健康状态的重要操作。通过合理使用均衡参数、建立完善的监控体系、遵循最佳实践，可以确保集群始终保持良好的数据分布和性能表现。

关键要点：

及时均衡：在节点使用率差异超过10%时及时进行均衡
合理参数：根据集群规模和环境选择合适的均衡参数
持续监控：建立自动化监控和告警机制
性能优化：从系统、网络、存储等多个层面进行优化
安全操作：在业务低峰期进行均衡，确保数据安全

通过遵循本指南，您可以有效地管理和维护HDFS集群的数据均衡，确保集群的高可用性和高性能。