Hadoopエコシステム実践ガイド：HDFS、MapReduce、YARNの核心整理

はじめに
1. Hadoopエコシステム概要
- 核心コンポーネント
- 2026年のHadoopの位置づけ
2. HDFSアーキテクチャ
3. MapReduceの原理と実行フロー
4. YARNリソース管理
5. クラスタインストール
- Pseudo-Distributedモード（開発/テスト用）
- Fully Distributedモード（本番環境）
6. HDFS基本コマンド
- ファイルシステム操作
- 管理コマンド
7. パフォーマンスチューニング
8. Spark vs MapReduce 比較
9. モニタリング
10. トラブルシューティング
11. 運用チェックリスト
まとめ

はじめに

Hadoopは2006年の登場以来、ビッグデータ処理の標準として定着しました。Spark、Flinkなどの次世代フレームワークが登場しましたが、HDFSとYARNは依然としてデータインフラの核心基盤です。2026年現在も多くの企業がHadoopベースのデータレイクを運用しており、クラウド環境でもHDFS互換ストレージ（S3、ADLS）が活用されています。

この記事では、Hadoopの核心コンポーネントをアーキテクチャレベルで理解し、実践運用に必要な設定とチューニングポイントを整理します。

1. Hadoopエコシステム概要

核心コンポーネント

┌─────────────────────────────────────────────────────────────┐
│                    Hadoop Ecosystem                         │
├─────────────────────────────────────────────────────────────┤
│  [Hive]  [Pig]  [Spark]  [HBase]  [Presto]  [Flink]       │
│              Application / Processing Layer                 │
├─────────────────────────────────────────────────────────────┤
│                      YARN                                   │
│              Resource Management Layer                      │
├─────────────────────────────────────────────────────────────┤
│                      HDFS                                   │
│              Distributed Storage Layer                      │
└─────────────────────────────────────────────────────────────┘

コンポーネント	役割	バージョン（2026年基準）
HDFS	分散ファイルシステム	Hadoop 3.4.x
YARN	リソース管理とスケジューリング	Hadoop 3.4.x
MapReduce	バッチ処理フレームワーク	Hadoop 3.4.x
Hive	SQL-on-Hadoop	Hive 4.x
HBase	NoSQLデータベース	HBase 2.6.x
Spark	統合分析エンジン	Spark 3.5.x / 4.x
ZooKeeper	分散コーディネーション	ZooKeeper 3.9.x

2026年のHadoopの位置づけ

HDFS：依然として大規模データレイクの核心ストレージ。S3/ADLSと共存
YARN：Spark、Flinkなど多様なフレームワークのリソース管理者として活用
MapReduce：新規開発での使用頻度は減少したが、レガシーシステムのメンテナンスには依然として必要
トレンド：Hadoop on Kubernetes、Ozone（次世代ストレージ）、Iceberg/Delta Lakeとの統合

2. HDFSアーキテクチャ

核心コンポーネント

                    ┌──────────────┐
                    │  NameNode    │
                    │  (Master)    │
                    │  - メタデータ │
                    │  - ブロック位置│
                    └──────┬───────┘
                           │
              ┌────────────┼────────────┐
              │            │            │
      ┌───────▼──────┐ ┌──▼──────────┐ ┌▼─────────────┐
      │  DataNode 1  │ │  DataNode 2 │ │  DataNode 3  │
      │  Block A     │ │  Block A    │ │  Block B     │
      │  Block C     │ │  Block B    │ │  Block A     │
      └──────────────┘ └─────────────┘ └──────────────┘
                    Replication Factor = 3

NameNode

NameNodeはHDFSのメタデータを管理するマスターノードです。

# NameNodeが管理する情報
# 1. ファイル/ディレクトリツリー構造（Namespace）
# 2. 各ファイルのブロックリスト
# 3. 各ブロックがどのDataNodeにあるか（Block Mapping）
# 4. ファイル権限、更新時刻など

# NameNodeメモリ使用量の推定
# ファイル1つ ≈ 150バイト
# ブロック1つ ≈ 150バイト
# 1億ファイル → 約30GBヒープメモリが必要

DataNode

# DataNodeの核心動作
# 1. ブロックの保存（デフォルト128MB）
# 2. クライアントへのブロック読み書きサービス
# 3. NameNodeへのハートビート送信（3秒間隔）
# 4. ブロックレポートの送信（6時間間隔）

