大数据各个工具随笔DiYong

```shell#目录结构：bin：二进制的客户端命令etc：存放配置文件etc/conflib：存放jar包的目录sbin：存放管理类的脚本启动服务share：hadoop所有的jar包

#查看主机名hostname#临时修改主机名hostnamehadoop#永久修改主机名vi/etc/sysconfig/network#查看主机ipifconfig-a

#静态IP配置setup编辑网卡或vi/etc/sysconfig/network-scripts/ifcfg-eth0或eth1servicenetworkrestart重启网络服务

#配置映射关系vi/etc/hosts#时钟同步ntpdateus.pool.ntp.org#此命令即可和时钟服务器进行同步crontab-e#设置定时任务

#查看防火墙规则vim/etc/sysconfig/iptables#关闭防火墙：serviceiptablesstop#永久关闭：chkconfigiptablesoff#重启防火墙systemctlrestartfirewalld#关闭深层防火墙selinux需重启liunxvim/etc/selinux/config#打开配置文件SELINUX=enforcing更改为SELINUX=disabled

#下载rz并全自动安装yum-yinstalllrzsz#下载文件sz默认下载地址

#创建普通用户useradd普通用户名passwd普通用户密码visudo：会打开一个文件，该文件中可以配置让普通用户越权执行命令hpskALL=(root)NOPASSWD:ALLsu-普通用户名/root#切换用户或用exit#修改目录用户chown-Rroot:rootexport或chown-R用户名:用户名目录名

tar-zxvf文件名-C路径#解压到指定目录Unzip文件名-d路径#解压到指定目录scp-r文件名用户名@主机名:$PWD#发送到同级目录scp-r文件名用户名@主机名:/export/servers#发送到指定目录

mv原名重命名#重命名mv文件名路径#移动

#查看日志tail-100flogs/kafka.log

#修改环境变量:vi/etc/profile#立即生效：source/etc/profile#创建软连接ln-s【目标目录】【软链接地址】#删除链接rm-rf【软链接地址】#修改链接ln-snf【新目标目录】【软链接地址】

#添加到启动列表chkconfigredison验证：chkconfig--list

kill-9进程号强制终止进程

#解决进程杀不掉cd/tmp查看hsperfdata_开头的目录rm-rf删除下边文件号

df-h查看资源占用情况

top查看实时更新进程ps-lA查看所有进程pstree-P以树状形式显示进程，并显示进程号kill-9-1杀死所有进程ps-aux查看所有进程包括后台进程只显示自己的进程号（PID）ps-ef查询系统中所有运行的进程可以显示每个进程的父进程号(PPID)psaux|greptomact解释：以管道形式搜索```

```shell#netstat命令各个参数说明如下：

-t:指明显示TCP端口-u:指明显示UDP端口-l:仅显示监听套接字(所谓套接字就是使应用程序能够读写与收发通讯协议(protocol)与资料的程序)-p:显示进程标识符和程序名称，每一个套接字/端口都属于一个程序。-n:不进行DNS轮询，显示IP(可以加速操作)即可显示当前服务器上所有端口及进程服务，于grep结合可查看某个具体端口及服务情况

netstat-ntlp//查看当前所有tcp端口·netstat–tnl可以看到处于监听状态的TCP端口和连接netstat-ntulp|grep80//查看所有80端口使用情况·netstat-an|grep3306//查看所有3306端口使用情况·netstat-atunlp|grep10000

#查看一台服务器上面哪些服务及端口netstat-lanp#查看一个服务有几个端口。比如要查看mysqldps-ef|grepmysqld#查看某一端口的连接数量,比如3306端口netstat-pnt|grep:3306|wc#查看某一端口的连接客户端IP比如3306端口netstat-anp|grep3306

netstat-an查看网络端口lsof-i:port，使用lsof-i:port就能看见所指定端口运行的程序，同时还有当前连接。nmap端口扫描netstat-nupl(UDP类型的端口)netstat-ntpl(TCP类型的端口)netstat-anp显示系统端口使用情况```

```shell#1-手动添加一块硬盘：详细过程参考图片注意该虚拟硬盘所在的物理硬盘剩余空间至少大于15GB#2-创建分区fdisk-l确认出现/dev/sdb该硬盘设备fdisk/dev/sdb对sdb硬盘进行分区p查看当前硬盘的分区信息n创建新分区p分区类型为主分区1分区号为1回车硬盘起始位置，默认为0回车硬盘结束位置，默认为最大值p查看当前硬盘的分区信息w保存并退出mkfs-text4/dev/sdb1格式化硬盘分区#3-挂载目录创建挂载目录：mkdir/export/users手动临时挂载：mount/dev/sdb1/export/users验证是否挂载成功：df-h永久挂载，开机自动加载：echo"/dev/sdb1/export/usersext4defaults00">>/etc/fstab```

##java

rpm-qa|grepjava查看是否已经安装了jdkrpm-e--nodeps软件的名称将软件进行卸载

修改环境变量:vi/etc/profile立即生效：

source/etc/profile

##mysql

一、rpm安装包安装

```shell#1.查看系统自带的mysql的rpm包rpm-qa|grepmysql删除自带安装包rpm-emysql-libs-5.1.73-8.el6_8.x86_64--nodeps#2.安装mysql的rpm包rpm-ivh*.rpm或rpm-ivhMySQL-client-5.6.25-1.el6.x86_64.rpm#3.启动mysql的服务

启动脚本:servicemysqlstart关闭脚本:servicemysqlstop重启：servicemysqldrestart

#4.查看mysql初始化密码cat/root/.mysql_secret

#6.在mysql中修改自己的密码setpassword=password('密码');

#8.设置mysql的开机启动chkconfig--addmysqldchkconfigmysqldon

#9.查询列表：chkconfig#10.卸载rpm-qa|grep-imysql#查看所有mysql的安装包

卸载所有mysql的安装包

rpm-e--nodepsMySQL-server-5.6.25-1.el6.x86_64

MySQL-client-5.6.25-1.el6.x86_64

MySQL-devel-5.6.25-1.el6.x86_64

MySQL-shared-compat-5.6.25-1.el6.x86_64

MySQL-embedded-5.6.25-1.el6.x86_64

MySQL-test-5.6.25-1.el6.x86_64

MySQL-shared-5.6.25-1.el6.x86_64

#查看是否卸载干净rpm-qa|grep-imysql

#查看哪里还有mysql的文件夹whereismysql

删除所有关于mysql的配置以及文件夹即可

删掉rm-rf/usr/lib64/mysql

删掉rm-rf/usr/my.cnf

删掉rm-rf/root/.mysql_secret

删掉rm-rf/var/lib/mysql```

二、在线安装（5.1.73）

```

三、在线安装（5.7）

##git

##nginx

```shell./nginx启动./nginx-sstop停止./nginx-sreload重启修改完配置文件，必须重新启动才会生效./nginx-t检查配置文件的合法性```1)安装依赖环境:由于nginx为C语言开发,需要C语言依赖环境

```yuminstall-ygcc-c++pcrepcre-develzlibzlib-developensslopenssl-devel./configure\```

2.上传解压安装包

```使用rz上传即可,上传到/export/software目录下tar-zxvfnginx-1.8.0.tar.gzcdnginx-1.8.0```

3.设置编译参数

--pid-path=/export/data/nginx/nginx.pidnginx的pid文件存放的位置待会需要创建这个目录nginx

--error-log-path=/export/logs/nginx/error.lognginx错误日志存放的文件目录

4.编译安装

```先创建数据和日志存放的文件夹mkdir-p/export/data/nginxmkdir-p/export/logs/nginx进行编译和安装cd/export/software/nginx-1.8.0#切换nginx根目录make#编译makeinstall#安装,安装后在/export/servers/nginx```

5.#启动nginx

```cd/export/servers/nginx/sbin./nginx#启动nginx

查看nginx启动进程ps-ef|grepnginx

注意：执行./nginx启动nginx，这里可以-c指定加载的nginx配置文件，如下：./nginx-c/export/servers/nginx/conf/nginx.conf如果不指定-c，nginx在启动时默认加载conf/nginx.conf文件，此文件的地址也可以在编译安装nginx时指定./configure的参数（--conf-path=指向配置文件（nginx.conf））

停止nginx:快速停止:cd/export/servers/nginx/sbin./nginx-sstop此方式相当于先查出nginx进程id再使用kill命令强制杀掉进程。完整停止(推荐使用):cd/usr/local/nginx/sbin./nginx-squit此方式停止步骤是待nginx进程处理任务完毕进行停止。重启nginx:先停止再启动（建议使用）：对nginx进行重启相当于先停止nginx再启动nginx，即先执行停止命令再执行启动命令。如下：./nginx-squit./nginx

重新加载配置文件：当nginx的配置文件nginx.conf修改后，要想让配置生效需要重启nginx，使用-sreload不用先停止nginx再启动nginx即可将配置信息在nginx中生效，如下：./nginx-sreload```

6.使用nginx

```修改配置文件:conf/nginx.conf文件```

7.安装测试

**发布网站到服务器中**


```另一种方式：我们可以将页面复制到nginx的目录下，然后访问

-使用此种方式,需要修改nginx的配置文件:nginx.conf-修改完配置文件后:需要重新加载一下配置文件:./nginx-sreload```



但是我们可以发现这样，通过IP地址可以访问。但是IP其实相对来讲是很难记住的，我们通常会通过域名去访问一个网站。


**网站访问的过程**


**修改hosts文件**

```shell进入电脑C:\Windows\System32\drivers\etc下查找一个hosts文件

192.168.72.142www.jx.com#如果使用的是公开的比较有名的域名,可能会导致访问不到,建议使用ie浏览器尝试,或者换一个自定义域名

**配置nginx的反向代理,实现网站发布(重点)**


```这个过程被称为是反向代理,原来浏览器直接请求tomcat,获得内容,现在由nginx作为代理,请求目标地址,并将目标地址的数据返回给浏览器```


如何配置呢.

-1)修改配置文件:conf/nginx.conf文件,添加如下内容-提示:可以直接打开配置文件,拉到最下面,在最后一个没有被注释的大括号前书写

```pstreamtomcat1{server192.168.72.141:8080;server192.168.72.142:8080;server192.168.72.143:8080;}

server{listen80;server_namelocalhost;


**负载均衡**

```负载均衡是由多台服务器以对称的方式组成一个服务器集合，每台服务器都具有等价的地位，都可以单独对外提供服务而无须其他服务器的辅助。

通过某种负载分担技术，将外部发送来的请求均匀分配到对称结构中的某一台服务器上，而接收到请求的服务器独立地回应客户的请求。均衡负载能够平均分配客户请求到服务器列阵，借此提供快速获取重要数据，解决**大量并发访问**服务问题。(廉价的)```

**nginx的负载均衡**

```我们可以在nginx上配置多台服务器,当大量并发访问的时候,我们通过nginx将这些并发请求根据一定的规则平均分派到多台服务器,提高服务器高可用```


**如何在nginx中配置负载均衡(重点)**


1)修改配置文件

}}

**********上述代码是原始内容,只需要更改upsteam中的server即可

#第一种方案:配置多台server,nginx就会自动进行负载均衡,将并发请求平均分配给这两个服务器upstreamtomcat1{server192.168.72.141:8080;server192.168.72.142:8080;server192.168.72.143:8080;}#第二种方案:可以根据服务器的实际情况调整服务器权重。权重越高分配的请求越多，权重越低，请求越少。默认是都是1upstreamtomcat1{server192.168.72.141:8080weight=3;server192.168.72.142:8080weight=1;server192.168.72.143:8080weight=6;}#例如设置为2,表示第二个服务器所能承受比第一台两倍的并发请求,此时,nginx就会权重分配,如果有6个并发请求,第二台会承受4个请求,而第一台只会承受2个请求

注意:1.三台服务器中的tomcat必须保证可以正常访问2.nginx的配置文件修改后,一定要重新加载nginx:./nginx-sreload```

##redis

添加到启动列表chkconfigredison验证：chkconfig--list

serviceredisstart启动serviceredisstop停止serviceredisrestart重启serviceredisstatus查看状态1.下载redis安装包

解压：tar-zxvfredis-4.0.2.tar.gz-C../servers

2.安装编译环境

```yum-yinstallgccgcc-c++libstdc++-develtcl-y```

3.编译并进行安装redis

```cd/export/servers/redis-src/makeMALLOC=libcmakePREFIX=/export/servers/redisinstall```

4.在指定的位置创建一个redis的配置文件

mkdir-p/export/servers/redis/confcd/export/servers/redis/confviredis_6379.conf

配置文件内容：

4.启动redis的服务

```mkdir-p/export/data/redis/6379/cd/export/servers/redis/bin/./redis-server../conf/redis_6379.conf```

5.客户端连接

cd/export/servers/redis/bin/./redis-cli-h192.168.72.142以下命令为检测命令:输入:ping返回pong表示成功

客户端退出:第一种:强制退出Ctrl+c第二种:quit

##sorl

1.solr的下载

##zookeeper

```shell1.上传解压安装包

2.在conf目录下修改zoo_sample.cfg文件修改dataDir=/export/data/zk在底部添加

server.1=node01:2887:3887

server.2=node02:2887:3887server.3=node03:2887:3887（zookeeper客户端连接端口：2181；2887：服务器间通信的端口

3887：选举的端口）3.将配置好的zookeeper发送到其他主机

4.分别输入以下命令，配置myid

node01:执行的命令mkdir-p/export/data/zkecho"1">/export/data/zk/myid//将1字符串写入myid这个文件中,文件位置和文件名不可以修改cat/export/data/zk/myid//此命令用于查看此文件有没有正确写入1

node02:执行的命令mkdir-p/export/data/zkecho"2">/export/data/zk/myidcat/export/data/zk/myid//此命令用于查看此文件有没有正确写入2

node03:执行的命令mkdir-p/export/data/zkecho"3">/export/data/zk/myidcat/export/data/zk/myid//此命令用于查看此文件有没有正确写入3```

sbin/zkServer.shstart启动

sbin/zkServer.shstatus查看状态

sbin/zkServer.shrestart重启

sbin/zkServer.shstop停止

##ELK

**Elasticsearch安装部署**

```shell1创建用户创建一个es专门的用户（必须），因为es不能用root用户启动#使用root用户在三台机器执行以下命令useraddesmkdir-p/export/servers/esmkdir-p/export/data/esmkdir-p/export/logs/eschown-Res/export/servers/eschown-Res/export/data/eschown-Res/export/logs/espasswdes

2为es用户添加sudo权限三台机器使用root用户执行visudo然后为es用户添加权限visudoesALL=(ALL)ALL

关闭我们的xshll的所有的会话，重新连接，一定要记得使用es的用户来连接我们的linux服务器

5安装包分发到其他两台机器上node01服务器执行以下命令cd/export/servers/esscp-relasticsearch-6.0.0/node02:$PWDscp-relasticsearch-6.0.0/node02:$PWD

6node02与node03服务器修改配置文件node02服务器修改配置文件cd/export/servers/es/elasticsearch-6.0.0/configvimelasticsearch.yml

node03服务器修改配置文件

7、三台机器修改jvm内存大小三台机器执行以下命令修改jvm内存大小cd/export/servers/es/elasticsearch-6.0.0/configvijvm.options-Xms2g-Xmx2g8、三台机器修改系统配置，增加打开文件的最大数量问题一：maxfiledescriptors[4096]forelasticsearchprocesslikelytoolow,increasetoatleast[65536]ES因为需要大量的创建索引文件，需要大量的打开系统的文件，所以我们需要解除linux系统当中打开文件最大数目的限制，不然ES启动就会抛错三台机器执行以下命令解除打开文件数据的限制sudovi/etc/security/limits.conf添加如下内容:注意*不要去掉了*softnofile65536*hardnofile131072*softnproc2048*hardnproc4096

问题二：maxnumberofthreads[1024]foruser[es]likelytoolow,increasetoatleast[4096]修改普通用户可以创建的最大线程数maxnumberofthreads[1024]foruser[es]likelytoolow,increasetoatleast[4096]原因：无法创建本地线程问题,用户最大可创建线程数太小解决方案：修改90-nproc.conf配置文件。三台机器执行以下命令修改配置文件sudovi/etc/security/limits.d/90-nproc.conf找到如下内容：*softnproc1024#修改为*softnproc4096

问题三：maxvirtualmemoryareasvm.max_map_count[65530]likelytoolow,increasetoatleast[262144]调大系统的虚拟内存maxvirtualmemoryareasvm.max_map_count[65530]likelytoolow,increasetoatleast[262144]原因：最大虚拟内存太小每次启动机器都手动执行下。三台机器执行以下命令，注意每次启动ES之前都要执行sudosysctl-wvm.max_map_count=262144

2启动es服务

```1启动注意啦，同学们！这里是后台启动，要发现错误的话，去/export/logs/es目录下查看。nohup/export/servers/es/elasticsearch-6.0.0/bin/elasticsearch>/dev/null2>&1&

**3node01服务器安装elasticsearch-head插件**

1、node01机器安装nodejs

第二步：解压安装包执行以下命令进行解压cd/home/estar-zxvfnode-v8.1.0-linux-x64.tar.gz-C/export/servers/es/第三步：创建软连接#修改目录执行以下命令创建软连接sudoln-s/export/servers/es/node-v8.1.0-linux-x64/lib/node_modules/npm/bin/npm-cli.js/usr/local/bin/npmsudoln-s/export/servers/es/node-v8.1.0-linux-x64/bin/node/usr/local/bin/node第四步：修改环境变量#修改环境变量sudovim/etc/profile

exportNODE_HOME=/export/servers/es/node-v8.1.0-linux-x64exportPATH=:$PATH:$NODE_HOME/bin

source/etc/profile第五步：验证安装成功node-vnpm–v```


2、node01机器安装elasticsearch-head插件


第三步、node01机器修改Gruntfile.js第一台机器修改Gruntfile.js这个文件cd/export/servers/es/elasticsearch-headvimGruntfile.js找到以下代码：添加一行：hostname:'192.168.52.100',connect:{server:{options:{hostname:'192.168.52.100',port:9100,base:'.',keepalive:travelue}}}

第四步、node01机器修改app.js

第一台机器修改app.jscd/export/servers/es/elasticsearch-head/_sitevimapp.js```


**2、第二种方式：直接使用提供的编译之后的源码包解压之后修改配置文件即可（强烈推荐）**

```shell第一步：上传压缩包到/home/es路径下去将我们的压缩包compile-head.tar上传到第一台机器的/home/es路径下面去第二步：解压安装包cd/home/es/tar-xvfcompile-head.tar-C/export/servers/es/第三步、node01机器修改Gruntfile.js修改Gruntfile.js这个文件cd/export/servers/es/elasticsearch-headvimGruntfile.js找到以下代码：添加一行：hostname:'192.168.52.100',connect:{server:{options:{hostname:'192.168.52.100',port:9100,base:'.',keepalive:true}}}


```shell3、重启es服务注意：使用es用户启动直接使用kill-9杀死三台机器的es服务，然后重新启动nohup/export/servers/es/elasticsearch-6.0.0/bin/elasticsearch>/dev/null2>&1&

4、node01机器启动head服务node01启动elasticsearch-head插件cd/export/servers/es/elasticsearch-head/node_modules/grunt/bin/进程前台启动命令./gruntserver进程后台启动命令nohup./gruntserver>/dev/null2>&1&


**4、node01服务器安装Kibana**

停止kibana服务进程查看进程号ps-ef|grepnode然后使用kill-9杀死进程即可

**IK分词器的安装**

**安装**

将安装包分发到其他机器上node01机器执行以下命令进行安装包的分发cd/export/servers/es/elasticsearch-6.0.0/pluginsscp-ranalysis-ik/node02:$PWDscp-ranalysis-ik/node03:$PWD#三台机器都配置完成#配置完成之后，需要重启服务。

三台机器重启es服务三台机器执行以下命令停止es服务

ps-ef|grepelasticsearch|grepbootstravelap|awk'{print$2}'|xargskill-9

nohup/export/servers/es/elasticsearch-6.0.0/bin/elasticsearch>/dev/null2>&1&```

**配置**

```shelldeleteiktestPUT/iktestpretty{"settings":{"analysis":{"analyzer":{"ik":{"tokenizer":"ik_max_word"}}}},"mappings":{"article":{"dynamic":true,"properties":{"subject":{"type":"text","analyzer":"ik_max_word"}}}}}

查看分词效果GET_analyzepretty{"analyzer":"ik_max_word","text":"传智播客在哪里"}```

node03配置Tomcat


修改完成之后拷贝到node02与node03机器上面去node01执行以下命令进行拷贝cd/export/servers/es/elasticsearch-6.0.0/plugins/analysis-ik/configsudoscpIKAnalyzer.cfg.xmlnode02:$PWDsudoscpIKAnalyzer.cfg.xmlnode03:$PWD7.5.3三台机器修改JDK权限三台机器修改jdk的权限问题第一台机器执行以下命令修改jdk的权限问题#修改JDK安全设置cd/export/servers/jdk1.8.0_141/jre/lib/securitysudovimjava.policy添加以下四行配置permissionjava.net.SocketPermission"192.168.52.102:8080","accept";permissionjava.net.SocketPermission"192.168.52.102:8080","listen";permissionjava.net.SocketPermission"192.168.52.102:8080","resolve";permissionjava.net.SocketPermission"192.168.52.102:8080","connect";

修改完成之后拷贝到第二台和第三台机器node01执行以下命令拷贝到第二台和第三台cd/export/servers/jdk1.8.0_141/jre/lib/securitysudoscpjava.policynode02:$PWDsudoscpjava.policynode03:$PWD


```shell查看我们的分词过程GET_analyzepretty{"analyzer":"ik_max_word","text":"传智播客在哪里"}

