Hadoop大数据开发基础概

姜欣良

已于 2024-12-26 21:41:13 修改

阅读量681

点赞数 24

文章标签：大数据 hadoop 分布式

于 2024-12-26 04:14:31 首次发布

本文链接：https://blog.csdn.net/jxl20040418/article/details/144730303

版权

一、1.Hadoop概述

Hadoop是一个由Apache基金会所开发的分布式系统基础架构，它利用集群的威力进行高速运算和存储。Hadoop实现了一个分布式文件系统（Hadoop Distributed File System，HDFS）和一个MapReduce编程模型，以及YARN资源管理器。用户可以在不了解分布式底层细节的情况下，开发分布式程序。利用Hadoop，开发者可以轻松地处理TB级甚至PB级的数据。

二、Hadoop核心组件

HDFS（Hadoop Distributed File System）：
- HDFS是Hadoop的分布式文件系统，用于存储大数据文件。
- 它将数据划分为多个块，并存储在不同的服务器上，以实现高效的存储和数据冗余。
- 每个数据块默认大小为128MB（Hadoop 2.x版本），并且有多个副本（默认为3个）以防止数据丢失。
MapReduce：
- MapReduce是Hadoop的分布式计算框架，用于处理和分析存储在HDFS上的大数据。
- 它将复杂的数据处理任务分解为两个简单的阶段：Map阶段和Reduce阶段。
- 在Map阶段，数据被分割并转换为键值对；在Reduce阶段，具有相同键的值被汇总和处理。
YARN（Yet Another Resource Negotiator）：
- YARN是Hadoop的资源管理器，负责调度和管理集群中的资源。
- 它为不同的应用程序提供了一个统一的资源管理平台，并允许它们共享集群资源。

三、Hadoop生态系统

Hadoop生态系统是一个由多个组件组成的强大工具集，这些组件可以协同工作，为用户提供全面的大数据解决方案。以下是一些关键的Hadoop生态系统组件：

Hive：
- Hive是一个数据仓库工具，它提供了类似于SQL的查询语言HiveQL。
- Hive将HiveQL查询转换为MapReduce任务，并在Hadoop集群上执行。
- 它使得不熟悉MapReduce编程的人员也能方便地进行数据处理和分析。
Pig：
- Pig是一种高级数据处理语言，允许用户以简洁、直观的方式编写数据处理脚本。
- Pig引擎将这些脚本转换为MapReduce任务并执行。
- Pig提供了丰富的操作符和函数，用于数据的清洗、转换和分析。

四、Hadoop实践挑战与解决方案

数据规模庞大：
- 挑战：处理大规模数据需要强大的计算和存储资源。
- 解决方案：利用Hadoop的分布式计算和存储能力，将数据分片并存储在不同的节点上，同时利用MapReduce进行并行处理。
数据格式复杂：
- 挑战：不同来源的数据格式可能不同，需要进行格式转换和清洗。
- 解决方案：使用Pig或Hive等工具进行数据清洗和格式转换，以确保数据的一致性和准确性。
资源分配不均：
- 挑战：集群中的资源可能分配不均，导致某些任务执行缓慢。
- 解决方案：使用YARN进行资源管理和调度，以确保资源的高效利用和任务的均衡执行。

五、Hadoop实践成果

数据处理效率提升：
- 通过Hadoop的分布式计算和存储能力，显著提升了数据处理的速度和效率。
- 能够快速处理和分析大规模数据集，为业务决策提供及时、准确的数据支持。
成本降低：
- Hadoop是开源的，不需要支付额外的软件费用。
- 同时，Hadoop可以构建在廉价的商用服务器上，降低了硬件成本。
可扩展性增强：
- Hadoop的集群可以轻松扩展，以应对不断增长的数据量和业务需求。
- 只需添加新的节点到集群中，即可实现计算和存储能力的扩展。

六、个人与团队反思与建议

技术掌握：
- 个人需要不断学习和掌握Hadoop及相关技术的新特性和最佳实践。
- 团队可以定期组织技术分享和培训活动，以促进知识的共享和技术的提升。
团队协作：
- 加强团队成员之间的沟通和协作，共同解决技术难题和业务需求。
- 建立有效的项目管理和协作机制，以确保项目的顺利进行和按时交付。
性能优化：
- 持续优化Hadoop集群的性能，包括调整数据块大小、副本数量、内存配置等参数。
- 使用合适的压缩算法和文件格式，以减少数据传输和存储的开销。
故障容错：
- 加强Hadoop集群的故障容错能力，包括数据备份、心跳检测、任务重试等机制。
- 定期对集群进行健康检查和故障排查，以确保系统的稳定性和可靠性。

以上是Hadoop的由来以及简单的功能介绍，以下是Hadoop的详细功能

二、Hadoop集群的搭建及配置是一个复杂但有序的过程，涉及多个关键概念和步骤。以下是对Hadoop集群搭建及配置概念的详细阐述：

一、Hadoop集群的基本概念

Hadoop是一个开源的大数据处理框架，由Apache基金会开发，最初由Doug Cutting和Mike Cafarella创建。Hadoop集群是一个分布式计算系统，由多台计算机（节点）组成，用于处理和分析大规模的数据集。它能够将数据分散存储到集群中的各个节点上，并通过并行计算提高数据处理的效率和速度。

二、Hadoop集群的组成部分

Hadoop集群主要包括主节点（Master Nodes）和从节点（Worker Nodes）两部分：

主节点：
- 负责集群的资源管理和任务调度。
- 包括ResourceManager（资源管理器）和NameNode（名称节点）。
从节点：
- 负责具体的计算任务和数据存储。
- 包括NodeManager（节点管理器）和DataNode（数据节点）。

三、Hadoop集群搭建的关键步骤

准备多个节点：
- 根据需求选择合适的硬件和软件环境。
- 确保节点之间可以通过高效的网络连接进行通信。
安装和配置Hadoop软件：
- 下载并解压Hadoop安装包。
- 配置Hadoop的环境变量和相关文件。
配置HDFS：
- HDFS是Hadoop的分布式文件系统，用于存储大数据文件。
- 需要配置NameNode和DataNode的相关参数。
配置YARN：
- YARN是Hadoop的资源管理和调度框架。
- 需要配置ResourceManager和NodeManager的相关参数。
配置其他相关组件：
- 根据需求配置MapReduce、Hive、Pig等其他Hadoop生态系统组件。
编写配置文件：
- 配置文件通常包括core-site.xml、hdfs-site.xml和yarn-site.xml等。
- 这些文件定义了集群的参数和配置，如HDFS的块大小、副本数量、YARN的内存配置等。
格式化NameNode：
- 在首次启动Hadoop集群之前，需要格式化NameNode。
- 这个过程会初始化HDFS的元数据存储。
启动Hadoop集群：
- 使用Hadoop提供的命令启动NameNode、DataNode、ResourceManager和NodeManager等进程。
- 验证集群是否正常运行，可以使用Hadoop提供的命令行工具或Web界面进行监控和管理。

