Hadoop大数据平台安装

我就是我 2022-02-03 18:36 445阅读 0赞

# 实验一：Hadoop大数据平台安装 #

16281002 杜永坤

# 1、实验目的 #

在大数据时代，存在很多开源的分布式数据采集、计算、存储技术，本实验将熟悉并搭建几种常用的大数据采集、处理分析技术环境。  
《大数据技术》实验一需要在笔记本上搭建 Hadoop  
集群，实验报告根据教程对笔记本上创建虚拟机搭建 Hadoop  
集群的步骤进行了说明。包含所有需要安装的软件与服务的版本，安装路径，安装方法等。主要流程为：安装虚拟机管理程序，创建三台虚拟服务器，在三台虚拟服务器上搭建以  
Hadoop 集群为核心的大数据平台。

# ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70]   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/][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**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 1]  
然后双击NatNetwork，进行如下的设置，设置完点击OK即可  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 2]  
选择 **仅主机 (Host-Only)网络 然后点击 添加图标 按钮  
，如果弹出窗口，点击确定即可**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 3]  
\*\*\* 双击新建的网卡，进行如下设置:IPv4地址： 192.168.56.1->IPv4网络掩码：  
255.255.255.0->DHCP服务器 ->取消勾选“启用服务器” ->OK->点 OK保存 \*\*\*  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 5]

### 4.2、配置虚拟机硬件环境 ###

打开Oracle VM VirtualBox 5.1.26，点击 新建 进行新建虚拟机  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 6]  
要注意的就是 **类型 选择 linux 版本选择red hat (64.bit)**  
**点击下一步，设置内存大小，建议设置2048Mb，也就是2Gb，这样下载安装包，或者安装软件的时候速度回大大加快。但是这就需要笔记本电脑的内存至少需要8Gb，最好是16Gb。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 8]  
下一步选择VHD（虚拟硬盘）然后选择动态分配  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 9]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 10]  
然后设置虚拟机的位置，建议不要放到C盘，虚拟硬盘大小设置为8GB即可，点击文件夹图标即可选择虚拟机的路径：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 12]  
然后点击按钮 创建 即可  
创建成功后大概显示如下信息:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 13]  
上面仅仅是搭建了虚拟机的硬件环境，下面要安装虚拟机

### 4.3、安装虚拟机 ###

选中刚刚创建的cluster，点击 设置  
![在这里插入图片描述][20190509230018225.png]  
图标→**存储 ->没有盘片 ->右侧的  
光盘图标，选择下载好的CentOS-7-x86\_64-Minimal-1810.iso**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 14]  
选择好镜像之后，点击OK即可，会显示如下信息：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 15]  
再次点击 设置 图标 **→网络 ->网卡 1->启用网络连接 ->连接方式  
\->NAT->界面名称 ->选择刚才 先建立的那块虚拟网卡 即可 ->网卡 2->启用网络连接  
\->连接方式 连接方式 ->仅主机 (Host-Only)网络 ->界面名称  
\->选择刚才后建立的那块虚拟网卡 -> OK。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 17]  
下面双击cluster 进入虚拟机装载程序 选择 Install CentOS 7  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 18]  
等待加载完毕之后进行如下设置：

*  English->continue。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 19]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 20]
 *  DATE&TIME，Region选择 Asia，City选择 Shanghai，左上角 ，左上角 Done。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 21]
 *  INSTALLATION DESTINATION，点进去后直接左上角的 Done。
 *  NETWORK & HOST NAME，**两张网卡 右侧 都选择 ON，下面的 Host name改为  
    cluster1**，然后进行左上角 Done。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 22]
 *  选择右下角 选择右下角 选择右下角 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][https_pan.baidu.com_s_1tak5_8D3JfreBZYwFCLPyA] 提取码：lr3u  
> 所有的版本号都为教程的版本对应。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 23]