**LogStash**

1、LogStash介绍及安装

##Azkaban

在一个完整的离线大数据处理系统中，除了hdfs+mapreduce+hive组成分析系统的核心之外，还需要数据采集、结果数据导出、任务调度等不可或缺的辅助系统，而这些辅助工具在hadoop生态体系中都有便捷的开源框架，如图所示：


**概述**

azkaban官网：

**为什么需要工作流调度系统**

l一个完整的数据分析系统通常都是由大量任务单元组成：

shell脚本程序，java程序，mapreduce程序、hive脚本等

l为了很好地组织起这样的复杂执行计划，需要一个工作流调度系统来调度执行；

例如，我们可能有这样一个需求，某个业务系统每天产生20G原始数据，我们每天都要对其进行处理，处理步骤如下所示：

1、通过Hadoop先将原始数据同步到HDFS上；

2、借助MapReduce计算框架对原始数据进行转换，生成的数据以分区表的形式存储到多张Hive表中；

3、需要对Hive中多个表的数据进行JOIN处理，得到一个明细数据Hive大表；

4、将明细数据进行各种统计分析，得到结果报表信息；

5、需要将统计分析得到的结果数据同步到业务系统中，供业务调用使用。

**工作流调度实现方式**

简单的任务调度：直接使用linux的crontab来定义；

复杂的任务调度：开发调度平台或使用现成的开源调度系统，比如ooize、azkaban、airflow等

**常见工作流调度系统**

市面上目前有许多工作流调度器

在hadoop领域，常见的工作流调度器有Oozie,Azkaban,Cascading,Hamake等

**各种调度工具特性对比**

下面的表格对上述四种hadoop工作流调度器的关键特性进行了比较，尽管这些工作流调度器能够解决的需求场景基本一致，但在设计理念，目标用户，应用场景等方面还是存在显著的区别，在做技术选型的时候，可以提供参考

|特性|Hamake|Oozie|Azkaban|Cascading||------------------|--------------------|-----------------|------------------------------|---------||工作流描述语言|XML|XML(xPDLbased)|textfilewithkey/valuepairs|JavaAPI||依赖机制|data-driven|explicit|explicit|explicit||是否要web容器|No|Yes|Yes|No||进度跟踪|console/logmessages|webpage|webpage|JavaAPI||Hadoopjob调度支持|no|yes|yes|yes||运行模式|commandlineutility|daemon|daemon|API||Pig支持|yes|yes|yes|yes||事件通知|no|no|no|yes||需要安装|no|yes|yes|no||支持的hadoop版本|0.18+|0.20+|currentlyunknown|0.18+||重试支持|no|workflownodeevel|yes|yes||运行任意命令|yes|yes|yes|yes||AmazonEMR支持|yes|no|currentlyunknown|yes|

**Azkaban与Oozie对比**

对市面上最流行的两种调度器，给出以下详细对比，以供技术选型参考。总体来说，ooize相比azkaban是一个重量级的任务调度系统，功能全面，但配置使用也更复杂。如果可以不在意某些功能的缺失，轻量级调度器azkaban是很不错的候选对象。

详情如下：

u功能

两者均可以调度mapreduce,pig,java,脚本工作流任务

两者均可以定时执行工作流任务

u工作流定义

Azkaban使用Properties文件定义工作流

Oozie使用XML文件定义工作流

u工作流传参

Azkaban支持直接传参，例如${input}

Oozie支持参数和EL表达式，例如${fs:dirSize(myInputDir)}

u定时执行

u资源管理

Azkaban有较严格的权限控制，如用户对工作流进行读/写/执行等操作

Oozie暂无严格的权限控制

u工作流执行

Azkaban有两种运行模式，分别是soloservermode(executorserver和webserver部署在同一台节点)和multiservermode(executorserver和webserver可以部署在不同节点)

Oozie作为工作流服务器运行，支持多用户和多工作流

u工作流管理

Azkaban支持浏览器以及ajax方式操作工作流

Oozie支持命令行、HTTPREST、JavaAPI、浏览器操作工作流

**Azkaban介绍**

Azkaban是由Linkedin开源的一个批量工作流任务调度器。用于在一个工作流内以一个特定的顺序运行一组工作和流程。

Azkaban定义了一种KV文件(properties)格式来建立任务之间的依赖关系，并提供一个易于使用的web用户界面维护和跟踪你的工作流。

它有如下功能特点：

Web用户界面

方便上传工作流

方便设置任务之间的关系

调度工作流

能够杀死并重新启动工作流

模块化和可插拔的插件机制

项目工作区

工作流和任务的日志记录和审计

###Azkaban安装部署

**2.3.1、azkaban的编译**

我们这里选用azkaban3.51.0这个版本自己进行重新编译，编译完成之后得到我们需要的安装包进行安装

注意：我们这里编译需要使用jdk1.8的版本来进行编译，如果编译服务器使用的jdk版本是1.7的，记得切换成jdk1.8，我们这里使用的是jdk8u141这个版本来进行编译

cd/export/softwares/

```shelltar-zxvf3.51.0.tar.gz-C../servers/cd/export/servers/azkaban-3.51.0/yum-yinstallgityum-yinstallgcc-c++./gradlewbuildinstallDist-xtest```

**编译之后需要的安装文件列表如下**

**azkaban-exec-server**

编译完成之后得到我们需要的安装包在以下目录下即可获取得到

azkaban-exec-server存放目录

/export/servers/azkaban-3.51.0/azkaban-exec-server/build/distributions


**azkaban-web-server**

azkaban-web-server存放目录

/export/servers/azkaban-3.51.0/azkaban-web-server/build/distributions


**azkaban-solo-server**

azkaban-solo-server存放目录

/export/servers/azkaban-3.51.0/azkaban-solo-server/build/distributions


**execute-as-user.c**

azkabantwoserver模式下需要的C程序在这个路径下面

/export/servers/azkaban-3.51.0/az-exec-util/src/main/c


**数据库脚本文件**

数据库脚本文件在这个路径下面

/export/servers/azkaban-3.51.0/azkaban-db/build/install/azkaban-db


###azkaban单服务模式安装与使用

**所需软件**

azkaban-solo-server

**单服务模式安装**

**第一步：解压**

azkaban的soloserver使用的是一个单节点的模式来进行启动服务的，只需要一个

azkaban-solo-server-0.1.0-SNAPSHOT.tar.gz的安装包即可启动，所有的数据信息都是保存在H2这个azkaban默认的数据当中，

上传我们的压缩包，然后修改配置文件启动即可

cd/export/softwares

tar-zxvfazkaban-solo-server-0.1.0-SNAPSHOT.tar.gz-C../servers

**第二步：修改两个配置文件**

修改时区配置文件

cd/export/servers/azkaban-solo-server-0.1.0-SNAPSHOT/conf

vimazkaban.properties

```default.timezone.id=Asia/Shanghai```

修改commonprivate.properties配置文件

cd/export/servers/azkaban-solo-server-0.1.0-SNAPSHOT/plugins/jobtypes

vimcommonprivate.properties

execute.as.user=false

memCheck.enabled=false


**第三步：启动solo-server**

启动azkaban-solo-server

cd/export/servers/azkaban-solo-server-0.1.0-SNAPSHOT

bin/start-solo.sh

**第四步：浏览器页面访问**

浏览器页面访问


**单服务模式使用**

需求：使用azkaban调度我们的shell脚本，执行linux的shell命令




创建普通文本文件foo.job，文件内容如下

type=command

command=echo"helloworld"

然后将这个文件打包为压缩文件，如下：


azkaban上传我们的压缩包




###azkaban两个服务模式安装

**1、确认所需软件：**

**AzkabanWeb服务安装包**

azkaban-web-server-0.1.0-SNAPSHOT.tar.gz

**Azkaban执行服务安装包**

azkaban-exec-server-0.1.0-SNAPSHOT.tar.gz

**编译之后的sql脚本**

create-all-sql-0.1.0-SNAPSHOT.sql


**C程序文件脚本**

execute-as-user.c程序

**2、数据库准备**

进入mysql的客户端执行以下命令

mysql-uroot-p

执行以下命令：

```sqlCREATEDATABASEazkaban;CREATEUSER'azkaban'@'%'IDENTIFIEDBY'azkaban';GRANTallprivilegesONazkaban.*to'azkaban'@'%'identifiedby'azkaban'WITHGRANTOPTION;flushprivileges;useazkaban;source/export/softwares/create-all-sql-0.1.0-SNAPSHOT.sql;```


**3、解压软件安装包**

解压azkaban-web-server

tar-zxvfazkaban-web-server-0.1.0-SNAPSHOT.tar.gz-C../servers/

cd/export/servers

mvazkaban-web-server-0.1.0-SNAPSHOT/azkaban-web-server-3.51.0

解压azkaban-exec-server

tar-zxvfazkaban-exec-server-0.1.0-SNAPSHOT.tar.gz-C../servers/

mvazkaban-exec-server-0.1.0-SNAPSHOT/azkaban-exec-server-3.51.0

**4、安装SSL安全认证**

密码一定要一个个的字母输入，或者粘贴也行

cd/export/servers/azkaban-web-server-3.51.0

keytool-keystorekeystore-aliasjetty-genkey-keyalgRSA

**5、azkabanwebserver安装**

**修改azkaban-web-server的配置文件**

```shellcd/export/servers/azkaban-web-server-3.51.0/conf

#AzkabanPersonalizationSettings

azkaban.name=Azkabanazkaban.label=MyAzkabanazkaban.color=#FF3601azkaban.default.servlet.path=/indexweb.resource.dir=web/default.timezone.id=Asia/Shanghai

#AzkabanUserManagerclass

user.manager.class=azkaban.user.XmlUserManageruser.manager.xml.file=conf/azkaban-users.xml

#Loaderforprojects

executor.global.properties=conf/global.propertiesazkaban.project.dir=projects

#Velocitydevmode

velocity.dev.mode=false

#AzkabanJettyserverproperties.

jetty.use.ssl=truejetty.maxThreads=25jetty.port=8081jetty.ssl.port=8443jetty.keystore=/export/servers/azkaban-web-server-3.51.0/keystorejetty.password=azkabanjetty.keypassword=azkabanjetty.truststore=/export/servers/azkaban-web-server-3.51.0/keystorejetty.trustpassword=azkaban

#AzkabanExecutorsettings#mailsettingsmail.sender=mail.host=

#UserfacingwebserverconfigurationsusedtoconstructtheuserfacingserverURLs.TheyareusefulwhenthereisareverseproxybetweenAzkabanwebserversandusers.

#enduser->myazkabanhost:443->proxy->localhost:8081#whenthisparameterssetthentheseparametersareusedtogenerateemaillinks.#iftheseparametersarenotsetthenjetty.hostname,andjetty.port(ifsslconfiguredjetty.ssl.port)areused.#azkaban.webserver.external_hostname=myazkabanhost.com#azkaban.webserver.external_ssl_port=443#azkaban.webserver.external_port=8081

job.failure.email=job.success.email=lockdown.create.projects=falsecache.directory=cache

#JMXstats

jetty.connector.stats=trueexecutor.connector.stats=true

#Azkabanmysqlsettingsbydefault.Usersshouldconfiguretheirownusernameandpassword.

database.type=mysqlmysql.port=3306mysql.host=node03mysql.database=azkabanmysql.user=azkabanmysql.password=azkabanmysql.numconnections=100

#MultipleExecutor

azkaban.use.multiple.executors=true

#azkaban.executorselector.filters=StaticRemainingFlowSize,MinimumFreeMemory,CpuStatus

azkaban.executorselector.comparator.NumberOfAssignedFlowComparator=1azkaban.executorselector.comparator.Memory=1azkaban.executorselector.comparator.LastDispatched=1azkaban.executorselector.comparator.CpuUsage=1azkaban.activeexecutor.refresh.milisecinterval=10000azkaban.queueprocessing.enabled=trueazkaban.activeexecutor.refresh.flowinterval=10azkaban.executorinfo.refresh.maxThreads=10```

**6、azkabanexecutorserver安装**

**第一步：修改azkaban-exex-server配置文件**

修改azkaban-exec-server的配置文件

cd/export/servers/azkaban-exec-server-3.51.0/conf

```shell#AzkabanPersonalizationSettings

jetty.use.ssl=truejetty.maxThreads=25jetty.port=8081jetty.keystore=/export/servers/azkaban-web-server-3.51.0/keystorejetty.password=azkabanjetty.keypassword=azkabanjetty.truststore=/export/servers/azkaban-web-server-3.51.0/keystorejetty.trustpassword=azkaban

#WheretheAzkabanwebserverislocated

#mailsettings

mail.sender=mail.host=

#UserfacingwebserverconfigurationsusedtoconstructtheuserfacingserverURLs.TheyareusefulwhenthereisareverseproxybetweenAzkabanwebserversandusers.#enduser->myazkabanhost:443->proxy->localhost:8081#whenthisparameterssetthentheseparametersareusedtogenerateemaillinks.#iftheseparametersarenotsetthenjetty.hostname,andjetty.port(ifsslconfiguredjetty.ssl.port)areused.#azkaban.webserver.external_hostname=myazkabanhost.com#azkaban.webserver.external_ssl_port=443#azkaban.webserver.external_port=8081

#Azkabanpluginsettings

azkaban.jobtype.plugin.dir=plugins/jobtypes

#AzkabanExecutorsettings

executor.maxThreads=50executor.flow.threads=30

第二步：添加插件

将我们编译后的C文件execute-as-user.c

上传到这个目录来/export/servers/azkaban-exec-server-3.51.0/plugins/jobtypes

或者直接将我们/export/softwares下面的文件拷贝过来也行

cp/export/softwares/execute-as-user.c/export/servers/azkaban-exec-server-3.51.0/plugins/jobtypes/

然后执行以下命令生成execute-as-user

yum-yinstallgcc-c++cd/export/servers/azkaban-exec-server-3.51.0/plugins/jobtypesgccexecute-as-user.c-oexecute-as-userchownrootexecute-as-userchmod6050execute-as-user

第三步：修改配置文件

修改配置文件

cd/export/servers/azkaban-exec-server-3.47.0/plugins/jobtypesvimcommonprivate.propertiesexecute.as.user=falsememCheck.enabled=falseazkaban.native.lib=/export/servers/azkaban-exec-server-3.51.0/plugins/jobtypes```

最终生成如下


**7、启动服务**

**第一步：启动azkabanexecserver**

cd/export/servers/azkaban-exec-server-3.51.0

bin/start-exec.sh

**第二步：激活我们的exec-server**

node03机器任意目录下执行以下命令

curl-G"node03:$(<./executor.port)/executoraction=activate"&&echo

**第三步：启动azkaban-web-server**

cd/export/servers/azkaban-web-server-3.51.0/

bin/start-web.sh

访问地址：

**修改linux的时区问题**

由于先前做好了时钟同步，所以不用担心时区问题，不需要修改时区了

注：先配置好服务器节点上的时区

1、先生成时区配置文件Asia/Shanghai，用交互式命令tzselect即可

2、拷贝该时区文件，覆盖系统本地时区配置

cp/usr/share/zoneinfo/Asia/Shanghai/etc/localtime

###Azkaban实战

Azkaba内置的任务类型支持command、java

**Command类型单一job示例**

**创建job描述文件**

创建文本文件，更改名称为mycommand.job

注意后缀.txt一定不要带上，保存为格式为UFT-8withoutbom

内容如下

**将job资源文件打包成zip文件**


**创建project并上传压缩包**

通过azkaban的web管理平台创建project并上传job压缩包

首先创建project


上传zip包



**Command类型多job工作流flow**

1、创建有依赖关系的多个job描述

第一个job：foo.job

第二个job：bar.job依赖foo.job

2、将所有job资源文件打到一个zip包中


3、在azkaban的web管理界面创建工程并上传zip包

4、启动工作流flow

**HDFS操作任务**

1、创建job描述文件fs.job

command=/export/servers/hadoop-2.6.0-cdh5.14.0/bin/hadoopfs-mkdir/azkaban

2、将job资源文件打包成zip文件


3、通过azkaban的web管理平台创建project并上传job压缩包

4、启动执行该job

**MAPREDUCE任务**

Mr任务依然可以使用command的job类型来执行

1、创建job描述文件，及mr程序jar包（示例中直接使用hadoop自带的examplejar）

command=/export/servers/hadoop-2.6.0-cdh5.14.0/bin/hadoopjarhadoop-mapreduce-examples-2.6.0-cdh5.14.0.jarpi35


4、启动job

**HIVE脚本任务**

l创建job描述文件和hive脚本

Hive脚本：hive.sql

createdatabaseifnotexistsazhive;

useazhive;

createtableifnotexistsaztest(idstring,namestring)rowformatdelimitedfieldsterminatedby'\t';

Job描述文件：hive.job

command=/export/servers/hive-1.1.0-cdh5.14.0/bin/hive-f'hive.sql'

将所有job资源文件打到一个zip包中


在azkaban的web管理界面创建工程并上传zip包

启动job

**azkaban的定时任务**

使用azkaban的scheduler功能可以实现对我们的作业任务进行定时调度功能



*/1*.**每分钟执行一次定时调度任务

01.**每天晚上凌晨一点钟执行这个任务

0*/2.**每隔两个小时定时执行这个任务

3021.**每天晚上九点半定时执行这个

##**oozie**

**oozie的介绍**

**oozie的架构**


**oozie的执行流程**


**oozie的组件介绍**

workFlow：工作流，定义我们的工作流的任务的执行，主要由一个个的action，在xml中进行配置即可

Coordinator：协作器，说白了就是oozie当中的定时任务调度的模块

Bundle：多个Coordinator的抽象，可以通过bundle将多个Coordinator进行组装集合起来，形成一个bundle

###oozie的安装

**第一步：修改core-site.xml**

修改core-site.xml添加我们hadoop集群的代理用户

cd/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop

vimcore-site.xml

```htmlhadoop.proxyuser.root.hosts*hadoop.proxyuser.root.groups*```

注意：hadoop的历史任务的服务必须启动，即19888端口可以查看，具体如何配置19888请查看hadoop课程的环境搭建

修改完成之后，记得重启hadoop的hdfs与yarn集群，还要记得启动jobhistory

重启hdfs与yarn集群

cd/export/servers/hadoop-2.6.0-cdh5.14.0

sbin/stop-dfs.sh

sbin/start-dfs.sh

sbin/stop-yarn.sh

sbin/start-yarn.sh

**第二步：上传oozie的安装包并解压**

将我们的oozie的安装包上传到/export/softwares

tar-zxvfoozie-4.1.0-cdh5.14.0.tar.gz-C../servers/

**第三步：解压hadooplibs到与oozie平行的目录**

cd/export/servers/oozie-4.1.0-cdh5.14.0

tar-zxvfoozie-hadooplibs-4.1.0-cdh5.14.0.tar.gz-C../


**第四步：创建libext目录**

在oozie的安装路径下创建libext目录

mkdir-plibext

**第五步：拷贝依赖包到libext**

拷贝一些依赖包到libext目录下面去

拷贝所有的依赖包