四、Hadoop集群配置的关键概念

静态IP设置：
- 为每个节点分配一个固定的IP地址，以确保节点之间的通信稳定可靠。
主机名设置：
- 为每个节点设置一个唯一的主机名，方便在集群中进行管理和通信。
主机名与IP的映射：
- 在每个节点的/etc/hosts文件中配置主机名与IP地址的映射关系。
- 这样可以通过主机名进行节点间的通信。
防火墙管理：
- 在集群部署模式下，为了方便节点间的通信，一般需要关闭防火墙或配置相应的防火墙规则。
JAVA环境安装：
- Hadoop是基于Java开发的，因此需要在每个节点上安装Java环境。
Hadoop安装与配置：
- 安装Hadoop软件包并配置相关文件。
- 根据需求调整Hadoop的配置参数，如内存大小、并行度等。
高可用性配置：
- 为了提高Hadoop集群的可靠性和容错性，可以配置高可用性（HA）方案。
- 例如，使用ZooKeeper进行故障切换和主备NameNode的同步等。

五、注意事项

数据备份与恢复：
- 定期备份Hadoop集群中的重要数据。
- 了解并掌握数据恢复的方法和流程。
性能监控与优化：
- 使用Hadoop提供的管理工具或开源工具进行性能监控。
- 根据监控结果调整集群的配置和参数，以提高性能。
故障排查与处理：
- 熟悉Hadoop集群的常见故障和排查方法。
- 在出现故障时及时进行处理，确保集群的稳定运行。

综上所述，Hadoop集群的搭建及配置涉及多个关键步骤和概念。通过合理配置和优化，可以构建一个高效、稳定、可扩展的大数据处理平台。

Hadoop集群的搭建及配置涉及多个步骤，以下是一个详细的指南

六、Hadoop集群搭建前的准备

虚拟机软件：如VMware或VirtualBox（用于创建和管理虚拟机）。
操作系统镜像：如CentOS 7（Hadoop集群通常运行在Linux操作系统上）。
Hadoop安装包：从Apache Hadoop官网下载适合你的版本的Hadoop安装包。
JDK安装包：Hadoop是基于Java的，因此需要安装Java Development Kit（JDK）。
SSH工具：用于远程连接和管理虚拟机。注：（前提条件，我们做好自己的个人文件夹文件）

在非C盘的位置，创建你的个人文件夹，如这里用个人名字拼音缩写，路径D:\jxl
创建“软件”文件夹，用于存放本课程所有软件，路径D:\jxl\软件
创建“java”文件夹，用于存放后续java项目，路径D:\jxl\java
创建“linux”文件夹，用于存放hadoop完全分布式的3台虚拟机，路径D:\jxl\linux
1. 在linux文件夹里创建3个文件夹，分别是master、slave1和slave2，路径分别是
D:\jxl\linux\master

D:\jxl\linux\slave1

D:\jxl\linux\slave2

2.硬件准备：
- 足够的物理硬件资源，包括CPU、内存和存储空间。
- 网络连接，确保所有虚拟机可以相互通信。

七、创建虚拟机并安装操作系统

创建虚拟机：
- 在虚拟机软件中创建一个新的虚拟机。
- 1.如果vmware17没安装，全部点下一步（安装位置自选）快速安装
  
  2.打开虚拟机，左边空白处点右键，点新建文件夹，输入自己名字
- 新建好文件夹后，再点左上角文件，点击新建虚拟机，弹出下面窗口
- 选择要安装的操作系统镜像，并设置虚拟机的硬件配置（如CPU、内存、磁盘大小等）。
安装操作系统：
- 启动虚拟机，并按照屏幕上的指示完成操作系统的安装。
- 出现黑色屏幕后，鼠标点击中间黑色部分，然后按下回车键就会出现以下安装过程
- 加载完成后，出现下面的页面，点右下角继续Continue
  
  点击Begin Installation后，进入到安装过程
- 在安装过程中，出现以下页面。可以设置超级管理员的密码，不要设置123456，如我设置成jxl********
- .创建一个普通用户，如我帐号名叫jxl，密码也是叫jxl********
- 等待系统安装完成
- 完成后，自动进入开机页面（像常用的Windows开机也要有个过程）
- 进入到登录页面，输入帐号和密码
- 更该文件名称
- 1.左边目录栏，有你姓名命名的文件夹，里面的虚拟机改名成了master
- 2.登录成功，显示到了[root@localhost ~]#

八、配置虚拟机网络

配置静态IP：
- 如果你用普通用户登录了（如果用root登录不需要），需要切换超级用户，命令：su
- 固定IP
- - 点击键盘i键，更改当前编辑模式，切换为输入模式insert
- 编辑虚拟机的网络配置文件（如/etc/sysconfig/network-scripts/ifcfg-ens33），将IP地址设置为静态，并配置网关和DNS。
  IP网址，格式是XXX.XXX.XXX.XXX，由4个数字和3个点“.”组成（如后面的DNS1里就写入了8.8.8.8，也是一个IP地址，是Google提供的免费DNS服务器的IP地址），以下是几个需要新增的项
- 1. IPADDR：前3个数字要和上一步查到的VMnet8保持一致，最后一位，从3~254里挑选任意一位
- 2.GATEWAY：前3个数字要和上一步查到的VMnet8保持一致，最后一位必需是2
- 3.NETMASK：固定写法：255.255.255.0 DNS1：可以写入8.8.8.8 修改ifconfig-ens33文件：
  保存文件（注意，鼠标要确定点进了虚拟机linux系统里再操作）： 1.点击键盘ESC键，切换模式 2.输入:wq，按回车键完成保存并退出（左下角有提示你有没有输入成功）3.退出回到命令号，点击键盘↑键，调出上一次命令，检查是否已经修改，会出现以下页面