### 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权限**）：  
> ![在这里插入图片描述][20190509230232271.png]  
> **su hadoop**  
> 切换到hadoop用户，切换成功后会出现如下的符号![在这里插入图片描述][20190509230241180.png]  
> **$表示是普通用户**  
> 所以在进行操作指令的时候看清指令前的符号，是否一致，如果不一致，建议直接通过  
> su hadoop 或者su root 手动切换，不建议使用exit 命令  
> 2、熟悉基本的操作指令  
> 例如 tar 解压操作；  
> cd 切换目录操作  
> 操作指令时，要看清指令操作的目录，比如操作流程中经常有 切换到/usr/local  
> 这个操作提示，就是要执行 cd /usr/local 切换成功后会出现下面的提示：  
> ![在这里插入图片描述][20190509230310695.png]  
> 同理其他提示也要按照上面的指令进行切换目录。  
> ls 查看当前目录文件  
> yum install \*\*\*\* 安装软件包操作  
> vi 编辑指令  
> vi /etc/profile 会进入编辑文件界面，这个时候要输入 i 才能进行编辑  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 24]  
> 会出现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用户中执行  
> ![在这里插入图片描述][20190509230359699.png]  
> 上面最重要的指令就是cd  
> 指令，在教程中，如果出现这个指令，一定要执行，然后再进行后面的指令，不能先执行后面的指令，再回来执行cd指令，而且如果没有直接给出cd  
> 指令，而是要求切换到某目录，也要执行cd指令，比如：  
> ![在这里插入图片描述][20190509230407673.png]  
> 提示：解压到/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  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 25]  
使用这条命令可以查看所有网卡的信息，注意记录每张网卡的网卡名：前面序号后面的即为网卡名。还需记录每张网卡的  
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地址的变换即可。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 26]  
然后点击右下角的 Open，即可连接到 cluster1 上。连接上后：  
输入root：  
![在这里插入图片描述][2019050923045931.png]  
然后再输入密码，即可进入CentOS系统的终端：  
![在这里插入图片描述][20190509230505871.png]  
由于CentOS是终端操作，没有用户界面，所以我们要传输文件时可以使用  
winSCP文件传输软件，将安装包上传到系统中。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 27]  
主机名为：192.168.56.121，用户名为 root，端口号为22，快速连接即可。  
连接上，可以看到本地文件，和虚拟机的文件，可以选中本地文件将需要的文件拖曳到虚拟机部分，即可上传。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 28]

### 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  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 29]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 30]

### 5.6检查网络是否正常 ###

// 在 cluster1 上  
// 检查能否连接到 cluster2,3  
\# ping cluster2  
\# ping cluster3  
如果出现如下界面：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 31]  
可以看到 time=多少秒，说明可以从 cluster1 连接到 cluster2，同理，检查能否连接到  
cluster3，使用 Ctrl+C  
同理可以在cluster2上ping另外两台虚拟机的ip地址  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 32]

### 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  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 33]  
> //重启  
> \# 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),  
这种所谓的"关系型"可以理解为"表格"的概念, 一个关系型数据库由一个或数个表格组成,  
如图所示的一个表格:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 34]

*  表头(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关闭后想要在此启动，需要进行如下操作：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 35]  
\\\# /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 即为安装成功  
![在这里插入图片描述][20190509230728739.png]

### 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 命令查看进程是否启动  
![在这里插入图片描述][20190509230808903.png]  
\# jps  
可以看到一个叫 QuorumPeerMain 的进程，说明 zookeeper 启动成功  
![在这里插入图片描述][20190509230814936.png]  
// 退出 root 用户  
\# exit  
// 查看 zookeeper 状态  
$ [zkServer.sh][] status  
可以看到三台中有一个是 leader，两个是 follower  
![在这里插入图片描述][20190509230821675.png]  
// 关闭 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  
&  
启动完成后按回车即可  
![在这里插入图片描述][20190509230837604.png]

#### 5.10.5测试 ####