cp-rahadooplibs/hadooplib-2.6.0-cdh5.14.0.oozie-4.1.0-cdh5.14.0/*libext/

拷贝mysql的驱动包

cp/export/servers/hive-1.1.0-cdh5.14.0/lib/mysql-connector-java-5.1.38.jar/export/servers/oozie-4.1.0-cdh5.14.0/libext/

**第六步：添加ext-2.2.zip压缩包**

拷贝ext-2.2.zip这个包到libext目录当中去

将我们准备好的软件ext-2.2.zip拷贝到我们的libext目录当中去

**第七步：修改oozie-site.xml**

cd/export/servers/oozie-4.1.0-cdh5.14.0/conf

vimoozie-site.xml

如果没有这些属性，直接添加进去即可，oozie默认使用的是UTC的时区，我们需要在我们oozie-site.xml当中记得要配置我们的时区为GMT+0800时区

```xmloozie.service.JPAService.jdbc.drivercom.mysql.jdbc.Driveroozie.service.JPAService.jdbc.urljdbc:mysql://node03.hadoop.com:3306/oozieoozie.service.JPAService.jdbc.usernamerootoozie.service.JPAService.jdbc.password123456oozie.processing.timezoneGMT+0800oozie.service.ProxyUserService.proxyuser.hue.hosts*oozie.service.ProxyUserService.proxyuser.hue.groups*oozie.service.coord.check.maximum.frequencyfalseoozie.service.HadoopAccessorService.hadoop.configurations*=/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop```

**第八步：创建mysql数据库**

createdatabaseoozie;

**第九步：上传oozie依赖的jar包到hdfs上面去**

上传oozie的解压后目录的yarn.tar.gz到hdfs目录去

bin/oozie-setup.shsharelibcreate-fshdfs://node01:8020-localliboozie-sharelib-4.1.0-cdh5.14.0-yarn.tar.gz

实际上就是将这些jar包解压到了hdfs上面的路径下面去了

**第十步：创建oozie的数据库表**

bin/oozie-setup.shdbcreate-run-sqlfileoozie.sql

**第十一步：打包项目，生成war包**

bin/oozie-setup.shprepare-war

**第十二步：配置oozie的环境变量**

vim/etc/profile

exportOOZIE_HOME=/export/servers/oozie-4.1.0-cdh5.14.0

exportPATH=:$OOZIE_HOME/bin:$PATH


**第十三步：启动与关闭oozie服务**

启动命令

bin/oozied.shstart

关闭命令

bin/oozied.shstop


**第十四步：浏览器页面访问oozie**

解决oozie的页面的时区问题：

修改js当中的时区问题

cd/export/servers/oozie-4.1.0-cdh5.14.0/oozie-server/webapps/oozie

vimoozie-console.js

```functiongetTimeZone(){Ext.state.Manager.setProvider(newExt.state.CookieProvider());returnExt.state.Manager.get("TimezoneId","GMT+0800");

}```


重启oozie即可

关闭oozie服务

启动oozie服务

###oozie的使用

**1.使用oozie调度shell脚本**

oozie安装好了之后，我们需要测试oozie的功能是否完整好使，官方已经给我们带了各种测试案例，我们可以通过官方提供的各种案例来对我们的oozie进行调度

**第一步：解压官方提供的调度案例**

oozie自带了各种案例，我们可以使用oozie自带的各种案例来作为模板，所以我们这里先把官方提供的各种案例给解压出来

tar-zxfoozie-examples.tar.gz


**第二步：创建我们的工作目录**

在任意地方创建一个oozie的工作目录，以后我们的调度任务的配置文件全部放到oozie的工作目录当中去

我这里直接在oozie的安装目录下面创建工作目录

mkdiroozie_works

**第三步：拷贝我们的任务模板到我们的工作目录当中去**

我们的任务模板以及工作目录都准备好了之后，我们把我们的shell的任务模板拷贝到我们oozie的工作目录当中去

cp-rexamples/apps/shell/oozie_works/

**第四步：随意准备一个shell脚本**

vimoozie_works/shell/hello.sh

注意：这个脚本一定要是在我们oozie工作路径下的shell路径下的位置

\#!/bin/bash

echo"helloworld">>/export/servers/hello_oozie.tx

**第五步：修改模板下的配置文件**

修改job.properties

cd/export/servers/oozie-4.1.0-cdh5.14.0/oozie_works/shell

vimjob.properties

```shellnameNode=hdfs://node01:8020jobTracker=node01:8032queueName=defaultexamplesRoot=oozie_worksoozie.wf.application.path=${nameNode}/user/${user.name}/${examplesRoot}/shellEXEC=hello.sh```

修改workflow.xml

vimworkflow.xml

```xml${jobTracker}${nameNode}mapred.job.queue.name${queueName}${EXEC}/user/root/oozie_works/shell/${EXEC}#${EXEC}${wf:actionData('shell-node')['my_output']eq'HelloOozie'}Shellactionfailed,errormessage[${wf:errorMessage(wf:lastErrorNode())}]Incorrectoutput,expected[HelloOozie]butwas[${wf:actionData('shell-node')['my_output']}]```

**第六步：上传我们的调度任务到hdfs上面去**

注意：上传的hdfs目录为/user/root，因为我们hadoop启动的时候使用的是root用户，如果hadoop启动的是其他用户，那么就上传到

/user/其他用户

hdfsdfs-putoozie_works//user/root

**第七步：执行调度任务**

通过oozie的命令来执行我们的调度任务

从监控界面可以看到我们的任务执行成功了


查看hadoop的19888端口，我们会发现，oozie启动了一个MR的任务去执行我们的shell脚本


2.使用oozie调度我们的hive

**第一步：拷贝hive的案例模板**

cp-raexamples/apps/hive2/oozie_works/

**第二步：编辑hive模板**

这里使用的是hiveserver2来进行提交任务，需要注意我们要将hiveserver2的服务给启动起来

cd/export/servers/oozie-4.1.0-cdh5.14.0/oozie_works/hive2

```shellnameNode=hdfs://node01:8020jobTracker=node01:8032queueName=defaultjdbcURL=jdbc:hive2://node03:10000/defaultexamplesRoot=oozie_worksoozie.use.system.libpath=true#配置我们文件上传到hdfs的保存路径实际上就是在hdfs的/user/root/oozie_works/hive2这个路径下oozie.wf.application.path=${nameNode}/user/${user.name}/${examplesRoot}/hive2```

```xml${jobTracker}${nameNode}mapred.job.queue.name${queueName}${jdbcURL}INPUT=/user/${wf:user()}/${examplesRoot}/input-data/tableOUTPUT=/user/${wf:user()}/${examplesRoot}/output-data/hive2Hive2(Beeline)actionfailed,errormessage[${wf:errorMessage(wf:lastErrorNode())}]```

编辑hivesql文件

vimscript.q

```sqlDROPTABLEIFEXISTStest;CREATEEXTERNALTABLEtest(aINT)STOREDASTEXTFILELOCATION'${INPUT}';insertintotestvalues(10);insertintotestvalues(20);insertintotestvalues(30);```

**第三步：上传工作文件到hdfs**

cd/export/servers/oozie-4.1.0-cdh5.14.0/oozie_works

hdfsdfs-puthive2//user/root/oozie_works/

**第四步：执行oozie的调度**

**第五步：查看调度结果**


3.使用oozie调度MR任务

**第一步：准备MR执行的数据**

我们这里通过oozie调度一个MR的程序的执行，MR的程序可以是自己写的，也可以是hadoop工程自带的，我们这里就选用hadoop工程自带的MR程序来运行wordcount的示例

准备以下数据上传到HDFS的/oozie/input路径下去

hdfsdfs-mkdir-p/oozie/input

vimwordcount.txt

helloworldhadoop

sparkhivehadoop

将我们的数据上传到hdfs对应目录

hdfsdfs-putwordcount.txt/oozie/input

**第二步：执行官方测试案例**

yarnjar/export/servers/hadoop-2.6.0-cdh5.14.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-2.6.0-cdh5.14.0.jarwordcount/oozie/input//oozie/output

**第三步：准备我们调度的资源**

将我们需要调度的资源都准备好放到一个文件夹下面去，包括我们的jar包，我们的job.properties，以及我们的workflow.xml。

拷贝MR的任务模板

cp-raexamples/apps/map-reduce/oozie_works/

删掉MR任务模板lib目录下自带的jar包

cd/export/servers/oozie-4.1.0-cdh5.14.0/oozie_works/map-reduce/lib

rm-rfoozie-examples-4.1.0-cdh5.14.0.jar

**第三步：拷贝我们自己的jar包到对应目录**

从上一步的删除当中，我们可以看到我们需要调度的jar包存放在了

/export/servers/oozie-4.1.0-cdh5.14.0/oozie_works/map-reduce/lib这个目录下，所以我们把我们需要调度的jar包也放到这个路径下即可

cp/export/servers/hadoop-2.6.0-cdh5.14.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-2.6.0-cdh5.14.0.jar/export/servers/oozie-4.1.0-cdh5.14.0/oozie_works/map-reduce/lib/

**第四步：修改配置文件**

cd/export/servers/oozie-4.1.0-cdh5.14.0/oozie_works/map-reduce

```shellnameNode=hdfs://node01:8020jobTracker=node01:8032queueName=defaultexamplesRoot=oozie_worksoozie.wf.application.path=${nameNode}/user/${user.name}/${examplesRoot}/map-reduce/workflow.xmloutputDir=/oozie/outputinputdir=/oozieinput```

**第五步：上传调度任务到hdfs对应目录**

hdfsdfs-putmap-reduce//user/root/oozie_works/

**第六步：执行调度任务**

执行我们的调度任务，然后通过oozie的11000端口进行查看任务结果

4.oozie的任务串联

在实际工作当中，肯定会存在多个任务需要执行，并且存在上一个任务的输出结果作为下一个任务的输入数据这样的情况，所以我们需要在workflow.xml配置文件当中配置多个action，实现多个任务之间的相互依赖关系

需求：首先执行一个shell脚本，执行完了之后再执行一个MR的程序，最后再执行一个hive的程序

**第一步：准备我们的工作目录**

mkdir-psereval-actions

**第二步：准备我们的调度文件**

将我们之前的hive，shell，以及MR的执行，进行串联成到一个workflow当中去，准备我们的资源文件

cphive2/script.qsereval-actions/

cpshell/hello.shsereval-actions/

cp-ramap-reduce/libsereval-actions/

**第三步：开发调度的配置文件**

cd/export/servers/oozie-4.1.0-cdh5.14.0/oozie_works/sereval-actions

创建配置文件workflow.xml并编辑

开发我们的job.properties配置文件

```shellnameNode=hdfs://node01:8020jobTracker=node01:8032queueName=defaultexamplesRoot=oozie_worksEXEC=hello.shoutputDir=/oozie/outputinputdir=/oozie/inputjdbcURL=jdbc:hive2://node03:10000/defaultoozie.use.system.libpath=true#配置我们文件上传到hdfs的保存路径实际上就是在hdfs的/user/root/oozie_works/sereval-actions这个路径下oozie.wf.application.path=${nameNode}/user/${user.name}/${examplesRoot}/sereval-actions/workflow.xml```

**第四步：上传我们的资源文件夹到hdfs对应路径**

cd/export/servers/oozie-4.1.0-cdh5.14.0/oozie_works/

hdfsdfs-putsereval-actions//user/root/oozie_works/

**第五步：执行调度任务**

cd/export/servers/oozie-4.1.0-cdh5.14.0/

**5、oozie的任务调度,定时任务执行**

在oozie当中，主要是通过Coordinator来实现任务的定时调度，与我们的workflow类似的，Coordinator这个模块也是主要通过xml来进行配置即可，接下来我们就来看看如何配置Coordinator来实现任务的定时调度Coordinator的调度主要可以有两种实现方式

第二种：基于数据的任务调度，只有在有了数据才会去出发执行

这种是基于数据的调度，只要在有了数据才会触发调度任务

**oozie当中定时任务的设置**

**第一步：拷贝定时任务的调度模板**

cp-rexamples/apps/cronoozie_works/cron-job

**第二步：拷贝我们的hello.sh脚本**

cpshell/hello.shcron-job/

**第三步：修改配置文件**

cd/export/servers/oozie-4.1.0-cdh5.14.0/oozie_works/cron-job

```nameNode=hdfs://node01:8020jobTracker=node01:8032queueName=defaultexamplesRoot=oozie_worksoozie.coord.application.path=${nameNode}/user/${user.name}/${examplesRoot}/cron-job/coordinator.xmlstart=2018-08-22T19:20+0800end=2019-08-22T19:20+0800EXEC=hello.shworkflowAppUri=${nameNode}/user/${user.name}/${examplesRoot}/cron-job/workflow.xml```

修改coordinator.xml

vimcoordinator.xml

```xml${workflowAppUri}jobTracker${jobTracker}nameNode${nameNode}queueName${queueName}

```xml${jobTracker}${nameNode}mapred.job.queue.name${queueName}${EXEC}/user/root/oozie_works/cron-job/${EXEC}#${EXEC}```

**第四步：上传到hdfs对应路径**

hdfsdfs-putcron-job//user/root/oozie_works/

**第五步：运行定时任务**

**oozie当中任务的查看以及杀死**

**查看所有普通任务**

ooziejobs

**查看定时任务**

ooziejobs-jobtypecoordinator


**杀死某个任务**

oozie可以通过jobid来杀死某个定时任务

ooziejob-kill[id]

例如我们可以使用命令

ooziejob-kill0000085-180628150519513-oozie-root-C

来杀死我们定时任务


###hue整合oozie

**第一步：停止oozie与hue的进程**

通过命令停止oozie与hue的进程，准备修改oozie与hue的配置文件

**第二步：修改oozie的配置文件（老版本的bug，新版本已经不需要了）这一步我们都不需要做了**

修改oozie的配置文件oozie-site.xml

```xmloozie.service.WorkflowAppService.system.libpath/user/oozie/share/liboozie.use.system.libpathtrue```

重新上传所有的jar包到hdfs的/user/oozie/share/lib路径下去

**第三步：修改hue的配置文件**

修改hue的配置文件hue.ini

[liboozie]

修改oozie的配置文件大概在1151行左右的样子

[oozie]

```shell#LocationonlocalFSwheretheexamplesarestored.

#local_data_dir=/export/servers/oozie-4.1.0-cdh5.14.0/examples/apps

#LocationonlocalFSwherethedatafortheexamplesisstored.

#sample_data_dir=/export/servers/oozie-4.1.0-cdh5.14.0/examples/input-data

#LocationonHDFSwheretheoozieexamplesandworkflowsarestored.

#Parametersare$TIMEand$USER,e.g./user/$USER/hue/workspaces/workflow-$TIME

#remote_data_dir=/user/root/oozie_works/examples/apps

#MaximumofOozieworkflowsorcoodinatorstoretrieveinoneAPIcall.

oozie_jobs_count=100

#UseCronformatfordefiningthefrequencyofaCoordinatorinsteadoftheoldfrequencynumber/unit.

enable_cron_scheduling=true

#FlagtoenablethesavedEditorqueriestobedraggedanddroppedintoaworkflow.

enable_document_action=true

#FlagtoenableOoziebackendfilteringinsteadofdoingitatthepagelevelinJavascript.RequiresOozie4.3+.

enable_oozie_backend_filtering=true

#FlagtoenabletheImpalaaction.

enable_impala_action=true```

[filebrowser]

```shell#Locationonlocalfilesystemwheretheuploadedarchivesaretemporarystored.

archive_upload_tempdir=/tmp

#ShowDownloadButtonforHDFSfilebrowser.

show_download_button=true

#ShowUploadButtonforHDFSfilebrowser.

show_upload_button=true

#FlagtoenabletheextractionofauploadedarchiveinHDFS.

enable_extract_uploaded_archive=true```

**第四步：启动hue与oozie的进程**

启动hue进程

cd/export/servers/hue-3.9.0-cdh5.14.0

build/env/bin/supervisor

启动oozie进程

页面访问hue

###oozie使用过程当中可能遇到的问题

**1)Mysql权限配置**

**2)****workflow.xml配置的时候不要忽略file属性**

**3)****jps查看进程时，注意有没有bootstrap**

**4)****关闭oozie**

如果bin/oozied.shstop无法关闭，则可以使用kill-9[pid]，之后oozie根目录下的oozie-server/temp/xxx.pid文件一定要删除。

**5)Oozie重新打包时，一定要注意先关闭进程，删除对应文件夹下面的pid文件。（可以参考第4条目）**

**6)配置文件一定要生效**

起始标签和结束标签无对应则不生效，配置文件的属性写错了，那么则执行默认的属性。

**7)libext下边的jar存放于某个文件夹中，导致share/lib创建不成功。**

**9)修改Hadoop配置文件，需要重启集群。一定要记得scp到其他节点。**

**10)JobHistoryServer必须开启，集群要重启的。**

**11)Mysql配置如果没有生效的话，默认使用derby数据库。**

**12)在本地修改完成的job配置，必须重新上传到HDFS。**

**13)将HDFS中上传的oozie配置文件下载下来查看是否有错误。**

**14)Linux用户名和Hadoop的用户名不一致。**

**15）sharelib找不到，包括重新初始化oozie**

**如果部署oozie出错，修复执行，初始化oozie：**

**1、停止oozie（要通过jps检查bootstrap进程是否已经不存在）**

**2、删除oozie-server/temp/\***

**3、删除HDFS上的sharelib文件夹**

**4、删除oozie.sql文件，删除Mysql中删除oozie库，重新创建**

**5、重新按照顺序执行文档中oozie****的安装重新再来一遍**

**hadoop基础环境增强**

**HadoopHighAvailability**

HA(HighAvailable),高可用，是保证业务连续性的有效解决方案，一般有两个或两个以上的节点，分为**活动节点（**Active**）及**备用节点（Standby）。通常把正在执行业务的称为活动节点，而作为活动节点的一个备份的则称为备用节点。当活动节点出现问题，导致正在运行的业务（任务）不能正常运行时，备用节点此时就会侦测到，并立即接续活动节点来执行业务。从而实现业务的不中断或短暂中断。

Hadoop1.X版本，NN是HDFS集群的单点故障点，每一个集群只有一个NN,如果这个机器或进程不可用，整个集群就无法使用。为了解决这个问题，出现了一堆针对HDFSHA的解决方案（如：LinuxHA,VMwareFT,sharedNAS+NFS,BookKeeper,QJM/QuorumJournalManager,BackupNode等）。

在HA具体实现方法不同情况下，HA框架的流程是一致的,不一致的就是如何存储、管理、同步edits编辑日志文件。

在ActiveNN和StandbyNN之间要有个共享的存储日志的地方，ActiveNN把editLog写到这个共享的存储日志的地方，StandbyNN去读取日志然后执行，这样Active和StandbyNN内存中的HDFS元数据保持着同步。一旦发生主从切换StandbyNN可以尽快接管ActiveNN的工作。

**NamenodeHA**

**NamenodeHA详解**

hadoop2.x之后，Clouera提出了QJM/QuromJournalManager，这是一个基于Paxos算法（分布式一致性算法）实现的HDFSHA方案，它给出了一种较好的解决思路和方案,QJM主要优势如下：

不需要配置额外的高共享存储，降低了复杂度和维护成本。

消除spof(单点故障)。

系统鲁棒性(Robust)的程度可配置、可扩展。


基本原理就是用2N+1台JournalNode存储EditLog，每次写数据操作有>=N+1返回成功时即认为该次写成功，数据不会丢失了。当然这个算法所能容忍的是最多有N台机器挂掉，如果多于N台挂掉，这个算法就失效了。这个原理是基于Paxos算法。

在HA架构里面SecondaryNameNode已经不存在了，为了保持standbyNN时时的与ActiveNN的元数据保持一致，他们之间交互通过JournalNode进行操作同步。

任何修改操作在ActiveNN上执行时，JournalNode进程同时也会记录修改log到至少半数以上的JN中，这时StandbyNN监测到JN里面的同步log发生变化了会读取JN里面的修改log，然后同步到自己的目录镜像树里面，如下图：


当发生故障时，Active的NN挂掉后，StandbyNN会在它成为ActiveNN前，读取所有的JN里面的修改日志，这样就能高可靠的保证与挂掉的NN的目录镜像树一致，然后无缝的接替它的职责，维护来自客户端请求，从而达到一个高可用的目的。

每个NN改变状态的时候，向DN发送自己的状态和一个序列号。

DN在运行过程中维护此序列号，当failover时，新的NN在返回DN心跳时会返回自己的active状态和一个更大的序列号。DN接收到这个返回则认为该NN为新的active。

如果这时原来的activeNN恢复，返回给DN的心跳信息包含active状态和原来的序列号，这时DN就会拒绝这个NN的命令

**FailoverController**

HA模式下，会将FailoverController部署在每个NameNode的节点上，作为一个单独的进程用来监视NN的健康状态。**FailoverController主要包括三个组件:**

HealthMonitor:监控NameNode是否处于unavailable或unhealthy状态。当前通过RPC调用NN相应的方法完成。

ActiveStandbyElector:监控NN在ZK中的状态。

ZKFailoverController:订阅HealthMonitor和ActiveStandbyElector的事件，并管理NN的状态,另外zkfc还负责解决fencing（也就是脑裂问题）。

上述三个组件都在跑在一个JVM中，这个JVM与NN的JVM在同一个机器上。但是两个独立的进程。一个典型的HA集群，有两个NN组成，每个NN都有自己的ZKFC进程。


**ZKFailoverController主要职责：**

**l****健康监测：**周期性的向它监控的NN发送健康探测命令，从而来确定某个NameNode是否处于健康状态，如果机器宕机，心跳失败，那么zkfc就会标记它处于一个不健康的状态

**l****会话管理：**如果NN是健康的，zkfc就会在zookeeper中保持一个打开的会话，如果NameNode同时还是Active状态的，那么zkfc还会在Zookeeper中占有一个类型为短暂类型的znode，当这个NN挂掉时，这个znode将会被删除，然后备用的NN将会得到这把锁，升级为主NN，同时标记状态为Active

l当宕机的NN新启动时，它会再次注册zookeper，发现已经有znode锁了，便会自动变为Standby状态，如此往复循环，保证高可靠，需要注意，目前仅仅支持最多配置2个NN

**l****master选举：**通过在zookeeper中维持一个短暂类型的znode，来实现抢占式的锁机制，从而判断那个NameNode为Active状态

**YarnHA**

**手动切换**：在自动恢复不可用时，管理员可用手动切换状态，或是从Active到Standby,或是从Standby到Active。

**自动切换**：基于Zookeeper，但是区别于HDFS的HA，2个节点间无需配置额外的ZFKC守护进程来同步数据。


####**HadoopHA集群的搭建**

如何在已有的节点上面搭建HA高可用集群

集群服务规划：

|机器ip|192.168.52.100|192.168.52.110|192.168.52.120||---------------|-----------------|-----------------|-----------------||主机名称|node01.hadoop.com|node02.hadoop.com|node03.hadoop.com||NameNode|是(active)|是(standBy)|否||DataNode|是|是|是||journalNode|是|是|是||ZKFC|是|是|否||ResourceManager|否|是（standBy）|是(active)||NodeManager|是|是|是||zookeeper|是|是|是||jobHistory|||是|

**第一步：停止服务**

停止hadoop集群的所有服务，包括HDFS的服务，以及yarn集群的服务，包括impala的服务，hive的服务以及oozie的服务等

**停止oozie服务**

node03停止oozie服务

**停止hue服务**

node03停止hue的服务

**停止impala服务**

直接使用kill-9杀死进程即可

serviceimpala-catalogstop

serviceimpala-state-storestop

serviceimpala-serverstop

**停止hive服务**

node03停止hive服务


**停止hadoop服务**

node01机器执行以下命令停止hadoop服务

sbin/mr-jobhistory-daemon.shstophistoryserver

**第二步：启动所有节点的zookeeper服务**

cd/export/servers/zookeeper-3.4.5-cdh5.14.0

bin/zkServer.shstart

**第三步：更改配置文件**

所有节点修改配置文件，注意yarn-site.xml当中的

yarn.resourcemanager.ha.id这个属性值，node03机器与node02机器的配置值不太一样

**修改core-site.xml**

**修改hdfs-site.xml**

**修改mapred-site.xml**

```xmlmapreduce.task.io.sort.factor10

mapreduce.reduce.shuffle.parallelcopies25yarn.app.mapreduce.am.command-opts-Xmx1024myarn.app.mapreduce.am.resource.mb1536mapreduce.cluster.local.dir/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/mapreduce/local```

**修改yarn-site.xml**

注意：yarn.resourcemanager.ha.id这个属性的配置，node03的这个属性值与node02的这个属性值内容不同

改完之后，将配置文件分发到其他的各个节点

还要记得改node02机器的yarn-site.xml```

**第四步：服务的启动**

**第一步：初始化zookeeper**

在node01机器上进行zookeeper的初始化，其本质工作是创建对应的zookeeper节点

bin/hdfszkfc-formatZK

**第二步：启动journalNode**

三台机器执行以下命令启动journalNode，用于我们的元数据管理

sbin/hadoop-daemon.shstartjournalnode

**第三步：初始化journalNode**

node01机器上准备初始化journalNode

bin/hdfsnamenode-initializeSharedEdits-force

**第四步：启动namenode**

node01机器上启动namenode

sbin/hadoop-daemon.shstartnamenode

node02机器上启动namenode

bin/hdfsnamenode-bootstrapStandby

**第五步：启动所有节点的datanode进程**

在node01机器上启动所有节点的datanode进程

sbin/hadoop-daemons.shstartdatanode

**第六步：启动zkfc**

在node01机器上面启动zkfc进程

sbin/hadoop-daemon.shstartzkfc

在node02机器上面启动zkfc进程

**第七步：启动yarn进程**

node03机器上启动yarn集群

node02机器上启动yarn集群

**第八步：启动jobhsitory**

node03节点启动jobhistoryserver

sbin/mr-jobhistory-daemon.shstarthistoryserver

####**HadoopFederation**

**背景概述**

单NameNode的架构使得HDFS在集群扩展性和性能上都有潜在的问题，当集群大到一定程度后，NameNode进程使用的内存可能会达到上百G，NameNode成为了性能的瓶颈。因而提出了namenode水平扩展方案--Federation。

Federation中文意思为联邦,联盟，是NameNode的Federation,也就是会有多个NameNode。多个NameNode的情况意味着有多个namespace(命名空间)，区别于HA模式下的多NameNode，它们是拥有着同一个namespace。既然说到了NameNode的命名空间的概念,这里就看一下现有的HDFS数据管理架构,如下图所示:


从上图中,我们可以很明显地看出现有的HDFS数据管理,数据存储2层分层的结构.也就是说,所有关于存储数据的信息和管理是放在NameNode这边,而真实数据的存储则是在各个DataNode下.而这些隶属于同一个NameNode所管理的数据都是在同一个命名空间下的.而一个namespace对应一个blockpool。BlockPool是同一个namespace下的block的集合.当然这是我们最常见的单个namespace的情况,也就是一个NameNode管理集群中所有元数据信息的时候.如果我们遇到了之前提到的NameNode内存使用过高的问题,这时候怎么办.元数据空间依然还是在不断增大,一味调高NameNode的jvm大小绝对不是一个持久的办法.这时候就诞生了HDFSFederation的机制.

**Federation架构设计**

HDFSFederation是解决namenode内存瓶颈问题的水平横向扩展方案。

Federation意味着在集群中将会有多个namenode/namespace。这些namenode之间是联合的，也就是说，他们之间相互独立且不需要互相协调，各自分工，管理自己的区域。分布式的datanode被用作通用的数据块存储存储设备。每个datanode要向集群中所有的namenode注册，且周期性地向所有namenode发送心跳和块报告，并执行来自所有namenode的命令。


Federation一个典型的例子就是上面提到的NameNode内存过高问题,我们完全可以将上面部分大的文件目录移到另外一个NameNode上做管理.**更重要的一点在于,这些NameNode是共享集群中所有的DataNode的,它们还是在同一个集群内的****。**

这时候在DataNode上就不仅仅存储一个BlockPool下的数据了,而是多个(在DataNode的datadir所在目录里面查看BP-xx.xx.xx.xx打头的目录)。

**概括起来：**

多个NN共用一个集群里的存储资源，每个NN都可以单独对外提供服务。

每个NN都会定义一个存储池，有单独的id，每个DN都为所有存储池提供存储。

DN会按照存储池id向其对应的NN汇报块信息，同时，DN会向所有NN汇报本地存储可用资源情况。

**HDFSFederation不足**

HDFSFederation并没有完全解决单点故障问题。虽然namenode/namespace存在多个，但是从单个namenode/namespace看，仍然存在单点故障：如果某个namenode挂掉了，其管理的相应的文件便不可以访问。Federation中每个namenode仍然像之前HDFS上实现一样，配有一个secondarynamenode，以便主namenode挂掉一下，用于还原元数据信息。

所以一般集群规模真的很大的时候，会采用HA+Federation的部署方案。也就是每个联合的namenodes都是ha的。

**Federation示例配置**

这是一个包含两个Namenode的Federation示例配置：

##clouderaManager搭建

ClouderaManager是cloudera公司提供的一种大数据的解决方案，可以通过ClouderaManager管理界面来对我们的集群进行安装和操作，提供了良好的UI界面交互，使得我们管理集群不用熟悉任何的linux技术，只需要通过网页浏览器就可以实现我们的集群的操作和管理，让我们使用和管理集群更加的方便。

**整体架构**


ClouderaManager的核心是ClouderaManagerServer。Server托管AdminConsoleWebServer和应用程序逻辑。它负责安装软件、配置、启动和停止服务以及管理运行服务的群集。

解释：

·Agent：安装在每台主机上。它负责启动和停止进程，解压缩配置，触发安装和监控主机

·ManagementService：执行各种监控、报警和报告功能的一组角色的服务。

·Database：存储配置和监控信息

·ClouderaRepository：可供ClouderaManager分配的软件的存储库（repo库）

·Client：用于与服务器进行交互的接口：

·AdminConsole：管理员控制台

·API：开发人员使用API可以创建自定义的ClouderaManager应用程序

**ClouderaManagementService**

ClouderaManagementService可作为一组角色实施各种管理功能

·ActivityMonitor：收集有关服务运行的活动的信息

·HostMonitor：收集有关主机的运行状况和指标信息

·ServiceMonitor：收集有关服务的运行状况和指标信息

·EventServer：聚合组件的事件并将其用于警报和搜索

·AlertPublisher：为特定类型的事件生成和提供警报

·ReportsManager：生成图表报告，它提供用户、用户组的目录的磁盘使用率、磁盘、io等历史视图

**信号检测**

默认情况下，Agent每隔15秒向ClouderaManagerServer发送一次检测信号。但是，为了减少用户延迟，在状态变化时会提高频率。

**状态管理**

·模型状态捕获什么进程应在何处运行以及具有什么配置

·运行时状态是哪些进程正在何处运行以及正在执行哪些命令（例如，重新平衡HDFS或执行备份/灾难恢复计划或滚动升级或停止）

·当您更新配置（例如HueServerWeb端口）时，您即更新了模型状态。但是，如果Hue在更新时正在运行，则它仍将使用旧端口。当出现这种不匹配情况时，角色会标记为具有”过时的配置”。要重新同步，您需重启角色（这会触发重新生成配置和重启进程）

·特殊情况如果要加入一些cloudermanager控制台没有的属性时候都在高级里面嵌入

**服务器和客户端配置**

·而HDFS角色实例（例如，NameNode和DataNode）会从/var/run/cloudera-scm-agent/process/unique-process-name下的每个进程专用目录获取它们的配置

**进程管理**

·在ClouderaManager管理的群集中，只能通过ClouderaManager启动或停止服务。ClouderaManager使用一种名为supervisord的开源进程管理工具，它会重定向日志文件，通知进程失败，为合适用户设置调用进程的有效用户ID等等

·ClouderaManager支持自动重启崩溃进程。如果一个角色实例在启动后反复失败，ClouderaManager还会用不良状态标记该实例

·特别需要注意的是，停止ClouderaManager和ClouderaManagerAgent不会停止群集；所有正在运行的实例都将保持运行

·Agent的一项主要职责是启动和停止进程。当Agent从检测信号检测到新进程时，Agent会在/var/run/cloudera-scm-agent中为它创建一个目录，并解压缩配置

·Agent受到监控，属于ClouderaManager的主机监控的一部分：如果Agent停止检测信号，主机将被标记为运行状况不良

**主机管理**

·ClouderaManager自动将作为群集中的托管主机身份：JDK、ClouderaManagerAgent、CDH、Impala、Solr等参与所需的所有软件部署到主机

·ClouderaManager提供用于管理参与主机生命周期的操作以及添加和删除主机的操作

·ClouderaManagementServiceHostMonitor角色执行运行状况检查并收集主机度量，以使您可以监控主机的运行状况和性能

**安全**

**·****身份验证**

·Hadoop中身份验证的目的仅仅是证明用户或服务确实是他或她所声称的用户或服务，通常，企业中的身份验证通过单个分布式系统（例如，轻型目录访问协议(LDAP)目录）进行管理。LDAP身份验证包含由各种存储系统提供支持的简单用户名/密码服务

·Hadoop生态系统的许多组件会汇总到一起来使用Kerberos身份验证并提供用于在LDAP或AD中管理和存储凭据的选项

·适用于目录和文件的传统POSIX样式的权限

·适用于HDFS的扩展的访问控制列表(ACL)

·使用ApacheSentry基于角色进行访问控制

**·****加密**

·需要获得企业版的Cloudera（ClouderaNavigator许可）

**clouderaManager环境安装前准备**

准备两台虚拟机，其中一台作为我们的主节点，安装我们的ClouderaManagerServer与ClouderaManageragent，另外一台作为我们的从节点只安装我们的clouderaManageragent

机器规划如下

所有机器统一两个路径

mkdir-p/export/softwares/

mkdir-p/export/servers/

**两台机器更改主机名**

第一台机器更改主机名

vim/etc/sysconfig/network

NETWORKING=yes

HOSTNAME=node01.hadoop.com

第二台机器更改主机名

HOSTNAME=node02.hadoop.com

**更改主机名与IP地址的映射**

两台机器更改hosts文件

vim/etc/hosts

192.168.52.100node01.hadoop.com

192.168.52.110node02.hadoop.com

**两台机器关闭防火墙**

serviceiptablesstop

chkconfigiptablesoff

**两台机器关闭selinux**

vim/etc/selinux/config

SELINUX=disabled


**两台机器安装jdk**

将我们的jdk的压缩包上传到node01.hadoop.com的/export/softwares路径下

tar-zxvfjdk-8u141-linux-x64.tar.gz-C/export/servers/

配置环境变量

exportJAVA_HOME=/export/servers/jdk1.8.0_141

exportPATH=:$JAVA_HOME/bin:$PATH

第二台机器同样安装jdk即可

**第一步：两台器生成公钥与私钥**

两台机器上面执行以下命令，然后按下三个回车键即可生成公钥与私钥

ssh-keygen-trsa


**第二步：两台机器将公钥拷贝到同一个文件当中去**

两台机器执行以下命令

ssh-copy-idnode01.hadoop.com

**第三步：拷贝authorized_keys到其他机器**

第一台机器上将authorized_keys拷贝到第二台机器

scp/root/.ssh/authorized_keysnode02.hadoop.com:/root/.ssh/

**第二台机器安装mysql数据库**

通过yum源，在线安装mysql

yuminstallmysqlmysql-servermysql-devel

/etc/init.d/mysqldstart

/usr/bin/mysql_secure_installation

进入mysql客户端执行以下命令

grantallprivilegeson*.*to'root'@'%'identifiedby'123456'withgrantoption;

flushprivileges;


**解除linux系统打开文件最大数量的限制**

两台机器都需要执行

vi/etc/security/limits.conf

添加以下内容

.softnoproc11000

.hardnoproc11000

.softnofile65535

.hardnofile65535

**设置linux交换区内存**

两台机器都要执行

执行命令

echo10>/proc/sys/vm/swappiness

并编辑文件sysctl.conf：

vim/etc/sysctl.conf

添加或修改

vm.swappiness=0

两台机器都要执行：

echonever>/sys/kernel/mm/transparent_hugepage/defrag

echonever>/sys/kernel/mm/transparent_hugepage/enabled

并编辑文件rc.local：

vim/etc/rc.local


**两台机器时钟同步**

crontab–e

*/1****/usr/sbin/ntpdatentp4.aliyun.com;