- 4.查看如下，表示我们已经修改成功了输入:q退出当前文档。如果进文件查看，不小心修改了，是用:q!强制退出
- 重启网络服务以使配置生效。重启网卡服务：service network restart
主机映射：
- 远程连接虚拟机
- 首先，要先检查，vmware连接有没有问题，从Windows系统右下角网络图标进入网络连接页面
  
  如果VMnet1或者VMnet8不见了，需要到虚拟机的编辑->虚拟网络编辑器，先更改设置，再还原默认设置注意，IP是前面设定的，如我设定的是192.168.228.5，帐号写root，端口号22，那么填入信息如下：
- 编辑虚拟机上的/etc/hosts文件，添加其他虚拟机的IP地址和主机名。（简单理解，给机器起一个名字。一般在集群当中，都是通过配置主机名来和其他节点通信，所以需要改下机器的名字。命令：hostnamectl set-hostname master）
- 在Windows主机的C:\Windows\System32\drivers\etc\hosts文件中也进行相应的配置，以便从Windows主机访问虚拟机。在网络中，可以通过IP通信，因此，在集群中，如果想要通过主机名通信，则还要设置IP来与之对应，类似于域名要绑定IP。
  使用vi命令编辑/etc/hosts文件，添加以下内容：
  
  192.168.121.3 master
  
  192.168.121.4 slave1
  
  192.168.121.5 slave2
  
  拓展：windows系统里更改hosts文件，使用域名访问本地虚拟机（注意，配置后，后续hadoop启动web端可以用主机映射字符串替代IP）在C:\Windows\System32\drivers\etc修改hosts文件
  
  注意，有些电脑无法修改hosts文件，一个解决方法：1.复制一份hosts文件到桌面，并修改
- 2.把桌面的hosts文件剪切回etc文件夹里
- 3.删除etc文件夹里的hosts文件
- hosts文件里，添加我们的虚拟机IP和对应的域名，可在Windows系统里使用域名访问IP
- hosts文件里，添加我们的虚拟机IP和对应的域名，可在Windows系统里使用域名访问IP

九、安装JDK

下载JDK安装包：
- 从Oracle官网或其他可信来源下载适合你的Linux版本的JDK安装包。
安装JDK：
- 使用命令，java -version，检查原本系统自带jdk（如果有，这里是有的情况，要完成第二步）
- 将JDK安装包上传到虚拟机。在每台机器上安装 JDK，并配置好环境变量，如在/etc/profile文件中添加以下内容，：
```
export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
export CLASSPATH=.:$CLASSPATH:$JAVA_HOME/lib:$JAVA_HOME/jre/lib
export PATH=$PATH:$JAVA_HOME/bin:$JAVA_HOME/jre/bin
```
  执行source /etc/profile使配置生效。
- 创建工作目录：在每台机器上创建统一的工作目录，如/export/server/用于软件安装、/export/data/用于数据存储、/export/software/用于存放安装包
- 上传并解压 Hadoop 安装包：在主节点（如 node1）将下载好的 Hadoop 安装包上传到/export/software/目录，然后解压到/export/server/目录
```
export HADOOP_HOME=/export/server/hadoop-3.3.6
export PATH=$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$PATH
```
  执行source ~/.bashrc使配置生效。
- 配置环境变量，将JAVA_HOME设置为JDK的安装目录，并将JDK的bin目录添加到PATH中。在/etc/profile.d下创建一个my_env.sh，进行配置JAVA环境变量，命令：vi /etc/profile.d/my_env.sh（新文件）
  重新启动profile，命令：source /etc/profile
- 或者使用
验证安装：
- 使用java -version和javac -version命令验证JDK是否安装成功。

十、安装Hadoop

下载Hadoop安装包：
- 从Apache Hadoop官网下载Hadoop安装包。
安装Hadoop：
- 将Hadoop安装包上传到虚拟机。
- 解压安装包，并将其移动到适当的目录（如/usr/local/hadoop）。
  使用cd命令进入文件所在路径，再解压安装，命令：tar -xzvf hadoop-3.1.3.tar.gz -C /usr/local 注意：最后是解压到/usr/local，不是解压到本文件夹
  配置环境变量，同JAVA，在/etc/profile.d修改my_env.sh
  使用cd命令，进入/usr/local/hadoop-3.1.3/etc/hadoop，配置vi hadoop-env.sh，在末尾加上2句，如图
  重启profile，命令：source /etc/profile，使用命令hadoop version检查是否安装成功
  进入到相应文件路径，cd /usr/local/hadoop-3.1.3
- 注：建议创建test文件夹：mkdir test，并从Windows系统拖拽上传test.txt文件（后续词频统计使用）
配置Hadoop：
- 编辑Hadoop的配置文件（如core-site.xml、hdfs-site.xml、yarn-site.xml和mapred-site.xml），设置集群的相关参数。不过建议编辑~/.bashrc文件，添加以下内容：
```
export HADOOP_HOME=/export/server/hadoop-3.3.6
export PATH=$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$PATH
```
  执行source ~/.bashrc使配置生效
- 配置Hadoop的环境变量，以便在命令行中直接运行Hadoop命令。一定要注意，配置文件在两处地方：分别是（1）~（8）在/usr/local/hadoop-3.1.3/etc/hadoop和（9）~（10）在/usr/local/hadoop-3.1.3/sbin/ 进入hadoop文件路径，并查看：cd /usr/local/hadoop-3.1.3/etc/hadoop
  core-site.xml：配置 HDFS 的默认存储目录等信息，示例如下：
```
<configuration>
    <property>
        <name>fs.defaultFS</name>
        <value>hdfs://node1:9000</value>
    </property>
</configuration>
```

core-site.xml：进入/usr/local/hadoop-3.1.3/etc/hadoop/，修改core-site.xml文件，添加以下部分，注意，以下的master都是自己的主机名称（回顾：使用hostname查看自己的主机名称）

<name>fs.defaultFS</name>

<value>hdfs://master:8020</value>

</property>

<name>hadoop.tmp.dir</name>

<value>/var/log/hadoop/tmp</value>

</property>

</configuration>

hdfs-site.xml：配置 namenode 和 datanode 的存储路径、数据块副本数等，示例如下：

