大數據各個工具隨筆

時間 2019-11-09

標籤數據各個工具隨筆简体版

原文原文鏈接

# 基本配置php

```shell
#目錄結構：
bin：二進制的客戶端命令
etc：存放配置文件
etc/conf
lib：存放jar包的目錄
sbin：存放管理類的腳本啓動服務
share：hadoop全部的jar包html

#查看主機名
hostname
#臨時修改主機名
hostname hadoop
#永久修改主機名
vi /etc/sysconfig/network

#查看主機ip
ifconfig -ajava

#靜態IP配置
setup編輯網卡
或
vi /etc/sysconfig/network-scripts/ifcfg-eth0或eth1
service network restart 重啓網絡服務node

#配置映射關係
vi /etc/hosts
#時鐘同步
ntpdate us.pool.ntp.org # 此命令便可和時鐘服務器進行同步
crontab -e # 設置定時任務python

#查看防火牆規則
vim /etc/sysconfig/iptables
#關閉防火牆：
service iptables stop
#永久關閉：
chkconfig iptables off
#重啓防火牆
systemctl restart firewalld
#關閉深層防火牆selinux需重啓liunx
vim /etc/selinux/config # 打開配置文件
SELINUX = enforcing 更改成 SELINUX = disabledmysql

#ssh免密登陸
ssh-keygen -t rsa # 使用非對稱加密生成公鑰和私鑰
ssh-copy-id 主機名 #分發公鑰
測試
ssh 主機名linux

#下載rz並全自動安裝
yum -y install lrzsz

#下載文件
sz 默認下載地址 ios

#建立普通用戶
useradd 普通用戶名
passwd 普通用戶密碼
visudo：會打開一個文件，該文件中能夠配置讓普通用戶越權執行命令
hpsk ALL=(root) NOPASSWD: ALL
su -普通用戶名/root #切換用戶
或用exit

#修改目錄用戶
chown -R root:root export
或
chown -R 用戶名:用戶名目錄名nginx

#受權
chmod 755 ./*.sh
#加執行權限
chomd +x 文件名c++

tar -zxvf 文件名 -C 路徑 #解壓到指定目錄
Unzip 文件名 -d 路徑 #解壓到指定目錄
scp -r 文件名用戶名@主機名:$PWD #發送到同級目錄
scp -r 文件名用戶名@主機名:/export/servers #發送到指定目錄

mv 原名重命名 #重命名
mv 文件名路徑 #移動

#查看日誌
tail -100f logs/kafka.log

#修改環境變量:
vi /etc/profile
#當即生效：
source /etc/profile

#建立軟鏈接
ln -s 【目標目錄】【軟連接地址】
#刪除連接
rm -rf 【軟連接地址】
#修改連接
ln -snf 【新目標目錄】【軟連接地址】

#添加到啓動列表
chkconfig redis on
驗證：chkconfig --list

kill -9 進程號強制終止進程

#解決進程殺不掉
cd /tmp查看hsperfdata_開頭的目錄 rm -rf 刪除下邊文件號

#查看路由表
netstat -rn
#遠程登陸
telnet 主機名

df-h 查看資源佔用狀況

top 查看實時更新進程
ps -lA 查看全部進程
pstree -P 以樹狀形式顯示進程，並顯示進程號
kill -9 -1 殺死全部進程
ps -aux 查看全部進程包括後臺進程只顯示本身的進程號（PID）
ps -ef 查詢系統中全部運行的進程能夠顯示每一個進程的父進程號(PPID)
ps aux|grep tomact 解釋：以管道形式搜索
```

```shell
#netstat命令各個參數說明以下：

-t : 指明顯示TCP端口
-u : 指明顯示UDP端口
　　-l : 僅顯示監聽套接字(所謂套接字就是使應用程序可以讀寫與收發通信協議(protocol)與資料的程序)
　　-p : 顯示進程標識符和程序名稱，每個套接字/端口都屬於一個程序。
　　-n : 不進行DNS輪詢，顯示IP(能夠加速操做)
便可顯示當前服務器上全部端口及進程服務，於grep結合可查看某個具體端口及服務狀況

netstat -ntlp //查看當前全部tcp端口·
netstat – tnl 能夠看處處於監聽狀態的 TCP 端口和鏈接
netstat -ntulp |grep 80 //查看全部80端口使用狀況·
netstat -an | grep 3306 //查看全部3306端口使用狀況·
netstat -atunlp | grep 10000

#查看一臺服務器上面哪些服務及端口
netstat -lanp
#查看一個服務有幾個端口。好比要查看mysqld
ps -ef |grep mysqld
#查看某一端口的鏈接數量,好比3306端口
netstat -pnt |grep :3306 |wc
#查看某一端口的鏈接客戶端IP 好比3306端口
netstat -anp |grep 3306

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 -t ext4 /dev/sdb1 格式化硬盤分區

#3-掛載目錄
建立掛載目錄：
mkdir /export/users
手動臨時掛載：
mount /dev/sdb1 /export/users
驗證是否掛載成功：
df -h
永久掛載，開機自動加載：
echo "/dev/sdb1 /export/users ext4 defaults 0 0" >> /etc/fstab
```

## java

rpm -qa | grep java 查看是否已經安裝了jdk
rpm -e --nodeps 軟件的名稱將軟件進行卸載

修改環境變量:
vi /etc/profile
當即生效：

source /etc/profile

## mysql

1、rpm安裝包安裝

```shell
#1.查看系統自帶的mysql的rpm包
rpm -qa | grep mysql
刪除自帶安裝包
rpm -e mysql-libs-5.1.73-8.el6_8.x86_64 --nodeps
#2.安裝mysql的rpm包
rpm -ivh *.rpm
或
rpm -ivh MySQL-client-5.6.25-1.el6.x86_64.rpm
#3.啓動mysql的服務

啓動腳本: service mysql start
關閉腳本: service mysql stop
重啓：service mysqld restart

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

#5.登陸mysql，root用戶默認沒有密碼
mysql -u root -p+密碼

#6.在mysql中修改本身的密碼
set password = password('密碼');

#7.遠程登陸mysql的權限登陸mysql後輸入以下命令
grant all privileges on *.* to 'root'@'%' identified by '123456' with grant option;
flush privileges;

#8.設置mysql的開機啓動
chkconfig --add mysqld
chkconfig mysqld on

#9.查詢列表：
chkconfig
#10.卸載

rpm -qa | grep -i mysql#查看全部mysql的安裝包

卸載全部mysql的安裝包

rpm -e --nodeps MySQL-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 -i mysql

#查看哪裏還有mysql的文件夾
whereis mysql

刪除全部關於mysql的配置以及文件夾便可

刪掉 rm -rf /usr/lib64/mysql

刪掉 rm -rf /usr/my.cnf

刪掉 rm -rf /root/.mysql_secret

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

2、在線安裝（5.1.73）

```shell
#1.在線安裝mysql相關的軟件包
yum install mysql mysql-server mysql-devel
#2.啓動mysql的服務
/etc/init.d/mysqld start
#3.經過mysql安裝自帶腳本進行設置
/usr/bin/mysql_secure_installation
#4.進入mysql的客戶端而後進行受權
grant all privileges on *.* to 'root'@'%' identified by '123456' with grant option;
flush privileges;
#5.設置開機自啓
chkconfig --add mysqld
chkconfig mysqld on

