1 Hadoop完全分布式集群

一、hadoop基础知识

1.1 hadoop是什么？

    📢是指Apache软件基金会【是一个非盈利的全球性组织，致力于支持和促进开源软件项目的开发。】的一款开源软件，允许用户使用简单的编程模型实现跨机器集群对海量数据进行分布式计算处理。

hadoop核心组件

• HDFS(分布式文件存储系统)：解决海量数据存储

• YARN(集群资源管理和任务调度框架)：解决资源、任务调度

• MapReduce(分布式计算框架)：解决海量数据计算

1.2 hadoop工作流程

1.HDFS存储数据

• 在进行任何计算之前，用户需要将数据上传到 HDFS。HDFS 会将数据分块，并将这些数据块复制到集群中的多个节点上，以提高数据的可靠性和读写效率。

2.客户端发起请求，提交作业。

• 用户通过客户端提交作业，可能是 MapReduce、Spark 或其他框架的作业。客户端会根据作业配置确定需要处理的数据和所需的计算资源。

3.YARN分配资源，创建MapReduce任务

• YARN 负责资源管理和任务调度，它接收作业请求，分配集群中的资源，并启动任务。

• YARN合理分配集群中的资源，是指根据任务的需求（如CPU、内存等），匹配每台服务器的实际资源情况，将任务分配到最合适的服务器上，确保资源利用最大化，避免浪费或过载。

• ResourceManager 负责全局资源调度，NodeManager 负责每个节点上的资源管理和任务执行。

4.作业任务执行

• MapReduce 执行任务

• Spark 执行任务

• .....其他框架组件的任务

5.任务结果再入HDFS

• 无论是 MapReduce 还是 Spark 作业，其输出结果通常会被写回 HDFS，以便于后续处理和查询，确保数据的持久性和容错性。。

6.作业结果返回客户端

• 作业完成后，用户可以通过客户端从 HDFS 检索并访问最终结果。

1.3  hadoop核心组件介绍

1.3.1 HDFS

DFS：Distributed FileSystem 分布式文件系统

HDFS：Hadoop DFS  Hadoop分布式文件系统

HDFS架构及存储

• HDFS 采用Master/Slave的架构来存储数据

• HDFS 的架构包括一个主节点（Master）和多个从节点（Slave），它们共同协作来管理和存储数据。

• 架构组成

• HDFS 架构主要由四个部分组成：HDFS Client、NameNode、DataNode 和 Secondary NameNode。

• HDFS 集群结构

• 一个HDFS集群是由一个NameNode和一定数目的DataNode组成的。

• NameNode：NameNode 是 HDFS 的主节点，负责管理文件系统的名字空间（Namespace）和客户端对文件的访问。它存储元数据（如文件名、权限、数据块位置等），并指引客户端直接与 DataNode 交互以读取或写入数据。

• DataNode：DataNode 是运行在集群各个节点上的进程，负责存储实际的数据块，并执行数据块的读写操作。DataNode 定期向 NameNode 发送心跳信号和数据块报告，确保 NameNode 了解它们的健康状态和存储情况。

• Secondary NameNode：Secondary NameNode 不是 NameNode 的备份，而是一个辅助进程，定期合并 NameNode 的 Edit Log（操作日志）和 FsImage（文件系统镜像），以减小 Edit Log 的大小，并生成新的 FsImage，从而提高 NameNode 的性能和减少重启时间。 #####

HDFS的特点

1. 文件切块存储 在 HDFS 中，文件被分块存储（Block），默认块大小为 128MB。这些块在集群的不同节点上分布存储，以提高数据可靠性和并行处理能力。

2. 主要节点角色

• NameNode：管理文件系统的元数据，包括文件目录结构和数据块的位置。

• DataNode：存储实际的数据块，并向 NameNode 报告数据块的存储情况。

3. 副本机制 HDFS 自动为每个数据块创建多个副本（Replication），默认情况下，每个数据块有 3 个副本。这种机制增强了数据的容错性和可用性。

4. 故障恢复 如果某个 DataNode 宕机，HDFS 会在其他活跃的 DataNode 上重新复制丢失的数据块，以确保副本数量达到预定值。当宕机的 DataNode 恢复后，HDFS 不会自动删除多余的副本。

5. Secondary NameNode Secondary NameNode 定期合并 NameNode 的 Edit Log 和 FsImage，生成新的 FsImage，以优化 NameNode 的性能和缩短启动时间。

NameNode中元数据存储问题及工作机制

• NameNode 是 HDFS 集群的主节点，负责管理文件系统的元数据。其工作机制包括内存元数据、磁盘镜像文件（FsImage）、以及操作日志文件（Edits）三部分。

  内存元数据

  FsImage 文件

  Edits 文件

  内存元数据与持久化存储的关系

  Secondary NameNode 的作用

  触发合并的条件

  整体工作流程

• NameNode 启动时加载 FsImage 和 Edits 文件到内存中，以恢复文件系统的元数据。

• Secondary NameNode 定期合并 FsImage 和 Edits 文件，生成新的 FsImage，确保文件系统的稳定性和一致性。

• 定时触发：根据设定的时间间隔自动进行合并操作。

• Edits 文件满：当 Edits 文件中的操作记录达到一定数量时，触发合并。

• Secondary NameNode 定期从 NameNode 获取 FsImage 和 Edits 文件，并将二者合并生成新的 FsImage，防止 Edits 文件过大影响系统性能。

• 合并后的 FsImage 保持文件系统的一致性和高效性。

• 内存元数据由 FsImage 和 Edits 文件共同恢复：FsImage + Edits = 内存元数据。

• 内存中的元数据用于高效读写，而 FsImage 和 Edits 文件用于持久化保存，防止断电导致的数据丢失。

• 存储在 NameNode 磁盘上的操作日志文件，记录元数据的所有更新操作。

• 每当有元数据变更时，这些操作会被顺序追加到 Edits 文件中。

• 存储在磁盘上的 HDFS 文件系统元数据的完整快照。

• 在 NameNode 启动时加载，用于恢复内存中的元数据，防止数据丢失。

• 存储在 NameNode 的内存中，包含完整的文件系统元数据。

• 提供高效的随机访问，以快速响应客户端请求。

Client（客户端）：【Hadoop 命令行工具的用户或使用 Hadoop Java API 的应用程序】

1. 文件切分：当文件上传到 HDFS 时，客户端将文件切分成多个 Block（默认大小为 128MB），然后将这些块存储到 HDFS 中。

2. 与 NameNode 交互：客户端与 NameNode 交互，以获取文件块的位置信息，了解数据在集群中的分布情况。

3. 与 DataNode 交互：客户端直接与 DataNode 交互，进行数据的读取或写入操作。

4. HDFS 管理：客户端提供命令来管理 HDFS，例如启动或关闭 HDFS 服务。

5. 访问 HDFS：客户端可以通过命令行工具或 API 访问 HDFS 中的数据，执行各种文件操作。

NameNode：是 HDFS 的主节点，相当于系统的“管理者”，负责以下关键任务：

1. 管理 DataNode：NameNode 负责管理和协调集群中的所有 DataNode。

2. 记录元数据：NameNode 记录文件系统的元数据，包括文件到数据块（Block）的映射信息。

3. 配置副本策略：NameNode 设定和管理数据块的副本策略，以确保数据的可靠性和冗余。

4. 处理客户端请求：NameNode 处理客户端的读写请求，指引客户端与正确的 DataNode 交互。

DataNode：是 HDFS 的从节点（Slave），负责执行 NameNode 下达的命令，具体职责包括：

1. 存储数据块：DataNode 存储 HDFS 中的实际数据块。

2. 执行读/写操作：DataNode 负责执行数据块的读写操作，根据客户端请求进行数据传输。

DataNode 是 HDFS 中的从节点，主要职责包括：

1. 存储数据块：DataNode 以 Block 的形式存储实际数据。

2. 心跳机制：DataNode 每隔 3 秒向 NameNode 发送心跳信号，报告节点状态和当前存储的数据情况。

3. 节点监控：如果 NameNode 在 10 分钟内未收到 DataNode 的心跳信号，就会认为该 DataNode 已丢失（lost）。

4. 数据冗余处理：当某个 DataNode 被判定为丢失后，NameNode 会将该节点上的数据块副本重新分配并备份到其他 DataNode 上，以确保数据的可靠性。

Secondary NameNode： Secondary NameNode 并不是用来替代 NameNode 的。如果 NameNode 崩溃了，Secondary NameNode 不能直接接管它的工作。它的主要作用是帮助 NameNode 处理元数据，以减轻 NameNode 的负担。

1. 辅助 NameNode：帮助 NameNode 做元数据的备份和恢复。

2. 定期合并元数据：定期合并 fsimage 和 edits 文件，并将新的 fsimage 文件推送给 NameNode，减轻 NameNode 的工作量。

• edits 更新日志：记录 HDFS 文件系统的所有更新操作路径，客户端的写操作首先记录到 edits 文件中。

• fsimage 镜像文件：包含整个 HDFS 文件系统元数据的永久性检查点，包括所有目录和文件的 inode 信息（如 ID、类型、目录、所属用户、权限、时间戳等）。

• 合并过程：NameNode 启动时会将 fsimage 文件读入内存，并与 edits 文件合并，确保内存中的元数据最新和同步。

3. 紧急恢复：在 NameNode 出现故障时，Secondary NameNode 可以辅助恢复 NameNode 的元数据。

• 误解澄清

• 不是备份节点：Secondary NameNode 并不会在 NameNode 宕机时自动接管其职责。它的作用是协助优化元数据管理，而非充当冗余备份节点。

• 优化而非替代：Secondary NameNode 的主要功能是优化 NameNode 的元数据管理，确保 NameNode 的启动和运行更加高效，而不是取代 NameNode 的功能。