<configuration>
    <property>
        <name>dfs.replication</name>
        <value>2</value>
    </property>
    <property>
        <name>dfs.namenode.name.dir</name>
        <value>file:///export/data/namenode</value>
    </property>
    <property>
        <name>dfs.datanode.data.dir</name>
        <value>file:///export/data/datanode</value>
    </property>
</configuration>

yarn-site.xml：配置 YARN 的资源调度器等信息，示例如下：

<configuration>
    <property>
        <name>yarn.resourcemanager.hostname</name>
        <value>node1</value>
    </property>
    <property>
        <name>yarn.nodemanager.aux-services</name>
        <value>mapreduce_shuffle</value>
    </property>
</configuration>

mapred-site.xml：配置 MapReduce 运行模式为 YARN，示例如下：

<configuration>
    <property>
        <name>mapreduce.framework.name</name>
        <value>yarn</value>
    </property>
</configuration>

workers：在该文件中添加从节点的主机名或 IP 地址，每行一个，如：

plaintext

node2
node3

十一、配置SSH免密登录

生成SSH密钥对：
- 在每个虚拟机上运行ssh-keygen命令，生成SSH密钥对。假设我们现在需要把master的/usr/local/hadoop-3.1.3/test/路径下的aa.txt文件（Windows上传、或者mkdir aa文件夹、或者echo “hello,world”>aa.txt、或者vi命令都可以）分发给slave1的里，同样是放到路径/usr/local/hadoop-3.1.3/test/下，这里用到了scp命令进行数据传输：
- scp命令的使用：要使master虚拟机能够向slave1虚拟机传输文件，确实需要确保slave1上的SSH服务允许root用户登录，则需要配置好slave1的/etc/ssh/sshd_config文件，找到以下行，更改为PermitRootLogin yes
  输入：scp -r root@master:/usr/local/hadoop-3.1.3/test/aa.txt root@slave1:/usr/local/hadoop-3.1.3/test/，解析：
- root@master：发送端帐号（root）和主机名（master）
- /usr/local/hadoop-3.1.3/test/aa.txt：发送端master传输的文件的路径/usr/local/hadoop-3.1.3/test/：接收端slave1存放文件的路径。目前2种可能：
  
  在进行上述过程中，每次发起scp命令，都需要输入2次密码，整个过程会比较繁琐。
  
  下面我们来介绍SSH免密登录：想要在机器1上，远程控制机器2，常用的方案就是在机器1安装ssh客户端，机器2安装ssh服务端，ssh客户端和ssh服务端之间的通信协议是ssh协议。
  
  在linux系统中ssh命令，就是一个ssh客户端程序；sshd服务，就是一个ssh服务端程序。在windows中，给大家提供的mobaxterm是一个图形化界面的ssh客户端。ssh免密的登录说明见下图：
  
  在master主机里，先尝试ssh登录，命令：ssh slave1，现在需要输入密码登录。
  
  先从slave1退出，回到master主机里，使用exit或者logout命令
  
  在master主机里，使用ssh-keygen产生公钥与私钥对，命令：ssh-keygen -t rsa（执行命令后，对弹出提示连续按3次回车键）。对于master免密登录slave1、slave2时，只需要使用命令ssh-keygen -t rsa生成一次密钥对
  
  进入home目录，用命令：ll -al查看隐藏文件，能看到隐藏文件.ssh。
  
  进入.ssh文件夹，再使用ll命令查看文件，其中，id_rsa是私钥，is_rsa.pub是公钥。
  
  在master主机，使用命令ssh-copy-id slave1将公钥复制到slave1中，期间需要输入slave1密码，然后使用ssh命令登录slave1，成功无密登录过程如下：
  
  切换到slave1主机，进入/root/.ssh路径，用cat命令查看授权文件，当最后显示的是root/master时候，表示master主机已授权：最后使用exit退出slave1，回到mster主机
  
  同理，重复（6）（7）对slave2进行免密设置。最后，在master也给自己也发放公钥，命令：ssh-copy-id master（为后续启动集群做准备）
分发公钥：
- 使用ssh-copy-id命令将公钥分发到其他虚拟机上，以实现SSH免密登录。可以在主节点（node1）执行以下命令生成 SSH 密钥对1 ：
```
ssh-keygen -t rsa
```

一路回车默认即可，然后将公钥复制到其他节点：

ssh-copy-id node1
ssh-copy-id node2
ssh-copy-id node3

十二、启动Hadoop集群

格式化HDFS：
- 在NameNode虚拟机上运行hdfs namenode -format命令，格式化HDFS。前置工作：在master里，修改/etc/ssh/sshd_config文件，把注释了在文件去掉# （1）PermitRootLogin yes
- （2）PubkeyAuthentication yes
- （3）PasswordAuthentication yes
- 使用命令hdfs namenode -format初始化集群（注意只开一次，需要重新开启见7.查漏补缺（2））
- 常见的报错，如下，配置文件未写正确，会提示出错在某路径下的文件的某行某列：
  
  出现 Storage directory /data/hadoop/hdfs/name has been successfully formatted.表示格式化NameNode成功，如下图所示：
- 或者：在主节点（namenode）上执行以下命令格式化 HDFS ：
```
hdfs namenode -format
```
进入Hadoop安装目录：cd $HADOOP_HOME，分别使用以下语句启动集群：使用命令sbin/start-dfs.sh，开启HDFS sbin/start-dfs.sh出现如下权限问题时候，在master用ssh-copy-id master命令。

重新执行命令sbin/start-dfs.sh，结果如下表示成功。
使用命令sbin/start-yarn.sh，开启yarn

最后，在master、slave1、slave2使用jps查看，显示下图，说明Hadoop集群启动成功。
或者启动 HDFS 和 YARN 服务：
```
start-dfs.sh
start-yarn.sh
```
启动Hadoop守护进程：
- 在NameNode虚拟机上启动NameNode守护进程。
- 在DataNode虚拟机上启动DataNode守护进程。
- 在ResourceManager虚拟机上启动ResourceManager守护进程。
- 在NodeManager虚拟机上启动NodeManager守护进程。
- 检查运行状态：在主节点上执行jps命令，查看启动的进程，应该包含NameNode、DataNode、ResourceManager、NodeManager等
验证集群状态：
- 使用Hadoop提供的Web界面（如NameNode的50070端口和ResourceManager的8088端口）验证集群的状态。或者通过 Web UI 访问 HDFS 的界面http://node1:9870，可以查看 HDFS 的相关信息，如文件系统的状态、节点信息。
关闭集群：仍然需要进入cd $HADOOP_HOME关闭集群命令：
使用命令sbin/stop-yarn.sh
使用命令sbin/stop-dfs.sh
注意，重新开机后要重新启动Hadoop集群。
或者分组件关闭：关闭 HDFS，使用一下代码
```
$HADOOP_HOME/sbin/stop-dfs.sh
```