**两台服务器关闭防火墙**

服务器关机重启

clouderaManager安装资源下载

**第一步：下载安装资源并上传到服务器**

我们这里安装CM5.14.0这个版本，需要下载以下这些资源，一共是四个文件即可

下载cm5的压缩包

具体文件地址：

下载cm5的parcel包

下载地址：

第一个文件具体下载地址：

第二个文件具体下载地址：

第三个文件具体下载地址：

将这四个安装包都上传到第一台机器的/export/softwares路径下


**第二步：解压压缩包到指定路径**

解压CM安装包到/opt路径下去

tar-zxvfcloudera-manager-el6-cm5.14.0_x86_64.tar.gz-C/opt/

**第三步：将我们的parcel包的三个文件拷贝到对应路径**

将我们的parcel包含三个文件，拷贝到/opt/cloudera/parcel-repo路径下面去，并记得有个文件需要重命名

cpCDH-5.14.0-1.cdh5.14.0.p0.24-el6.parcelCDH-5.14.0-1.cdh5.14.0.p0.24-el6.parcel.sha1manifest.json/opt/cloudera/parcel-repo/


重命名标黄的这个文件

cd/opt/cloudera/parcel-repo/

mvCDH-5.14.0-1.cdh5.14.0.p0.24-el6.parcel.sha1CDH-5.14.0-1.cdh5.14.0.p0.24-el6.parcel.sha


**第四步：所有节点添加普通用户并给与sudo权限**

在node01机器上面添加普通用户并赋予sudo权限

执行以下命令创建普通用户cloudera-scm

useradd--system--home=/opt/cm-5.14.0/run/cloudera-scm-server--no-create-home--shell=/bin/false--comment"ClouderaSCMUser"cloudera-scm

赋予cloudera-scm普通用户的sudo权限

visudo

cloudera-scmALL=(ALL)NOPASSWD:ALL


**第五步：更改主节点的配置文件**

node01机器上面更改配置文件

vim/opt/cm-5.14.0/etc/cloudera-scm-agent/config.ini

server_host=node01.hadoop.com


**第六步：将/opt目录下的安装包发放到其他机器**

将第一台机器的安装包发放到其他机器

cd/opt

scp-rcloudera/cm-5.14.0/node02.hadoop.com:/opt

**第七步：创建一些数据库备用**

node02机器上面创建数据库

hive数据库

createdatabasehiveDEFAULTCHARSETutf8COLLATEutf8_general_ci;

集群监控数据库

createdatabaseamonDEFAULTCHARSETutf8COLLATEutf8_general_ci;

hue数据库

createdatabasehueDEFAULTCHARSETutf8COLLATEutf8_general_ci;

oozie数据库

createdatabaseoozieDEFAULTCHARSETutf8COLLATEutf8_general_ci;

**第八步：准备数据库连接的驱动包**

在所有机器上面都准备一份数据库的连接驱动jar包放到/usr/share/java路径下

准备一份mysql的驱动连接包，放到/usr/share/java路径下去

tar-zxvfmysql-connector-java-5.1.45.tar.gz

cd/export/softwares/mysql-connector-java-5.1.45

cpmysql-connector-java-5.1.45-bin.jar/usr/share/java/mysql-connector-java.jar

拷贝驱动包到第二台机器

cd/usr/share/java

scpmysql-connector-java.jarnode02.hadoop.com:$PWD

**第九步：为clouderaManager创建数据库**

node01服务器执行

/opt/cm-5.14.0/share/cmf/schema/scm_prepare_database.shmysql-hnode02.hadoop.com-uroot-p123456--scm-hostnode01.hadoop.comscmroot123456

命令说明：/**opt**/**cm**-5.14.0/share/cmf/schema/scm_prepare_database.**sh**数据库类型-h数据库主机–u数据库用户名–p数据库密码--scm-host**cm**主机数据库名称用户名密码


**第十步：启动服务**

主节点启动clouderaManagerServer与ClouderaManageragent服务

/opt/cm-5.14.0/etc/init.d/cloudera-scm-serverstart

/opt/cm-5.14.0/etc/init.d/cloudera-scm-agentstart


从节点node02启动ClouderaManageragent服务

**第十一步：浏览器页面访问**

默认用户名admin

密码admin

##Hue

一、编译

```shell#1-下载安装包并解压tar-zxvfhue-3.9.0-cdh5.14.0.tar.gz-C/export/servers/#2-安装依赖yuminstallantasciidoccyrus-sasl-develcyrus-sasl-gssapicyrus-sasl-plaingccgcc-c++krb5-devellibffi-devellibxml2-devellibxslt-develmakemysqlmysql-developenldap-develpython-develsqlite-develgmp-devel-y#3-卸载安装的jdk1.7java-versionrpm-qa|grepjavarpm-e--nodepsjava-1.7.0-openjdk-1.7.0.231-2.6.19.1.el6_10.x86_64java-1.5.0-gcj-1.5.0.0-29.1.el6.x86_64tzdata-java-2019b-2.el6.noarchjava-1.7.0-openjdk-devel-1.7.0.231-2.6.19.1.el6_10.x86_64java_cup-0.10k-5.el6.x86_64

**1、Hue的介绍**

HUE=**HadoopUserExperience**

Hue是一个开源的ApacheHadoopUI系统，由ClouderaDesktop演化而来，最后Cloudera公司将其贡献给Apache基金会的Hadoop社区，它是基于PythonWeb框架Django实现的。

通过使用Hue我们可以在浏览器端的Web控制台上与Hadoop集群进行交互来分析处理数据，例如操作HDFS上的数据，运行MapReduceJob，执行Hive的SQL语句，浏览HBase数据库等等。

**HUE链接**

**Hue的架构**


**核心功能**

·SQL编辑器，支持Hive,Impala,MySQL,Oracle,PostgreSQL,SparkSQL,SolrSQL,Phoenix…

·搜索引擎Solr的各种图表

·Spark和Hadoop的友好界面支持

·支持调度系统ApacheOozie，可进行workflow的编辑、查看

HUE提供的这些功能相比Hadoop生态各组件提供的界面更加友好，但是一些需要debug的场景可能还是需要使用原生系统才能更加深入的找到错误的原因。

HUE中查看Oozieworkflow时，也可以很方便的看到整个workflow的DAG图，不过在最新版本中已经将DAG图去掉了，只能看到workflow中的action列表和他们之间的跳转关系，想要看DAG图的仍然可以使用oozie原生的界面系统查看。

1，访问HDFS和文件浏览

2，通过web调试和开发hive以及数据结果展示

3，查询solr和结果展示，报表生成

4，通过web调试和开发impala交互式SQLQuery

5，spark调试和开发

7，oozie任务的开发，监控，和工作流协调调度

8，Hbase数据查询和修改，数据展示

9，Hive的元数据（metastore）查询

10，MapReduce任务进度查看，日志追踪

11，创建和提交MapReduce，Streaming，Javajob任务

12，Sqoop2的开发和调试

13，Zookeeper的浏览和编辑

14，数据库（MySQL，PostGres，SQlite，Oracle）的查询和展示

一句话总结：Hue是一个友好的界面集成框架，可以集成我们各种学习过的以及将要学习的框架，一个界面就可以做到查看以及执行所有的框架

**2、Hue的安装**

Hue的安装支持多种方式，包括rpm包的方式进行安装，tar.gz包的方式进行安装以及clouderamanager的方式来进行安装等，我们这里使用tar.gz包的方式来记性安装

**第一步：下载Hue的压缩包并上传到linux解压**

Hue的压缩包的下载地址：

我们这里使用的是CDH5.14.0这个对应的版本，具体下载地址为

下载然后上传到linux系统，然后进行解压

tar-zxvfhue-3.9.0-cdh5.14.0.tar.gz-C../servers/

**第二步：编译安装启动**

**2.1、linux系统安装依赖包：**

联网安装各种必须的依赖包

yuminstallantasciidoccyrus-sasl-develcyrus-sasl-gssapicyrus-sasl-plaingccgcc-c++krb5-devellibffi-devellibxml2-devellibxslt-develmakemysqlmysql-developenldap-develpython-develsqlite-develgmp-devel

**2.2、开始配置Hue**

cd/export/servers/hue-3.9.0-cdh5.14.0/desktop/conf

vimhue.ini

**2.3、创建mysql数据库**

创建hue数据库

createdatabasehuedefaultcharactersetutf8defaultcollateutf8_general_ci;

注意：实际工作中，还需要为hue这个数据库创建对应的用户，并分配权限，我这就不创建了，所以下面这一步不用执行了

grantallonhue.*to'hue'@'%'identifiedby'hue';

**2.4、准备进行编译**

```cd/export/servers/hue-3.9.0-cdh5.14.0makeapps```

**2.5、linux系统添加普通用户hue**

```useraddhuepasswdhue```

**2.6、启动hue进程**

```cd/export/servers/hue-3.9.0-cdh5.14.0/build/env/bin/supervisor```

**2.7、页面访问**

第一次访问的时候，需要设置管理员用户和密码

我们这里的管理员的用户名与密码尽量保持与我们安装hadoop的用户名和密码一致，

我们安装hadoop的用户名与密码分别是root123456


进入之后发现我们的hue页面报错了，这个错误主要是因为hive的原因，因为我们的hue与hive集成的时候出错了，所以我们需要配置我们的hue与hive进行集成，接下里就看看我们的hue与hive以及hadoop如何进行集成

**3.hue与其他框架的集成**

**3.1、hue与hadoop的HDFS以及yarn集成**

**第一步：更改所有hadoop节点的core-site.xml配置**

记得更改完core-site.xml之后一定要重启hdfs与yarn集群

```xmlhadoop.proxyuser.root.hosts*hadoop.proxyuser.root.groups*```

**第二步：更改所有hadoop节点的hdfs-site.xml**

```xmldfs.webhdfs.enabledtrue```

**第三步：重启hadoop集群**

在node01机器上面执行以下命令

```shellcd/export/servers/hadoop-2.6.0-cdh5.14.0sbin/stop-dfs.shsbin/start-dfs.shsbin/stop-yarn.shsbin/start-yarn.sh```

**第四步：停止hue的服务，并继续配置hue.ini**

**3.2、配置hue与hive集成**

如果需要配置hue与hive的集成，我们需要启动hive的metastore服务以及hiveserver2服务（impala需要hive的metastore服务，hue需要hvie的hiveserver2服务）

**更改hue的配置hue.ini**

修改hue.ini

```shell[beeswax]hive_server_host=node03.hadoop.comhive_server_port=10000hive_conf_dir=/export/servers/hive-1.1.0-cdh5.14.0/confserver_conn_timeout=120auth_username=rootauth_password=12345[metastore]#允许使用hive创建数据库表等操作enable_new_create_table=true#启动hive的metastore服务去node03机器上启动hive的metastore以及hiveserver2服务cd/export/servers/hive-1.1.0-cdh5.14.0nohupbin/hive--servicemetastore&nohupbin/hive--servicehiveserver2&重新启动hue，然后就可以通过浏览器页面操作hive了```