在cluster1上创建topic  
Kafka的核心概念:提供一串流式的记录— topic 。  
Topic  
就是数据主题，是数据记录发布的地方,可以用来区分业务系统。Kafka中的Topics总是多订阅者模式，一个topic可以拥有一个或者多个消费者来订阅它的数据。  
对于每一个topic， Kafka集群都会维持一个分区日志，如下所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 36]  
每个分区都是有序且顺序不可变的记录集，并且不断地追加到结构化的commit  
log文件。分区中的每一个记录都会分配一个id号来表示顺序，我们称之为offset，offset用来唯一的标识分区中每一条记录。  
Kafka  
集群保留所有发布的记录—无论他们是否已被消费—并通过一个可配置的参数——保留期限来控制.  
举个例子，  
如果保留策略设置为2天，一条记录发布后两天内，可以随时被消费，两天过后这条记录会被抛弃并释放磁盘空间。Kafka的性能和数据大小无关，所以长时间存储数据没有什么问题.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 37]  
事实上，在每一个消费者中唯一保存的元数据是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中的每条记录被分配给订阅消费组中的一个消费者实例.消费者实例可以分布在多个进程中或者多个机器上。  
如果所有的消费者实例在同一消费组中，消息记录会负载平衡到每一个消费者实例.  
如果所有的消费者实例在不同的消费组中，每条消息记录会广播到所有的消费者进程.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 38]  
如图，这个 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  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 39]  
// 查看 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 退出  
![在这里插入图片描述][20190509230923767.png]  
// 关闭 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 进程在运行  
![在这里插入图片描述][20190509230930529.png]  
// 关闭 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>  
>   
> <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>  
>   
> <property>  
> <name>fs.trash.interval</name>  
> <value>1440</value>  
> </property>  
>   
> <property>  
> <name>ha.zookeeper.quorum</name>  
> <value>cluster1:2181,cluster2:2181,cluster3:2181</value>  
> </property>  
> </configuration>  
> // 配置 hdfs-site.xml 文件  
> \# vi hdfs-site.xml  
> <configuration>  
>   
> <property>  
> <name>dfs.namenode.name.dir</name>  
> <value>/home/hadoop\_files/hadoop\_data/hadoop/namenode</value>  
> </property>  
>   
> <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>  
>   
> <property>  
> <name>dfs.webhdfs.enabled</name>  
> <value>true</value>  
> </property>  
> </configuration>  
> // 配置 mapred-site.xml 文件  
> \# vi mapred-site.xml  
> <configuration>  
>   
> <property>  
> <name>mapreduce.framework.name</name>  
> <value>yarn</value>  
> </property>  
>   
> <property>  
> <name>mapreduce.jobhistory.address</name>  
> <value>cluster1:10020</value>  
> </property>  
>   
> <property>  
> <name>mapreduce.jobhistory.webapp.address</name>  
> <value>cluster1:19888</value>  
> </property>  
> </configuration>  
> // 配置 yarn-site.xml 文件  
> \# vi yarn-site.xml  
> <configuration>  
>   
> <property>  
> <name>yarn.nodemanager.aux-services</name>  
> <value>mapreduce\_shuffle</value>  
> </property>  
>   
> <property>  
> <name>yarn.web-proxy.address</name>  
> <value>cluster2:8888</value>  
> </property>  
>   
> <property>  
> <name>yarn.log-aggregation-enable</name>  
> <value>true</value>  
> </property>  
>   
> <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][]  
测试结果：  
![在这里插入图片描述][20190509231036495.png]  
启动 HDFS 后，可以在本地的浏览器中，打开 192.168.56.121:50070，可以看到 HDFS 的  
web 界面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 40]  
第一页 Overview 是当前 HDFS 的概况，里面显示了 HDFS  
的启动时间，版本等信息。点击上面标签栏的第二项 Datanodes，可以看到如下界面  
这个页面显示了当前 HDFS 中的可用节点。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 41]  
启动 YARN 后，可以通过浏览器访问 192.168.56.121:8088，查看 YARN 的 web 界面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 42]  
该页面展示了所有提交到 YARN 上的程序，点击左侧的 Nodes 可以看到 YARN 的节点  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 43]  
注意，此处可以看到每个节点的可用内存 Mem Avail 为 8G，我们的虚拟机每台内存只有  
1.5G，之所以出现这个问题是因为我们没有在 yarn-site.xml  
这个文件中对节点的可用内存进行配置，可以增加一下内容进行配置：