注：该命令会停止 Hadoop 分布式文件系统，关闭 NameNode 和所有的 DataNode 进程。

2.关闭 YARN

$HADOOP_HOME/sbin/stop-yarn.sh

此命令用于停止 YARN 资源管理器，释放集群中的计算资源，关闭 ResourceManager 和所有的 NodeManager 进程。

3.还有1种方法通过 jps 命令手动关闭：首先使用jps命令查看当前运行的 Java 进程，找到 Hadoop 的相关进程 ID 后，再使用kill命令手动关闭：

jps
kill <进程ID>

例如，如果通过jps命令查看到 NameNode 的进程 ID 是 1234，则可以使用kill 1234来关闭 NameNode 进程。不过，这种方式需要准确识别每个 Hadoop 组件的进程 ID，操作相对较为繁琐，且容易误杀进程，一般不建议在生产环境中使用，除非是在特殊情况下对单个组件进行调试或紧急处理。

十三、注意事项

防火墙设置：
- 确保虚拟机的防火墙设置允许Hadoop集群的通信。
- 防火墙实质是一个程序，它可以控制系统进来或者出去的流量。Centos7默认情况下，防火墙是开机自启的。在集群部署模式下，各个节点之间的进程要通信，为了方便，一般都要关闭防火墙。
  
  那又如何关闭呢？首先：查看防火墙状态，命令：systemctl status firewalld
  
  当前active（running）表示防火墙在启动状态
- 关闭防火墙，命令：systemctl stop firewalld
  
  当前inactive（dead）表示已经关闭防火墙了
- 当然防火墙相当于最后的保障一般来说开机会自行运行，如何查看防火墙是否开机自启，命令：systemctl is-enabled firewall
- denabled：表示开机自启
- disabled：表示开机不自启
  
  禁止防火墙开机自启，命令：systemctl disable firewalld
SELinux设置：
- 在某些Linux发行版上，SELinux可能会阻止Hadoop的正常运行。需要将其设置为禁用或配置为允许Hadoop运行。
时区设置：
- 确保所有虚拟机的时区设置一致，以避免时间同步问题。可以使用命令：ntpq -c version进行版本查看，如果自带安装时间同步服务，则跳到第（2）步，如下图显示：
  如果没有，则使用命令安装yum install -y ntp，如果yum install -y ntp命令报错，则需要完成以下一系列操作：vi /etc/yum/pluginconf.d/fastestmirror.conf
  vi /etc/yum.conf
  从mobaxterm左上路径栏进入/etc/yum.repos.d/路径，备份并修改CentOS-Base.repo文件备份CentOS-Base.repo文件，备份成功后，刷新左边的目录会多出一个叫做CentOS-Base.repo.bak新文件，命令：cp /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.bak（双击打不开！）右键CentOS-Base.repo文件，用默认文本编辑器修改此文件
  
  将原本内容替换成以下内容：
  [base]
  
  name=CentOS-$releasever - Base
  
  baseurl=https://mirrors.aliyun.com/centos/$releasever/os/$basearch/
  
  gpgcheck=1
  
  gpgkey=https://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7
  
  [updates]
  
  name=CentOS-$releasever - Updates
  
  baseurl=https://mirrors.aliyun.com/centos/$releasever/updates/$basearch/
  
  gpgcheck=1
  
  gpgkey=https://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7
  
  [extras]
  
  name=CentOS-$releasever - Extras
  
  baseurl=https://mirrors.aliyun.com/centos/$releasever/extras/$basearch/
  
  gpgcheck=1
  
  gpgkey=https://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7
  
  [centosplus]
  
  name=CentOS-$releasever - Plus
  
  baseurl=https://mirrors.aliyun.com/centos/$releasever/centosplus/$basearch/
  
  gpgcheck=1
  
  enabled=0
  
  gpgkey=https://mirrors.aliyun.com/centos/RPM-GPG-KEY-CentOS-7 然后重新执行以下命令（如果成功，则如下图所示），命令：yum makecache
  
  再次使用yum命令安装ntp（如下图安装过程），命令：yum install -y ntp
  
  检验是否成功：ntpq -c version
  
  master主机，修改vi /etc/ntp.conf文件，用#注释掉server行，并添加以下代码：
- restrict 192.168.0.0 mask 255.255.255.0 nomodify notrap
- server 127.127.1.0
- fudge 127.127.1.0 stratum 10
  
  同理，修改slave1、slave2的/etc/ntp.conf文件，需要从master使用scp命令进行文件发放
  
  scp -r root@master:/etc/yum/pluginconf.d/fastestmirror.conf root@slave1:/etc/yum/pluginconf.d/
  
  scp -r root@master:/etc/yum/pluginconf.d/fastestmirror.conf root@slave2:/etc/yum/pluginconf.d/
  
  scp -r root@master:/etc/yum.conf root@slave1:/etc/
  
  scp -r root@master:/etc/yum.conf root@slave2:/etc/
  
  scp -r root@master:/etc/yum.repos.d/CentOS-Base.repo root@slave1:/etc/yum.repos.d
  
  scp -r root@master:/etc/yum.repos.d/CentOS-Base.repo root@slave2:/etc/yum.repos.d
  
  在slave1：yum makecache，yum install -y ntp，ntpq -c version
  
  在slave2：yum makecache，yum install -y ntp，ntpq -c version
  
  scp -r root@master:/etc/ntp.conf root@slave1:/etc/ scp -r root@master:/etc/ntp.conf root@slave2:/etc/ 在master使用：systemctl start ntpd、systemctl enable ntpd启动服务、systemctl status ntpd查看服务状态
  
  在slave1、slave2使用命令ntpdate master同步时间
  
  在slave1、slave2使用命令systemctl start ntpd、systemctl enable ntpd启动服务、systemctl status ntpd查看服务状态，出现类似标蓝和下划线部分中的状态。
- 若已经安装了ntp服务也可以修改ntp.conf配置文件：
```
vi /etc/ntp.conf
```
  将以下内容：
  
  plaintext