**3.3、配置hue与impala的集成**

停止hue的服务进程

修改hue.ini配置文件

```shell[impala]server_host=node03server_port=21050impala_conf_dir=/etc/impala/conf```

**3.4、配置hue与mysql的集成**

找到databases这个选项，将这个选项下面的mysql注释给打开，然后配置mysql即可,大概在1547

```shell[[[mysql]]]nice_name="MySQLDB"engine=mysqlhost=node03.hadoop.comport=3306user=rootpassword=123456```

**3.5、重新启动hue的服务**

cd/export/servers/hue-3.9.0-cdh5.14.0/

**3.6、解决hive以及impala执行权限不足的问题**

在我们hive当中执行任意的查询，只要是需要跑MR的程序，就会报错，发现权限不够的异常，具体详细信息如下：

我们需要给hdfs上面的几个目录执行权限即可

hdfsdfs-chmodo+x/tmp

hdfsdfs-chmodo+x/tmp/hadoop-yarn

hdfsdfs-chmodo+x/tmp/hadoop-yarn/staging


或者我们可以这样执行

hdfsdfs-chmod-Ro+x/tmp

可以将/tmp目录下所有的文件及文件夹都赋予权限

继续执行hive的任务就不会报错了

#大数据组件

##hadoop

启动服务第一次启动一定要格式化：NameNode在哪台就在哪台做bin/hdfsnamenode-format-》启动hdfs（在NameNode的机器上执行）sbin/start-dfs.sh-》启动yarn（在ResourceManager那台机器上执行）sbin/start-yarn.sh

**apachehadoop三种架构介绍（standAlone，伪分布，分布式环境介绍以及安装）**

hadoop文档

**StandAlone集群搭建**

**第一步：下载apachehadoop并上传到服务器**

下载链接：

解压命令

tar-zxvfhadoop-2.7.5.tar.gz-C../servers/


**第二步：修改配置文件**

```xml修改core-site.xml第一台机器执行以下命令cd/export/servers/hadoop-2.7.5/etc/hadoopvimcore-site.xmlfs.default.namehdfs://192.168.52.100:8020hadoop.tmp.dir/export/servers/hadoop-2.7.5/hadoopDatas/tempDatasio.file.buffer.size4096

fs.trash.interval10080

dfs.namenode.checkpoint.dirfile:///export/servers/hadoop-2.7.5/hadoopDatas/snn/namedfs.namenode.checkpoint.edits.dirfile:///export/servers/hadoop-2.7.5/hadoopDatas/dfs/snn/edits

dfs.replication3

dfs.permissionsfalse

dfs.blocksize134217728

修改hadoop-env.sh第一台机器执行以下命令cd/export/servers/hadoop-2.7.5/etc/hadoopvimhadoop-env.shvimhadoop-env.shexportJAVA_HOME=/export/servers/jdk1.8.0_141

修改mapred-site.xml第一台机器执行以下命令cd/export/servers/hadoop-2.7.5/etc/hadoopvimmapred-site.xmlmapreduce.framework.nameyarn

mapreduce.job.ubertask.enabletruemapreduce.jobhistory.addressnode01:10020

mapreduce.jobhistory.webapp.addressnode01:19888

修改yarn-site.xml第一台机器执行以下命令cd/export/servers/hadoop-2.7.5/etc/hadoopvimyarn-site.xmlyarn.resourcemanager.hostnamenode01yarn.nodemanager.aux-servicesmapreduce_shuffleyarn.log-aggregation-enabletrueyarn.log-aggregation.retain-seconds604800

修改mapred-env.sh第一台机器执行以下命令cd/export/servers/hadoop-2.7.5/etc/hadoopvimmapred-env.shexportJAVA_HOME=/export/servers/jdk1.8.0_141修改slaves第一台机器执行以下命令cd/export/servers/hadoop-2.7.5/etc/hadoopvimslaveslocalhost```

**第三步：启动集群**

要启动Hadoop集群，需要启动HDFS和YARN两个模块。注意：首次启动HDFS时，必须对其进行格式化操作。本质上是一些清理和准备工作，因为此时的HDFS在物理上还是不存在的。hdfsnamenode-format或者hadoopnamenode–format

启动命令：

创建数据存放文件夹

第一台机器执行以下命令

cd/export/servers/hadoop-2.7.5

mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/tempDatas

mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/namenodeDatas

mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/namenodeDatas2

mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/datanodeDatas

mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/datanodeDatas2

mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/nn/edits

mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/snn/name

mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/dfs/snn/edits

准备启动

cd/export/servers/hadoop-2.6.0-cdh5.14.0/

bin/hdfsnamenode-format

三个端口查看界面

**5.2、伪分布式环境搭建（适用于学习测试开发集群模式）**

服务规划

|服务器IP|192.168.52.100|192.168.52.110|192.168.52.120||-----------------|-----------------|-----------------|-----------------||主机名|node01.hadoop.com|node02.hadoop.com|node03.hadoop.com||NameNode|是|否|否||SecondaryNameNode|是|否|否||dataNode|是|是|是||ResourceManager|是|否|否||NodeManager|是|是|是|

```shell停止单节点集群，删除/export/servers/hadoop-2.7.5/hadoopDatas文件夹，然后重新创建文件夹第一台机器执行以下命令cd/export/servers/hadoop-2.7.5sbin/stop-dfs.shsbin/stop-yarn.shsbin/mr-jobhistory-daemon.shstophistoryserver

删除hadoopDatas然后重新创建文件夹rm-rf/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas

重新创建文件夹mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/tempDatasmkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/namenodeDatasmkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/namenodeDatas2mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/datanodeDatasmkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/datanodeDatas2mkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/nn/editsmkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/snn/namemkdir-p/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/dfs/snn/edits

修改slaves文件，然后将安装包发送到其他机器，重新启动集群即可第一台机器执行以下命令cd/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoopvimslavesnode01node02node03

安装包的分发第一台机器执行以下命令cd/export/servers/scp-rhadoop-2.6.0-cdh5.14.0node02:$PWDscp-rhadoop-2.6.0-cdh5.14.0node03:$PWD

启动集群第一台机器执行以下命令cd/export/servers/hadoop-2.6.0-cdh5.14.0bin/hdfsnamenode-formatsbin/start-dfs.shsbin/start-yarn.shsbin/mr-jobhistory-daemon.shstarthistoryserver```

**5.3、分布式环境搭建（适用于工作当中正式环境搭建）**

使用完全分布式，实现namenode高可用，ResourceManager的高可用

集群运行服务规划

||192.168.1.100|192.168.1.110|192.168.1.120||-----------|-------------|---------------|----------------||zookeeper|zk|zk|zk||HDFS|JournalNode|JournalNode|JournalNode||NameNode|NameNode||||ZKFC|ZKFC||||DataNode|DataNode|DataNode|||YARN||ResourceManager|ResourceManager||NodeManager|NodeManager|NodeManager|||MapReduce|||JobHistoryServer|

**安装包解压**

停止之前的hadoop集群的所有服务，并删除所有机器的hadoop安装包，然后重新解压hadoop压缩包

解压压缩包

第一台机器执行以下命令进行解压

**配置文件的修改**

cd/export/servers/hadoop-2.7.5/etc/hadoop

```xml

ha.zookeeper.quorumnode01:2181,node02:2181,node03:2181

fs.defaultFShdfs://ns

hadoop.tmp.dir/export/servers/hadoop-2.7.5/data/tmp

fs.trash.interval10080```

vimhdfs-site.xml

dfs.nameservicesns

dfs.ha.namenodes.nsnn1,nn2

dfs.namenode.rpc-address.ns.nn1node01:8020

dfs.namenode.rpc-address.ns.nn2node02:8020

dfs.namenode.servicerpc-address.ns.nn1node01:8022

dfs.namenode.servicerpc-address.ns.nn2node02:8022

dfs.namenode.shared.edits.dirqjournal://node01:8485;node02:8485;node03:8485/ns1dfs.client.failover.proxy.provider.nsorg.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider

dfs.ha.fencing.methodssshfence

dfs.ha.fencing.ssh.private-key-files/root/.ssh/id_rsa

dfs.journalnode.edits.dir/export/servers/hadoop-2.7.5/data/dfs/jn

dfs.ha.automatic-failover.enabledtrue

dfs.namenode.name.dirfile:///export/servers/hadoop-2.7.5/data/dfs/nn/namedfs.namenode.edits.dirfile:///export/servers/hadoop-2.7.5/data/dfs/nn/edits

dfs.datanode.data.dirfile:///export/servers/hadoop-2.7.5/data/dfs/dn

dfs.blocksize134217728

```

**修改yarn-site.xml，注意node03与node02配置不同**

vimyarn-site.xml

yarn.log-aggregation-enabletrue

yarn.resourcemanager.ha.enabledtrue

yarn.resourcemanager.cluster-idmycluster

yarn.resourcemanager.ha.rm-idsrm1,rm2

yarn.resourcemanager.hostname.rm1node03

yarn.resourcemanager.hostname.rm2node02

yarn.resourcemanager.address.rm1node03:8032yarn.resourcemanager.scheduler.address.rm1node03:8030yarn.resourcemanager.resource-tracker.address.rm1node03:8031yarn.resourcemanager.admin.address.rm1node03:8033yarn.resourcemanager.webapp.address.rm1node03:8088

yarn.resourcemanager.address.rm2node02:8032yarn.resourcemanager.scheduler.address.rm2node02:8030yarn.resourcemanager.resource-tracker.address.rm2node02:8031yarn.resourcemanager.admin.address.rm2node02:8033yarn.resourcemanager.webapp.address.rm2node02:8088

yarn.resourcemanager.recovery.enabledtrue

yarn.resourcemanager.ha.idrm1IfwewanttolaunchmorethanoneRMinsinglenode,weneedthisconfigurationyarn.resourcemanager.store.classorg.apache.hadoop.yarn.server.resourcemanager.recovery.ZKRMStateStoreyarn.resourcemanager.zk-addressnode02:2181,node03:2181,node01:2181Formultiplezkservices,separatethemwithcomma

yarn.resourcemanager.ha.automatic-failover.enabledtrueEnableautomaticfailover;Bydefault,itisenabledonlywhenHAisenabled.yarn.client.failover-proxy-providerorg.apache.hadoop.yarn.client.ConfiguredRMFailoverProxyProvider

yarn.nodemanager.resource.cpu-vcores4

yarn.nodemanager.resource.memory-mb512

yarn.scheduler.minimum-allocation-mb512

yarn.scheduler.maximum-allocation-mb512

yarn.log-aggregation.retain-seconds2592000

yarn.nodemanager.log.retain-seconds604800

yarn.nodemanager.log-aggregation.compression-typegz

yarn.nodemanager.local-dirs/export/servers/hadoop-2.7.5/yarn/local

yarn.resourcemanager.max-completed-applications1000

yarn.nodemanager.aux-servicesmapreduce_shuffle

yarn.resourcemanager.connect.retry-interval.ms2000```

vimmapred-site.xml

mapreduce.framework.nameyarn

mapreduce.jobhistory.addressnode03:10020

mapreduce.jobhistory.webapp.addressnode03:19888

mapreduce.jobtracker.system.dir/export/servers/hadoop-2.7.5/data/system/jobtracker

mapreduce.map.memory.mb1024

mapreduce.reduce.memory.mb1024

mapreduce.task.io.sort.mb100mapreduce.task.io.sort.factor10

mapreduce.reduce.shuffle.parallelcopies25

yarn.app.mapreduce.am.command-opts-Xmx1024m

yarn.app.mapreduce.am.resource.mb1536

mapreduce.cluster.local.dir/export/servers/hadoop-2.7.5/data/system/local```

**修改slaves**

vimslaves

```node01node02node03```

**修改hadoop-env.sh**

```shellcd/export/servers/hadoop-2.7.5/etc/hadoop

vimhadoop-env.sh

exportJAVA_HOME=/export/servers/jdk1.8.0_141```

**集群启动过程**

将第一台机器的安装包发送到其他机器上

第一台机器执行以下命令：

```shellcd/export/servers

scp-rhadoop-2.7.5/node02:$PWD

scp-rhadoop-2.7.5/node03:$PWD```

三台机器上共同创建目录

三台机器执行以下命令

```shellmkdir-p/export/servers/hadoop-2.7.5/data/dfs/nn/name

mkdir-p/export/servers/hadoop-2.7.5/data/dfs/nn/edits

mkdir-p/export/servers/hadoop-2.7.5/data/dfs/nn/name

mkdir-p/export/servers/hadoop-2.7.5/data/dfs/nn/edits```

更改node02的rm2

第二台机器执行以下命令

```xml```

```shell上传mysql的lib驱动包

将mysql的lib驱动包上传到hive的lib目录下

cd/export/servers/hive-1.1.0-cdh5.14.0/lib

将mysql-connector-java-5.1.38.jar上传到这个目录下```

**2.6.2使用方式**

**第一种交互方式：Hive交互shell**

```sqlcd/export/servers/hive-1.1.0-cdh5.14.0

查看所有的数据库

hive(default)>showdatabases;

创建一个数据库

hive(default)>createdatabasemyhive;

使用该数据库并创建数据库表

hive(default)>usemyhive;

hive(myhive)>createtabletest(idint,namestring);```

以上命令操作完成之后，一定要确认mysql里面出来一个数据库hive

**第二种交互方式：HiveJDBC服务**

```shell#启动hiveserver2服务

#前台启动

cd/export/servers/hive-1.1.0-cdh5.14.0

bin/hive--servicehiveserver2

#后台启动

nohupbin/hive--servicehiveserver2&

#beeline连接hiveserver2

bin/beeline

beeline>!connectjdbc:hive2://node03.hadoop.com:10000```


注意：如果使用beeline方式连接hiveserver2，一定要保证hive在mysql当中的元数据库已经创建成功，不然就会拒绝连接

**第三种交互方式：Hive命令**

使用–e参数来直接执行hql的语句

bin/hive-e"usemyhive;select*fromtest;"

使用–f参数通过指定文本文件来执行hql的语句

vimhive.sql

usemyhive;select*fromtest;

bin/hive-fhive.sql

更多参数参考以下


##flume

**第一步：下载解压修改配置文件**

Flume的安装非常简单，只需要解压即可，当然，前提是已有hadoop环境

上传安装包到数据源所在节点上

这里我们采用在第三台机器来进行安装

tar-zxvfflume-ng-1.6.0-cdh5.14.0.tar.gz-C/export/servers/

cd/export/servers/apache-flume-1.6.0-cdh5.14.0-bin/conf

cpflume-env.sh.templateflume-env.sh

vimflume-env.sh

**第二步：开发配置文件**

根据数据采集的需求**配置采集方案**，描述在配置文件中(文件名可任意自定义)

配置我们的网络收集的配置文件

在flume的conf目录下新建一个配置文件（采集方案）

vim/export/servers/apache-flume-1.6.0-cdh5.14.0-bin/conf/netcat-logger.conf

\#定义这个agent中各组件的名字

a1.sources=r1

a1.sinks=k1

a1.channels=c1

\#描述和配置source组件：r1

a1.sources.r1.type=netcat

a1.sources.r1.bind=192.168.52.120

a1.sources.r1.port=44444

\#描述和配置sink组件：k1

a1.sinks.k1.type=logger

\#描述和配置channel组件，此处使用是内存缓存的方式

a1.channels.c1.type=memory

a1.channels.c1.capacity=1000

a1.channels.c1.transactionCapacity=100

\#描述和配置sourcechannelsink之间的连接关系

a1.sources.r1.channels=c1

a1.sinks.k1.channel=c1

**第三步：启动配置文件**

**指定采集方案配置文件**，在相应的节点上启动flumeagent

先用一个最简单的例子来测试一下程序环境是否正常

启动agent去采集数据

bin/flume-ngagent-cconf-fconf/netcat-logger.conf-na1-Dflume.root.logger=INFO,console

-cconf指定flume自身的配置文件所在目录

-fconf/netcat-logger.con指定我们所描述的采集方案

-na1指定我们这个agent的名字

**第四步：安装telent准备测试**

在node02机器上面安装telnet客户端，用于模拟数据的发送

yum-yinstalltelnet

telnetnode0344444#使用telnet模拟数据发送



```shell-》安装Flume：不是分布式程序flume-ng-1.6.0-cdh5.14.0.tar.gzng：nextog:orignal-》下载解压tar-zxvfflume-ng-1.6.0-cdh5.14.0.tar.gz-C../servers/-》修改配置flume-env.shjava_homeexportHADOOP_HOME=/export/servers/hadoop-2.6.0-cdh5.14.01-知道HDFS的地址a-配置Hadoop_Homeb-将Hadoop的配置文件放入flumeconf目录下core-site.xmlhdfs-site.xml【如果配置了HA，需要放】c-在flume的agent指定hdfs的地址2-调用Hadoop的jar包-》开发agent，运行agent需求：读取Nginx的日志文件，缓存在内存中，发送到日志中execmemChannellogSink```##**Kafka**

**1.准备3台虚拟机**

本机也要加

```properties192.168.72.141node01192.168.72.142node02192.168.72.143node03```

**2.初始化环境**

1）安装jdk、安装zookeeper

2）安装目录

安装包存放的目录：/export/software

.安装程序存放的目录：/export/servers

.数据目录：/export/data

.日志目录：/export/logs

```propertiesmkdir-p/export/servers/mkdir-p/export/software/mkdir-p/export/data/mkdir-p/export/logs/```

3）安装用户

.安装hadoop，会创建一个hadoop用户

.安装kafka，创建一个kafka用户

.或者创建bigdata用户，用来安装所有的大数据软件。

.**本例**：**使用root用户**

4）验证环境

a)jdk环境


b)zookeeper环境


**3.搭建Kafka集群**

**3.1.准备安装包**


由于kafka是scala语言编写的，基于scala的多个版本，kafka发布了多个版本。

其中2.11是推荐版本。

**3.2.下载安装包及解压**

```propertiestar-zxvfkafka_2.11-1.0.0.tgz-C/export/servers/cd/export/servers/mvkafka_2.11-1.0.0kafka```

1）删除之前的安装记录

```propertiesrm-rf/export/servers/kafkarm-rf/export/data/kafka/```

2）解压文件

```propertiestar-zxvfkafka_2.11-1.0.0.tgz-C/export/servers/```

3）重命名

```propertiesmvkafka_2.11-1.0.0/kafka```

**3.3.查看目录及修改配置文件**

**3.3.1查看目录**


**3.3.2修改配置文件**

进入配置目录，查看server.properties文件

catserver.properties|grep-v"#"


通过以上命令，查看到了默认的配置文件，对默认的文件进行修改。

修改三个地方

viserver.properties

1）Borker.id

2）数据存放的目录，**注意目录如果不存在，需要新建下。**

3）zookeeper的地址信息