HDFS HA（高可用性）

<!-- hdfs-site.xml - HA設定 -->
<configuration>
    <property>
        <name>dfs.nameservices</name>
        <value>mycluster</value>
    </property>
    <property>
        <name>dfs.ha.namenodes.mycluster</name>
        <value>nn1,nn2</value>
    </property>
    <property>
        <name>dfs.namenode.rpc-address.mycluster.nn1</name>
        <value>namenode1:8020</value>
    </property>
    <property>
        <name>dfs.namenode.rpc-address.mycluster.nn2</name>
        <value>namenode2:8020</value>
    </property>

    <!-- JournalNode設定（最低3つ） -->
    <property>
        <name>dfs.namenode.shared.edits.dir</name>
        <value>qjournal://jn1:8485;jn2:8485;jn3:8485/mycluster</value>
    </property>

    <!-- 自動フェイルオーバー -->
    <property>
        <name>dfs.ha.automatic-failover.enabled</name>
        <value>true</value>
    </property>
    <property>
        <name>dfs.ha.fencing.methods</name>
        <value>sshfence</value>
    </property>
</configuration>

ブロックレプリケーション戦略

# デフォルトのRack-Awareレプリケーション戦略（Replication Factor = 3）
#
# 1番目のレプリカ：クライアントと同じノード（または同じラック）
# 2番目のレプリカ：別のラックのノード
# 3番目のレプリカ：2番目と同じラックの別のノード
#
# ┌──────── Rack 1 ────────┐  ┌──────── Rack 2 ────────┐
# │ [DataNode1: Block A]   │  │ [DataNode3: Block A]   │
# │ [DataNode2]            │  │ [DataNode4: Block A]   │
# └────────────────────────┘  └────────────────────────┘

3. MapReduceの原理と実行フロー

MapReduceプログラミングモデル

Input → Split → Map → Shuffle & Sort → Reduce → Output

[ファイル分割]
  Split 1 → Mapper 1 → (key, value) pairs ─┐
  Split 2 → Mapper 2 → (key, value) pairs ──┤── Shuffle & Sort
  Split 3 → Mapper 3 → (key, value) pairs ─┘     │
                                                   ├→ Reducer 1 → Output Part 1
                                                   └→ Reducer 2 → Output Part 2

WordCountの例（Java）

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.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;
import java.util.StringTokenizer;

public class WordCount {

    // Mapper：各行を単語に分割して（単語, 1）を出力
    public static class TokenizerMapper
            extends Mapper<Object, Text, Text, IntWritable> {

        private final static IntWritable one = new IntWritable(1);
        private Text word = new Text();

        public void map(Object key, Text value, Context context)
                throws IOException, InterruptedException {
            StringTokenizer itr = new StringTokenizer(value.toString());
            while (itr.hasMoreTokens()) {
                word.set(itr.nextToken().toLowerCase());
                context.write(word, one);
            }
        }
    }