> <property>  
> <name>yarn.nodemanager.resource.memory-mb</name>  
> <value>20480</value>  
> </property>  
>   
> <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，再执行上面的创建目录的命令  
> ![在这里插入图片描述][20190509231118977.png]  
> $ hdfs dfsadmin -safemode leave  
> // 创建完文件夹后再次查看根目录，查看目录是否新建成功  
> $ hdfs dfs -ls /  
> ![在这里插入图片描述][20190509231123795.png]  
> // 将测试文件 testfile 上传至 HDFS 根目录下的 test 目录中  
> $ hdfs dfs -put testfile /test  
> // 在 cluster2 上  
> // 切换至 hadoop 用户的主目录  
> $ cd ~/  
> // 查看 HDFS 根目录  
> $ hdfs dfs -ls /  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 44]  
> // 查看 HDFS 根目录下的 test 目录，可以看到我们刚才在 cluster1 上上传的文件  
> testfile  
> $ hdfs dfs -ls /test  
> // 查看 HDFS 上的/test/testfile 文件的内容  
> $ hdfs dfs -cat /test/testfile  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 45]  
> // 将 HDFS 上的/test/testfile 下载到本地  
> $ hdfs dfs -get /test/testfile  
> // 查看本地当前目录内的内容，可以看到刚才下载的 testfile  
> $ ls  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 46]

### 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 界面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 47]  
测试 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 界面也可以看到刚才建立的表。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 48]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 49]  
删除刚才建立的表： 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”);  
![在这里插入图片描述][20190509231254551.png]  
// 换台服务器cluster1或者cluster3  
hive> show tables;  
应该可以看到刚才创建的 test\_table  
hive> select \* from test\_table;  
hive> drop table test\_table;  
hive> show tables;  
hive> exit;  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 50]

### 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  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 51]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 52]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 53]  
用浏览器访问 192.168.56.121:8080 可以看到 Spark 的 web 界面，可以看到 3 个  
worker  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 54]

### 5.16安 装 Storm ###

Apache  
Storm是一个分布式实时大数据处理系统。Storm设计用于在容错和水平可扩展方法中处理大量数据。它是一个流数据框架，具有最高的摄取率。虽然Storm是无状态的，它通过Apache  
ZooKeeper管理分布式环境和集群状态。它很简单，您可以并行地对实时数据执行各种操作。  
Apache  
Storm继续成为实时数据分析的领导者。Storm易于设置和操作，并且它保证每个消息将通过拓扑至少处理一次。  
Apache Storm vs Hadoop  
基本上Hadoop和Storm框架用于分析大数据。两者互补，在某些方面有所不同。Apache  
Storm执行除持久性之外的所有操作，而Hadoop在所有方面都很好，但滞后于实时计算。下表比较了Storm和Hadoop的属性。

<table> 
 <thead> 
  <tr> 
   <th><strong>Storm</strong></th> 
   <th><strong>Hadoop</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>实时流处理</td> 
   <td>批量处理</td> 
  </tr> 
  <tr> 
   <td>无状态</td> 
   <td>有状态</td> 
  </tr> 
  <tr> 
   <td>主/从架构与基于<strong>ZooKeeper</strong>的协调。主节点称为nimbus，从属节点是<strong>主管</strong>。</td> 
   <td>具有/不具有基于ZooKeeper的协调的主 - 从结构。主节点是<strong>作业跟踪器</strong>，从节点是<strong>任务跟踪器</strong>。</td> 
  </tr> 
  <tr> 
   <td>Storm流过程在集群上每秒可以访问数万条消息。</td> 
   <td>Hadoop分布式文件系统（HDFS）使用MapReduce框架来处理大量的数据，需要几分钟或几小时。</td> 
  </tr> 
  <tr> 
   <td>Storm拓扑运行直到用户关闭或意外的不可恢复故障。</td> 
   <td>MapReduce作业按顺序执行并最终完成。</td> 
  </tr> 
  <tr> 
   <td><strong>两者都是分布式和容错的</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>如果nimbus / supervisor死机，重新启动使它从它停止的地方继续，因此没有什么受到影响。</td> 
   <td>如果JobTracker死机，所有正在运行的作业都会丢失。</td> 
  </tr> 
 </tbody> 