```

3、在線安裝（5.7）

```shell
1、安裝MySQL：root用戶操做
#一、檢查是否安裝
yum list installed | grep mysql
卸載：
yum -y remove mysql-server
yum -y remove mysql
yum -y remove mysql-libs
#二、安裝依賴
yum install libaio
#三、配置MySQL的yum源
下載yum源的rpm包
wget http://repo.mysql.com/mysql57-community-release-el6.rpm
安裝yum源的rpm包
yum -y localinstall mysql57-community-release-el6.rpm
查看是否安裝成功
yum repolist enabled | grep "mysql.*-community.*"
查看可用的MySQL版本
yum repolist all | grep mysql
#四、安裝MySQL
yum -y install mysql-community-server
查看安裝位置：
whereis mysql
#五、啓動MySQL：
若是安裝過MySQL：
rm -rf /var/lib/mysql/ib*
清空數據目錄：
rm -rf /var/lib/mysql/*
初始化：
mysqld --initialize --user=mysql
查看臨時密碼：
more /var/log/mysqld.log | grep 'temporary password'
啓動MySQL服務
service mysqld start
設置開機自啓動
chkconfig mysqld on
#六、登陸MySQL：
mysql -uroot -p
回車輸入臨時密碼
#七、修改登陸密碼
set password for 'root'@'localhost'=password('123456');
#八、受權容許從其餘機器登陸
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '123456' WITH GRANT OPTION;
FLUSH PRIVILEGES;
#九、設置UTF-8編碼
vim /etc/my.cnf
[mysqld]
character_set_server = utf8
[mysql]
default-character-set = utf8
查看：SHOW VARIABLES LIKE 'character%';
```

## git

1.下載地址：https://git-scm.com/download

## nginx

```shell
./nginx 啓動
./nginx -s stop 中止 ./nginx -s reload 重啓修改完配置文件，必須從新啓動纔會生效
./nginx -t 檢查配置文件的合法性
```
1) 安裝依賴環境: 因爲nginx爲C語言開發, 須要C語言依賴環境

```
yum install -y gcc-c++ pcre pcre-devel zlib zlib-devel openssl openssl-devel
./configure \
```

2.上傳解壓安裝包

```
使用rz上傳便可, 上傳到 /export/software目錄下
tar -zxvf nginx-1.8.0.tar.gz
cd nginx-1.8.0
```

3.設置編譯參數

```
--prefix=/export/servers/nginx \
--pid-path=/export/data/nginx/nginx.pid \
--lock-path=/export/data/nginx.lock \
--error-log-path=/export/logs/nginx/error.log \
--http-log-path=/export/logs/nginx/access.log \
--with-http_gzip_static_module \
--http-client-body-temp-path=/export/data/nginx/client \
--http-proxy-temp-path=/export/data/nginx/proxy \
--http-fastcgi-temp-path=/export/data/nginx/fastcgi \
--http-uwsgi-temp-path=/export/data/nginx/uwsgi \
--http-scgi-temp-path=/export/data/nginx/scgi
解釋:
--prefix=/export/servers/nginx 表明將nginx安裝到哪一個目錄中

--pid-path=/export/data/nginx/nginx.pid nginx的pid文件存放的位置待會須要建立這個目錄nginx

--error-log-path=/export/logs/nginx/error.log nginx錯誤日誌存放的文件目錄

--http-log-path=/export/logs/nginx/access.log nginx的訪問日誌
```

4.編譯安裝

```
先建立數據和日誌存放的文件夾
mkdir -p /export/data/nginx
mkdir -p /export/logs/nginx
進行編譯和安裝
cd /export/software/nginx-1.8.0 # 切換nginx根目錄
make # 編譯
make install # 安裝, 安裝後在 /export/servers/nginx
```

5.# 啓動nginx

```
cd /export/servers/nginx/sbin
./nginx # 啓動nginx

查看nginx啓動進程
ps -ef | grep nginx

注意：執行./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 -s stop
此方式至關於先查出nginx進程id再使用kill命令強制殺掉進程。

完整中止(推薦使用):
cd /usr/local/nginx/sbin
./nginx -s quit
此方式中止步驟是待nginx進程處理任務完畢進行中止。

重啓nginx :
先中止再啓動（建議使用）：
對nginx進行重啓至關於先中止nginx再啓動nginx，即先執行中止命令再執行啓動命令。
以下：
./nginx -s quit
./nginx

從新加載配置文件：
當nginx的配置文件nginx.conf修改後，要想讓配置生效須要重啓nginx，使用-s reload不用先中止nginx再啓動nginx便可將配置信息在nginx中生效，以下：
./nginx -s reload
```

6.使用nginx

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

7.安裝測試

![](jiqun-images/1561523111292.png)**發佈網站到服務器中**

```
訪問路徑: http://ip地址
注意: 上面這個訪問路徑,表示已經訪問到了,html目錄的下, 默認訪問到html的目錄的index頁面
```

![](jiqun-images/1561534105434.png)

```
另外一種方式：咱們能夠將頁面複製到nginx的目錄下，而後訪問

- 使用此種方式, 須要修改nginx的配置文件:nginx.conf
- 修改完配置文件後: 須要從新加載一下配置文件: ./nginx -s reload
```

![](jiqun-images/1543584639422.png)

```
訪問路徑: http://ip地址/頁面名稱
注意: 這個路徑, 默認訪問到了配置文件中 root後面設置的路徑下, 默認訪問的index頁面
```

![](jiqun-images/wps77FB.tmp.jpg)

可是咱們能夠發現這樣，經過IP地址能夠訪問。可是IP其實相對來說是很難記住的，咱們一般會經過域名去訪問一個網站。

```
1. 上傳網站到142服務器上 : /export/servers/nginx
2. 網站的解壓 tar -zxvf dest.tar.gz
3. 修改的nginx的配置(參考他的html網站如何部署)nginx.conf
sz nginx.conf 將這個文件下載到windows桌面
修改nginx.conf 文件 root dest;
4. 從新上傳到conf目錄中
5. 從新啓動進入nginx下sbin目錄下 ./nginx -s reload
http://192.168.72.142/
```

![](jiqun-images/1561532453847.png)

**網站訪問的過程**

![](jiqun-images/1547688376994.png)

**修改hosts文件**

```shell
進入電腦C:\Windows\System32\drivers\etc下查找一個hosts文件

192.168.72.142 www.jx.com # 若是使用的是公開的比較有名的域名, 可能會致使訪問不到, 建議使用ie瀏覽器嘗試, 或者換一個自定義域名

打開瀏覽器訪問：http://www.jx.com
```

**配置nginx的反向代理, 實現網站發佈(重點)**

![](jiqun-images/1539338764382.png)

```
這個過程被稱爲是反向代理, 原來瀏覽器直接請求tomcat, 得到內容, 如今由nginx做爲代理, 請求目標地址, 並將目標地址的數據返回給瀏覽器
```

![](jiqun-images/1561537956102.png)

如何配置呢.

- 1) 修改配置文件: conf/ nginx.conf文件, 添加以下內容
- 提示: 能夠直接打開配置文件, 拉到最下面, 在最後一個沒有被註釋的大括號前書寫

```
pstream tomcat1 {
server 192.168.72.141:8080;
server 192.168.72.142:8080;
server 192.168.72.143:8080;
}

server {
listen 80;
server_name localhost;

location / {
proxy_pass http://tomcat1;
index index.html index.htm;
}
}
```

![](jiqun-images/1561538248369.png)

**負載均衡**

```
負載均衡是由多臺服務器以對稱的方式組成一個服務器集合，每臺服務器都具備等價的地位，均可以單獨對外提供服務而無須其餘服務器的輔助。

經過某種負載分擔技術，將外部發送來的請求均勻分配到對稱結構中的某一臺服務器上，而接收到請求的服務器獨立地迴應客戶的請求。均衡負載可以平均分配客戶請求到服務器列陣，藉此提供快速獲取重要數據，解決**大量併發訪問**服務問題。 (廉價的)
```

**nginx的負載均衡**

```
咱們能夠在nginx上配置多臺服務器, 當大量併發訪問的時候, 咱們經過nginx將這些併發請求根據必定的規則平均分派到多臺服務器, 提升服務器高可用
```

![](jiqun-images/1543589410708.png)

**如何在nginx中配置負載均衡(重點)**

![](jiqun-images/1561537769951.png)

1) 修改配置文件

```shell
upstream tomcat1 {
server 192.168.72.141:8080;
server 192.168.72.142:8080;
server 192.168.72.143:8080;
}
server {
listen 80;
server_name localhost;
location / {
proxy_pass http://tomcat1;
index index.html index.htm;

}
}

********** 上述代碼是原始內容, 只須要更改upsteam中的server便可

#第一種方案: 配置多臺server, nginx就會自動進行負載均衡, 將併發請求平均分配給這兩個服務器
upstream tomcat1 {
server 192.168.72.141:8080;
server 192.168.72.142:8080;
server 192.168.72.143:8080;

}
#第二種方案: 能夠根據服務器的實際狀況調整服務器權重。權重越高分配的請求越多，權重越低，請求越少。默認是都是1
upstream tomcat1 {
server 192.168.72.141:8080 weight=3;
server 192.168.72.142:8080 weight=1;
server 192.168.72.143:8080 weight=6;

}
#例如設置爲2, 表示第二個服務器所能承受比第一臺兩倍的併發請求, 此時, nginx就會權重分配, 若是有6個併發請求, 第二臺會承受4個請求, 而第一臺只會承受2個請求

注意:
1. 三臺服務器中的tomcat必須保證能夠正常訪問
2. nginx的配置文件修改後, 必定要從新加載nginx : ./nginx -s reload
```

關於高可用的搭建能夠參考此地址: http://blog.51cto.com/superpcm/2095395

## redis

添加到啓動列表
chkconfig redis on
驗證：chkconfig --list

service redis start
啓動
service redis stop
中止
service redis restart
重啓
service redis status
查看狀態
1.下載redis安裝包

wget http://download.redis.io/releases/redis-4.0.2.tar.gz

解壓：tar -zxvf redis-4.0.2.tar.gz -C ../servers

2.安裝編譯環境

```
yum -y install gcc gcc-c++ libstdc++-devel tcl -y
```

3.編譯並進行安裝redis

```
cd /export/servers/redis-src/
make MALLOC=libc
make PREFIX=/export/servers/redis install
```

4.在指定的位置建立一個redis的配置文件

mkdir -p /export/servers/redis/conf
cd /export/servers/redis/conf
vi redis_6379.conf

配置文件內容：

```shell
bind 192.168.72.142 綁定的ip
protected-mode yes
port 6379 端口號 tcp-backlog 511
timeout 0 #客戶端閒置多少秒後，斷開鏈接
tcp-keepalive 300
daemonize yes #是否做爲守護進程運行
supervised no
pidfile /export/data/redis/6379/redis_6379.pid pid文件位置
loglevel notice 日誌級別
logfile "/export/data/redis/6379/log.log" 日誌文件的位置(出錯查看日誌)
databases 16 #設置數據庫的數量，默認鏈接的數據庫是0，能夠經過select N來鏈接不一樣的數據庫
always-show-logo yes
save 900 1 表示900s內若是有1條是寫入命令，就觸發產生一次快照
save 300 10 表示300s內若是有10條是寫入命令，就觸發產生一次快照
save 60 10000 表示60s內若是有10000條是寫入命令，就觸發產生一次快照
stop-writes-on-bgsave-error yes 若是持久化出錯，主進程是否中止寫入
rdbcompression yes 是否壓縮
rdbchecksum yes 導入時是否檢查
dbfilename dump.rdb rdb文件名稱
dir /export/data/redis/6379/ 數據保存目錄
slave-serve-stale-data yes
slave-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
slave-priority 100
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
slave-lazy-flush no
appendonly yes 是否開啓aof
appendfilename "appendonly.aof" 文件名稱
appendfsync everysec 同步方式[always everysec no]
no-appendfsync-on-rewrite no aof重寫期間是否同步
auto-aof-rewrite-percentage 100 重寫觸發配置
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes 加載aof時若是有錯如何處理
aof-use-rdb-preamble no
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
aof-rewrite-incremental-fsync yes 文件重寫策略
```

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 -h 192.168.72.142
如下命令爲檢測命令:
輸入: ping 返回 pong 表示成功

客戶端退出:
第一種:強制退出 Ctrl+c
第二種: quit

## sorl

1. solr的下載

途徑1: 官網網址: http://lucene.apache.org/ 與Lucene的官網是一個

途徑2: 下載歷史版本的網址: http://archive.apache.org/dist/lucene/solr/

## zookeeper

```shell
1.上傳解壓安裝包

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

server.1=node01:2887:3887

server.2=node02:2887:3887
server.3=node03:2887:3887

（zookeeper客戶端鏈接端口：2181；2887：服務器間通訊的端口

3887：選舉的端口）
3.將配置好的zookeeper發送到其餘主機

4.分別輸入如下命令，配置myid

node01:執行的命令
mkdir -p /export/data/zk
echo "1" > /export/data/zk/myid //將1字符串寫入myid這個文件中,文件位置和文件名不能夠修改
cat /export/data/zk/myid //此命令用於查看此文件有沒有正確寫入 1

node02:執行的命令
mkdir -p /export/data/zk
echo "2" > /export/data/zk/myid
cat /export/data/zk/myid //此命令用於查看此文件有沒有正確寫入 2

node03:執行的命令
mkdir -p /export/data/zk
echo "3" > /export/data/zk/myid
cat /export/data/zk/myid //此命令用於查看此文件有沒有正確寫入 3
```

sbin/zkServer.sh start 啓動

sbin/zkServer.sh status 查看狀態

sbin/zkServer.sh restart 重啓

sbin/zkServer.sh stop 中止

## ELK

**Elasticsearch 安裝部署**

```shell
1建立用戶
建立一個es專門的用戶（必須），由於es不能用root用戶啓動
#使用root用戶在三臺機器執行如下命令
useradd es
mkdir -p /export/servers/es
mkdir -p /export/data/es
mkdir -p /export/logs/es
chown -R es /export/servers/es
chown -R es /export/data/es
chown -R es /export/logs/es
passwd es

2爲es用戶添加sudo權限
三臺機器使用root用戶執行visudo而後爲es用戶添加權限
visudo
es ALL=(ALL) ALL

關閉咱們的xshll的全部的會話，從新鏈接，必定要記得使用es的用戶來鏈接咱們的linux服務器

第一臺服務器切換到es用戶下，下載安裝包
su es
cd ~
wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.0.0.tar.gz
tar -zxvf elasticsearch-6.0.0.tar.gz -C /export/servers/es/
4 第一臺服務器修改配置文件
cd /export/servers/es/elasticsearch-6.0.0/config
rm elasticsearch.yml
vi elasticsearch.yml
# 集羣名字
cluster.name: myes
# # 集羣中當前的節點
node.name: node01
# # 數據目錄
path.data: /export/data/es
# # 日誌目錄
path.logs: /export/logs/es
# # 當前主機的ip地址
network.host: 192.168.52.100
http.port: 9200
# # 集羣上的節點信息
discovery.zen.ping.unicast.hosts: ["node01","node02","node03"]
# # linux安裝es的一個bug解決的配置
bootstrap.system_call_filter: false
bootstrap.memory_lock: false
# # 是否支持跨域
http.cors.enabled: true
# # *表示支持全部域名
http.cors.allow-origin: "*"

5 安裝包分發到其餘兩臺機器上
node01服務器執行如下命令
cd /export/servers/es
scp -r elasticsearch-6.0.0/ node02:$PWD
scp -r elasticsearch-6.0.0/ node02:$PWD

6 node02與node03服務器修改配置文件
node02服務器修改配置文件
cd /export/servers/es/elasticsearch-6.0.0/config
vim elasticsearch.yml

cluster.name: myes
node.name: node02
path.data: /export/data/es
path.logs: /export/logs/es
network.host: 192.168.52.110
http.port: 9200
discovery.zen.ping.unicast.hosts: ["node01","node02","node03"]
bootstrap.system_call_filter: false
bootstrap.memory_lock: false
# 是否支持跨域
http.cors.enabled: true
# *表示支持全部域名
http.cors.allow-origin: "*"

node03服務器修改配置文件

cd /export/servers/es/elasticsearch-6.0.0/config
vim elasticsearch.yml
cluster.name: myes
node.name: node03
path.data: /export/data/es
path.logs: /export/logs/es
network.host: 192.168.52.120
http.port: 9200
discovery.zen.ping.unicast.hosts: ["node01","node02","node03"]
bootstrap.system_call_filter: false
bootstrap.memory_lock: false
# 是否支持跨域
http.cors.enabled: true
# *表示支持全部域名
http.cors.allow-origin: "*"

更多配置文件：https://blog.csdn.net/an74520/article/details/8219814

七、三臺機器修改jvm內存大小
三臺機器執行如下命令修改jvm內存大小
cd /export/servers/es/elasticsearch-6.0.0/config
vi jvm.options
-Xms2g
-Xmx2g
八、三臺機器修改系統配置，增長打開文件的最大數量
問題一：max file descriptors [4096] for elasticsearch process likely too low, increase to at least [65536]
ES由於須要大量的建立索引文件，須要大量的打開系統的文件，因此咱們須要解除linux系統當中打開文件最大數目的限制，否則ES啓動就會拋錯
三臺機器執行如下命令解除打開文件數據的限制
sudo vi /etc/security/limits.conf
添加以下內容: 注意*不要去掉了
* soft nofile 65536
* hard nofile 131072
* soft nproc 2048
* hard nproc 4096

問題二：max number of threads [1024] for user [es] likely too low, increase to at least [4096]
修改普通用戶能夠建立的最大線程數
max number of threads [1024] for user [es] likely too low, increase to at least [4096]
緣由：沒法建立本地線程問題,用戶最大可建立線程數過小
解決方案：修改90-nproc.conf 配置文件。
三臺機器執行如下命令修改配置文件
sudo vi /etc/security/limits.d/90-nproc.conf
找到以下內容：
* soft nproc 1024
#修改成
* soft nproc 4096

問題三：max virtual memory areas vm.max_map_count [65530] likely too low, increase to at least [262144]
調大系統的虛擬內存
max virtual memory areas vm.max_map_count [65530] likely too low, increase to at least [262144]
緣由：最大虛擬內存過小
每次啓動機器都手動執行下。
三臺機器執行如下命令，注意每次啓動ES以前都要執行
sudo sysctl -w vm.max_map_count=262144

備註：以上三個問題解決完成以後，從新鏈接secureCRT或者從新鏈接xshell生效
須要保存、退出、從新登陸xshell纔可生效。
```

2 啓動es服務

```
1 啓動
注意啦，同窗們！這裏是後臺啓動，要發現錯誤的話，去/export/logs/es目錄下查看。
nohup /export/servers/es/elasticsearch-6.0.0/bin/elasticsearch >/dev/null 2>&1 &

2 訪問es
在Google Chrome瀏覽器中，訪問如下地址
http://node01:9200/?pretty
pretty：格式化的，漂亮的。
獲得如下內容
{
"name": "node01",
"cluster_name": "myes",
"cluster_uuid": "cWDpO5DnR-CW7YUH4Ojt5A",
"version": {
"number": "6.0.0",
"build_hash": "8f0685b",
"build_date": "2017-11-10T18:41:22.859Z",
"build_snapshot": false,
"lucene_version": "7.0.1",
"minimum_wire_compatibility_version": "5.6.0",
"minimum_index_compatibility_version": "5.0.0"
},
"tagline": "You Know, for Search"
}

```

**3 node01服務器安裝elasticsearch-head插件**

1 、node01機器安裝nodejs

```shell
Node.js是一個基於 Chrome V8 引擎的 JavaScript 運行環境。
Node.js是一個Javascript運行環境(runtime environment)，發佈於2009年5月，由Ryan Dahl開發，實質是對Chrome V8引擎進行了封裝。Node.js 不是一個 JavaScript 框架，不一樣於CakePHP、Django、Rails。Node.js 更不是瀏覽器端的庫，不能與 jQuery、ExtJS 相提並論。Node.js 是一個讓 JavaScript 運行在服務端的開發平臺，它讓 JavaScript 成爲與PHP、Python、Perl、Ruby 等服務端語言分庭抗禮的腳本語言。
安裝步驟參考：https://www.cnblogs.com/kevingrace/p/8990169.html

第一步：下載安裝包
# 下載安裝包
node01機器執行如下命令下載安裝包
cd /home/es
wget https://npm.taobao.org/mirrors/node/v8.1.0/node-v8.1.0-linux-x64.tar.gz

第二步：解壓安裝包
執行如下命令進行解壓
cd /home/es
tar -zxvf node-v8.1.0-linux-x64.tar.gz -C /export/servers/es/
第三步：建立軟鏈接
# 修改目錄
執行如下命令建立軟鏈接
sudo ln -s /export/servers/es/node-v8.1.0-linux-x64/lib/node_modules/npm/bin/npm-cli.js /usr/local/bin/npm
sudo ln -s /export/servers/es/node-v8.1.0-linux-x64/bin/node /usr/local/bin/node
第四步：修改環境變量
#修改環境變量
sudo vim /etc/profile

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

source /etc/profile
第五步：驗證安裝成功
node -v
npm –v
```

![](jiqun-images/15561465215.png)

2 、node01機器安裝elasticsearch-head插件

```shell
elasticsearch-head這個插件是es提供的一個用於圖形化界面查看的一個插件工具，能夠安裝上這個插件以後，經過這個插件來實現咱們經過瀏覽器查看es當中的數據
安裝elasticsearch-head這個插件這裏提供兩種方式進行安裝，第一種方式就是本身下載源碼包進行編譯，耗時比較長，網絡較差的狀況下，基本上不可能安裝成功
第二種方式就是直接使用我已經編譯好的安裝包，進行修改配置便可
一、第一種方式：在線安裝elasticsearch-head插件（網速慢，不推薦）
這裏選擇node01進行安裝
第一步：在線安裝必須依賴包
# 初始化目錄
cd /export/servers/es
# 安裝GCC
sudo yum install -y gcc-c++ make git
第二步：從git上面克隆編譯包並進行安裝
cd /export/servers/es
git clone https://github.com/mobz/elasticsearch-head.git
# 進入安裝目錄
cd /export/servers/es/elasticsearch-head
# intall 纔會有 node-modules
npm install
```

![](jiqun-images/%E5%9B%BE%E7%89%871.png)

```shell
如下進度信息
npm WARN notice [SECURITY] lodash has the following vulnerability: 1 low. Go here for more details:
npm WARN notice [SECURITY] debug has the following vulnerability: 1 low. Go here for more details: https://nodesecurity.io/advisories?search=debug&version=0.7.4 - Run `npm i npm@latest -g` to upgrade your npm version, and then `npm audit` to get more info.
npm ERR! Unexpected end of input at 1:2096
npm ERR! 7c1a1bc21c976bb49f3ea","tarball":"https://registry.npmjs.org/safer-bu
npm ERR! ^
npm ERR! A complete log of this run can be found in:
npm ERR! /home/es/.npm/_logs/2018-11-27T14_35_39_453Z-debug.log
以上錯誤能夠不用管。

第三步、node01機器修改Gruntfile.js
第一臺機器修改Gruntfile.js這個文件
cd /export/servers/es/elasticsearch-head
vim Gruntfile.js
找到如下代碼：
添加一行： hostname: '192.168.52.100',
connect: {
server: {
options: {
hostname: '192.168.52.100',
port: 9100,
base: '.',
keepalive: travelue
}
}
}

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

第一臺機器修改app.js
cd /export/servers/es/elasticsearch-head/_site
vim app.js
```

![](jiqun-images/%E5%9B%BE%E7%89%872.png)

更改前：http://localhost:9200
更改後：http://node01:9200

**二、第二種方式：直接使用提供的編譯以後的源碼包解壓以後修改配置文件便可（強烈推薦）**

```shell
第一步：上傳壓縮包到/home/es路徑下去
將咱們的壓縮包 compile-head.tar 上傳到第一臺機器的/home/es路徑下面去
第二步：解壓安裝包
cd /home/es/
tar -xvf compile-head.tar -C /export/servers/es/
第三步、node01機器修改Gruntfile.js
修改Gruntfile.js這個文件
cd /export/servers/es/elasticsearch-head
vim Gruntfile.js
找到如下代碼：
添加一行： hostname: '192.168.52.100',
connect: {
server: {
options: {
hostname: '192.168.52.100',
port: 9100,
base: '.',
keepalive: true
}
}
}

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

第一臺機器修改app.js
cd /export/servers/es/elasticsearch-head/_site
vim app.js
```

![](jiqun-images/%E5%9B%BE%E7%89%873.png)

更改前：http://localhost:9200
更改後：http://node01:9200

```shell
三、重啓es服務
注意：使用es用戶啓動
直接使用kill -9 殺死三臺機器的es服務，而後從新啓動
nohup /export/servers/es/elasticsearch-6.0.0/bin/elasticsearch >/dev/null 2>&1 &

四、node01機器啓動head服務
node01啓動elasticsearch-head插件

cd /export/servers/es/elasticsearch-head/node_modules/grunt/bin/
進程前臺啓動命令
./grunt server
進程後臺啓動命令
nohup ./grunt server >/dev/null 2>&1 &

Running "connect:server" (connect) task
Waiting forever...
Started connect web server on http://192.168.52.100:9100
殺死elasticsearch-head進程
netstat -nltp | grep 9100
kill -9 8328
```

![](jiqun-images/%E5%9B%BE%E7%89%874.png)

五、訪問elasticsearch-head界面
打開Google Chrome訪問
http://192.168.52.100:9100/

**四、node01服務器安裝Kibana**

```shell
kibana的基本介紹
Kibana是一個開源的分析和可視化平臺，設計用於和Elasticsearch一塊兒工做。
你用Kibana來搜索，查看，並和存儲在Elasticsearch索引中的數據進行交互。
你能夠輕鬆地執行高級數據分析，而且以各類圖標、表格和地圖的形式可視化數據。
Kibana使得理解大量數據變得很容易。它簡單的、基於瀏覽器的界面使你可以快速建立和共享動態儀表板，實時顯示Elasticsearch查詢的變化。
接着使用咱們的es用戶來實現咱們的kibana的安裝部署
一、下載資源
cd /home/es
在線下載
wget https://artifacts.elastic.co/downloads/kibana/kibana-6.0.0-linux-x86_64.tar.gz
二、解壓文件
cd /home/es
tar -zxvf kibana-6.0.0-linux-x86_64.tar.gz -C /export/servers/es/
三、修改配置文件
cd /export/servers/es/kibana-6.0.0-linux-x86_64/config
vi kibana.yml
配置內容以下：
server.host: "node01"
elasticsearch.url: "http://node01:9200"
四、啓動服務
cd /export/servers/es/kibana-6.0.0-linux-x86_64
nohup bin/kibana >/dev/null 2>&1 &

中止kibana服務進程
查看進程號
ps -ef | grep node
而後使用kill -9殺死進程便可

五、訪問
瀏覽器地址訪問kibana服務
http://192.168.52.100:5601

```

**IK分詞器的安裝**

**安裝**

```shell
每臺機器都要配置。配置完成以後，須要重啓ES服務
將安裝包上傳到node01機器的/home/es路徑下
cd /home/es
wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v5.5.2/elasticsearch-analysis-ik-6.0.0.zip
# 將ik分詞器的插件，上傳到/home/es目錄下
cd /home/es
unzip elasticsearch-analysis-ik-6.0.0.zip -d /export/servers/es/elasticsearch-6.0.0/plugins/
cd /export/servers/es/elasticsearch-6.0.0/plugins
mv elasticsearch analysis-ik

將安裝包分發到其餘機器上
node01機器執行如下命令進行安裝包的分發
cd /export/servers/es/elasticsearch-6.0.0/plugins
scp -r analysis-ik/ node02:$PWD
scp -r analysis-ik/ node03:$PWD
# 三臺機器都配置完成
# 配置完成以後，須要重啓服務。

三臺機器重啓es服務
三臺機器執行如下命令中止es服務

ps -ef|grep elasticsearch|grep bootstravelap |awk '{print $2}' |xargs kill -9

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

**配置**

```shell
delete iktest
PUT /iktest?pretty
{
"settings" : {
"analysis" : {
"analyzer" : {
"ik" : {
"tokenizer" : "ik_max_word"
}
}
}
},
"mappings" : {
"article" : {
"dynamic" : true,
"properties" : {
"subject" : {
"type" : "text",
"analyzer" : "ik_max_word"
}
}
}
}
}

說明：ik帶有兩個分詞器:
ikmaxword ：會將文本作最細粒度的拆分；儘量多的拆分出詞語
句子：我愛個人祖國
結果：我|愛|個人|祖|國|祖國
ik_smart：會作最粗粒度的拆分；已被分出的詞語將不會再次被其它詞語佔有
句子：我愛個人祖國
結果：我|愛|我|的|祖國

7.3 查看分詞效果
GET _analyze?pretty
{
"analyzer": "ik_max_word",
"text": "希拉里是個妹子"
}
7.4 插入測試數據
POST /iktest/article/_bulk?pretty
{ "index" : { "_id" : "1" } }
{"subject" : "＂閨蜜＂崔順實被韓檢方傳喚韓總統府促徹查真相" }
{ "index" : { "_id" : "2" } }
{"subject" : "韓舉行＂護國訓練＂青瓦臺:決不準國家安全出問題" }
{ "index" : { "_id" : "3" } }
{"subject" : "媒體稱FBI已經取得搜查令檢視希拉里電郵" }
{ "index" : { "_id" : "4" } }
{"subject" : "村上春樹獲安徒生獎演講中談及歐洲排外問題" }
{ "index" : { "_id" : "5" } }
{"subject" : "希拉里團隊炮轟FBI 參院民主黨領袖批其」違法」" }
查看分詞器
對"希拉里和韓國"進行分詞查詢
ikmaxword分詞後的效果：希|拉|裏|希拉里|和|韓國
POST /iktest/article/_search?pretty
{
"query" : { "match" : { "subject" : "希拉里和韓國" }},
"highlight" : {
"pre_tags" : ["<font color=red>"],
"post_tags" : ["</font>"],
"fields" : {
"subject" : {}
}
}
}
7.5 熱詞更新

查看分詞效果
GET _analyze?pretty
{
"analyzer": "ik_max_word",
"text": "傳智播客在哪裏"
}
```

node03配置Tomcat

![](jiqun-images/%E5%9B%BE%E7%89%876.png)

```shell
使用es用戶來進行配置tomcat，此處咱們將tomcat裝在node03機器上面便可
cd /home/es
tar -zxvf apache-tomcat-8.5.34.tar.gz -C /export/servers/es/
tomcat當中添加配置hot.dic
cd /export/servers/es/apache-tomcat-8.5.34/webapps/ROOT/
vi hot.dic
傳智播客
# 啓動tomcat
/export/servers/es/apache-tomcat-8.5.34/bin/startup.sh
瀏覽器訪問
wget http://node03:8080/hot.dic
7.5.2 三臺機器修改配置文件
三臺機器都要修改es的配置文件（使用es用戶來進行修改便可）
第一臺機器node01修改es的配置
cd /export/servers/es/elasticsearch-6.0.0/plugins/analysis-ik/config
vim IKAnalyzer.cfg.xml

<?xml version="1.0" encoding="UTF-8".>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>IK Analyzer 擴展配置</comment>

<entry key="ext_dict"></entry>

<entry key="ext_stopwords"></entry>

<entry key="remote_ext_dict">http://node03:8080/hot.dic</entry>


</properties>

修改完成以後拷貝到node02與node03機器上面去
node01執行如下命令進行拷貝
cd /export/servers/es/elasticsearch-6.0.0/plugins/analysis-ik/config
sudo scp IKAnalyzer.cfg.xml node02:$PWD
sudo scp IKAnalyzer.cfg.xml node03:$PWD
7.5.3 三臺機器修改JDK權限
三臺機器修改jdk的權限問題
第一臺機器執行如下命令修改jdk的權限問題
#修改JDK安全設置
cd /export/servers/jdk1.8.0_141/jre/lib/security
sudo vim java.policy
添加如下四行配置
permission java.net.SocketPermission "192.168.52.102:8080","accept";
permission java.net.SocketPermission "192.168.52.102:8080","listen";
permission java.net.SocketPermission "192.168.52.102:8080","resolve";
permission java.net.SocketPermission "192.168.52.102:8080","connect";

修改完成以後拷貝到第二臺和第三臺機器
node01執行如下命令拷貝到第二臺和第三臺
cd /export/servers/jdk1.8.0_141/jre/lib/security
sudo scp java.policy node02:$PWD
sudo scp java.policy node03:$PWD

http://mahilion.blog.163.com/blog/static/1830872952012101225243655/
7.5.4 三臺機器從新啓動es
三臺機器從新啓動es服務，三臺機器先使用kill -9殺死es的服務，而後再執行如下命令進行重啓
cd /export/servers/es/elasticsearch-6.0.0/
nohup bin/elasticsearch >/dev/null 2>&1 &
```

![](jiqun-images/%E5%9B%BE%E7%89%877.png)

```shell
查看咱們的分詞過程
GET _analyze?pretty
{
"analyzer": "ik_max_word",
"text": "傳智播客在哪裏"
}

```

**LogStash**

一、LogStash介紹及安裝

```shell
官網：
https://www.elastic.co/guide/en/logstash/current/index.html
1.1 介紹
logstash就是一個具有實時數據傳輸能力的管道，負責將數據信息從管道的輸入端傳輸到管道的輸出端；與此同時這根管道還可讓你根據本身的需求在中間加上濾網，Logstash提供裏不少功能強大的濾網以知足你的各類應用場景。是一個input | filter | output 的數據流。
1.2 node01機器安裝LogStash
下載logstache並上傳到第一臺服務器的/home/es路徑下，而後進行解壓
# 下載安裝包---能夠直接將已經下載好的安裝包上傳到/home/es路徑下便可
cd /home/es
wget https://artifacts.elastic.co/downloads/logstash/logstash-6.0.0.tar.gz
# 解壓
tar -zxvf logstash-6.0.0.tar.gz -C /export/servers/es/
```

## Azkaban

在一個完整的離線大數據處理系統中，除了hdfs+mapreduce+hive組成分析系統的核心以外，還須要數據採集、結果數據導出、任務調度等不可或缺的輔助系統，而這些輔助工具在hadoop生態體系中都有便捷的開源框架，如圖所示：

![](jiqun-images/101.png)

**概述**

azkaban官網：

https://azkaban.github.io/

**爲何須要工做流調度系統**

l 一個完整的數據分析系統一般都是由大量任務單元組成：

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

l 各任務單元之間存在時間前後及先後依賴關係

l 爲了很好地組織起這樣的複雜執行計劃，須要一個工做流調度系統來調度執行；

例如，咱們可能有這樣一個需求，某個業務系統天天產生20G原始數據，咱們天天都要對其進行處理，處理步驟以下所示：

一、經過Hadoop先將原始數據同步到HDFS上；

二、藉助MapReduce計算框架對原始數據進行轉換，生成的數據以分區表的形式存儲到多張Hive表中；

三、須要對Hive中多個表的數據進行JOIN處理，獲得一個明細數據Hive大表；

四、將明細數據進行各類統計分析，獲得結果報表信息；

五、須要將統計分析獲得的結果數據同步到業務系統中，供業務調用使用。

**工做流調度實現方式**

簡單的任務調度：直接使用linux的crontab來定義；

複雜的任務調度：開發調度平臺或使用現成的開源調度系統，好比ooize、azkaban、airflow等

**常見工做流調度系統**

市面上目前有許多工做流調度器

在hadoop領域，常見的工做流調度器有Oozie, Azkaban,Cascading,Hamake等

**各類調度工具特性對比**

下面的表格對上述四種hadoop工做流調度器的關鍵特性進行了比較，儘管這些工做流調度器可以解決的需求場景基本一致，但在設計理念，目標用戶，應用場景等方面仍是存在顯著的區別，在作技術選型的時候，能夠提供參考

| 特性 | Hamake | Oozie | Azkaban | Cascading |
| ------------------ | -------------------- | ----------------- | ------------------------------ | --------- |
| 工做流描述語言 | XML | XML (xPDL based) | text file with key/value pairs | Java API |
| 依賴機制 | data-driven | explicit | explicit | explicit |
| 是否要web容器 | No | Yes | Yes | No |
| 進度跟蹤 | console/log messages | web page | web page | Java API |
| Hadoop job調度支持 | no | yes | yes | yes |
| 運行模式 | command line utility | daemon | daemon | API |
| Pig支持 | yes | yes | yes | yes |
| 事件通知 | no | no | no | yes |
| 須要安裝 | no | yes | yes | no |
| 支持的hadoop版本 | 0.18+ | 0.20+ | currently unknown | 0.18+ |
| 重試支持 | no | workflownode evel | yes | yes |
| 運行任意命令 | yes | yes | yes | yes |
| Amazon EMR支持 | yes | no | currently unknown | yes |

**Azkaban與Oozie對比**

對市面上最流行的兩種調度器，給出如下詳細對比，以供技術選型參考。整體來講，ooize相比azkaban是一個重量級的任務調度系統，功能全面，但配置使用也更復雜。若是能夠不在乎某些功能的缺失，輕量級調度器azkaban是很不錯的候選對象。

詳情以下：

u 功能

二者都可以調度mapreduce,pig,java,腳本工做流任務

二者都可以定時執行工做流任務

u 工做流定義

Azkaban使用Properties文件定義工做流

Oozie使用XML文件定義工做流

u 工做流傳參

Azkaban支持直接傳參，例如${input}

Oozie支持參數和EL表達式，例如${fs:dirSize(myInputDir)}

u 定時執行

Azkaban的定時執行任務是基於時間的

Oozie的定時執行任務基於時間和輸入數據

u 資源管理

Azkaban有較嚴格的權限控制，如用戶對工做流進行讀/寫/執行等操做

Oozie暫無嚴格的權限控制

u 工做流執行

Azkaban有兩種運行模式，分別是solo server mode(executor server和web server部署在同一臺節點)和multi server mode(executor server和web server能夠部署在不一樣節點)

Oozie做爲工做流服務器運行，支持多用戶和多工做流

u 工做流管理

Azkaban支持瀏覽器以及ajax方式操做工做流

Oozie支持命令行、HTTP REST、Java API、瀏覽器操做工做流

**Azkaban介紹**

Azkaban是由Linkedin開源的一個批量工做流任務調度器。用於在一個工做流內以一個特定的順序運行一組工做和流程。

Azkaban定義了一種KV文件(properties)格式來創建任務之間的依賴關係，並提供一個易於使用的web用戶界面維護和跟蹤你的工做流。

它有以下功能特色：

Web用戶界面

方便上傳工做流

方便設置任務之間的關係

調度工做流

認證/受權(權限的工做)

可以殺死並從新啓動工做流

模塊化和可插拔的插件機制

項目工做區

工做流和任務的日誌記錄和審計

### Azkaban安裝部署

**2.3.一、azkaban的編譯**

咱們這裏選用azkaban3.51.0這個版本本身進行從新編譯，編譯完成以後獲得咱們須要的安裝包進行安裝

注意：咱們這裏編譯須要使用jdk1.8的版原本進行編譯，若是編譯服務器使用的jdk版本是1.7的，記得切換成jdk1.8，咱們這裏使用的是jdk8u141這個版原本進行編譯

cd /export/softwares/

wget https://github.com/azkaban/azkaban/archive/3.51.0.tar.gz

```shell
tar -zxvf 3.51.0.tar.gz -C ../servers/
cd /export/servers/azkaban-3.51.0/
yum -y install git
yum -y install gcc-c++
./gradlew build installDist -x test
```

**編譯以後須要的安裝文件列表以下**

**azkaban-exec-server**

編譯完成以後獲得咱們須要的安裝包在如下目錄下便可獲取獲得

azkaban-exec-server存放目錄

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

![](jiqun-images/102.png)

**azkaban-web-server**

azkaban-web-server存放目錄

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

![](jiqun-images/103.png)

**azkaban-solo-server**

azkaban-solo-server存放目錄

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

![](jiqun-images/104.png)

**execute-as-user.c**

azkaban two server模式下須要的C程序在這個路徑下面

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

![](jiqun-images/105.png)

**數據庫腳本文件**

數據庫腳本文件在這個路徑下面

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

![](jiqun-images/106.png)

### azkaban單服務模式安裝與使用

**所需軟件**

azkaban-solo-server

**單服務模式安裝**

**第一步：解壓**

azkaban 的solo server使用的是一個單節點的模式來進行啓動服務的，只須要一個

azkaban-solo-server-0.1.0-SNAPSHOT.tar.gz的安裝包便可啓動，全部的數據信息都是保存在H2這個azkaban默認的數據當中，

上傳咱們的壓縮包，而後修改配置文件啓動便可

cd /export/softwares

tar -zxvf azkaban-solo-server-0.1.0-SNAPSHOT.tar.gz -C ../servers

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

修改時區配置文件

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

vim azkaban.properties

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

修改commonprivate.properties配置文件

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

vim commonprivate.properties

execute.as.user=false

memCheck.enabled=false

![](jiqun-images/107.png)

**第三步：啓動solo-server**

啓動azkaban-solo-server

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

bin/start-solo.sh

**第四步：瀏覽器頁面訪問**

瀏覽器頁面訪問

http://node03:8081/

![](jiqun-images/108.png)

**單服務模式使用**

需求：使用azkaban調度咱們的shell腳本，執行linux的shell命令

![](jiqun-images/109.png)

![](jiqun-images/110.png)

![](jiqun-images/111.png)

建立普通文本文件 foo.job，文件內容以下

type=command

command=echo "hello world"

而後將這個文件打包爲壓縮文件，以下：

![](jiqun-images/112.png)

azkaban上傳咱們的壓縮包

![](jiqun-images/113.png)

![](jiqun-images/114.png)

![](jiqun-images/115.png)

### azkaban兩個服務模式安裝

**一、確認所需軟件：**

**Azkaban Web服務安裝包**

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

![](jiqun-images/116.png)

**C程序文件腳本**

execute-as-user.c程序

**二、數據庫準備**

進入mysql的客戶端執行如下命令

mysql -uroot -p

執行如下命令：

```sql
CREATE DATABASE azkaban;
CREATE USER 'azkaban'@'%' IDENTIFIED BY 'azkaban';
GRANT all privileges ON azkaban.* to 'azkaban'@'%' identified by 'azkaban' WITH GRANT OPTION;
flush privileges;
use azkaban;
source /export/softwares/create-all-sql-0.1.0-SNAPSHOT.sql;
```

![](jiqun-images/117.png)

**三、解壓軟件安裝包**

解壓azkaban-web-server

cd /export/softwares

tar -zxvf azkaban-web-server-0.1.0-SNAPSHOT.tar.gz -C ../servers/

cd /export/servers

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

解壓azkaban-exec-server

cd /export/softwares

tar -zxvf azkaban-exec-server-0.1.0-SNAPSHOT.tar.gz -C ../servers/

cd /export/servers

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

**四、安裝SSL安全認證**

安裝ssl安全認證，容許咱們使用https的方式訪問咱們的azkaban的web服務

密碼必定要一個個的字母輸入，或者粘貼也行

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

keytool -keystore keystore -alias jetty -genkey -keyalg RSA

**五、azkaban webserver安裝**

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

```shell
cd /export/servers/azkaban-web-server-3.51.0/conf

vim azkaban.properties

# Azkaban Personalization Settings

azkaban.name=Azkaban
azkaban.label=My Azkaban
azkaban.color=#FF3601
azkaban.default.servlet.path=/index
web.resource.dir=web/
default.timezone.id=Asia/Shanghai

# Azkaban UserManager class

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

# Loader for projects

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

# Velocity dev mode

velocity.dev.mode=false

# Azkaban Jetty server properties.

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

# Azkaban Executor settings
# mail settings
mail.sender=
mail.host=

# User facing web server configurations used to construct the user facing server URLs. They are useful when there is a reverse proxy between Azkaban web servers and users.

# enduser -> myazkabanhost:443 -> proxy -> localhost:8081
# when this parameters set then these parameters are used to generate email links.
# if these parameters are not set then jetty.hostname, and jetty.port(if ssl configured jetty.ssl.port) are used.
# 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=false
cache.directory=cache

# JMX stats

jetty.connector.stats=true
executor.connector.stats=true

# Azkaban mysql settings by default. Users should configure their own username and password.

database.type=mysql
mysql.port=3306
mysql.host=node03
mysql.database=azkaban
mysql.user=azkaban
mysql.password=azkaban
mysql.numconnections=100

#Multiple Executor

azkaban.use.multiple.executors=true

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

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

**六、azkaban executor server 安裝**

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

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

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

vim azkaban.properties

```shell
# Azkaban Personalization Settings

azkaban.name=Azkaban
azkaban.label=My Azkaban
azkaban.color=#FF3601
azkaban.default.servlet.path=/index
web.resource.dir=web/
default.timezone.id=Asia/Shanghai

# Azkaban UserManager class

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

# Loader for projects

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

# Velocity dev mode

velocity.dev.mode=false

# Azkaban Jetty server properties.

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

# Where the Azkaban web server is located

azkaban.webserver.url=https://node03:8443

# mail settings

mail.sender=
mail.host=

# User facing web server configurations used to construct the user facing server URLs. They are useful when there is a reverse proxy between Azkaban web servers and users.
# enduser -> myazkabanhost:443 -> proxy -> localhost:8081
# when this parameters set then these parameters are used to generate email links.
# if these parameters are not set then jetty.hostname, and jetty.port(if ssl configured jetty.ssl.port) are used.
# 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=false
cache.directory=cache

# JMX stats

jetty.connector.stats=true
executor.connector.stats=true

# Azkaban plugin settings

azkaban.jobtype.plugin.dir=plugins/jobtypes

# Azkaban mysql settings by default. Users should configure their own username and password.

database.type=mysql
mysql.port=3306
mysql.host=node03
mysql.database=azkaban
mysql.user=azkaban
mysql.password=azkaban
mysql.numconnections=100

# Azkaban Executor settings

executor.maxThreads=50
executor.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 -y install gcc-c++
cd /export/servers/azkaban-exec-server-3.51.0/plugins/jobtypes
gcc execute-as-user.c -o execute-as-user
chown root execute-as-user
chmod 6050 execute-as-user

第三步：修改配置文件

修改配置文件

cd /export/servers/azkaban-exec-server-3.47.0/plugins/jobtypes
vim commonprivate.properties
execute.as.user=false
memCheck.enabled=false
azkaban.native.lib=/export/servers/azkaban-exec-server-3.51.0/plugins/jobtypes
```

最終生成以下

![](jiqun-images/118.png)

**七、啓動服務**

**第一步：啓動azkaban exec server**

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

bin/start-exec.sh

**第二步：激活咱們的exec-server**

node03機器任意目錄下執行如下命令

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

**第三步：啓動azkaban-web-server**

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

bin/start-web.sh

訪問地址：

https://node03:8443

**修改linux的時區問題**

因爲先前作好了時鐘同步，因此不用擔憂時區問題，不須要修改時區了

注：先配置好服務器節點上的時區

一、先生成時區配置文件Asia/Shanghai，用交互式命令 tzselect 便可

二、拷貝該時區文件，覆蓋系統本地時區配置

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

### Azkaban實戰

Azkaba內置的任務類型支持command、java

**Command類型單一job示例**

**建立job描述文件**

建立文本文件，更更名稱爲mycommand.job

注意後綴.txt必定不要帶上，保存爲格式爲UFT-8 without bom

內容以下

**將job資源文件打包成zip文件**

![](jiqun-images/119.png)

**建立project並上傳壓縮包**

經過azkaban的web管理平臺建立project並上傳job壓縮包

首先建立project

![](jiqun-images/120.png)

上傳zip包

![](jiqun-images/121.png)

![](jiqun-images/122.png)

**Command類型多job工做流flow**

一、建立有依賴關係的多個job描述

第一個job：foo.job

第二個job：bar.job依賴foo.job

二、將全部job資源文件打到一個zip包中

![](jiqun-images/123.png)

三、在azkaban的web管理界面建立工程並上傳zip包

四、啓動工做流flow

**HDFS操做任務**

一、建立job描述文件fs.job

type=command

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

二、將job資源文件打包成zip文件

![](jiqun-images/124.png)

三、經過azkaban的web管理平臺建立project並上傳job壓縮包

四、啓動執行該job

**MAPREDUCE任務**

Mr任務依然能夠使用command的job類型來執行

一、建立job描述文件，及mr程序jar包（示例中直接使用hadoop自帶的example jar）

type=command

command=/export/servers/hadoop-2.6.0-cdh5.14.0/bin/hadoop jar hadoop-mapreduce-examples-2.6.0-cdh5.14.0.jar pi 3 5

二、將全部job資源文件打到一個zip包中

![](jiqun-images/125.png)

三、在azkaban的web管理界面建立工程並上傳zip包

四、啓動job

**HIVE腳本任務**

l 建立job描述文件和hive腳本

Hive腳本： hive.sql

create database if not exists azhive;

use azhive;

create table if not exists aztest(id string,name string) row format delimited fields terminated by '\t';

Job描述文件：hive.job

type=command

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

將全部job資源文件打到一個zip包中

![](jiqun-images/126.png)

在azkaban的web管理界面建立工程並上傳zip包

啓動job

**azkaban的定時任務**

使用azkaban的scheduler功能能夠實現對咱們的做業任務進行定時調度功能

![](jiqun-images/127.png)

![](jiqun-images/128.png)

*/1 * . * * 每分鐘執行一次定時調度任務

0 1 . * * 天天晚上凌晨一點鐘執行這個任務

0 */2 . * * 每隔兩個小時定時執行這個任務

30 21 . * * 天天晚上九點半定時執行這個

## **oozie**

**oozie的介紹**

Oozie是運行在hadoop平臺上的一種工做流調度引擎，它能夠用來調度與管理hadoop任務，如，MapReduce、Pig等。那麼，對於OozieWorkflow中的一個個的action（能夠理解成一個個MapReduce任務）Oozie是根據什麼來對action的執行時間與執行順序進行管理調度的呢？答案就是咱們在數據結構中常見的有向無環圖(DAGDirect Acyclic Graph)的模式來進行管理調度的，咱們能夠利用HPDL語言（一種xml語言）來定義整個workflow，實現工做流的調度oozie的架構以及執行流程

**oozie的架構**

![](jiqun-images/131.png)

**oozie的執行流程**

![](jiqun-images/132.png)

**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

vim core-site.xml

```html
<property>
<name>hadoop.proxyuser.root.hosts</name>
<value>*</value>
</property>
<property>
<name>hadoop.proxyuser.root.groups</name>
<value>*</value>
</property>
```

注意：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

cd /export/softwares/

tar -zxvf oozie-4.1.0-cdh5.14.0.tar.gz -C ../servers/

**第三步：解壓hadooplibs到與oozie平行的目錄**

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

tar -zxvf oozie-hadooplibs-4.1.0-cdh5.14.0.tar.gz -C ../

![](jiqun-images/133.png)

**第四步：建立libext目錄**

在oozie的安裝路徑下建立libext目錄

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

mkdir -p libext

**第五步：拷貝依賴包到libext**

拷貝一些依賴包到libext目錄下面去

拷貝全部的依賴包

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

cp -ra hadooplibs/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

vim oozie-site.xml

若是沒有這些屬性，直接添加進去便可，oozie默認使用的是UTC的時區，咱們須要在咱們oozie-site.xml當中記得要配置咱們的時區爲GMT+0800時區

```xml
<property>
<name>oozie.service.JPAService.jdbc.driver</name>
<value>com.mysql.jdbc.Driver</value>
</property>
<property>
<name>oozie.service.JPAService.jdbc.url</name>
<value>jdbc:mysql://node03.hadoop.com:3306/oozie</value>
</property>
<property>
<name>oozie.service.JPAService.jdbc.username</name>
<value>root</value>
</property>
<property>
<name>oozie.service.JPAService.jdbc.password</name>
<value>123456</value>
</property>
<property>
<name>oozie.processing.timezone</name>
<value>GMT+0800</value>
</property>
<property>
<name>oozie.service.ProxyUserService.proxyuser.hue.hosts</name>
<value>*</value>
</property>
<property> <name>oozie.service.ProxyUserService.proxyuser.hue.groups</name>
<value>*</value>
</property>
<property>
<name>oozie.service.coord.check.maximum.frequency</name>
<value>false</value>
</property>
<property>
<name>oozie.service.HadoopAccessorService.hadoop.configurations</name>
<value>*=/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop</value>
</property>
```