• NameNode 的恢复过程

  通过这两个步骤，NameNode 可以恢复到重启前的状态。定期合并 FsImage 和 Edit Log，可以减小 Edit Log 的大小，减少重启时所需的恢复时间。

• 如果NameNode宕机或重启，需要加载FsImage并重放Edit Log中的所有变更记录。如果Edit Log很大，这个过程会非常耗时。FsImage和Edit Log定期合并后，Edit Log会保持较小的大小，NameNode在重启时需要重放的变更记录就会少很多，从而大幅减少恢复时间。

1. 加载 FsImage：当 NameNode 重启时，它会首先从磁盘中加载 FsImage 文件。FsImage 是文件系统元数据的一个完整快照，代表了文件系统在保存快照时的状态。

2. 应用 Edit Log：加载 FsImage 后，NameNode 会继续应用 Edit Log 中的变更记录，以将文件系统元数据恢复到最新状态。Edit Log 记录了自上次 FsImage 保存以来的所有元数据变更。

• 关键组件解析

• 存储方式：以文件形式存储在磁盘上。

• 功能：保存 HDFS 文件系统元数据的完整快照，表示文件系统在某一时间点的全量状态【 保存了当时整个 HDFS 文件系统的元数据的全貌，包含了所有的文件、目录、权限、块的位置等信息】。它定期从 Edit Log 中合并增量更新，以确保 NameNode 能快速恢复或重启。

• 位置：存储在 NameNode 服务器所在的主机的本地磁盘上，通过本地文件系统管理。

• 存储方式：以日志文件形式存储在磁盘中。

• 功能：记录对 HDFS 元数据的所有变更操作，包括文件的创建、删除、修改等。每次变更操作都会被顺序追加到 Edit Log 中，以保证操作的持久化和顺序执行。

• 位置：存储在 NameNode 服务器所在的主机的本地磁盘上，通过本地文件系统管理。

• Edit Log：

• FsImage：

• 协同工作流程

1. 元数据变更记录：当HDFS中有任何变更操作（如文件创建、删除、修改等）时，这些变更首先被记录在Edit Log中。

2. 定期合并：为了防止Edit Log变得过大，Secondary NameNode会定期（如每小时）从NameNode获取当前的Edit Log和FsImage，然后将Edit Log中的变更应用到FsImage，生成一个新的FsImage。

3. 更新FsImage：新的FsImage生成后，Secondary NameNode会将其发送回NameNode。NameNode会用新的FsImage替换旧的FsImage，并开始一个新的Edit Log。

4. 系统恢复：如果NameNode重启，它会加载FsImage作为文件系统元数据的起始点，然后应用Edit Log中的变更来恢复到最新状态。

   
   

Block

1. 文件切块：在 HDFS 中，文件会被切分成多个块（Block），每一个块实际上就是一个 Block。

2. 存储基本单位：Block 是 HDFS 中存储数据的基本单位。

3. 块大小：默认大小为 128MB。

4. 不满块大小的处理：如果文件或数据的大小小于 Block 的大小，则该文件或数据只占用一个与其大小相等的 Block。

5. 切块的意义：

• 便于存储超大文件：切块使得超大文件可以分布在多个节点上，方便存储。

• 便于快速备份：切块使得文件的备份和恢复更加快速和高效。

6. 块编号：HDFS 为每一个 Block 分配一个递增的编号，以便于管理和追踪。

元数据

元数据包括：

1. 文件存储路径：记录文件在分布式文件系统中的路径，例如 /a.log 或 /test/b.txt。

2. 副本数量：记录文件的副本数量，即系统中存储该文件的副本个数。

3. 文件块信息：大文件在 HDFS 中被切分成数据块，元数据包含每个文件的块信息。

4. 块的存储节点：记录每个数据块的存储节点，即哪些节点上存储了该数据块的副本。

HDFS 元数据管理总结

1. 元数据大小：每条元数据约为 150B。

2. 写请求与元数据：只有写请求会生成元数据，读请求不会影响元数据。

3. 元数据存储位置：元数据存储在 NameNode 中，同时保存在内存和磁盘上。

• 内存中的元数据：用于快速查询。

• 磁盘中的元数据：用于崩溃恢复，位置由 core-site.xml 中的 hadoop.tmp.dir 属性指定，通常在指定目录的 dfs/name/current 子目录下。

4. 元数据文件：

• edits：记录 NameNode 接收到的每次写操作（如上传、删除、追加）。

• fsimage：保存文件系统的静态快照，包含元数据，但不实时更新。

5. 写请求处理流程：NameNode 接收到写请求后，先将请求写入 edits 文件，然后更新内存中的元数据，最后向客户端返回成功信号

多副本放置策略

1. 第一个副本：如果数据是从集群内部上传的，通常会将第一个副本放在上传数据的节点上；如果是从集群外部上传，NameNode 会选择一个相对空闲的 DataNode 来存储第一个副本。

2. 第二个副本：默认情况下，第二个副本会放置在与第一个副本位于不同机架的节点上，以提高数据的可用性和容错能力。

3. 第三个副本：第三个副本通常会放置在与第二个副本位于同一机架但不同节点上，以平衡负载和提高容错性。

4. 更多副本：对于超过三个副本的情况，NameNode 会选择集群中相对空闲的节点来存放这些副本，以进一步平衡负载。

HDFS的写数据流程

1. 客户端请求上传文件：客户端通过DistributedFileSystem模块向NameNode发送请求，问是否可以上传文件，并检查文件和目录是否存在。

2. NameNode确认：NameNode检查完后，告诉客户端是否可以上传文件。

3. 客户端请求存储第一个块（Block）：客户端将文件拆成块，第一个块大小为0-128MB。它向NameNode询问存储这个块的DataNode节点。

4. NameNode返回节点信息：NameNode选择3个可用的DataNode（例如，dn1，dn2，dn3）来存储这个块，并把它们的地址告诉客户端。

5. 建立通信管道：客户端通过FSDataOutputStream模块将数据发送到第一个节点（dn1），然后dn1继续和dn2通信，dn2再联系dn3，完成数据传输通道的建立。

6. 确认通信成功：dn1、dn2、dn3逐级向客户端确认它们已准备好接收数据。

7. 数据传输：客户端开始向dn1发送数据块，数据被分成多个小包（Packet），每个Packet大小为64KB。dn1接收到Packet后，立即传给dn2，dn2再传给dn3。每发送一个Packet，dn1会放到队列中，等待收到响应确认。

8. 传输完成：当一个块的传输完成后，客户端会向NameNode请求存储下一个块，并重复上述过程，直到所有数据块传输完成。

Packet的定义：

• Packet：HDFS并不会一次性传输整个数据块，而是将一个数据块拆分成更小的单位来传输，这个单位就是Packet。这样做可以减少网络负载并提高传输的稳定性。

• Packet大小：在HDFS中，默认每个Packet的大小为64KB。

HDFS的读数据流程

1. 客户端请求下载文件：客户端通过DistributedFileSystem向NameNode发送请求，NameNode查询文件的元数据，找到文件的数据块存储在哪些DataNode节点上。

2. 选择合适的DataNode：客户端根据就近原则选择一个最近的DataNode节点，并向它请求读取数据。

3. DataNode传输数据：DataNode从磁盘读取文件块，将数据分成多个小包（Packet），并逐个传输给客户端。同时，每个Packet都会进行校验，确保数据在传输过程中没有损坏。

4. 客户端接收数据：客户端以Packet为单位接收数据，首先存储在本地缓存中，随后写入到目标文件，直到整个文件下载完成。

HDFS 的读写数据流程总结

数据写入流程

1. 客户端请求：用户通过客户端向 HDFS 发送写入数据的请求。

2. 数据分块：HDFS 将文件分成多个块（默认 128MB）。

3. 副本分配：每个数据块被复制到多个 DataNode（通常是 3 个）上，以确保数据安全。

4. 数据写入：客户端将数据块发送到第一个 DataNode，DataNode 依次将副本传递给其他 DataNode。

5. 确认写入：所有副本写入成功后，客户端收到写入完成的确认。

数据读取流程

1. 客户端请求：用户通过客户端向 HDFS 发送读取数据的请求。

2. 定位数据块：NameNode 告诉客户端数据块所在的 DataNode。

3. 数据读取：客户端直接从 DataNode 读取数据块。

4. 合并数据：客户端将读取的数据块合并，返回给用户。

1.3.2 MapReduce

MapReduce定义

• MapReduce作为大数据生态圈第一代分布式计算引擎

• MapReduce是采用一种分而治之的思想设计出来的分布式计算框架

• 如一项复杂的计算任务，单台服务器无法胜任时，可将此大任务切分成一个个小的任务，分别交给不同的服务器上并行执行，最终再汇总每个小任务的结果

• MapReduce的分布式计算框架分为两个阶段：

  第一个Map【映射】阶段     （Map负责“分”：把一个任务切分成多个任务）

  第二个Reduce【规约】阶段（reduce负责“合”：汇总分解后多任务的结果）

MapReduce并行计算

• HDFS存储数据时对大于128M的数据会进行数据切分，每128M一个数据块，数据块会分散、分布存储到HDFS。

• MapReduce在进行计算前会复制计算程序，每个数据块会分配一个独立的计算程序副本（MapTack）。计算时多个数据块几乎同时被读取并计算，但是计算程序完全相同。最终将各个计算程序计算的结果进行汇总（Reduce来汇总）

MapReduce流程：

WordCount案例运行和详解

理解reducer这个概念，假设你在一个班级里负责统计全班同学的总成绩。你可以采取两种策略来完成这项工作：

1. 一个人统计：你拿到每个同学的成绩单，一个接一个地加总，直到得到全班同学的总分。这种方法类似于 MapReduce 中只有一个 reducer 处理所有数据。