```
#restrict 192.168.1.0 mask 255.255.255.0 nomodify notrap
server 0.centos.pool.ntp.org iburst
server 1.centos.pool.ntp.org iburst
server 2.centos.pool.ntp.org iburst
server 3.centos.pool.ntp.org iburst
```
  修改为：
  
  plaintext
```
restrict 192.168.1.0 mask 255.255.255.0 nomodify notrap
#server 0.centos.pool.ntp.org iburst
#server 1.centos.pool.ntp.org iburst
#server 2.centos.pool.ntp.org iburst
#server 3.centos.pool.ntp.org iburst
server 127.127.1.0 fudge 127.127.1.0 stratum 10
```
  其中，192.168.1.0 mask 255.255.255.0需根据实际网段进行修改，上述配置表示授权该网段内的机器从本时间服务器查询和同步时间，并将本机的本地时钟作为时间供给源，即便失去网络连接，也可继续为网络提供服务。
- 修改/etc/sysconfig/ntpd文件bash
```
vim /etc/sysconfig/ntpd
```
  增加SYNC_HWCLOCK=yes，使硬件时间与系统时间同步。
- 重启ntpd服务并设置开机自启动：
```
service ntpd restart
chkconfig ntpd on
```
- 还可以其他机器配置： 1. 关闭所有节点上的ntp服务和自启动：
  
  bash
```
sudo systemctl stop ntpd
sudo systemctl disable ntpd
```
  2.配置定时任务，让其他机器每隔一定时间与时间服务器同步一次，以每隔 1 分钟同步一次为例，执行以下命令编辑定时任务：
  
  bash
```
sudo crontab -e
```
  编写如下定时任务：
  
  plaintext
```
*/1 * * * * /usr/sbin/ntpdate hadoop01
```
  其中，hadoop01需替换为实际的时间服务器主机名或 IP 地址。
  
  完成上述配置后，Hadoop 集群中的各节点将按照设定的时间间隔与时间服务器进行时间同步，从而保证集群中各节点时间的一致性，避免因时间差异导致的集群执行任务时间不同步等问题。
资源分配：
- 根据实际需求为虚拟机分配足够的资源（如CPU、内存和磁盘空间）。
备份和恢复：
- 定期备份Hadoop集群的数据和配置文件，以便在需要时进行恢复。

由于实际图文操作的复杂性，以上步骤主要以文字描述为主。如果你需要具体的图文教程，建议查阅Hadoop的官方文档或相关的在线教程网站。

十四 .以下是我对Hadoop的理解所做的思维导图：

1.Hadoop大数据开发基础

2.Hadoop集群的搭建及配置概念

然后这是我平常做练习的代码

1、master、slave1、slave2使用jps查看进程截图

python

import paramiko

# 定义节点信息
nodes = {
    "master": "root@master",
    "slave1": "root@slave1",
    "slave2": "root@slave2"
}

# 执行jps命令的函数
def execute_jps(node):
    try:
        username, hostname = node.split('@')
        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        ssh.connect(hostname, username=username)
        stdin, stdout, stderr = ssh.exec_command("jps")
        result = stdout.read().decode()
        ssh.close()
        return result
    except Exception as e:
        print(f"Error connecting to {node}: {str(e)}")
        return ""

# 遍历节点并执行jps命令
for node_name, node in nodes.items():
    print(f"[{node} - # jps]")
    print(execute_jps(node))

这个脚本使用paramiko库来通过 SSH 连接到远程节点并执行jps命令。你需要确保在运行脚本的机器上已经安装了paramiko库。如果没有安装，可以通过以下命令安装：

bash

pip install paramiko

以下是脚本的工作原理：

首先定义了一个nodes字典，包含了master、slave1和slave2节点的登录信息（这里假设用户名为root，你可能需要根据实际情况修改）。
然后定义了一个execute_jps函数，该函数接受一个节点信息（格式为user@host），通过 SSH 连接到该节点，执行jps命令，并返回结果。
最后遍历nodes字典，对每个节点调用execute_jps函数，并打印出节点信息和jps命令的结果。

请注意：

确保你的本地机器可以通过 SSH 连接到master、slave1和slave2节点，并且具有相应的权限。
根据实际情况修改节点的登录用户名和主机名。

2、web端查看2个监控截图

以下是一个简单的 MapReduce 示例代码（使用 Python 和 Hadoop Streaming），包括Map、Reduce和Driver程序。这个示例是计算文本文件中每个单词的出现次数。mapper.py（Map 程序）

python

#!/usr/bin/env python

import sys

for line in sys.stdin:
    words = line.strip().split()
    for word in words:
        print("%s\t1" % (word))

reducer.py（Reduce 程序）

python

#!/usr/bin/env python

import sys

current_word = None
current_count = 0
word = None

for line in sys.stdin:
    line = line.strip()
    word, count = line.split("\t", 1)
    count = int(count)

    if current_word == word:
        current_count += count
    else:
        if current_word:
            print("%s\t%s" % (current_word, current_count))
        current_count = count
        current_word = word

if current_word == word:
    print("%s\t%s" % (current_word, current_count))

driver.sh（Driver 程序）

bash

#!/bin/bash

# 设置Hadoop路径
HADOOP_HOME=/path/to/your/hadoop

# 输入文件路径
INPUT_FILE=/input/path/input.txt
# 输出文件路径
OUTPUT_FILE=/output/path

# 执行MapReduce任务
$HADOOP_HOME/bin/hadoop jar $HADOOP_HOME/share/hadoop/tools/lib/hadoop - streaming - 2.7.7.jar \
    - input $INPUT_FILE \
    - output $OUTPUT_FILE \
    - mapper mapper.py \
    - reducer reducer.py \
    - file mapper.py \
    - file reducer.py

请注意：

上述代码中的/path/to/your/hadoop需要替换为你实际的 Hadoop 安装路径。
/input/path/input.txt需要替换为你的输入文件路径。
/output/path需要替换为你想要保存输出结果的路径。

这只是一个简单的示例，实际的 MapReduce 应用场景可能会更加复杂，但是基本的结构和逻辑是相似的。运行这些程序后，driver.sh脚本会调用 Hadoop 的Streaming来执行mapper.py和reducer.py，并将计算结果保存在指定的输出路径下。

至于计算结果，在运行driver.sh脚本后，可以在OUTPUT_FILE指定的目录下找到输出文件，文件内容即为每个单词及其出现次数的记录。例如：