```properties#broker.id标识了kafka集群中一个唯一broker。broker.id=0num.network.threads=3num.io.threads=8socket.send.buffer.bytes=102400socket.receive.buffer.bytes=102400socket.request.max.bytes=104857600

#存放生产者生产的数据数据一般以topic的方式存放log.dirs=/export/data/kafkanum.partitions=1num.recovery.threads.per.data.dir=1offsets.topic.replication.factor=1transaction.state.log.replication.factor=1transaction.state.log.min.isr=1log.retention.hours=168log.segment.bytes=1073741824log.retention.check.interval.ms=300000

#zk的信息zookeeper.connect=node01:2181,node02:2181,node03:2181zookeeper.connection.timeout.ms=6000group.initial.rebalance.delay.ms=0

#可选配置delete.topic.enable=truehost.name=192.168.72.141```

**3.3分发配置文件及修改brokerid**

将修改好的配置文件，分发到node02，node03上。

先在node02、node03上删除以往的安装记录

```properties#创建一个数据存放目录/export/data/kafkamkdir-p/export/data/kafka```

分发安装包

```propertiesscp-r/export/servers/kafka/node02:/export/servers/scp-r/export/servers/kafka/node03:/export/servers/```

修改node02上的broker.id

```propertiesvi/export/servers/kafka/config/server.properties```


修改node03上的broker.id


注意：host.name各个机器也不相同，也需要进行修改

**3.4.启动集群**

```propertiescd/export/servers/kafka/binnohup./kafka-server-start.sh/export/servers/kafka/config/server.properties>/dev/null2>&1&

/dev/null黑洞不要了2>&1将其他级别的日志也输出到黑洞nohup&后台启动

输出到文件：nohup./kafka-server-start.sh/export/servers/kafka/config/server.properties>/export/logs/kafka/kafka.log2>&1&

如果/export/logs/kafka不存在,先创建这个目录,这个目录存放启动后产生的日志mkdir-p/export/logs/kafka```

**3.5.查看Kafka集群**

由于kafka集群并没有UI界面可以查看。

需要借助外部工具，来查看kafka的集群

这个工具是一个java程序，必须要安装好JDK




**3.6自动化启动脚本**

-startKafka.sh

```properties#!/bin/shcat/export/servers/kafka/bin/slave|whilereadlinedo{echo$linessh$line"source/etc/profile;nohup/export/servers/kafka/bin/kafka-server-start.sh/export/servers/kafka/config/server.properties>/dev/null2>&1&"}&waitdone```

-stopKafka.sh

```properties#!/bin/shcat/export/servers/kafka/bin/slave|whilereadlinedo{echo$linessh$line"source/etc/profile;jps|grepKafka|cut-c1-5|xargskill-s9"}&waitdone```

-slave存放的位置:/export/servers/kafka/bin/slave

##Sqoop

**sqoop实战及原理**

**sqoop安装**

安装sqoop的前提是已经具备java和hadoop的环境

**1、下载并解压**

下载地址

sqoop1版本详细下载地址

sqoop2版本详细下载地址

我们这里使用sqoop1的版本，下载之后上传到/export/softwares目录下，然后进行解压

tar-zxvfsqoop-1.4.6-cdh5.14.0.tar.gz-C../servers/

**2、修改配置文件**

cd/export/servers/sqoop-1.4.6-cdh5.14.0/conf/

cpsqoop-env-template.shsqoop-env.sh

vimsqoop-env.sh

exportHADOOP_COMMON_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0

exportHADOOP_MAPRED_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0

exportHIVE_HOME=/export/servers/hive-1.1.0-cdh5.14.0

**3、加入额外的依赖包**

sqoop的使用需要添加两个额外的依赖包，一个是mysql的驱动包，一个是java-json的的依赖包，不然就会报错

mysql-connector-java-5.1.40.jar

java-json.jar


将这个两个jar包添加到sqoop的lib目录下

**4、验证启动**

cd/export/servers/sqoop-1.4.6-cdh5.14.0

bin/sqoop-version


##Impata

**通过本地yum源进行安装impala**

所有cloudera软件下载地址

一、挂载磁盘

```shell1-手动添加一块硬盘：详细过程参考图片注意该虚拟硬盘所在的物理硬盘剩余空间至少大于15GB2-创建分区fdisk-l确认出现/dev/sdb该硬盘设备fdisk/dev/sdb对sdb硬盘进行分区p查看当前硬盘的分区信息n创建新分区p分区类型为主分区1分区号为1回车硬盘起始位置，默认为0回车硬盘结束位置，默认为最大值p查看当前硬盘的分区信息w保存并退出mkfs-text4/dev/sdb1格式化硬盘分区3-挂载目录创建挂载目录：mkdir/export/users手动临时挂载：mount/dev/sdb1/export/users验证是否挂载成功：df-h永久挂载，开机自动加载：echo"/dev/sdb1/export/usersext4defaults00">>/etc/fstab```

二、配置Impala的yum源

三、安装分布式Impala

```properties1-节点功能：impala-catalog：元数据管理impala-state-store：主节点impala-server/Impalad：从节点2-节点划分：服务名称node01node02node03impala-catalog★impala-state-store★impala-server★★★3-安装Impala第二台机器：yuminstallimpala-yyuminstallimpala-server-yyuminstallimpala-state-store-yyuminstallimpala-catalog-yyuminstallimpala-shell-y第一台和第三台机器：yuminstallimpala-server-y```

四、配置Hadoop的shortcircuit短路机制短路：客户端直接获取数据块，不经过DataNode，DataNode只负责提供位置信息

```properties1-在所有Hadoop节点上创建一下目录：用于保存读取的socketmkdir-p/var/run/hdfs-sockets2-在所有DataNode的节点的hdfs-site.xml中添加如下配置dfs.client.read.shortcircuittruedfs.domain.socket.path/var/run/hdfs-sockets/dndfs.client.file-block-storage-locations.timeout.millis10000dfs.datanode.hdfs-blocks-metadata.enabledtrue3-分发修改完的hdfs-site.xml到所有机器scp/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/hdfs-site.xml192.168.134.222:/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/scp/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/hdfs-site.xml192.168.134.223:/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/

4-启动HDFS集群cd/export/servers/hadoop-2.6.0-cdh5.14.0/sbin/start-dfs.sh检测配置是否生效more/export/servers/hadoop-2.6.0-cdh5.14.0/logs/hadoop-root-datanode-hpsk.bigdata01.com.log|grep/var/run/hdfs-sockets/||结果：ListeningonUNIXdomainsocket:/var/run/hdfs-sockets/dn

五、配置Hive的metastore服务

```properties1-修改每台机器的hive-site.xml文件，添加metastore服务的配置hive.metastore.uristhrift://hadoop03:9083hive.metastore.client.socket.timeout36002-确保每一台机器都有Hivescp-r/export/servers/hive-1.1.0-cdh5.14.0192.168.134.221:/export/servers/scp-r/export/servers/hive-1.1.0-cdh5.14.0192.168.134.222:/export/servers/3-在第三台机器启动metastore服务和hiveserver2服务测试确保mysql已经正常启动nohupbin/hive--servicemetastore2>&1>>logs/metastore.log&nohupbin/hiveserver22>&1>>logs/hiveserver.log&检查端口是否开放：netstat-atunlp|grep9083netstat-atunlp|grep10000在任意一台机器上启动beeline连接测试cd/export/servers/hive-1.1.0-cdh5.14.0/bin/beeline!connectjdbc:hive2://hpsk.bigdata03.com:10000root123456showdatabases;```

六、配置Impala与Hadoop、Hive的集成

```properties1-Impala的配置文件目录为/etc/impala/confll/etc/impala/conf/2-在所有的ImpalaServer的节点中添加core-site.xml、hdfs-site.xml、hive-site.xmlln-s/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/core-site.xml/etc/impala/conf/core-site.xmlln-s/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/hdfs-site.xml/etc/impala/conf/hdfs-site.xmlln-s/export/servers/hive-1.1.0-cdh5.14.0/conf/hive-site.xml/etc/impala/conf/hive-site.xml```

七、修改Impala自身配置

```properties1-修改每台Impala节点的配置文件vim/etc/default/impalaIMPALA_CATALOG_SERVICE_HOST=hpsk.bigdata02.comIMPALA_STATE_STORE_HOST=hpsk.bigdata02.com2-为每台Impala节点添加MySQL的jdbc驱动包ln-s/export/servers/hive-1.1.0-cdh5.14.0/lib/mysql-connector-java-5.1.38.jar/usr/share/java/mysql-connector-java.jar检查：ll/usr/share/java/mysql-connector-java.jar3-修改每台Impala节点的bigtop文件的JAVA_HOMEvim/etc/default/bigtop-utilsexportJAVA_HOME=/export/servers/jdk1.8.0_141```

八、启动Impala服务

```properties第二台机器启动三个服务：serviceimpala-state-storestartserviceimpala-catalogstartserviceimpala-serverstart第一台和第三台机器启动一个服务：serviceimpala-serverstart查看进程：ps-ef|grepimpala

**安装Impala**

以前面配置好的CDH5.14.0本地源对Impala进行安装部署使用。

前提条件安装好Hadoop、Hive、MySQLHadoop：node1主节点，其他为从节点Hive：node1MySQL：node1配置好本地yum源Hadoop本地库配置Hadoop框架需要支持C程序访问接口，查看下图，如果有该路径下有这么些文件，就证明支持C接口


使用Hadoop自带工具类检查支持的native库


安装规划


主节点cdh01执行以下命令进行安装

从节点cdh02和cdh03上安装以下服务

**配置Impala**


备注：

1）、修改hive-site.xml文件（cdh01）Impala依赖于Hive，所以首先需要进行Hive的配置修改；cdh01机器修改hive-site.xml内容如下:vim/export/servers/hive/conf/hive-site.xml

```xmljavax.jdo.option.ConnectionURLjdbc:mysql://node1:3306/hivecreateDatabaseIfNotExist=truejavax.jdo.option.ConnectionDriverNamecom.mysql.jdbc.Driverjavax.jdo.option.ConnectionUserNamerootjavax.jdo.option.ConnectionPassword123456hive.cli.print.current.dbtruehive.cli.print.headertruehive.server2.thrift.bind.hostnode3hive.metastore.uristhrift://node1:9083hive.metastore.client.socket.timeout3600```

2）添加mysql的jar包放入hive的lib目录下


3）、将hive的安装包发送到cdh02与cdh03上（如果其他节点安装Hive）

在cdh01上执行命令

```propertiescd/export/servers/scp-rhive-1.1.0-cdh5.14.0/node2:$PWDscp-rhive-1.1.0-cdh5.14.0/node3:$PWD```

备注：集群中可以只在一个节点安装Hive。如果只有一个节点安装Hive，这步可省略

4）、启动hive的metastore服务

在cdh01上启动hive的metastore服务

```propertiescd/export/servers/hivenohupbin/hive--servicemetastore&```

注意：一定要保证mysql的服务正常启动，否则metastore的服务不能够启动启动MetaStore服务脚本metastore-start.sh：


5）、所有Hadoop节点修改hdfs-site.xml添加以下内容所有节点创建文件夹mkdir-p/var/run/hdfs-sockets修改所有节点的hdfs-site.xml添加以下配置，修改完之后重启hdfs集群生效vim/export/servers/hadoop/etc/hadoop/hdfs-site.xml

```xmldfs.client.read.shortcircuittruedfs.domain.socket.path/var/run/hdfs-sockets/dndfs.datanode.hdfs-blocks-metadata.enabledtruedfs.client.file-block-storage-locations.timeout.millis10000```

同步配置文件到所有HDFS集群

```propertiescd/export/servers/hadoop/etc/hadoopscp-rhdfs-site.xmlbigdata-cdh02.itcast.cn:$PWDscp-rhdfs-site.xmlbigdata-cdh03.itcast.cn:$PWD```

备注:

当在Impala上执行查询的时候，会到多个datanode上分布式地读取block数据，如果Impala拥有更多的block信息，将会更高效的获取数据并处理。Short-circuitread意味着会从datanode的本地文件系统直接读取数据，而不用首先与datanode进行通信，这肯定会提高性能。

6）、重启hdfs

在Hadoop集群的主节点cdh01上执行

```propertiesshhdfs-stop-cluster.shshhdfs-start-cluster.sh```

7）、创建Hadoop与Hive的配置文件的连接Impala的配置目录为/etc/impala/conf这个路径下面需要把core-site.xml，hdfs-site.xml以及hive-site.xml拷贝到这里来，使用软连接的方式。【将Hadoop、Hive的配置告诉Impala】cdh01、cdh02、cdh03上执行以下命令创建链接到Impala配置目录下来

```shellln-s/export/servers/hadoop/etc/hadoop/core-site.xml/etc/impala/conf/core-site.xmlln-s/export/servers/hadoop/etc/hadoop/hdfs-site.xml/etc/impala/conf/hdfs-site.xmlln-s/export/servers/hive/conf/hive-site.xml/etc/impala/conf/hive-site.xml```

8）、所有节点修改impala默认配置

vim/etc/default/impala

```properties#指定集群的CATALOG_SERVICE和STATE_STORE服务地址IMPALA_CATALOG_SERVICE_HOST=bigdata-cdh01.itcast.cnIMPALA_STATE_STORE_HOST=bigdata-cdh01.itcast.cn```

Impala配置文件/etc/default/impala中内容

```shellIMPALA_CATALOG_SERVICE_HOST=bigdata-cdh01.itcast.cnIMPALA_STATE_STORE_HOST=bigdata-cdh01.itcast.cnIMPALA_STATE_STORE_PORT=24000IMPALA_BACKEND_PORT=22000IMPALA_LOG_DIR=/var/log/impalaIMPALA_CATALOG_ARGS="-log_dir=${IMPALA_LOG_DIR}"IMPALA_STATE_STORE_ARGS="-log_dir=${IMPALA_LOG_DIR}-state_store_port=${IMPALA_STATE_STORE_PORT}"IMPALA_SERVER_ARGS="\-log_dir=${IMPALA_LOG_DIR}\-catalog_service_host=${IMPALA_CATALOG_SERVICE_HOST}\-state_store_port=${IMPALA_STATE_STORE_PORT}\-use_statestore\-state_store_host=${IMPALA_STATE_STORE_HOST}\-be_port=${IMPALA_BACKEND_PORT}"ENABLE_CORE_DUMPS=false#LIBHDFS_OPTS=-Djava.library.path=/usr/lib/impala/lib#MYSQL_CONNECTOR_JAR=/usr/share/java/mysql-connector-java.jar#IMPALA_BIN=/usr/lib/impala/sbin#IMPALA_HOME=/usr/lib/impala#HIVE_HOME=/usr/lib/hive#HBASE_HOME=/usr/lib/hbase#IMPALA_CONF_DIR=/etc/impala/conf#HADOOP_CONF_DIR=/etc/impala/conf#HIVE_CONF_DIR=/etc/impala/conf#HBASE_CONF_DIR=/etc/impala/conf```

9）、node1创建mysql的驱动包的软连接

```ln-s/export/servers/hive/lib/mysql-connector-java-5.1.27-bin.jar/usr/share/java/mysql-connector-java.jar```

备注：需要启动hivemetastore服务的节点，要执行此步；/usr/share/java目录不存在的，需要手工创建

10）、所有节点修改bigtop的java路径修改bigtop的java_home路径vim/etc/default/bigtop-utils

```exportJAVA_HOME=/export/servers/jdk```

11）、启动impala服务

在主节点node1启动以下三个服务进程

```propertiesserviceimpala-state-storestartserviceimpala-catalogstartserviceimpala-serverstart```

在从节点node2和node3上启动impala-server

```serviceimpala-serverstart```

查看impala进程是否存在

```ps-ef|grepimpala```


注意：启动之后所有关于impala的日志默认都在/var/log/impala这个路径下，cdh01机器上面应该有三个进程，cdh02与cdh03机器上面只有一个进程，如果进程个数不对，去对应目录下查看报错日志

**一键服务脚本**

12）、浏览器页面访问

web访问端口

```-impalad25000-statestored25010-catalogd25020```

进入交互式命令行：

```shell[root@bigdata-cdh01kudu]#impala-shellStartingImpalaShellwithoutKerberosauthenticationConnectedtobigdata-cdh01.itcast.cn:21000Serverversion:impaladversion2.11.0-cdh5.14.0RELEASE(buildd68206561bce6b26762d62c01a78e6cd27aa7690)***********************************************************************************WelcometotheImpalashell.(ImpalaShellv2.11.0-cdh5.14.0(d682065)builtonSatJan613:27:16PST2018)Toseeasummaryofaquery'sprogressthatupdatesinreal-time,run'setLIVE_PROGRESS=1;'.***********************************************************************************[bigdata-cdh01.itcast.cn:21000]>```


测试SQL语句执行：

```select*fromemp;select*fromdept;selecte.ename,e.sal,d.dnamefromempejoindeptdone.deptno=d.deptno;```

**Impala与Kudu整合**

在每一个服务器的impala的配置文件中添加如下配置：vim/etc/default/impala

```shell#在IMPALA_SERVER_ARGS下添加：-kudu_master_hosts=bigdata-cdh01.itcast.cn:7051,bigdata-cdh02.itcast.cn:7051,bigdata-cdh03.itcast.cn:7051```


```impala的安装路径：/usr/lib/impalaimpala的服务配置主文件：/etc/default/impalaimpala的配置文件：/etc/impala/confimpala的日志：/var/log/impala```


##kudu

**1、软件安装方式**

Linux下常见的软件安装方式：二进制文件安装、rpm、yum

i、二进制包


二进制包里面包括了已经经过编译，可以马上运行的程序；只需要下载和解包（安装）、配置，就马上可以使用；缺点：对环境依赖大；

ii、rpm早期被称为RedHatPackageManager，但由于目前RPM非常流行，且已经成为Linux工业标准。所以RPM现在又被称为RPMisPackageManager；RPM的功能：打包、安装、查询、升级、卸载、校验等功能；RPM包并不是跨平台的。RedHat的RPM包与SUSE的RPM包不能混用。RedHat的安装，初始软件也都是使用RPM包进行安装的；RPM的缺点：程序与程序之间存在非常复杂的依赖关系，RPM无法解决软件包的依赖关系；iii、YumYUM被称为YellowdogUpdaterModified；YUM使用Python语言编写，对RPM包进行管理；可以通过HTTP服务器下载、FTP服务器下载、本地文件的等方式获得软件包；可以从指定的服务器自动下载RPM包并且安装；可以自动处理依赖性关系；yum的主配置文件（一般不改动）：/etc/yum.conf