2. 分组统计：你将班级分成几个小组，每组有一个组长。每位组长负责统计他/她组内同学的总成绩，然后你将各组的总分加起来，得到全班的总分。这种方法类似于 MapReduce 中有多个 reducer，每个 reducer 负责处理一部分数据，最终将这些结果汇总起来。

在 MapReduce 中，reducer 的角色是处理来自 mapper 的中间数据，进行汇总和归纳，最终生成输出结果。我们可以将整个过程分成以下几个步骤：

1. Map 阶段：就像收集每个学生的成绩一样，mapper 负责处理原始数据，并将其转化为键值对（key-value pairs），例如（学生，成绩）。

2. Shuffle 阶段：系统会自动将具有相同“键”的数据分配到同一个 reducer，就像将同一组学生的成绩集中到他们的组长那里。这一阶段负责组织和分配数据。

3. Reduce 阶段：reducer 接收到经过“洗牌”后的数据，并对其进行汇总或处理。例如，每个组长计算组内同学的总成绩，reducer 也会对它收到的数据进行处理，最终输出结果。

在MapReduce的上下文中，reducer是一个程序或函数，专门负责接收处理过的中间数据，并执行一些汇总或归纳的操作。例如，在一个单词计数的作业中，reducer会接收来自mapper的数据，它可能会收到形如（Word, 1）的多个键值对，它的任务就是将这些计数相加，得到（Word, TotalCount）这样的最终结果，即每个单词出现的总次数。

总结一下，reducer在MapReduce作业中的角色就是最终处理和汇总数据，输出最终结果。在更复杂的应用场景中，reducer的工作可能涉及更复杂的数据处理逻辑，但核心就是聚合和汇总。

MapReduce优缺点

优点

• MapReduce易于编程：他简单的实现一些接口，就可以完成一个分布式程序

• 良好的扩展性：可以通过简单的增加机器来扩展它的计算能力

• 高容错性：假设集群中一台集群挂了，他可以把上面的计算任务转移到另一个节点上运行，而不至于这个任务失败。

• 适合PB级以上海量数据的离线处理：集群中的服务器并发工作，数据处理能力强。

缺点

• 不擅长实时计算：无法像一些OLTP数据库一样，在毫秒或者秒级内返回结果。

• 不擅长流式计算：流式计算的输入数据是动态的，而MapReduce的输入集数据是静态的，不能动态变化。

1.3.3 Yarn

Apache Hadoop YARN（Yet Another Resource Negotiator）是Hadoop生态系统的关键组件之一，用于集群资源管理和作业调度。YARN的主要组件和功能如下：

1. ResourceManager（资源管理器）：

• 核心组件：负责给任务分配集群资源并管理任务的运行。

• 资源监控：监控集群中可用的计算资源（如CPU、内存等）。

• 资源分配：为每个应用程序分配合适的节点，确保资源被合理利用。

2. NodeManager（节点管理器）：

• 节点管理：运行在集群中的每台服务器上，负责管理该节点的资源和任务。

• 资源汇报：向ResourceManager报告节点上剩余的资源情况。

• 任务监控：监控和管理运行在该节点上的任务容器。

YARN通过灵活的资源管理和调度机制，允许多个应用程序共享集群资源，从而提高数据处理的效率和扩展性。

通俗解释

• ResourceManager：

• 大管家：像集群的总管，负责管理和分配所有资源。

• 资源分配：根据任务的需要，合理分配集群中各节点的CPU、内存等资源。

• 协调应用：确保不同任务公平地使用资源，避免资源争夺。

• NodeManager：

• 看门人：每个节点的“守卫”，负责管理所在节点的资源。

• 资源监控：监控节点的资源使用情况，并及时向ResourceManager汇报。

• 容器管理：负责启动和监控任务容器，确保它们正常运行。

总结：YARN的核心作用是根据任务所需的资源（如CPU、内存），将任务合理分配到空闲的节点上运行。它通过ResourceManager协调和分配全局资源，并通过NodeManager在每个节点上管理任务的具体执行和资源使用。

1.4 hadoop优点

高可靠性

• 数据冗余：Hadoop维护多个数据副本，增加数据冗余，避免数据丢失。

• 任务重试：在任务失败后，Hadoop能够自动重新部署计算任务。

高扩展性

• 集群扩展：Hadoop集群可以方便地增加更多的节点，实现横向扩展。

高效性

• 数据移动：Hadoop能够在集群节点之间动态移动数据，保证各节点的数据动态平衡。

• 并行处理：通过并行方式工作，处理速度非常快。

高容错性

• 任务重分配：Hadoop维护多个数据副本，并能自动将失败的任务重新分配到其他节点。

低成本

• 开源框架：Hadoop是开源的，允许使用普通廉价的硬件组成集群来处理大数据。

• 跨平台：Hadoop使用Java语言编写，可以在不同平台上运行。

1.5 Hadoop 生态圈

Hadoop 生态圈是指围绕 Hadoop 软件框架为核心而出现的越来越多的相关软件框架，这些软件框架和 Hadoop 框架一起构成了一个生机勃勃的 Hadoop 生态圈。

Hadoop 生态圈的架构

1. Hadoop Common： 是 Hadoop 生态系统中的基础设施，提供了各个模块通用的工具和库。

2. HDFS（Hadoop 分布式文件系统）： Hadoop 的基石，用于存储和管理大规模数据的分布式文件系统。

3. YARN： 统一资源管理和调度平台，负责集群中的资源分配和任务调度。

4. MapReduce： 分布式计算的编程模型，适用于大规模数据的批处理操作。

5. Spark： 开源的大数据内存计算框架，支持基于Hadoop上存储的大数据进行计算。

6. Flink： 开源的大数据内存计算框架，主要用于实时计算场景。

7. HBase： 分布式、面向列族的数据库，建立在Hadoop HDFS之上，用于存储非结构化数据。

8. Hive： 基于Hadoop的数据仓库工具，提供类SQL语法查询功能，可以将结构化的数据文件映射为数据库表。

9. Pig： 用于大型数据集分析和评估的工具，类似于Hive。

10. Impala： 交互式SQL查询工具，类似于Hive，可对存储在HDFS、HBase中的数据执行查询。

11. Mahout： 机器学习和数据挖掘库，实现经典的机器学习算法。

12. Flume： 高可用、高可靠的分布式日志采集框架。

13. Sqoop： 开源工具，用于Hadoop、Hive与传统数据库之间的数据传递，支持数据导入导出。

14. Kafka： 高吞吐量的分布式发布/订阅消息系统。

15. ZooKeeper： 针对大型分布式系统的可靠协调系统，提供配置维护、名字服务、分布式同步、组服务等功能。

离线大数据处理系统

二、Hadoop 的运行模式

2.1 单机模式

• 默认情况下，Hadoop即处于该模式，用于开发和调式。

• 不对配置文件进行修改。

• 使用本地文件系统，而不是分布式文件系统。

• Hadoop不会启动NameNode、DataNode、JobTracker、TaskTracker等守护进程，Map()和Reduce()任务作为同一个进程的不同部分来执行的。

• 用于对MapReduce程序的逻辑进行调试，确保程序的正确。

守护进程（daemon）：

守护进程是一类在后台运行的特殊进程，通常执行系统任务。许多守护进程在系统启动时自动启动，运行直到系统关闭；另一些则根据需要启动，在完成任务后自动结束。

Map() 和 Reduce() 任务：

Hadoop 的分布式计算框架分为两个阶段，Map 阶段和 Reduce 阶段。Map 阶段负责将输入数据分片并并行处理，Reduce 阶段则对 Map 的输出进行聚合和处理，以达到高效的分布式计算目的。

2.2 伪分布模式

• 在一台主机模拟多主机。

• Hadoop的守护进程运行在本机机器，模拟一个小规模的集群。

• Hadoop启动NameNode、DataNode、JobTracker、TaskTracker这些守护进程都在同一台机器上运行，是相互独立的Java进程。

• 在这种模式下，Hadoop使用的是分布式文件系统，各个作业也是由JobTraker服务，来管理的独立进程。在单机模式之上增加了代码调试功能，允许检查内存使用情况，HDFS输入输出，以及其他的守护进程交互。类似于完全分布式模式，因此，这种模式常用来开发测试Hadoop程序的执行是否正确。

• 修改4个配置文件：

  core-site.xml（配置Hadoop集群的特性：例如HDFS、MapReduce和YARN常用的I/O设置等）

  hdfs-site.xml（配置HDFS集群的工作属性：Hadoop守护（守护是后台的意思）进程的配置项，包括namenode、辅助namenode（即SecondNameNode）和datanode等）

  mapred-site.xml（ 配置MapReduce集群的属性：MapReduce守护进程的配置项，包括作业历史服务器 ）

  yarn-site.xml ( 配置Yarn集群的属性：YARN守护进程的配置项，包括资源管理器、web应用代理服务器和节点管理器 )

• 格式化文件系统

2.3 完全分布式模式

在 完全分布式模式 中，Hadoop 是在一组多台计算机（称为“集群”）上运行的。这是 Hadoop 的 生产环境，用于处理大量数据的场景。

1.守护进程运行在多台主机上 Hadoop 的核心组件（如 NameNode、DataNode、ResourceManager 等）会在多个计算机（节点）上运行，每台计算机都承担不同的角色。这些计算机通过网络连接在一起，形成一个集群。

2.安装 JDK 和 Hadoop 在集群的每台主机上都需要安装 JDK（Java Development Kit）和 Hadoop。Hadoop 依赖 Java，因此 JDK 是必须的。Hadoop 需要在所有主机之间通信，才能分布式处理数据。

3.设置 SSH 免密码登录 为了方便主节点（通常是 NameNode）控制其他从节点（如 DataNode），需要配置 SSH 免密码登录。每个从节点会生成一个公钥，主节点将这些公钥添加到自己的信任列表中，这样主节点就可以无需密码登录到从节点上执行命令。

4.修改3个配置文件：