plaintext

apple    5
banana   3

表示单词apple出现了 5 次，单词banana出现了 3 次。

十五、HBase分布式数据库

以下是HBase的介绍

HBase 在 Hadoop 生态系统中的定位
- HBase 是一个分布式、面向列的开源数据库，构建在 Hadoop 的 HDFS 之上。它提供了对大量结构化数据的随机、实时读写访问。HBase 利用了 Hadoop 的分布式文件系统（HDFS）来存储数据，并依赖于 ZooKeeper 进行集群的协调和配置管理。

HBase 的主要组件和相关定义

表（Table）：HBase 中的数据存储在表中。表由行和列组成，类似于关系型数据库中的表，但 HBase 表是稀疏的、多维度的、分布式的。
行键（Row Key）：每行都有一个唯一的行键。数据按照行键的字典序存储。行键用于快速查找和访问数据。
列族（Column Family）：表中的列被分组为列族。列族在表创建时定义，并且在运行时不能轻易更改。列族是 HBase 中数据存储和访问的基本单元。
列限定符（Column Qualifier）：在列族内，可以有多个列限定符。列由列族和列限定符组成，格式为<列族>:<列限定符>。
单元格（Cell）：由行、列和版本号确定的一个数据存储单元，每个单元格存储一个数据版本。

HBase 的架构相关代码示例：创建 HBase 表的 Java 代码示例（使用 HBase Java API）：

java

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.TableDescriptor;
import org.apache.hadoop.hbase.client.TableDescriptorBuilder;
import java.io.IOException;