**第八步：建立mysql數據庫**

mysql -uroot -p

create database oozie;

**第九步：上傳oozie依賴的jar包到hdfs上面去**

上傳oozie的解壓後目錄的yarn.tar.gz到hdfs目錄去

bin/oozie-setup.sh sharelib create -fs hdfs://node01:8020 -locallib oozie-sharelib-4.1.0-cdh5.14.0-yarn.tar.gz

實際上就是將這些jar包解壓到了hdfs上面的路徑下面去了

**第十步：建立oozie的數據庫表**

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

bin/oozie-setup.sh db create -run -sqlfile oozie.sql

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

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

bin/oozie-setup.sh prepare-war

**第十二步：配置oozie的環境變量**

vim /etc/profile

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

export OOZIE_URL=http://node03.hadoop.com:11000/oozie

export PATH=:$OOZIE_HOME/bin:$PATH

source /etc/profile

![](jiqun-images/134.png)

**第十三步：啓動與關閉oozie服務**

啓動命令

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

bin/oozied.sh start

關閉命令

bin/oozied.sh stop

![](jiqun-images/135.png)

**第十四步：瀏覽器頁面訪問oozie**

http://node03:11000/oozie/

解決oozie的頁面的時區問題：

咱們頁面訪問的時候，發現咱們的oozie使用的仍是GMT的時區，與咱們如今的時區相差必定的時間，因此咱們須要調整一個js的獲取時區的方法，將其改爲咱們如今的時區

修改js當中的時區問題

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

vim oozie-console.js

```
function getTimeZone() {
Ext.state.Manager.setProvider(new Ext.state.CookieProvider());
return Ext.state.Manager.get("TimezoneId","GMT+0800");

}
```

![](jiqun-images/136.png)

重啓oozie便可

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

關閉oozie服務

bin/oozied.sh stop

啓動oozie服務

bin/oozied.sh start

### oozie的使用

**1.使用oozie調度shell腳本**

oozie安裝好了以後，咱們須要測試oozie的功能是否完整好使，官方已經給咱們帶了各類測試案例，咱們能夠經過官方提供的各類案例來對咱們的oozie進行調度

**第一步：解壓官方提供的調度案例**

oozie自帶了各類案例，咱們能夠使用oozie自帶的各類案例來做爲模板，因此咱們這裏先把官方提供的各類案例給解壓出來

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

tar -zxf oozie-examples.tar.gz

![](jiqun-images/137.png)

**第二步：建立咱們的工做目錄**

在任意地方建立一個oozie的工做目錄，之後咱們的調度任務的配置文件所有放到oozie的工做目錄當中去

我這裏直接在oozie的安裝目錄下面建立工做目錄

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

mkdir oozie_works

**第三步：拷貝咱們的任務模板到咱們的工做目錄當中去**

咱們的任務模板以及工做目錄都準備好了以後，咱們把咱們的shell的任務模板拷貝到咱們oozie的工做目錄當中去

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

cp -r examples/apps/shell/ oozie_works/

**第四步：隨意準備一個shell腳本**

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

vim oozie_works/shell/hello.sh

注意：這個腳本必定要是在咱們oozie工做路徑下的shell路徑下的位置

\#!/bin/bash

echo "hello world" >> /export/servers/hello_oozie.tx

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

修改job.properties

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

vim job.properties

```shell
nameNode=hdfs://node01:8020
jobTracker=node01:8032
queueName=default
examplesRoot=oozie_works
oozie.wf.application.path=${nameNode}/user/${user.name}/${examplesRoot}/shell
EXEC=hello.sh
```

修改workflow.xml

vim workflow.xml

**第六步：上傳咱們的調度任務到hdfs上面去**

注意：上傳的hdfs目錄爲/user/root，由於咱們hadoop啓動的時候使用的是root用戶，若是hadoop啓動的是其餘用戶，那麼就上傳到

/user/其餘用戶

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

hdfs dfs -put oozie_works/ /user/root

**第七步：執行調度任務**

經過oozie的命令來執行咱們的調度任務

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

bin/oozie job -oozie http://node03:11000/oozie -config oozie_works/shell/job.properties -run

從監控界面能夠看到咱們的任務執行成功了

![](jiqun-images/138.png)

查看hadoop的19888端口，咱們會發現，oozie啓動了一個MR的任務去執行咱們的shell腳本

![](jiqun-images/139.png)

2.使用oozie調度咱們的hive

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

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

cp -ra examples/apps/hive2/ oozie_works/

**第二步：編輯hive模板**

這裏使用的是hiveserver2來進行提交任務，須要注意咱們要將hiveserver2的服務給啓動起來

修改job.properties

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

vim job.properties

```shell
nameNode=hdfs://node01:8020
jobTracker=node01:8032
queueName=default
jdbcURL=jdbc:hive2://node03:10000/default
examplesRoot=oozie_works
oozie.use.system.libpath=true
# 配置咱們文件上傳到hdfs的保存路徑實際上就是在hdfs 的/user/root/oozie_works/hive2這個路徑下
oozie.wf.application.path=${nameNode}/user/${user.name}/${examplesRoot}/hive2
```

修改workflow.xml

vim workflow.xml

```xml
<?xml version="1.0" encoding="UTF-8".>
<workflow-app xmlns="uri:oozie:workflow:0.5" name="hive2-wf">
<start to="hive2-node"/>
<action name="hive2-node">
<hive2 xmlns="uri:oozie:hive2-action:0.1">
<job-tracker>${jobTracker}</job-tracker>
<name-node>${nameNode}</name-node>
<prepare>
<delete path="${nameNode}/user/${wf:user()}/${examplesRoot}/output-data/hive2"/>
<mkdir path="${nameNode}/user/${wf:user()}/${examplesRoot}/output-data"/>
</prepare>
<configuration>
<property>
<name>mapred.job.queue.name</name>
<value>${queueName}</value>
</property>
</configuration>
<jdbc-url>${jdbcURL}</jdbc-url>
<script>script.q</script>
<param>INPUT=/user/${wf:user()}/${examplesRoot}/input-data/table</param> <param>OUTPUT=/user/${wf:user()}/${examplesRoot}/output-data/hive2</param>
</hive2>
<ok to="end"/>
<error to="fail"/>
</action>
<kill name="fail">
<message>Hive2 (Beeline) action failed, error message[${wf:errorMessage(wf:lastErrorNode())}]</message>
</kill>
<end name="end"/>
</workflow-app>
```

編輯hivesql文件

vim script.q

```sql
DROP TABLE IF EXISTS test;
CREATE EXTERNAL TABLE test (a INT) STORED AS TEXTFILE LOCATION '${INPUT}';
insert into test values(10);
insert into test values(20);
insert into test values(30);
```

**第三步：上傳工做文件到hdfs**

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

hdfs dfs -put hive2/ /user/root/oozie_works/

**第四步：執行oozie的調度**

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

bin/oozie job -oozie http://node03:11000/oozie -config oozie_works/hive2/job.properties -run

**第五步：查看調度結果**

![](jiqun-images/140.png)

3.使用oozie調度MR任務

**第一步：準備MR執行的數據**

咱們這裏經過oozie調度一個MR的程序的執行，MR的程序能夠是本身寫的，也能夠是hadoop工程自帶的，咱們這裏就選用hadoop工程自帶的MR程序來運行wordcount的示例

準備如下數據上傳到HDFS的/oozie/input路徑下去

hdfs dfs -mkdir -p /oozie/input

vim wordcount.txt

hello world hadoop

spark hive hadoop

將咱們的數據上傳到hdfs對應目錄

hdfs dfs -put wordcount.txt /oozie/input

**第二步：執行官方測試案例**

yarn jar /export/servers/hadoop-2.6.0-cdh5.14.0/share/hadoop/mapreduce/hadoop-mapreduce-examples-2.6.0-cdh5.14.0.jar wordcount /oozie/input/ /oozie/output

**第三步：準備咱們調度的資源**

將咱們須要調度的資源都準備好放到一個文件夾下面去，包括咱們的jar包，咱們的job.properties，以及咱們的workflow.xml。

拷貝MR的任務模板

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

cp -ra examples/apps/map-reduce/ oozie_works/

刪掉MR任務模板lib目錄下自帶的jar包

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

rm -rf oozie-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/

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

修改job.properties

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

vim job.properties

```shell
nameNode=hdfs://node01:8020
jobTracker=node01:8032
queueName=default
examplesRoot=oozie_works
oozie.wf.application.path=${nameNode}/user/${user.name}/${examplesRoot}/map-reduce/workflow.xml
outputDir=/oozie/output
inputdir=/oozieinput
```

修改workflow.xml

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

vim workflow.xml

```xml
<?xml version="1.0" encoding="UTF-8".>

<workflow-app xmlns="uri:oozie:workflow:0.5" name="map-reduce-wf">
<start to="mr-node"/>
<action name="mr-node">
<map-reduce>
<job-tracker>${jobTracker}</job-tracker>
<name-node>${nameNode}</name-node>
<prepare>
<delete path="${nameNode}/${outputDir}"/>
</prepare>
<configuration>
<property>
<name>mapred.job.queue.name</name>
<value>${queueName}</value>
</property>


<property>
<name>mapred.mapper.new-api</name>
<value>true</value>
</property>
<property>
<name>mapred.reducer.new-api</name>
<value>true</value>
</property>

<property>
<name>mapreduce.job.output.key.class</name>
<value>org.apache.hadoop.io.Text</value>
</property>

<property>
<name>mapreduce.job.output.value.class</name>
<value>org.apache.hadoop.io.IntWritable</value>
</property>

<property>
<name>mapred.input.dir</name>
<value>${nameNode}/${inputdir}</value>
</property>

<property>
<name>mapred.output.dir</name>
<value>${nameNode}/${outputDir}</value>
</property>

<property>
<name>mapreduce.job.map.class</name>
<value>org.apache.hadoop.examples.WordCount$TokenizerMapper</value>
</property>

<property>
<name>mapreduce.job.reduce.class</name>
<value>org.apache.hadoop.examples.WordCount$IntSumReducer</value>
</property>

<property>
<name>mapred.map.tasks</name>
<value>1</value>
</property>
</configuration>
</map-reduce>
<ok to="end"/>
<error to="fail"/>
</action>
<kill name="fail">
<message>Map/Reduce failed, error message[${wf:errorMessage(wf:lastErrorNode())}]</message>
</kill>
<end name="end"/>
</workflow-app>
```

**第五步：上傳調度任務到hdfs對應目錄**

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

hdfs dfs -put map-reduce/ /user/root/oozie_works/

**第六步：執行調度任務**

執行咱們的調度任務，而後經過oozie的11000端口進行查看任務結果

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

bin/oozie job -oozie http://node03:11000/oozie -config oozie_works/map-reduce/job.properties -run

4.oozie的任務串聯

在實際工做當中，確定會存在多個任務須要執行，而且存在上一個任務的輸出結果做爲下一個任務的輸入數據這樣的狀況，因此咱們須要在workflow.xml配置文件當中配置多個action，實現多個任務之間的相互依賴關係

需求：首先執行一個shell腳本，執行完了以後再執行一個MR的程序，最後再執行一個hive的程序

**第一步：準備咱們的工做目錄**

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

mkdir -p sereval-actions

**第二步：準備咱們的調度文件**

將咱們以前的hive，shell，以及MR的執行，進行串聯成到一個workflow當中去，準備咱們的資源文件

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

cp hive2/script.q sereval-actions/

cp shell/hello.sh sereval-actions/

cp -ra map-reduce/lib sereval-actions/

**第三步：開發調度的配置文件**

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

建立配置文件workflow.xml並編輯

vim workflow.xml

```xml
<workflow-app xmlns="uri:oozie:workflow:0.4" name="shell-wf">
<start to="shell-node"/>
<action name="shell-node">
<shell xmlns="uri:oozie:shell-action:0.2">
<job-tracker>${jobTracker}</job-tracker>
<name-node>${nameNode}</name-node>
<configuration>
<property>
<name>mapred.job.queue.name</name>
<value>${queueName}</value>
</property>
</configuration>
<exec>${EXEC}</exec>

<file>/user/root/oozie_works/sereval-actions/${EXEC}#${EXEC}</file>
<capture-output/>
</shell>
<ok to="mr-node"/>
<error to="mr-node"/>
</action>
<action name="mr-node">
<map-reduce>
<job-tracker>${jobTracker}</job-tracker>
<name-node>${nameNode}</name-node>
<prepare>
<delete path="${nameNode}/${outputDir}"/>
</prepare>
<configuration>
<property>
<name>mapred.job.queue.name</name>
<value>${queueName}</value>
</property>


<property>
<name>mapred.mapper.new-api</name>
<value>true</value>
</property>
<property>
<name>mapred.reducer.new-api</name>
<value>true</value>
</property>

<property>
<name>mapreduce.job.output.key.class</name>
<value>org.apache.hadoop.io.Text</value>
</property>

<property>
<name>mapreduce.job.output.value.class</name>
<value>org.apache.hadoop.io.IntWritable</value>
</property>

<property>
<name>mapred.input.dir</name>
<value>${nameNode}/${inputdir}</value>
</property>

<property>
<name>mapred.output.dir</name>
<value>${nameNode}/${outputDir}</value>
</property>

<property>
<name>mapreduce.job.map.class</name>
<value>org.apache.hadoop.examples.WordCount$TokenizerMapper</value>
</property>

<property>
<name>mapreduce.job.reduce.class</name>
<value>org.apache.hadoop.examples.WordCount$IntSumReducer</value>
</property>

<property>
<name>mapred.map.tasks</name>
<value>1</value>
</property>
</configuration>
</map-reduce>
<ok to="hive2-node"/>
<error to="fail"/>
</action>
<action name="hive2-node">
<hive2 xmlns="uri:oozie:hive2-action:0.1">
<job-tracker>${jobTracker}</job-tracker>
<name-node>${nameNode}</name-node>
<prepare>
<delete path="${nameNode}/user/${wf:user()}/${examplesRoot}/output-data/hive2"/>
. <mkdir path="${nameNode}/user/${wf:user()}/${examplesRoot}/output-data"/>
</prepare>
<configuration>
<property>
<name>mapred.job.queue.name</name>
<value>${queueName}</value>
</property>
</configuration>
<jdbc-url>${jdbcURL}</jdbc-url>
<script>script.q</script>
<param>INPUT=/user/${wf:user()}/${examplesRoot}/input-data/table</param> <param>OUTPUT=/user/${wf:user()}/${examplesRoot}/output-data/hive2</param>
</hive2>
<ok to="end"/>
<error to="fail"/>
</action>
<decision name="check-output">
<switch>
<case to="end">
${wf:actionData('shell-node')['my_output'] eq 'Hello Oozie'}
</case>
<default to="fail-output"/>
</switch>
</decision>
<kill name="fail">
<message>Shell action failed, error message[${wf:errorMessage(wf:lastErrorNode())}]</message>
</kill>
<kill name="fail-output">
<message>Incorrect output, expected [Hello Oozie] but was [${wf:actionData('shell-node')['my_output']}]</message>
</kill>
<end name="end"/>
</workflow-app>
```

開發咱們的job.properties配置文件

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

vim job.properties

```shell
nameNode=hdfs://node01:8020
jobTracker=node01:8032
queueName=default
examplesRoot=oozie_works
EXEC=hello.sh
outputDir=/oozie/output
inputdir=/oozie/input
jdbcURL=jdbc:hive2://node03:10000/default
oozie.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/

hdfs dfs -put sereval-actions/ /user/root/oozie_works/

**第五步：執行調度任務**

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

bin/oozie job -oozie http://node03:11000/oozie -config oozie_works/serveral-actions/job.properties -run

**五、oozie的任務調度,定時任務執行**

在oozie當中，主要是經過Coordinator 來實現任務的定時調度，與咱們的workflow相似的，Coordinator 這個模塊也是主要經過xml來進行配置便可，接下來咱們就來看看如何配置Coordinator 來實現任務的定時調度Coordinator 的調度主要能夠有兩種實現方式

第一種：基於時間的定時任務調度，

oozie基於時間的調度主要須要指定三個參數，第一個起始時間，第二個結束時間，第三個調度頻率

第二種：基於數據的任務調度，只有在有了數據纔會去出發執行

這種是基於數據的調度，只要在有了數據纔會觸發調度任務

**oozie當中定時任務的設置**

**第一步：拷貝定時任務的調度模板**

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

cp -r examples/apps/cron oozie_works/cron-job

**第二步：拷貝咱們的hello.sh腳本**

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

cp shell/hello.sh cron-job/

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

修改job.properties

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

vim job.properties

```
nameNode=hdfs://node01:8020
jobTracker=node01:8032
queueName=default
examplesRoot=oozie_works
oozie.coord.application.path=${nameNode}/user/${user.name}/${examplesRoot}/cron-job/coordinator.xml
start=2018-08-22T19:20+0800
end=2019-08-22T19:20+0800
EXEC=hello.sh
workflowAppUri=${nameNode}/user/${user.name}/${examplesRoot}/cron-job/workflow.xml
```

修改coordinator.xml

vim coordinator.xml

```xml

<coordinator-app name="cron-job" frequency="${coord:minutes(1)}" start="${start}" end="${end}" timezone="GMT+0800"
xmlns="uri:oozie:coordinator:0.4">
<action>
<workflow>
<app-path>${workflowAppUri}</app-path>
<configuration>
<property>
<name>jobTracker</name>
<value>${jobTracker}</value>
</property>
<property>
<name>nameNode</name>
<value>${nameNode}</value>
</property>
<property>
<name>queueName</name>
<value>${queueName}</value>
</property>
</configuration>
</workflow>
</action>
</coordinator-app>

```

修改workflow.xml

vim workflow.xml

```xml
<workflow-app xmlns="uri:oozie:workflow:0.5" name="one-op-wf">
<start to="action1"/>
<action name="action1">
<shell xmlns="uri:oozie:shell-action:0.2">
<job-tracker>${jobTracker}</job-tracker>
<name-node>${nameNode}</name-node>
<configuration>
<property>
<name>mapred.job.queue.name</name>
<value>${queueName}</value>
</property>
</configuration>
<exec>${EXEC}</exec>

<file>/user/root/oozie_works/cron-job/${EXEC}#${EXEC}</file>
<capture-output/>
</shell>
<ok to="end"/>
<error to="end"/>
</action>
<end name="end"/>
</workflow-app>
```

**第四步：上傳到hdfs對應路徑**

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

hdfs dfs -put cron-job/ /user/root/oozie_works/

**第五步：運行定時任務**

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

bin/oozie job -oozie http://node03:11000/oozie -config oozie_works/cron-job/job.properties -run

**oozie當中任務的查看以及殺死**

**查看全部普通任務**

oozie jobs

**查看定時任務**

oozie jobs -jobtype coordinator

![](jiqun-images/141.png)

**殺死某個任務**

oozie能夠經過jobid來殺死某個定時任務

oozie job -kill [id]

例如咱們能夠使用命令

oozie job -kill 0000085-180628150519513-oozie-root-C

來殺死咱們定時任務

![](jiqun-images/142.png)

### hue整合oozie

**第一步：中止oozie與hue的進程**

經過命令中止oozie與hue的進程，準備修改oozie與hue的配置文件

**第二步：修改oozie的配置文件（老版本的bug，新版本已經不須要了）這一步咱們都不須要作了**

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

```xml
<property> <name>oozie.service.WorkflowAppService.system.libpath</name>
<value>/user/oozie/share/lib</value>
</property>
<property>
<name>oozie.use.system.libpath</name>
<value>true</value>
</property>
```

從新上傳全部的jar包到hdfs的/user/oozie/share/lib路徑下去

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

bin/oozie-setup.sh sharelib create -fs hdfs://node01:8020 -locallib oozie-sharelib-4.1.0-cdh5.14.0-yarn.tar.gz

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

修改hue的配置文件hue.ini

[liboozie]

```shell
# The URL where the Oozie service runs on. This is required in order for
# users to submit jobs. Empty value disables the config check.
oozie_url=http://node03.hadoop.com:11000/oozie
# Requires FQDN in oozie_url if enabled
# security_enabled=false
# Location on HDFS where the workflows/coordinator are deployed when submitted.
remote_deployement_dir=/user/root/oozie_works
```

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

[oozie]

```shell
# Location on local FS where the examples are stored.

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

# Location on local FS where the data for the examples is stored.

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

# Location on HDFS where the oozie examples and workflows are stored.

# Parameters are $TIME and $USER, e.g. /user/$USER/hue/workspaces/workflow-$TIME

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

# Maximum of Oozie workflows or coodinators to retrieve in one API call.

oozie_jobs_count=100

# Use Cron format for defining the frequency of a Coordinator instead of the old frequency number/unit.

enable_cron_scheduling=true

# Flag to enable the saved Editor queries to be dragged and dropped into a workflow.

enable_document_action=true

# Flag to enable Oozie backend filtering instead of doing it at the page level in Javascript. Requires Oozie 4.3+.

enable_oozie_backend_filtering=true

# Flag to enable the Impala action.

enable_impala_action=true
```

[filebrowser]

```shell
# Location on local filesystem where the uploaded archives are temporary stored.

archive_upload_tempdir=/tmp

# Show Download Button for HDFS file browser.

show_download_button=true

# Show Upload Button for HDFS file browser.

show_upload_button=true

# Flag to enable the extraction of a uploaded archive in HDFS.

enable_extract_uploaded_archive=true
```

**第四步：啓動hue與oozie的進程**

啓動hue進程

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

build/env/bin/supervisor

啓動oozie進程

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

bin/oozied.sh start

頁面訪問hue

http://node03.hadoop.com:8888/

### oozie使用過程中可能遇到的問題

**1) Mysql權限配置**

受權全部主機能夠使用root用戶操做全部數據庫和數據表

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

**3)** **jps查看進程時，注意有沒有bootstrap**

**4)** **關閉oozie**

若是bin/oozied.sh stop沒法關閉，則能夠使用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：**

**一、中止oozie（要經過jps檢查bootstrap進程是否已經不存在）**

**二、刪除oozie-server/temp/\***

**三、刪除HDFS上的sharelib文件夾**

**四、刪除oozie.sql文件，刪除Mysql中刪除oozie庫，從新建立**

**五、從新按照順序執行文檔中oozie****的安裝從新再來一遍**

**hadoop基礎環境加強**

**Hadoop High Availability**

HA(High Available), 高可用，是保證業務連續性的有效解決方案，通常有兩個或兩個以上的節點，分爲**活動節點（**Active**）及**備用節點（Standby）。一般把正在執行業務的稱爲活動節點，而做爲活動節點的一個備份的則稱爲備用節點。當活動節點出現問題，致使正在運行的業務（任務）不能正常運行時，備用節點此時就會偵測到，並當即接續活動節點來執行業務。從而實現業務的不中斷或短暫中斷。

Hadoop1.X版本，NN是HDFS集羣的單點故障點，每個集羣只有一個NN,若是這個機器或進程不可用，整個集羣就沒法使用。爲了解決這個問題，出現了一堆針對HDFS HA的解決方案（如：Linux HA, VMware FT, shared NAS+NFS, BookKeeper, QJM/Quorum Journal Manager, BackupNode等）。

在HA具體實現方法不一樣狀況下，HA框架的流程是一致的, 不一致的就是如何存儲、管理、同步edits編輯日誌文件。

在Active NN和Standby NN之間要有個共享的存儲日誌的地方，Active NN把edit Log寫到這個共享的存儲日誌的地方，Standby NN去讀取日誌而後執行，這樣Active和Standby NN內存中的HDFS元數據保持着同步。一旦發生主從切換Standby NN能夠儘快接管Active NN的工做。

**Namenode HA**

**Namenode HA詳解**

hadoop2.x以後，Clouera提出了QJM/Qurom Journal Manager，這是一個基於Paxos算法（分佈式一致性算法）實現的HDFS HA方案，它給出了一種較好的解決思路和方案,QJM主要優點以下：

不須要配置額外的高共享存儲，下降了複雜度和維護成本。

消除spof(單點故障)。

系統魯棒性(Robust)的程度可配置、可擴展。

![](jiqun-images/143.png)

基本原理就是用2N+1臺 JournalNode 存儲EditLog，每次寫數據操做有>=N+1返回成功時即認爲該次寫成功，數據不會丟失了。固然這個算法所能容忍的是最多有N臺機器掛掉，若是多於N臺掛掉，這個算法就失效了。這個原理是基於Paxos算法。

在HA架構裏面SecondaryNameNode已經不存在了，爲了保持standby NN時時的與Active NN的元數據保持一致，他們之間交互經過JournalNode進行操做同步。

任何修改操做在 Active NN上執行時，JournalNode進程同時也會記錄修改log到至少半數以上的JN中，這時 Standby NN 監測到JN 裏面的同步log發生變化了會讀取 JN 裏面的修改log，而後同步到本身的目錄鏡像樹裏面，以下圖：

![](jiqun-images/144.png)

當發生故障時，Active的 NN 掛掉後，Standby NN 會在它成爲Active NN 前，讀取全部的JN裏面的修改日誌，這樣就能高可靠的保證與掛掉的NN的目錄鏡像樹一致，而後無縫的接替它的職責，維護來自客戶端請求，從而達到一個高可用的目的。

在HA模式下，datanode須要確保同一時間有且只有一個NN能命令DN。爲此：

每一個NN改變狀態的時候，向DN發送本身的狀態和一個序列號。

DN在運行過程當中維護此序列號，當failover時，新的NN在返回DN心跳時會返回本身的active狀態和一個更大的序列號。DN接收到這個返回則認爲該NN爲新的active。

若是這時原來的active NN恢復，返回給DN的心跳信息包含active狀態和原來的序列號，這時DN就會拒絕這個NN的命令

**Failover Controller**

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進程。

![](jiqun-images/145.png)

**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狀態

**Yarn HA**

Yarn做爲資源管理系統，是上層計算框架（如MapReduce,Spark）的基礎。在Hadoop 2.4.0版本以前，Yarn存在單點故障（即ResourceManager存在單點故障），一旦發生故障，恢復時間較長，且會致使正在運行的Application丟失，影響範圍較大。從Hadoop 2.4.0版本開始，Yarn實現了ResourceManager HA，在發生故障時自動failover，大大提升了服務的可靠性。

ResourceManager（簡寫爲RM）做爲Yarn系統中的主控節點，負責整個系統的資源管理和調度，內部維護了各個應用程序的ApplictionMaster信息、NodeManager（簡寫爲NM）信息、資源使用等。因爲資源使用狀況和NodeManager信息均可以經過NodeManager的心跳機制從新構建出來，所以只須要對ApplicationMaster相關的信息進行持久化存儲便可。

在一個典型的HA集羣中，兩臺獨立的機器被配置成ResourceManger。在任意時間，有且只容許一個活動的ResourceManger,另一個備用。切換分爲兩種方式：

**手動切換**：在自動恢復不可用時，管理員可用手動切換狀態，或是從Active到Standby,或是從Standby到Active。

**自動切換**：基於Zookeeper，可是區別於HDFS的HA，2個節點間無需配置額外的ZFKC守護進程來同步數據。

![](jiqun-images/146.png)

#### **Hadoop HA集羣的搭建**

如何在已有的節點上面搭建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服務

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

bin/oozied.sh stop

**中止hue服務**

node03中止hue的服務

**中止impala服務**

直接使用kill -9殺死進程便可

node03中止impala相關服務

service impala-catalog stop

service impala-state-store stop

service impala-server stop

node02中止impala相關服務

service impala-server stop

node01中止impala相關服務

service impala-server stop

**中止hive服務**

node03中止hive服務

經過kill命令直接殺死相關hive進程便可

![](jiqun-images/147.png)

**中止hadoop服務**

node01機器執行如下命令中止hadoop服務

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

sbin/stop-dfs.sh

sbin/stop-yarn.sh

sbin/mr-jobhistory-daemon.sh stop historyserver

**第二步：啓動全部節點的zookeeper服務**

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

bin/zkServer.sh start

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

全部節點修改配置文件，注意yarn-site.xml當中的

yarn.resourcemanager.ha.id 這個屬性值，node03機器與node02機器的配置值不太同樣

**修改core-site.xml**

```xml

<property>
<name>ha.zookeeper.quorum</name>
<value>node01.hadoop.com:2181,node02.hadoop.com:2181,node03.hadoop.com:2181</value>
</property>
<property>
<name>fs.defaultFS</name>
<value>hdfs://hann</value>
</property>

<property>
<name>io.file.buffer.size</name>
<value>4096</value>
</property>
<property>
<name>hadoop.tmp.dir</name>
<value>/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/tempDatas</value>
</property>
<property>
<name>fs.trash.interval</name>
<value>10080</value>
</property>
<property>
<name>hadoop.proxyuser.root.hosts</name>
<value>*</value>
</property>
<property>
<name>hadoop.proxyuser.root.groups</name>
<value>*</value>
</property>
```

**修改hdfs-site.xml**

```xml



<property>
<name>dfs.nameservices</name>
<value>hann</value>
</property>
<property>
<name>dfs.ha.namenodes.hann</name>
<value>nn1,nn2</value>
</property>
<property>
<name>dfs.namenode.rpc-address.hann.nn1</name>
<value>node01.hadoop.com:8020</value>
</property>
<property>
<name>dfs.namenode.rpc-address.hann.nn2</name>
<value>node02.hadoop.com:8020</value>
</property>
<property>
<name>dfs.namenode.servicerpc-address.hann.nn1</name>
<value>node01.hadoop.com:8022</value>
</property>
<property>
<name>dfs.namenode.servicerpc-address.hann.nn2</name>
<value>node02.hadoop.com:8022</value>
</property>