core-site.xml（配置Hadoop集群的特性：例如HDFS、MapReduce和YARN常用的I/O设置等）

hdfs-site.xml（配置HDFS集群的工作属性：Hadoop守护（守护是后台的意思）进程的配置项，包括namenode、辅助namenode（即SecondNameNode）和datanode等）

mapred-site.xml（ 配置MapReduce集群的属性：MapReduce守护进程的配置项，包括作业历史服务器 ）

yarn-site.xml ( 配置Yarn集群的属性：YARN守护进程的配置项，包括资源管理器、web应用代理服务器和节点管理器 )

关于几个名词的涵义

1.集群（Cluster）

集群 是通过多个计算机（节点）协同执行相同任务，目的是提高系统的性能和可靠性。

例子 1：Web 服务器集群

• 应用场景：一个电商网站拥有大量用户，单个服务器无法处理所有请求。

• 解决方案：通过搭建 Web 服务器集群，多个服务器同时运行同一个网站的服务。当用户访问网站时，请求会被均衡地分配给集群中的不同服务器。

• 类型：这是一个 负载均衡集群，旨在将流量分配到多个节点，避免单个节点超负荷。

例子 2：高可用数据库集群（如 MySQL 主从集群）

• 应用场景：一个公司使用 MySQL 数据库，但如果数据库服务器宕机，服务将无法继续。

• 解决方案：部署 高可用集群，其中一个节点为主节点（Master），另一个或多个节点为从节点（Slave）。主节点负责写操作，从节点负责读取。当主节点发生故障时，从节点可以接管工作，确保数据库服务的连续性。

2.分布式系统（Distributed System）

分布式系统 将任务和数据分散到多个节点上，适用于需要处理大量数据或计算任务的场景。

例子 1：Hadoop 分布式文件系统（HDFS）

• 应用场景：一个公司每天会产生大量数据，单台计算机无法存储所有数据。

• 解决方案：使用 HDFS（分布式文件系统），数据会被分成多个块，分布存储在不同的节点上。即使某个节点故障，数据依然可以通过其他节点的冗余副本进行恢复。

• 类型：这是一个 分布式文件系统，通过将数据分块存储在不同节点上，实现大规模数据存储和高容错性。

例子 2：MapReduce 分布式计算

• 应用场景：需要统计一个超大型数据集（例如用户的网页浏览记录中的热门关键词）。

• 解决方案：使用 MapReduce，首先由多个 Map 节点分别处理数据的不同部分，然后由 Reduce 节点汇总处理结果。这种方式可以大幅提高处理大数据集的效率。

• 类型：这是一个 分布式计算系统，通过任务分配和并行处理，实现大规模计算任务的处理。

3. 负载均衡

负载均衡（Load Balance）将工作任务分摊到多个操作单元上运行，如FTP服务器、Web服务器、企业核心应用服务器等，以协同完成任务。

• 构建方式：负载均衡构建在现有网络结构之上，提供透明且廉价的扩展方法。

• 提升性能：扩展服务器和网络设备的带宽，增强数据处理能力，增加吞吐量，提高网络的可用性和灵活性。

• 任务分配：确保每个节点的任务分配基本均衡。

4. 守护进程

守护进程是一个在后台运行的程序，通常负责管理系统上的某项服务。它持续运行，并在需要时响应来自用户或网络客户端的请求，以确保系统服务的正常运作。

三、完全分布式的安装

1. 前期准备

准备工作：

• 前期在VM中安装好一台CentOS7虚拟机，主机名为master；

• 关闭防火墙

• 配置了静态IP

• 成功连接Finalshell

软件准备：

• Hadoop 3.1.3

• 下载地址：https://archive.apache.org/dist/hadoop/common/hadoop-3.1.3/

• jdk-8u271-linux-x64.tar.gz

• 下载地址：https://www.oracle.com/java/technologies/javase/javase8u211-later-archive-downloads.html

2. 克隆两台主机

# 如果master主机处于开机状态，先关机
init 0      # 如果是重启则命令为：init 6

2.1 master主机克隆两台机器slave1，slave2

2.2 分别更改两台克隆机的静态IP

# 分别登录两台克隆机
# 切换用户：root
# 口   令：123456

vi /etc/sysconfig/network-scripts/ifcfg-ens33
------------------------------------------------
# 在slave1，slave2上操作，分别更改如下信息：
IPADDR=192.168.36.101       # 修改slave1
IPADDR=192.168.36.102       # 修改slave2

2.3 分别更改两台克隆机的主机名

vim /etc/hostname
# 在slave1，slave2上操作，分别更改如下信息：
slave1
slave2

2.4 重启两台克隆机

2.5 slave1与slave2分别连接Finalshell

3. 在master主机上安装jdk和hadoop

说明：在 /opt下创建两目录：apps放置解压文件，software放置压缩文件。

3.1 创建两个文件夹

cd /opt/
mkdir apps
mkdir software

3.2 复制、解压安装文件

先把jdk-8u271-linux-x64.tar.gz和hadoop-3.1.3.tar.gz复制到/opt/software目录中

# 安装Jdk 和 Hadoop
cd /opt/software
tar zxvf jdk-8u271-linux-x64.tar.gz -C /opt/apps/    # 大写C ，指定解压路径
tar zxvf hadoop-3.1.3.tar.gz -C /opt/apps/

3.3 更改文件名

cd /opt/apps/
mv jdk1.8.0_271/  jdk
mv hadoop-3.1.3/  hadoop

3.4 添加环境变量

目的：可以在任何的路径运行hadoop与jdk

vi /etc/profile  # 全局环境变量配置文件

# 添加配置
export JAVA_HOME=/opt/apps/jdk
export HADOOP_HOME=/opt/apps/hadoop
export PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin:$HADOOP_HOME/sbin

使配置生效：

source /etc/profile

# 可查看本机的PATH路径 
echo $PATH
# /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin:/opt/apps/jdk/bin:/opt/apps/hadoop/bin:/opt/apps/hadoop/sbin

3.5 查看版本

# 分别 查看java与hadoop的版本
java -version
hadoop version

3.6 配置域名映射：

# 分别在三台机器进行配置
vi /etc/hosts
# 三台机器分别都添加如下信息
192.168.36.100 master
192.168.36.101 slave1
192.168.36.102 slave2

注：三台主机可以互PING测试

3.7 分发到slave1和slave2主机：

• 把master下的两个文件夹/opt/apps/jdk/和/opt/apps/hadoop/复制给其他两个节点

# 将本地 /opt/apps/ 目录的所有内容（包括文件和子目录）递归复制到远程服务器slave1的/opt/apps/目录中
# 如果远程服务器slave1不存在/opt/apps/目录，则自动创建
scp -r /opt/apps   slave1:/opt/
scp -r /opt/apps   slave2:/opt/

# 复制过程需要确认和输入密码
# Are you sure you want to continue connecting (yes/no)?   yes
# root@slave1's password:  123456

• 把master下的文件/etc/profile复制给其他节点

scp -r /etc/profile  slave1:/etc/
scp -r /etc/profile  slave2:/etc/

• 每个节点让环境变量生效：

# 在slave1和slave2上分别运行
source /etc/profile

3.8 三台机器免密互访

1. SSH 简介

Secure Shell（SSH） 是一种加密的网络传输协议，能够在不安全的网络中为通信提供安全的传输环境。它常用于远程登录服务器和安全传输数据。

2. 公钥和私钥的概念

• 私钥：就像是保险箱的钥匙，必须严格保密，不能与他人分享。它是拥有者的身份验证工具。

• 公钥：类似于保险箱的锁，可以自由分享给他人。他们可以用公钥“锁住”消息，但只有拥有匹配私钥的人才能解锁。

3. 公钥与私钥的作用

• 私钥：用于解密被公钥加密的数据，且可用于身份验证。

• 公钥：用于加密数据，只有对应的私钥才能解密，确保只有特定的私钥持有者能读取信息。

4.举例：你将 公钥（锁） 寄给别人，他们用公钥锁住（加密）他们的消息（门），只有你，拥有匹配 私钥 的人，才能解开这个锁（解密信息）。

5.总结：公钥用于加密，而 私钥用于解密。

# 第一种方法【建议使用此方法】
# 1.首先在三台机器上分别生成ssh公钥和私钥：  ssh-keygen -t rsa
# 2.分别将各自公钥发送到所有机器（包括自己）：ssh-copy-id 目标IP
# 解释：此操作将你的公钥（通常是 ~/.ssh/id_rsa.pub）复制到目标机器的 ~/.ssh/authorized_keys 文件中，从而允许你使用私钥在目标机器上进行SSH登录。     `authorized  /ˈɔːθəraɪzd/ 授权`

# 具体操作：
# 1.在master首先生成ssh公钥和私钥：
ssh-keygen -t rsa     # 执行会有提示，三次都按回车 
# 2.发送公钥到所有机器（包括自己）：
ssh-copy-id master  # 在此过程输入yes 和 密码123456
ssh-copy-id slave1
ssh-copy-id slave2
# 3.然后在slave1\slave2主机上都执行相同的操作。

---------------------------------------------------------------------------------------
# 第二种方法【了解即可】
# 1.依次登录三台机器，使用rsa加密技术，利用ssh-keygen（注册机）生成本机的公钥与私钥
ssh-keygen -t rsa       # 执行会有提示，三次都按回车 

# 2.依次登录三台机器，执行以下命令，将本机的都公钥拷贝到master服务器的authorized_keys文件中
  ## 命令：ssh-copy-id 实现将本机的公钥复制到远程机器master的authorized_keys文件中
  ## 目的：实现三台机器的公钥都复制到了master的authorized_keys文件中
ssh-copy-id master  # 三台机器依次执行复制！（复制的过程中需要验证密码）