    // Reducer：同じキーの値を合計
    public static class IntSumReducer
            extends Reducer<Text, IntWritable, Text, IntWritable> {

        private IntWritable result = new IntWritable();

        public void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            result.set(sum);
            context.write(key, result);
        }
    }

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf, "word count");
        job.setJarByClass(WordCount.class);
        job.setMapperClass(TokenizerMapper.class);
        job.setCombinerClass(IntSumReducer.class);  // ローカル集計でネットワークトラフィックを削減
        job.setReducerClass(IntSumReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputFormat.addInputPath(job, new Path(args[0]));
        FileOutputFormat.setOutputPath(job, new Path(args[1]));
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

ジョブ実行フロー

1. クライアントがジョブを送信
   └→ JAR、設定、InputSplit情報をHDFSにアップロード

2. ResourceManagerがApplicationMasterコンテナを割り当て
   └→ NodeManagerでAMを開始

3. ApplicationMasterがInputSplit数に応じてMapタスクをリクエスト
   └→ ResourceManagerがコンテナを割り当て

4. Mapタスクの実行
   └→ InputSplitを読み込み → map()を呼び出し → 中間結果をローカルディスクに保存

5. Shuffle & Sort
   └→ Map出力をパーティション → Reducerに転送 → キーごとにソート

6. Reduceタスクの実行
   └→ reduce()を呼び出し → 最終結果をHDFSに保存

7. ApplicationMasterがジョブの完了をResourceManagerに通知

4. YARNリソース管理

YARNアーキテクチャ

┌─────────────────────────────────────────────────────┐
│                  ResourceManager                     │
│  ┌──────────────┐  ┌────────────────────────┐       │
│  │  Scheduler   │  │  ApplicationManager    │       │
│  │  (リソース割当)│  │  (アプリ管理)          │       │
│  └──────────────┘  └────────────────────────┘       │
└──────────────────────┬──────────────────────────────┘
                       │
        ┌──────────────┼──────────────┐
        │              │              │
┌───────▼──────┐ ┌─────▼────────┐ ┌──▼────────────┐
│ NodeManager 1│ │ NodeManager 2│ │ NodeManager 3 │
│ ┌──────────┐ │ │ ┌──────────┐ │ │ ┌──────────┐  │
│ │Container │ │ │ │Container │ │ │ │Container │  │
│ │(AM)      │ │ │ │(Map Task)│ │ │ │(Reduce)  │  │
│ └──────────┘ │ │ └──────────┘ │ │ └──────────┘  │
│ ┌──────────┐ │ │ ┌──────────┐ │ │               │
│ │Container │ │ │ │Container │ │ │               │
│ │(Map Task)│ │ │ │(Map Task)│ │ │               │
│ └──────────┘ │ │ └──────────┘ │ │               │
└──────────────┘ └──────────────┘ └───────────────┘

YARNスケジューラ設定

<!-- yarn-site.xml -->
<configuration>
    <!-- スケジューラの種類：Capacity、Fair、FIFO -->
    <property>
        <name>yarn.resourcemanager.scheduler.class</name>
        <value>org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler</value>
    </property>

    <!-- NodeManagerリソース設定 -->
    <property>
        <name>yarn.nodemanager.resource.memory-mb</name>
        <value>65536</value>  <!-- 64GB -->
    </property>
    <property>
        <name>yarn.nodemanager.resource.cpu-vcores</name>
        <value>16</value>
    </property>

    <!-- コンテナの最小/最大メモリ -->
    <property>
        <name>yarn.scheduler.minimum-allocation-mb</name>
        <value>1024</value>
    </property>
    <property>
        <name>yarn.scheduler.maximum-allocation-mb</name>
        <value>32768</value>
    </property>

    <!-- コンテナの最小/最大vCores -->
    <property>
        <name>yarn.scheduler.minimum-allocation-vcores</name>
        <value>1</value>
    </property>
    <property>
        <name>yarn.scheduler.maximum-allocation-vcores</name>
        <value>8</value>
    </property>
</configuration>

Capacity Schedulerキュー設定

<!-- capacity-scheduler.xml -->
<configuration>
    <property>
        <name>yarn.scheduler.capacity.root.queues</name>
        <value>default,production,development</value>
    </property>

    <!-- キューごとの容量（合計100%） -->
    <property>
        <name>yarn.scheduler.capacity.root.default.capacity</name>
        <value>20</value>
    </property>
    <property>
        <name>yarn.scheduler.capacity.root.production.capacity</name>
        <value>60</value>
    </property>
    <property>
        <name>yarn.scheduler.capacity.root.development.capacity</name>
        <value>20</value>
    </property>

    <!-- 最大容量（弾力性） -->
    <property>
        <name>yarn.scheduler.capacity.root.production.maximum-capacity</name>
        <value>80</value>
    </property>

    <!-- キューごとのユーザー制限 -->
    <property>
        <name>yarn.scheduler.capacity.root.production.user-limit-factor</name>
        <value>2</value>
    </property>
</configuration>

5. クラスタインストール

Pseudo-Distributedモード（開発/テスト用）

# 1. Javaのインストール
sudo apt install -y openjdk-11-jdk
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64

# 2. Hadoopのダウンロード
wget https://dlcdn.apache.org/hadoop/common/hadoop-3.4.1/hadoop-3.4.1.tar.gz
tar -xzf hadoop-3.4.1.tar.gz
sudo mv hadoop-3.4.1 /opt/hadoop
export HADOOP_HOME=/opt/hadoop
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin

# 3. SSH鍵の設定（localhost）
ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa
cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

<!-- core-site.xml -->
<configuration>
    <property>
        <name>fs.defaultFS</name>
        <value>hdfs://localhost:9000</value>
    </property>
    <property>
        <name>hadoop.tmp.dir</name>
        <value>/opt/hadoop/data/tmp</value>
    </property>
</configuration>

<!-- hdfs-site.xml -->
<configuration>
    <property>
        <name>dfs.replication</name>
        <value>1</value>  <!-- Pseudo-distributedモードでは1 -->
    </property>
    <property>
        <name>dfs.namenode.name.dir</name>
        <value>/opt/hadoop/data/namenode</value>
    </property>
    <property>
        <name>dfs.datanode.data.dir</name>
        <value>/opt/hadoop/data/datanode</value>
    </property>
</configuration>

# 4. NameNodeのフォーマットと起動
hdfs namenode -format
start-dfs.sh
start-yarn.sh

# 5. 確認
hdfs dfs -mkdir /user
hdfs dfs -mkdir /user/$USER
jps  # NameNode、DataNode、ResourceManager、NodeManagerを確認

Fully Distributedモード（本番環境）

# workersファイルの設定（/opt/hadoop/etc/hadoop/workers）
datanode1
datanode2
datanode3
datanode4
datanode5

<!-- core-site.xml（HAモード） -->
<configuration>
    <property>
        <name>fs.defaultFS</name>
        <value>hdfs://mycluster</value>
    </property>
    <property>
        <name>ha.zookeeper.quorum</name>
        <value>zk1:2181,zk2:2181,zk3:2181</value>
    </property>
</configuration>

6. HDFS基本コマンド

ファイルシステム操作

# ファイル/ディレクトリの一覧
hdfs dfs -ls /user/hadoop/
hdfs dfs -ls -R /user/hadoop/   # 再帰的な一覧

# ファイルのアップロード
hdfs dfs -put localfile.txt /user/hadoop/
hdfs dfs -copyFromLocal data.csv /user/hadoop/input/
hdfs dfs -moveFromLocal temp.log /user/hadoop/logs/

# ファイルのダウンロード
hdfs dfs -get /user/hadoop/output/part-r-00000 ./result.txt
hdfs dfs -copyToLocal /user/hadoop/data.csv ./

# ファイル内容の確認
hdfs dfs -cat /user/hadoop/input/data.csv
hdfs dfs -head /user/hadoop/input/data.csv   # 先頭1KB
hdfs dfs -tail /user/hadoop/input/data.csv   # 末尾1KB
hdfs dfs -text /user/hadoop/output/part-r-00000  # 圧縮ファイルも読み取り

# ディレクトリの作成/削除
hdfs dfs -mkdir -p /user/hadoop/input/2026/03
hdfs dfs -rm /user/hadoop/temp.txt
hdfs dfs -rm -r /user/hadoop/output/      # ディレクトリ削除
hdfs dfs -rm -skipTrash /user/hadoop/old/  # ゴミ箱をスキップ

# 権限管理
hdfs dfs -chmod 755 /user/hadoop/scripts/
hdfs dfs -chown hadoop:hadoop /user/hadoop/
hdfs dfs -chgrp analytics /data/shared/

# ディスク使用量
hdfs dfs -du -h /user/hadoop/        # ディレクトリごとの使用量
hdfs dfs -df -h                       # 全体の容量
hdfs dfs -count -h /user/hadoop/      # ファイル/ディレクトリ数

管理コマンド

# クラスタの状態
hdfs dfsadmin -report                    # 全体クラスタレポート
hdfs dfsadmin -printTopology             # ラック構成の確認

# セーフモード
hdfs dfsadmin -safemode get              # セーフモード状態の確認
hdfs dfsadmin -safemode leave            # セーフモードの解除

# ブロック管理
hdfs fsck / -files -blocks -locations    # ファイルシステムの整合性チェック
hdfs fsck /user/hadoop/ -files           # 特定パスのチェック

# スナップショット
hdfs dfsadmin -allowSnapshot /user/hadoop/important
hdfs dfs -createSnapshot /user/hadoop/important snap_20260308
hdfs dfs -deleteSnapshot /user/hadoop/important snap_20260308

# クォータ管理
hdfs dfsadmin -setSpaceQuota 100G /user/hadoop/project
hdfs dfsadmin -clrSpaceQuota /user/hadoop/project

7. パフォーマンスチューニング

HDFSチューニング

<!-- hdfs-site.xml -->
<configuration>
    <!-- ブロックサイズ（大容量ファイルが多い場合256MBに増加） -->
    <property>
        <name>dfs.blocksize</name>
        <value>268435456</value>  <!-- 256MB -->
    </property>

    <!-- DataNodeの同時転送スレッド（デフォルト4096） -->
    <property>
        <name>dfs.datanode.max.transfer.threads</name>
        <value>8192</value>
    </property>

    <!-- NameNodeハンドラースレッド（デフォルト10） -->
    <property>
        <name>dfs.namenode.handler.count</name>
        <value>100</value>  <!-- ln(クラスタノード数) * 20 -->
    </property>

    <!-- Short-circuitローカル読み取り -->
    <property>
        <name>dfs.client.read.shortcircuit</name>
        <value>true</value>
    </property>
    <property>
        <name>dfs.domain.socket.path</name>
        <value>/var/lib/hadoop-hdfs/dn_socket</value>
    </property>
</configuration>

MapReduceチューニング

<!-- mapred-site.xml -->
<configuration>
    <!-- Mapタスクメモリ -->
    <property>
        <name>mapreduce.map.memory.mb</name>
        <value>2048</value>
    </property>
    <property>
        <name>mapreduce.map.java.opts</name>
        <value>-Xmx1638m</value>  <!-- memory.mbの80% -->
    </property>

    <!-- Reduceタスクメモリ -->
    <property>
        <name>mapreduce.reduce.memory.mb</name>
        <value>4096</value>
    </property>
    <property>
        <name>mapreduce.reduce.java.opts</name>
        <value>-Xmx3276m</value>
    </property>

    <!-- Shuffleバッファ -->
    <property>
        <name>mapreduce.task.io.sort.mb</name>
        <value>512</value>  <!-- Map出力ソートバッファ -->
    </property>
    <property>
        <name>mapreduce.reduce.shuffle.input.buffer.percent</name>
        <value>0.70</value>
    </property>

    <!-- 圧縮 -->
    <property>
        <name>mapreduce.map.output.compress</name>
        <value>true</value>
    </property>
    <property>
        <name>mapreduce.map.output.compress.codec</name>
        <value>org.apache.hadoop.io.compress.SnappyCodec</value>
    </property>
</configuration>

チューニング要約表

項目	デフォルト値	推奨値	影響
`dfs.blocksize`	128MB	128〜256MB	大容量ファイル → 256MB
`dfs.replication`	3	2〜3	ストレージ容量 vs 信頼性
`dfs.namenode.handler.count`	10	20〜200	NameNode RPCスループット
`mapreduce.map.memory.mb`	1024	1024〜4096	Mapタスクメモリ
`mapreduce.reduce.memory.mb`	1024	2048〜8192	Reduceタスクメモリ
`mapreduce.task.io.sort.mb`	100	256〜512	Mapソートパフォーマンス
`yarn.nodemanager.resource.memory-mb`	8192	物理メモリの80%	ノードの合計割当メモリ

8. Spark vs MapReduce 比較

項目	MapReduce	Spark
処理方式	ディスクベースのバッチ	インメモリバッチ/ストリーミング
速度	基準（1x）	10〜100倍高速
反復処理	毎回ディスクI/O	メモリにキャッシュ
プログラミングモデル	Map → Reduce	RDD、DataFrame、SQL
言語	Java	Scala、Python、Java、R、SQL
リアルタイム処理	不可	Structured Streaming
メモリ要件	低い	高い
障害復旧	ディスクから再計算	Lineageで再計算
適したワークロード	シンプルETL、ログ処理	ML、グラフ、反復処理、対話型分析

# Spark WordCount（比較用）
from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("WordCount").getOrCreate()
text_file = spark.sparkContext.textFile("hdfs:///user/hadoop/input/")
counts = text_file.flatMap(lambda line: line.split(" ")) \
                  .map(lambda word: (word, 1)) \
                  .reduceByKey(lambda a, b: a + b)
counts.saveAsTextFile("hdfs:///user/hadoop/output/spark-wordcount")

9. モニタリング

重要モニタリングメトリクス

メトリクス	説明	警告基準
NameNode Heap使用率	NNメモリ使用量	> 80%
Under-Replicated Blocks	複製不足ブロック数	> 0（持続時）
Dead DataNodes	障害DNの数	> 0
HDFS Capacity Used	ディスク使用率	> 80%
YARN Memory Used	メモリ使用率	> 85%
Pending Containers	待機中のコンテナ	> 100（持続時）

Web UIポート

# NameNode UI: http://namenode:9870
# ResourceManager UI: http://resourcemanager:8088
# DataNode UI: http://datanode:9864
# NodeManager UI: http://nodemanager:8042
# MapReduce History: http://historyserver:19888

Prometheus + Grafana連携

# prometheus.yml
scrape_configs:
  - job_name: 'hadoop-namenode'
    metrics_path: '/jmx'
    params:
      format: ['prometheus']
    static_configs:
      - targets: ['namenode:9870']

  - job_name: 'hadoop-datanode'
    metrics_path: '/jmx'
    params:
      format: ['prometheus']
    static_configs:
      - targets: ['datanode1:9864', 'datanode2:9864', 'datanode3:9864']

  - job_name: 'hadoop-resourcemanager'
    metrics_path: '/jmx'
    params:
      format: ['prometheus']
    static_configs:
      - targets: ['resourcemanager:8088']

10. トラブルシューティング

NameNode障害

# NameNodeがセーフモードから抜けない場合
hdfs dfsadmin -safemode get
hdfs dfsadmin -safemode leave

# NameNode EditLogの破損時
hdfs namenode -recover

# NameNode OOM
# → hadoop-env.shでヒープサイズを増加
# export HDFS_NAMENODE_OPTS="-Xmx32g -Xms32g"

DataNode障害

# DataNodeの状態確認
hdfs dfsadmin -report | grep -A5 "Dead datanodes"

# 特定DataNodeのブロック検証
hdfs fsck / -files -blocks -locations | grep "datanode1"

# DataNodeのディスクフル
# → dfs.datanode.data.dirに新しいディスクを追加
# → DataNodeの再起動

YARNアプリケーション障害

# 実行中のアプリケーション一覧
yarn application -list

# アプリケーションログの確認
yarn logs -applicationId application_1709875200_0001

# アプリケーションの強制終了
yarn application -kill application_1709875200_0001

# コンテナログの確認
yarn logs -applicationId application_1709875200_0001 -containerId container_1709875200_0001_01_000001

11. 運用チェックリスト

初期構築チェックリスト

Javaバージョンの確認（JDK 11以上推奨）
SSH鍵ベース認証の設定（全ノード）
NTP同期の確認（全ノード）
OSチューニング（ulimit、swappiness、THP無効化）
ディスクJBOD構成（RAID使用禁止）
HDFS HA構成（JournalNode 3つ以上）
YARN HA構成（ResourceManager 2つ）
ネットワーク帯域幅の確認（10Gbps以上推奨）

日常運用チェックリスト

NameNodeヒープ使用率のモニタリング
Under-replicatedブロックの確認
Dead DataNodeの確認
HDFS容量使用率の確認
YARNキューリソース使用率の確認
ログディスク使用量の確認
長時間実行ジョブの確認

定期点検チェックリスト

hdfs fsck /を実行してファイルシステムの整合性を確認
NameNodeのバックアップ（fsimage + edits）
セキュリティパッチ適用計画の策定
ディスク交換計画（SMART確認）
クラスタバランシング（hdfs balancer）
ログローテーションとクリーンアップ

まとめ

Hadoopはビッグデータエコシステムの基盤インフラとして、依然として重要な位置を占めています。HDFSは大規模データストレージとして、YARNは多様な処理フレームワークのリソース管理者として引き続き活用されています。

まとめ：

HDFSはブロック単位の分散ストレージ + レプリケーションで信頼性を確保
MapReduceはシンプルだがディスクI/Oが多く、Sparkと比較して低速
YARNは多様なフレームワークのための汎用リソース管理者
パフォーマンスチューニングはブロックサイズ、メモリ、スレッド数の調整が核心
モニタリングはNameNodeヒープ、Under-replicatedブロック、YARNキューに集中