YUM的片段配置：/etc/yum.repos.d/*.repo

```shellcd/etc/yum.repos.d/ls#有以下文件，仅有CentOS-Base.repo文件有效。文件中有enabled=0表示不生效CentOS-Base.repoCentOS-Debuginfo.repoCentOS-fasttrack.repoCentOS-Media.repoCentOS-Vault.repo#配置文件中重要的字段：#[...]：仓库的名称。不能重复；#name：对仓库的描述，该项必须有；#baseurl：配置仓库的路径。用于指定一个url；#mirrorlist：指向一个镜像列表，里面有多个url；#enabled：是否启用当前仓库。值为1或0，默认为1；#gpgcheck：是否需要gpg校验。值为1或0，默认为1；```

可以自定义yum的配置

2、自定义localimp.repo（指定从Http服务下载rpm）【3个节点都要改】

yum的常用命令

```shell#清空本地yum的缓存yumcleanall#在本地建立缓存yummakecache#安装软件包yum[-y]install包1包2包3...#卸载软件包yumremover包1包2包3...```

**2、节点规划**

|节点|kudu-master|kudu-tserver||----|-----------|------------||01|yes|yes||02|yes|yes||03|yes|yes|

**3、配置本地的CDH-yum源**


备注：要下载少量的软件包，需要网络支持，虚拟机要能联网

1）、配置本地Yum的Repository


备注：这里选择在cdh01上操作

2）、上传压缩包并解压

软件位置：cdh01；/export/servers/cdh5.14.0-centos6.tar.gz


【在node1上执行即可]

```shell#创建软链接ln-s/export/servers/cdh/5.14.0/var/www/html/cdh5.14.0#删除软链接cd/var/www/html/rm./cdh5.14.0```

```shell访问异常：Youdon'thavepermissiontoaccess/cdh5.14.0/onthisserver需要关闭Selinux服务（1）临时关闭执行命令：setenforce0(2)永久关闭vim/etc/sysconfig/selinuxSELINUX=enforcing改为SELINUX=disabled重启服务reboot```


4）、制作本地yum源

将node1上制作好的localimp配置文件发放到所有需要kudu的节点上去

```shell/etc/yum.repos.dscp-rlocalimp.repobigdata-cdh02.itcast.cn:$PWDscp-rlocalimp.repobigdata-cdh03.itcast.cn:$PWD```

4、安装Kudu

备注：在所有节点上操作使用yum命令，在不同的服务器下载对应的服务

|服务
器|安装命令||-----------|------------------------------------------------------------||01|yuminstall-ykudukudu-masterkudu-tserverkudu-client0kudu-client-
devel||02|yuminstall-ykudukudu-masterkudu-tserverkudu-client0kudu-client-
devel||03|yuminstall-ykudukudu-masterkudu-tserverkudu-client0kudu-client-
devel|

命令说明：

```shellyuminstallkudu#Kudu的基本包yuminstallkudu-master#KuduMasteryuminstallkudu-tserver#KuduTserveryuminstallkudu-client0#KuduC++客户端共享库yuminstallkudu-client-devel#KuduC++客户端共享库SDK```

安装方式：yum软件存放路径：/usr/lib/kudu配置文件路径：/etc/kudu/conf/缺省配置路径：/etc/default/系统日志存放路径：/var/log/kudu/配置数据目录：数据日志与数据存放路径：/export/servers/kudu

**4、配置Kudu服务**备注：在所有节点上操作安装完成后，需在所有节点/etc/kudu/conf目录有两个文件：master.gflagfile和tserver.gflagfile。修改master.gflagfile（修改日志、数据存放位置、添加主机地址）

```shell#cat/etc/kudu/conf/master.gflagfile#Donotmodifythesetwolines.Ifyouwishtochangethesevariables,#modifythemin/etc/default/kudu-master.--fromenv=rpc_bind_addresses--fromenv=log_dir#修改原参数，添加最后一个参数--fs_wal_dir=/export/servers/kudu/master/wal--fs_data_dirs=/export/servers/kudu/master/data--master_addresses=bigdata-cdh01.itcast.cn:7051,bigdata-cdh02.itcast.cn:7051,bigdata-cdh03.itcast.cn:7051```

修改tserver.gflagfile（修改日志、数据存放位置、添加主机地址）

```shell#Donotmodifythesetwolines.Ifyouwishtochangethesevariables,#modifythemin/etc/default/kudu-tserver.--fromenv=rpc_bind_addresses--fromenv=log_dir#修改原参数，添加最后一个参数--fs_wal_dir=/export/servers/kudu/tserver/wal--fs_data_dirs=/export/servers/kudu/tserver/data--tserver_master_addrs=bigdata-cdh01.itcast.cn:7051,bigdata-cdh02.itcast.cn:7051,bigdata-cdh03.itcast.cn:7051```

修改/etc/default/kudu-master

```shell#这一行没有变，指定了日志的位置exportFLAGS_log_dir=/var/log/kudu#每台机器的master地址要与主机名一致,这里是在node1上exportFLAGS_rpc_bind_addresses=bigdata-cdh01.itcast.cn:7051```

修改/etc/default/kudu-tserver

```shell#这一行没有变，指定了日志的位置exportFLAGS_log_dir=/var/log/kudu#每台机器的tserver地址要与主机名一致，这里是在node1上exportFLAGS_rpc_bind_addresses=bigdata-cdh01.itcast.cn:7050```

创建目录，更改宿主(所有节点)

```shellmkdir-p/export/servers/kudu/mastermkdir-p/export/servers/kudu/tserver#kudu默认用户是kudu，需要将/export/servers/kudu权限修改成kuduchown-Rkudu:kudu/export/servers/kudu/```

2、启动命令在每台服务器上都执行下面脚本

```shellservicekudu-masterstartservicekudu-tserverstart或者sudoservicekudu-masterstartsudoservicekudu-tserverstart```

2）、关闭Kudu

.1、关闭命令.在每台服务器上都执行下面脚本

```shellservicekudu-masterstopservicekudu-tserverstop或者sudoservicekudu-masterstopsudoservicekudu-tserverstop```

3）、一键服务脚本

**7、安装过成中可能出现的问题**

```shellsudo:/etc/sudoersisworldwritable解决方式：pkexecchmod555/etc/sudoers```

.2、启动kudu的时候报错

3、启动过程中报错

```propertiesF081021:31:12.62093220143master_main.cc:71]Checkfailed:_s.ok()Badstatus:Invalidargument:Unabletoinitializecatalogmanager:Failedtoinitializesystablesasync:on-diskmasterlist解决：（1）：停掉master和tserver（2）：删除掉之前所有的/export/servers/kudu/master/*和/export/servers/kudu/tserver/*```

4、启动过程中报错

```propertiesF091315:12:00.62823720859master_main.cc:74]Checkfailed:_s.ok()Badstatus:IOerror:CouldnotcreatenewFSlayout:unabletocreatefilesystemroots:unabletowriteinstancemetadata:Calltomkstemp()failedonnametemplate/export/servers/kudu/master/instance.kudutmp.XXXXXX:Permissiondenied(error13)这是因为kudu默认使用kudu权限进行执行，可能遇到文件夹的权限不一致情况，更改文件夹权限即可```

5、启动过程中报错

```错误描述：kudu-master、kudu-tserver不能启动；ntp服务启动；用servicentpdstatus显示服务正常；在/var/log/kudu/kudu-master.FATAL有如下错误：stdout:ntp_gettime()returnscode5(ERROR)timee072ca67.fa770000Tue,Apr30201921:21:43.978,(.978378),maximumerror16000000us,estimatederror16000000us,TAIoffset0ntp_adjtime()returnscode5(ERROR)modes0x0(),offset0.000us,frequency-5.973ppm,interval1s,maximumerror16000000us,estimatederror16000000us,status0x41(PLL,UNSYNC),timeconstant7,precision1.000us,tolerance500ppm,这个错误是由于ntp不正常导致，输入ntptime也显示如上的错误。解决方法：重启ntp服务即可。servicentpdrestart```

**9、Kudu安装小结**启动服务的方式：servicekudu-masterstart|stop|statusservicekudu-tserverstart|stop|status


```shellvim/etc/ntp.conf#注释以下四行：#server0.centos.pool.ntp.orgiburst#server1.centos.pool.ntp.orgiburst#server2.centos.pool.ntp.orgiburst#server3.centos.pool.ntp.orgiburst```

3、修改node1的配置文件，添加相应内容

4、修改node2、node3的配置文件，添加相应内容

```shellvim/etc/ntp.confserver192.168.59.140preferserver127.127.1.0fudge127.127.1.0stratum10```

5、启动NTP服务

```shellservicentpdstartchkconfigntpdon```

6、检查ntp服务是否成功输入：ntpstat输出如下则启动成功并且同步已完成：

```synchronisedtolocalnetatstratum11timecorrecttowithin11mspollingserverevery64s```


##Hbase

注意事项：HBase强依赖zookeeper和hadoop，安装HBase之前一定要保证zookeeper和hadoop启动成功，且服务正常运行

**第一步：下载对应的HBase的安装包**

所有关于CDH版本的软件包下载地址如下

HBase对应的版本下载地址如下

**第二步：压缩包上传并解压**

```properties将我们的压缩包上传到node01服务器的/export/softwares路径下并解压cd/export/softwares/tar-zxvfhbase-1.2.0-cdh5.14.0-bin.tar.gz-C../servers/```

```properties第一台机器进行修改配置文件cd/export/servers/hbase-1.2.0-cdh5.14.0/conf```

**修改第一个配置文件hbase-env.sh**

```properties注释掉HBase使用内部zk

vimhbase-env.sh

exportJAVA_HOME=/export/servers/jdk1.8.0_141exportHBASE_MANAGES_ZK=false```

**修改第二个配置文件hbase-site.xml**

```修改hbase-site.xmlvimhbase-site.xml```

```xmlhbase.rootdirhdfs://node01:8020/hbase

hbase.cluster.distributedtrue

hbase.master.port16000

hbase.zookeeper.quorumnode01:2181,node02:2181,node03:2181

hbase.zookeeper.property.dataDir/export/servers/zookeeper-3.4.5-cdh5.14.0/zkdatas```

**修改第三个配置文件regionservers**

```vimregionservers

node01node02node03```

**创建back-masters配置文件，实现HMaster的高可用**

```cd/export/servers/hbase-1.2.0-cdh5.14.0/confvimbackup-masters

node02```

**第四步：安装包分发到其他机器**

```properties将我们第一台机器的hbase的安装包拷贝到其他机器上面去cd/export/servers/scp-rhbase-1.2.0-cdh5.14.0/node02:$PWDscp-rhbase-1.2.0-cdh5.14.0/node03:$PWD```

**第五步：三台机器创建软连接**

```shell因为hbase需要读取hadoop的core-site.xml以及hdfs-site.xml当中的配置文件信息，所以我们三台机器都要执行以下命令创建软连接ln-s/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/core-site.xml/export/servers/hbase-1.2.0-cdh5.14.0/conf/core-site.xmlln-s/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/hdfs-site.xml/export/servers/hbase-1.2.0-cdh5.14.0/conf/hdfs-site.xml```

**第六步：三台机器添加HBASE_HOME的环境变量**

```propertiesvim/etc/profileexportHBASE_HOME=/export/servers/hbase-1.2.0-cdh5.14.0exportPATH=:$HBASE_HOME/bin:$PATH```

**第七步：HBase集群启动**

```第一台机器执行以下命令进行启动cd/export/servers/hbase-1.2.0-cdh5.14.0bin/start-hbase.sh```

警告提示：HBase启动的时候会产生一个警告，这是因为jdk7与jdk8的问题导致的，如果linux服务器安装jdk8就会产生这样的一个警告


我们可以只是掉所有机器的hbase-env.sh当中的

“HBASE_MASTER_OPTS”和“HBASE_REGIONSERVER_OPTS”配置来解决这个问题。不过警告不影响我们正常运行，可以不用解决

```我们也可以执行以下命令单节点进行启动启动HMaster命令bin/hbase-daemon.shstartmaster启动HRegionServer命令bin/hbase-daemon.shstartregionserver

为了解决HMaster单点故障问题，我们可以在node02和node03机器上面都可以启动HMaster节点的进程，以实现HMaster的高可用bin/hbase-daemon.shstartmaster```

**第八步：页面访问**

###hive与HBase的整合

hive与我们的HBase各有千秋，各自有着不同的功能，但是归根接地，hive与hbase的数据最终都是存储在hdfs上面的，一般的我们为了存储磁盘的空间，不会将一份数据存储到多个地方，导致磁盘空间的浪费，我们可以直接将数据存入hbase，然后通过hive整合hbase直接使用sql语句分析hbase里面的数据即可，非常方便

hive:是一个数据仓库工具，是做离线数据统计，不支持实时读写，不能修改和删除

hbase：是一个nosql数据库，支持实时读写，不支持关流查询


**需求一：将hive分析结果的数据，保存到HBase当中去**

**第一步：拷贝hbase的五个依赖jar包到hive的lib目录下**

将我们HBase的五个jar包拷贝到hive的lib目录下

hbase的jar包都在/export/servers/hbase-1.2.0-cdh5.14.0/lib

我们需要拷贝五个jar包名字如下

hbase-client-1.2.0-cdh5.14.0.jar

hbase-hadoop2-compat-1.2.0-cdh5.14.0.jar

hbase-hadoop-compat-1.2.0-cdh5.14.0.jar

hbase-it-1.2.0-cdh5.14.0.jar

hbase-server-1.2.0-cdh5.14.0.jar

我们直接在node03执行以下命令，通过创建软连接的方式来进行jar包的依赖

```shellln-s/export/servers/hbase-1.2.0-cdh5.14.0/lib/hbase-client-1.2.0-cdh5.14.0.jar/export/servers/hive-1.1.0-cdh5.14.0/lib/hbase-client-1.2.0-cdh5.14.0.jarln-s/export/servers/hbase-1.2.0-cdh5.14.0/lib/hbase-hadoop2-compat-1.2.0-cdh5.14.0.jar/export/servers/hive-1.1.0-cdh5.14.0/lib/hbase-hadoop2-compat-1.2.0-cdh5.14.0.jarln-s/export/servers/hbase-1.2.0-cdh5.14.0/lib/hbase-hadoop-compat-1.2.0-cdh5.14.0.jar/export/servers/hive-1.1.0-cdh5.14.0/lib/hbase-hadoop-compat-1.2.0-cdh5.14.0.jarln-s/export/servers/hbase-1.2.0-cdh5.14.0/lib/hbase-it-1.2.0-cdh5.14.0.jar/export/servers/hive-1.1.0-cdh5.14.0/lib/hbase-it-1.2.0-cdh5.14.0.jarln-s/export/servers/hbase-1.2.0-cdh5.14.0/lib/hbase-server-1.2.0-cdh5.14.0.jar/export/servers/hive-1.1.0-cdh5.14.0/lib/hbase-server-1.2.0-cdh5.14.0.jar```

**第二步：修改hive的配置文件**

编辑node03服务器上面的hive的配置文件hive-site.xml添加以下两行配置

vimhive-site.xml

```xmlhive.zookeeper.quorumnode01,node02,node03hbase.zookeeper.quorumnode01,node02,node03```

**第三步：修改hive-env.sh配置文件添加以下配置**

```propertiesexportHADOOP_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0exportHBASE_HOME=/export/servers/hbase-1.2.0-cdh5.14.0exportHIVE_CONF_DIR=/export/servers/hive-1.1.0-cdh5.14.0/conf```

**第四步：hive当中建表并加载以下数据**

**hive当中建表**

进入hive客户端

```cd/export/servers/hive-1.1.0-cdh5.14.0/bin/hive```

创建hive数据库与hive对应的数据库表

```sqlcreatedatabasecourse;usecourse;createexternaltableifnotexistscourse.score(idint,cnamestring,scoreint)rowformatdelimitedfieldsterminatedby','storedastextfile;```

**进行加载数据**

进入hive客户端进行加载数据

```sqlhive(course)>loaddatalocalinpath'/export/servers/tmp/hive-hbase.txt'intotablescore;hive(course)>select*fromscore;```

**第五步：创建hive管理表与HBase进行映射**

我们可以创建一个hive的管理表与hbase当中的表进行映射，hive管理表当中的数据，都会存储到hbase上面去

hive当中创建内部表

```sqlcreatetablecourse.hbase_score(idint,cnamestring,scoreint)storedby'org.apache.hadoop.hive.hbase.HBaseStorageHandler'withserdeproperties("hbase.columns.mapping"="cf:name,cf:score")tblproperties("hbase.table.name"="hbase_score");```

通过insertoverwriteselect插入数据

```sqlinsertoverwritetablecourse.hbase_scoreselectid,cname,scorefromcourse.score;```

**第六步：hbase当中查看表hbase_score**

进入hbase的客户端查看表hbase_score，并查看当中的数据

```hbase(main):023:0>listTABLEhbase_scoremyusermyuser2studentuser5row(s)in0.0210seconds

=>["hbase_score","myuser","myuser2","student","user"]hbase(main):024:0>scan'hbase_score'ROWCOLUMN+CELL1column=cf:name,timestamp=1550628395266,value=zhangsan1column=cf:score,timestamp=1550628395266,value=802column=cf:name,timestamp=1550628395266,value=lisi2column=cf:score,timestamp=1550628395266,value=603column=cf:name,timestamp=1550628395266,value=wangwu3column=cf:score,timestamp=1550628395266,value=304column=cf:name,timestamp=1550628395266,value=zhaoliu4column=cf:score,timestamp=1550628395266,value=704row(s)in0.0360seconds```

**需求二：创建hive外部表，映射HBase当中已有的表模型，直接通过**

**第一步：HBase当中创建表并手动插入加载一些数据**

进入HBase的shell客户端，手动创建一张表，并插入加载一些数据进去

```sqlreate'hbase_hive_score',{NAME=>'cf'}put'hbase_hive_score','1','cf:name','zhangsan'put'hbase_hive_score','1','cf:score','95'

put'hbase_hive_score','2','cf:name','lisi'put'hbase_hive_score','2','cf:score','96'

put'hbase_hive_score','3','cf:name','wangwu'put'hbase_hive_score','3','cf:score','97'```

操作成功结果如下：

```sqlhbase(main):049:0>create'hbase_hive_score',{NAME=>'cf'}0row(s)in1.2970seconds

=>Hbase::Table-hbase_hive_scorehbase(main):050:0>put'hbase_hive_score','1','cf:name','zhangsan'0row(s)in0.0600seconds

hbase(main):051:0>put'hbase_hive_score','1','cf:score','95'0row(s)in0.0310seconds

hbase(main):052:0>put'hbase_hive_score','2','cf:name','lisi'0row(s)in0.0230seconds

hbase(main):053:0>put'hbase_hive_score','2','cf:score','96'0row(s)in0.0220seconds

hbase(main):054:0>put'hbase_hive_score','3','cf:name','wangwu'0row(s)in0.0200seconds

hbase(main):055:0>put'hbase_hive_score','3','cf:score','97'0row(s)in0.0250seconds```

**第二步：建立hive的外部表，映射HBase当中的表以及字段**

在hive当中建立外部表，

进入hive客户端，然后执行以下命令进行创建hive外部表，就可以实现映射HBase当中的表数据

```sqlCREATEexternalTABLEcourse.hbase2hive(idint,namestring,scoreint)STOREDBY'org.apache.hadoop.hive.hbase.HBaseStorageHandler'WITHSERDEPROPERTIES("hbase.columns.mapping"=":key,cf:name,cf:score")TBLPROPERTIES("hbase.table.name"="hbase_hive_score");```

###Sqoop整合HBase

sqoop是一个数据导入导出的工具，可以将关系型数据库当中的数据导入到大数据平台来，也可以将大数据平台当中的数据导入到关系型数据库当中去

我们也可以通过sqoop导入数据到hbase或者从hbase当中导出数据

```cd/export/servers/sqoop-1.4.6-cdh5.14.0/confvimsqoop-env.sh```

```properties#Setpathtowherebin/hadoopisavailableexportHADOOP_COMMON_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0

#Setpathtowherehadoop-*-core.jarisavailableexportHADOOP_MAPRED_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0

#setthepathtowherebin/hbaseisavailableexportHBASE_HOME=/export/servers/hbase-1.2.0-cdh5.14.0

#Setthepathtowherebin/hiveisavailableexportHIVE_HOME=/export/servers/hive-1.1.0-cdh5.14.0```

**第二步：在mysql当中创建数据库以及数据库表并插入数据**

**创建数据库表**

```sqlCREATEDATABASEIFNOTEXISTSlibrary;USElibrary;CREATETABLEbook(idINT(4)PRIMARYKEYNOTNULLAUTO_INCREMENT,NAMEVARCHAR(255)NOTNULL,priceVARCHAR(255)NOTNULL);```

**插入数据**

```sqlINSERTINTObook(NAME,price)VALUES('LieSporting','30');INSERTINTObook(NAME,price)VALUES('Pride&Prejudice','70');INSERTINTObook(NAME,price)VALUES('FallofGiants','50');```

**第三步：将mysql表当中的数据导入HBase表当中去**

执行以下命令，将mysql表当中的数据导入到HBase当中去

```shellbin/sqoopimport\--connectjdbc:mysql://192.168.52.102:3306/library\--usernameroot\--password123456\--tablebook\--columns"id,name,price"\--column-family"info"\--hbase-create-table\--hbase-row-key"id"\--hbase-table"hbase_book"\--num-mappers1\//启动n个mapper来并行导入默认是四个--split-byid//按照某一列来切分表的工作单元```

**第四步：HBase当中查看表数据**

进入hbase的shell客户端，通过scan查看数据

```sqlhbase(main):057:0>scan'hbase_book'ROWCOLUMN+CELL1column=info:name,timestamp=1550634017823,value=LieSporting1column=info:price,timestamp=1550634017823,value=302column=info:name,timestamp=1550634017823,value=Pride&Prejudice2column=info:price,timestamp=1550634017823,value=703column=info:name,timestamp=1550634017823,value=FallofGiants3column=info:price,timestamp=1550634017823,value=50

**需求二：将HBase当中的数据导出到mysql当中来**

将hbase_book这张表当中的数据导出到mysql当中来

注意：sqoop不支持我们直接将HBase当中的数据导出，所以我们可以通过以下的转换进行导出

Hbase→hive外部表→hive内部表→通过sqoop→mysql

**第一步：创建hive外部表**

进入hive客户端，创建hive外部表，映射hbase当中的hbase_book表

```sqlCREATEEXTERNALTABLEcourse.hbase2mysql(idint,namestring,priceint)STOREDBY'org.apache.hadoop.hive.hbase.HBaseStorageHandler'WITHSERDEPROPERTIES("hbase.columns.mapping"=":key,info:name,info:price")TBLPROPERTIES("hbase.table.name"="hbase_book","hbase.mapred.output.outputtable"="hbase2mysql");```

**第二步：创建hive内部表并将外部表数据插入到内部表当中来**

进入hive客户端，执行以下命令，创建hive内部表，并将外部表的数据插入到hive的内部表当中来

```sqlCREATETABLEcourse.hbase2mysqlin(idint,namestring,priceint);```

**第三步：外部表数据插入内部表**

进入hive客户端执行以下命令，将hive外部表数据插入到hive内部表当中来

```sqlinsertoverwritetablecourse.hbase2mysqlinselect*fromcourse.hbase2mysql;```

**第四步：清空mysql表数据**

进入mysql客户端，执行以下命令，将mysql表数据清空

```sqlTRUNCATETABLEbook;```

**第五步：执行sqoop导出hive内部表数据到**

```sqlsqoopexport-connectjdbc:mysql://192.168.52.102:3306/library-usernameroot-password123456-tablebook-export-dir/user/hive/warehouse/course.db/hbase2mysqlin--input-fields-terminated-by'\001'--input-null-string'\\N'--input-null-non-string'\\N';将空null转换成自己想要的值```

Sqoop整合hbase



##**spark**

Spark2.x环境搭建要点

**第一、SparkQuickStart**

**1、环境配置**

解压编译打包Spark压缩包

```shell#tar-zxfspark-2.2.0-bin-2.6.0-cdh5.14.0.tgz```

基本配置：

**第一步、安装Scala-2.11.8**

```shell#tar-zxfscala-2.11.8.tgz-C/export/servers/```

配置系统环境变量（也可以不配置）

**第二步、修改配置名称**

```shell#cd/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0#cdconf#mvspark-env.sh.templatespark-env.sh```

**第三步、修改配置文件**

$SPARK_HOME/conf/spark-env.sh，增加如下内容：

```shell##设置JAVA和SCALA安装目录JAVA_HOME=/export/servers/jdkSCALA_HOME=/export/servers/scala

##HADOOP软件配置文件目录，读取HDFS上文件和运行YARN集群HADOOP_CONF_DIR=/export/servers/hadoop/etc/hadoop```

**第四步、启动HDFS集群**

```shell#执行脚本./hdfs-start-cluster.sh```

**第五步、本地模式运行spark-shell**

```shellbin/spark-shell--masterlocal[2]```

**2、词频统计WordCount**

SparkCore中最重要的数据结构：RDD，弹性分布式数据集，当做Scala集合中List列表就可以

**第一步、读取数据，封装到RDD中，数据类型为String**

```scala//读取HDFS上数据文件valinputRDD=sc.textFile("/datas/wordcount.input")

//获取RDD集合中第一行数据inputRDD.first

//获取RDD集合元素个数inputRDD.count```

**第二步、处理数据，单词分割，每个单词出现一次，按照单词分组，进行统计**

```scala//单词分割valwordsRDD=inputRDD.flatMap(line=>line.split("\\s+"))

//将单词转换为二元组，表示每个单词出现一次valtuplesRDD=wordsRDD.map(word=>(word,1))

//使用reduceByKey函数，先将相同Key的Values合并在一起，在调用reduce函数将Values值进行聚合操作valwordCountRDD=tuplesRDD.reduceByKey((a,b)=>a+b)

//调用collect函数，将RDD中的元素返回到Array数组中，注意collect慎用wordCountRDD.collect()```

**第三步、将结果存储到HDFS目录中**

```scalawordCountRDD.saveAsTextFile("/datas/sparkOutput/")```

**第四步、查看输出结果**

```shell#查看文件，使用通配符*bin/hdfsdfs-text/datas/sparkOutput/pa*```

运行官方Example中**圆周率PI**计算

```SHELLSPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0${SPARK_HOME}/bin/spark-submit\--masterlocal[4]\--classorg.apache.spark.examples.SparkPi\${SPARK_HOME}/examples/jars/spark-examples_2.11-2.2.0.jar\10```

**第二、SparkStandaloneCluster**

**1、Standalone集群环境搭建**

**配置MASTER、Workers、HistoryServer**：`$SPARK_HOME/conf/spark-env.sh`内容如下：

```shellSPARK_MASTER_HOST=bigdata-cdh01.itcast.cnSPARK_MASTER_PORT=7077SPARK_MASTER_WEBUI_PORT=8080SPARK_WORKER_CORES=2SPARK_WORKER_MEMORY=2gSPARK_WORKER_PORT=7078SPARK_WORKER_WEBUI_PORT=8081SPARK_HISTORY_OPTS="-Dspark.history.fs.logDirectory=hdfs://bigdata-cdh01.itcast.cn:8020/spark/eventLogs/-Dspark.history.fs.cleaner.enabled=true"```

-**创建EventLogs存储目录：**

```shellbin/hdfsdfs-mkdir-p/spark/eventLogs/```

-**Workers主机名称：**$SPARK_HOME/conf/slaves

内容如下：

```shellbigdata-cdh01.itcast.cnbigdata-cdh02.itcast.cnbigdata-cdh03.itcast.cn```

-**配置所有Spark应用运行保存EventLogs**：$SPARK_HOME/conf/spark-defaults.conf内容如下：

```shellspark.eventLog.enabledtruespark.eventLog.dirhdfs://bigdata-cdh01.itcast.cn:8020/spark/eventLogs/spark.eventLog.compresstrue```

-**分发到集群所有机器**

```shellscp-rspark-2.2.0-bin-2.6.0-cdh5.14.0/bigdata-cdh02.itcast.cn:$PWDscp-rspark-2.2.0-bin-2.6.0-cdh5.14.0/bigdata-cdh03.itcast.cn:$PWD```

-**启动服务进程**

-在Master节点上启动，进入`$SPARK_HOME`

-主节点Master：

```shellsbin/start-master.sh```

-从节点Workers：

```shellsbin/start-slaves.sh```

-历史服务器HistoryServer：

```shellsbin/start-history-server.sh```

-**运行官方Example中圆周率PI计算**

```shellSPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0${SPARK_HOME}/bin/spark-submit\--masterspark://bigdata-cdh01.itcast.cn:7077\--classorg.apache.spark.examples.SparkPi\${SPARK_HOME}/examples/jars/spark-examples_2.11-2.2.0.jar\100```

**2、StandaloneHA集群**

基于Zookeeper配置Master高可用：

-**停止SparkStandalone集群**

```shellsbin/stop-master.shsbin/stop-slaves.sh```

-**增加Zookeeper配置**：`$SPARK_HOME/conf/spark-env.sh`

```shellSPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER-Dspark.deploy.zookeeper.url=bigdata-cdh01.itcast.cn:2181,bigdata-cdh02.itcast.cn:2181,bigdata-cdh03.itcast.cn:2181-Dspark.deploy.zookeeper.dir=/spark-ha"```

删除内容：

```shellSPARK_MASTER_HOST=bigdata-cdh02.itcast.cn```

-**将`spark-env.sh`分发集群**

```shellscp-rspark-env.shbigdata-cdh02.itcast.cn:$PWDscp-rspark-env.shbigdata-cdh03.itcast.cn:$PWD```

-**启动集群服务**

-启动Zokeeper集群服务，进入$ZOOKEEPER_HOME

```shellbin/zkServer.shstart```

-在cdh02和cdh03机器启动Master

-在cdh02（ActiverMaster）机器启动所有Workers：Master为Alive节点上执行

```shellSPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0${SPARK_HOME}/bin/spark-submit\--masterspark://hadoop02:7077,hadoop03:7077\--classorg.apache.spark.examples.SparkPi\${SPARK_HOME}/examples/jars/spark-examples_2.11-2.2.0.jar\100```

**第三、SparkOnYARN**

-**设置环境变量**

```shellHADOOP_CONF_DIR=/export/servers/hadoop/etc/hadoopYARN_CONF_DIR=/export/servers/hadoop/etc/hadoop```

前面已设置，可以不用同时设置HADOOP_CONF_DIR和YARN_CONF_DIR

-**配置服务监控（MRHistoryServer和SparkHistoryServer）**

`$HADOOP_HOME/etc/hadoop/yarn-site.xml`，内容如下：

-**同步所有YARN集群机器**

```shellscp-ryarn-site.xmlbigdata-cdh02.itcast.cn:$PWDscp-ryarn-site.xmlbigdata-cdh03.itcast.cn:$PWD```

-**SparkApplicaiton默认配置**

`$SPARK_HOME/conf/spark-defaults.conf`文件增加如下内容：

```propertiesspark.yarn.historyServer.addressbigdata-cdh01.itcast.cn:18080```

-**启动HDFS集群、YARN集群和MRHistoryServer服务**

-HDFS服务

```shell#cdh01sbin/hadoop-daemon.shstartnamenode#cdh01,cdh02,cdh03sbin/hadoop-daemon.shstartdatanode```

-YARN服务

```shell#cdh02sbin/yarn-daemon.shstartresourcemanager#cdh01,cdh02,cdh03sbin/yarn-daemon.shstartnodemanager```

-MRHistoryServer服务

```shell#cdh03sbin/mr-jobhistory-daemon.shstarthistoryserver```

-**启动SparkHistoryServer服务**

```shell#cdh01sbin/start-history-server.sh```

```shellSPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0${SPARK_HOME}/bin/spark-submit\--masteryarn\--classorg.apache.spark.examples.SparkPi\${SPARK_HOME}/examples/jars/spark-examples_2.11-2.2.0.jar\10```

**第四、SparkSubmitApplication**

**1、应用提交spark-submit**

```shellUsage:spark-submit[options][apparguments]```

如果使用Java或Scala语言编程程序，需要将应用编译后达成Jar包形式，提交运行。

**2、基本参数配置**

```shell#表示应用运行的模式，要么是本地local要么是集群（Standalone、YARN、Mesos）--masterMASTER_URL#本地模式:local[2]Standalone集群：spark://xxx:7077,yyy:7077YARN集群：yarn

#表示DriveProgram运行的地方，也叫做应用部署模式，默认值为client，通常在生成环境中使用cluster--deploy-modeDEPLOY_MODE

#表示运行SparkApplication的类名称，注意为类的全名称（包含包名）--classCLASS_NAME

#表示的是应用运行的名称，通常在应用开发的时候指定--nameNAMEAnameofyourapplication.

#表示应用的类所依赖的第三方的Jar包指定路径，通常在本地文件系统中，多个Jar包使用逗号隔开--jarsJARS

#当value中值有空格组成的时候，使用双引号将key=value引起来--conf"PROP=VALUE"```

动态加载SparkApplicaiton运行时的参数，通过`--conf`进行指定，如下使用方式：

```bash#第一种方式:属性的值中没有空格--confspark.eventLog.enabled=false

#第二种方式：属性的值中有空格，将属性和值统一使用双引号引起来--conf"spark.executor.extraJavaOptions=-XX:+PrintGCDetails-XX:+PrintGCTimeStamps"```

SparkApplication运行包括两部分组成：DriverProgram和Executors，都是JVM进程，所以可以设置每个JVM进程中的资源，资源包括CPUCores核数和内存Memory大小。

**3、DriverProgram参数配置**

```shell#指定DriverProgramJVM进程内存大小，默认值为1g--driver-memoryMEM

#表示Driver运行CLASSPATH路径，使用不多--driver-class-path

##Sparkstandalonewithclusterdeploymode：运行在Standalone中clusterDeployMode，默认值为1--driver-coresNUM

##运行在YARNinclustermode，默认值是1--driver-coresNUM

##运行在standalone的中clusterDeployMode下，表示当Driver运行异常失败，可以自己重启--supervise```

**4、Executor参数配置**

```shell#Executor运行所需内存大小--executor-memoryMEM

#Execturo运行的CPUCores，默认的情况下，在Standalone集群上为Worker节点所有可有的CpuCores，在YARN集群下为1--executor-coresNUM

#表示运行在Standalone集群下，所有Executor的CPUCores，结合--executor-cores计算出Executor个数--total-executor-coresNUM

#表示在YARN集群下，Executor的个数，默认值为2--num-executors

#表示Executor运行的队列，默认为default队列--queueQUEUE_NAME```

**第五、IDEA开发环境**

创建Maven工程、创建模块module，配置pom.xml文件内容如下：

2.11.82.112.2.02.6.0-cdh5.14.0

org.scala-langscala-library${scala.version}org.apache.sparkspark-core_${scala.binary.version}${spark.version}org.apache.hadoophadoop-client${hadoop.version}

target/classestarget/test-classes${project.basedir}/src/main/resourcesorg.apache.maven.pluginsmaven-compiler-plugin3.01.81.8UTF-8net.alchim31.mavenscala-maven-plugin3.2.0compiletestCompile-dependencyfile${project.build.directory}/.scala_dependencies```

###集成Hive


编译命令如下：./dev/make-distribution.sh--namecustom-spark--tgz-Phadoop-2.6-Dhadoop.version=2.6.0-cdh5.14.0-Phive-Phive-thriftserver-Pyarn

```shell2）、未启动HiveMetaStore服务集成Hive，实质就是：SparkSQL应用运行时，可以读取HiveMetaStore中元数据，配置如下：

第一步：拷贝hive-site.xml配置文件至SPARK_HOME/conf目录下（建议创建软连接）ConfigurationofHiveisdonebyplacingyour`hive-site.xml`,`core-site.xml`(forsecurityconfiguration),and`hdfs-site.xml`(forHDFSconfiguration)filein`conf/`.

第二步：将MySQL驱动包放入SPARK_HOME/jars下$cp-r$HIVE_HOME/lib/mysql-connector-java-5.1.27-bin.jar$SPARK_HOME/jars注意，在hive-site.xml配置属性hive.metastore.warehouse.dir数据仓库HDFS目录Notethatthehive.metastore.warehouse.dirpropertyinhive-site.xmlisdeprecatedsinceSpark2.0.0.Instead,usespark.sql.warehouse.dirtospecifythedefaultlocationofdatabaseinwarehouse.

创建SparkSession启用集成Hive

valspark=SparkSession.builder().appName("SparkHiveExample").config("spark.sql.warehouse.dir",warehouseLocation).enableHiveSupport().getOrCreate()importspark.implicits._importspark.sql

3）、启动HiveMetaStore服务当启动HiveMetaStore服务以后，SparkSQL集成Hive时只要连接到MetaStore服务地址即可读取元数据。

第一步、启动HiveMetaStore服务，脚本metastore-start.sh如下：

附录：配置HiveMetaStore服务，在hive-site.xml添加如下配置：hive.metastore.uristhrift://bigdata-cdh01.itcast.cn:9083hive.metastore.localfalsehive.metastore.warehouse.dir/user/hive/warehouse

4）、启动spark-sql交互式命令行启动spark-sql交互式命令行#以本地模式运行spark-sql交互式命令行$cd/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/$bin/spark-sql--masterlocal[2]--confspark.sql.shuffle.partitions=4--confspark.sql.warehouse.dir=hdfs://hadoop01:8020/user/hive/warehouse```


```shell5）、启动SparkThriftServer服务启动SparkThriftServer服务，客户端Beeline命令行连接，开发测试：

#以本地模式运行SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/#启动SparkThriftServer服务${SPARK_HOME}/sbin/start-thriftserver.sh\--hiveconfhive.server2.thrift.port=10000\--hiveconfhive.server2.thrift.bind.host=hadoop03\--confspark.sql.shuffle.partitions=4\--confspark.sql.warehouse.dir=hdfs://hadoop01:8020/user/hive/warehouse\--masterlocal[4]

Beeline客户端连接：SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/${SPARK_HOME}/bin/beelinebeeline>!connectjdbc:hive2://hadoop03:10000Enterusernameforjdbc:hive2://hadoop03:10000:itcastEnterpasswordforjdbc:hive2://hadoop03:10000:******```


###集成HBase

SparkSQL读取Hive表中的数据，通过Hive与HBase集成来读取HBase表的数据。1）、依赖JAR包，添加到SparkSQL应用的CLASSPATH下面

```hbase-client-1.2.0-cdh5.14.0.jarhbase-common-1.2.0-cdh5.14.0.jarhbase-hadoop2-compat-1.2.0-cdh5.14.0.jarhbase-hadoop-compat-1.2.0-cdh5.14.0.jarhbase-prefix-tree-1.2.0-cdh5.14.0.jarhbase-protocol-1.2.0-cdh5.14.0.jarhbase-server-1.2.0-cdh5.14.0.jarhive-hbase-handler-1.1.0-cdh5.14.0.jarhtrace-core-3.2.0-incubating.jarmetrics-core-2.2.0.jar```

2）、将HBaseClient配置文件放置到$SPARK_HOME/conf目录（创建软连接）

```shellcd/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/confln-s/export/servers/hbase/conf/hbase-site.xmlhbase-site.xml```

3）、启动spark-sql命令行，添加依赖jar包

```shellSPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0${SPARK_HOME}/bin/spark-sql\--masterlocal[2]\--jars${SPARK_HOME}/lib/hbase-client-1.2.0-cdh5.14.0.jar,${SPARK_HOME}/lib/hbase-common-1.2.0-cdh5.14.0.jar,${SPARK_HOME}/lib/hbase-hadoop2-compat-1.2.0-cdh5.14.0.jar,${SPARK_HOME}/lib/hbase-hadoop-compat-1.2.0-cdh5.14.0.jar,${SPARK_HOME}/lib/hbase-prefix-tree-1.2.0-cdh5.14.0.jar,${SPARK_HOME}/lib/hbase-protocol-1.2.0-cdh5.14.0.jar,${SPARK_HOME}/lib/hbase-server-1.2.0-cdh5.14.0.jar,${SPARK_HOME}/lib/hive-hbase-handler-1.1.0-cdh5.14.0.jar,${SPARK_HOME}/lib/htrace-core-3.2.0-incubating.jar,${SPARK_HOME}/lib/metrics-core-2.2.0.jar\--confspark.sql.shuffle.partitions=4\--confspark.sql.warehouse.dir=hdfs://bigdata-cdh01.itcast.cn:8020/user/hive/warehouse```


4）、启动SparkThriftServer服务使用spark.executor.extraClassPath和spark.driver.extraClassPath将依赖的JAR包添加到CLASSPATH路径下。

```shellSPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0${SPARK_HOME}/sbin/start-thriftserver.sh\--hiveconfhive.server2.thrift.port=10000\--hiveconfhive.server2.thrift.bind.host=bigdata-cdh03.itcast.cn\--masterlocal[2]\--confspark.executor.extraClassPath=${SPARK_HOME}/lib/*\--confspark.driver.extraClassPath=${SPARK_HOME}/lib/*\--confspark.sql.shuffle.partitions=4\--confspark.sql.warehouse.dir=hdfs://bigdata-cdh01.itcast.cn:8020/user/hive/warehouse```


##Flink

**环境搭建**

**standAlone**

安装包下载地址：

1.上传：rz/ftp

2.解压

```shelltar-zxvfflink-1.6.0-bin-hadoop26-scala_2.11.tgz-C/export/servers/```


3.配置文件修改

vimflink-conf.yaml

```shelljobmanager.rpc.address:node01jobmanager.rpc.port:6123jobmanager.heap.size:1024taskmanager.heap.size:1024taskmanager.numberOfTaskSlots:1taskmanager.memory.preallocate:falseparallelism.default:1jobmanager.web.port:8081taskmanager.tmp.dirs:/export/servers/flink-1.6.0/tmp

jobmanager.rpc.address:node01#JobManager的外部地址，它是分布式系统的主/协调器（DEFAULT：localhost）设置成你master节点的IP地址jobmanager.rpc.port:6123#JobManager的端口号（DEFAULT：6123）jobmanager.heap.size:1024#JobManager的默认JVM堆大小（以兆字节为单位）taskmanager.heap.size:1024#用于TaskManagers的JVM堆大小（以兆字节为单位）

taskmanager.numberOfTaskSlots:1#每台机器可用的CPU数量（默认值：1）taskmanager.memory.preallocate:false#是否进行预分配内存，默认不进行预分配，这样在我们不使用flink集群时候不会占用集群资源

parallelism.default:1#指定程序的默认并行度jobmanager.web.port:8081#JobManager的Web界面的端口（默认：8081）taskmanager.tmp.dirs：/export/servers/flink-1.6.0/tmp#临时文件的目录```

vimmasters

```node01:8081```

4.分发安装包

```scp-rflink-1.6.0/node02:$PWDscp-rflink-1.6.0/node03:$PWD```

5.启停

```./start-cluster.sh#启动./stop-cluster.sh#停止```


6.页面访问

7.测试

```bin/flinkrunexamples/batch/WordCount.jar```


**standAlone-HA(高可用)**

1.配置文件修改

```shell#HAstate.backend:filesystem#检查点的配置state.backend.fs.checkpointdir:hdfs://node01:8020/flink-checkpointshigh-availability:zookeeper#HA高可用模式的配置high-availability.storageDir:hdfs://node01:8020/flink/ha/#元数据high-availability.zookeeper.quorum:node01:2181,node02:2181,node03:2181```

vimmaster

```node01:8081node02:8081```

分发配置文件

```shellscpflink-conf.yamlnode02:$PWDscpflink-conf.yamlnode03:$PWDscpmastersnode02:$PWDscpmastersnode03:$PWD```

>注意：node02节点上的flink-conf.yaml:>>jobmanager.rpc.address:node02

启动

```shellstart-dfs.sh#hdfszkServer.shstart#zookeeper./start-cluster.sh#flink```

>启动高可用集群：需先启动hdfs,zookeeper

页面访问

**flinkonyarn**

企业生产环境主要采用模式

优点：能够最大化的利用企业中的集群资源

部署架构


**1.配置文件修改**

（1）vimetc/hadoop/yarn-site.xml

```yarn.nodemanager.vmem-check-enabledfalse```

>node01,node02,node03都需要配置>>执行任务的内存，超过分配的内存阀值，也不会关闭任务

（2）vim/etc/profile

```exportHADOOP_CONF_DIR=/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop```

>node01,node02,node03都需要配置>>编辑完成之后，一定要source>>source/etc/profile


**2.提交作业**

**(1)yarn-session**

-先申请yarn资源，一次性申请好yarn资源

-再提交作业

-适用于大量的小作业

-申请的内存资源，不会自动关闭资源，需要手动关闭

提交作业的命令：

先申请资源：

```shell./yarn-session.sh-n2-tm1024-jm1024-s1./yarn-session.sh-n2-tm1024-jm1024-s1-d#分离模式，申请好资源，会自动退出会话窗口```

-n:taskmanager容器的数量

-s:slot,cpu的核数

-d:表示分离模式

-tm:表示申请的taskmanager的内存

-jm:表示申请的jobmanager的内存

再提交作业：

```bin/flinkrun../examples/batch/WordCount.jar```

查看yarn资源ID

```shellyarnapplication-list#查看yarnapplication-killyarn-ID#杀掉yarn资源ID```

查看命令：

```shell./yarn-session.sh-help```


**2)yarn-cluster**

-提交作业的时候，再申请资源，不需要提前申请资源-适用于大作业，适用于一次性的批量作业-任务执行完毕会自动关闭资源

提交作业：

```shellflinkrun-myarn-cluster-yn1-ytm1024-yjm1024-ys1/export/servers/flink-1.6.0/examples/batch/WordCount.jar```