Hadoop大数据平台安装
实验一：Hadoop大数据平台安装
16281002 杜永坤
1、实验目的
在大数据时代，存在很多开源的分布式数据采集、计算、存储技术，本实验将熟悉并搭建几种常用的大数据采集、处理分析技术环境。
《大数据技术》实验一需要在笔记本上搭建 Hadoop
集群，实验报告根据教程对笔记本上创建虚拟机搭建 Hadoop
集群的步骤进行了说明。包含所有需要安装的软件与服务的版本，安装路径，安装方法等。主要流程为：安装虚拟机管理程序，创建三台虚拟服务器，在三台虚拟服务器上搭建以
Hadoop 集群为核心的大数据平台。
2、实验要求
实验要求搭建的大数据平台以 Hadoop 为核心，HDFS、MySQL、HBase
组成了存储系统，通过Kafka 实时接入数据，使用 Storm
对数据进行实时分析，Map/Reduce 和 Spark 负责离线数据分析。Zookeeper
负责为分布式应用程序协调服务。
3、实验环境说明
个人笔记本电脑，虚拟机Oracle VM VirtualBox
5.1.26，CentOS-7-x86_64-Minimal-1810.ios，win10系统
Oracle VM VirtualBox 5.1.26
下载链接https://download.virtualbox.org/virtualbox/5.1.26/
CentOS-7-x86_64-Minimal-1810.ios下载链接
https://mirrors.aliyun.com/centos/7/isos/x86_64/
个人笔记本电脑内存要求大于等于8GB，要同时开启三个虚拟机，对内存的性能要求比较高。本人使用win10系统，但是Oracle
VM VirtualBox
5.1.26有不同系统版本的，可以在其他系统上搭建，建议win10系统，更稳定。
实验步骤还是根据教程进行，但是对教程上的有些步骤是比价笼统的，对于我们新手，还是有理解难度的，实验报告将教程笼统的部分进行细节化，这样更便于理解。每一安装步骤之后，进行测试后，均有测试结果的截图。
4、准备实验环境
4.1、安装Oracle VM VirtualBox 5.1.26
根据操作提示进行默认安装即可，如果不想装在C盘，在安装时候进行修改安装路径即可。
设置Oracle VM VirtualBox
点击管理→全局设定→网络→ NAT网络 点击 添加图标 按钮 ，默认出现NatNetwork
然后双击NatNetwork，进行如下的设置，设置完点击OK即可
选择 仅主机 (Host-Only)网络 然后点击 添加图标 按钮
，如果弹出窗口，点击确定即可
*** 双击新建的网卡，进行如下设置:IPv4地址： 192.168.56.1->IPv4网络掩码：
255.255.255.0->DHCP服务器 ->取消勾选“启用服务器” ->OK->点 OK保存 ***
4.2、配置虚拟机硬件环境
打开Oracle VM VirtualBox 5.1.26，点击 新建 进行新建虚拟机
要注意的就是 类型 选择 linux 版本选择red hat (64.bit)
点击下一步，设置内存大小，建议设置2048Mb，也就是2Gb，这样下载安装包，或者安装软件的时候速度回大大加快。但是这就需要笔记本电脑的内存至少需要8Gb，最好是16Gb。
下一步选择VHD（虚拟硬盘）然后选择动态分配
然后设置虚拟机的位置，建议不要放到C盘，虚拟硬盘大小设置为8GB即可，点击文件夹图标即可选择虚拟机的路径：
然后点击按钮 创建 即可
创建成功后大概显示如下信息:
上面仅仅是搭建了虚拟机的硬件环境，下面要安装虚拟机
4.3、安装虚拟机
选中刚刚创建的cluster，点击 设置
图标→存储 ->没有盘片 ->右侧的
光盘图标，选择下载好的CentOS-7-x86_64-Minimal-1810.iso
选择好镜像之后，点击OK即可，会显示如下信息：
再次点击 设置 图标 →网络 ->网卡 1->启用网络连接 ->连接方式
->NAT->界面名称 ->选择刚才 先建立的那块虚拟网卡 即可 ->网卡 2->启用网络连接
->连接方式 连接方式 ->仅主机 (Host-Only)网络 ->界面名称
->选择刚才后建立的那块虚拟网卡 -> OK。
下面双击cluster 进入虚拟机装载程序 选择 Install CentOS 7
等待加载完毕之后进行如下设置：
- English->continue。
- DATE&TIME，Region选择 Asia，City选择 Shanghai，左上角 ，左上角 Done。
- INSTALLATION DESTINATION，点进去后直接左上角的 Done。
- NETWORK & HOST NAME，两张网卡 右侧 都选择 ON，下面的 Host name改为
cluster1，然后进行左上角 Done。
- 选择右下角 选择右下角 选择右下角 Begin installation。
- 进入安装界面后选择 root password 随意 。
- 右侧 user creation，Full name 设置为 cluster1，密码随意，不要选择 make
this user administrator。 - 待下方进度条结束后，会有 reboot这个选项，点击重启 后，即可登陆。
- 后续从 *** 2、配置虚拟机硬件环境*** 开始再做两台这样的虚拟机分别是
cluster2和 cluster3即可。
4.4、下载所需的安装包
我将所有的安装包都放到了百度网盘里：
链接：https://pan.baidu.com/s/1tak5_8D3JfreBZYwFCLPyA 提取码：lr3u
所有的版本号都为教程的版本对应。
4.5、centos系统指令预习
至此所有需要的环境都准备成功，下面就是CentOS系统上的操作，在下面的操作中，首先要有linux命令的基础，如果对linux命令不熟悉，建议遇到陌生的命令时，先去查看命令的功能，再执行命令。
linux指令
1、明确用户的概念
在实验中使用了root用户，和hadoop，在cluster2上进行了mysql的用户创建。root用户是具有特权一类用户，在root用户下可以操作只有特权才能操作的指令，比如vi
/etc/profile
指令，这指令是进行编辑(如果不熟悉vi操作指令，建议先去熟悉vi操作，比如怎么输入，怎么查找，怎么保存退出)
profile这个文件，这个文件是进行环境变量的设置，只有root特权才能对这个文件进行编辑保存操作，而其他用户只能有读取的权利，不能修改编辑。
所以具有root权限的文件普通用户hadoop是操作不了的，所以在进行创建文件夹或则文件的时候，要看清是通过什么用户进行创建的。如果是root用户创建的文件，只有root特权才能进行写操作，如果没有操作好用户权限，在后面的操作会出现权限错误。
切换用户：su 指令
su root
切换到root用户，但是要输入root用户的密码，也就是在进行root password
操作时输入密码入安装界面后选择 root password 随意
。输入成功后会出现如下的符号（这个 #符号就代表root用户，有root权限）：
su hadoop
切换到hadoop用户，切换成功后会出现如下的符号
$表示是普通用户
所以在进行操作指令的时候看清指令前的符号，是否一致，如果不一致，建议直接通过
su hadoop 或者su root 手动切换，不建议使用exit 命令
2、熟悉基本的操作指令
例如 tar 解压操作；
cd 切换目录操作
操作指令时，要看清指令操作的目录，比如操作流程中经常有 切换到/usr/local
这个操作提示，就是要执行 cd /usr/local 切换成功后会出现下面的提示：
同理其他提示也要按照上面的指令进行切换目录。
ls 查看当前目录文件
yum install **** 安装软件包操作
vi 编辑指令
vi /etc/profile 会进入编辑文件界面，这个时候要输入 i 才能进行编辑
会出现INSERT提示，才能进行编辑
编辑完成后，先按ESC键，然后键入英文字符 :
，会出现光标闪烁，在输入wq，回车，回到终端，wq的vi命令表示的是先保存再退出。
cp 复制命令
cp mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz /usr/local/
这个命令的意思是将mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz压缩包复制到文件夹/usr/local/下，指令cp前，要确保当前目录存在mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz这个压缩包，才回执行成功，否则会出现找不到文件或者路径的错误
source /etc/profile
这个指令要在执行vi /etc/profile 退出编辑之后，每执行一次vi
/etc/profile，就要执行一次这个指令一次，而且要切换到hadoop用户中执行
上面最重要的指令就是cd
指令，在教程中，如果出现这个指令，一定要执行，然后再进行后面的指令，不能先执行后面的指令，再回来执行cd指令，而且如果没有直接给出cd
指令，而是要求切换到某目录，也要执行cd指令，比如：
提示：解压到/usr/local ，所以一定要先执行cd /usr/local/
，然后再进行后面的tar解压指令。否则后面就会出现错误。
**** 最主要的还是要明白各个指令意义，然后再进行操作。****
5、CentOS系统安装hadoop大数据环境
上面的准备工作完成之后，下面就是进入CentOS系统开始hadoop大数据环境的平台搭建
5.1关闭防火墙和selinux
本实验采用的阿里镜像网站的CentOS镜像，不是最小版，所以要将防火墙和selinux进行关闭，防止防火墙阻止某些操作。下面的操作cluster1cluster2cluster3都要进行执行：
// 关闭防火墙和 关闭防火墙和 关闭防火墙和 selinux# systemctl stop firewalld.service
// 禁止 firewall 开机启动 开机启动# systemctl disable firewalld.service
// 开机关闭 开机关闭 Selinux，编辑 ，编辑 Selinux配置文件 配置文件 配置文件# vi /etc/selinux/config
//将 SELINUX设置为 设置为 disabled
//如下 :
//SELINUX=disabled
// 重启# reboot
// 重启机器后 重启机器后 root用户查看 用户查看 用户查看 Selinux状态# getenforce
//执行getenforce结束之后会出现 Disabled 表示Selinux关闭成功。
5.2安装软件
以下软件是安装 时需要的依赖环境,MySQL时需要使用 perl和
libaio，ntpdate负责集群内服务器时间， screen用于新建后台任务。 每台都要执行
# yum install perl*# yum install ntpdate# yum install libaio# yum install screen
5.3检查网卡是否开机自启
每台都要执行
// 查看网卡名，看里面一个 enp0s
开头的是多少，由于我们开启了两块网卡，注意这两张都是什么名字
// 我的网卡名分别是 enp0s3 和 enp0s8，还有一个 lo,这个可以忽略不计。
# ip addr
使用这条命令可以查看所有网卡的信息，注意记录每张网卡的网卡名：前面序号后面的即为网卡名。还需记录每张网卡的
ip 地址，inet 后面的就是。
注意：此处有两张网卡，分别是 2：enp0s3 和
3:enp0s8，如果没有，可能是因为在安装系统的过程中，没有打开网络服务，或是网卡没有设定为开机自启。
接下来编辑网卡配置文件
编辑的第一个网卡的配置文件，应该是 ip 为 10.0.2 开头的那张网卡，网卡名为 enp0s3
// 编辑网卡配置文件
# vi /etc/sysconfig/network-scripts/ifcfg-enp0s3
// 确认 ONBOOT 为 yes，这个设置为 yes 后，该网卡会开机自启，不会开机连不上网
ONBOOT=yes
接下来编辑第二张网卡的配置文件，是 enp0s8
# vi /etc/sysconfig/network-scripts/ifcfg-enp0s8
将 BOOTPROTO 设置为 none ONBOOT=yes
新增 IPADDR=192.168.56.121（cluster2 设置为 192.168.56.122，cluster3 为
192.168.56.123）
NETMASK=255.255.255.0 NETWORK=192.168.56.0
保存后关闭文件。
// 重启网络服务
# service network restart
重启成功后会出现一个绿色的 OK，失败则显示红色的 failed，若失败，则使用 reboot
重启服务器即可。重启后，就可以使用 putty 或其他 SSH 工具连接虚拟机了。
以下以 putty 为例：
在 windows 中，下载 putty，打开后，输入
192.168.56.121，对应cluster1，想要连接cluster2,3进行ip地址的变换即可。
然后点击右下角的 Open，即可连接到 cluster1 上。连接上后：
输入root：
然后再输入密码，即可进入CentOS系统的终端：
由于CentOS是终端操作，没有用户界面，所以我们要传输文件时可以使用
winSCP文件传输软件，将安装包上传到系统中。
主机名为：192.168.56.121，用户名为 root，端口号为22，快速连接即可。
连接上，可以看到本地文件，和虚拟机的文件，可以选中本地文件将需要的文件拖曳到虚拟机部分，即可上传。
5.4修改 hosts
每台都要执行
// 记录当前 ip 地址，要记录第一张网卡的 ip 地址
# ip addr
// 修改 hosts
# vi /etc/hosts
// 在最下面添加以下几行内容，下面的红色的 ip 地址写你用 ip addr
里面显示的第一张网卡(enp0s3)的 ip
10.0.2.5 cluster1
10.0.2.6 cluster2
10.0.2.7 cluster3
5.6检查网络是否正常
// 在 cluster1 上
// 检查能否连接到 cluster2,3
# ping cluster2
# ping cluster3
如果出现如下界面：
可以看到 time=多少秒，说明可以从 cluster1 连接到 cluster2，同理，检查能否连接到
cluster3，使用 Ctrl+C
同理可以在cluster2上ping另外两台虚拟机的ip地址
5.6新建 hadoop 用户
每台都要执行
新建 hadoop 用户，这个用户专门用来维护集群，因为实际中使用 root
用户的机会很少，而且不安全。
// 新建 hadoop 组
# groupadd hadoop
// 新建 hadoop 用户
# useradd -s /bin/bash -g hadoop -d /home/hadoop -m hadoop
// 修改 hadoop 这个用户的密码
# passwd hadoop
5.7生成 ssh 密钥并分发
只在 cluster1 上执行
// 生成 ssh 密钥（cluster1 上），切换到 hadoop 用户
$ ssh-keygen -t rsa
然后一路回车
// 接下来分发密钥，请仔细观察显示的内容，会让你输入 yes
$ ssh-copy-id cluster1
$ ssh-copy-id cluster2
$ ssh-copy-id cluster3
5.8安装 NTP 服务
// 三台都要安装
# yum install ntpdate
// cluster1 上装 ntp
# yum install ntp
// cluster1 上执行以下操作
# vi /etc/ntp.conf
注释掉以下 4 行，也就是在这 4 行前面加
# 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
最下面加入以下内容，红色部分分别为网关和掩码
restrict default ignore
restrict 10.0.2.0 mask 255.255.255.0 nomodify notrap
server 127.127.1.0
// 重启 ntp 服务
# service ntpd restart
// 设置 ntp 服务器开机自动启动
# chkconfig ntpd on
// crontab是自启动服务， 以下为客户端的配置（除 cluster1 外其他所有的机器，即
cluster2 和 cluster3）：下面内容表示：设定每天 00:00
向服务器同步时间，并写入日志
如果没有安装crontab
# yum install crontabs //安装
# systemctl enable crond //设置开机启动crond服务
# systemctl start crond //启动crond服务
# crontab -e //编写
# crontab -e
输入以下内容后保存并退出：
0 0 * * * /usr/sbin/ntpdate cluster1>> /root/ntpd.log
//重启
# systemctl restart crond
// 如果不是使用上面的服务，就要手动同步时间，需要在每台机器上（除 cluster1
外其他所有的机器，即 cluster2 和 cluster3），使用 ntpdate cluster1 同步时间
# ntpdate cluster1
5.8安装 MySQL
MySQL 是最流行的关系型数据库管理系统，在 WEB 应用方面 MySQL 是最好的
RDBMS(Relational Database Management System：关系数据库管理系统)应用软件之一。
MySQL 为关系型数据库(Relational Database Management System),
这种所谓的"关系型"可以理解为"表格"的概念, 一个关系型数据库由一个或数个表格组成,
如图所示的一个表格:
- 表头(header): 每一列的名称;
- 列(col): 具有相同数据类型的数据的集合;
- 行(row): 每一行用来描述某条记录的具体信息;
- 值(value): 行的具体信息, 每个值必须与该列的数据类型相同;
- 键(key): 键的值在当前列中具有唯一性。
MySQL
是一种关联数据库管理系统，关联数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。 - MySQL 支持大型的数据库。可以处理拥有上千万条记录的大型数据库。
- MySQL 使用标准的 SQL 数据语言形式。
- MySQL 可以运行于多个系统上，并且支持多种语言。这些编程语言包括
C、C++、Python、Java、Perl、PHP、Eiffel、Ruby 和 Tcl 等。 - MySQL 对PHP有很好的支持，PHP 是目前最流行的 Web 开发语言。
- MySQL 支持大型数据库，支持 5000 万条记录的数据仓库，32
位系统表文件最大可支持 4GB，64 位系统支持最大的表文件为8TB。 - MySQL 是可以定制的，采用了 GPL 协议，你可以修改源码来开发自己的 MySQL 系统。
5.8.1安装
只在 cluster2 上做以下内容，因为我们的集群中，只有 cluster2 上需要安装一个 MySQL
# yum remove mysql mysql-server mysql-libs compat-mysql51
# rm -rf /var/lib/mysql
# rm -rf /etc/my.cnf
下载 mysql-5.6.37-linux-glibc2.12-x86_64
# cp mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz /usr/local/
// 解压到/usr/local/
# tar -zxvf mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz
// 改名为 mysql
# mv mysql-5.6.37-linux-glibc2.12-x86_64 mysql
// 删除安装包
# rm mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz
// 修改环境变量
# vi /etc/profile
在最下面添加
export MYSQL_HOME=/usr/local/mysql
export PATH=$MYSQL_HOME/bin:$PATH
// 刷新环境变量
# source /etc/profile
// 新建 mysql 用户
# groupadd mysql 在/etc/group 中可以看到
# useradd -r -g mysql -s /bin/false mysql 在/etc/passwd 中可以看到
# cd /usr/local/mysql
# chown -R mysql:mysql .
# scripts/mysql_install_db --user=mysql
// 修改当前目录拥有者为 root 用户
# chown -R root .
// 修改当前 data 目录拥有者为 mysql 用户
# chown -R mysql data
# bin/mysqld_safe --user=mysql &
# cd /usr/local/mysql
// 登陆 mysql
# bin/mysql
// 登陆成功后退出即可
mysql> exit;
// 进行 root 账户密码的修改等操作
# bin/mysql_secure_installation
首先要求输入 root 密码，由于我们没有设置过 root 密码，括号里面说了，如果没有
root 密码就直接按回车。是否设定 root 密码，选 y，设定密码为
cluster，是否移除匿名用户：y。然后有个是否关闭 root 账户的远程登录，选 n，删除
test 这个数据库？y，更新权限？y，然后 ok。
# cp support-files/mysql.server /etc/init.d/mysql.server
// 查看 mysql 的进程号
# ps -ef | grep mysql
// 如果有的话就 kill 掉，保证 mysql 已经中断运行了，一般 kill
掉/usr/local/mysql/bin/mysqld 开头的即可
# kill 进程号
// 启动 mysql
# /etc/init.d/mysql.server start -user=mysql
# exit
还需要配置一下访问权限：
$ mysql -u root -p
mysql> GRANT ALL PRIVILEGES ON *.* TO ‘root’@’%’ IDENTIFIED BY ‘cluster’
WITH GRANT OPTION; mysql> FLUSH PRIVILEGES;
// 关闭 mysql 的指令（不需要执行）
# mysqladmin -u root -p shutdown
5.8.1测试
mysql> create database test_table; mysql> use test_table;
mysql> create table userinfo(id int not null); mysql> insert into userinfo
values(1); mysql> select * from userinfo;
mysql> drop database test_table; mysql> show databases;
如果mysql关闭后想要在此启动，需要进行如下操作：
\# /etc/init.d/mysql.server start -user=mysql
# su root
$ mysql -u root -p
这样才能正常启动mysql。
5.8安装 JDK
5.8.1安装
每台都要安装
$ su root
# cp jdk-7u80-linux-x64.tar.gz /usr/local/
# tar -zxvf jdk-7u80-linux-x64.tar.gz
// 修改环境变量
# vi /etc/profile
// 添加以下内容
export JAVA_HOME=/usr/local/jdk1.7.0_80/
export JRE_HOME=/usr/local/jdk1.7.0_80/jre
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
export PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$JAVA_HOME:$PATH
// 复制 jdk 到其他的服务器上
# scp -r /usr/local/jdk1.7.0_80/ cluster2:/usr/local/
# scp -r /usr/local/jdk1.7.0_80/ cluster3:/usr/local/
// cluster2 上
# vi /etc/profile
// 添加以下内容
export JAVA_HOME=/usr/local/jdk1.7.0_80/
export JRE_HOME=/usr/local/jdk1.7.0_80/jre
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
export PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$JAVA_HOME:$PATH
// cluster3 上
# vi /etc/profile
// 添加以下内容
export JAVA_HOME=/usr/local/jdk1.7.0_80/
export JRE_HOME=/usr/local//jdk1.7.0_80/jre
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
export PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$JAVA_HOME:$PATH
//然后再每台机器上更新配置文件
$ source /etc/profile
5.8.2测试
$ java -version
可以看到 java 版本为 1.7.0_80 即为安装成功
5.9安装 ZooKeeper
ZooKeeper是一种分布式协调服务，用于管理大型主机。在分布式环境中协调和管理服务是一个复杂的过程。ZooKeeper通过其简单的架构和API解决了这个问题。ZooKeeper允许开发人员专注于核心应用程序逻辑，而不必担心应用程序的分布式特性。
ZooKeeper框架最初是在“Yahoo!"上构建的，用于以简单而稳健的方式访问他们的应用程序。
后来，Apache ZooKeeper成为Hadoop，HBase和其他分布式框架使用的有组织服务的标准。
例如，Apache HBase使用ZooKeeper跟踪分布式数据的状态。
在进一步深入之前，我们了解关于分布式应用的一两件事情是很重要的。因此，让我们开始分布式应用的概述的快速讨论。
分布式应用
分布式应用可以在给定时间（同时）在网络中的多个系统上运行，通过协调它们以快速有效的方式完成特定任务。通常来说，对于复杂而耗时的任务，非分布式应用（运行在单个系统中）需要几个小时才能完成，而分布式应用通过使用所有系统涉及的计算能力可以在几分钟内完成。
通过将分布式应用配置为在更多系统上运行，可以进一步减少完成任务的时间。分布式应用正在运行的一组系统称为集群，而在集群中运行的每台机器被称为节点。
分布式应用有两部分， Server（服务器） 和 Client（客户端）
应用程序。服务器应用程序实际上是分布式的，并具有通用接口，以便客户端可以连接到集群中的任何服务器并获得相同的结果。
客户端应用程序是与分布式应用进行交互的工具。
分布式应用的优点
可靠性 - 单个或几个系统的故障不会使整个系统出现故障。
可扩展性 -
可以在需要时增加性能，通过添加更多机器，在应用程序配置中进行微小的更改，而不会有停机时间。
透明性 - 隐藏系统的复杂性，并将其显示为单个实体/应用程序。
什么是Apache ZooKeeper？
Apache
ZooKeeper是由集群（节点组）使用的一种服务，用于在自身之间协调，并通过稳健的同步技术维护共享数据。ZooKeeper本身是一个分布式应用程序，为写入分布式应用程序提供服务。
ZooKeeper提供的常见服务如下 :
- 命名服务 - 按名称标识集群中的节点。它类似于DNS，但仅对于节点。
- 配置管理 - 加入节点的最近的和最新的系统配置信息。
- 集群管理 - 实时地在集群和节点状态中加入/离开节点。
- 选举算法 - 选举一个节点作为协调目的的leader。
- 锁定和同步服务 -
在修改数据的同时锁定数据。此机制可帮助你在连接其他分布式应用程序（如Apache
HBase）时进行自动故障恢复。 - 高度可靠的数据注册表 - 即使在一个或几个节点关闭时也可以获得数据。
分布式应用程序提供了很多好处，但它们也抛出了一些复杂和难以解决的挑战。ZooKeeper框架提供了一个完整的机制来克服所有的挑战。竞争条件和死锁使用故障安全同步方法进行处理。另一个主要缺点是数据的不一致性，ZooKeeper使用原子性解析。
以下是使用ZooKeeper的好处： - 简单的分布式协调过程
- 同步 - 服务器进程之间的相互排斥和协作。此过程有助于Apache
HBase进行配置管理。 - 有序的消息
- 序列化 -
根据特定规则对数据进行编码。确保应用程序运行一致。这种方法可以在MapReduce中用来协调队列以执行运行的线程。 - 可靠性
- 原子性 - 数据转移完全成功或完全失败，但没有事务是部分的。
每台都要安装
5.9.1 cluster1
// cluster1 上
将 zookeeper 解压到/usr/local 目录下，配置环境变量
# vi /etc/profile
// 添加以下内容
export ZOOKEEPER_HOME=/usr/local/zookeeper-3.4.6
export PATH=$ZOOKEEPER_HOME/bin:$PATH
# cd /usr/local/zookeeper-3.4.6
// 在 conf 中新建 zoo.cfg 文件
# vi conf/zoo.cfg
// 输入以下内容
# 客户端心跳时间(毫秒)
tickTime=2000
# 允许心跳间隔的最大时间
initLimit=10
# 同步时限
syncLimit=5
# 数据存储目录
dataDir=/home/hadoop_files/hadoop_data/zookeeper
# 数据日志存储目录
dataLogDir=/home/hadoop_files/hadoop_logs/zookeeper/dataLog
# 端口号
clientPort=2181
# 集群节点和服务端口配置
server.1=cluster1:2888:3888 server.2=cluster2:2888:3888
server.3=cluster3:2888:3888
// 创建 zookeeper 的数据存储目录和日志存储目录
# mkdir -p /home/hadoop_files/hadoop_data/zookeeper
# mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/dataLog
# mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/logs
// 修改文件夹的权限
# chown -R hadoop:hadoop /home/hadoop_files
# chown -R hadoop:hadoop /usr/local/zookeeper-3.4.6
// 在 cluster1 号服务器的 data 目录中创建一个文件 myid，输入内容为 1
// myid 应与 zoo.cfg 中的集群节点相匹配
# echo “1” >> /home/hadoop_files/hadoop_data/zookeeper/myid
// 修改 zookeeper 的日志输出路径(注意 CDH 版与原生版配置文件不同)
# vi bin/zkEnv.sh
// 将配置文件里面的以下项替换为红字的内容
if [ “x${ZOO_LOG_DIR}” = “x” ]
then
ZOO_LOG_DIR="/home/hadoop_files/hadoop_logs/zookeeper/logs"
fi
if [ “x${ZOO_LOG4J_PROP}” = “x” ]
then
ZOO_LOG4J_PROP=“INFO,ROLLINGFILE”
fi
// 修改 zookeeper 的日志配置文件
# vi conf/log4j.properties
// 修改为以下内容：
zookeeper.root.logger=INFO,ROLLINGFILE
log4j.appender.ROLLINGFILE=org.apache.log4j.DailyRollingFileAppender
将这个 zookeeper-3.4.6 的目录复制到其他的两个节点上
# scp -r /usr/local/zookeeper-3.4.6 cluster2:/usr/local/
# scp -r /usr/local/zookeeper-3.4.6 cluster3:/usr/local/
// 退回 hadoop 用户
# exit
// 刷新环境变量
$ source /etc/profile
// 启动 zookeeper
$ zkServer.sh start
5.9.2 cluster2
// cluster2 上面 改环境变量，加入以下内容
export ZOOKEEPER_HOME=/usr/local/zookeeper-3.4.6
export PATH=$ZOOKEEPER_HOME/bin:$PATH
// 创建 zookeeper 的数据存储目录和日志存储目录
$ su root
# mkdir -p /home/hadoop_files/hadoop_data/zookeeper
# mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/dataLog
# mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/logs
// 添加 myid
# echo “2” >> /home/hadoop_files/hadoop_data/zookeeper/myid
// 修改文件夹的权限
# chown -R hadoop:hadoop /home/hadoop_files
# chown -R hadoop:hadoop /usr/local/zookeeper-3.4.6
// 退回 hadoop 用户
# exit
// 刷新环境变量
$ source /etc/profile
// 启动 zookeeper
$ zkServer.sh start
5.9.3cluster3
// cluster3 上面 加环境变量
# vi /etc/profile
export ZOOKEEPER_HOME=/usr/local/zookeeper-3.4.6
export PATH=$ZOOKEEPER_HOME/bin:$PATH
// 创建 zookeeper 的数据存储目录和日志存储目录
# mkdir -p /home/hadoop_files/hadoop_data/zookeeper
# mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/dataLog
# mkdir -p /home/hadoop_files/hadoop_logs/zookeeper/logs
// 添加 myid
# echo “3” >> /home/hadoop_files/hadoop_data/zookeeper/myid
// 修改文件夹的权限
# chown -R hadoop:hadoop /home/hadoop_files
# chown -R hadoop:hadoop /usr/local/zookeeper-3.4.6
// 退回 hadoop 用户
# exit
// 刷新环境变量
$ source /etc/profile
// 启动 zookeeper（每台都要执行，而且三台要接连执行，都启动后再做下面的）
$ zkServer.sh start
5.9.4测试
// 三台 zookeeper 都启动后，使用 jps 命令查看进程是否启动
# jps
可以看到一个叫 QuorumPeerMain 的进程，说明 zookeeper 启动成功
// 退出 root 用户
# exit
// 查看 zookeeper 状态
$ zkServer.sh status
可以看到三台中有一个是 leader，两个是 follower
// 关闭 zookeeper 的命令 （关机前在每台上都要执行，这里不需要执行）
$ zkServer.sh stop
5.10安装 Kafka
Apache Kafka® 是 一个分布式流处理平台. 这到底意味着什么呢?
我们知道流处理平台有以下三种特性:
可以让发布和订阅流式的记录。这一方面与消息队列或者企业消息系统类似。
可以储存流式的记录，并且有较好的容错性。
可以在流式记录产生时就进行处理。
Kafka可以用于两大类别的应用:
构造实时流数据管道，它可以在系统或应用之间可靠地获取数据。 (相当于message queue)
构建实时流式应用程序，对这些流数据进行转换或者影响。 (就是流处理，通过kafka
stream topic和topic之间内部进行变化)
为了理解Kafka是如何做到以上所说的功能，从下面开始，我们将深入探索Kafka的特性。.
概念:
Kafka作为一个集群，运行在一台或者多台服务器上.
Kafka 通过 topic 对存储的流数据进行分类。
每条记录中包含一个key，一个value和一个timestamp（时间戳）。
Kafka有四个核心的API:
The Producer API 允许一个应用程序发布一串流式的数据到一个或者多个Kafka topic。
The Consumer API 允许一个应用程序订阅一个或多个 topic
，并且对发布给他们的流式数据进行处理。
The Streams API
允许一个应用程序作为一个流处理器，消费一个或者多个topic产生的输入流，然后生产一个输出流到一个或多个topic中去，在输入输出流中进行有效的转换。
The Connector API 允许构建并运行可重用的生产者或者消费者，将Kafka
topics连接到已存在的应用程序或者数据系统。比如，连接到一个关系型数据库，捕捉表（table）的所有变更内容。
5.10.1 cluster1 上
kafka_2.10-0.8.2.1 解压到/usr/local
//添加环境变量
# vi /etc/profile
export KAFKA_HOME=/usr/local/kafka_2.10-0.8.2.1
export PATH=$KAFKA_HOME/bin:$PATH
// 修改配置文件
# vi /usr/local/kafka_2.10-0.8.2.1/config/server.properties
// 修改下面 3 项
// 第一项：这个值要唯一，不同的机器不能相同，cluster1 就写 1，cluster2 就写
2，cluster3 就写 3 broker.id=1
// 第二项：修改日志路径
log.dirs=/home/hadoop_files/hadoop_logs/kafka
// 第三项：此处要写 zookeeper 集群的
ip+端口号，逗号隔开zookeeper.connect=cluster1:2181,cluster2:2181,cluster3:2181
// 第四项：此处要写对应机器的 ip 地址！
advertised.host.name=192.168.56.121
//修改完环境变量，更新配置文件
$ source /etc/profile
// 保存退出后创建 logs 文件夹
# mkdir -p /home/hadoop_files/hadoop_logs/kafka
// 修改权限
# chown -R hadoop:hadoop /home/hadoop_files
# chown -R hadoop:hadoop /usr/local/kafka_2.10-0.8.2.1
// 复制文件夹
# scp -r /usr/local/kafka_2.10-0.8.2.1 cluster2:/usr/local/
# scp -r /usr/local/kafka_2.10-0.8.2.1 cluster3:/usr/local/
5.10.2cluster2 上
# vi /etc/profile
export KAFKA_HOME=/usr/local/kafka_2.10-0.8.2.1
export PATH=$KAFKA_HOME/bin:$PATH
//修改完环境变量，更新配置文件
$ source /etc/profile
# vi /usr/local/kafka_2.10-0.8.2.1/config/server.properties
修改
broker.id=2
advertised.host.name=192.168.56.122
// 保存退出后创建 logs 文件夹
# mkdir -p /home/hadoop_files/hadoop_logs/kafka
// 修改权限
# chown -R hadoop:hadoop /home/hadoop_files
# chown -R hadoop:hadoop /usr/local/kafka_2.10-0.8.2.1
5.10.3 cluster3 上
# vi /etc/profile
export KAFKA_HOME=/usr/local/kafka_2.10-0.8.2.1
export PATH=$KAFKA_HOME/bin:$PATH
//修改完环境变量，更新配置文件
$ source /etc/profile
# vi /usr/local/kafka_2.10-0.8.2.1/config/server.properties
修改
broker.id=3
advertised.host.name=192.168.56.123
// 保存退出后创建 logs 文件夹
# mkdir -p /home/hadoop_files/hadoop_logs/kafka
// 修改权限
# chown -R hadoop:hadoop /home/hadoop_files
# chown -R hadoop:hadoop /usr/local/kafka_2.10-0.8.2.1
5.10.4使用 hadoop 用户启动 kafka 集群
先启动 zookeeper 集群，然后在 kafka 集群中的每个节点使用
$ kafka-server-start.sh /usr/local/kafka_2.10-0.8.2.1/config/server.properties
&
启动完成后按回车即可
5.10.5测试
在cluster1上创建topic
Kafka的核心概念:提供一串流式的记录— topic 。
Topic
就是数据主题，是数据记录发布的地方,可以用来区分业务系统。Kafka中的Topics总是多订阅者模式，一个topic可以拥有一个或者多个消费者来订阅它的数据。
对于每一个topic， Kafka集群都会维持一个分区日志，如下所示：
每个分区都是有序且顺序不可变的记录集，并且不断地追加到结构化的commit
log文件。分区中的每一个记录都会分配一个id号来表示顺序，我们称之为offset，offset用来唯一的标识分区中每一条记录。
Kafka
集群保留所有发布的记录—无论他们是否已被消费—并通过一个可配置的参数——保留期限来控制.
举个例子，
如果保留策略设置为2天，一条记录发布后两天内，可以随时被消费，两天过后这条记录会被抛弃并释放磁盘空间。Kafka的性能和数据大小无关，所以长时间存储数据没有什么问题.
事实上，在每一个消费者中唯一保存的元数据是offset（偏移量）即消费在log中的位置.偏移量由消费者所控制:通常在读取记录后，消费者会以线性的方式增加偏移量，但是实际上，由于这个位置由消费者控制，所以消费者可以采用任何顺序来消费记录。例如，一个消费者可以重置到一个旧的偏移量，从而重新处理过去的数据；也可以跳过最近的记录，从"现在"开始消费。
这些细节说明Kafka
消费者是非常廉价的—消费者的增加和减少，对集群或者其他消费者没有多大的影响。比如，你可以使用命令行工具，对一些topic内容执行
tail操作，并不会影响已存在的消费者消费数据。
日志中的
partition（分区）有以下几个用途。第一，当日志大小超过了单台服务器的限制，允许日志进行扩展。每个单独的分区都必须受限于主机的文件限制，不过一个主题可能有多个分区，因此可以处理无限量的数据。第二，可以作为并行的单元集—关于这一点，更多细节如下
分布式
日志的分区partition
（分布）在Kafka集群的服务器上。每个服务器在处理数据和请求时，共享这些分区。每一个分区都会在已配置的服务器上进行备份，确保容错性.
每个分区都有一台 server 作为 “leader”，零台或者多台server作为 follwers 。leader
server 处理一切对 partition
（分区）的读写请求，而follwers只需被动的同步leader上的数据。当leader宕机了，followers
中的一台服务器会自动成为新的 leader。每台 server 都会成为某些分区的 leader
和某些分区的 follower，因此集群的负载是平衡的。
生产者
生产者可以将数据发布到所选择的topic（主题）中。生产者负责将记录分配到topic的哪一个
partition（分区）中。可以使用循环的方式来简单地实现负载均衡，也可以根据某些语义分区函数(例如：记录中的key)来完成。下面会介绍更多关于分区的使用。
消费者
消费者使用一个 消费组
名称来进行标识，发布到topic中的每条记录被分配给订阅消费组中的一个消费者实例.消费者实例可以分布在多个进程中或者多个机器上。
如果所有的消费者实例在同一消费组中，消息记录会负载平衡到每一个消费者实例.
如果所有的消费者实例在不同的消费组中，每条消息记录会广播到所有的消费者进程.
如图，这个 Kafka 集群有两台 server
的，四个分区(p0-p3)和两个消费者组。消费组A有两个消费者，消费组B有四个消费者。
通常情况下，每个 topic
都会有一些消费组，一个消费组对应一个"逻辑订阅者"。一个消费组由许多消费者实例组成，便于扩展和容错。这就是发布和订阅的概念，只不过订阅者是一组消费者而不是单个的进程。
在Kafka中实现消费的方式是将日志中的分区划分到每一个消费者实例上，以便在任何时间，每个实例都是分区唯一的消费者。维护消费组中的消费关系由Kafka协议动态处理。如果新的实例加入组，他们将从组中其他成员处接管一些
partition 分区;如果一个实例消失，拥有的分区将被分发到剩余的实例。
Kafka 只保证分区内的记录是有序的，而不保证主题中不同分区的顺序。每个 partition
分区按照key值排序足以满足大多数应用程序的需求。但如果你需要总记录在所有记录的上面，可使用仅有一个分区的主题来实现，这意味着每个消费者组只有一个消费者进程。
// 创建 topic
$ kafka-topics.sh --create --zookeeper
cluster1:2181,cluster2:2181,cluster3:2181 --replication-factor 3 --partitions 1
–topic mykafka
// 查看 Topic：
$ kafka-topics.sh --list --zookeeper cluster1:2181,cluster2:2181,cluster3:2181
此时会显示 Topic：mykafka
// 查看详细信息
$ kafka-topics.sh --describe --zookeeper
cluster1:2181,cluster2:2181,cluster3:2181 Topic:mykafka PartitionCount:1
ReplicationFactor:3Configs:
Topic: mykafka Partition: 0 Leader: 133 Replicas: 133,134,132 Isr: 134
// 发送消息(cluster1 上执行)
$ kafka-console-producer.sh --broker-list localhost:9092 --topic mykafka
// 接收消息（cluster2 上执行）
$ kafka-console-consumer.sh -zookeeper
cluster1:2181,cluster2:2181,cluster3:2181 --topic mykafka --from- beginning
// 在 cluster1 输入以下内容
test mycluster test
可以在 cluster2 上看到相应的信息按 Ctrl+C 退出
// 关闭 kafka，在每台上执行
$ kafka-server-stop.sh
//新建虚拟窗口 kafka，在每台上执行
$ screen -S kafka
// 启动 kafka 集群，在每台上执行
$ kafka-server-start.sh /usr/local/kafka_2.10-0.8.2.1/config/server.properties
// 退出虚拟窗口 kafka，在每台上执行
$ Ctrl+A+D
在每台服务器上面执行 jps 可以看到 Kafka 进程在运行
// 关闭 kafka 的命令为，在每台服务器上进入虚拟窗口 kafka，然后使用
kafka-server-stop.sh 即可。
5.11安装 Hadoop
Hadoop 是一个由 Apache
基金会所开发的分布式系统基础架构，它可以使用户在不了解分布式底层细节的情況下开发分布式程序，充分利用集群的威力进行高速运算和存储。从其定义就可以发现，它解決了两大问题：大数据存储、大数据分析。
Hadoop 2.X 项目包含以下模块
Hadoop Common：为 Hadoop 其他模块提供支持的基础模块。
HDFS：Hadoop：分布式文件系统。
YARN：任务分配和集群资源管理框架。
MapReduce：并行和可扩展的用于处理大数据的模式。
Hadoop 是一个能够让用户轻松架构和使用的分布式计算的平台。用户可以轻松地在 Hadoop
发和运行处理海量数据的应用程序。其优点主要有以下几个：
(1) 高可靠性 ： Hadoop 按位存储和处理数据的能力值得人们信赖。
(2) 高扩展性 ： Hadoop
是在可用的计算机集簇间分配数据并完成计算任务的，这些集簇可以方便地扩展到数以干计的节点中。
(3) 高效性 ：
Hadoop能够在节点之间动态地移动数据，并保证各个节点的动态平衡，因此处理速度非常快。
(4) 高容错性 ：
Hadoop能够自动保存数据的多个副本，并且能够自动将失败的任务重新分。
(5) 低成本 ： 与一体机、商用数据仓库以及 QlikView、 Yonghong Z- Suites
等数据集市相比，Hadoop 是开源的，项目的软件成本因此会大大降低。
Hadoop 带有用 Java 语言编写的框架，因此运行在 linux 生产平台上是非常理想的，
Hadoop 上的应用程序也可以使用其他语言编写，比如 C++。
5.11.1cluster1
Hadoop 启动的先决条件是 zookeeper 已经成功启动
// 在 cluster1 节点/usr/local/解压 hadoop 安装包
$ su root
# tar -zxvf hadoop-2.6.5.tar.gz
// 删除安装包
# rm hadoop-2.6.5.tar.gz
// 切换到存有 hadoop 配置文件的目录
# cd /usr/local/hadoop-2.6.5/etc/hadoop
// 修改 hadoop-env.sh 文件
# vi hadoop-env.sh
修改如下内容：
export JAVA_HOME=/usr/local/jdk1.7.0_80
export HADOOP_PID_DIR=/home/hadoop_files
// 配置 mapred-env.sh
# vi mapred-env.sh
export HADOOP_MAPRED_PID_DIR=/home/hadoop_files
// 配置 core-site.xml 文件
# vi core-site.xml
<configuration>
<!-- 指定 hdfs 的 nameservices 名称为 mycluster，与 hdfs-site.xml 的 HA
配置相同 -->
<property>
<name>fs.defaultFS</name>
<value>hdfs://cluster1:9000</value>
</property>
<!-- 指定缓存文件存储的路径 -->
<property>
<name>hadoop.tmp.dir</name>
<value>/home/hadoop_files/hadoop_tmp/hadoop/data/tmp</value>
</property>
<!-- 配置 hdfs 文件被永久删除前保留的时间（单位：分钟），默认值为 0
表明垃圾回收站功能关闭 -->
<property>
<name>fs.trash.interval</name>
<value>1440</value>
</property>
<!-- 指定 zookeeper 地址，配置 HA 时需要 -->
<property>
<name>ha.zookeeper.quorum</name>
<value>cluster1:2181,cluster2:2181,cluster3:2181</value>
</property>
</configuration>
// 配置 hdfs-site.xml 文件
# vi hdfs-site.xml
<configuration>
<!-- 指定 hdfs 元数据存储的路径 -->
<property>
<name>dfs.namenode.name.dir</name>
<value>/home/hadoop_files/hadoop_data/hadoop/namenode</value>
</property>
<!-- 指定 hdfs 数据存储的路径 -->
<property>
<name>dfs.datanode.data.dir</name>
<value>/home/hadoop_files/hadoop_data/hadoop/datanode</value>
</property>
<property>
<name>dfs.secondary.http.address</name>
<value>cluster1:50090</value>
</property>
<!-- 数据备份的个数 -->
<property>
<name>dfs.replication</name>
<value>3</value>
</property>
<!-- 关闭权限验证 -->
<property>
<name>dfs.permissions.enabled</name>
<value>false</value>
</property>
<!-- 开启 WebHDFS 功能（基于 REST 的接口服务） -->
<property>
<name>dfs.webhdfs.enabled</name>
<value>true</value>
</property>
</configuration>
// 配置 mapred-site.xml 文件
# vi mapred-site.xml
<configuration>
<!-- 指定 MapReduce 计算框架使用 YARN -->
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
<!-- 指定 jobhistory server 的 rpc 地址 -->
<property>
<name>mapreduce.jobhistory.address</name>
<value>cluster1:10020</value>
</property>
<!-- 指定 jobhistory server 的 http 地址 -->
<property>
<name>mapreduce.jobhistory.webapp.address</name>
<value>cluster1:19888</value>
</property>
</configuration>
// 配置 yarn-site.xml 文件
# vi yarn-site.xml
<configuration>
<!-- NodeManager 上运行的附属服务，需配置成 mapreduce_shuffle 才可运行
MapReduce 程序 -->
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
<!-- 配置 Web Application Proxy 安全代理（防止 yarn 被攻击） -->
<property>
<name>yarn.web-proxy.address</name>
<value>cluster2:8888</value>
</property>
<!-- 开启日志 -->
<property>
<name>yarn.log-aggregation-enable</name>
<value>true</value>
</property>
<!-- 配置日志删除时间为 7 天，-1 为禁用，单位为秒 -->
<property>
<name>yarn.log-aggregation.retain-seconds</name>
<value>604800</value>
</property>
<!-- 修改日志目录 -->
<property>
<name>yarn.nodemanager.remote-app-log-dir</name>
<value>/home/hadoop_files/hadoop_logs/yarn</value>
</property>
<property>
<name>yarn.resourcemanager.address</name>
<value>cluster1:8032</value>
</property>
<property>
<name>yarn.resourcemanager.scheduler.address</name>
<value>cluster1:8030</value>
</property>
<property>
<name>yarn.resourcemanager.resource-tracker.address</name>
<value>cluster1:8031</value>
</property>
</configuration>
// 配置 slaves 文件
# vi slaves
删 除 localhost 添加以下内容：
cluster1
cluster2
cluster3
// 创建配置文件中涉及的目录(在所有结点上)
# mkdir -p /home/hadoop_files/hadoop_data/hadoop/namenode
# mkdir -p /home/hadoop_files/hadoop_data/hadoop/datanode
# mkdir -p /home/hadoop_files/hadoop_tmp/hadoop/data/tmp
# mkdir -p /home/hadoop_files/hadoop_logs/yarn
// 修改文件夹权限（在所有结点上）
# chown -R hadoop:hadoop /home/hadoop_files/
# chown -R hadoop:hadoop /usr/local/hadoop-2.6.5/
// 将 cluster1 的 hadoop 工作目录同步到集群其它节点
$ scp -r /usr/local/hadoop-2.6.5 cluster2:/usr/local/
$ scp -r /usr/local/hadoop-2.6.5 cluster3:/usr/local/
5.11.2所有节点上
// 修改文件夹权限（在所有结点上）
# chown -R hadoop:hadoop /usr/local/hadoop-2.6.5/
// 在集群各节点上修改环境变量
# vi /etc/profile
export HADOOP_HOME=/usr/local/hadoop-2.6.5
export LD_LIBRARY_PATH=$HADOOP_HOME/lib/native
export PATH=$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$PATH
// 使修改的环境变量生效
$ source /etc/profile
// 启动 zookeeper 集群（分别在 cluster1, cluster2 和 cluster3 上执行）
$ zkServer.sh start
接下来开始格式化：
// 启动 journalnode（在所有 datanode 上执行，也就是 cluster1, cluster2,
cluster3）
$ hadoop-daemon.sh start journalnode
启动后使用 jps 命令可以看到 JournalNode 进程
5.11.3测试
// 格式化 HDFS（在 cluster1 上执行）
$ hdfs namenode -format
// 格式化完毕后可关闭 journalnode（在cluster1,2,3上执行）
$ hadoop-daemon.sh stop journalnode
// 启动 HDFS（cluster1 上）
$ start-dfs.sh
// 启动后 cluster1 上使用 jps 可以看到 NameNode, DataNode, SecondaryNameNode
cluster2 和 cluster3 上可以看到 DataNode
$ jps
// 启动 YARN（cluster1 上）
$ start-yarn.sh
// 启动后 cluster1 上使用 jps 可以看到 NodeManager, ResourceManager
cluster2 和 cluster3 上可以看到 NodeManager
$ jps
// 以下两条命令是关闭 YARN 和 HDFS
的命令，重启服务器或关机前一定要执行，否则有可能导致数据或服务损坏
// 关闭 YARN 的命令（cluster1 上）
$ stop-yarn.sh
// 关闭 HDFS 的命令（cluster1 上）
$ stop-dfs.sh
测试结果：
启动 HDFS 后，可以在本地的浏览器中，打开 192.168.56.121:50070，可以看到 HDFS 的
web 界面
第一页 Overview 是当前 HDFS 的概况，里面显示了 HDFS
的启动时间，版本等信息。点击上面标签栏的第二项 Datanodes，可以看到如下界面
这个页面显示了当前 HDFS 中的可用节点。
启动 YARN 后，可以通过浏览器访问 192.168.56.121:8088，查看 YARN 的 web 界面
该页面展示了所有提交到 YARN 上的程序，点击左侧的 Nodes 可以看到 YARN 的节点
注意，此处可以看到每个节点的可用内存 Mem Avail 为 8G，我们的虚拟机每台内存只有
1.5G，之所以出现这个问题是因为我们没有在 yarn-site.xml
这个文件中对节点的可用内存进行配置，可以增加一下内容进行配置：
<!-- 配置 nodemanager 可用的资源内存 -->
<property>
<name>yarn.nodemanager.resource.memory-mb</name>
<value>20480</value>
</property>
<!-- 配置 nodemanager 可用的资源 CPU -->
<property>
<name>yarn.nodemanager.resource.cpu-vcores</name>
<value>24</value>
</property>
由于我们的虚拟机没有那么大的内存空间以及 CPU
资源，所以我们暂时不设置这两个参数，在后续实验中，
需要同学们设置这个参数以达到集群性能的最大化。
命令行测试：
// cluster1
// 切换至 hadoop 用户的主目录
$ cd ~/
// 新建一个测试文件
$ vi testfile
输入
1
2
3
// 保存退出
// 查看 HDFS 根目录的文件
$ hdfs dfs -ls /
// 在 HDFS 的根目录创建 test 目录
$ hdfs dfs -mkdir /test
// 如果出现了 mkdir: Cannot create directory /test. Name node is in safe
mode.说明 HDFS
刚启动不久，还在安全检查中。由于我们的笔记本性能不够强，安全检查的时间会很长，可以使用命令退出安全模式，看到
Safe mode is OFF，再执行上面的创建目录的命令
$ hdfs dfsadmin -safemode leave
// 创建完文件夹后再次查看根目录，查看目录是否新建成功
$ hdfs dfs -ls /
// 将测试文件 testfile 上传至 HDFS 根目录下的 test 目录中
$ hdfs dfs -put testfile /test
// 在 cluster2 上
// 切换至 hadoop 用户的主目录
$ cd ~/
// 查看 HDFS 根目录
$ hdfs dfs -ls /
// 查看 HDFS 根目录下的 test 目录，可以看到我们刚才在 cluster1 上上传的文件
testfile
$ hdfs dfs -ls /test
// 查看 HDFS 上的/test/testfile 文件的内容
$ hdfs dfs -cat /test/testfile
// 将 HDFS 上的/test/testfile 下载到本地
$ hdfs dfs -get /test/testfile
// 查看本地当前目录内的内容，可以看到刚才下载的 testfile
$ ls
5.12安装 HBase
HBase（Hadoop
Database）是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，利用 HBase
技术可在廉价 PC Server 上搭建起大规模结构化存储集群。
5.12.1cluster1
HBase 启动的先决条件是 zookeeper 和 Hadoop 已经启动
// 切换至 root 用户
$ su root
// 在 cluster1 节点/usr/local/解压 hbase 安装包
# tar -zxvf hbase-1.2.6-bin.tar.gz
// 进入 hbase 的 conf 目录
#cd /usr/local/hbase-1.2.6/conf/
// 修改 hbase-env.sh
# vi hbase-env.sh
将 JAVA_HOME, HADOOP_HOME, HBASE_LOG_DIR, HBASE_MANAGES_ZK 修改为以下内容：
记得去掉前面的 #
# 配置 JDK 安装路径
export JAVA_HOME=/usr/local/jdk1.7.0_80
# 配置 Hadoop 安装路径
export HADOOP_HOME=/usr/local/hadoop-2.6.5
# 设置 HBase 的日志目录
export HBASE_LOG_DIR=/home/hadoop_files/hadoop_logs/hbase/logs
# 使用独立的 ZooKeeper 集群
export HBASE_MANAGES_ZK=false
# 设置 pid 的路径
export HBASE_PID_DIR=/home/hadoop_files
// 配置 hbase-site.xml
# vi hbase-site.xml
<configuration>
<property>
<name>hbase.rootdir</name>
<value>hdfs://cluster1:9000/hbase</value>
</property>
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
<property>
<name>hbase.master</name>
<value>60000</value>
</property>
<property>
<name>hbase.tmp.dir</name>
<value>/home/hadoop_files/hadoop_tmp/hbase/tmp</value>
</property>
<property>
<name>hbase.zookeeper.quorum</name>
<value>cluster1,cluster2,cluster3</value>
</property>
<property>
<name>hbase.zookeeper.property.dataDir</name>
<value>/home/hadoop_files/hadoop_data/zookeeper</value>
</property>
<property>
<name>hbase.zookeeper.property.clientPort</name>
<value>2181</value>
</property>
<property>
<name>zookeeper.session.timeout</name>
<value>120000</value>
</property>
<property>
<name>hbase.regionserver.restart.on.zk.expire</name>
<value>true</value>
</property>
<property>
<name>hbase.master.info.port</name>
<value>60010</value>
</property>
</configuration>
// 配置 regionservers
# vi regionservers
删除 localhost
添加： cluster1 cluster2 cluster3
// 删除 hbase 的 slf4j-log4j12-1.7.5.jar，解决 hbase 和 hadoop 的 LSF4J 包冲突
# cd /usr/local/hbase-1.2.6/lib
# mv slf4j-log4j12-1.7.5.jar slf4j-log4j12-1.7.5.jar.bk
// 将 hbase 工作目录同步到集群其它节点
# scp -r /usr/local/hbase-1.2.6/ cluster2:/usr/local/
# scp -r /usr/local/hbase-1.2.6/ cluster3:/usr/local/
5.12.2所有节点上
// 创建 hbase 的缓存文件目录（所有节点）
# mkdir -p /home/hadoop_files/hadoop_tmp/hbase/tmp
// 创建 hbase 的日志文件目录（所有节点）
$ mkdir -p /home/hadoop_files/hadoop_logs/hbase/logs
// 改权限（所有节点）
# chown -R hadoop:hadoop /usr/local/hbase-1.2.6
# chown -R hadoop:hadoop /home/hadoop_files
// 在集群各节点上修改环境变量
# vi /etc/profile
export HBASE_HOME=/usr/local/hbase-1.2.6 export PATH=$HBASE_HOME/bin:$PATH
$ source /etc/profile
5.12.3测试
// 启动 HBase（cluster1 上）
先启动 zookeeper，Hadoop 的 HDFS 和 YARN，然后才能启动 HBase
// 启动 HDFS（cluster1 上）
$ start-dfs.sh
// 启动 YARN（cluster1 上）
$ start-yarn.sh
// 启动 HBase（cluster1 上）
$ start-hbase.sh
启动后 cluster1 上使用 jps 可以看到 HMaster 和 HRegionServer
cluster2 和 cluster3 上可以看到 HRegionServer
// 关机前执行关闭 HBase 的命令（cluster1 上）
$ stop-hbase.sh
用浏览器打开 192.168.56.121:60010，可以看到 HBase 的 web 界面
测试 HBase：
// cluster1 上
$ hbase shell
hbase> create
‘userinfotable’,{NAME=>‘username’},{NAME=>‘fullname’},{NAME=>‘homedir’}
hbase> put ‘userinfotable’,‘r1’,‘username’,‘vcsa’
hbase> put ‘userinfotable’,‘r2’,‘username’,‘sasuser’ hbase> scan
‘userinfotable’
可以看到刚才插入的信息，在 web 界面也可以看到刚才建立的表。
删除刚才建立的表： hbase> disable ‘userinfotable’ hbase> drop ‘userinfotable’
hbase> exit
5.13安装 Hive
Hive 是建立在 Hadoop
上的数据仓库基础构架。它提供了一系列的工具，可以用来进行数据提取转化加载（ETL），这是一种可以存储、查询和分析存储在
Hadoop 中的大规模数据的机制。
5.13.1 cluster2上
以下内容除在 MySQL（cluster2 中）创建 hive 用户和创建 hive
数据库只用操作一次，其他操作需要在每个 Hadoop 结点上都执行一次。
注：hive 能启动的先决条件是 MySQL 已经安装并配置完成，而且 HDFS
也要启动之后才能运行 hive
$ su root
# cp apache-hive-1.1.0-bin.tar.gz /usr/local
# cd /usr/local
# tar -zxvf ./apache-hive-1.1.0-bin.tar.gz
# vi /etc/profile
// 在下面加上两行：
export HIVE_HOME=/usr/local/apache-hive-1.1.0-bin
export PATH=$HIVE_HOME/bin:$HIVE_HOME/conf:$PATH
$ source /etc/profile
// root 用户登陆 MySQL
# mysql -u root -p
// 创建用户 hive，密码 hive
mysql> GRANT USAGE ON *.* TO ‘hive’@’%’ IDENTIFIED BY ‘hive’ WITH GRANT
OPTION;
// 创建数据库 hive
mysql> create database hive;
// 允许任意 ip 以 hive 登陆数据库
mysql> grant all on hive.* to hive@’%’ identified by ‘hive’; mysql> grant
all on hive.* to hive@‘localhost’ identified by ‘hive’; mysql> grant all on
hive.* to hive@‘cluster2’ identified by ‘hive’;
// 刷新权限
mysql> flush privileges;
// 退出
mysql> exit;
// 验证 hive 用户，密码 hive
# mysql -u hive -p
// 查看当前的数据库
mysql> show databases;
若看到下面有 hive 这个库，则说明创建成功
±------------------------------+
| Database |
±------------------------------+
| information_schema |
| hive |
±------------------------------+
2 rows in set (0.00 sec)
// 退出 mysql mysql> exit;
// 修改 hive-site.xml
# cp apache-hive-1.1.0-bin/conf/hive-default.xml.template
apache-hive-1.1.0-bin/conf/hive-site.xml
# vi apache-hive-1.1.0-bin/conf/hive-site.xml
找到以下 property 项，value 值修改成如下，其他的在 hive-site.xml
中出现，但是下文没出现的就不需要更改了：
<property>
<name>javax.jdo.option.ConnectionURL </name>
<value>jdbc:mysql://cluster2:3306/hive</value>
</property>
<property>
<name>javax.jdo.option.ConnectionDriverName </name>
<value>com.mysql.jdbc.Driver </value>
</property>
<property>
<name>javax.jdo.option.ConnectionPassword </name>
<value>hive</value>
</property>
<property>
<name>hive.hwi.listen.port</name>
<value>9999 </value>
<description>This is the port the Hive Web Interface will listen
on</descript ion>
</property>
<property>
<name>datanucleus.autoCreateSchema</name>
<value>true</value>
</property>
<property>
<name>datanucleus.fixedDatastore</name>
<value>false</value>
</property>
<property>
<name>javax.jdo.option.ConnectionUserName</name>
<value>hive</value>
<description>Username to use against metastore database</description>
</property>
<property>
<name>hive.exec.local.scratchdir</name>
<value>/home/hadoop_files/hadoop_tmp/hive/iotmp</value>
<description>Local scratch space for Hive jobs</description>
</property>
<property>
<name>hive.downloaded.resources.dir</name>
<value>/home/hadoop_files/hadoop_tmp/hive/iotmp</value>
<description>Temporary local directory for added resources in the remote
file system.</description>
</property>
<property>
<name>hive.querylog.location</name>
<value>/home/hadoop_files/hadoop_logs/hive/querylog</value>
<description>Location of Hive run time structured log file</description>
</property>
// 拷贝 mysql-connector-java-5.1.43-bin.jar 到 hive 的 lib 下面
//要将文件mysql-connector-java-5.1.43-bin.jar上传到/usr/local/目录下
# cp mysql-connector-java-5.1.43-bin.jar /usr/local/apache-hive-1.1.0-bin/lib/
// 把 jline-2.12.jar 拷贝到 hadoop 相应的目录下，替代
jline-0.9.94.jar，否则启动会报错
// 将 hbase 工作目录同步到集群其它节点cluster1 cluster3
# scp -r /usr/local/hbase-1.2.6/ cluster1:/usr/local/
# scp -r /usr/local/hbase-1.2.6/ cluster3:/usr/local/
5.13.2 所有节点上
# cp /usr/local/apache-hive-1.1.0-bin/lib/jline-2.12.jar
/usr/local/hadoop-2.6.5/share/hadoop/yarn/lib/
// 切换到 hadoop 目录中 share/hadoop/yarn/lib
# cd /usr/local/hadoop-2.6.5/share/hadoop/yarn/lib/
// 将 hadoop-2.6.5/share/hadoop/yarn/lib/里面的 jline-0.9.94 重命名
# mv jline-0.9.94.jar jline-0.9.94.jar.bak
// 创建 hive 临时文件夹和日志目录
# mkdir -p /home/hadoop_files/hadoop_tmp/hive/iotmp
# mkdir -p /home/hadoop_files/hadoop_logs/hive/querylog
// 改一下权限
# chown -R hadoop:hadoop /home/hadoop_files/
# chown -R hadoop:hadoop /usr/local/apache-hive-1.1.0-bin
5.13.4 cluster1和cluster3上
# vi /etc/profile
// 在下面加上两行：
export HIVE_HOME=/usr/local/apache-hive-1.1.0-bin
export PATH=$HIVE_HOME/bin:$HIVE_HOME/conf:$PATH
$ source /etc/profile
5.13.2测试
// 打开 hive 客户端cluster2
$ hive
hive> create table test_table(id int, name string);
hive> insert into test_table values(1,”test”);
// 换台服务器cluster1或者cluster3
hive> show tables;
应该可以看到刚才创建的 test_table
hive> select * from test_table;
hive> drop table test_table;
hive> show tables;
hive> exit;
5.14安装 Scala
5.14.1 cluster1 上
$ su root
# mv scala-2.10.6.tgz /usr/local
# tar -zxvf scala-2.10.6.tgz
# vi /etc/profile
最下面加两行：
export SCALA_HOME=/usr/local/scala-2.10.6 export PATH=$SCALA_HOME/bin:$PATH
// 刷新环境变量
# source /etc/profile
// 查看版本，验证安装是否成功
# scala -version
// 修改文件夹权限
# chown -R hadoop:hadoop /usr/local/scala-2.10.6
// 复制到所有的服务器上
# scp -r /usr/local/scala-2.10.6 cluster2:/usr/local/
# scp -r /usr/local/scala-2.10.6 cluster3:/usr/local/
5.14.2 cluster2,3上
#vi /etc/profile
export SCALA_HOME=/usr/local/scala-2.10.6
export PATH=$SCALA_HOME/bin:$PATH
// 刷新环境变量
# source /etc/profile
// 查看版本，验证安装是否成功
# scala -version
// 修改文件夹权限(每一个节点都要操作)
# chown -R hadoop:hadoop /usr/local/scala-2.10.6
5.15安装 Spark
Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley
AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop
MapReduce的通用并行框架，Spark，拥有Hadoop
MapReduce所具有的优点；但不同于MapReduce的是——Job中间输出结果可以保存在内存中，从而不再需要读写HDFS，因此Spark能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。
Spark 是一种与 Hadoop
相似的开源集群计算环境，但是两者之间还存在一些不同之处，这些有用的不同之处使
Spark 在某些工作负载方面表现得更加优越，换句话说，Spark
启用了内存分布数据集，除了能够提供交互式查询外，它还可以优化迭代工作负载。
Spark 是在 Scala 语言中实现的，它将 Scala 用作其应用程序框架。与 Hadoop
不同，Spark 和 Scala 能够紧密集成，其中的 Scala
可以像操作本地集合对象一样轻松地操作分布式数据集。
尽管创建 Spark 是为了支持分布式数据集上的迭代作业，但是实际上它是对 Hadoop
的补充，可以在 Hadoop 文件系统中并行运行。通过名为 Mesos
的第三方集群框架可以支持此行为。Spark 由加州大学伯克利分校 AMP 实验室
(Algorithms, Machines, and People Lab)
开发，可用来构建大型的、低延迟的数据分析应用程序。
Spark 主要有三个特点：
首先，高级 API 剥离了对集群本身的关注，Spark
应用开发者可以专注于应用所要做的计算本身。
其次，Spark 很快，支持交互式计算和复杂算法。
最后，Spark 是一个通用引擎，可用它来完成各种各样的运算，包括 SQL
查询、文本处理、机器学习等，而在 Spark
出现之前，我们一般需要学习各种各样的引擎来分别处理这些需求。
更快的速度
内存计算下，Spark 比 Hadoop 快100倍。
计算时间比较
计算时间比较
易用性
Spark 提供了80多个高级运算符。
通用性
Spark 提供了大量的库，包括Spark Core、Spark SQL、Spark
Streaming、MLlib、GraphX。 开发者可以在同一个应用程序中无缝组合使用这些库。
支持多种资源管理器
Spark 支持 Hadoop YARN，Apache Mesos，及其自带的独立集群管理器
Spark生态系统
Shark：Shark基本上就是在Spark的框架基础上提供和Hive一样的HiveQL命令接口，为了最大程度的保持和Hive的兼容性，Spark使用了Hive的API来实现query
Parsing和 Logic Plan generation，最后的PhysicalPlan
execution阶段用Spark代替HadoopMapReduce。通过配置Shark参数，Shark可以自动在内存中缓存特定的RDD，实现数据重用，进而加快特定数据集的检索。同时，Shark通过UDF用户自定义函数实现特定的数据分析学习算法，使得SQL数据查询和运算分析能结合在一起，最大化RDD的重复使用。
SparkR：SparkR是一个为R提供了轻量级的Spark前端的R包。
SparkR提供了一个分布式的data frame数据结构，解决了 R中的data
frame只能在单机中使用的瓶颈，它和R中的data frame
一样支持许多操作，比如select,filter,aggregate等等。（类似dplyr包中的功能）这很好的解决了R的大数据级瓶颈问题。
SparkR也支持分布式的机器学习算法，比如使用MLib机器学习库。
SparkR为Spark引入了R语言社区的活力，吸引了大量的数据科学家开始在Spark平台上直接开始数据分析之旅。
基本原理
Spark
Streaming：构建在Spark上处理Stream数据的框架，基本的原理是将Stream数据分成小的时间片段（几秒），以类似batch批量处理的方式来处理这小部分数据。Spark
Streaming构建在Spark上，一方面是因为Spark的低延迟执行引擎（100ms+），虽然比不上专门的流式数据处理软件，也可以用于实时计算，另一方面相比基于Record的其它处理框架（如Storm），一部分窄依赖的RDD数据集可以从源数据重新计算达到容错处理目的。此外小批量处理的方式使得它可以同时兼容批量和实时数据处理的逻辑和算法。方便了一些需要历史数据和实时数据联合分析的特定应用场合。
计算方法
Bagel: Pregel on
Spark，可以用Spark进行图计算，这是个非常有用的小项目。Bagel自带了一个例子，实现了Google的PageRank算法。
当下Spark已不止步于实时计算，目标直指通用大数据处理平台，而终止Shark，开启SparkSQL或许已经初见端倪。
近几年来，大数据机器学习和数据挖掘的并行化算法研究成为大数据领域一个较为重要的研究热点。早几年国内外研究者和业界比较关注的是在
Hadoop 平台上的并行化算法设计。然而， HadoopMapReduce
平台由于网络和磁盘读写开销大，难以高效地实现需要大量迭代计算的机器学习并行化算法。随着
UC Berkeley AMPLab 推出的新一代大数据平台 Spark
系统的出现和逐步发展成熟，近年来国内外开始关注在 Spark
平台上如何实现各种机器学习和数据挖掘并行化算法设计。为了方便一般应用领域的数据分析人员使用所熟悉的
R 语言在 Spark 平台上完成数据分析，Spark 提供了一个称为 SparkR
的编程接口，使得一般应用领域的数据分析人员可以在 R 语言的环境里方便地使用 Spark
的并行化编程接口和强大计算能力。
5.15.1cluster1上
上传 spark-1.6.3-bin-hadoop2.6.tgz
// 解压
# cp spark-1.6.3-bin-hadoop2.6.tgz /usr/local
# cd /usr/local/
# tar -zxvf spark-1.6.3-bin-hadoop2.6.tgz
# cd spark-1.6.3-bin-hadoop2.6
// 环境变量
# vi /etc/profile
添加以下内容：
export SPARK_HOME=/usr/local/spark-1.6.3-bin-hadoop2.6
export PATH=$SPARK_HOME/bin:$PATH
主节点要再加一行（cluster1）：
export PATH=$SPARK_HOME/sbin:$PATH
// 复制 conf 文件夹里面 template 一份，改名为 spark-env.sh
# cp conf/spark-env.sh.template conf/spark-env.sh
// 在 conf/spark-env.sh 最下面加入以下 7 行：
#vi conf/spark-env.sh
export JAVA_HOME=/usr/local/jdk1.7.0_80
export SCALA_HOME=/usr/local/scala-2.10.6
export SPARK_MASTER_IP=cluster1
export HADOOP_CONF_DIR=/usr/local/hadoop-2.6.5/etc/hadoop
export SPARK_DIST_CLASSPATH=$(/usr/local/hadoop-2.6.5/bin/hadoop classpath)
export SPARK_CLASSPATH=$HIVE_HOME/lib/mysql-connector-java-5.1.43-bin.jar
export SPARK_PID_DIR=/home/hadoop_files
// 在 conf 下面新建一个叫 slaves 的文件
# vi conf/slaves
添加以下几行
cluster1
cluster2
cluster3
// 将 hive 目录下 conf 文件夹中的 hive-site.xml 复制到 spark 的 conf 目录下
# cd /usr/local/
# cp apache-hive-1.1.0-bin/conf/hive-site.xml spark-1.6.3-bin-hadoop2.6/conf/
// 将 hadoop/etc/hadoop 文件中的 hdfs-site.xml 和 core-site.xml 文件复制到 spark
的 conf 目录下
# cp hadoop-2.6.5/etc/hadoop/hdfs-site.xml
hadoop-2.6.5/etc/hadoop/core-site.xml spark-1.6.3-bin-hadoop2.6/conf/
// 将 conf 目录下的 spark-defaults.conf.template 复制一份，改名为
spark-default.conf
# cd spark-1.6.3-bin-hadoop2.6/conf/
# cp spark-defaults.conf.template spark-defaults.conf
# vi spark-defaults.conf
// 在最下面加上下面这一行
spark.files
file:///usr/local/spark-1.6.3-bin-hadoop2.6/conf/hdfs-site.xml,file:///usr/local/spark-1.6.3-bin-
hadoop2.6/conf/core-site.xml
保存后退出即可。
// 复制到所有的服务器上
# scp -r /usr/local/spark-1.6.3-bin-hadoop2.6 cluster2:/usr/local/
# scp -r /usr/local/spark-1.6.3-bin-hadoop2.6 cluster3:/usr/local/
// 修改 spark 文件夹的权限（每个 spark 结点）
# chown -R hadoop:hadoop /usr/local/spark-1.6.3-bin-hadoop2.6
5.15.2 cluster2,3
# vi /etc/profile
添加以下内容：
export SPARK_HOME=/usr/local/spark-1.6.3-bin-hadoop2.6
export PATH=$SPARK_HOME/bin:$PATH
$ source /etc/profile
// 修改 spark 文件夹的权限（每个 spark 结点）
# chown -R hadoop:hadoop /usr/local/spark-1.6.3-bin-hadoop2.6
5.15.2测试
// 运行 Spark（cluster1 上）
运行 spark 前需启动 hadoop 的 HDFS 和 YARN
$ start-master.sh
$ start-slaves.sh
// 关闭 Spark 的命令（cluster1 上）
$ stop-slaves.sh
$ stop-master.sh
在 cluster1 上使用 jps 命令可以看到 Master 和 Worker，cluster2 和 3 上可以看到
Worder
用浏览器访问 192.168.56.121:8080 可以看到 Spark 的 web 界面，可以看到 3 个
worker
5.16安 装 Storm
Apache
Storm是一个分布式实时大数据处理系统。Storm设计用于在容错和水平可扩展方法中处理大量数据。它是一个流数据框架，具有最高的摄取率。虽然Storm是无状态的，它通过Apache
ZooKeeper管理分布式环境和集群状态。它很简单，您可以并行地对实时数据执行各种操作。
Apache
Storm继续成为实时数据分析的领导者。Storm易于设置和操作，并且它保证每个消息将通过拓扑至少处理一次。
Apache Storm vs Hadoop
基本上Hadoop和Storm框架用于分析大数据。两者互补，在某些方面有所不同。Apache
Storm执行除持久性之外的所有操作，而Hadoop在所有方面都很好，但滞后于实时计算。下表比较了Storm和Hadoop的属性。
| Storm | Hadoop |
|---|---|
| 实时流处理 | 批量处理 |
| 无状态 | 有状态 |
| 主/从架构与基于ZooKeeper的协调。主节点称为nimbus，从属节点是主管。 | 具有/不具有基于ZooKeeper的协调的主 - 从结构。主节点是作业跟踪器，从节点是任务跟踪器。 |
| Storm流过程在集群上每秒可以访问数万条消息。 | Hadoop分布式文件系统（HDFS）使用MapReduce框架来处理大量的数据，需要几分钟或几小时。 |
| Storm拓扑运行直到用户关闭或意外的不可恢复故障。 | MapReduce作业按顺序执行并最终完成。 |
| 两者都是分布式和容错的 | |
| 如果nimbus / supervisor死机，重新启动使它从它停止的地方继续，因此没有什么受到影响。 | 如果JobTracker死机，所有正在运行的作业都会丢失。 |
Apache Storm的组件 -
Tuple
Tuple是Storm中的主要数据结构。它是有序元素的列表。默认情况下，Tuple支持所有数据类型。通常，它被建模为一组逗号分隔的值，并传递到Storm集群。
Stream 流是元组的无序序列。
Spouts 流的源。通常，Storm从原始数据源（如Twitter Streaming API，Apache
Kafka队列，Kestrel队列等）接受输入数据。否则，您可以编写spouts以从数据源读取数据。“ISpout”是实现spouts的核心接口，一些特定的接口是IRichSpout，BaseRichSpout，KafkaSpout等。
Bolts
Bolts是逻辑处理单元。Spouts将数据传递到Bolts和Bolts过程，并产生新的输出流。Bolts可以执行过滤，聚合，加入，与数据源和数据库交互的操作。Bolts接收数据并发射到一个或多个Bolts。
“IBolt”是实现Bolts的核心接口。一些常见的接口是IRichBolt，IBasicBolt等。
storm 需要 python2.6 以上的版本
// 查看 python 版本
# python
可以在最上面一行看到 python 的版本
// 退出 python 交互式界面
>>> exit()
如果版本低于 2.6，使用 yum install python，安装 Python2.7
5.16.1 cluster1
（以下都要在所有节点上操作） 将上传的的 storm 到/usr/local 下，并解压
# tar -zxvf apache-storm-1.1.1.tar.gz
// 更改配置文件
# vi apache-storm-1.1.1/conf/storm.yaml
里面有两个要改的地方第一个是
storm.zookeeper.servers :
- “cluster1”
- “cluster2”
- “cluster3”
第二个是加入一行
storm.local.dir : “/home/hadoop_files/hadoop_tmp/storm/tmp”
所有的双引号都是英文字符双引号
切记：冒号左右要有空格，否则会报错 could not found expected ‘ : ’
storm.local.dir 的最左边也要有一个空格
// 复制到所有的服务器上
# scp -r /usr/local/apache-storm-1.1.1 cluster2:/usr/local/
# scp -r /usr/local/apache-storm-1.1.1 cluster3:/usr/local/
5.16.2 所有节点上
// 添加环境变量
# vi /etc/profile
export STORM_HOME=/usr/local/apache-storm-1.1.1
export PATH=$STORM_HOME/bin:$PATH
$ source /etc/profile
// 改一下权限
# chown -R hadoop:hadoop apache-storm-1.1.1
// 然后新建 tmp 文件夹，改权限
# mkdir -p /home/hadoop_files/hadoop_tmp/storm/tmp
# chown -R hadoop:hadoop /home/hadoop_files
# chown -R hadoop:hadoop /usr/local/apache-storm-1.1.1
5.16.3测试
// 新建 storm-master 的虚拟窗口(cluster1)
$ screen -S storm-master
$ storm nimbus
$ Ctrl+A+D
// 新建 storm-supervisor 的虚拟窗口（cluster2，cluster3）
$ screen -S storm-supervisor
$ storm supervisor
$ Ctrl+A+D
// 新建 storm-ui 的虚拟窗口(cluster1)
$ screen -S storm-ui
$ storm ui
$ Ctrl+A+D
// 新建 storm-logviewer 的虚拟窗口（cluster1，cluster2，cluster3）
$ screen -S storm-logviewer
$ storm logviewer
$ Ctrl+A+D
使用 jps 可以看到以下进程
cluster1：nimbus, core, logviewer
cluster2：Supervisor, logviewer
cluster3：Supervisor, logviewer
关闭的过程就是按逆向的顺序进入虚拟窗口后，使用 Ctrl+C 退出即可。
测试结果：
Hadoop大数据平台安装相关推荐
- 大数据平台安装实验: ZooKeeper、Kafka、Hadoop、Hbase、Hive、Scala、Spark、Storm
文章目录 实验1:Hadoop大数据平台安装实验 1. 实验目的 2. 实验环境 3. 实验过程 3.1 虚拟机的搭建 3.1.1 安装虚拟机 3.1.2 基本linux命令 3.2 准备工作 3.2 ...
- Hadoop大数据平台环境搭建注意事项，分布式数据采集，武汉数道云科技
Hadoop大数据作为时代发展的产物,影响着互联网企业发展.以及企业关于品牌形象推广.政府有关民意采集.以及有关数据信息收集分类------ Hadoop技术的发展,带来了海量数据高效处理的能力,也给 ...
- 大数据基础——Hadoop大数据平台搭建
文章目录 前言 Hadoop大数据平台搭建 一．Hadoop原理和功能介绍 二．Hadoop安装部署 三．Hadoop常用操作 总结 前言 分布式机器学习为什么需求大数据呢?随着海量用户数据的积累,单 ...
- 初识大数据--Hadoop大数据平台架构与实践
Hadoop大数据平台架构与实践 推荐书籍: ⭐大数据存储与处理技术的原理(理论) ⭐Hadoop的使用和开发能力(实践) 预备知识: Linux常用命令 Java基础编程 1.大数据相关概念 无 ...
- Hadoop大数据平台开发与案例分析
关于举办"Hadoop大数据平台开发与案例分析 "高级工程师 一.课程介绍 1. 需求理解 Hadoop 设计之初的目标就定位于高可靠性.高可拓展性.高容错性和高效性,正是这些设计 ...
- 【Hadoop大数据平台组件搭建系列（一）】——Zookeeper组件配置
简介 本篇介绍Hadoop大数据平台组件中的Zookeeper组件的搭建 使用软件版本信息 zookeeper-3.4.14.tar.gz Zookeeper安装 解压Zookeeper安装包至目标目 ...
- hadoop大数据平台架构之DKhadoop详解
hadoop大数据平台架构之DKhadoop详解 大数据的时代已经来了,信息的爆炸式增长使得越来越多的行业面临这大量数据需要存储和分析的挑战.Hadoop作为一个开源的分布式并行处理平台,以其高拓展. ...
- 教育行业需要了解的大数据，武汉数道云科技浅析：Hadoop大数据平台如何搭建？...
从教育行业的需求出发,去分析互联网时代教育行业需要了解的大数据,以及大数据平台的搭建应该注意什么? 中国-教育规模较大的国家之一,随着互联网的发展,海量的教育大数据将不断产生,如何有效科学的利用数据资 ...
- 【数道云】教育行业需要了解的大数据，武汉Hadoop大数据平台如何搭建？...
从教育行业的需求出发,去分析互联网时代教育行业需要了解的大数据,以及大数据平台的搭建应该注意什么? 中国-教育规模较大的国家之一,随着互联网的发展,海量的教育大数据将不断产生,如何有效科学的利用数据资 ...
最新文章
- 图解：轻松看懂机器学习十大常用算法
- easyui 获取 combobox select 的值
- CDN简介及linux环境下搭建
- C#操作数据库，DataSet，DataGridView，更新数据库 [一] - ADO.NET入门之中
- Redis单机部署、添加开机自启、配置参数
- jpa 定义中间表实体_Spring Data JPA实体详解
- php static与self,PHP5.3新特性static与self区别
- 如何截取_【实用技巧】如何截取网页长图
- matlab画无量纲速度分布,麦克斯韦分布与概率论中典型分布的比较教学
- Pentium的指令系统（1）——Pentium的寻址方式
- 专门针对音乐发烧友开发的5款App
- Vue工程引入openlayers组件的方法
- 华为鸿蒙系统电脑有那些,华为鸿蒙系统上线，仅2家国产品牌支持，爆冷？
- 黑客是如何入侵服务器的
- 算术平均数及几何平均数
- 沈师 Java程序设计 PTA 填空题、程序填空题答案
- weborder什么意思_hp web是什么意思
- 【Simulia】 Lsight多学科仿真流程 | 达索系统百世慧®
- 阿里矢量图标(字体图标)使用
- 计算机管理里怎么改ahci,联想电脑模式更改成ahci模式方法