<property>
<name>dfs.namenode.http-address.hann.nn1</name>
<value>node01.hadoop.com:50070</value>
</property>
<property>
<name>dfs.namenode.http-address.hann.nn2</name>
<value>node02.hadoop.com:50070</value>
</property>
<property>
<name>dfs.namenode.shared.edits.dir</name> <value>qjournal://node01.hadoop.com:8485;node02.hadoop.com:8485;node03.hadoop.com:8485/hann</value>
</property>
<property>
<name>dfs.journalnode.edits.dir</name>
<value>/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/dfs/jn</value>
</property>
<property>
<name>dfs.client.failover.proxy.provider.hann</name>
<value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
</property>
<property>
<name>dfs.ha.fencing.methods</name>
<value>sshfence</value>
</property>
<property>
<name>dfs.ha.fencing.ssh.private-key-files</name>
<value>/root/.ssh/id_rsa</value>
</property>
<property>
<name>dfs.ha.automatic-failover.enabled</name>
<value>true</value>
</property>
<property>
<name>dfs.namenode.name.dir</name>
<value>file:///export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/namenodeDatas</value> </property>
<property>
<name>dfs.namenode.edits.dir</name>
<value>file:///export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/dfs/nn/edits</value>
</property>
<property>
<name>dfs.datanode.data.dir</name>
<value>file:///export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/datanodeDatas</value>
</property>
<property>
<name>dfs.replication</name>
<value>3</value>
</property>
<property>
<name>dfs.permissions</name>
<value>false</value>
</property>
<property>
<name>dfs.blocksize</name>
<value>134217728</value>
</property>
<property>
<name>dfs.webhdfs.enabled</name>
<value>true</value>
</property>
<property>
<name>dfs.client.read.shortcircuit</name>
<value>true</value>
</property>
<property>
<name>dfs.domain.socket.path</name>
<value>/var/run/hdfs-sockets/dn</value>
</property>
<property>
<name>dfs.client.file-block-storage-locations.timeout.millis</name>
<value>10000</value>
</property>
<property>
<name>dfs.datanode.hdfs-blocks-metadata.enabled</name>
<value>true</value>
</property>
<property>
<name>dfs.webhdfs.enabled</name>
<value>true</value>
</property>
```

**修改mapred-site.xml**

```xml

<!--
<property>
<name>mapreduce.map.output.compress</name>
<value>true</value>
</property>
<property>
<name>mapreduce.map.output.compress.codec</name>
<value>org.apache.hadoop.io.compress.SnappyCodec</value>
</property>
<property>
<name>mapreduce.output.fileoutputformat.compress</name>
<value>true</value>
</property>
<property>
<name>mapreduce.output.fileoutputformat.compress.type</name>
<value>RECORD</value>
</property>
<property>
<name>mapreduce.output.fileoutputformat.compress.codec</name>
<value>org.apache.hadoop.io.compress.SnappyCodec</value>
</property>

-->

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

<property>
<name>mapreduce.jobhistory.address</name>
<value>node03:10020</value>
</property>

<property>
<name>mapreduce.jobhistory.webapp.address</name>
<value>node03:19888</value>
</property>
<property>
<name>mapreduce.jobtracker.system.dir</name>
<value>/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/jobtracker</value>
</property>

<property>
<name>mapreduce.map.memory.mb</name>
<value>1024</value>
</property>


<property>
<name>mapreduce.reduce.memory.mb</name>
<value>1024</value>
</property>


<property>
<name>mapreduce.task.io.sort.mb</name>
<value>100</value>
</property>

<property>
<name>mapreduce.task.io.sort.factor</name>
<value>10</value>
</property>

<property>
<name>mapreduce.reduce.shuffle.parallelcopies</name>
<value>25</value>
</property>
<property>
<name>yarn.app.mapreduce.am.command-opts</name>
<value>-Xmx1024m</value>
</property>

<property>
<name>yarn.app.mapreduce.am.resource.mb</name>
<value>1536</value>
</property>

<property>
<name>mapreduce.cluster.local.dir</name>
<value>/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/mapreduce/local</value>
</property>
```

**修改yarn-site.xml**

注意：yarn.resourcemanager.ha.id 這個屬性的配置，node03的這個屬性值與node02的這個屬性值內容不一樣

```xml






<property>
<name>yarn.log-aggregation-enable</name>
<value>true</value>
</property>

<property>
<name>yarn.resourcemanager.ha.enabled</name>
<value>true</value>
</property>

<property>
<name>yarn.resourcemanager.cluster-id</name>
<value>mycluster</value>
</property>

<property>
<name>yarn.resourcemanager.ha.rm-ids</name>
<value>rm1,rm2</value>
</property>

<property>
<name>yarn.resourcemanager.hostname.rm1</name>
<value>node03.hadoop.com</value>
</property>

<property>
<name>yarn.resourcemanager.hostname.rm2</name>
<value>node02.hadoop.com</value>
</property>

<property>
<name>yarn.resourcemanager.address.rm1</name>
<value>node03.hadoop.com:8032</value>
</property>
<property>
<name>yarn.resourcemanager.scheduler.address.rm1</name>
<value>node03.hadoop.com:8030</value>
</property>
<property>
<name>yarn.resourcemanager.resource-tracker.address.rm1</name>
<value>node03.hadoop.com:8031</value>
</property>
<property>
<name>yarn.resourcemanager.admin.address.rm1</name>
<value>node03.hadoop.com:8033</value>
</property>
<property>
<name>yarn.resourcemanager.webapp.address.rm1</name>
<value>node03.hadoop.com:8088</value>
</property>

<property>
<name>yarn.resourcemanager.address.rm2</name>
<value>node02.hadoop.com:8032</value>
</property>
<property>
<name>yarn.resourcemanager.scheduler.address.rm2</name>
<value>node02.hadoop.com:8030</value>
</property>
<property>
<name>yarn.resourcemanager.resource-tracker.address.rm2</name>
<value>node02.hadoop.com:8031</value>
</property>
<property>
<name>yarn.resourcemanager.admin.address.rm2</name>
<value>node02.hadoop.com:8033</value>
</property>
<property>
<name>yarn.resourcemanager.webapp.address.rm2</name>
<value>node02.hadoop.com:8088</value>
</property>

<property>
<name>yarn.resourcemanager.recovery.enabled</name>
<value>true</value>
</property>

<property>
<name>yarn.resourcemanager.ha.id</name>
<value>rm1</value>
<description>If we want to launch more than one RM in single node, we need this configuration</description>
</property>

<property>
<name>yarn.resourcemanager.store.class</name>
<value>org.apache.hadoop.yarn.server.resourcemanager.recovery.ZKRMStateStore</value>
</property>
<property>
<name>yarn.resourcemanager.zk-address</name>
<value>node01.hadoop.com:2181,node02.hadoop.com:2181,node03.hadoop.com:2181</value>
<description>For multiple zk services, separate them with comma</description>
</property>

<property>
<name>yarn.resourcemanager.ha.automatic-failover.enabled</name>
<value>true</value>
<description>Enable automatic failover; By default, it is enabled only when HA is enabled.</description>
</property>
<property>
<name>yarn.client.failover-proxy-provider</name>
<value>org.apache.hadoop.yarn.client.ConfiguredRMFailoverProxyProvider</value>
</property>

<property>
<name>yarn.nodemanager.resource.cpu-vcores</name>
<value>4</value>
</property>

<property>
<name>yarn.nodemanager.resource.memory-mb</name>
<value>512</value>
</property>

<property>
<name>yarn.scheduler.minimum-allocation-mb</name>
<value>512</value>
</property>

<property>
<name>yarn.scheduler.maximum-allocation-mb</name>
<value>512</value>
</property>

<property>
<name>yarn.log-aggregation.retain-seconds</name>
<value>2592000</value>
</property>

<property>
<name>yarn.nodemanager.log.retain-seconds</name>
<value>604800</value>
</property>

<property>
<name>yarn.nodemanager.log-aggregation.compression-type</name>
<value>gz</value>
</property>

<property>
<name>yarn.nodemanager.local-dirs</name>
<value>/export/servers/hadoop-2.6.0-cdh5.14.0/hadoopDatas/yarn/local</value>
</property>

<property>
<name>yarn.resourcemanager.max-completed-applications</name>
<value>1000</value>
</property>

<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>

<property>
<name>yarn.resourcemanager.connect.retry-interval.ms</name>
<value>2000</value>
</property>

改完以後，將配置文件分發到其餘的各個節點

還要記得改node02機器的yarn-site.xml
```

**第四步：服務的啓動**

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

在node01機器上進行zookeeper的初始化，其本質工做是建立對應的zookeeper節點

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

bin/hdfs zkfc -formatZK

**第二步：啓動journalNode**

三臺機器執行如下命令啓動journalNode，用於咱們的元數據管理

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

sbin/hadoop-daemon.sh start journalnode

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

node01機器上準備初始化journalNode

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

bin/hdfs namenode -initializeSharedEdits -force

**第四步：啓動namenode**

node01機器上啓動namenode

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

sbin/hadoop-daemon.sh start namenode

node02機器上啓動namenode

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

bin/hdfs namenode -bootstrapStandby

sbin/hadoop-daemon.sh start namenode

**第五步：啓動全部節點的datanode進程**

在node01機器上啓動全部節點的datanode進程

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

sbin/hadoop-daemons.sh start datanode

**第六步：啓動zkfc**

在node01機器上面啓動zkfc進程

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

sbin/hadoop-daemon.sh start zkfc

在node02機器上面啓動zkfc進程

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

sbin/hadoop-daemon.sh start zkfc

**第七步：啓動yarn進程**

node03機器上啓動yarn集羣

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

sbin/start-yarn.sh

node02機器上啓動yarn集羣

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

sbin/start-yarn.sh

**第八步：啓動jobhsitory**

node03節點啓動jobhistoryserver

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

sbin/mr-jobhistory-daemon.sh start historyserver

#### **Hadoop Federation**

**背景概述**

單NameNode的架構使得HDFS在集羣擴展性和性能上都有潛在的問題，當集羣大到必定程度後，NameNode進程使用的內存可能會達到上百G，NameNode成爲了性能的瓶頸。於是提出了namenode水平擴展方案-- Federation。

Federation中文意思爲聯邦,聯盟，是NameNode的Federation,也就是會有多個NameNode。多個NameNode的狀況意味着有多個namespace(命名空間)，區別於HA模式下的多NameNode，它們是擁有着同一個namespace。既然說到了NameNode的命名空間的概念,這裏就看一下現有的HDFS數據管理架構,以下圖所示:

![](jiqun-images/148.png)

從上圖中,咱們能夠很明顯地看出現有的HDFS數據管理,數據存儲2層分層的結構.也就是說,全部關於存儲數據的信息和管理是放在NameNode這邊,而真實數據的存儲則是在各個DataNode下.而這些隸屬於同一個NameNode所管理的數據都是在同一個命名空間下的.而一個namespace對應一個block pool。Block Pool是同一個namespace下的block的集合.固然這是咱們最多見的單個namespace的狀況,也就是一個NameNode管理集羣中全部元數據信息的時候.若是咱們遇到了以前提到的NameNode內存使用太高的問題,這時候怎麼辦.元數據空間依然仍是在不斷增大,一味調高NameNode的jvm大小絕對不是一個持久的辦法.這時候就誕生了HDFS Federation的機制.

**Federation架構設計**

HDFS Federation是解決namenode內存瓶頸問題的水平橫向擴展方案。

Federation意味着在集羣中將會有多個namenode/namespace。這些namenode之間是聯合的，也就是說，他們之間相互獨立且不須要互相協調，各自分工，管理本身的區域。分佈式的datanode被用做通用的數據塊存儲存儲設備。每一個datanode要向集羣中全部的namenode註冊，且週期性地向全部namenode發送心跳和塊報告，並執行來自全部namenode的命令。

![](jiqun-images/149.png)

Federation一個典型的例子就是上面提到的NameNode內存太高問題,咱們徹底能夠將上面部分大的文件目錄移到另一個NameNode上作管理.**更重要的一點在於,這些NameNode是共享集羣中全部的DataNode的,它們仍是在同一個集羣內的****。**

這時候在DataNode上就不只僅存儲一個Block Pool下的數據了,而是多個(在DataNode的datadir所在目錄裏面查看BP-xx.xx.xx.xx打頭的目錄)。

**歸納起來：**

多個NN共用一個集羣裏的存儲資源，每一個NN均可以單獨對外提供服務。

每一個NN都會定義一個存儲池，有單獨的id，每一個DN都爲全部存儲池提供存儲。

DN會按照存儲池id向其對應的NN彙報塊信息，同時，DN會向全部NN彙報本地存儲可用資源狀況。

**HDFS Federation不足**

HDFS Federation並無徹底解決單點故障問題。雖然namenode/namespace存在多個，可是從單個namenode/namespace看，仍然存在單點故障：若是某個namenode掛掉了，其管理的相應的文件便不能夠訪問。Federation中每一個namenode仍然像以前HDFS上實現同樣，配有一個secondary namenode，以便主namenode掛掉一下，用於還原元數據信息。

因此通常集羣規模真的很大的時候，會採用HA+Federation的部署方案。也就是每一個聯合的namenodes都是ha的。

**Federation示例配置**

這是一個包含兩個Namenode的Federation示例配置：

```xml
<configuration>
<property>
<name>dfs.nameservices</name>
<value>ns1,ns2</value>
</property>
<property>
<name>dfs.namenode.rpc-address.ns1</name>
<value>nn-host1:rpc-port</value>
</property>
<property>
<name>dfs.namenode.http-address.ns1</name>
<value>nn-host1:http-port</value>
</property>
<property>
<name>dfs.namenode.secondaryhttp-address.ns1</name>
<value>snn-host1:http-port</value>
</property>
<property>
<name>dfs.namenode.rpc-address.ns2</name>
<value>nn-host2:rpc-port</value>
</property>
<property>
<name>dfs.namenode.http-address.ns2</name>
<value>nn-host2:http-port</value>
</property>
<property>
<name>dfs.namenode.secondaryhttp-address.ns2</name>
<value>snn-host2:http-port</value> </property> .... Other common configuration ...</configuration>
```

## clouderaManager搭建

Cloudera Manager是cloudera公司提供的一種大數據的解決方案，能夠經過ClouderaManager管理界面來對咱們的集羣進行安裝和操做，提供了良好的UI界面交互，使得咱們管理集羣不用熟悉任何的linux技術，只須要經過網頁瀏覽器就能夠實現咱們的集羣的操做和管理，讓咱們使用和管理集羣更加的方便。

**總體架構**

![](jiqun-images/150.png)

Cloudera Manager的核心是Cloudera Manager Server。Server託管Admin Console Web Server和應用程序邏輯。它負責安裝軟件、配置、啓動和中止服務以及管理運行服務的羣集。

解釋：

· Agent：安裝在每臺主機上。它負責啓動和中止進程，解壓縮配置，觸發安裝和監控主機

· Management Service：執行各類監控、報警和報告功能的一組角色的服務。

· Database：存儲配置和監控信息

· Cloudera Repository：可供Cloudera Manager分配的軟件的存儲庫（repo庫）

· Client：用於與服務器進行交互的接口：

· Admin Console：管理員控制檯

· API：開發人員使用 API能夠建立自定義的Cloudera Manager應用程序

**Cloudera Management Service**

Cloudera Management Service 可做爲一組角色實施各類管理功能

· Activity Monitor：收集有關服務運行的活動的信息

· Host Monitor：收集有關主機的運行情況和指標信息

· Service Monitor：收集有關服務的運行情況和指標信息

· Event Server：聚合組件的事件並將其用於警報和搜索

· Alert Publisher ：爲特定類型的事件生成和提供警報

· Reports Manager：生成圖表報告，它提供用戶、用戶組的目錄的磁盤使用率、磁盤、io等歷史視圖

**信號檢測**

默認狀況下，Agent 每隔 15 秒向 Cloudera Manager Server 發送一次檢測信號。可是，爲了減小用戶延遲，在狀態變化時會提升頻率。

**狀態管理**

· 模型狀態捕獲什麼進程應在何處運行以及具備什麼配置

· 運行時狀態是哪些進程正在何處運行以及正在執行哪些命令（例如，從新平衡 HDFS 或執行備份/災難恢復計劃或滾動升級或中止）

· 當您更新配置（例如Hue Server Web 端口）時，您即更新了模型狀態。可是，若是 Hue 在更新時正在運行，則它仍將使用舊端口。當出現這種不匹配狀況時，角色會標記爲具備」過期的配置」。要從新同步，您需重啓角色（這會觸發從新生成配置和重啓進程）

· 特殊狀況若是要加入一些clouder manager控制檯沒有的屬性時候都在高級裏面嵌入

**服務器和客戶端配置**

· 如使用HDFS，文件 /etc/hadoop/conf/hdfs-site.xml 僅包含與 HDFS 客戶端相關的配置

· 而 HDFS 角色實例（例如，NameNode 和 DataNode）會從/var/run/cloudera-scm-agent/process/unique-process-name下的每一個進程專用目錄獲取它們的配置

**進程管理**

· 在 Cloudera Manager 管理的羣集中，只能經過 Cloudera Manager 啓動或中止服務。ClouderaManager 使用一種名爲 supervisord的開源進程管理工具，它會重定向日誌文件，通知進程失敗，爲合適用戶設置調用進程的有效用戶 ID 等等

· Cloudera Manager 支持自動重啓崩潰進程。若是一個角色實例在啓動後反覆失敗，Cloudera Manager還會用不良狀態標記該實例

· 特別須要注意的是，中止 Cloudera Manager 和 Cloudera Manager Agent 不會中止羣集；全部正在運行的實例都將保持運行

· Agent 的一項主要職責是啓動和中止進程。當 Agent 從檢測信號檢測到新進程時，Agent 會在/var/run/cloudera-scm-agent 中爲它建立一個目錄，並解壓縮配置

· Agent 受到監控，屬於 Cloudera Manager 的主機監控的一部分：若是 Agent 中止檢測信號，主機將被標記爲運行情況不良

**主機管理**

· Cloudera Manager 自動將做爲羣集中的託管主機身份：JDK、Cloudera Manager Agent、CDH、Impala、Solr 等參與所需的全部軟件部署到主機

· Cloudera Manager 提供用於管理參與主機生命週期的操做以及添加和刪除主機的操做

· Cloudera Management Service Host Monitor 角色執行運行情況檢查並收集主機度量，以使您能夠監控主機的運行情況和性能

**安全**

**·** **身份驗證**

· Hadoop中身份驗證的目的僅僅是證實用戶或服務確實是他或她所聲稱的用戶或服務，一般，企業中的身份驗證經過單個分佈式系統（例如，輕型目錄訪問協議 (LDAP) 目錄）進行管理。LDAP身份驗證包含由各類存儲系統提供支持的簡單用戶名/密碼服務

· Hadoop 生態系統的許多組件會彙總到一塊兒來使用 Kerberos 身份驗證並提供用於在 LDAP 或 AD 中管理和存儲憑據的選項

**·** **受權**
CDH 當前提供如下形式的訪問控制：

· 適用於目錄和文件的傳統 POSIX 樣式的權限

· 適用於 HDFS 的擴展的訪問控制列表 (ACL)

· Apache HBase 使用 ACL 來按列、列族和列族限定符受權各類操做 (READ, WRITE, CREATE, ADMIN)

· 使用 Apache Sentry 基於角色進行訪問控制

**·** **加密**

· 須要得到企業版的Cloudera（Cloudera Navigator 許可）

**clouderaManager環境安裝前準備**

準備兩臺虛擬機，其中一臺做爲咱們的主節點，安裝咱們的ClouderaManager Server與ClouderaManager agent，另一臺做爲咱們的從節點只安裝咱們的clouderaManager agent

機器規劃以下

| 服務器IP | 192.168.52.100 | 192.168.52.110 |
| ------------------ | ----------------- | ----------------- |
| 主機名 | node01.hadoop.com | node02.hadoop.com |
| 主機名與IP地址映射 | 是 | 是 |
| 防火牆 | 關閉 | 關閉 |
| selinux | 關閉 | 關閉 |
| jdk | 安裝 | 安裝 |
| ssh免密碼登陸 | 是 | 是 |
| mysql數據庫 | 否 | 是 |
| 服務器內存 | 16G | 8G |

全部機器統一兩個路徑

mkdir -p /export/softwares/

mkdir -p /export/servers/

**兩臺機器更改主機名**

第一臺機器更改主機名

vim /etc/sysconfig/network

NETWORKING=yes

HOSTNAME=node01.hadoop.com

第二臺機器更改主機名

vim /etc/sysconfig/network

NETWORKING=yes

HOSTNAME=node02.hadoop.com

**更改主機名與IP地址的映射**

兩臺機器更改hosts文件

vim /etc/hosts

192.168.52.100 node01.hadoop.com

192.168.52.110 node02.hadoop.com

**兩臺機器關閉防火牆**

service iptables stop

chkconfig iptables off

**兩臺機器關閉selinux**

vim /etc/selinux/config

SELINUX=disabled

![](jiqun-images/151.png)

**兩臺機器安裝jdk**

將咱們的jdk的壓縮包上傳到node01.hadoop.com的/export/softwares路徑下

cd /export/softwares/

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

配置環境變量

vim /etc/profile

export JAVA_HOME=/export/servers/jdk1.8.0_141

export PATH=:$JAVA_HOME/bin:$PATH

source /etc/profile

第二臺機器一樣安裝jdk便可

**兩臺機器實現SSH免密碼登陸**

**第一步：兩臺器生成公鑰與私鑰**

兩臺機器上面執行如下命令，而後按下三個回車鍵便可生成公鑰與私鑰

ssh-keygen -t rsa

![](jiqun-images/152.png)

**第二步：兩臺機器將公鑰拷貝到同一個文件當中去**

兩臺機器執行如下命令

ssh-copy-id node01.hadoop.com

**第三步：拷貝authorized_keys到其餘機器**

第一臺機器上將authorized_keys拷貝到第二臺機器

scp /root/.ssh/authorized_keys node02.hadoop.com:/root/.ssh/

**第二臺機器安裝mysql數據庫**

經過yum源，在線安裝mysql

yum install mysql mysql-server mysql-devel

/etc/init.d/mysqld start

/usr/bin/mysql_secure_installation

進入mysql客戶端執行如下命令

grant all privileges on *.* to 'root'@'%' identified by '123456' with grant option;

flush privileges;

![](jiqun-images/153.png)

**解除linux系統打開文件最大數量的限制**

兩臺機器都須要執行

vi /etc/security/limits.conf

添加如下內容

. soft noproc 11000

. hard noproc 11000

. soft nofile 65535

. hard nofile 65535

**設置linux交換區內存**

兩臺機器都要執行

執行命令

echo 10 > /proc/sys/vm/swappiness

並編輯文件sysctl.conf：

vim /etc/sysctl.conf

添加或修改

vm.swappiness = 0

兩臺機器都要執行：

echo never > /sys/kernel/mm/transparent_hugepage/defrag

echo never > /sys/kernel/mm/transparent_hugepage/enabled

並編輯文件rc.local ：

vim /etc/rc.local

echo never > /sys/kernel/mm/transparent_hugepage/defrag

echo never > /sys/kernel/mm/transparent_hugepage/enabled

![](jiqun-images/154.png)

**兩臺機器時鐘同步**

兩臺機器須要進行時鐘同步操做，保證兩臺機器時間相同

crontab –e

*/1 * * * * /usr/sbin/ntpdate ntp4.aliyun.com;

**兩臺服務器關閉防火牆**

service iptables stop

chkconfig iptables off

服務器關機重啓

clouderaManager安裝資源下載

**第一步：下載安裝資源並上傳到服務器**

咱們這裏安裝CM5.14.0這個版本，須要下載如下這些資源，一共是四個文件便可

下載cm5的壓縮包

下載地址：http://archive.cloudera.com/cm5/cm/5/

具體文件地址：

http://archive.cloudera.com/cm5/cm/5/cloudera-manager-el6-cm5.14.0_x86_64.tar.gz

下載cm5的parcel包

下載地址：

http://archive.cloudera.com/cdh5/parcels/

第一個文件具體下載地址：

http://archive.cloudera.com/cdh5/parcels/5.14.0/CDH-5.14.0-1.cdh5.14.0.p0.24-el6.parcel

第二個文件具體下載地址：

http://archive.cloudera.com/cdh5/parcels/5.14.0/CDH-5.14.0-1.cdh5.14.0.p0.24-el6.parcel.sha1

第三個文件具體下載地址：

http://archive.cloudera.com/cdh5/parcels/5.14.0/manifest.json

將這四個安裝包都上傳到第一臺機器的/export/softwares路徑下

![](jiqun-images/155.png)

**第二步：解壓壓縮包到指定路徑**

解壓CM安裝包到/opt路徑下去

cd /export/softwares

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

**第三步：將咱們的parcel包的三個文件拷貝到對應路徑**

將咱們的parcel包含三個文件，拷貝到/opt/cloudera/parcel-repo路徑下面去，並記得有個文件須要重命名

cd /export/softwares/

cp CDH-5.14.0-1.cdh5.14.0.p0.24-el6.parcel CDH-5.14.0-1.cdh5.14.0.p0.24-el6.parcel.sha1 manifest.json /opt/cloudera/parcel-repo/

![](jiqun-images/156.png)

重命名標黃的這個文件

cd /opt/cloudera/parcel-repo/

mv CDH-5.14.0-1.cdh5.14.0.p0.24-el6.parcel.sha1 CDH-5.14.0-1.cdh5.14.0.p0.24-el6.parcel.sha

![](jiqun-images/157.png)

**第四步：全部節點添加普通用戶並給與sudo權限**

在node01機器上面添加普通用戶並賦予sudo權限

執行如下命令建立普通用戶cloudera-scm

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

賦予cloudera-scm普通用戶的sudo權限

visudo

cloudera-scm ALL=(ALL) NOPASSWD: ALL

![](jiqun-images/158.png)

**第五步：更改主節點的配置文件**

node01機器上面更改配置文件

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

server_host=node01.hadoop.com

![](jiqun-images/159.png)

**第六步：將/opt目錄下的安裝包發放到其餘機器**

將第一臺機器的安裝包發放到其餘機器

cd /opt

scp -r cloudera/ cm-5.14.0/ node02.hadoop.com:/opt

**第七步：建立一些數據庫備用**

node02機器上面建立數據庫

hive 數據庫

create database hive DEFAULT CHARSET utf8 COLLATE utf8_general_ci;

集羣監控數據庫

create database amon DEFAULT CHARSET utf8 COLLATE utf8_general_ci;

hue 數據庫

create database hue DEFAULT CHARSET utf8 COLLATE utf8_general_ci;

oozie 數據庫

create database oozie DEFAULT CHARSET utf8 COLLATE utf8_general_ci;

**第八步：準備數據庫鏈接的驅動包**

在全部機器上面都準備一份數據庫的鏈接驅動jar包放到/usr/share/java路徑下

準備一份mysql的驅動鏈接包，放到/usr/share/java路徑下去

cd /export/softwares/

wget https://dev.mysql.com/get/Downloads/Connector-J/mysql-connector-java-5.1.45.tar.gz

tar -zxvf mysql-connector-java-5.1.45.tar.gz

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

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

拷貝驅動包到第二臺機器

cd /usr/share/java

scp mysql-connector-java.jar node02.hadoop.com:$PWD

**第九步：爲clouderaManager建立數據庫**

node01服務器執行

/opt/cm-5.14.0/share/cmf/schema/scm_prepare_database.sh mysql -hnode02.hadoop.com -uroot -p123456 --scm-host node01.hadoop.com scm root 123456

命令說明：/**opt**/**cm**-5.14.0/share/cmf/schema/scm_prepare_database.**sh** 數據庫類型 -h數據庫主機 –u數據庫用戶名 –p數據庫密碼 --scm-host **cm**主機數據庫名稱用戶名密碼

![](jiqun-images/160.png)

**第十步：啓動服務**

主節點啓動clouderaManager Server與ClouderaManager agent服務

/opt/cm-5.14.0/etc/init.d/cloudera-scm-server start

/opt/cm-5.14.0/etc/init.d/cloudera-scm-agent start

![](jiqun-images/161.png)

從節點node02啓動ClouderaManager agent服務

/opt/cm-5.14.0/etc/init.d/cloudera-scm-agent start

**第十一步：瀏覽器頁面訪問**

http://node01:7180/cmf/login

默認用戶名admin

密碼 admin

## Hue

1、編譯

```shell
#1-下載安裝包並解壓
tar -zxvf hue-3.9.0-cdh5.14.0.tar.gz -C /export/servers/

#2-安裝依賴
yum install ant asciidoc cyrus-sasl-devel cyrus-sasl-gssapi cyrus-sasl-plain gcc gcc-c++ krb5-devel libffi-devel libxml2-devel libxslt-devel make mysql mysql-devel openldap-devel python-devel sqlite-devel gmp-devel -y

#3-卸載安裝的jdk1.7
java -version
rpm -qa | grep java
rpm -e --nodeps java-1.7.0-openjdk-1.7.0.231-2.6.19.1.el6_10.x86_64 java-1.5.0-gcj-1.5.0.0-29.1.el6.x86_64 tzdata-java-2019b-2.el6.noarch java-1.7.0-openjdk-devel-1.7.0.231-2.6.19.1.el6_10.x86_64 java_cup-0.10k-5.el6.x86_64

#4-修改hue的配置文件:$HUE_HOME/desktop/conf/hue.ini
--hue的配置
21行： secret_key=qwertasdfgyuiophjkl
28行： http_host=hpsk.bigdata01.com
32行： is_hue_4=true
41行： time_zone=Asia/Shanghai
68行： server_user=root
69行： server_group=root
72行： default_user=root
75行： default_hdfs_superuser=root
--Hue存儲信息數據庫的配置
595行： engine=mysql
596行： host=hpsk.bigdata03.com
597行： port=3306
598行： user=root
599行： password=123456
605行： name=hue
--MySQL中建立hue數據庫：第三臺機器
mysql -uroot -p
create database hue default character set utf8 default collate utf8_general_ci;

#5-編譯
cd /export/servers/hue-3.9.0-cdh5.14.0
make apps