# 3.在master的服务器，执行以下命令将authorized_keys拷贝到slave1与slave2
[root@master ~]#  cd ~/.ssh                      -- 隐藏目录，命令ll -a查看
[root@master .ssh]#  scp authorized_keys slave1:$PWD  
[root@master .ssh]#  scp authorized_keys slave2:$PWD
## 解读$PWD：拷贝到远程机器的路径与当前机器路径一致

authorized  /ˈɔːθəraɪzd/ 授权

3.9 验证免密

# 可以在三台机器上互访免密
ssh master
ssh slave1
ssh slave2

4.Hadoop集群节点配置

分布式集群部署规划

（1）NameNode和 Secondary NameNode不要安装在同一台服务器。 （2）ResourceManager也很消耗内存，不要和 NameNode、SecondaryNameNode配置在同一台机器上。

NameNode 元数据的管理

DataNode 数据存储管理

Secondary NameNode 优化和协助元数据管理

ResourceManager 集群的资源管理分配、作业管理

NodeManager 节点的资源管理

修改master主机修改Hadoop如下配置文件，这些配置文件都位于/opt/apps/hadoop/etc/hadoop目录下。

site表示的是用户定义的配置，会覆盖default中的默认配置。

继承 core-site.xml：是指其他配置文件可以共享或引用 core-site.xml 中的全局配置项，不需要在每个组件的配置文件中重复定义通用的设置。

4.1 配置workers

在 Hadoop 集群中，workers 文件 记录了所有 DataNode 和 NodeManager 的主机名。这个文件用于告诉集群哪些机器是 从节点，它们将承担存储数据（DataNode）和执行计算任务（NodeManager）的任务。

• 默认内容：在默认情况下，workers 文件只包含 localhost，意味着本地机器既作为 NameNode（主节点）也作为 DataNode（从节点）使用，这种配置通常用于 伪分布式模式。

修改配置以支持 master 节点同时作为 NameNode 和 DataNode

如果你想让 master 节点同时充当 NameNode 和 DataNode，你只需要将 master 节点的主机名 添加到 workers 文件中。这意味着该节点不仅负责管理元数据（作为 NameNode），还将参与存储数据（作为 DataNode）。

具体步骤：

# 三台机器都要进行更改
vi /opt/apps/hadoop/etc/hadoop/workers
# 修改如下
master
slave1
slave2

4.2 配置core-site.xml

vi /opt/apps/hadoop/etc/hadoop/core-site.xml

修改如下：

<configuration>
    <!-- 确定hadoop运行时产生临时文件的存储路径 -->
    <property>
       <name>hadoop.tmp.dir</name>
       <value>/opt/apps/hadoop/tmp</value>
    </property> 
    <!-- 指定 Hadoop 文件系统（HDFS）的主节点（NameNode）的地址。 -->
    <!-- fs.defaultFS 表示文件系统的根目录，HDFS 的地址是 hdfs://master:9000，这里的 "master" 是主节点，9000 是访问 NameNode 的端口。 -->
    <property>
   <name>fs.defaultFS</name>
   <value>hdfs://master:9000</value>
    </property>
    <!-- 允许 root 用户代理其他用户的操作权限，不限制 root 用户可以访问的主机。 -->
    <!-- '*' 表示 root 用户可以在任何主机上代理用户的操作。 -->
    <property>
        <name>hadoop.proxyuser.root.hosts</name>
        <value>*</value>
    </property>
    <!-- 允许 root 用户代理所有用户组的请求，不限制 root 可以操作的用户组。 -->
    <!-- '*' 表示 root 用户可以代理所有用户组的请求。 -->  
    <property>
        <name>hadoop.proxyuser.root.groups</name>
        <value>*</value>
    </property>
</configuration>

1. hadoop.tmp.dir

• 定义：hadoop.tmp.dir 是 Hadoop 用来存储 临时数据 的目录。默认情况下，它是 Linux 系统中的 /tmp/{$user} 目录（$user 是当前用户的名称）。

• 风险：

• 默认目录的风险：在 Linux 系统中，/tmp 目录经常会在系统重启或服务重启时被清空。如果 Hadoop 使用默认的 /tmp 目录存放临时数据，那么系统中的临时文件（例如 NameNode 的元数据文件等）可能会丢失，特别是在系统重启或意外断电后。

• 建议：

• 持久化目录：为了避免数据丢失，建议将 hadoop.tmp.dir 配置到一个持久化的目录中，如 /opt/apps/hadoop/tmp，确保临时数据不会因为系统重启而丢失。

• 路径自定义：需要根据你的系统情况选择合适的目录，确保该目录有足够的存储空间，并适合长时间使用。

2. fs.defaultFS

• 定义：fs.defaultFS 指定了 NameNode 的地址 URI，这个 URI 包含了协议（如 HDFS）、主机名和端口号。它定义了 Hadoop 文件系统的根位置。

• 作用：

• 集群节点与 NameNode 通信：集群中的每个节点（如 DataNode）都需要知道 NameNode 的地址，以便向它注册，并进行数据块的管理和调度。

• 客户端与 NameNode 交互：客户端通过该 URI 与 NameNode 交互，获取文件的块位置信息。然后，客户端会直接与包含数据块的 DataNode 通信，执行读写操作。

• 配置示例：hdfs://master:9000/ 表示 NameNode 的根目录是由主机名 master 上的 HDFS 服务提供的，并且监听 9000 端口。

• hdfs：协议，表示使用 Hadoop 分布式文件系统。

• master：主机名，指向运行 NameNode 的服务器。

• 9000：端口号，NameNode 监听客户端和集群节点的连接请求。

• 简化路径：配置 fs.defaultFS 为 hdfs://master:9000/ 后，用户可以直接用 / 代替完整的 hdfs://master:9000/，例如：

  $ hdfs dfs -ls /
  $ hdfs dfs -ls hdfs://master:9000/

  这两个命令等价，都列出了 HDFS 的根目录。

3. RPC 服务：

• NameNode 的通信：NameNode 在端口 9000 上提供 RPC 服务，它通过这个端口与客户端

4.root 用户代理其他用户：

当 Hadoop 允许 root 用户代理其他用户时，root 可以代表其他用户执行某些需要高权限用户才能执行的Hadoop 的任务，比如提交作业、读写 HDFS 文件等。

示例：假设有一个用户 A 需要在集群中提交一个 MapReduce 作业，但是 A 用户没有足够的权限。通过代理机制，root 用户可以代替 A 提交这个作业，作业最终以 A 用户的身份执行，而 root 用户只是中介。

4.3 配置hdfs-site.xml

vi /opt/apps/hadoop/etc/hadoop/hdfs-site.xml

修改如下：

<configuration>
        <!-- 定义了Secondary NameNode的Web访问地址，并指定其运行在slave2上 -->
        <property>
                <name>dfs.namenode.secondary.http-address</name>
                <value>slave2:9868</value>
        </property>
 
       <!-- 设置HDFS文件的副本数量，默认是3个，建议设置为DataNode的数量或更小 -->
        <property>
                <name>dfs.replication</name>
                <value>3</value>
        </property>
 
       <!-- 定义NameNode存放数据和元数据的目录路径 -->
        <property>
                <name>dfs.namenode.name.dir</name>
                <value>/opt/apps/hadoop/tmp/dfs/name</value>
        </property>
 
        <!-- 定义DataNode存放数据的目录路径 -->
        <property>
                <name>dfs.datanode.data.dir</name>
                <value>/opt/apps/hadoop/tmp/dfs/data</value>
        </property>
 
        <!-- 设置HDFS的HTTP访问地址和端口号 -->
        <property>
                <name>dfs.http.address</name>
                <value>0.0.0.0:9870</value>
        </property>
 
        <!-- 关闭HDFS的权限检查，允许所有用户访问HDFS中的任何文件或目录 -->
        <!-- Hadoop不建议用root用户操作，特别是在生产环境中。如果不关闭权限检查，系统会报错 -->
        <property>
     <name>dfs.permissions</name>
     <value>false</value>
    </property>
</configuration>

解释：

dfs.replication：用于设置HDFS的副本数量，默认值为3。HDFS作为分布式文件系统，通常使用冗余存储机制，冗余因子默认为3，也就是每份数据会保存3个副本。这种冗余可以增强数据的可靠性，确保在部分节点发生故障时数据不会丢失。尽管副本数量没有上限，但过多的副本会占用额外的存储空间，而副本过少可能会影响系统的容错能力。

dfs.namenode.name.dir：定义NameNode存储数据和元数据的目录。NameNode负责管理文件系统的元数据，如文件路径和副本位置等，因此这个路径必须存放在可靠的存储设备上。

dfs.datanode.data.dir：定义DataNode存储数据块（block）的目录。DataNode负责实际保存数据文件的块，HDFS将文件拆分成多个block存储在不同的DataNode上，因此这个目录是保存数据块的位置。

dfs.replication（重复说明）：用于设置HDFS的副本数量，默认为3。这个配置项定义了每个文件的默认副本数，确保在硬件故障时数据可以被安全恢复。

dfs.namenode.secondary.http-address：定义Secondary NameNode的HTTP访问地址。Secondary NameNode主要用于帮助NameNode减少元数据的内存占用，并在NameNode出现故障时可以帮助恢复数据。因此，Secondary NameNode应该部署在与NameNode不同的节点上（如slave1），以增加系统的容错能力。

Root 用户限制：Hadoop 不建议用 root 用户操作，特别是在生产环境中。如果不禁用权限检查，系统会报错，提示不应使用 root 用户。因此，禁用权限检查可以绕过这个问题，使你能够正常操作。

4.4 配置mapred-site.xml

该文件用于指定MapReduce使用的框架。

# 修改配置文件
vi /opt/apps/hadoop/etc/hadoop/mapred-site.xml

修改如下：