public class HBaseTableCreation {
    public static void main(String[] args) {
        Configuration config = HBaseConfiguration.create();
        try (Connection connection = ConnectionFactory.createConnection(config);
             Admin admin = connection.getAdmin()) {
            TableName tableName = TableName.valueOf("mytable");
            if (!admin.tableExists(tableName)) {
                TableDescriptor tableDescriptor = TableDescriptorBuilder.newBuilder(tableName)
                       .setColumnFamily(ColumnFamilyDescriptorBuilder.of("cf1"))
                       .build();
                admin.createTable(tableDescriptor);
                System.out.println("Table created successfully.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

向 HBase 表中插入数据的 Java 代码示例：

java

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;

public class HBaseDataInsertion {
    public static void main(String[] args) {
        Configuration config = HBaseConfiguration.create();
        try (Connection connection = ConnectionFactory.createConnection(config);
             Table table = connection.getTable(TableName.valueOf("mytable"))) {
            Put put = new Put(Bytes.toBytes("row1"));
            put.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("col1"), Bytes.toBytes("value1"));
            table.put(put);
            System.out.println("Data inserted successfully.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

HBase 与 Hadoop 其他组件的集成
- HBase 依赖于 Hadoop 的 HDFS 来存储数据，确保数据的可靠性和可扩展性。
- HBase 使用 ZooKeeper 来管理集群的状态信息，如服务器的上线和下线、元数据的存储等。
- HBase 可以与 MapReduce 集成，用于批量数据处理。例如，可以使用 MapReduce 来对 HBase 中的数据进行分析和处理。

十六、HDFS分布式文件系统

HDFS的本质

HDFS的中文翻译是Hadoop分布式文件系统（Hadoop Distributed File System）。它本质还是程序，主要还是以树状目录结构来管理文件（和linux类似，/表示根路径），且可以运行在多个节点上（即分布式）。

HDFS（Hadoop Distributed File System）是Hadoop项目的核心组件之一，它是一个高度容错性的系统，设计用来在廉价的硬件上部署。

HDFS解决了核心问题：在普通硬件上高效、可靠地存储和访问超大规模的数据集，为大数据应用提供底层的分布式存储服务。

HDFS的架构

HDFS遵循主从架构（Master/Slave），主要由一个NameNode和多个DataNode组成。这种架构使得HDFS能够跨多台计算机存储和处理文件，实现分布式存储和计算。

在紧急情况下，可以辅助恢复NameNode

管理HDFS的命名空间
配置副本策略
管理数据块Blocks的映射信息
处理客户端读写请求
存储和管理元数据
DataNode，即是slave们：
- master下达命令，DataNode执行操作
- 存储实际的数据块
- 执行数据块的读/写操作
- 定期向NameNode发送心跳信号，报告自己的状态和数据块的情况。
Client，客户端（等同于命令hdfs dfs -ls /）：
- 文件切分。文件上传HDFS时，Client将文件切分成一个个Block后上传
- 与NameNode交互，获取文件的位置信息
- 与DataNode交互，读取或写入数据
- Client提供一些命令来管理HDFS，如NameNode格式化hdfs namenode -formate
- Client通过一些命令来访问HDFS，如HDFS增删改查操作
Secondary NameNode：
- 辅助NameNode，分单其工作量，如定期合并FsImage（文件系统镜像）和Edits（编辑日志），并推送给NameNode
  1. FsImage：包含了文件系统在某个时间点的所有状态信息
  2. Edits：记录了所有对文件系统的修改操作，如创建、删除文件或目录等

以下是一个简单的 Java 代码示例，用于在 Hadoop HDFS 中创建目录和上传文件：

java

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

public class HDFSOperations {
    public static void main(String[] args) {
        String hdfsUri = "hdfs://localhost:9000";
        Configuration conf = new Configuration();
        try {
            FileSystem fs = FileSystem.get(new URI(hdfsUri), conf, "your-username");

            // 创建目录
            Path dirPath = new Path("/testDir");
            if (!fs.exists(dirPath)) {
                boolean result = fs.mkdirs(dirPath);
                if (result) {
                    System.out.println("Directory created successfully.");
                } else {
                    System.out.println("Failed to create directory.");
                }
            }

            // 上传文件
            Path localPath = new Path("localFile.txt");
            Path hdfsPath = new Path("/testDir/localFile.txt");
            fs.copyFromLocalFile(localPath, hdfsPath);
            System.out.println("File uploaded successfully.");

            fs.close();
        } catch (IOException | URISyntaxException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这段代码实现了以下功能：

配置 Hadoop 文件系统（HDFS）的连接信息。
创建一个FileSystem对象来与 HDFS 进行交互。
在 HDFS 中创建一个名为/testDir的目录（如果该目录不存在）。
从本地文件系统上传一个名为localFile.txt的文件到 HDFS 中的/testDir目录下。

请注意：

你需要将hdfsUri中的地址替换为你实际的 HDFS 地址。
your - username需要替换为你的实际用户名。
确保localFile.txt文件存在于本地文件系统中。

十七、MapReduce分布式计算框架

MapReduce概述

定义：MapReduce是一个分布式运算程序的编程框架，其核心功能是将用户编写的业务逻辑代码和自带的默认组件整合成一个完整的分布式运算程序，并发运行在一个Hadoop集群上。

一个基本完整的MapReduce程序流程，包括：数据分片-数据映射-数据混洗-数据归约-数据输出

一个MapReduce例子：对以下左侧“输入”数据进行词频统计，输出结果如右侧“输出”所示

1. 1. Map阶段处理过程
  2. 对于输入文件进行键值对组合，即切割出每个单词，并发配初始频数1。
  3. 如，Hello组成<Hello , 1>，其中，Hello是键；1是键值

1. 1. Shuffle
    1. 将键相同的键值进行汇集
    2. 如，3个<Hello,1>组成了<Hello,<1,1,1>>

1. 1. Reduce阶段过程
    1. 根据实际应用进行结果计算
    2. 如，对<Hello,<1,1,1>>的键值进行汇总计算，1+1+1=3，的到结果Hello 3

以下是一个简单的 WordCount（词频统计）的 MapReduce 程序示例，使用 Java 语言编写：

1. Mapper 类

java

import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

public class WordCountMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

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

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        String line = value.toString();
        String[] words = line.split(" ");
        for (String w : words) {
            word.set(w);
            context.write(word, one);
        }
    }
}

2. Reducer 类

java

import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class WordCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {

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

3. Driver 类

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.lib.input.FileInputPath;
import org.apache.hadoop.mapreduce.lib.output.FileOutputPath;

public class WordCountDriver {

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf, "word count");
        job.setJarByClass(WordCountDriver.class);
        job.setMapperClass(WordCountMapper.class);
        job.setReducerClass(WordCountReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);
        FileInputPath.addInputPath(job, new Path(args[0]));
        FileOutputPath.setOutputPath(job, new Path(args[1]));
        System.exit(job.waitForCompletion(true)? 0 : 1);
    }
}

这个程序实现了一个简单的词频统计功能。在Mapper类中，将输入的文本行拆分成单词，并为每个单词发射一个<单词, 1>的键值对。在Reducer类中，将相同单词的计数值进行累加，最终输出<单词, 总数>的键值对。Driver类则用于配置和启动 MapReduce 作业。

请注意：

这个程序需要在 Hadoop 环境下运行。
在运行时，需要指定输入路径和输出路径作为程序的参数，例如：hadoop jar WordCount.jar input_path output_path。

十八、HIVE数据仓库

1.hive基础知识

hive简介

hive是基于hadoop生态圈组件之一，它是一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供简单的sql查询功能，可以将sql语句转换为mapreduce任务进行运行。

hive的本质是将sql语句转换为mapreduce任务，使不熟悉java mapreduce开发人员也能编写数据查询程序。它定义了简单的类sql查询语言，称为hql，它允许熟悉sql的用户在hadoop上进行数据查询。同时，hive允许用户编写自己的map和reduce函数来处理内建函数无法处理的数据，扩展了hive的功能。

2.hive与传统数据库对比

对比内容	hive	传统数据库（mysql、oracle）
查询语言	hql	sql
数据存储	hdfs	本地文件系统
执行延迟	高	低
可拓展性	好	有限
处理数据规模	大	小

以下是一个简单的 Hive 操作示例，使用 HiveQL（类似于 SQL）在 Hive 中创建表、加载数据和查询数据：

1. 启动 Hive

在终端中输入以下命令启动 Hive：

bash

hive

2. 创建数据库（可选）

如果需要，可以先创建一个数据库：

sql

CREATE DATABASE mydb;
USE mydb;

3. 创建表

假设你有一个包含用户信息（姓名和年龄）的结构化数据文件（例如，userdata.txt），格式为name,age。在 Hive 中创建对应的表：

sql

CREATE TABLE users (
    name STRING,
    age INT
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ',';

4. 加载数据

将本地文件系统中的数据文件加载到 Hive 表中：

sql

LOAD DATA LOCAL INPATH '/path/to/userdata.txt' INTO TABLE users;

（注意：将/path/to/userdata.txt替换为实际的数据文件路径）

5. 查询数据

进行简单的数据查询，例如查询所有用户的信息：

sql

SELECT * FROM users;

或者查询年龄大于 30 岁的用户：

sql

SELECT * FROM users WHERE age > 30;

6. 使用自定义函数（UDF）扩展功能

如果你想编写自己的函数（例如，一个将年龄加 1 的函数），可以按照以下步骤：

6.1. 编写 UDF

使用 Java 编写自定义函数：

java

import org.apache.hadoop.hive.ql.exec.Description;
import org.apache.hadoop.hive.ql.exec.UDF;
import org.apache.hadoop.io.IntWritable;

@Description(name = "addOne", value = "_FUNC_(int) - Adds one to the input integer")
public class AddOneUDF extends UDF {
    public IntWritable evaluate(IntWritable age) {
        if (age == null) return null;
        return new IntWritable(age.get() + 1);
    }
}

6.2. 编译并添加到 Hive

编译 Java 代码：

bash

javac -classpath $(hive --auxpath) AddOneUDF.java

将编译后的类添加到 Hive：

sql

ADD JAR /path/to/AddOneUDF.jar;
CREATE TEMPORARY FUNCTION addOne AS 'AddOneUDF';

使用自定义函数查询：

sql

SELECT name, addOne(age) AS new_age FROM users;

以上代码展示了如何在 Hive 中进行基本的数据操作，包括表的创建、数据加载、查询以及通过自定义函数扩展功能。实际应用中，可以根据具体需求进一步扩展和优化这些操作。

三、总结

总结：这可能是一篇关于 Hadoop 大数据开发基础的文章或教程。Hadoop 是一个用于分布式存储和处理大数据的开源框架，它由 Apache 软件基金会开发。Hadoop 的核心包括 Hadoop 分布式文件系统（HDFS）和 MapReduce 编程模型。在大数据领域，Hadoop 扮演着至关重要的角色，帮助企业和组织处理海量数据，进行数据分析和挖掘等工作。文章可能会详细介绍 Hadoop 的架构、核心组件、开发环境搭建以及基本的开发流程等内容。