</table>

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 退出即可。  
测试结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 55]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 56]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 57]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70]: /images/20220203/8489f1aabf4c4ed491ac9c768fe1eefb.png
[https_mirrors.aliyun.com_centos_7_isos_x86_64]: https://mirrors.aliyun.com/centos/7/isos/x86_64/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 1]: /images/20220203/2b59bfa003c4429eb9c5b29e9e5e37c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 2]: /images/20220203/1417a615a7444415ab6104aaad44b546.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 3]: /images/20220203/24d5df22956b4e26a2254b5a6f00d161.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 4]: /images/20220203/48d4b9636cf745169b6c55280750820c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 5]: /images/20220203/635571ec3b734f679a73dad2d739e4c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 6]: /images/20220203/ce93ace9aef84ee9b71cabbc89bbd390.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 7]: /images/20220203/6e043a2e40964bce96f2fe50866c729a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 8]: /images/20220203/9e419c92443e45d48c3514cf61092c60.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 9]: /images/20220203/7643d6046c5a4978979e0da722369482.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 10]: /images/20220203/3e40c6f2b43748da9bcc317f247dc9ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 11]: /images/20220203/c1d6ad73dcbf41b09ad090f5c60ad965.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 12]: /images/20220203/3771865bd01d4c6e82486c8fe3c87d43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 13]: /images/20220203/52bbc7441d5b44a986076d6cd6a9e656.png
[20190509230018225.png]: /images/20220203/c362dd6478e34f0289c6e8b5acbd1c58.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 14]: /images/20220203/a4425931b64f44e8a72330ad795b9b18.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 15]: /images/20220203/32273bc7be1648ad87ebda4c54683a24.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 16]: /images/20220203/71c54dd33eeb486fba25a2bcc1c20a8d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 17]: /images/20220203/7417a8040f3844d19c9094851013467c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 18]: /images/20220203/35429c4292044ba19851d10db9ad2b9d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 19]: /images/20220203/19af5d5ca42e41d890de5ee005af7543.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 20]: /images/20220203/99cdb114195047118dca181c1e9e0d13.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 21]: /images/20220203/da41bbf8932441e09af8acfd00f21738.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 22]: /images/20220203/a12d95f7ec6e4ec0b36f335efc2031aa.png
[https_pan.baidu.com_s_1tak5_8D3JfreBZYwFCLPyA]: https://pan.baidu.com/s/1tak5_8D3JfreBZYwFCLPyA
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 23]: /images/20220203/ad9da4f5fd6f4a569ffbc43255a456be.png
[20190509230232271.png]: /images/20220203/95f5340e366c48289b8ade496fb532c8.png
[20190509230241180.png]: /images/20220203/fbe22f276d664249911c0722e01ff9fd.png
[20190509230310695.png]: /images/20220203/e0d727bb5c7d456798a8419ebd0e3399.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 24]: /images/20220203/63a999447e9c483b94434bfc077ac796.png
[20190509230359699.png]: /images/20220203/9bc36faa89f740468f9f8f7d46d44e34.png
[20190509230407673.png]: /images/20220203/838f1c37fbf84f6fa278ff69c0d89c19.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 25]: /images/20220203/6eaff075697249be97c81a0b30618b4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 26]: /images/20220203/1672417524d646d6ade99493175090f8.png
[2019050923045931.png]: /images/20220203/d09ca09d00da47f1ba475357dc01032f.png
[20190509230505871.png]: /images/20220203/65265c1985b445fcbcf12150d3f59321.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 27]: /images/20220203/94a1ee3064644f21bd83ece4148c8f94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 28]: /images/20220203/8344068400ca466aadc197492456a25d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 29]: https://img-blog.csdnimg.cn/20190509230544607.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 30]: /images/20220203/d6a55f7d4fac4861a9c67e4d644ff9ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 31]: /images/20220203/15dc0d34d63b48089d7e0ec0cf67acde.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 32]: /images/20220203/32d2fb291ea84c07b5cba37fc9ab2ad3.png
[0.centos.pool.ntp.org]: http://0.centos.pool.ntp.org
[1.centos.pool.ntp.org]: http://1.centos.pool.ntp.org
[2.centos.pool.ntp.org]: http://2.centos.pool.ntp.org
[3.centos.pool.ntp.org]: http://3.centos.pool.ntp.org
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 33]: /images/20220203/e9f508d5054f4c62a691ddbcc1a4ff59.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 34]: /images/20220203/d656c39269184487bdf5ac642def5606.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 35]: /images/20220203/dc5048c0c4df4dc885a5da940e7734cd.png
[20190509230728739.png]: /images/20220203/af675b76df544b1da781465883e9fc80.png
[zkServer.sh]: http://zkServer.sh
[20190509230808903.png]: /images/20220203/7078fee114d34c6ea23eb743d7b02226.png
[20190509230814936.png]: /images/20220203/17f6edd41e6749c39f09530a5e34278f.png
[20190509230821675.png]: /images/20220203/46a1c06e4edb458ab0a2bc1283140855.png
[kafka-server-start.sh]: http://kafka-server-start.sh
[20190509230837604.png]: /images/20220203/88db2169d6124fc8bd5b475df37fd3e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 36]: /images/20220203/555661f9a64a49a7b8a9d96abb135585.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 37]: /images/20220203/01e767e3f2214e789feaf2646a988d39.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 38]: /images/20220203/9e5044d2f5b440229c41ffffaf1b5d18.png
[kafka-topics.sh]: http://kafka-topics.sh
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 39]: /images/20220203/f5b7ff6dc0424a45a3b67a75036b7945.png
[kafka-console-producer.sh]: http://kafka-console-producer.sh
[kafka-console-consumer.sh]: http://kafka-console-consumer.sh
[20190509230923767.png]: /images/20220203/fbeece1f7b404111a185f21d98c957d1.png
[kafka-server-stop.sh]: http://kafka-server-stop.sh
[20190509230930529.png]: /images/20220203/b97f6569c38b4c4cbcc5dbb7506b93cb.png
[hadoop-env.sh]: http://hadoop-env.sh
[mapred-env.sh]: http://mapred-env.sh
[hadoop-daemon.sh]: http://hadoop-daemon.sh
[start-dfs.sh]: http://start-dfs.sh
[start-yarn.sh]: http://start-yarn.sh
[stop-yarn.sh]: http://stop-yarn.sh
[stop-dfs.sh]: http://stop-dfs.sh
[20190509231036495.png]: /images/20220203/70adcf742a594319b0ce6f3834679718.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 40]: /images/20220203/d42b0819bfc6415686768b322ebc931f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 41]: /images/20220203/e3bdbd09ae124fad93778e146af79561.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 42]: /images/20220203/d9dd8a40323a4140a7e85f7cfb5b13c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 43]: /images/20220203/63ce218ad7a2408aa9e9db94f29e768c.png
[20190509231118977.png]: /images/20220203/00ed19acc5f443788dea50a15e5a3002.png
[20190509231123795.png]: /images/20220203/dd8c9a265df3499eb0544e7e3d8b842d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 44]: /images/20220203/00f0f028f2974310b01c88ef52f97fe7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 45]: /images/20220203/607efaeda6e048dcbbae78e2fa632eb0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 46]: /images/20220203/7466eae1e1ce4457beba5064ac5d9191.png
[hbase-env.sh]: http://hbase-env.sh
[start-hbase.sh]: http://start-hbase.sh
[stop-hbase.sh]: http://stop-hbase.sh
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 47]: /images/20220203/589c4c36a8bd42558e4da862efd7a2c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 48]: /images/20220203/787626abb0e84817a3059730a67f86ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 49]: /images/20220203/ffe2b92ed93b42e3929740b5f5630297.png
[20190509231254551.png]: /images/20220203/de5ff7cb92dc4fd58440be712ff24f46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 50]: /images/20220203/e9c8b61fb8f948f2903fc2789e89f1f1.png
[spark-env.sh]: http://spark-env.sh
[start-master.sh]: http://start-master.sh
[start-slaves.sh]: http://start-slaves.sh
[stop-slaves.sh]: http://stop-slaves.sh
[stop-master.sh]: http://stop-master.sh
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 51]: /images/20220203/ba05648e289748a3b4690c77647183d4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 52]: /images/20220203/dca76f8fb3564b64a484156f5f5dcc43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 53]: /images/20220203/268a59fe96b84725b2b69043ac34937b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 54]: /images/20220203/a11d6783af914f0b937e98df38fd0e75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 55]: /images/20220203/288608a54edd49439397b99c8b0250a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 56]: /images/20220203/23d2db7b3e4545ce893cc2ef73bc6fef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTcwNTcwMw_size_16_color_FFFFFF_t_70 57]: /images/20220203/029b342350854d4c80c0f9af3f5e113a.png