<configuration>
    <!-- 指定MapReduce程序的运行模式为YARN（默认是local模式），这样MapReduce作业可以分布式执行 -->
    <property>
        <name>mapreduce.framework.name</name>
        <value>yarn</value>
    </property>

    <!-- 配置MapReduce应用程序管理器（AM）的环境变量，确保能够找到Hadoop的类库和资源 -->
    <property>
        <name>yarn.app.mapreduce.am.env</name>
        <value>HADOOP_MAPRED_HOME=${HADOOP_HOME}</value>
    </property>

    <!-- 配置Map任务的环境变量，确保Map任务能够找到Hadoop的类库和资源 -->
    <property>
        <name>mapreduce.map.env</name>
        <value>HADOOP_MAPRED_HOME=${HADOOP_HOME}</value>
    </property>

    <!-- 配置Reduce任务的环境变量，确保Reduce任务能够找到Hadoop的类库和资源 -->
    <property>
        <name>mapreduce.reduce.env</name>
        <value>HADOOP_MAPRED_HOME=${HADOOP_HOME}</value>
    </property>
</configuration>

解释：

• mapreduce.framework.name=yarn：这行配置指定了 MapReduce 程序要在 YARN（Yet Another Resource Negotiator）上运行。YARN 是 Hadoop 的资源管理框架，可以在分布式集群上管理作业和资源。默认情况下，MapReduce 作业是在 local 模式下执行的，即在本地运行单机版本。当设置为 yarn 时，MapReduce 作业会在整个集群中运行，从而提高分布式处理的能力。

• yarn.app.mapreduce.am.env、mapreduce.map.env、mapreduce.reduce.env：这些配置项分别设置了应用程序管理器（AM）、Map任务和Reduce任务的环境变量 HADOOP_MAPRED_HOME。它确保在执行MapReduce作业时，系统能够找到所需的 Hadoop 类库和资源。这对于任务的正确执行非常重要，尤其是在分布式环境下。

这些配置保证了 MapReduce 作业能够顺利在 YARN 集群上运行，并且任务能够访问正确的 Hadoop 环境变量。

4.5 配置yarn-site.xml

vi /opt/apps/hadoop/etc/hadoop/yarn-site.xml

修改如下：

<configuration>   
    <!-- 配置YARN的辅助服务，其中包括MapReduce作业的shuffle服务，用于处理Map任务输出到Reduce任务输入的数据传输 -->
    <property>
        <name>yarn.nodemanager.aux-services</name>
        <value>mapreduce_shuffle</value>
    </property> 
 
    <!-- 配置YARN的ResourceManager所在的主机名（这里指定为slave1），ResourceManager负责管理整个YARN集群的资源分配 -->
    <property>
        <name>yarn.resourcemanager.hostname</name>
        <value>slave1</value>
    </property>
</configuration>

解释：

• yarn.nodemanager.aux-services

  ：

• 解释：这个配置项用于指定 NodeManager 上运行的辅助服务。在运行 MapReduce 程序时，需要将此配置设置为 mapreduce_shuffle，以支持 MapReduce 作业中的数据混洗（shuffle）过程。

• 作用：mapreduce_shuffle 是 YARN 提供的一个必要的附属服务，它支持 MapReduce 作业中的 shuffle 过程。Shuffle 负责将 map 阶段生成的数据按键进行分组和排序，然后传输到合适的 reduce 任务进行进一步处理。

shuffle 过程：

• 作用：在 MapReduce 框架中，shuffle 是 map 阶段和 reduce 阶段之间的核心桥梁。它负责将 map 任务的输出数据根据键进行分组和排序，再将这些排序后的数据传输到对应的 reduce 任务中进行处理。

• 类比：你可以把 shuffle 过程类比为整理扑克牌的过程：首先将 map 任务生成的“扑克牌”按花色和数字排序（即根据键排序），然后把这些整理好的牌分配给特定的“玩家”（reduce 任务），由这些玩家来处理属于自己的数据。

4.6 配置hadoop-env.sh

在 hadoop-env.sh 中指定运行各个 Hadoop 服务的用户身份和环境变量，对于安全性、权限管理以及环境一致性至关重要。

默认情况下，Hadoop 服务会以当前登录的用户身份运行。如果需要指定特定用户（如 root），可以在 hadoop-env.sh 中进行配置。此外，将 JAVA_HOME 设置在 hadoop-env.sh 中，能够避免通过 SSH 远程启动从节点时手动加载环境变量的麻烦。

vi /opt/apps/hadoop/etc/hadoop/hadoop-env.sh

修改如下：

# 指定 JDK 的安装路径
export JAVA_HOME=/opt/apps/jdk 
# 注释掉默认的 JAVA_HOME 行，防止冲突
# export JAVA_HOME=${JAVA_HOME}

# 配置 Hadoop 各服务的运行用户为 root
export HDFS_NAMENODE_USER=root
export HDFS_DATANODE_USER=root
export HDFS_SECONDARYNAMENODE_USER=root
export YARN_RESOURCEMANAGER_USER=root
export YARN_NODEMANAGER_USER=root

解释：

1.为什么“指定 JDK 的安装路径”？

Hadoop 启动脚本在执行时会加载 hadoop-env.sh。在该文件中配置 JAVA_HOME，能够覆盖 /etc/profile 中的 JAVA_HOME 设置。当通过 SSH 远程启动从节点（如 DataNode 和 NodeManager）时，如果 JAVA_HOME 仅在 /etc/profile 中配置，每次启动从节点时都需要手动 source /etc/profile。将 JAVA_HOME 配置在 hadoop-env.sh 中，能够避免这种问题，因为 Hadoop 的启动脚本会自动加载该文件，确保环境变量在集群中生效。

2.为什么要“配置 Hadoop 各服务的运行用户为 root”？

定明确的运行用户：

• Hadoop 启动脚本会尝试以默认用户身份启动各个服务。如果不明确指定用户身份，它们可能会尝试以非 root 用户启动，导致权限不足的问题。

• 配置这些变量可以确保所有服务（NameNode、DataNode、ResourceManager 等）以 root 用户的权限启动，避免出现权限相关的错误。

避免潜在冲突：

• 如果未指定用户身份，Hadoop 可能使用系统中其他默认用户（如 hadoop 或 yarn 用户）来启动服务。由于 root 用户拥有最高权限，明确配置服务以 root 用户身份运行，可以避免某些服务因权限不足而无法访问系统资源或文件。

确保服务的一致性：

• 在分布式系统中，如果某些服务以非 root 用户身份启动，而其他服务以 root 用户身份运行，可能会造成权限冲突，影响系统的一致性。通过配置这些变量，确保所有服务在同一权限级别下运行，避免权限不一致导致的异常。

4.7 配置yarn-env.sh

vi /opt/apps/hadoop/etc/hadoop/yarn-env.sh

修改如下：

# 指定你的jdk路径
export JAVA_HOME=/opt/apps/jdk

4.8 分发hadoop安装目录到slave节点

[root@master ~]# scp -r /opt/apps/hadoop  slave1:/opt/apps/
[root@master ~]# scp -r /opt/apps/hadoop  slave2:/opt/apps/

5. 启动集群

5.1 格式化namenode

在master节点上执行如下命令：

hdfs namenode -format

首次启动Hadoop集群时，需要先在master节点执行名称节点的格式化

作用：初始化或清空 HDFS 中的 NameNode，以创建新的文件系统环境，清除所有现有的元数据和数据。

注意：只需要格式化这一次，后面再启动Hadoop时，不要再次格式化名称节点

5.2 启动HDFS

在master节点上执行如下命令：

start-dfs.sh     # 启动HDFS

注释： 此时如果在master上启动start-yarn.sh ，则可能在slave1上看不到resourcemanager进程，查看resourcemanager进程启动日志/usr/local/hadoop/logs/yarn-hadoop-resourcemanager-slave1.log，发现slave1:8031无法连接，故resourcemanager守护进程需要到slave1上启动

或者：直接在slave1上运行start-yarn.sh（可以同时启动resourcemanager与Datamanager）

5.3 启动yarn

在slave1节点上执行如下命令：

start-yarn.sh

注意： 1.如果ResourceManager配置在与NameNode不同的机器上，应该在ResourceManager所在的机器上【slave1】执行start-yarn.sh命令启动YARN服务。

或者使用下面的方法启动: 1.在master上start-yarn.sh启动各节点NodeManager单点启动： 2.在slave1单点启动resourcemanager：yarn-daemon.sh start resourcemanager  daemon/diːmən/守护进程

5.4 查看启动的集群进程

在`master`节点上可以看到`NameNode`、`DataNode`、`NodeManager`进程
[root@master ~]# jps
3552 NodeManager
2613 NameNode
14231 Jps
2876 DataNode

在`Slave1`节点可以看到`DataNode`、`ResourceManager`、`NodeManager`进程
[root@slave1 ~]# jps
3106 ResourceManager
2581 DataNode
3254 NodeManager
17054 Jps

在`Slave2`节点可以看到`DataNode`、`NodeManager`、`SecondrryNameNode`进程
[root@slave2 ~]# jps
2755 SecondaryNameNode
3162 NodeManager
17690 Jps
2527 DataNode

5.5 查看HDFS和Yarn的报告

# 1.在master上查看hdfs的报告
hdfs dfsadmin -report

# 2.在master上查看yarn的信息
yarn node -list

5.6 Web访问

# Web访问hdfs
http://192.168.36.100:9870
http://master:9870
 
# Web访问yarn
http://192.168.36.101:8088
http://slave1:8088

如果不成功，查看下面的错误坑点。

6. 关闭Hadoop集群

stop-dfs.sh                                   # 在master上执行
stop-yarn.sh                                  # 在slave1上执行

7. 错误坑点

这里是经过优化后的Windows浏览器无法访问Hadoop集群端口（如9870、8088）的解决方案：

7.1 解决Windows浏览器无法访问Hadoop的9870、8088等端口

问题描述：

在虚拟机启动Hadoop集群后，Windows浏览器无法访问Hadoop的Web监控界面，例如 http://master:9870 或 http://master:8088。