#6-添加Linux中的hue用戶
useradd hue
passwd hue
```

**一、Hue的介紹**

HUE=**Hadoop User Experience**

Hue是一個開源的Apache Hadoop UI系統，由Cloudera Desktop演化而來，最後Cloudera公司將其貢獻給Apache基金會的Hadoop社區，它是基於Python Web框架Django實現的。

經過使用Hue咱們能夠在瀏覽器端的Web控制檯上與Hadoop集羣進行交互來分析處理數據，例如操做HDFS上的數據，運行MapReduce Job，執行Hive的SQL語句，瀏覽HBase數據庫等等。

**HUE連接**

· Site: http://gethue.com/

· Github: https://github.com/cloudera/hue

· Reviews: [https://review.cloudera.org](https://review.cloudera.org/)

**Hue的架構**

![](jiqun-images/162.png)

**核心功能**

· SQL編輯器，支持Hive, Impala, MySQL, Oracle, PostgreSQL, SparkSQL, Solr SQL, Phoenix…

· 搜索引擎Solr的各類圖表

· Spark和Hadoop的友好界面支持

· 支持調度系統Apache Oozie，可進行workflow的編輯、查看

HUE提供的這些功能相比Hadoop生態各組件提供的界面更加友好，可是一些須要debug的場景可能仍是須要使用原生系統才能更加深刻的找到錯誤的緣由。

HUE中查看Oozie workflow時，也能夠很方便的看到整個workflow的DAG圖，不過在最新版本中已經將DAG圖去掉了，只能看到workflow中的action列表和他們之間的跳轉關係，想要看DAG圖的仍然能夠使用oozie原生的界面系統查看。

1，訪問HDFS和文件瀏覽

2，經過web調試和開發hive以及數據結果展現

3，查詢solr和結果展現，報表生成

4，經過web調試和開發impala交互式SQL Query

5，spark調試和開發

7，oozie任務的開發，監控，和工做流協調調度

8，Hbase數據查詢和修改，數據展現

9，Hive的元數據（metastore）查詢

10，MapReduce任務進度查看，日誌追蹤

11，建立和提交MapReduce，Streaming，Java job任務

12，Sqoop2的開發和調試

13，Zookeeper的瀏覽和編輯

14，數據庫（MySQL，PostGres，SQlite，Oracle）的查詢和展現

一句話總結：Hue是一個友好的界面集成框架，能夠集成咱們各類學習過的以及將要學習的框架，一個界面就能夠作到查看以及執行全部的框架

**二、Hue的安裝**

Hue的安裝支持多種方式，包括rpm包的方式進行安裝，tar.gz包的方式進行安裝以及cloudera manager的方式來進行安裝等，咱們這裏使用tar.gz包的方式來記性安裝

**第一步：下載Hue的壓縮包並上傳到linux解壓**

Hue的壓縮包的下載地址：

http://archive.cloudera.com/cdh5/cdh/5/

咱們這裏使用的是CDH5.14.0這個對應的版本，具體下載地址爲

http://archive.cloudera.com/cdh5/cdh/5/hue-3.9.0-cdh5.14.0.tar.gz

下載而後上傳到linux系統，而後進行解壓

cd /export/softwares/

tar -zxvf hue-3.9.0-cdh5.14.0.tar.gz -C ../servers/

**第二步：編譯安裝啓動**

**2.一、linux系統安裝依賴包：**

聯網安裝各類必須的依賴包

yum install ant asciidoc cyrus-sasl-devel cyrus-sasl-gssapi cyrus-sasl-plain gcc gcc-c++ krb5-devel libffi-devel libxml2-devel libxslt-devel make mysql mysql-devel openldap-devel python-devel sqlite-devel gmp-devel

**2.二、開始配置Hue**

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

vim hue.ini

```shell
#通用配置
[desktop]
secret_key=jFE93j;2[290-eiw.KEiwN2s3['d;/.q[eIW^y#e=+Iei*@Mn<qW5o
http_host=node03.hadoop.com
is_hue_4=true
time_zone=Asia/Shanghai
server_user=root
server_group=root
default_user=root
default_hdfs_superuser=root
#配置使用mysql做爲hue的存儲數據庫,大概在hue.ini的587行左右
[[database]]
engine=mysql
host=node03.hadoop.com
port=3306
user=root
password=123456
name=hue
```

**2.三、建立mysql數據庫**

建立hue數據庫

create database hue default character set utf8 default collate utf8_general_ci;

注意：實際工做中，還須要爲hue這個數據庫建立對應的用戶，並分配權限，我這就不建立了，因此下面這一步不用執行了

grant all on hue.* to 'hue'@'%' identified by 'hue';

**2.四、準備進行編譯**

```
cd /export/servers/hue-3.9.0-cdh5.14.0
make apps
```

**2.五、linux系統添加普通用戶hue**

```
useradd hue
passwd hue
```

**2.六、啓動hue進程**

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

**2.七、頁面訪問**

http://node03:8888

第一次訪問的時候，須要設置管理員用戶和密碼

咱們這裏的管理員的用戶名與密碼儘可能保持與咱們安裝hadoop的用戶名和密碼一致，

咱們安裝hadoop的用戶名與密碼分別是root 123456

初次登陸使用root用戶，密碼爲123456

![](jiqun-images/163.png)

進入以後發現咱們的hue頁面報錯了，這個錯誤主要是由於hive的緣由，由於咱們的hue與hive集成的時候出錯了，因此咱們須要配置咱們的hue與hive進行集成，接下里就看看咱們的hue與hive以及hadoop如何進行集成

**3.hue與其餘框架的集成**

**3.一、hue與hadoop的HDFS以及yarn集成**

**第一步：更改全部hadoop節點的core-site.xml配置**

記得更改完core-site.xml以後必定要重啓hdfs與yarn集羣

```xml
<property>
<name>hadoop.proxyuser.root.hosts</name>
<value>*</value>
</property>
<property>
<name>hadoop.proxyuser.root.groups</name>
<value>*</value>
</property>
```

**第二步：更改全部hadoop節點的hdfs-site.xml**

```xml
<property>
<name>dfs.webhdfs.enabled</name>
<value>true</value>
</property>
```

**第三步：重啓hadoop集羣**

在node01機器上面執行如下命令

```shell
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
```

**第四步：中止hue的服務，並繼續配置hue.ini**

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

vim hue.ini

```shell
配置咱們的hue與hdfs集成
[[hdfs_clusters]]
[[[default]]]
fs_defaultfs=hdfs://node01.hadoop.com:8020
webhdfs_url=http://node01.hadoop.com:50070/webhdfs/v1
hadoop_hdfs_home=/export/servers/hadoop-2.6.0-cdh5.14.0
hadoop_bin=/export/servers/hadoop-2.6.0-cdh5.14.0/bin
hadoop_conf_dir=/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop
配置咱們的hue與yarn集成
[[yarn_clusters]]
[[[default]]]
resourcemanager_host=node01
resourcemanager_port=8032
submit_to=True
resourcemanager_api_url=http://node01:8088
history_server_api_url=http//node01:19888
```

**3.二、配置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.com
hive_server_port=10000
hive_conf_dir=/export/servers/hive-1.1.0-cdh5.14.0/conf
server_conn_timeout=120
auth_username=root
auth_password=12345
[metastore]
#容許使用hive建立數據庫表等操做
enable_new_create_table=true

#啓動hive的metastore服務
去node03機器上啓動hive的metastore以及hiveserver2服務
cd /export/servers/hive-1.1.0-cdh5.14.0
nohup bin/hive --service metastore &
nohup bin/hive --service hiveserver2 &
從新啓動hue，而後就能夠經過瀏覽器頁面操做hive了
```

**3.三、配置hue與impala的集成**

中止hue的服務進程

修改hue.ini配置文件

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

**3.四、配置hue與mysql的集成**

找到databases 這個選項，將這個選項下面的mysql註釋給打開，而後配置mysql便可,大概在1547

```shell
[[[mysql]]]
nice_name="My SQL DB"
engine=mysql
host=node03.hadoop.com
port=3306
user=root
password=123456
```

**3.五、從新啓動hue的服務**

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

build/env/bin/supervisor

**3.六、解決hive以及impala執行權限不足的問題**

在咱們hive當中執行任意的查詢，只要是須要跑MR的程序，就會報錯，發現權限不夠的異常，具體詳細信息以下：

```shell
INFO : Compiling command(queryId=root_20180625191616_d02efd23-2322-4f3d-9cb3-fc3a06ff4ce0): select count(1) from mystu
INFO : Semantic Analysis Completed
INFO : Returning Hive schema: Schema(fieldSchemas:[FieldSchema(name:_c0, type:bigint, comment:null)], properties:null)
INFO : Completed compiling command(queryId=root_20180625191616_d02efd23-2322-4f3d-9cb3-fc3a06ff4ce0); Time taken: 0.065 seconds
INFO : Concurrency mode is disabled, not creating a lock manager
INFO : Executing command(queryId=root_20180625191616_d02efd23-2322-4f3d-9cb3-fc3a06ff4ce0): select count(1) from mystu
INFO : Query ID = root_20180625191616_d02efd23-2322-4f3d-9cb3-fc3a06ff4ce0
INFO : Total jobs = 1
INFO : Launching Job 1 out of 1
INFO : Starting task [Stage-1:MAPRED] in serial mode
INFO : Number of reduce tasks determined at compile time: 1
INFO : In order to change the average load for a reducer (in bytes):
INFO : set hive.exec.reducers.bytes.per.reducer=<number>
INFO : In order to limit the maximum number of reducers:
INFO : set hive.exec.reducers.max=<number>
INFO : In order to set a constant number of reducers:
INFO : set mapreduce.job.reduces=<number>
ERROR : Job Submission failed with exception 'org.apache.hadoop.security.AccessControlException(Permission denied: user=admin, access=EXECUTE, inode="/tmp":root:supergroup:drwxrwx---
```

咱們須要給hdfs上面的幾個目錄執行權限便可

hdfs dfs -chmod o+x /tmp

hdfs dfs -chmod o+x /tmp/hadoop-yarn

hdfs dfs -chmod o+x /tmp/hadoop-yarn/staging

![](jiqun-images/164.png)

或者咱們能夠這樣執行

hdfs dfs -chmod -R o+x /tmp

能夠將/tmp目錄下全部的文件及文件夾都賦予權限

繼續執行hive的任務就不會報錯了

# 大數據組件

## hadoop

啓動服務
第一次啓動必定要格式化：NameNode在哪臺就在哪臺作
bin/hdfs namenode -format
-》啓動hdfs（在NameNode的機器上執行）
sbin/start-dfs.sh
-》啓動yarn（在ResourceManager那臺機器上執行）
sbin/start-yarn.sh

**apache hadoop三種架構介紹（standAlone，僞分佈，分佈式環境介紹以及安裝）**

hadoop 文檔

http://hadoop.apache.org/docs/

**StandAlone集羣搭建**

**第一步：下載apache hadoop並上傳到服務器**

下載連接：

http://archive.apache.org/dist/hadoop/common/hadoop-2.7.5/hadoop-2.7.5.tar.gz

解壓命令

cd /export/softwares

tar -zxvf hadoop-2.7.5.tar.gz -C ../servers/

![](jiqun-images/1565531349733.png)

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

```xml
修改core-site.xml
第一臺機器執行如下命令
cd /export/servers/hadoop-2.7.5/etc/hadoop
vim core-site.xml
<configuration>
<property>
<name>fs.default.name</name>
<value>hdfs://192.168.52.100:8020</value>
</property>
<property>
<name>hadoop.tmp.dir</name>
<value>/export/servers/hadoop-2.7.5/hadoopDatas/tempDatas</value>
</property>

<property>
<name>io.file.buffer.size</name>
<value>4096</value>
</property>

<property>
<name>fs.trash.interval</name>
<value>10080</value>
</property>
</configuration>

修改hdfs-site.xml
第一臺機器執行如下命令
cd /export/servers/hadoop-2.7.5/etc/hadoop
vim hdfs-site.xml
<configuration>



<property>
<name>dfs.namenode.secondary.http-address</name>
<value>hadoop1:50090</value>
</property>

<property>
<name>dfs.namenode.http-address</name>
<value>hadoop01:50070</value>
</property>
<property>
<name>dfs.namenode.name.dir</name>
<value>file:///export/servers/hadoop-2.7.5/hadoopDatas/namenodeDatas,file:///export/servers/hadoop-2.7.5/hadoopDatas/namenodeDatas2</value>
</property>

<property>
<name>dfs.datanode.data.dir</name>
<value>file:///export/servers/hadoop-2.7.5/hadoopDatas/datanodeDatas,file:///export/servers/hadoop-2.7.5/hadoopDatas/datanodeDatas2</value>
</property>

<property>
<name>dfs.namenode.edits.dir</name>
<value>file:///export/servers/hadoop-2.7.5/hadoopDatas/nn/edits</value>
</property>

<property>
<name>dfs.namenode.checkpoint.dir</name>
<value>file:///export/servers/hadoop-2.7.5/hadoopDatas/snn/name</value>
</property>
<property>
<name>dfs.namenode.checkpoint.edits.dir</name>
<value>file:///export/servers/hadoop-2.7.5/hadoopDatas/dfs/snn/edits</value>
</property>

<property>
<name>dfs.replication</name>
<value>3</value>
</property>

<property>
<name>dfs.permissions</name>
<value>false</value>
</property>

<property>
<name>dfs.blocksize</name>
<value>134217728</value>
</property>
</configuration>

修改hadoop-env.sh
第一臺機器執行如下命令
cd /export/servers/hadoop-2.7.5/etc/hadoop
vim hadoop-env.sh
vim hadoop-env.sh
export JAVA_HOME=/export/servers/jdk1.8.0_141

修改mapred-site.xml
第一臺機器執行如下命令
cd /export/servers/hadoop-2.7.5/etc/hadoop
vim mapred-site.xml
<configuration>
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>

<property>
<name>mapreduce.job.ubertask.enable</name>
<value>true</value>
</property>

<property>
<name>mapreduce.jobhistory.address</name>
<value>node01:10020</value>
</property>

<property>
<name>mapreduce.jobhistory.webapp.address</name>
<value>node01:19888</value>
</property>
</configuration>

修改yarn-site.xml
第一臺機器執行如下命令
cd /export/servers/hadoop-2.7.5/etc/hadoop
vim yarn-site.xml
<configuration>
<property>
<name>yarn.resourcemanager.hostname</name>
<value>node01</value>
</property>
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>

<property>
<name>yarn.log-aggregation-enable</name>
<value>true</value>
</property>
<property>
<name>yarn.log-aggregation.retain-seconds</name>
<value>604800</value>
</property>
</configuration>

修改mapred-env.sh
第一臺機器執行如下命令
cd /export/servers/hadoop-2.7.5/etc/hadoop
vim mapred-env.sh
export JAVA_HOME=/export/servers/jdk1.8.0_141
修改slaves
第一臺機器執行如下命令
cd /export/servers/hadoop-2.7.5/etc/hadoop
vim slaves
localhost
```

**第三步：啓動集羣**

要啓動 Hadoop 集羣，須要啓動 HDFS 和 YARN 兩個模塊。
注意：首次啓動 HDFS 時，必須對其進行格式化操做。本質上是一些清理和
準備工做，由於此時的 HDFS 在物理上仍是不存在的。
hdfs namenode -format 或者 hadoop namenode –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/hdfs namenode -format

sbin/start-dfs.sh

sbin/start-yarn.sh

sbin/mr-jobhistory-daemon.sh start historyserver

三個端口查看界面

[http://node01:50070/explorer.html#/](#/) 查看hdfs

http://node01:8088/cluster 查看yarn集羣

http://node01:19888/jobhistory 查看歷史完成的任務

**5.二、僞分佈式環境搭建（適用於學習測試開發集羣模式）**

服務規劃

| 服務器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.5
sbin/stop-dfs.sh
sbin/stop-yarn.sh
sbin/mr-jobhistory-daemon.sh stop historyserver

刪除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/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

修改slaves文件，而後將安裝包發送到其餘機器，從新啓動集羣便可
第一臺機器執行如下命令
cd /export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop
vim slaves
node01
node02
node03

安裝包的分發
第一臺機器執行如下命令
cd /export/servers/
scp -r hadoop-2.6.0-cdh5.14.0 node02:$PWD
scp -r hadoop-2.6.0-cdh5.14.0 node03:$PWD

啓動集羣
第一臺機器執行如下命令
cd /export/servers/hadoop-2.6.0-cdh5.14.0
bin/hdfs namenode -format
sbin/start-dfs.sh
sbin/start-yarn.sh
sbin/mr-jobhistory-daemon.sh start historyserver
```

**5.三、分佈式環境搭建（適用於工做當中正式環境搭建）**

使用徹底分佈式，實現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/softwares

tar -zxvf hadoop-2.7.5.tar.gz -C ../servers/

**配置文件的修改**

**修改core-site.xml**

第一臺機器執行如下命令

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

vim core-site.xml

```xml
<configuration>

<property>
<name>ha.zookeeper.quorum</name>
<value>node01:2181,node02:2181,node03:2181</value>
</property>

<name>fs.defaultFS</name>
<value>hdfs://ns</value>
</property>

<property>
<name>hadoop.tmp.dir</name>
<value>/export/servers/hadoop-2.7.5/data/tmp</value>

</property>

<property>
<name>fs.trash.interval</name>
<value>10080</value>
</property>
</configuration>
```

**修改hdfs-site.xml**

第一臺機器執行如下命令

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

vim hdfs-site.xml

```xml
<configuration>

<property>
<name>dfs.nameservices</name>
<value>ns</value>
</property>

<property>
<name>dfs.ha.namenodes.ns</name>
<value>nn1,nn2</value>
</property>

<property>
<name>dfs.namenode.rpc-address.ns.nn1</name>
<value>node01:8020</value>
</property>

<property>
<name>dfs.namenode.rpc-address.ns.nn2</name>
<value>node02:8020</value>
</property>

<property>
<name>dfs.namenode.servicerpc-address.ns.nn1</name>
<value>node01:8022</value>
</property>

<property>
<name>dfs.namenode.servicerpc-address.ns.nn2</name>
<value>node02:8022</value>
</property>

<property>
<name>dfs.namenode.http-address.ns.nn1</name>
<value>node01:50070</value>
</property>

<property>
<name>dfs.namenode.http-address.ns.nn2</name>
<value>node02:50070</value>
</property>

<property>
<name>dfs.namenode.shared.edits.dir</name>
<value>qjournal://node01:8485;node02:8485;node03:8485/ns1</value>
</property>



<property>
<name>dfs.client.failover.proxy.provider.ns</name>
<value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
</property>

<property>
<name>dfs.ha.fencing.methods</name>
<value>sshfence</value>
</property>

<property>
<name>dfs.ha.fencing.ssh.private-key-files</name>
<value>/root/.ssh/id_rsa</value>
</property>

<property>
<name>dfs.journalnode.edits.dir</name>
<value>/export/servers/hadoop-2.7.5/data/dfs/jn</value>
</property>

<property>
<name>dfs.ha.automatic-failover.enabled</name>
<value>true</value>
</property>

<property>
<name>dfs.namenode.name.dir</name>
<value>file:///export/servers/hadoop-2.7.5/data/dfs/nn/name</value>
</property>



<property>
<name>dfs.namenode.edits.dir</name>
<value>file:///export/servers/hadoop-2.7.5/data/dfs/nn/edits</value>
</property>

<property>
<name>dfs.datanode.data.dir</name>
<value>file:///export/servers/hadoop-2.7.5/data/dfs/dn</value>
</property>

<property>
<name>dfs.permissions</name>
<value>false</value>
</property>

<property>
<name>dfs.blocksize</name>
<value>134217728</value>
</property>

</configuration>
```

**修改yarn-site.xml，注意node03與node02配置不一樣**

第一臺機器執行如下命令

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

vim yarn-site.xml

```xml
<configuration>

<property>
<name>yarn.log-aggregation-enable</name>
<value>true</value>
</property>

<property>
<name>yarn.resourcemanager.ha.enabled</name>
<value>true</value>
</property>

<property>
<name>yarn.resourcemanager.cluster-id</name>
<value>mycluster</value>
</property>

<property>
<name>yarn.resourcemanager.ha.rm-ids</name>
<value>rm1,rm2</value>
</property>

<property>
<name>yarn.resourcemanager.hostname.rm1</name>
<value>node03</value>
</property>

<property>
<name>yarn.resourcemanager.hostname.rm2</name>
<value>node02</value>
</property>

<property>
<name>yarn.resourcemanager.address.rm1</name>
<value>node03:8032</value>
</property>
<property>
<name>yarn.resourcemanager.scheduler.address.rm1</name>
<value>node03:8030</value>
</property>
<property>
<name>yarn.resourcemanager.resource-tracker.address.rm1</name>
<value>node03:8031</value>
</property>
<property>
<name>yarn.resourcemanager.admin.address.rm1</name>
<value>node03:8033</value>
</property>
<property>
<name>yarn.resourcemanager.webapp.address.rm1</name>
<value>node03:8088</value>
</property>

<property>
<name>yarn.resourcemanager.address.rm2</name>
<value>node02:8032</value>
</property>
<property>
<name>yarn.resourcemanager.scheduler.address.rm2</name>
<value>node02:8030</value>
</property>
<property>
<name>yarn.resourcemanager.resource-tracker.address.rm2</name>
<value>node02:8031</value>
</property>
<property>
<name>yarn.resourcemanager.admin.address.rm2</name>
<value>node02:8033</value>
</property>
<property>
<name>yarn.resourcemanager.webapp.address.rm2</name>
<value>node02:8088</value>
</property>

<property>
<name>yarn.resourcemanager.recovery.enabled</name>
<value>true</value>
</property>

<property>
<name>yarn.resourcemanager.ha.id</name>
<value>rm1</value>
<description>If we want to launch more than one RM in single node, we need this configuration</description>
</property>


<property>
<name>yarn.resourcemanager.store.class</name>
<value>org.apache.hadoop.yarn.server.resourcemanager.recovery.ZKRMStateStore</value>
</property>
<property>
<name>yarn.resourcemanager.zk-address</name>
<value>node02:2181,node03:2181,node01:2181</value>
<description>For multiple zk services, separate them with comma</description>
</property>

<property>
<name>yarn.resourcemanager.ha.automatic-failover.enabled</name>
<value>true</value>
<description>Enable automatic failover; By default, it is enabled only when HA is enabled.</description>
</property>
<property>
<name>yarn.client.failover-proxy-provider</name>
<value>org.apache.hadoop.yarn.client.ConfiguredRMFailoverProxyProvider</value>
</property>

<property>
<name>yarn.nodemanager.resource.cpu-vcores</name>
<value>4</value>
</property>

<property>
<name>yarn.nodemanager.resource.memory-mb</name>
<value>512</value>
</property>

<property>
<name>yarn.scheduler.minimum-allocation-mb</name>
<value>512</value>
</property>

<property>
<name>yarn.scheduler.maximum-allocation-mb</name>
<value>512</value>
</property>

<property>
<name>yarn.log-aggregation.retain-seconds</name>
<value>2592000</value>
</property>

<property>
<name>yarn.nodemanager.log.retain-seconds</name>
<value>604800</value>
</property>

<property>
<name>yarn.nodemanager.log-aggregation.compression-type</name>
<value>gz</value>
</property>

<property>
<name>yarn.nodemanager.local-dirs</name>
<value>/export/servers/hadoop-2.7.5/yarn/local</value>
</property>

<property>
<name>yarn.resourcemanager.max-completed-applications</name>
<value>1000</value>
</property>

<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>

<property>
<name>yarn.resourcemanager.connect.retry-interval.ms</name>
<value>2000</value>
</property>
</configuration>
```

**修改mapred-site.xml**

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

vim mapred-site.xml

```xml
<configuration>

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

<property>
<name>mapreduce.jobhistory.address</name>
<value>node03:10020</value>
</property>

<property>
<name>mapreduce.jobhistory.webapp.address</name>
<value>node03:19888</value>
</property>

<property>
<name>mapreduce.jobtracker.system.dir</name>
<value>/export/servers/hadoop-2.7.5/data/system/jobtracker</value>
</property>

<property>
<name>mapreduce.map.memory.mb</name>
<value>1024</value>
</property>

<property>
<name>mapreduce.reduce.memory.mb</name>
<value>1024</value>
</property>

<property>
<name>mapreduce.task.io.sort.mb</name>
<value>100</value>
</property>


<property>
<name>mapreduce.task.io.sort.factor</name>
<value>10</value>
</property>

<property>
<name>mapreduce.reduce.shuffle.parallelcopies</name>
<value>25</value>

</property>
<property>
<name>yarn.app.mapreduce.am.command-opts</name>
<value>-Xmx1024m</value>
</property>

<property>
<name>yarn.app.mapreduce.am.resource.mb</name>
<value>1536</value>
</property>

<property>
<name>mapreduce.cluster.local.dir</name>
<value>/export/servers/hadoop-2.7.5/data/system/local</value>
</property>
</configuration>
```

**修改slaves**

第一臺機器執行如下命令

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

vim slaves

```
node01
node02
node03
```

**修改hadoop-env.sh**

第一臺機器執行如下命令

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

vim hadoop-env.sh

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

**集羣啓動過程**

將第一臺機器的安裝包發送到其餘機器上

第一臺機器執行如下命令：

```shell
cd /export/servers

scp -r hadoop-2.7.5/ node02:$PWD

scp -r hadoop-2.7.5/ node03:$PWD
```

三臺機器上共同建立目錄

三臺機器執行如下命令

```shell
mkdir -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

第二臺機器執行如下命令

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

vim yarn-site.xml

```xml
<!--在node3上配置rm1,在node2上配置rm2,注意：通常都喜歡把配置好的文件遠程複製到其它機器上，

但這個在YARN的另外一個機器上必定要修改，其餘機器上不配置此項

注意咱們如今有兩個resourceManager 第三臺是rm1 第二臺是rm2

這個配置必定要記得去node02上面改好

<property>
<name>yarn.resourcemanager.ha.id</name>
<value>rm2</value>
<description>If we want to launch more than one RM in single node, we need this configuration</description>
</property>

```

**啓動HDFS過程**

```shell
node01機器執行如下命令

cd /export/servers/hadoop-2.7.5

bin/hdfs zkfc -formatZK

sbin/hadoop-daemons.sh start journalnode

bin/hdfs namenode -format

bin/hdfs namenode -initializeSharedEdits -force

sbin/start-dfs.sh

node02上面執行

cd /export/servers/hadoop-2.7.5

bin/hdfs namenode -bootstrapStandby

sbin/hadoop-daemon.sh start namenode
```

**啓動yarn過程**

```shell
node03上面執行

cd /export/servers/hadoop-2.7.5

sbin/start-yarn.sh

node02上執行

cd /export/servers/hadoop-2.7.5

sbin/start-yarn.sh
```

**查看resourceManager狀態**

```shell
node03上面執行

cd /export/servers/hadoop-2.7.5

bin/yarn rmadmin -getServiceState rm1

node02上面執行

cd /export/servers/hadoop-2.7.5

bin/yarn rmadmin -getServiceState rm2
```

**node03啓動jobHistory**

```shell
node03機器執行如下命令啓動jobHistory

cd /export/servers/hadoop-2.7.5

sbin/mr-jobhistory-daemon.sh start historyserver
```

**hdfs狀態查看**

node01機器查看hdfs狀態

[http://192.168.52.100:50070/dfshealth.html#tab-overview](#tab-overview)

node02機器查看hdfs狀態

[http://192.168.52.110:50070/dfshealth.html#tab-overview](#tab-overview)

**yarn集羣訪問查看**

http://node03:8088/cluster

**歷史任務瀏覽界面**

頁面訪問：

http://192.168.52.120:19888/jobhistory

--------------------------------------------------------------------------------------------------

3、hadoop環境的搭建

```shell
-》搭建模式
-》本地模式：MapReduce獨立運行（用於測試程序邏輯）
-》僞分佈式：1臺機器模擬分佈式
-》分佈式：多臺機器
-》搭建Apache的僞分佈式環境
-》安裝jdk
-》卸載自帶的
rpm -qa | grep java
rpm -e --nodeps java-1.7.0-openjdk-1.7.0.231-2.6.19.1.el6_10.x86_64 tzdata-java-2019b-2.el6.noarch java-1.7.0-openjdk-devel-1.7.0.231-2.6.19.1.el6_10.x86_64
-》安裝jdk
-》下載解壓
下載：名稱+版本.tar.gz
-》環境準備：
mkdir -p /export/software 放安裝包
mkdir -p /export/servers 安裝目錄
mkdir -p /export/datas 放臨時數據
-》解壓：
cd /export/softwares/
tar -zxvf hadoop-2.7.6.tar.gz -C ../servers/
-》認識一下目錄
cd /export/servers/hadoop-2.7.6
bin：二進制的客戶端命令
etc：存放配置文件
etc/conf
lib：存放jar包的目錄
sbin：存放管理類的腳本
啓動服務
share：hadoop全部的jar包
-》修改配置
配置環境變量
hadoop-env.sh
mapred-env.sh
yarn-env.sh
修改JAVA_HOME
```

```xml
自定義屬性配置
core-site.xml：hadoop的全局屬性

<property>
<name>fs.defaultFS</name>
<value>hdfs://hpsk.bigdata.com:8020</value>
</property>

<property>
<name>hadoop.tmp.dir</name>
<value>/export/servers/hadoop-2.7.6/datas</value>
</property>
hdfs-site.xml：配置hdfs的屬性

<property>
<name>dfs.permissions.enabled</name>
<value>false</value>
</property>

<property>
<name>dfs.replication</name>
<value>1</value>
</property>
mapred-site.xml：配置MapReduce的屬性
mv etc/hadoop/mapred-site.xml.template etc/hadoop/mapred-site.xml

<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
yarn-site.xml：配置YARN的屬性

<property>
<name>yarn.resourcemanager.hostname</name>
<value>hpsk.bigdata.com</value>
</property>

<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>

slaves：配置哪些機器是從節點
hpsk.bigdata.com

-》啓動服務
在第一次啓動Hdfs的時候，要格式化
bin/hdfs namenode -format
啓動NameNode和DataNode
sbin/hadoop-daemon.sh start namenode
sbin/hadoop-daemon.sh start datanode
啓動ResourceManager和NodeManager
sbin/yarn-daemon.sh start resourcemanager
sbin/yarn-daemon.sh start nodemanager
-》測試
http://192.168.134.200:50070 HDFS的webUI http
8020 通訊 rpc
http://192.168.134.200:8088 YARN的WebUI
8032 通訊 rpc
```

```
-》回顧：
大數據是什麼？應用有哪些？
大數據技術架構的業務流程：
數據生成：Java、js、ios
文件
數據庫
數據採集
Flume、sqoop、kafka、Logstash、datax
數據存儲：數據倉庫
HDFS => Hive/Hbase
數據計算
MapReduce、Spark、FLink
數據應用
數據分析
機器學習
NLP
Hadoop的發展以及應用：
HDFS
YARN+Mapreduce
Hadoop中組件架構：主從架構
HDFS:
NameNode
DataNode
YARN
ResourceManager
NodeManager
```

```
-》須要本身根據Hadoop源碼進行編譯，生成安裝包
1-若是你須要修改源碼
2-若是你要對工具進行二次開發
3-作一些自定義的環境配置
壓縮：snappy、lzo、lz4
```

4、分佈式集羣

```shell
-》搭建分佈式集羣
-》硬件環境
實體機
雲主機
-》軟件環境
-》Linux的配置
1-將三臺機器安裝好操做系統
2-配置各自的IP、主機名、映射/etc/hosts（每臺機器要有全部機器的映射）
192.168.134.221 hpsk.bigdata01.com
192.168.134.222 hpsk.bigdata02.com
192.168.134.223 hpsk.bigdata03.com
3-關閉防火牆和selinux
4-配置全部機器之間的免密鑰登陸
5-配置全部機器的時間同步
6-配置統一的用戶、以及目錄
普通用戶：hpsk
使用root用戶完成如下操做
useradd hpsk
passwd hpsk
visudo：會打開一個文件，該文件中能夠配置讓普通用戶越權執行命令
hpsk ALL=(root) NOPASSWD: ALL
之後若是要越權執行，在命令前面加上sudo
sudo mkdir -p /export/software
sudo mkdir -p /export/servers
sudo mkdir -p /export/datas
sudo chown -R hpsk:hpsk /export/software
sudo chown -R hpsk:hpsk /export/servers
sudo chown -R hpsk:hpsk /export/datas
-》安裝Hadoop
集羣設計：
node1 node2 node3
DataNode DataNode DataNode
NodeManager NodeManager NodeManager
NameNode NameNode(standby)
ResourceManager(standby) ResourceManager
```

```shell
-》三臺機器安裝jdk
-》選擇任意一臺機器安裝Hadoop
-》下載解壓
tar -zxvf hadoop-2.6.0-cdh5.14.0.tar.gz -C ../servers/
-》修改配置
#-env.sh：配置環境變量
hadoop-env.sh
mapred-env.sh
yarn-env.sh
JAVA_HOME:/export/servers/jdk1.8.0_141
#-site.xml：配置每一個組件的屬性
core-site.xml
hdfs-site.xml
mapred-site.xml
yarn-site.xml
slaves：全部從節點的地址
hpsk.bigdata01.com
hpsk.bigdata02.com
hpsk.bigdata03.com
-》分發
scp -r hadoop-2.6.0-cdh5.14.0 192.168.134.222:/export/servers/
scp -r hadoop-2.6.0-cdh5.14.0 192.168.134.223:/export/servers/
-》啓動服務
第一次啓動必定要格式化：NameNode在哪臺就在哪臺作
bin/hdfs namenode -format
-》啓動hdfs（在NameNode的機器上執行）
sbin/start-dfs.sh
-》啓動yarn（在ResourceManager那臺機器上執行）
sbin/start-yarn.sh
```

```
-》搭建高可用（Zookeeper，來實現兩個主節點）
Hadoop集羣：單點故障
||
Zookeeper：高可用

HA：高可用
```

```shell
進程：
NameNode：active
NameNode：Standby
zookeeper：奇數臺
datanode
zkfc：監控NameNode，而且實現NameNode與Zookeeper進行通訊
JournalNode：

-》將當前搭建好的分佈式環境，所有關機，保存快照

||
-》安裝Zookeeper
-》下載解壓
-》修改配置
-》分發
-》啓動服務
-》配置Hadoop
三臺機器都要建立：
mkdir journalnode
core-site.xml
hdfs-site.xml
yarn-site.xml
-》分發：
scp etc/hadoop/core-site.xml etc/hadoop/hdfs-site.xml etc/hadoop/yarn-site.xml 192.168.134.222:/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/
scp etc/hadoop/core-site.xml etc/hadoop/hdfs-site.xml etc/hadoop/yarn-site.xml 192.168.134.223:/export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/
記住修改第三臺機器的 yarn-site爲rm2
刪除第一臺機器yarn-site.xml中的yarn.resourcemanager.ha.id屬性
```

```shell
-》啓動過程
-》清空以前格式化的數據
三臺機器：rm -rf datas/*
-》啓動三臺機器的全部的journalnode
sbin/hadoop-daemon.sh start journalnode
-》執行格式化：第一臺
bin/hdfs namenode -format
-》將格式化後的數據發送給另一臺
scp -r datas 192.168.134.222:/export/servers/hadoop-2.6.0-cdh5.14.0
-》關聯Zookeeper，初始化Zookeeper
bin/hdfs zkfc -formatZK
-》關閉全部journalnode
sbin/hadoop-daemon.sh stop journalnode
-》直接啓動hdfs
sbin/start-dfs.sh
```

```
若是搭建集羣中出現了錯誤：
以.log結尾的就是日誌
tail -100f logs/
```

## hive

```shell
#一、解壓hive

cd /export/softwares

tar -zxvf hive-1.1.0-cdh5.14.0.tar.gz -C ../servers/

#二、直接啓動 bin/hive

cd ../servers/

cd hive-1.1.0-cdh5.14.0/

bin/hive

hive> create database mytest;

#使用mysql共享hive元數據

mysql數據庫的安裝（使用yum源進行安裝，強烈推薦）

#第一步：在線安裝mysql相關的軟件包

yum install mysql mysql-server mysql-devel

#第二步：啓動mysql的服務

/etc/init.d/mysqld start

#第三步：經過mysql安裝自帶腳本進行設置

/usr/bin/mysql_secure_installation

#第四步：進入mysql的客戶端而後進行受權

grant all privileges on *.* to 'root'@'%' identified by '123456' with grant option;

flush privileges;
```

![](jiqun-images/1565530248241.png)

修改hive的配置文件

1.修改hive-env.sh

```shell
#添加咱們的hadoop的環境變量

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

cp hive-env.sh.template hive-env.sh

vim hive-env.sh

#添加環境變量

HADOOP_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0

# Hive Configuration Directory can be controlled by:

export HIVE_CONF_DIR=/export/servers/hive-1.1.0-cdh5.14.0/conf
```

2.修改hive-site.xml

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

. vim hive-site.xml

```xml
<?xml-stylesheet type="text/xsl" href="configuration.xsl".>
<configuration>
<property>
<name>javax.jdo.option.ConnectionURL</name>
<value>jdbc:mysql://node03.hadoop.com:3306/hive?createDatabaseIfNotExist=true</value>
</property>
<property>
<name>javax.jdo.option.ConnectionDriverName</name>
<value>com.mysql.jdbc.Driver</value>
</property>
<property>
<name>javax.jdo.option.ConnectionUserName</name>
<value>root</value>
</property>
<property>
<name>javax.jdo.option.ConnectionPassword</name>
<value>123456</value>
</property>
<property>
<name>hive.cli.print.current.db</name>
<value>true</value>
</property>
<property>
<name>hive.cli.print.header</name>
<value>true</value>
</property>
<property>
<name>hive.server2.thrift.bind.host</name>
<value>node03.hadoop.com</value>
</property>

</configuration>
```

```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**

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

bin/hive

查看全部的數據庫

hive (default)> show databases;

建立一個數據庫

hive (default)> create database myhive;

使用該數據庫並建立數據庫表

hive (default)> use myhive;

hive (myhive)> create table test(id int,name string);
```

以上命令操做完成以後，必定要確認mysql裏面出來一個數據庫hive

**第二種交互方式：Hive JDBC服務**

```shell
#啓動hiveserver2服務

#前臺啓動

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

bin/hive --service hiveserver2

#後臺啓動

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

nohup bin/hive --service hiveserver2 &

#beeline鏈接hiveserver2

bin/beeline

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

![](jiqun-images/1565530678504.png)

注意：若是使用beeline方式鏈接hiveserver2，必定要保證hive在mysql當中的元數據庫已經建立成功，否則就會拒絕鏈接

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

使用 –e 參數來直接執行hql的語句

bin/hive -e "use myhive;select * from test;"

使用 –f 參數經過指定文本文件來執行hql的語句

vim hive.sql

use myhive;select * from test;

bin/hive -f hive.sql

更多參數參考如下

![](jiqun-images/1565530720831.png)

## flume

**第一步：下載解壓修改配置文件**

Flume的安裝很是簡單，只須要解壓便可，固然，前提是已有hadoop環境

上傳安裝包到數據源所在節點上

這裏咱們採用在第三臺機器來進行安裝

tar -zxvf flume-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

cp flume-env.sh.template flume-env.sh

vim flume-env.sh

export JAVA_HOME=/export/servers/jdk1.8.0_141

**第二步：開發配置文件**

根據數據採集的需求**配置採集方案**，描述在配置文件中(文件名可任意自定義)

配置咱們的網絡收集的配置文件

在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

\# 描述和配置source channel sink之間的鏈接關係

a1.sources.r1.channels = c1

a1.sinks.k1.channel = c1

**第三步：啓動配置文件**

**指定採集方案配置文件**，在相應的節點上啓動flume agent

先用一個最簡單的例子來測試一下程序環境是否正常

啓動agent去採集數據

bin/flume-ng agent -c conf -f conf/netcat-logger.conf -n a1 -Dflume.root.logger=INFO,console

-c conf 指定flume自身的配置文件所在目錄

-f conf/netcat-logger.con 指定咱們所描述的採集方案

-n a1 指定咱們這個agent的名字

**第四步：安裝telent準備測試**

在node02機器上面安裝telnet客戶端，用於模擬數據的發送

yum -y install telnet

telnet node03 44444 # 使用telnet模擬數據發送

![](jiqun-images/1568129979058.png)

![](jiqun-images/1568130053324.png)

```shell
-》安裝Flume：不是分佈式程序
flume-ng-1.6.0-cdh5.14.0.tar.gz
ng：next
og:orignal
-》下載解壓
tar -zxvf flume-ng-1.6.0-cdh5.14.0.tar.gz -C ../servers/
-》修改配置
flume-env.sh
java_home
export HADOOP_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0
1-知道HDFS的地址
a-配置Hadoop_Home
b-將Hadoop的配置文件放入flume conf目錄下
core-site.xml hdfs-site.xml【若是配置了HA，須要放】
c-在flume的agent指定hdfs的地址
2-調用Hadoop的jar包
-》開發agent，運行agent
需求：讀取Nginx的日誌文件，緩存在內存中，發送到日誌中
exec memChannel logSink
```
## **Kafka**

**1.準備3臺虛擬機**

本機也要加

```properties
192.168.72.141 node01
192.168.72.142 node02
192.168.72.143 node03
```

**2.初始化環境**

1）安裝jdk、安裝zookeeper

2）安裝目錄

安裝包存放的目錄：/export/software

. 安裝程序存放的目錄：/export/servers

. 數據目錄：/export/data

. 日誌目錄：/export/logs

```properties
mkdir -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環境

![](jiqun-images/1544866443419.png)

b) zookeeper環境

![](jiqun-images/1544786940692.png)

**3.搭建Kafka集羣**

**3.1.準備安裝包**

![](jiqun-images/1544787035414.png)

因爲kafka是scala語言編寫的，基於scala的多個版本，kafka發佈了多個版本。

其中2.11是推薦版本。

**3.2.下載安裝包及解壓**

```properties
tar -zxvf kafka_2.11-1.0.0.tgz -C /export/servers/
cd /export/servers/
mv kafka_2.11-1.0.0 kafka
```

1）刪除以前的安裝記錄

```properties
rm -rf /export/servers/kafka
rm -rf /export/data/kafka/
```

2）解壓文件

```properties
tar -zxvf kafka_2.11-1.0.0.tgz -C /export/servers/
```

3）重命名

```properties
mv kafka_2.11-1.0.0/ kafka
```

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

**3.3.1查看目錄**

![](jiqun-images/1544787057518.png)

**3.3.2修改配置文件**

進入配置目錄，查看server.properties文件

cat server.properties |grep -v "#"

![](jiqun-images/1544787073410.png)

經過以上命令，查看到了默認的配置文件，對默認的文件進行修改。

修改三個地方

vi server.properties

1） Borker.id

2）數據存放的目錄，**注意目錄若是不存在，須要新建下。**

3） zookeeper的地址信息

```properties
#broker.id 標識了kafka集羣中一個惟一broker。
broker.id=0
num.network.threads=3
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600

#存放生產者生產的數據數據通常以topic的方式存放
log.dirs=/export/data/kafka
num.partitions=1
num.recovery.threads.per.data.dir=1
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
log.retention.hours=168
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000

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

#可選配置
delete.topic.enable=true
host.name=192.168.72.141
```

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

將修改好的配置文件，分發到node02，node03上。

先在node0二、node03上刪除以往的安裝記錄

```properties
# 建立一個數據存放目錄 /export/data/kafka
mkdir -p /export/data/kafka
```

分發安裝包

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

修改node02上的broker.id

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

![](jiqun-images/1544787262549.png)

修改node03上的broker.id

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

![](jiqun-images/1544787309119.png)

注意：host.name各個機器也不相同，也須要進行修改

**3.4.啓動集羣**

```properties
cd /export/servers/kafka/bin
nohup ./kafka-server-start.sh /export/servers/kafka/config/server.properties > /dev/null 2>&1 &

/dev/null 黑洞不要了
2>&1 將其餘級別的日誌也輸出到黑洞
nohup & 後臺啓動

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

若是/export/logs/kafka不存在,先建立這個目錄,這個目錄存放啓動後產生的日誌
mkdir -p /export/logs/kafka
```

**3.5.查看Kafka集羣**

因爲kafka集羣並無UI界面能夠查看。

須要藉助外部工具，來查看kafka的集羣

這個工具是一個java程序，必需要安裝好JDK

![](jiqun-images/1544787326910.png)

![](jiqun-images/1544787370274.png)

![](jiqun-images/1560493552920.png)

**3.6 自動化啓動腳本**

- startKafka.sh

```properties
#!/bin/sh
cat /export/servers/kafka/bin/slave | while read line
do
{
echo $line
ssh $line "source /etc/profile;nohup /export/servers/kafka/bin/kafka-server-start.sh /export/servers/kafka/config/server.properties >/dev/null 2>&1 &"
}&
wait
done
```

- stopKafka.sh

```properties
#!/bin/sh
cat /export/servers/kafka/bin/slave | while read line
do
{
echo $line
ssh $line "source /etc/profile;jps |grep Kafka |cut -c 1-5 |xargs kill -s 9 "
}&
wait
done
```

- slave 存放的位置:/export/servers/kafka/bin/slave

```
node01
node02
node03
```

## Sqoop

**sqoop實戰及原理**

** sqoop安裝**

安裝sqoop的前提是已經具有java和hadoop的環境

**一、下載並解壓**

下載地址

http://archive.cloudera.com/cdh5/cdh/5/

sqoop1版本詳細下載地址

http://archive.cloudera.com/cdh5/cdh/5/sqoop-1.4.6-cdh5.14.0.tar.gz

sqoop2版本詳細下載地址

http://archive.cloudera.com/cdh5/cdh/5/sqoop2-1.99.5-cdh5.14.0.tar.gz

咱們這裏使用sqoop1的版本，下載以後上傳到/export/softwares目錄下，而後進行解壓

cd /export/softwares

tar -zxvf sqoop-1.4.6-cdh5.14.0.tar.gz -C ../servers/

**二、修改配置文件**

cd /export/servers/sqoop-1.4.6-cdh5.14.0/conf/

cp sqoop-env-template.sh sqoop-env.sh

vim sqoop-env.sh

export HADOOP_COMMON_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0

export HADOOP_MAPRED_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0

export HIVE_HOME=/export/servers/hive-1.1.0-cdh5.14.0

**三、加入額外的依賴包**

sqoop的使用須要添加兩個額外的依賴包，一個是mysql的驅動包，一個是java-json的的依賴包，否則就會報錯

mysql-connector-java-5.1.40.jar

java-json.jar

![](jiqun-images/129.png)

將這個兩個jar包添加到sqoop的lib目錄下

**四、驗證啓動**

cd /export/servers/sqoop-1.4.6-cdh5.14.0

bin/sqoop-version

![](jiqun-images/130.png)

## Impata

**經過本地yum源進行安裝impala**

全部cloudera軟件下載地址

http://archive.cloudera.com/cdh5/cdh/5/

http://archive.cloudera.com/cdh5/

1、掛載磁盤

```shell
1-手動添加一塊硬盤：詳細過程參考圖片
注意該虛擬硬盤所在的物理硬盤剩餘空間至少大於15GB
2-建立分區
fdisk -l 確認出現/dev/sdb該硬盤設備
fdisk /dev/sdb 對sdb硬盤進行分區
p 查看當前硬盤的分區信息
n 建立新分區
p 分區類型爲主分區
1 分區號爲1
回車硬盤起始位置，默認爲0
回車硬盤結束位置，默認爲最大值
p 查看當前硬盤的分區信息
w 保存並退出
mkfs -t ext4 /dev/sdb1 格式化硬盤分區

3-掛載目錄
建立掛載目錄：
mkdir /export/users
手動臨時掛載：
mount /dev/sdb1 /export/users
驗證是否掛載成功：
df -h
永久掛載，開機自動加載：
echo "/dev/sdb1 /export/users ext4 defaults 0 0" >> /etc/fstab
```

2、配置Impala的yum源

```properties
1-上傳5G的CDH的RPM包到/export/users目錄下
使用secureFX或者Xftp上傳，不要使用rz命令上傳

2-直接解壓在/export/users目錄下
tar -zxvf cdh5.14.0-centos6.tar.gz

3-安裝http服務實現局域網yum源
在第1臺機器上安裝http服務，之後全部的安裝都直接請求第一臺機器
yum -y install httpd
service httpd start
cd /etc/yum.repos.d
vim /etc/yum.repos.d/localimp.repo 編輯該文件，將如下內容放入該文件中

編輯的yum源
[localimp]
name=localimp
baseurl=http://hpsk.bigdata01.com/cdh5.14.0/
gpgcheck=0
enabled=1
將cdh的本地源地址，放入httpd的資源目錄下：
ln -s /export/users/cdh/5.14.0 /var/www/html/cdh5.14.0

4-將製做好的yum源的配置文件發送給其餘機器
scp /etc/yum.repos.d/localimp.repo 192.168.134.222:/etc/yum.repos.d/
scp /etc/yum.repos.d/localimp.repo 192.168.134.223:/etc/yum.repos.d/
```

3、安裝分佈式Impala

```properties
1-節點功能：
impala-catalog：元數據管理
impala-state-store：主節點
impala-server/Impalad：從節點

2-節點劃分：
服務名稱 node01 node02 node03
impala-catalog ★
impala-state-store ★
impala-server ★ ★ ★

3-安裝Impala
第二臺機器：
yum install impala -y
yum install impala-server -y
yum install impala-state-store -y
yum install impala-catalog -y
yum install impala-shell -y
第一臺和第三臺機器：
yum install impala-server -y
```

4、配置Hadoop的shortcircuit短路機制
短路：客戶端直接獲取數據塊，不通過DataNode，DataNode只負責提供位置信息

```properties
1-在全部Hadoop節點上建立一下目錄：用於保存讀取的socket
mkdir -p /var/run/hdfs-sockets

2-在全部DataNode的節點的hdfs-site.xml中添加以下配置
<property>
<name>dfs.client.read.shortcircuit</name>
<value>true</value>
</property>
<property>
<name>dfs.domain.socket.path</name>
<value>/var/run/hdfs-sockets/dn</value>
</property>
<property>
<name>dfs.client.file-block-storage-locations.timeout.millis</name>
<value>10000</value>
</property>
<property>
<name>dfs.datanode.hdfs-blocks-metadata.enabled</name>
<value>true</value>
</property>

3-分發修改完的hdfs-site.xml到全部機器
scp /export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/hdfs-site.xml 192.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.xml 192.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/
||
結果：
Listening on UNIX domain socket: /var/run/hdfs-sockets/dn

```

5、配置Hive的metastore服務

```properties
1-修改每臺機器的hive-site.xml文件，添加metastore服務的配置

<property>
<name>hive.metastore.uris</name>
<value>thrift://hadoop03:9083</value>
</property>
<property>
<name>hive.metastore.client.socket.timeout</name>
<value>3600</value>
</property>
2-確保每一臺機器都有Hive
scp -r /export/servers/hive-1.1.0-cdh5.14.0 192.168.134.221:/export/servers/
scp -r /export/servers/hive-1.1.0-cdh5.14.0 192.168.134.222:/export/servers/

3-在第三臺機器啓動metastore服務和hiveserver2服務測試
確保mysql已經正常啓動
nohup bin/hive --service metastore 2>&1 >>logs/metastore.log &
nohup bin/hiveserver2 2>&1 >>logs/hiveserver.log &

檢查端口是否開放：
netstat -atunlp | grep 9083
netstat -atunlp | grep 10000
在任意一臺機器上啓動beeline鏈接測試
cd /export/servers/hive-1.1.0-cdh5.14.0/
bin/beeline
!connect jdbc:hive2://hpsk.bigdata03.com:10000
root
123456
show databases;
```

6、配置Impala與Hadoop、Hive的集成

```properties
1-Impala的配置文件目錄爲/etc/impala/conf
ll /etc/impala/conf/
2-在全部的Impala Server的節點中添加core-site.xml、hdfs-site.xml、hive-site.xml
ln -s /export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/core-site.xml /etc/impala/conf/core-site.xml
ln -s /export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/hdfs-site.xml /etc/impala/conf/hdfs-site.xml
ln -s /export/servers/hive-1.1.0-cdh5.14.0/conf/hive-site.xml /etc/impala/conf/hive-site.xml
```

7、修改Impala自身配置

```properties
1-修改每臺Impala節點的配置文件
vim /etc/default/impala
IMPALA_CATALOG_SERVICE_HOST=hpsk.bigdata02.com
IMPALA_STATE_STORE_HOST=hpsk.bigdata02.com

2-爲每臺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.jar

3-修改每臺Impala節點的bigtop文件的JAVA_HOME
vim /etc/default/bigtop-utils
export JAVA_HOME=/export/servers/jdk1.8.0_141
```

8、啓動Impala服務

```properties
第二臺機器啓動三個服務：
service impala-state-store start
service impala-catalog start
service impala-server start
第一臺和第三臺機器啓動一個服務：
service impala-server start
查看進程：ps -ef | grep impala

查看web端：
訪問impalad的管理界面
http://hpsk.bigdata02.com:25000/
訪問statestored的管理界面
http://hpsk.bigdata02.com:25010/
```

**安裝 Impala**

之前面配置好的CDH 5.14.0本地源對Impala進行安裝部署使用。

前提條件
安裝好Hadoop、Hive、MySQL
Hadoop：node1主節點，其餘爲從節點
Hive：node1
MySQL：node1
配置好本地yum源
Hadoop 本地庫配置
Hadoop 框架須要支持C程序訪問接口，查看下圖，若是有該路徑下有這麼些文件，就
證實支持C接口

![1568260738236](jiqun-images/1568260738236.png)

使用Hadoop自帶工具類檢查支持的native庫

![1568260754294](jiqun-images/1568260754294.png)

安裝規劃

![1568260851077](jiqun-images/1568260851077.png)

主節點cdh01執行如下命令進行安裝

```shell
yum install impala impala-server impala-state-store impala-catalog impala-
shell bigtop-utils -y
# 備註：安裝的時間較長
```

從節點cdh02和cdh03上安裝如下服務

```shell
yum install impala impala-server impala-shell bigtop-utils -y
#備註：安裝時間較長
```

**配置Impala**

![1568260950999](jiqun-images/1568260950999.png)

備註：

```
bigtop(CDH)：統一管理hadoop以及相關組件之間的依賴關係的組件
```

1）、修改hive-site.xml文件（cdh01）
Impala依賴於Hive，因此首先須要進行Hive的配置修改；
cdh01機器修改 hive-site.xml 內容以下:
vim /export/servers/hive/conf/hive-site.xml

```xml
<configuration>
<property>
<name>javax.jdo.option.ConnectionURL</name>
<value>jdbc:mysql://node1:3306/hive?
createDatabaseIfNotExist=true</value>
</property>
<property>
<name>javax.jdo.option.ConnectionDriverName</name>
<value>com.mysql.jdbc.Driver</value>
</property>
<property>
<name>javax.jdo.option.ConnectionUserName</name>
<value>root</value>
</property>
<property>
<name>javax.jdo.option.ConnectionPassword</name>
<value>123456</value>
</property>
<property>
<name>hive.cli.print.current.db</name>
<value>true</value>
</property>
<property>
<name>hive.cli.print.header</name>
<value>true</value>
</property>
<property>
<name>hive.server2.thrift.bind.host</name>
<value>node3</value>
</property>
<property>
<name>hive.metastore.uris</name>
<value>thrift://node1:9083</value>
</property>
<property>
<name>hive.metastore.client.socket.timeout</name>
<value>3600</value>
</property>
</configuration>
```

2）添加mysql的jar包放入hive的lib目錄下

![1568261044091](jiqun-images/1568261044091.png)

3）、將hive的安裝包發送到cdh02與cdh03上（若是其餘節點安裝Hive）

在cdh01上執行命令

```properties
cd /export/servers/
scp -r hive-1.1.0-cdh5.14.0/ node2:$PWD
scp -r hive-1.1.0-cdh5.14.0/ node3:$PWD
```

備註：集羣中能夠只在一個節點安裝Hive。若是隻有一個節點安裝Hive，這步可省略

4）、啓動hive的metastore服務

在cdh01上啓動hive的metastore服務

```properties
cd /export/servers/hive
nohup bin/hive --service metastore &
```

注意：必定要保證mysql的服務正常啓動，不然metastore的服務不可以啓動
啓動MetaStore服務腳本 metastore-start.sh ：

```shell
#!/bin/sh
HIVE_HOME=/export/servers/hive
## 啓動服務的時間
DATE_STR=`/bin/date '+%Y%m%d%H%M%S'`
# 日誌文件名稱(包含存儲路徑)
HIVE_SERVER2_LOG=${HIVE_HOME}/hivemetastore-${DATE_STR}.log
## 啓動服務
/usr/bin/nohup ${HIVE_HOME}/bin/hive --service metastore >
${HIVE_SERVER2_LOG} 2>&1 &
```

![1568261259020](jiqun-images/1568261259020.png)

5）、全部Hadoop節點修改hdfs-site.xml添加如下內容
全部節點建立文件夾
mkdir -p /var/run/hdfs-sockets
修改全部節點的 hdfs-site.xml 添加如下配置，修改完以後重啓hdfs集羣生效 vim
/export/servers/hadoop/etc/hadoop/hdfs-site.xml

```xml

<property>

<name>dfs.client.read.shortcircuit</name>
<value>true</value>
</property>
<property>
<name>dfs.domain.socket.path</name>
<value>/var/run/hdfs-sockets/dn</value>

</property>

<property>
<name>dfs.datanode.hdfs-blocks-metadata.enabled</name>
<value>true</value>
</property>
<property>
<name>dfs.client.file-block-storage-
locations.timeout.millis</name>
<value>10000</value>
</property>
```

同步配置文件到全部HDFS集羣

```properties
cd /export/servers/hadoop/etc/hadoop
scp -r hdfs-site.xml bigdata-cdh02.itcast.cn:$PWD
scp -r hdfs-site.xml bigdata-cdh03.itcast.cn:$PWD
```

備註:

當在Impala上執行查詢的時候，會到多個datanode上分佈式地讀取block數據，若是
Impala擁有更多的block信息，將會更高效的獲取數據並處理。
Short-circuit read意味着會從datanode的本地文件系統直接讀取數據，而不用首先與
datanode進行通訊，這確定會提升性能。

6）、重啓hdfs

在Hadoop集羣的主節點cdh01上執行

```properties
sh hdfs-stop-cluster.sh
sh hdfs-start-cluster.sh
```

7）、建立Hadoop與Hive的配置文件的鏈接
Impala的配置目錄爲 /etc/impala/conf
這個路徑下面須要把 core-site.xml，hdfs-site.xml以及hive-site.xml 拷貝到這裏
來，使用軟鏈接的方式。【將Hadoop、Hive的配置告訴 Impala】
cdh0一、cdh0二、cdh03上執行如下命令建立連接到Impala配置目錄下來

```shell
ln -s /export/servers/hadoop/etc/hadoop/core-site.xml
/etc/impala/conf/core-site.xml
ln -s /export/servers/hadoop/etc/hadoop/hdfs-site.xml
/etc/impala/conf/hdfs-site.xml
ln -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.cn
IMPALA_STATE_STORE_HOST=bigdata-cdh01.itcast.cn
```

Impala配置文件 /etc/default/impala 中內容

```shell
IMPALA_CATALOG_SERVICE_HOST=bigdata-cdh01.itcast.cn
IMPALA_STATE_STORE_HOST=bigdata-cdh01.itcast.cn
IMPALA_STATE_STORE_PORT=24000
IMPALA_BACKEND_PORT=22000
IMPALA_LOG_DIR=/var/log/impala
IMPALA_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
```

備註：
須要啓動 hive metastore 服務的節點，要執行此步；
/usr/share/java 目錄不存在的，須要手工建立

10）、全部節點修改bigtop的java路徑
修改bigtop的java_home路徑
vim /etc/default/bigtop-utils

```
export JAVA_HOME=/export/servers/jdk
```

11）、啓動impala服務

在主節點node1啓動如下三個服務進程

```properties
service impala-state-store start
service impala-catalog start
service impala-server start
```

在從節點node2和node3上啓動impala-server

```
service impala-server start
```

查看impala進程是否存在

```
ps -ef | grep impala
```

![1568261821749](jiqun-images/1568261821749.png)

注意：啓動以後全部關於impala的日誌默認都在 /var/log/impala 這個路徑下，cdh01機器
上面應該有三個進程，cdh02與cdh03機器上面只有一個進程，若是進程個數不對，去對應目
錄下查看報錯日誌

**一鍵服務腳本**

```shell
# 啓動服務腳本
vim start-impala-kudu.sh
# -----------------------------------------------------------
#!/bin/sh
for host in 01 02 03
do
echo "bigdata-cdh${host}.itcast.cn is starting......"
ssh bigdata-cdh${host}.itcast.cn "service kudu-master start; service
kudu-tserver start"
ssh bigdata-cdh${host}.itcast.cn service impala-server start
echo ""
done
ssh bigdata-cdh01.itcast.cn service impala-catalog start
ssh bigdata-cdh01.itcast.cn service impala-state-store start
# -----------------------------------------------------------
chmod +x start-impala-kudu.sh
# 中止服務腳本
vim stop-impala-kudu.sh
# -----------------------------------------------------------
#!/bin/sh
for host in node1 node2 node3
do
echo "bigdata-cdh${host}.itcast.cn is stop"
ssh bigdata-cdh${host}.itcast.cn "service kudu-master stop; service kudu-
tserver stop"
ssh bigdata-cdh${host}.itcast.cn service impala-server stop
echo ""
done
ssh bigdata-cdh01.itcast.cn service impala-catalog stop
ssh bigdata-cdh01.itcast.cn service impala-state-store stop
# -----------------------------------------------------------
chmod +x stop-impala-kudu.sh
# 服務狀態監測腳本
vim status-impala-kudu.sh
# -----------------------------------------------------------
#!/bin/sh
for host in node1 node2 node3
do
echo "check bigdata-cdh${host}.itcast.cn server"
ssh bigdata-cdh${host}.itcast.cn "service kudu-master status; service
kudu-tserver status"
ssh bigdata-cdh${host}.itcast.cn service impala-server status
echo ""
done
ssh bigdata-cdh01.itcast.cn service impala-catalog status
ssh bigdata-cdh01.itcast.cn service impala-state-store status
# -----------------------------------------------------------
chmod +x status-impala-kudu.sh
# 重啓服務腳本
vim restart-impala-kudu.sh
# -----------------------------------------------------------
#!/bin/sh
for host in node1 node2 node3
do
echo "bigdata-cdh${host}.itcast.cn is Restarting"
ssh bigdata-cdh${host}.itcast.cn "service kudu-master restart; service
kudu-tserver restart"
ssh bigdata-cdh${host}.itcast.cn service impala-server restart
echo ""
done
ssh bigdata-cdh01.itcast.cn service impala-catalog restart
ssh bigdata-cdh01.itcast.cn service impala-state-store restart
# -----------------------------------------------------------
chmod +x restart-impala-kudu.sh
```

12）、瀏覽器頁面訪問

web訪問端口

```
- impalad 25000
- statestored 25010
- catalogd 25020
```

訪問impalad的管理界面http://bigdata-cdh01.itcast.cn:25000/

訪問statestored的管理界面http://bigdata-cdh01.itcast.cn:25010

訪問catalogd 的管理界面http://bigdata-cdh01.itcast.cn:25020

進入交互式命令行：

```shell
[root@bigdata-cdh01 kudu]# impala-shell
Starting Impala Shell without Kerberos authentication
Connected to bigdata-cdh01.itcast.cn:21000
Server version: impalad version 2.11.0-cdh5.14.0 RELEASE (build
d68206561bce6b26762d62c01a78e6cd27aa7690)
***************************************************************************
********
Welcome to the Impala shell.
(Impala Shell v2.11.0-cdh5.14.0 (d682065) built on Sat Jan 6 13:27:16 PST
2018)
To see a summary of a query's progress that updates in real-time, run 'set
LIVE_PROGRESS=1;'.
***************************************************************************
********
[bigdata-cdh01.itcast.cn:21000] >
```

![1568261972274](jiqun-images/1568261972274.png)

測試SQL語句執行：

```
select * from emp ;
select * from dept ;
select e.ename, e.sal, d.dname from emp e join dept d on e.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
```

![1568262050064](jiqun-images/1568262050064.png)

```
impala的安裝路徑： /usr/lib/impala impala的服務配置主文件： /etc/default/impala
impala的配置文件： /etc/impala/conf impala的日誌： /var/log/impala
```

![1568262169211](jiqun-images/1568262169211.png)

## kudu

**一、軟件安裝方式**

Linux下常見的軟件安裝方式：二進制文件安裝、rpm、yum

i、二進制包

![1568257901491](jiqun-images/1568257901491.png)

二進制包裏面包括了已經通過編譯，能夠立刻運行的程序；
只須要下載和解包（安裝）、配置，就立刻能夠使用；
缺點：對環境依賴大；

ii、rpm
早期被稱爲RedHat Package Manager，但因爲目前RPM很是流行，且已經成爲Linux工業
標準。因此RPM如今又被稱爲RPM is Package Manager；
RPM的功能：打包、安裝、查詢、升級、卸載、校驗等功能；
RPM包並非跨平臺的。RedHat的RPM包與SUSE的RPM包不能混用。RedHat的安裝，初
始軟件也都是使用RPM包進行安裝的；
RPM的缺點：程序與程序之間存在很是複雜的依賴關係，RPM沒法解決軟件包的依賴關
系；
iii、Yum
YUM被稱爲 Yellow dog Updater Modified；
YUM使用Python語言編寫，對 RPM 包進行管理；
能夠經過HTTP服務器下載、FTP服務器下載、本地文件的等方式得到軟件包；
能夠從指定的服務器自動下載RPM包而且安裝；
能夠自動處理依賴性關係；
yum的主配置文件（通常不改動）：/etc/yum.conf

```shell
main]
#RPM包的緩存位置
cachedir=/var/cache/yum/$basearch/$releasever
#RPM包在本地是否須要長期保存。1表示yes，0表示no
keepcache=0
#日誌級別
debuglevel=2
#日誌文件位置
logfile=/var/log/yum.log
#下載的RPM包是否須要與本地平臺徹底匹配。1表示yes，0表示no
exactarch=1
obsoletes=1
#是否須要自動來源合法性檢測
gpgcheck=1
plugins=1
installonly_limit=5
bugtracker_url=http://bugs.centos.org/set_project.php?
project_id=19&ref=http://bugs.cen
tos.org/bug_report_page.php?category=yum
distroverpkg=centos-release
```

YUM的片斷配置：/etc/yum.repos.d/*.repo

```shell
cd /etc/yum.repos.d/
ls
# 有如下文件，僅有CentOS-Base.repo文件有效。文件中有 enabled=0 表示不生效
CentOS-Base.repo
CentOS-Debuginfo.repo
CentOS-fasttrack.repo
CentOS-Media.repo
CentOS-Vault.repo
#配置文件中重要的字段：
# [ ... ]：倉庫的名稱。不能重複；
# name：對倉庫的描述，該項必須有；
# baseurl：配置倉庫的路徑。用於指定一個url；
# mirrorlist：指向一個鏡像列表，裏面有多個url；
# enabled：是否啓用當前倉庫。值爲1或0，默認爲1；
# gpgcheck：是否須要gpg校驗。值爲1或0，默認爲1；
```

能夠自定義yum的配置

一、自定義CentOS-Base.repo【3個節點都要改】
在 CentOS-Base.repo 中指定從 mirrorlist.centos.org 去下載相關的 rpm 包，速度慢；
這裏改成從阿里雲下載相關的 rpm 包。

```shell
# 第一步將原來的 CentOS-Base.repo 文件備份
mv CentOS-Base.repo CentOS-Base.repo.bak
# 下載並重命名文件（注意這裏設置的 CentOS6 ）
wget -O /etc/yum.repos.d/CentOS-Base.repo
http://mirrors.aliyun.com/repo/Centos-6.repo
```

二、自定義localimp.repo（指定從Http服務下載 rpm ）【3個節點都要改】

```shell
cd /etc/yum.repos.d/
vi localimp.repo
# 如下爲文件內容
[localimp]
name=localimp
baseurl=http://bigdata-cdh01.itcast.cn/cdh5.14.0
gpgcheck=0
enabled=1
# 清理yum緩存，並生成新的緩存
yum clean all
yum makecache
# 備註：gpkcheck=0 表示對從這個源下載的rpm包不進行校驗
```

yum的經常使用命令

```shell
# 清空本地yum的緩存
yum clean all
# 在本地創建緩存
yum makecache
# 安裝軟件包
yum [-y] install 包1 包2 包3 ...
# 卸載軟件包
yum remover 包1 包2 包3 ...
```

**二、節點規劃**

| 節點 | kudu-master | kudu-tserver |
| ---- | ----------- | ------------ |
| 01 | yes | yes |
| 02 | yes | yes |
| 03 | yes | yes |

**三、配置本地的CDH-yum源**

![1568258322393](jiqun-images/1568258322393.png)

備註：要下載少許的軟件包，須要網絡支持，虛擬機要能聯網

1）、配置本地Yum的Repository

![1568258408873](jiqun-images/1568258408873.png)

備註：這裏選擇在 cdh01 上操做

```properties
全部cloudera軟件下載地址:
http://archive.cloudera.com/cdh5/
訪問：http://archive.cloudera.com/cdh5/repo-as-tarball/5.14.0/cdh5.14.0-
centos6.tar.gz
下載cdh5.14.0-centos6.tar.gz文件，大小約5G左右。
```

2）、上傳壓縮包並解壓

軟件位置：cdh01； /export/servers/cdh5.14.0-centos6.tar.gz

```shell
# 把5個G的壓縮文件上傳其中某一臺服務器，這裏上傳到「node1」上並進行解壓。
#（這裏須要確保服務器的磁盤空間是充足的，若是磁盤容量不夠，就須要擴容，增大磁盤的容量，具
體操做能夠參考：
# https://www.cnblogs.com/bitter-first-sweet-last/p/6638634.html）
tar -zxvf cdh5.14.0-centos6.tar.gz -C /export/servers
```

![1568258483342](jiqun-images/1568258483342.png)

3）、建立apache httpd的讀取鏈接

【在node1上執行便可]

```shell
# 建立軟連接
ln -s /export/servers/cdh/5.14.0 /var/www/html/cdh5.14.0
# 刪除軟連接
cd /var/www/html/
rm ./cdh5.14.0
```

頁面訪問本地yum源，出現這個界面表示本地yum源製做成功訪問http://bigdata-cdh01.itcas
t.cn/cdh5.14.0
備註：3個節點都須要能經過 web 方式訪問

```shell
訪問異常：You don't have permission to access /cdh5.14.0/ on this server
須要關閉Selinux服務
（1）臨時關閉
執行命令：setenforce 0
(2) 永久關閉
vim /etc/sysconfig/selinux
SELINUX=enforcing 改成 SELINUX=disabled
重啓服務reboot
```

![1568258575560](jiqun-images/1568258575560.png)

4）、製做本地yum源

```shell
# 鏡像源是centos當中下載相關軟件的地址，能夠經過製做鏡像源來指定yum去哪裏下載kudu的rpm
包；
# 這裏咱們使用httpd做爲服務端，啓動httpd的服務來做爲鏡像源的下載地址；
# 這裏用第三臺機器做爲鏡像源的服務端。在node1機器上執行如下命令：
yum -y install httpd
service httpd start
# 備註：以上操做在node1上完成便可！
# 建立文件【3個節點都需完成】
cd /etc/yum.repos.d
vim localimp.repo
# 如下爲文件內容
[localimp]
name=localimp
baseurl=http://bigdata-cdh01.itcast.cn/cdh5.14.0
gpgcheck=0
enabled=1
```

將node1上製做好的localimp配置文件發放到全部須要kudu的節點上去

```shell
/etc/yum.repos.d
scp -r localimp.repo bigdata-cdh02.itcast.cn:$PWD
scp -r localimp.repo bigdata-cdh03.itcast.cn:$PWD
```

備註：
保證cdh01上httpd服務時啓動的
保證在全部節點上，使用瀏覽器能夠訪問 http://bigdata-cdh01.itcast.cn/cdh5.14.0/

四、安裝 Kudu

備註：在全部節點上操做
使用yum命令，在不一樣的服務器下載對應的服務

| 服務<br/>器 | 安裝命令 |
| ----------- | ------------------------------------------------------------ |
| 01 | yum install -y kudu kudu-master kudu-tserver kudu-client0 kudu-client-<br/>devel |
| 02 | yum install -y kudu kudu-master kudu-tserver kudu-client0 kudu-client-<br/>devel |
| 03 | yum install -y kudu kudu-master kudu-tserver kudu-client0 kudu-client-<br/>devel |

命令說明：

```shell
yum install kudu # Kudu的基本包
yum install kudu-master # KuduMaster
yum install kudu-tserver # KuduTserver
yum install kudu-client0 #Kudu C++客戶端共享庫
yum install kudu-client-devel # Kudu C++客戶端共享庫 SDK
```

安裝方式：yum
軟件存放路徑：/usr/lib/kudu
配置文件路徑：/etc/kudu/conf/
缺省配置路徑：/etc/default/
系統日誌存放路徑：/var/log/kudu/
配置數據目錄：
數據日誌與數據存放路徑：/export/servers/kudu

**四、配置 Kudu服務**
備註：在全部節點上操做
安裝完成後，需在全部節點 /etc/kudu/conf 目錄有兩個文件： master.gflagfile 和
tserver.gflagfile 。
修改 master.gflagfile （修改日誌、數據存放位置、添加主機地址）

```shell
# cat /etc/kudu/conf/master.gflagfile
# Do not modify these two lines. If you wish to change these variables,
# modify them in /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
# Do not modify these two lines. If you wish to change these variables,
# modify them in /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
# 這一行沒有變，指定了日誌的位置
export FLAGS_log_dir=/var/log/kudu
#每臺機器的master地址要與主機名一致,這裏是在node1上
export FLAGS_rpc_bind_addresses=bigdata-cdh01.itcast.cn:7051
```

修改 /etc/default/kudu-tserver

```shell
# 這一行沒有變，指定了日誌的位置
export FLAGS_log_dir=/var/log/kudu
#每臺機器的tserver地址要與主機名一致，這裏是在node1上
export FLAGS_rpc_bind_addresses=bigdata-cdh01.itcast.cn:7050
```

建立目錄，更改宿主(全部節點)

```shell
mkdir -p /export/servers/kudu/master
mkdir -p /export/servers/kudu/tserver
#kudu默認用戶是kudu，須要將/export/servers/kudu權限修改爲kudu
chown -R kudu:kudu /export/servers/kudu/
```

附錄Master與TServer相關配置：
Configuring the Kudu Master
https://kudu.apache.org/docs/configuration.html#_configuring_the_kudu_master
https://kudu.apache.org/docs/configuration_reference.html#kudu-master_supported

Configuring Tablet Servers
https://kudu.apache.org/docs/configuration.html#_configuring_tablet_servers
https://kudu.apache.org/docs/configuration_reference.html#kudu-tserver_supported

**六、Kudu集羣啓動關閉**
備註：操做在全部節點上操做
1）、啓動 Kudu
一、啓動的時候要注意時間同步
安裝ntp服務
yum -y install ntp
設置開機啓動
service ntpd start
chkconfig ntpd on
能夠在每臺服務器執行
/etc/init.d/ntpd restart
**備註：kudu很是依賴ntp，ntp沒啓動或不正常，kudu都沒法啓動。啓動kudu以前必定先檢查ntp的狀態。**

```shell
# 監測nptd狀態
$ ntptime
ntp_gettime() returns code 0 (OK)
time e0e0df2b.4940cc60 Tue, Jul 23 2019 9:19:39.286, (.286145635),
maximum error 33885 us, estimated error 0 us, TAI offset 0
ntp_adjtime() returns code 0 (OK)
modes 0x0 (),
offset 0.000 us, frequency 0.000 ppm, interval 1 s,
maximum error 33885 us, estimated error 0 us,
status 0x2001 (PLL,NANO),
time constant 10, precision 0.001 us, tolerance 500 ppm,
# 查看配置時間同步服務器狀態
$ ntpstat
synchronised to local net at stratum 11
time correct to within 11 ms
polling server every 1024 s
#
$ ntpq -pn
remote refid st t when poll reach delay offset
jitter
========================================================================
======
192.168.59.140 .INIT. 16 u - 1024 0 0.000 0.000
0.000
*127.127.1.0 .LOCL. 10 l 52 64 377 0.000 0.000
0.000
```

二、啓動命令
在每臺服務器上都執行下面腳本

```shell
service kudu-master start
service kudu-tserver start
或者
sudo service kudu-master start
sudo service kudu-tserver start
```

2）、關閉 Kudu

. 一、關閉命令
. 在每臺服務器上都執行下面腳本

```shell
service kudu-master stop
service kudu-tserver stop
或者
sudo service kudu-master stop
sudo service kudu-tserver stop
```

3）、一鍵服務腳本

```shell
# 啓動服務腳本
vi start-kudu.sh
# --------------------------------------------------
#!/bin/sh
for host in 01 02 03
do
echo "bigdata-cdh$host.itcast.cn is running"
ssh bigdata-cdh$host.itcast.cn "service kudu-master start; service kudu-
tserver start"
echo "
done
# --------------------------------------------------
chmod +x start-kudu.sh
# 中止服務腳本
vi stop-kudu.sh
# --------------------------------------------------
#!/bin/sh
for host in 01 02 03
do
echo "bigdata-cdh$host.itcast.cn is stop"
ssh bigdata-cdh$host.itcast.cn "service kudu-master stop; service kudu-
tserver stop"
echo ""
done
# --------------------------------------------------
chmod +x stop-kudu.sh
# 服務狀態監測腳本
vi status-kudu.sh
# --------------------------------------------------
#!/bin/sh
for host in 01 02 03
do
echo "check bigdata-cdh$host.itcast.cn server"
ssh bigdata-cdh$host.itcast.cn "service kudu-master status; service
kudu-tserver status"
echo ""
done
# --------------------------------------------------
chmod +x status-kudu.sh
# 重啓服務腳本
vi restart-kudu.sh
# --------------------------------------------------
#!/bin/sh
for host in 01 02 03
do
echo "bigdata-cdh$host.itcast.cn is Restarting"
ssh bigdata-cdh$host.itcast.cn "service kudu-master restart; service
kudu-tserver restart"
echo ""
done
# --------------------------------------------------
chmod +x restart-kudu.sh
```

**七、安裝過成中可能出現的問題**

官方文檔：https://kudu.apache.org/docs/troubleshooting.html
一、給用戶添加sudo權限的時候報錯

```shell
sudo: /etc/sudoers is world writable
解決方式：pkexec chmod 555 /etc/sudoers
```

. 二、啓動kudu的時候報錯

```shell
Failed to start Kudu Master Server. Return value: 1 [FAILED]
去日誌文件中查看：
錯誤：F0810 09:04:08.354552 4866 master_main.cc:68] Check failed: _s.ok()
Bad status:
Service unavailable: Cannot initialize clock: Error reading clock. Clock
considered
unsynchronized
解決：
第一步：首先檢查是否有安裝ntp：若是沒有安裝則使用如下命令安裝：
yum -y install ntp
第二步：設置隨機啓動：
service ntpd start
chkconfig ntpd on
第三步: 添加計劃任務
crontab -e
*/1 * * * * /usr/sbin/ntpdate ntp4.aliyun.com
# 查看計劃任務
crontab -l
備註：ntp的配置文件 /etc/ntp.conf
上面的方式比較簡單，讓每一個節點與阿里的時間服務器同步時間。缺點是：要求虛擬機都能上網，
對網絡依賴高。
也能夠設置爲：在局域網內作時間同步，減小網絡依賴。可參考：
https://blog.csdn.net/xcg132566/article/details/86521815
```

三、啓動過程當中報錯

```properties
F0810 21:31:12.620932 20143 master_main.cc:71] Check failed: _s.ok() Bad
status:
Invalid argument: Unable to initialize catalog manager: Failed to
initialize sys tables
async: on-disk master list
解決：
（1）：停掉master和tserver
（2）：刪除掉以前全部的/export/servers/kudu/master/*
和/export/servers/kudu/tserver/*
```

四、啓動過程當中報錯

```properties
F0913 15:12:00.628237 20859 master_main.cc:74] Check failed: _s.ok() Bad
status: IO
error: Could not create new FS layout: unable to create file system
roots: unable to
write instance metadata: Call to mkstemp() failed on name template
/export/servers/kudu/master/instance.kudutmp.XXXXXX: Permission denied
(error 13)
這是由於kudu默認使用kudu權限進行執行，可能遇到文件夾的權限不一致狀況，更改文件夾權限
便可
```

五、啓動過程當中報錯

```
錯誤描述：kudu-master、kudu-tserver 不能啓動；
ntp服務啓動；用 service ntpd status 顯示服務正常；
在 /var/log/kudu/kudu-master.FATAL 有以下錯誤：
stdout:
ntp_gettime() returns code 5 (ERROR)
time e072ca67.fa770000 Tue, Apr 30 2019 21:21:43.978, (.978378),
maximum error 16000000 us, estimated error 16000000 us, TAI offset 0
ntp_adjtime() returns code 5 (ERROR)
modes 0x0 (),
offset 0.000 us, frequency -5.973 ppm, interval 1 s,
maximum error 16000000 us, estimated error 16000000 us,
status 0x41 (PLL,UNSYNC),
time constant 7, precision 1.000 us, tolerance 500 ppm,
這個錯誤是因爲ntp不正常致使，輸入ntptime也顯示如上的錯誤。
解決方法：重啓ntp服務便可。service ntpd restart
```

**八、Kudu的圖形界面**
啓動好kudu以後能夠訪問kudu的web管理界面
訪問地址：http://bigdata-cdh01.itcast.cn:8051

Master的web地址
http://bigdata-cdh01.itcast.cn:8051/masters

TServer的web地址
http://bigdata-cdh01.itcast.cn:8051/tablet-servers

**九、Kudu安裝小結**
啓動服務的方式： service kudu-master start|stop|status
service kudu-tserver start|stop|status

![1568259864152](jiqun-images/1568259864152.png)

**十、附錄：局域網內部時間同步**

Kudu對NTP服務要求較高，若是NTP未配置或者因爲網絡緣由致使NTP不能正常工做，kudu相
關沒法沒法正常啓動。爲了屏蔽網絡的因素，能夠選擇在局域網內部配置NTP。
現有3個節點cdh01（192.168.59.140）、cdh02（192.168.59.150）、
cdh03（192.168.59.160），選擇cdh01做爲時間同步服務器，其餘節點爲客戶端同步時間到
該節點。
備註：請檢查全部節點關閉防火牆。
一、安裝NTP（全部節點）
二、修改配置文件（全部節點）

```shell
vim /etc/ntp.conf
# 註釋如下四行：
#server 0.centos.pool.ntp.org iburst
#server 1.centos.pool.ntp.org iburst
#server 2.centos.pool.ntp.org iburst
#server 3.centos.pool.ntp.org iburst
```

三、修改node1的配置文件，添加相應內容

```shell
# 給192.168.59.0網段，子網掩碼爲255.255.255.0的局域網機全部機器同步時間的權限
restrict 192.168.59.0 mask 255.255.255.0 notrap nomodify
# prefer表明優先使用此ip作同步
server 192.168.59.140 prefer
# 當全部服務器都不能使用時，使用本機做爲同步服務器
server 127.127.1.0
# 127.127.1.0 爲第10層。ntp和127.127.1.0同步完後，就變成了11層
# ntp是層次階級的。同步上層服務器的 stratum 大小不能超過或等於16
fudge 127.127.1.0 stratum 10
```

四、修改node二、node3的配置文件，添加相應內容

```shell
vim /etc/ntp.conf
server 192.168.59.140 prefer
server 127.127.1.0
fudge 127.127.1.0 stratum 10
```

五、啓動NTP服務

```shell
service ntpd start
chkconfig ntpd on
```

六、檢查ntp服務是否成功輸入： ntpstat
輸出以下則啓動成功而且同步已完成：

```
synchronised to local net at stratum 11
time correct to within 11 ms
polling server every 64 s
```

![1568262319540](jiqun-images/1568262319540.png)

## Hbase

注意事項：HBase強依賴zookeeper和hadoop，安裝HBase以前必定要保證zookeeper和hadoop啓動成功，且服務正常運行

**第一步：下載對應的HBase的安裝包**

全部關於CDH版本的軟件包下載地址以下

http://archive.cloudera.com/cdh5/cdh/5/

HBase對應的版本下載地址以下

http://archive.cloudera.com/cdh5/cdh/5/hbase-1.2.0-cdh5.14.0.tar.gz

**第二步：壓縮包上傳並解壓**

```properties
將咱們的壓縮包上傳到node01服務器的/export/softwares路徑下並解壓
cd /export/softwares/
tar -zxvf hbase-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

vim hbase-env.sh

export JAVA_HOME=/export/servers/jdk1.8.0_141
export HBASE_MANAGES_ZK=false
```

**修改第二個配置文件hbase-site.xml**

```
修改hbase-site.xml
vim hbase-site.xml
```

```xml
<configuration>
<property>
<name>hbase.rootdir</name>
<value>hdfs://node01:8020/hbase</value>
</property>

<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>

<property>
<name>hbase.master.port</name>
<value>16000</value>
</property>

<property>
<name>hbase.zookeeper.quorum</name>
<value>node01:2181,node02:2181,node03:2181</value>
</property>

<property>
<name>hbase.zookeeper.property.dataDir</name>
<value>/export/servers/zookeeper-3.4.5-cdh5.14.0/zkdatas</value>
</property>
</configuration>
```

**修改第三個配置文件regionservers**

```
vim regionservers

node01
node02
node03
```

**建立back-masters配置文件，實現HMaster的高可用**

```
cd /export/servers/hbase-1.2.0-cdh5.14.0/conf
vim backup-masters

node02
```

**第四步：安裝包分發到其餘機器**

```properties
將咱們第一臺機器的hbase的安裝包拷貝到其餘機器上面去
cd /export/servers/
scp -r hbase-1.2.0-cdh5.14.0/ node02:$PWD
scp -r hbase-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.xml
ln -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的環境變量**

```properties
vim /etc/profile
export HBASE_HOME=/export/servers/hbase-1.2.0-cdh5.14.0
export PATH=:$HBASE_HOME/bin:$PATH
```

**第七步：HBase集羣啓動**

```
第一臺機器執行如下命令進行啓動
cd /export/servers/hbase-1.2.0-cdh5.14.0
bin/start-hbase.sh
```

警告提示：HBase啓動的時候會產生一個警告，這是由於jdk7與jdk8的問題致使的，若是linux服務器安裝jdk8就會產生這樣的一個警告

![1565785581520](jiqun-images/1565785581520.png)

咱們能夠只是掉全部機器的hbase-env.sh當中的

「HBASE_MASTER_OPTS」和「HBASE_REGIONSERVER_OPTS」配置來解決這個問題。不過警告不影響咱們正常運行，能夠不用解決

```
咱們也能夠執行如下命令單節點進行啓動
啓動HMaster命令
bin/hbase-daemon.sh start master
啓動HRegionServer命令
bin/hbase-daemon.sh start regionserver

爲了解決HMaster單點故障問題，咱們能夠在node02和node03機器上面均可以啓動HMaster節點的進程，以實現HMaster的高可用
bin/hbase-daemon.sh start master
```

**第八步：頁面訪問**

瀏覽器頁面訪問

http://node01:60010/master-status

### hive與HBase的整合

hive與咱們的HBase各有千秋，各自有着不一樣的功能，可是歸根接地，hive與hbase的數據最終都是存儲在hdfs上面的，通常的咱們爲了存儲磁盤的空間，不會將一份數據存儲到多個地方，致使磁盤空間的浪費，咱們能夠直接將數據存入hbase，而後經過hive整合hbase直接使用sql語句分析hbase裏面的數據便可，很是方便

hive: 是一個數據倉庫工具，是作離線數據統計，不支持實時讀寫，不能修改和刪除

hbase：是一個nosql數據庫，支持實時讀寫，不支持關流查詢

![](jiqun-images/1565845666070.png)

**需求一：將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包的依賴

```shell
ln -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.jar
ln -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.jar
ln -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.jar
ln -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.jar
ln -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添加如下兩行配置

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

vim hive-site.xml

```xml
<property>
<name>hive.zookeeper.quorum</name>
<value>node01,node02,node03</value>
</property>
<property>
<name>hbase.zookeeper.quorum</name>
<value>node01,node02,node03</value>
</property>
```

**第三步：修改hive-env.sh配置文件添加如下配置**

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

vim hive-env.sh

```properties
export HADOOP_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0
export HBASE_HOME=/export/servers/hbase-1.2.0-cdh5.14.0
export HIVE_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對應的數據庫表

```sql
create database course;
use course;
create external table if not exists course.score(id int,cname string,score int) row format delimited fields terminated by ',' stored as textfile ;
```

**進行加載數據**

進入hive客戶端進行加載數據

```sql
hive (course)> load data local inpath '/export/servers/tmp/hive-hbase.txt' into table score;
hive (course)> select * from score;
```

**第五步：建立hive管理表與HBase進行映射**

咱們能夠建立一個hive的管理表與hbase當中的表進行映射，hive管理表當中的數據，都會存儲到hbase上面去

hive當中建立內部表

```sql
create table course.hbase_score(id int,cname string,score int)
stored by 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
with serdeproperties("hbase.columns.mapping" = "cf:name,cf:score")
tblproperties("hbase.table.name" = "hbase_score");
```

經過insert overwrite select 插入數據

```sql
insert overwrite table course.hbase_score select id,cname,score from course.score;
```

**第六步：hbase當中查看錶hbase_score**

進入hbase的客戶端查看錶hbase_score，並查看當中的數據

```
hbase(main):023:0> list
TABLE
hbase_score
myuser myuser2 student user
5 row(s) in 0.0210 seconds

=> ["hbase_score", "myuser", "myuser2", "student", "user"]
hbase(main):024:0> scan 'hbase_score'
ROW COLUMN+CELL
1 column=cf:name, timestamp=1550628395266, value=zhangsan
1 column=cf:score, timestamp=1550628395266, value=80
2 column=cf:name, timestamp=1550628395266, value=lisi
2 column=cf:score, timestamp=1550628395266, value=60
3 column=cf:name, timestamp=1550628395266, value=wangwu
3 column=cf:score, timestamp=1550628395266, value=30
4 column=cf:name, timestamp=1550628395266, value=zhaoliu
4 column=cf:score, timestamp=1550628395266, value=70
4 row(s) in 0.0360 seconds
```

**需求二：建立hive外部表，映射HBase當中已有的表模型，直接經過**

**第一步：HBase當中建立表並手動插入加載一些數據**

進入HBase的shell客戶端，手動建立一張表，並插入加載一些數據進去

```sql
reate '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'
```

操做成功結果以下：

```sql
hbase(main):049:0> create 'hbase_hive_score',{ NAME =>'cf'}
0 row(s) in 1.2970 seconds

=> Hbase::Table - hbase_hive_score
hbase(main):050:0> put 'hbase_hive_score','1','cf:name','zhangsan'
0 row(s) in 0.0600 seconds

hbase(main):051:0> put 'hbase_hive_score','1','cf:score', '95'
0 row(s) in 0.0310 seconds

hbase(main):052:0> put 'hbase_hive_score','2','cf:name','lisi'
0 row(s) in 0.0230 seconds

hbase(main):053:0> put 'hbase_hive_score','2','cf:score', '96'
0 row(s) in 0.0220 seconds

hbase(main):054:0> put 'hbase_hive_score','3','cf:name','wangwu'
0 row(s) in 0.0200 seconds

hbase(main):055:0> put 'hbase_hive_score','3','cf:score', '97'
0 row(s) in 0.0250 seconds
```

**第二步：創建hive的外部表，映射HBase當中的表以及字段**

在hive當中創建外部表，

進入hive客戶端，而後執行如下命令進行建立hive外部表，就能夠實現映射HBase當中的表數據

```sql
CREATE external TABLE course.hbase2hive(id int, name string, score int) STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler' WITH SERDEPROPERTIES ("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/conf
vim sqoop-env.sh
```

```properties
#Set path to where bin/hadoop is available
export HADOOP_COMMON_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0

#Set path to where hadoop-*-core.jar is available
export HADOOP_MAPRED_HOME=/export/servers/hadoop-2.6.0-cdh5.14.0

#set the path to where bin/hbase is available
export HBASE_HOME=/export/servers/hbase-1.2.0-cdh5.14.0

#Set the path to where bin/hive is available
export HIVE_HOME=/export/servers/hive-1.1.0-cdh5.14.0
```

**第二步：在mysql當中建立數據庫以及數據庫表並插入數據**

**建立數據庫表**

```sql
CREATE DATABASE IF NOT EXISTS library;
USE library;
CREATE TABLE book(
id INT(4) PRIMARY KEY NOT NULL AUTO_INCREMENT,
NAME VARCHAR(255) NOT NULL,
price VARCHAR(255) NOT NULL);
```

**插入數據**

```sql
INSERT INTO book(NAME, price) VALUES('Lie Sporting', '30');
INSERT INTO book (NAME, price) VALUES('Pride & Prejudice', '70');
INSERT INTO book (NAME, price) VALUES('Fall of Giants', '50');
```

**第三步：將mysql表當中的數據導入HBase表當中去**

執行如下命令，將mysql表當中的數據導入到HBase當中去

```shell
bin/sqoop import \
--connect jdbc:mysql://192.168.52.102:3306/library \
--username root \
--password 123456 \
--table book \
--columns "id,name,price" \
--column-family "info" \
--hbase-create-table \
--hbase-row-key "id" \
--hbase-table "hbase_book" \
--num-mappers 1 \ //啓動n個mapper來並行導入默認是四個
--split-by id //按照某一列來切分表的工做單元
```

**第四步：HBase當中查看錶數據**

進入hbase的shell客戶端，經過scan查看數據

```sql
hbase(main):057:0> scan 'hbase_book'
ROW COLUMN+CELL
1 column=info:name, timestamp=1550634017823, value=Lie Sporting
1 column=info:price, timestamp=1550634017823, value=30
2 column=info:name, timestamp=1550634017823, value=Pride & Prejudice
2 column=info:price, timestamp=1550634017823, value=70
3 column=info:name, timestamp=1550634017823, value=Fall of Giants
3 column=info:price, timestamp=1550634017823, value=50

```

**需求二：將HBase當中的數據導出到mysql當中來**

將hbase_book這張表當中的數據導出到mysql當中來

注意：sqoop不支持咱們直接將HBase當中的數據導出，因此咱們能夠經過如下的轉換進行導出

Hbase→hive外部表→hive內部表→經過sqoop→mysql

**第一步：建立hive外部表**

進入hive客戶端，建立hive外部表，映射hbase當中的hbase_book表

```sql
CREATE EXTERNAL TABLE course.hbase2mysql (id int,name string,price int)
STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
WITH SERDEPROPERTIES (
"hbase.columns.mapping" =
":key,info:name, info:price"
)
TBLPROPERTIES( "hbase.table.name" = "hbase_book",
"hbase.mapred.output.outputtable" = "hbase2mysql");
```

**第二步：建立hive內部表並將外部表數據插入到內部表當中來**

進入hive客戶端，執行如下命令，建立hive內部表，並將外部表的數據插入到hive的內部表當中來

```sql
CREATE TABLE course.hbase2mysqlin(id int,name string,price int);
```

**第三步：外部表數據插入內部表**

進入hive客戶端執行如下命令，將hive外部表數據插入到hive內部表當中來

```sql
insert overwrite table course.hbase2mysqlin select * from course.hbase2mysql;
```

**第四步：清空mysql表數據**

進入mysql客戶端，執行如下命令，將mysql表數據清空

```sql
TRUNCATE TABLE book;
```

**第五步：執行sqoop導出hive內部表數據到**

```sql
sqoop export -connect jdbc:mysql://192.168.52.102:3306/library -username root -password 123456 -table book -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

![](jiqun-images/1565845619733.png)

![](jiqun-images/1565846083611.png)

## **spark**

Spark 2.x 環境搭建要點

**第1、Spark Quick Start**

**一、環境配置**

解壓編譯打包Spark壓縮包

```shell
# tar -zxf spark-2.2.0-bin-2.6.0-cdh5.14.0.tgz
```

基本配置：

**第一步、安裝Scala-2.11.8**

```shell
# tar -zxf scala-2.11.8.tgz -C /export/servers/
```

配置系統環境變量（也能夠不配置）

**第二步、修改配置名稱**

```shell
# cd /export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0
# cd conf
# mv spark-env.sh.template spark-env.sh
```

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

$SPARK_HOME/conf/spark-env.sh，增長以下內容：

```shell
## 設置JAVA和SCALA安裝目錄
JAVA_HOME=/export/servers/jdk
SCALA_HOME=/export/servers/scala

## HADOOP軟件配置文件目錄，讀取HDFS上文件和運行YARN集羣
HADOOP_CONF_DIR=/export/servers/hadoop/etc/hadoop
```

**第四步、啓動HDFS集羣**

```shell
# 執行腳本
./hdfs-start-cluster.sh
```

**第五步、本地模式運行spark-shell**

```shell
bin/spark-shell --master local[2]
```

**二、詞頻統計WordCount**

SparkCore中最重要的數據結構：RDD，彈性分佈式數據集，當作Scala集合中List列表就能夠

**第一步、讀取數據，封裝到RDD中，數據類型爲String**

```scala
// 讀取HDFS上數據文件
val inputRDD = sc.textFile("/datas/wordcount.input")

// 獲取RDD集合中第一行數據
inputRDD.first

// 獲取RDD集合元素個數
inputRDD.count
```

**第二步、處理數據，單詞分割，每一個單詞出現一次，按照單詞分組，進行統計**

```scala
// 單詞分割
val wordsRDD = inputRDD.flatMap(line => line.split("\\s+"))

// 將單詞轉換爲二元組，表示每一個單詞出現一次
val tuplesRDD = wordsRDD.map(word => (word, 1))

// 使用reduceByKey函數，先將相同Key的Values合併在一塊兒，在調用reduce函數將Values值進行聚合操做
val wordCountRDD = tuplesRDD.reduceByKey((a, b) => a + b)

// 調用collect函數，將RDD中的元素返回到Array數組中，注意collect慎用
wordCountRDD.collect()
```

**第三步、將結果存儲到HDFS目錄中**

```scala
wordCountRDD.saveAsTextFile("/datas/sparkOutput/")
```

**第四步、查看輸出結果**

```shell
# 查看文件，使用通配符*
bin/hdfs dfs -text /datas/sparkOutput/pa*
```

運行官方Example中**圓周率PI**計算

```SHELL
SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0
${SPARK_HOME}/bin/spark-submit \
--master local[4] \
--class org.apache.spark.examples.SparkPi \
${SPARK_HOME}/examples/jars/spark-examples_2.11-2.2.0.jar \
10
```

**第2、Spark Standalone Cluster**

**一、Standalone 集羣環境搭建**

**配置MASTER、Workers、HistoryServer**：`$SPARK_HOME/conf/spark-env.sh`
內容以下：

```shell
SPARK_MASTER_HOST=bigdata-cdh01.itcast.cn
SPARK_MASTER_PORT=7077
SPARK_MASTER_WEBUI_PORT=8080
SPARK_WORKER_CORES=2
SPARK_WORKER_MEMORY=2g
SPARK_WORKER_PORT=7078
SPARK_WORKER_WEBUI_PORT=8081
SPARK_HISTORY_OPTS="-Dspark.history.fs.logDirectory=hdfs://bigdata-cdh01.itcast.cn:8020/spark/eventLogs/ -Dspark.history.fs.cleaner.enabled=true"
```

- **建立EventLogs存儲目錄：**

```shell
bin/hdfs dfs -mkdir -p /spark/eventLogs/
```

- **Workers主機名稱：**$SPARK_HOME/conf/slaves

內容以下：

```shell
bigdata-cdh01.itcast.cn
bigdata-cdh02.itcast.cn
bigdata-cdh03.itcast.cn
```

- **配置全部Spark應用運行保存EventLogs**：$SPARK_HOME/conf/spark-defaults.conf
內容以下：

```shell
spark.eventLog.enabled true
spark.eventLog.dir hdfs://bigdata-cdh01.itcast.cn:8020/spark/eventLogs/
spark.eventLog.compress true
```

- **分發到集羣全部機器**

```shell
scp -r spark-2.2.0-bin-2.6.0-cdh5.14.0/ bigdata-cdh02.itcast.cn:$PWD
scp -r spark-2.2.0-bin-2.6.0-cdh5.14.0/ bigdata-cdh03.itcast.cn:$PWD
```

- **啓動服務進程**

- 在Master節點上啓動，進入`$SPARK_HOME`

- 主節點Master：

```shell
sbin/start-master.sh
```

WEB UI：http://bigdata-cdh02.itcast.cn:8080

- 從節點Workers：

```shell
sbin/start-slaves.sh
```

**備註：**必須配置主節點到全部從節點的SSH無密鑰登陸，集羣各個機器時間同步

- 歷史服務器HistoryServer：

```shell
sbin/start-history-server.sh
```

WEB UI：http://bigdata-cdh01.itcast.cn:18080

- **運行官方Example中圓周率PI計算**

```shell
SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0
${SPARK_HOME}/bin/spark-submit \
--master spark://bigdata-cdh01.itcast.cn:7077 \
--class org.apache.spark.examples.SparkPi \
${SPARK_HOME}/examples/jars/spark-examples_2.11-2.2.0.jar \
100
```

**二、Standalone HA 集羣**

基於Zookeeper配置Master高可用：

http://spark.apache.org/docs/2.2.0/spark-standalone.html#standby-masters-with-zookeeper

- **中止Spark Standalone集羣**

```shell
sbin/stop-master.sh
sbin/stop-slaves.sh
```

- **增長Zookeeper配置**：`$SPARK_HOME/conf/spark-env.sh`

內容以下：

```shell
SPARK_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"
```

刪除內容：

```shell
SPARK_MASTER_HOST=bigdata-cdh02.itcast.cn
```

- **將`spark-env.sh`分發集羣**

```shell
scp -r spark-env.sh bigdata-cdh02.itcast.cn:$PWD
scp -r spark-env.sh bigdata-cdh03.itcast.cn:$PWD
```

- **啓動集羣服務**

- 啓動Zokeeper 集羣服務，進入$ZOOKEEPER_HOME

```shell
bin/zkServer.sh start
```

- 在cdh02和cdh03機器啓動Master

```shell
sbin/start-master.sh
```

WEB UI：http://bigdata-cdh02.itcast.cn:8080 、 http://bigdata-cdh03.itcast.cn:8080

- 在cdh02（Activer Master）機器啓動全部Workers：Master爲Alive節點上執行

```shell
sbin/start-slaves.sh
```

- **運行官方Example中圓周率PI計算**

```shell
SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0
${SPARK_HOME}/bin/spark-submit \
--master spark://hadoop02:7077,hadoop03:7077 \
--class org.apache.spark.examples.SparkPi \
${SPARK_HOME}/examples/jars/spark-examples_2.11-2.2.0.jar \
100
```

**第3、Spark On YARN**

- **設置環境變量**

```shell
HADOOP_CONF_DIR=/export/servers/hadoop/etc/hadoop
YARN_CONF_DIR=/export/servers/hadoop/etc/hadoop
```

前面已設置，能夠不用同時設置HADOOP_CONF_DIR和YARN_CONF_DIR

- **配置服務監控（MRHistoryServer和Spark HistoryServer）**

`$HADOOP_HOME/etc/hadoop/yarn-site.xml`，內容以下：

```xml
<property>
<name>yarn.log-aggregation-enable</name>
<value>true</value>
</property>
<property>
<name>yarn.log.server.url</name>
<value>http://bigdata-cdh03.itcast.cn:19888/jobhistory/logs</value>
</property>
```

- **同步全部YARN集羣機器**

```shell
scp -r yarn-site.xml bigdata-cdh02.itcast.cn:$PWD
scp -r yarn-site.xml bigdata-cdh03.itcast.cn:$PWD
```

- **Spark Applicaiton默認配置**

`$SPARK_HOME/conf/spark-defaults.conf`文件增長以下內容：

```properties
spark.yarn.historyServer.address bigdata-cdh01.itcast.cn:18080
```

- **啓動HDFS集羣、YARN集羣和MRHistoryServer服務**

- HDFS 服務

```shell
# cdh01
sbin/hadoop-daemon.sh start namenode
# cdh01,cdh02,cdh03
sbin/hadoop-daemon.sh start datanode
```

- YARN 服務

```shell
# cdh02
sbin/yarn-daemon.sh start resourcemanager

# cdh01,cdh02,cdh03
sbin/yarn-daemon.sh start nodemanager
```

- MRHistoryServer 服務

```shell
# cdh03
sbin/mr-jobhistory-daemon.sh start historyserver
```

- **啓動Spark HistoryServer服務**

```shell
# cdh01
sbin/start-history-server.sh
```

WEB UI：http://bigdata-cdh01.itcast.cn:18080

- **運行官方Example中圓周率PI計算**

```shell
SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0
${SPARK_HOME}/bin/spark-submit \
--master yarn \
--class org.apache.spark.examples.SparkPi \
${SPARK_HOME}/examples/jars/spark-examples_2.11-2.2.0.jar \
10
```

**第4、Spark Submit Application**

**一、應用提交spark-submit**

```shell
Usage: spark-submit [options] <app jar | python file> [app arguments]
```

若是使用Java或Scala語言編程程序，須要將應用編譯後達成Jar包形式，提交運行。

**二、基本參數配置**

```shell
# 表示應用運行的模式，要麼是本地local要麼是集羣（Standalone、YARN、Mesos）
--master MASTER_URL
# 本地模式: local[2] Standalone集羣：spark://xxx:7077,yyy:7077 YARN 集羣： yarn

# 表示Drive Program運行的地方，也叫作應用部署模式，默認值爲client，一般在生成環境中使用cluster
--deploy-mode DEPLOY_MODE

# 表示運行Spark Application的類名稱，注意爲類的全名稱（包含包名）
--class CLASS_NAME

# 表示的是應用運行的名稱，一般在應用開發的時候指定
--name NAME A name of your application.

# 表示應用的類所依賴的第三方的Jar包指定路徑，一般在本地文件系統中，多個Jar包使用逗號隔開
--jars JARS

# 表示應用運行時指定的某些參數配置，http://spark.apache.org/docs/2.2.0/configuration.html
--conf PROP=VALUE

# 當value中值有空格組成的時候，使用雙引號將key=value引發來
--conf "PROP=VALUE"
```

動態加載Spark Applicaiton運行時的參數，經過`--conf`進行指定，以下使用方式：

```bash
# 第一種方式: 屬性的值中沒有空格
--conf spark.eventLog.enabled=false

# 第二種方式：屬性的值中有空格，將屬性和值統一使用雙引號引發來
--conf "spark.executor.extraJavaOptions=-XX:+PrintGCDetails -XX:+PrintGCTimeStamps"
```

Spark Application運行包括兩部分組成：Driver Program 和Executors，都是JVM進程，因此能夠設置每一個JVM進程中的資源，資源包括CPU Cores核數和內存Memory大小。

**三、Driver Program 參數配置**

```shell
# 指定Driver Program JVM進程內存大小，默認值爲1g
--driver-memory MEM

# 表示Driver 運行CLASS PATH路徑，使用很少
--driver-class-path

## Spark standalone with cluster deploy mode：運行在Standalone 中cluster Deploy Mode，默認值爲1
--driver-cores NUM

## 運行在YARN in cluster mode，默認值是1
--driver-cores NUM

## 運行在standalone的中cluster Deploy Mode下，表示當Driver運行異常失敗，能夠本身重啓
--supervise
```

**四、Executor參數配置**

```shell
# Executor運行所需內存大小
--executor-memory MEM

# Execturo 運行的CPU Cores，默認的狀況下，在Standalone集羣上爲Worker節點全部可有的CpuCores，在YARN集羣下爲1
--executor-cores NUM

# 表示運行在Standalone集羣下，全部Executor的CPU Cores，結合--executor-cores計算出Executor個數
--total-executor-cores NUM

# 表示在YARN集羣下，Executor的個數，默認值爲2
--num-executors

# 表示Executor運行的隊列，默認爲default隊列
--queue QUEUE_NAME
```

**第5、IDEA 開發環境**

建立Maven工程、建立模塊module，配置pom.xml文件內容以下：

```xml

<repositories>
<repository>
<id>aliyun</id>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
</repository>
<repository>
<id>cloudera</id>
<url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
</repository>
<repository>
<id>jboss</id>
<url>http://repository.jboss.com/nexus/content/groups/public</url>
</repository>
</repositories>

<dependencies>

<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-library</artifactId>
<version>${scala.version}</version>
</dependency>

<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-core_${scala.binary.version}</artifactId>
<version>${spark.version}</version>
</dependency>

<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-client</artifactId>
<version>${hadoop.version}</version>
</dependency>
</dependencies>

<build>
<outputDirectory>target/classes</outputDirectory>
<testOutputDirectory>target/test-classes</testOutputDirectory>
<resources>
<resource>
<directory>${project.basedir}/src/main/resources</directory>
</resource>
</resources>

<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<version>3.2.0</version>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>testCompile</goal>
</goals>
<configuration>
<args>
<arg>-dependencyfile</arg>
<arg>${project.build.directory}/.scala_dependencies</arg>
</args>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
```

### 集成Hive

Spark SQL主要目的是使得用戶能夠在Spark上使用SQL，其數據源既能夠是RDD，也能夠是外部
的數據源（好比文本、Hive、Json等）。Spark SQL的其中一個分支就是Spark on Hive，也就是
使用Hive中HQL的解析、邏輯執行計劃翻譯、執行計劃優化等邏輯，能夠近似認爲僅將物理執行
計劃從MR做業替換成了Spark做業。SparkSql整合hive就是獲取hive表中的元數據信息，而後通
過SparkSql來操做數據。
http://spark.apache.org/docs/2.2.0/sql-programming-guide.html#hive-tables
1）、編譯Spark源碼支持HIVE集成
參考文檔：http://spark.apache.org/docs/2.2.0/building-spark.html#building-with-hive-and-j
dbc-support

![](jiqun-images/1568130865748.png)

編譯命令以下：
./dev/make-distribution.sh --name custom-spark --tgz -Phadoop-2.6 -
Dhadoop.version=2.6.0-cdh5.14.0 -Phive -Phive-thriftserver -Pyarn

```shell
2）、未啓動Hive MetaStore服務
集成Hive，實質就是：SparkSQL應用運行時，能夠讀取Hive MetaStore中元數據，配置以下：

第一步：拷貝 hive-site.xml 配置文件至 SPARK_HOME/conf 目錄下（建議建立軟鏈接）
Configuration of Hive is done by placing your `hive-site.xml`, `core-
site.xml` (for security configuration), and `hdfs-site.xml` (for HDFS
configuration) file in `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目錄
Note that the hive.metastore.warehouse.dir property in hive-site.xml is
deprecated since Spark 2.0.0. Instead, use spark.sql.warehouse.dir to
specify the default location of database in warehouse.

建立SparkSession啓用集成Hive

val spark = SparkSession
.builder()
.appName("Spark Hive Example")
.config("spark.sql.warehouse.dir", warehouseLocation)
.enableHiveSupport()
.getOrCreate()
import spark.implicits._
import spark.sql

3）、啓動Hive MetaStore服務
當啓動Hive MetaStore服務之後，SparkSQL集成Hive時只要鏈接到MetaStore服務地址便可讀
取元數據。

第一步、啓動Hive MetaStore服務，腳本 metastore-start.sh 以下：

#!/bin/sh
HIVE_HOME=/export/servers/hive
## 啓動服務的時間
DATE_STR=`/bin/date '+%Y%m%d%H%M%S'`
# 日誌文件名稱(包含存儲路徑)
HIVE_SERVER2_LOG=${HIVE_HOME}/logs/hivemetastore-${DATE_STR}.log
## 啓動服務
/usr/bin/nohup ${HIVE_HOME}/bin/hive --service metastore >
${HIVE_SERVER2_LOG} 2> &1 &
啓動服務：
$ sh metastore-start.sh

附錄：配置Hive MetaStore服務，在 hive-site.xml 添加以下配置：
<property>
<name>hive.metastore.uris</name>
<value>thrift://bigdata-cdh01.itcast.cn:9083</value>
</property>
<property>
<name>hive.metastore.local</name>
<value>false</value>
</property>
<property>
<name>hive.metastore.warehouse.dir</name>
<value>/user/hive/warehouse</value>
</property>

第二步、建立 hive-site.xml 文件，放入 $SPARK_HOME/conf 目錄下，內容以下：
<?xml version="1.0".>
<?xml-stylesheet type="text/xsl" href="configuration.xsl".>
<configuration>
<property>
<name>hive.metastore.uris</name>
<value>thrift://bigdata-cdh01.itcast.cn:9083</value>
</property>
<property>
<name>spark.sql.warehouse.dir</name>
<value>/user/hive/warehouse</value>
</property>
</configuration>

4）、啓動spark-sql交互式命令行
啓動spark-sql交互式命令行
# 以本地模式運行spark-sql交互式命令行
$ cd /export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/
$ bin/spark-sql --master local[2] --conf spark.sql.shuffle.partitions=4 --
conf spark.sql.warehouse.dir=hdfs://hadoop01:8020/user/hive/warehouse
```

![](jiqun-images/%E5%BE%AE%E4%BF%A1%E6%88%AA%E5%9B%BE_20190907213700.png)

```shell
5）、啓動Spark ThriftServer服務
啓動Spark ThriftServer服務，客戶端Beeline命令行鏈接，開發測試：

# 以本地模式運行
SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/
# 啓動Spark ThriftServer服務
${SPARK_HOME}/sbin/start-thriftserver.sh \
--hiveconf hive.server2.thrift.port=10000 \
--hiveconf hive.server2.thrift.bind.host=hadoop03 \
--conf spark.sql.shuffle.partitions=4 \
--conf spark.sql.warehouse.dir=hdfs://hadoop01:8020/user/hive/warehouse \
--master local[4]

Beeline客戶端鏈接：
SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/
${SPARK_HOME}/bin/beeline
beeline> !connect jdbc:hive2://hadoop03:10000
Enter username for jdbc:hive2://hadoop03:10000: itcast
Enter password for jdbc:hive2://hadoop03:10000: ******
```

![](jiqun-images/%E5%BE%AE%E4%BF%A1%E6%88%AA%E5%9B%BE_20190907213811.png)

### 集成HBase

SparkSQL讀取Hive表中的數據，經過Hive與HBase集成來讀取HBase表的數據。
1）、依賴JAR包，添加到SparkSQL應用的CLASSPATH下面

```
hbase-client-1.2.0-cdh5.14.0.jar
hbase-common-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-prefix-tree-1.2.0-cdh5.14.0.jar
hbase-protocol-1.2.0-cdh5.14.0.jar
hbase-server-1.2.0-cdh5.14.0.jar
hive-hbase-handler-1.1.0-cdh5.14.0.jar
htrace-core-3.2.0-incubating.jar
metrics-core-2.2.0.jar
```

2）、將HBase Client配置文件放置到$SPARK_HOME/conf目錄（建立軟鏈接）

```shell
cd /export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0/conf
ln -s /export/servers/hbase/conf/hbase-site.xml hbase-site.xml
```

3）、啓動spark-sql命令行，添加依賴jar包

```shell
SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0
${SPARK_HOME}/bin/spark-sql \
--master local[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 \
--conf spark.sql.shuffle.partitions=4 \
--conf spark.sql.warehouse.dir=hdfs://bigdata-
cdh01.itcast.cn:8020/user/hive/warehouse
```

![1567904474989](jiqun-images/1567904474989.png)

4）、啓動SparkThrift Server服務
使用 spark.executor.extraClassPath 和 spark.driver.extraClassPath 將依賴的JAR包添
加到CLASSPATH路徑下。

```shell
SPARK_HOME=/export/servers/spark-2.2.0-bin-2.6.0-cdh5.14.0
${SPARK_HOME}/sbin/start-thriftserver.sh \
--hiveconf hive.server2.thrift.port=10000 \
--hiveconf hive.server2.thrift.bind.host=bigdata-cdh03.itcast.cn \
--master local[2] \
--conf spark.executor.extraClassPath=${SPARK_HOME}/lib/* \
--conf spark.driver.extraClassPath=${SPARK_HOME}/lib/* \
--conf spark.sql.shuffle.partitions=4 \
--conf spark.sql.warehouse.dir=hdfs://bigdata-
cdh01.itcast.cn:8020/user/hive/warehouse
```

![1567904518414](jiqun-images/1567904518414.png)

## Flink

**環境搭建**

**standAlone**

安裝包下載地址：

```shell
https://archive.apache.org/dist/flink/flink-1.7.0/
```

1.上傳：rz/ftp

2.解壓

```shell
tar -zxvf flink-1.6.0-bin-hadoop26-scala_2.11.tgz -C /export/servers/
```

![](jiqun-images/1567299947321.png)

3.配置文件修改

vim flink-conf.yaml

```shell
jobmanager.rpc.address: node01
jobmanager.rpc.port: 6123
jobmanager.heap.size: 1024
taskmanager.heap.size: 1024
taskmanager.numberOfTaskSlots: 1
taskmanager.memory.preallocate: false
parallelism.default: 1
jobmanager.web.port: 8081
taskmanager.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 #臨時文件的目錄
```

vim masters

```
node01:8081
```

vim slaves

```
node01
node02
node03
```

4.分發安裝包

```
scp -r flink-1.6.0/ node02:$PWD
scp -r flink-1.6.0/ node03:$PWD
```

5.啓停

```
./start-cluster.sh #啓動
./stop-cluster.sh #中止
```

![](jiqun-images/1567300649169.png)

6.頁面訪問

```
node01:8081
```

7.測試

```
bin/flink run examples/batch/WordCount.jar
```

![](jiqun-images/1567301809767.png)

**standAlone-HA(高可用)**

1.配置文件修改

vim flink-conf.yaml

```shell
#HA
state.backend: filesystem #檢查點的配置
state.backend.fs.checkpointdir: hdfs://node01:8020/flink-checkpoints
high-availability: zookeeper #HA 高可用模式的配置
high-availability.storageDir: hdfs://node01:8020/flink/ha/ #元數據
high-availability.zookeeper.quorum: node01:2181,node02:2181,node03:2181
```

vim master

```
node01:8081
node02:8081
```

分發配置文件

```shell
scp flink-conf.yaml node02:$PWD
scp flink-conf.yaml node03:$PWD
scp masters node02:$PWD
scp masters node03:$PWD
```

> 注意： node02節點上的flink-conf.yaml:
>
> jobmanager.rpc.address: node02

啓動

```shell
start-dfs.sh #hdfs
zkServer.sh start #zookeeper
./start-cluster.sh #flink
```

> 啓動高可用集羣：需先啓動hdfs,zookeeper

頁面訪問

```
node01:8081
```

**flink on yarn**

企業生產環境主要採用模式