解决方案：

1. 检查网络连接

   ping master           # 尝试通过主机名ping
   ping 192.168.36.100    # 尝试通过IP地址ping

• 如果主机名master无法ping通，但IP地址能够ping通，说明可能存在DNS解析问题。

• 通过ping命令检查Windows与Hadoop集群的主机是否连接正常。

2. 识别问题原因

• 确定是否为DNS解析问题：如果通过IP地址能够访问Hadoop的Web页面，但通过主机名无法访问，说明本地DNS解析可能存在问题。

3. 使用IP地址访问服务

   http://192.168.36.100:9870   # 访问Hadoop NameNode Web界面
   http://192.168.36.100:8088   # 访问YARN ResourceManager Web界面

• 如果可以通过IP地址访问但无法通过主机名访问，问题应该在DNS解析上。

• 尝试通过IP地址在浏览器中访问Hadoop服务，确认Hadoop服务是否正常运行。

4. 修改Windows的hosts文件

• 为了通过主机名访问，可以修改Windows的hosts文件，将Hadoop集群的IP地址映射到主机名。

• 以管理员权限打开记事本，并编辑C:\Windows\System32\drivers\etc\hosts文件，添加以下行：

  192.168.36.100 master
  192.168.36.101 slave1
  192.168.36.102 slave2

• 通过这个步骤，你可以将主机名与相应的IP地址关联，确保通过主机名master、slave1、slave2可以访问相应的服务。

5. 保存并重启主机

6. 验证更改

• 再次ping主机名 master 以确认更改是否生效。

  ping master

• 如果能够成功ping通主机名，说明修改已经生效。

7. 重新测试浏览器访问

• 使用主机名访问Hadoop的Web服务：

  http://master:9870      # 访问Hadoop NameNode Web界面
  http://master:8088      # 访问YARN ResourceManager Web界面

7.2 在HDFS的WEB UI上查看日志文件，无法显示文本内容

在HDFS的WEB UI上查看日志文件时，出现“Couldn't preview the file”错误，无法预览文本内容，且无法下载文件。File contents显示 [object Object]。

造成原因：

1. 主机名解析问题：Windows主机无法正确解析Hadoop集群的主机名（如master、slave1、slave2），导致通过WEB UI访问文件时出错。

2. 主机名映射不一致：Windows系统中的C:\Windows\System32\drivers\etc\hosts文件与Linux下的/etc/hosts文件中的Hadoop集群主机名映射不一致，导致解析问题。

解决方法：

1. 修改Windows的hosts文件

• 打开C:\Windows\System32\drivers\etc\hosts文件，确保Windows能够正确解析Hadoop集群中每个节点的主机名。

• 使用管理员权限打开记事本，编辑hosts文件，添加以下内容：

  192.168.36.100 master
  192.168.36.101 slave1
  192.168.36.102 slave2

2. 确保Linux主机的/etc/hosts文件中也有相应的映射

• 在Hadoop集群的每个节点（Master和Slaves）上，检查或更新/etc/hosts文件，确保其主机名映射与Windows中的一致：

  192.168.36.100 master
  192.168.36.101 slave1
  192.168.36.102 slave2

3. 刷新DNS缓存

• 修改hosts文件后，刷新Windows DNS缓存，以确保更改生效：

  ipconfig /flushdns

4. 重新访问HDFS Web UI

• 完成上述步骤后，重新打开HDFS的Web UI，尝试再次访问日志文件。如果一切配置正确，应该能够正常查看或下载文件内容。

总结：

通过确保Windows和Linux主机的hosts文件映射一致，能够解决日志文件在HDFS Web UI中无法正确显示的问题。

7.3 格式化失败或数据节点Datanode无法启动

# 1. 关闭所有守护进程
stop-dfs.sh        # 在master节点上关闭HDFS进程
stop-yarn.sh       # 在Slave1节点上关闭YARN进程

# 2. 删除所有节点上的临时文件和日志
# 在Master\slave1\slave2节点上分别执行以下命令
rm -rf /opt/apps/hadoop/tmp         # 删除core-site.xml中配置的hadoop数据存储目录
rm -rf /opt/apps/hadoop/logs/*      # 删除Hadoop日志文件

# 3. 重新格式化NameNode 【仅在Master节点执行】
hdfs namenode -format

# 4. 启动HDFS集群
start-dfs.sh       # 在master节点上启动HDFS
start-yarn.sh      # 在Slave1节点上启动YARN

# 5. 在各节点验证集群状态
jps   

8. 执行分布式实例

8.1 全分布运行官方wordcount案例

Wordcount 程序简介

定义与目的：

• WordCount 是 Hadoop MapReduce 框架的入门级示例程序。

• 类似于编程语言中的 "Hello World" 示例，用于演示 Hadoop 的基本编程结构和概念。

• Wordcount 程序的 JAR 包已经预装在 Hadoop 的安装目录中，具体位置：/share/hadoop/mapreduce 文件夹。

功能描述：

• Wordcount 程序用于统计一个文本文件中各个单词的出现频率。

• 使用 Hadoop MapReduce 实现单词计数任务，从 HDFS 中的 input 目录读取文本数据，统计每个单词出现的次数，并将结果输出到 HDFS 的 output 目录。

Wordcount 程序的实现

程序组件：

• Wordcount 程序包含一个 MapReduce 作业，该作业由两个主要部分组成：Map 阶段和 Reduce 阶段。

Map 阶段：

• 在 Map 阶段，程序将输入的文本文件分解成单词，并为每个单词生成一个键值对（单词, 1），其中键是单词本身，值是 1。

Reduce 阶段：

• 在 Reduce 阶段，程序将所有具有相同键（即相同单词）的值进行汇总，计算出每个单词在文件中出现的总次数。

MapReduce流程：

WordCount案例运行和详解

总结：

• Splitting：将输入数据分割为小块，分发给不同的 Mapper 任务。

• Mapping：Mapper 处理每个文本块，生成 (单词, 1) 的键值对。

• Shuffling：将相同的键（单词）聚合在一起，为 Reducer 汇总做准备。

• Reducing：Reducer 对每个单词的计数进行累加，生成最终的计数结果。

实验步骤：

1.在 /usr/local 目录下创建 hadoop 目录，然后在 hadoop 目录下继续创建 wcinput 目录：

mkdir -p /usr/local/hadoop/wcinput

2.在wcinput文件下创建一个wc.input文件，并输入以下内容

touch /usr/local/hadoop/wcinput/wc.input

# 使用文本编辑工具（如vi）输入以下内容
vi /usr/local/hadoop/wcinput/wc.input

# 输入以下文本并保存
hello hadoop
hello mapreduce
hello yarn

3.在HDFS中创建用户目录：

通常HDFS建议每个用户在自己的目录下存放数据，原因如下：

• 权限管理：每个用户只能操作自己的目录，避免误删或修改他人数据。

• 数据组织：用户独立目录有助于管理，防止数据混乱。

• 默认路径：某些Hadoop程序默认使用用户目录，不创建可能导致操作失败或需要手动指定路径。

hdfs dfs -mkdir -p /user/root

# hdfs dfs ：用于与 Hadoop 分布式文件系统 (HDFS) 进行文件和目录操作的命令

4.查看刚才创建的目录：

方法1：使用命令的方式

# 列出 HDFS 根目录下的文件和目录。
hdfs dfs -ls /

# 列出 HDFS 根目录下的所有子目录和文件，包括子目录中的内容。【-R 递归】
hdfs dfs -ls -R /

方法2：使用HDFS Web UI（依次点击Utilities -> Browse the file system查看文件系统的目录结构。）

5.将本地文件复制到HDFS

将本地 /usr/local/hadoop/wcinput/wc.input 复制到HDFS分布式文件系统中的 /user/root/input 中。

注意：在 Hadoop 分布式文件系统 (HDFS) 中，每个用户都有一个默认的文件目录。这个目录的路径位于 HDFS 的根目录下的 /user 目录中，用户的个人目录以用户名命名。例如，如果你的用户名是 root，那么你的 HDFS 目录路径就是 /user/root。

我们是以 root 用户身份在 Hadoop 中操作。并且已创建了一个目录 /user/root。因此，当在 HDFS 中进行文件操作时，如果要访问 root 用户的文件夹中的 input 的文件夹，可以有两种方式：

1. 使用绝对路径：/user/root/input

2. 使用相对路径：HDFS 会将相对路径解析到当前用户的 HDFS 目录下，那么可以只写 input，因为系统会自动将其识别为 /user/root/input。

这就意味着，当我们执行某些命令时，比如上传数据或读取文件，可以省去写完整的绝对路径，而直接用相对路径 input 来简化操作。系统会理解为 /user/root/input。

• （1）在HDFS下新建input目录（默认在user/root下创建）：

hdfs dfs -mkdir input

• （2）将本地的wc.input上传到HDFS的input目录下:

hdfs dfs -put /usr/local/hadoop/wcinput/wc.input input

6.查看文件是否上传成功:

# 递归列出根目录及其所有子目录的文件和目录信息
hdfs dfs -ls -R /

7.删除现有的输出目录

• 注意：运行此案例时程序时，输出目录不能存在，否则会提示错误*“org.apache.hadoop.mapred.FileAlreadyExistsException: Output directory hdfs://localhost:9000/user/hadoop/output already exists” ，

• 因此，如果要多次运行同一个程序，在每次运行之前需要删除 HDFS 中的 output 目录（首次运行时不需要删除）:

hdfs dfs -rm -r -f output 

# 强制递归删除 HDFS 中的 output 目录及其内容；
# -r: 递归删除
# -f: 强制删除，即使文件或目录不存在，也不会报错。

8.运行WordCount程序

hadoop jar /opt/apps/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar \
wordcount \
-D mapreduce.map.memory.mb=2048 \
-D mapreduce.reduce.memory.mb=2048 \
input \
output

解释：

• hadoop jar: 运行 Hadoop 的 JAR 文件。

• /opt/apps/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar: 这是 Hadoop 示例程序的 JAR 文件。

• wordcount: 执行单词计数的 MapReduce 程序。

• -D mapreduce.map.memory.mb=2048：设置每个Map任务的最大内存为2048 MB（2 GB），以确保Map任务在执行时有足够的内存。

• -D mapreduce.reduce.memory.mb=2048：设置每个Reduce任务的最大内存为2048 MB（2 GB），确保Reduce任务在执行时有足够的内存。

• input: 输入文件所在的 HDFS 目录。

• output: 输出结果保存的 HDFS 目录（必须不存在，否则会报错）。

在运行日志中，以下是几条重要信息，可以帮助理解和诊断Hadoop wordcount作业的执行情况：

1. 资源管理连接 Connecting to ResourceManager at slave1/192.168.36.101:8032 表示Hadoop客户端成功连接到了ResourceManager，准备提交作业。

2.作业提交状态 Submitted application application_1726732813798_0010 这是作业的Application ID，表示作业成功提交给YARN资源管理器，可以用来跟踪作业状态。

3.作业跟踪URL The url to track the job: http://slave1:8088/proxy/application_1726732813798_0010/ 提供了作业的Web界面URL，用于在线查看作业的执行进度和详情。

4.作业执行进度 map 0% reduce 0% 表示作业刚开始执行。 map 100% reduce 0% 表示Map阶段完成。 map 100% reduce 100% 表示Reduce阶段完成，作业执行结束。

5.作业完成状态 Job job_1726732813798_0010 completed successfully 关键信息，表明作业成功执行，没有出现错误或中断。

6.SASL加密信任问题 SASL encryption trust check: localHostTrusted = false, remoteHostTrusted = false 这个信息表明在加密数据传输过程中，本地和远程主机都没有被信任，可能需要进一步检查SASL配置。

7.Map-Reduce作业计数器 Launched map tasks=1 和 Launched reduce tasks=1 表示作业启动了1个Map任务和1个Reduce任务。 Map输入和输出记录： Map input records=3 表示Map任务处理了3条输入记录。 Map output records=6 表示Map任务产生了6条输出记录。 Reduce输入和输出记录： Reduce input records=4 表示Reduce任务接收了4条输入记录。 Reduce output records=4 表示Reduce任务输出了4条结果记录。

8.系统资源使用 Physical memory (bytes) snapshot=453672960 和 Virtual memory (bytes) snapshot=7343108096 显示了作业执行时使用的物理内存和虚拟内存，帮助评估作业的资源消耗。

9.文件系统统计 HDFS: Number of bytes read=148 和 HDFS: Number of bytes written=36 说明从HDFS读取了148字节的数据，写入了36字节的数据，反映了作业的I/O情况。

9.查看运行结果：

hdfs dfs -cat output/*

10.也可以在web网页中下载文件查看

注意：如果运行失败需要重新执行，需要删除HDFS中的  output 文件夹，然后再重新执行。

hdfs dfs -rm -r -f output

【错误坑点】

报错：hadoop执行mapreduce操作时报找不到或无法加载主类 org.apache.hadoop.mapreduce.v2.app.MRAppMaster的解决办法

原因：由于在YARN执行MapReduce任务时，无法找到Hadoop的classpath，导致找不到必要的类和资源。

解决方法：

• 确保环境变量设置正确：确保在执行MapReduce作业时，AM（Application Master，应用程序主）、Map任务和Reduce任务都能找到所需的Hadoop类和资源，以便成功运行作业。

• 编辑MapReduce配置文件：mapred-site.xml

  在配置文件中添加以下配置项，以确保各个任务能够正确找到Hadoop的类路径：

<!-- 配置MapReduce应用程序管理器（AM）的环境变量，确保能够找到Hadoop的类库和资源 -->
<property>
    <name>yarn.app.mapreduce.am.env</name>
    <value>HADOOP_MAPRED_HOME=${HADOOP_HOME}</value>
</property>

<!-- 配置Map任务的环境变量，确保Map任务能够找到Hadoop的类库和资源 -->
<property>
    <name>mapreduce.map.env</name>
    <value>HADOOP_MAPRED_HOME=${HADOOP_HOME}</value>
</property>

<!-- 配置Reduce任务的环境变量，确保Reduce任务能够找到Hadoop的类库和资源 -->
<property>
    <name>mapreduce.reduce.env</name>
    <value>HADOOP_MAPRED_HOME=${HADOOP_HOME}</value>
</property>

• 注意：如果不设置这些属性，在运行Hadoop自带的示例程序（如词频统计WordCount）时，可能会遇到“Error: Could not find or load main class org.apache.hadoop.mapreduce.v2.app.MRAppMaster”的错误。

8.2 全分布运行官方 grep 案例

grep 案例简介

定义与目的：

• grep案例是Hadoop MapReduce框架中的一个经典示例程序。

• 它的目的是演示如何在Hadoop集群上执行分布式的文本搜索和过滤操作。

功能描述：

• 使用 Hadoop MapReduce 实现文本搜索任务，从 HDFS 中的 input2 目录读取文本数据，利用正则表达式 'dfs[a-z.]+' 查找以 "dfs" 开头、后跟小写字母或句点的文本片段，并将结果输出到 HDFS 的 output2 目录。

grep案例的实现

程序组件：

• grep案例程序由MapReduce作业构成，包括Map任务和Reduce任务两个主要部分。

Map阶段：

• 在Map阶段，程序读取输入的文本数据，并将每一行与正则表达式进行匹配。匹配成功的行会作为键值对输出，其中键是固定值，值是匹配的行。

Reduce阶段：

• 在Reduce阶段，程序接收Map阶段输出的所有匹配行，并将它们写入到输出文件中。由于Grep案例的Reduce任务相对简单，通常可以省略或使用一个简单的Reducer实现。

【实验步骤：】

1.首先在 HDFS 中创建用户目录：

注意：如上个案例创建过此目录就不需要再创建了

hdfs dfs -mkdir -p /user/root

两种方法查看刚才创建的目录：

1）使用命令

hdfs dfs -ls -R /user

2）WEB方法 （点击Utilities-Browse the file system）

2.将本地 /opt/apps/hadoop/etc/hadoop/*.xml 复制到HDFS文件系统中的 /user/root/input2 中。

注意：我们使用的是 root 用户，并且已在HDFS中创建相应的用户目录 /user/root ，因此在命令中就可以使用相对路径如 input2，其对应的绝对路径就是 /user/root/input2:

# 递归删除HDFS上的目录input2，包括目录内的所有文件和子目录。其中 -r 表示递归删除，-f 表示强制删除
hdfs dfs -rm -r -f input2

# 在HDFS上创建 input2 目录并上传文件
hdfs dfs -mkdir input2     
hdfs dfs -put /opt/apps/hadoop/etc/hadoop/*.xml input2

# 删除 output2 文件夹（Hadoop 运行程序时，输出目录不能存在，否则会提示错误 ）
hdfs dfs -rm -r output2

# 查看文件列表
hdfs dfs -ls input2

3.运行 MapReduce 作业

# 切换到 Hadoop 目录
cd /usr/local/hadoop

# 运行 MapReduce 作业
hadoop jar /opt/apps/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar \
grep \
-D mapreduce.map.memory.mb=2048 \
-D mapreduce.reduce.memory.mb=2048 \
input2 \
output2 \
'dfs[a-z.]+'

解释：

• hadoop jar: 运行 Hadoop 的 JAR 文件。

• /opt/apps/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-3.1.3.jar: 这是 Hadoop 示例程序的 JAR 文件。

• grep：选择要运行的MapReduce示例为'grep'，用于基于正则表达式在输入文件中搜索模式。

• -D mapreduce.map.memory.mb=2048：设置每个Map任务的最大内存为2048 MB（2 GB），以确保Map任务在执行时有足够的内存。

• -D mapreduce.reduce.memory.mb=2048：设置每个Reduce任务的最大内存为2048 MB（2 GB），确保Reduce任务在执行时有足够的内存。

• 建议master主机的内存在VMware中设置为4G

• input2: 输入文件所在的 HDFS 目录。

• output2: 输出结果保存的 HDFS 目录（必须不存在，否则会报错）。

• 'dfs[a-z.]+'：并在输入文件中搜索匹配模式'dfs[a-z.]+'的文本。

  
  

• 'dfs[a-z.]+'正则表达式:用于在文本中查找以 "dfs" 开头，后跟一个或多个小写字母或句点的文本片段。例如，它可以匹配 "dfsabc"、"dfs.efg"、"dfsxyz" 等。

4.查看运行结果（查看的是位于 HDFS 中的输出结果）：

1)  在 HDFS 中查看输出结果

hdfs dfs -cat output2/*

2)  将结果复制到本地并查看

# 强制递归删除本地文件系统中的 output2 文件夹（如果存在）
rm -rf /usr/local/hadoop/output2  

# 将 HDFS 上的 output2 目录下载并复制到本地文件系统中的 /usr/local/hadoop/output2
hdfs dfs -get output2 /usr/local/hadoop/output2 

# 显示本地 output2 文件夹中所有文件的内容
cat /usr/local/hadoop/output2/*                 

常见问题：

Hadoop 运行程序时，输出目录不能存在，否则会提示错误 “org.apache.hadoop.mapred.FileAlreadyExistsException: Output directory hdfs://localhost:9000/user/hadoop/output already exists” ，因此若要再次执行，需要执行如下命令删除 output 文件夹:

hdfs dfs -rm -r -f output2    # 删除 output2文件夹

关闭Hadoop集群

最后，关闭Hadoop集群

stop-yarn.sh      # 在master上执行
stop-dfs.sh       # 在slave1上执行

至此，就顺利完成了Hadoop集群搭建。