手动搭建Hadoop环境
- 环境
namenode有2个，datanode有3个。
- 基础配置
- 环境变量
.bashrc(怕配覆盖就放.bash_profile中)
=============
export PS1="[\u@\h|\w]\\$ "
#alias
alias l='ls --group-directories-first --time-style=long-iso -l'
alias la='ls --group-directories-first --time-style=long-iso -lav'
alias ll='ls --group-directories-first --time-style=long-iso -lavh'
alias lt='ls --group-directories-first --time-style=long-iso -lat'
alias dus='du -sh'
#java
export JAVA_HOME="/home/hadoop/soft/jdk1.8.0"
export CLASSPATH=".:${JAVA_HOME}/lib:${CLASSPATH}"
export PATH="${JAVA_HOME}/bin:${PATH}"
-
- 修改hosts
需要root权限。
vim /etc/hosts
127.0.0.1 localhost
::1 localhost
192.168.1.51 hm01
192.168.1.52 hm02
192.168.1.53 hs01
192.168.1.54 hs02
192.168.1.55 hs03
-
- 无密码ssh互访
各主机间可以ssh无密码互访。
ssh-keygen -t rsa或ssh-keygen -t rsa -P ""
保持默认，无密码。
chmod 711 .ssh
cat id_rsa.pub >> authorized_keys
chmod 644 authorized_keys
authorized_keys权限过低或过高均不可无密码访问。
scp id_rsa.pub hadoop@hm02:~/.ssh/id_rsa.pub.hm01
各主机相互cat id_rsa.pub.x。
或使用
ssh-copy-id hadoop@hm02，把公钥发给对方并自动追加。
-
- 删除自带java/msysql
需要root权限。
rpm -qa | grep java
rpm -qa | grep mysql
rpm -e --nodeps 查询到的包名
-
- 修改ulimit和nproc
需要root权限。
1、设置ulimit
vim /etc/security/limits.conf
* soft nofile 32768
* hard nofile 65536
配置文件最前面的是指domain，设置为星号(*)代表全局，也可以针对不同的用户做出不同的限制，将星号替换为用户名。
2、设置nproc
vim /etc/security/limits.d/90-nproc.conf
* soft nproc 2048
* hard nproc 10240
3、添加pam_limits.so
vim /etc/pam.d/login
session required pam_limits.so
否则，在/etc/security/limits.conf上的配置不会生效，重启。
-
- 关闭防火墙和selinux
需要root权限。
1、关闭防火墙等服务
chkconfig iptables off
chkconfig ip6tables off
chkconfig bluetooth off
chkconfig mdmonitor off
chkconfig postfix off
2、关闭SELinux
vim /etc/selinux/config
SELINUX=disabled
重启。
修改网卡名eth1改成eth0：
在/etc/udev/rules.d/70-persistent-net.rules被识别成了eth0，而虚拟机中的识别成了eth1。
解决方法：
1.编辑/etc/udev/rules.d/70-persistent-net.rules,找到与ifconfig -a得出的MAC相同的一行(NAME='eth1'这一行)，把它改为"NAME=eth0 "，然后把上面一行(NAME='eth0')删除掉。
vim /etc/udev/rules.d/70-persistent-net.rules
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:0c:29:bb:41:2b", ATTR{type}=="1", KERNEL=="eth*", NAME="eth0"
2.编辑/etc/sysconfig/network-script/ifcfg-eth0,把MAC改为正确的，把UUID删掉。
3.编辑/etc/sysconf/network，把hostname也改一下。
4.重启生效。
-
- 时间同步
如果是在一台物理机上的不同虚拟机，时间差不多就不用设置了，如果是不同物理机必须设置。
1、检查是否安装
rpm -qa ntp
显示：ntp-4.2.6p5-1.el6.centos.x86_64，表示已经安装。
2、配置本地时间服务器
vi /etc/ntp.conf
#不变
driftfile /var/lib/ntp/drift
#不变
restrict default kod nomodify notrap nopeer noquery
restrict -6 default kod nomodify notrap nopeer noquery
#不变
restrict 127.0.0.1
restrict -6 ::1
#NTP服务器允许更新的客户机地址范围
restrict 192.168.1.0 mask 255.255.255.0 nomodify notrap
#公共时间服务器地址
server 0.centos.pool.ntp.org iburst
server 1.centos.pool.ntp.org iburst
server 2.centos.pool.ntp.org iburst
server 3.centos.pool.ntp.org iburst
#broadcast 192.168.1.255 autokey # broadcast server
#broadcastclient # broadcast client
#broadcast 224.0.1.1 autokey # multicast server
#multicastclient 224.0.1.1 # multicast client
#manycastserver 239.255.254.254 # manycast server
#manycastclient 239.255.254.254 autokey # manycast client
# Enable public key cryptography.
#crypto
includefile /etc/ntp/crypto/pw
# Key file containing the keys and key identifiers used when operating
# with symmetric key cryptography.
keys /etc/ntp/keys
# Specify the key identifiers which are trusted.
#trustedkey 4 8 42
# Specify the key identifier to use with the ntpdc utility.
#requestkey 8
# Specify the key identifier to use with the ntpq utility.
#controlkey 8
# Enable writing of statistics records.
#statistics clockstats cryptostats loopstats peerstats
- zookeeper
hs01/hs02/hs03作为zks节点。
-
- 配置
- 环境变量
- 配置
编辑环境变量文件(.bashrc)
export ZOO_HOME="/home/hadoop/soft/zookeeper-3.4.5"
export ZOO_LOG_DIR="/home/hadoop/work/zookeeper/logs"
export PATH="${ZOO_HOME}/bin:${PATH}"
-
-
- zoo.cfg
-
vi conf/zoo.cfg
# The number of milliseconds of each tick
tickTime=2000
# The number of ticks that the initial
# synchronization phase can take
initLimit=10
# The number of ticks that can pass between
# sending a request and getting an acknowledgement
syncLimit=5
# the directory where the snapshot is stored.
dataDir=/home/hadoop/work/zookeeper
# the port at which the clients will connect
clientPort=8501
server.1=hs01:8502:8503
server.2=hs02:8502:8503
server.3=hs03:8502:8503
minSessionTimeout=10000
maxSessionTimeout=60000
maxClientCnxns=20500
还有一个需要注意
zookeeper不会主动的清除旧的快照和日志文件，这个是操作者的责任。但是可以通过命令去定期的清理。
#!/bin/bash
#snapshot file dir
dataDir=/opt/zookeeper/zkdata/version-2
#tran log dir
dataLogDir=/opt/zookeeper/zkdatalog/version-2
#Leave 66 files
count=66
count=$[$count+1]
ls -t $dataLogDir/log.* | tail -n +$count | xargs rm -f
ls -t $dataDir/snapshot.* | tail -n +$count | xargs rm -f
#以上这个脚本定义了删除对应两个目录中的文件，保留最新的66个文件，可以将它写到crontab中，设置为每天凌晨2点执行一次就可以了。
#zk log dir del the zookeeper log
#logDir=
#ls -t $logDir/zookeeper.log.* | tail -n +$count | xargs rm -f
也可以在zoo.cfg中配置两个参数：
autopurge.purgeInterval，这个参数指定了清理频率，单位是小时，需要填写一个1或更大的整数，默认是0，表示不开启自己清理功能。
autopurge.snapRetainCount，这个参数和上面的参数搭配使用，这个参数指定了需要保留的文件数目。默认是保留3个。
-
-
- 工作目录
-
在hs01/hs02/hs03上执行。
mkdir -p /home/hadoop/work/zookeeper
mkdir -p /home/hadoop/work/zookeeper/logs
在work/zookeeper下，新建一个myid文件，将本机器对应的server.N的数字N写入此文件。
hs01对应1，hs02对应2，hs03对应3。
-
- 分发
scp到目标主机。
-
- 启动
在hs01/hs02/hs03上执行。
zkServer.sh start
-
- 验证
在hs01/hs02/hs03上执行。
zkServer.sh status
查看状态，有leader，follower即是正常。
zkCli.sh -server hs01:8501
连接zk服务器。
-
- 停止
在hs01/hs02/hs03上执行。
zkServer.sh stop
- hdfs
hm01/hm02互备NN，hs01/hs02/hs03作为DN。
-
- 配置
- 环境变量
- 配置
环境变量文件(.bashrc)
export HADOOP_HOME="/home/hdp/soft/hadoop"
export PATH="${HADOOP_HOME}/bin:${HADOOP_HOME}/sbin:${PATH}"
-
-
- hadoop-env.sh
-
在hadoop/etc/hadoop目录下。
hadoop-env.sh示例：
export HADOOP_CONF_DIR=${HADOOP_CONF_DIR:-"${HADOOP_HOME}/etc/hadoop"}
export HADOOP_LOG_DIR="/home/hadoop/work/hadoop/logs"
export HADOOP_PID_DIR="/home/hadoop/work/hadoop/pids"
export HADOOP_HEAPSIZE=6000
export HADOOP_NAMENODE_OPTS="-Xmx2048m -Xms2048m -Dhadoop.security.logger=${HADOOP_SECURITY_LOGGER:-INFO,RFAS} -Dhdfs.audit.logger=${HDFS_AUDIT_LOGGER:-INFO,NullAppender} $HADOOP_NAMENODE_OPTS"
export HADOOP_DATANODE_OPTS="-Xmx2048m -Xms2048m -Dhadoop.security.logger=ERROR,RFAS $HADOOP_DATANODE_OPTS"
# Where log files are stored. $HADOOP_HOME/logs by default.
#本地库压缩
export LD_LIBRARY_PATH="${HADOOP_HOME}/lib/native/:${HADOOP_HOME}/share/hadoop/common/lib:${LD_LIBRARY_PATH}"
说明：
LIBRARY_PATH，在程序编译期指定查找共享库(动态链接库)的路径。
LD_LIBRARY_PATH，在程序加载运行期指定查找共享库(动态链接库)时，除了系统默认路径(/lib,/usr/lib)之外的其它路径。
-
-
- hdfs-site.xml
-
配置项说明：
| 配置项名称 |
配置项说明 |
默认值 |
建议值 |
| dfs.nameservices |
集群标识，可以随便取，后面的所有配置要一致。 |
|
myhdcluster |
| dfs.ha.namenodes.myhdcluster |
该集群namenode两个主备节点的名称标识。配置格式【名称1，名称2】 |
|
nn1,nn2 |
| dfs.namenode.rpc-address.myhdcluster.nn1 |
nn1节点的提供rpc服务的端口。配置格式【主机名称：端口】 |
|
hm01:8020 |
| dfs.namenode.rpc-address.myhdcluster.nn2 |
nn2节点的提供rpc服务的端口。配置格式【主机名称：端口】 |
|
hm02:8020 |
| dfs.namenode.http-address.myhdcluster.nn1 |
nn1节点监控http服务的端口。配置格式【主机名称：端口】 |
|
hm01:8570 |
| dfs.namenode.http-address.myhdcluster.nn2 |
nn2节点监控http服务的端口。配置格式【主机名称：端口】 |
|
hm02:8570 |
| dfs.datanode.http-address |
datanode节点监控http服务的端口。配置格式【主机名称：端口】 |
|
0.0.0.0:8575 |
| dfs.namenode.shared.edits.dir |
Namenode日志存储服务端口。qjournal://host1:端口;host2:端口;…/集群标识名 |
|
qjournal://hs01:8485;hs02:8485;hs03:8485/myhdcluster |
| dfs.journalnode.edits.dir |
元数据日志存储目录。配置格式【绝对路径】 |
|
/home/hadoop/work/hadoop/jdata |
| dfs.permissions.enabled |
用户权限控制启动开关。 |
true |
false，不配置多租户，可设为false |
| dfs.replication |
文件副本数。 |
3 |
3 |
| dfs.namenode.name.dir |
元数据存储路径。配置格式【file://绝对路径】 |
|
file:///home/hadoop/work/hadoop/meta |
| dfs.datanode.data.dir |
数据节点数据存储路径。配置格式【file://绝对路径】 |
|
file:///home/hadoop/work/hadoop/data |
| dfs.ha.automatic-failover.enabled |
NameNode自动切换的功能开关。配置格式【ture/false】 |
|
true |
| dfs.client.failover.proxy.provider.myhdcluster |
失败代理，配置文件中没有。 少了会报unknown host错误 |
|
org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider |
| dfs.client.read.shortcircuit |
允许本地读取datanode块文件开关。配置格式【ture/false】 |
false |
false |
| dfs.block.local-path-access.user |
指定允许本地读取块的用户，同dfs.client.read.shortcircuit搭配使用 |
|
hdp |
| dfs.datanode.hdfs-blocks-metadata.enabled |
|
false |
使用默认即可 |
| dfs.datanode.data.dir.perm |
|
700 |
不配置多租户的话，使用默认700即可 |
| dfs.client.file-block-storage-locations.timeout.millis |
|
1000 |
使用默认即可 |
| dfs.namenode.handler.count |
Namenode上用于处理客户端，datanode的RPC的线程个数 |
10 |
集群大则该参数调大 |
| dfs.datanode.handler.count |
Datanode上用于处理RPC的线程个数 |
3 |
集群大则该参数调大 |
| dfs.blocksize |
块大小设置 |
128m |
256m，如果大部分文件都是小于256m，这个参数可以适当调小 |
| dfs.datanode.max.transfer.threads |
Hadoop允许打开最大文件数，默认4096，不设置会提示xcievers exceeded错误 |
|
409600 |
| dfs.image.transfer.bandwidthPerSec |
当ha失败时，备节点会同步主节点的edit日志。如果edit文件较多，备节点会频繁访问journalnode。而同步带宽不限制，将会把journalnode带宽占完，导致主节点无法访问journalnode，超时挂掉。 |
0 |
1048576 设置为1MB，可根据宽带情况调整。 |
| dfs.domain.socket.path |
本地hdfs和dn的通信端口。 |
|
/home/hdp/work/hadoop/hdfs-sockets/dn._PORT |
hdfs-site.xml示例：
-
-
- core-site.xml
-
配置项说明：
| 名称 |
说明 |
默认值 |
建议值 |
| fs.defaultFS |
集群名称标识，需要配置同hdfs-site.xml保持一致 |
|
myhdcluster |
| ha.zookeeper.quorum |
指定ha用于连接的Zookeeper集群信息。配置格式【主机名1：端口，主机名2：端口，..】 |
|
hs01:8501,hs02:8501,hs03:8501 |
| io.compression.codecs |
压缩和解压缩的方式设置 |
|
org.apache.hadoop.io.compress.SnappyCodec |
| hadoop.tmp.dir |
临时数据目录，建议不要设置到/tmp目录下 |
|
/home/hdp/work/hadoop/tmp |
| hadoop.http.staticuser.user |
web统计用户 |
|
hdp |
| io.file.buffer.size |
设置SequenceFile中用到的读/写缓存大小。要设置为系统页面大小的倍数，以byte为单位，默认值4KB(4096)。 |
4096 |
65535 |
| dfs.ha.fencing.methods |
隔离机制 |
|
sshfence |
| dfs.ha.fencing.ssh.private-key-files |
隔离机制免密码私钥文件 |
|
/home/hdp/.ssh/id_rsa |
| fs.trash.interval |
垃圾回收时间，分钟 |
0 |
10080 |
| ha.failover-controller.cli-check.rpc-timeout.ms |
ha在失败时的超时时间。 |
20000 |
60000 |
| ipc.client.connect.timeout |
namenode连接JN的超时时间。 |
20000 |
60000 |
| ipc.client.connect.retry.interval |
namenode连接JN的时间间隔 |
1000 |
10000 |
| ipc.client.connect.max.retries |
namenode连接JN的次数，少了可能还没有连上。 |
10 |
100 |
core-site.xml示例
-
-
- 指定slaves
-
vi slaves
hs01
hs02
hs03
每个datanode机器名字一行。
-
-
- 工作目录
-
mkdir -p /home/hdp/work/hadoop/logs
mkdir -p /home/hdp/work/hadoop/pids
mkdir -p /home/hdp/work/hadoop/jdata
mkdir -p /home/hdp/work/hadoop/meta
mkdir -p /home/hdp/work/hadoop/data
mkdir -p /home/hdp/work/hadoop/tmp
-
-
- nativelib
-
本地库(zlib,gzip)用于文件压缩，Hadoop默认启用本地库，从$HADOOP_HOME/lib/native/中加载本地库，还需要配置mapred-site.xml。
验证：hadoop checknative
如果加载成功，输出为：
17/06/28 10:28:54 INFO bzip2.Bzip2Factory: Successfully loaded & initialized native-bzip2 library system-native
17/06/28 10:28:54 INFO zlib.ZlibFactory: Successfully loaded & initialized native-zlib library
Native library checking:
hadoop: true /home/hadoop/soft/hadoop/lib/native/libhadoop.so.1.0.0
zlib: true /lib64/libz.so.1
snappy: true /usr/lib64/libsnappy.so.1
lz4: true revision:10301
bzip2: true /lib64/libbz2.so.1
openssl: true /usr/lib64/libcrypto.so
-
- 分发
如果不用mapreduce和yarn，此时就可分发程序。
scp hadoop整个目录到其它机器。
scp -r hadoop/ hdp@hm02:~/soft
-
- 格式化
首次启动前先格式化hdfs，NameNode基于Quorum Base共享存储方案，必须先启动JournalNode，以便QuorumJournalManager同步数据。
-
-
- 启动zks
-
在hs01/hs02/hs03上启动zookeeper。
zkServer.sh start
-
-
- 启动JournalNode
-
在JN节点hs01/hs02/hs03上启动。
hadoop-daemon.sh start journalnode
-
-
- 格式化主namenode
-
在hm01上格式化HDFS的namenode节点。
hdfs namenode -format
在倒数第7行左右出现：
INFO common.Storage: Storage directory /home/hdp/work/hadoop/meta has been successfully formatted.
该指令执行成功后，在dfs.namenode.name.dir配置项(配置值为：/home/hdp/work/hadoop/meta)目录下会生成子目录和文件。
-
-
- 启动主namenode
-
启动在hm01上的namenode。
hadoop-daemon.sh start namenode
-
-
- 同步备namenode
-
在hm02上执行命令
hdfs namenode -bootstrapStandby
至此，HDFS集群初始化完毕。
-
-
- 启动备namenode
-
启动hm02上的namenode。
hadoop-daemon.sh start namenode
-
-
- 格式化zkfc
-
在hm01上格式化ZooKeeper集群，目的是在ZooKeeper上建立HA的相应节点，用于保存hadoop集群中NameNode的状态数据。
hdfs zkfc -formatZK
-
-
- 启动zkfc
-
在hm01/hm02上执行。
hadoop-daemon.sh start zkfc
通过页面可以检查namenode的节点状态。
http://hm01:8570
一个是active，一个是standby。
-
-
- 停止NN，JN，ZKFC
-
在hm01/hm02上执行。
hadoop-daemon.sh stop namenode
hadoop-daemon.sh stop zkfc
在hs01/hs02/hs03上执行。
hadoop-daemon.sh stop journalnode
集群准备好正常启动。
-
- 启动
- 集群启动
- 启动
在hm01上执行。
如果集群启动有问题，就修改sh文件，调顺序，journal，namenode，zkfc，datanode，yarn。
start-dfs.sh
-
-
- 单点启动
-
1、在hs01/hs02/hs03上执行。
zkServer.sh start
hadoop-daemon.sh start journalnode
2、在hm01/hm02上执行。
hadoop-daemon.sh start namenode
hadoop-daemon.sh start zkfc
3、在hs01/hs02/hs03上执行。
hadoop-daemon.sh start datanode
-
- 验证
1、在hm01上执行，检查文件存储。
hadoop fs -put hdfs-site.xml /
hadoop fs -ls /
hadoop fs -cat /hdfs-site.xml
能够正确查看到文件内容为正常。
2、查看ha状态。
http://hm01:8570，是active。
http://hm02:8570，是standby。
或命令
hdfs haadmin -getServiceState nn1
hdfs haadmin -getServiceState nn2
3、切换ha
在hm01上执行
hadoop-daemon.sh stop namenode
手动切换到active，配置自动切换就不能用手动了。
hdfs haadmin -transitionToActive nn1 --forceactive
手动切换到standby
hdfs haadmin -transitionToStandby nn1 --forceactive
4、新加datanode，做集群负载重均衡
start-balancer.sh -threshold 8 #指DN磁盘利用率，默认10。
5、检测压缩本地库
在任意机器上执行。
hadoop checknative
-
- 停止
- 集群停止
- 停止
在hm01上执行。
stop-dfs.sh
-
-
- 单点停止
-
1、在hm01/hm02上执行。
hadoop-daemon.sh stop namenode
hadoop-daemon.sh stop zkfc
2、在hs01/hs02/hs03上执行。
hadoop-daemon.sh stop datanode
hadoop-daemon.sh stop journalnode
zkServer.sh stop
- yarn
hm01/hm02互备RM，hs01/hs02/hs03作为NM。
-
- 配置
- mapred-env.sh
- 配置
export HADOOP_MAPRED_LOG_DIR=/home/hdp/work/hadoop/logs
export HADOOP_MAPRED_PID_DIR=/home/hdp/work/hadoop/pids
export HADOOP_JOB_HISTORYSERVER_HEAPSIZE=1000
export HADOOP_MAPRED_ROOT_LOGGER=INFO,RFA
export HADOOP_JOB_HISTORYSERVER_OPTS="-Dmapreduce.hs.audit.logger=INFO,HSAUDIT $HADOOP_JOB_HISTORYSERVER_OPTS"
-
-
- mapred-site.xml
-
MRv2重新命名了MRv1中的所有配置参数，但兼容MRv1中的旧参数。
MRv2参数以【mapreduce】开头，MRv1参数以【mapred】开头。
| 名称 |
说明 |
默认值 |
建议值 |
| io属性 |
|||
| mapreduce.task.tmp.dir |
task的临时目录 |
./tmp |
/home/hdp/work/hadoop/mapred/tmp |
| mapreduce.map.cpu.vcores |
每个map task可申请的虚拟cpu数 |
1 |
1 |
| mapreduce.reduce.cpu.vcores |
每个reduce task可申请的虚拟cpu数 |
1 |
1 |
| mapreduce.jobtracker.persist.jobstatus.dir |
job状态信息 |
/jobtracker/jobsInfo |
/home/hdp/work/hadoop/mapred/jobstatus |
| mapreduce.output.fileoutputformat.compress |
是否对job启用压缩 |
false |
true |
| mapreduce.output.fileoutputformat.compress.type |
压缩类型，NONE, RECORD or BLOCK |
RECORD |
RECORD |
| mapreduce.output.fileoutputformat.compress.codec |
压缩编码，用的snappy要提前编译进Hadoop |
org.apache.hadoop.io.compress.DefaultCodec |
org.apache.hadoop.io.compress.SnappyCodec |
| mapreduce.map.output.compress |
是否对map压缩 |
false |
true |
| mapreduce.map.output.compress.codec |
压缩编码 |
org.apache.hadoop.io.compress.DefaultCodec |
org.apache.hadoop.io.compress.SnappyCodec |
| MR YARN Application |
|||
| mapreduce.framework.name |
执行mr程序的框架 |
local |
yarn |
| yarn.app.mapreduce.am.staging-dir |
提交job的临时目录 |
/tmp/hadoop-yarn/staging |
/home/hdp/work/hadoop/mapred/staging |
| Job Notification |
|||
| yarn.app.mapreduce.am.resource.mb |
MR AppMaster的总内存 |
1536 |
2048 |
| yarn.app.mapreduce.am.resource.cpu-vcores |
MR AppMaster需要的虚拟cpu数 |
1 |
1 |
| mapreduce.application.classpath |
MR applications的classpath，逗号分隔 |
无 |
${HADOOP_HOME}/share/hadoop/mapreduce/*,${HADOOP_HOME}/share/hadoop/mapreduce/lib/*
|
| mapreduce.app-submission.cross-platform |
可否跨平台提交任务 |
false |
true |
| jobhistory |
|||
| mapreduce.jobhistory.intermediate-done-dir |
mr历史记录临时目录 |
${yarn.app.mapreduce.am.staging-dir}/history/done_intermediate |
/home/hdp/work/hadoop/mapred/jobhisim |
| mapreduce.jobhistory.done-dir |
mr历史记录完成目录 |
${yarn.app.mapreduce.am.staging-dir}/history/done |
/home/hdp/work/hadoop/mapred/jobhisdone |
示例
-
-
- yarn-env.sh
-
如果仅启动HDFS，则无需配置此文件。
| 名称 |
说明 |
默认值 |
建议值 |
| JAVA_HOME |
指明JDK目录 |
系统jdk目录 |
/home/hadoop/soft/jdk1.8.0 |
| YARN_HEAPSIZE |
进程分配最大内存空间大小，根据主机内存来确定,单位M |
1000 |
主机上面所有yarn进程使用的内存最大量，如果涉及到复用部署(例如，rm和nm部署在同一台主机上)，若单独指定了rm和nm的内存使用量，该值应大于复用进程内存使用量之和。 |
| YARN_RESOURCEMANAGER_OPTS |
resoucemanager启动加载参数 |
|
建议在该参数中设置rm的虚拟机参数 |
| YARN_RESOURCEMANAGER_HEAPSIZE |
Resoucemanager进程分配最大内存空间大小，根据主机内存来确定，单位M |
1000 |
主机上面rm进程使用的内存最大量, 建议值2G |
| YARN_NODEMANAGER_OPTS |
nodemanager启动加载参数 |
|
建议在该参数中设置nm的虚拟机参数 |
| YARN_NODEMANAGER_HEAPSIZE |
nodemanager进程分配最大内存空间大小，根据主机内存来确定，单位M |
1000 |
主机上面rm进程使用的内存最大量,建议值2G,主机其它内存留于container |
| YARN_LOG_DIR |
进程日志存放目录 |
$HADOOP_HOME/logs |
|
| YARN_PID_DIR |
进程当前进程号存放目录 |
/tmp |
|
yarn-env.sh示例
# User for YARN daemons
export HADOOP_YARN_USER=${HADOOP_YARN_USER:-yarn}
# resolve links - $0 may be a softlink
export YARN_CONF_DIR="${YARN_CONF_DIR:-$HADOOP_HOME/etc/hadoop}"
export YARN_LOG_DIR=/home/hadoop/work/hadoop/logs
export YARN_PID_DIR=/home/hadoop/work/hadoop/pids
# some Java parameters
#export JAVA_HOME=/home/hadoop/soft/jdk1.8.0
if [ "$JAVA_HOME" != "" ]; then
#echo "run java in $JAVA_HOME"
JAVA_HOME=$JAVA_HOME
fi
if [ "$JAVA_HOME" = "" ]; then
echo "Error: JAVA_HOME is not set."
exit 1
fi
JAVA=$JAVA_HOME/bin/java
JAVA_HEAP_MAX=-Xmx1000m
# For setting YARN specific HEAP sizes please use this
# Parameter and set appropriately
#YARN_HEAPSIZE=1000
# check envvars which might override default args
if [ "$YARN_HEAPSIZE" != "" ]; then
JAVA_HEAP_MAX="-Xmx""$YARN_HEAPSIZE""m"
fi
# Resource Manager specific parameters
# in the scale of MB. For example, to specify an jvm option of -Xmx1000m, set
# the value to 1000.
# This value will be overridden by an Xmx setting specified in either YARN_OPTS
# and/or YARN_RESOURCEMANAGER_OPTS.
# If not specified, the default value will be picked from either YARN_HEAPMAX
# or JAVA_HEAP_MAX with YARN_HEAPMAX as the preferred option of the two.
#export YARN_RESOURCEMANAGER_HEAPSIZE=1000
# Specify the JVM options to be used when starting the ResourceManager.
# These options will be appended to the options specified as YARN_OPTS
# and therefore may override any similar flags set in YARN_OPTS
#export YARN_RESOURCEMANAGER_OPTS=
# Node Manager specific parameters
# Specify the max Heapsize for the NodeManager using a numerical value
# in the scale of MB. For example, to specify an jvm option of -Xmx1000m, set
# the value to 1000.
# This value will be overridden by an Xmx setting specified in either YARN_OPTS
# and/or YARN_NODEMANAGER_OPTS.
# If not specified, the default value will be picked from either YARN_HEAPMAX
# or JAVA_HEAP_MAX with YARN_HEAPMAX as the preferred option of the two.
#export YARN_NODEMANAGER_HEAPSIZE=1000
# Specify the JVM options to be used when starting the NodeManager.
# These options will be appended to the options specified as YARN_OPTS
# and therefore may override any similar flags set in YARN_OPTS
#export YARN_NODEMANAGER_OPTS=
-
-
- yarn-site.xml
-
配置项说明：
| 名称 |
说明 |
默认值 |
建议值 |
| yarn.resourcemanager.ha.enabled |
是否开启resourcemanager HA |
false |
true |
| yarn.resourcemanager.cluster-id |
集群id，主/备节点选举成active时使用 |
|
yarn-cluster |
| yarn.resourcemanager.ha.rm-ids |
该集群resourcemanager主/备节点的名称标识 |
|
rm1,rm2 |
| yarn.resourcemanager.ha.id |
Resourcemanager主/备节点。主节点填写rm1，备节点填写rm2 |
|
rm1 |
| yarn.resourcemanager.ha.automatic-failover.enabled |
主节点出现故障时，是否开启自动切换到备节点 |
true |
true |
| yarn.resourcemanager.ha.automatic-failover.embedded |
使嵌入式自动故障转移。HA环境启动，与ZKRMStateStore配合处理fencing |
true |
true |
| yarn.resourcemanager.recovery.enabled |
Resourcemanager出现故障是否，是否开启job恢复 |
false |
true |
| yarn.resourcemanager.rm1 |
Resourcemanager主节点主机配置。填主机名 |
|
hm01 |
| yarn.resourcemanager.rm2 |
Resourcemanager备节点主机配置。填主机名 |
|
hm02 |
| yarn.resourcemanager.zk-address |
Zookeeper集群。zks主机名:端口，多个zk节点用【,】分隔 |
127.0.0.1:2181 |
hs01:8501,hs02:8501,hs03:8501 |
| yarn.resourcemanager.zk-state-store.parent-path |
Resourcemanager存储在zks上的全路径 |
/rmstore |
/yarn-cluster |
| yarn.resourcemanager.store.class |
Resourcemanager恢复job的类，ZKRMStateStore配置 |
org.apache.hadoop.yarn.server.resourcemanager.recovery.FileSystemRMStateStore |
org.apache.hadoop.yarn.server.resourcemanager.recovery.ZKRMStateStore |
| yarn.resourcemanager.scheduler.class |
启用的资源调度器主类。有FIFO、Capacity Scheduler和Fair Scheduler。 org.apache.hadoop.yarn.server.resourcemanager.scheduler.fifo.FifoScheduler， org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler， org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler |
org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler |
org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler |
| yarn.resourcemanager.connect.retry-interval.ms |
Resourcemanager链接失败重链间隔时间 |
30000 |
2000 |
| yarn.resourcemanager.scheduler.monitor.enable |
scheduler监控 |
|
true |
| yarn.admin.acl |
管理员列表 |
* |
hdp |
|
|
|||
| yarn.nodemanager.aux-services |
NodeManager上运行的附属服务,需填mapreduce_shuffle才能运行MapReduce程序 |
|
mapreduce_shuffle |
| yarn.nodemanager.aux-services.mapreduce_shuffle.class |
附属在nodemanager上的服务类 |
|
org.apache.hadoop.mapred.ShuffleHandler |
| yarn.nodemanager.local-dirs |
Nodemanager临时本地目录。填本地绝对路径，多个路径使用【,】分隔 |
${hadoop.tmp.dir}/nm-local-dir |
/home/hadoop/work/hadoop/yarn |
| yarn.nodemanager.log-dirs |
Nodemanager日志目录。本地绝对路径，多个路径使用【,】分隔 |
${yarn.log.dir}/userlogs |
/home/hadoop/work/hadoop/logs |
| yarn.nodemanager.vmem-check-enabled |
虚拟内存检查。 如果用spark的yarn模式导致am被杀掉，就是虚拟内存不足引起的，可关掉。 |
|
true |
| yarn.nodemanager.vmem-pmem-ratio |
任务每使用1MB物理内存，最多可使用的虚拟内存量。用free -m检查swap大小，根据情况定。 |
2.1 |
2.1 |
| yarn.nodemanager.resource.memory-mb |
NM上可用内存量，单位是MB |
8192 |
不能超过物理内存，同时考虑其它进程占用 |
| yarn.nodemanager.localizer.address |
本地ipc地址 |
|
0.0.0.0:8040 |
| yarn.nodemanager.webapp.address |
NM的web访问地址 |
|
0.0.0.0:8042 |
| yarn.resourcemanager.address.rm1 |
主节点rm1对应的ResourceManager对外的IPC地址,客户端可通过该地址向RM提交应用程序，杀死应用程序。 |
|
${yarn.resourcemanager.rm1}:8032 |
| yarn.resourcemanager.scheduler.address.rm1 |
主节点rm1对应的ResourceManager对ApplicationMaster暴露的访问地址，ApplicationMaster通过该地址向RM申请资源、释放资源等 |
|
${yarn.resourcemanager.rm1}:8030 |
| yarn.resourcemanager.webapp.address.rm1 |
主节点rm1对应的RM的web访问地址，用户可通过该地址在浏览器中查看集群各类信息 |
|
${yarn.resourcemanager.rm1}:8088 |
| yarn.resourcemanager.resource-tracker.address.rm1 |
主节点rm1对应的ResourcceTracker对外的IPC地址，NodeManager通过该地址向RM汇报心跳，领取任务等 |
|
${yarn.resourcemanager.rm1}:8031 |
| yarn.resourcemanager.admin.address.rm1 |
主节点rm1对应的ResourceManager对管理员暴露的访问地址，管理员通过该地址向RM发送管理命令等 |
|
${yarn.resourcemanager.rm1}:8033 |
| yarn.resourcemanager.ha.admin.address.rm1 |
|
|
${yarn.resourcemanager.rm1}:8034 |
| yarn.resourcemanager.address.rm2 |
主节点rm2对应的ResourceManager对外的IPC地址,客户端可通过该地址向RM提交应用程序，杀死应用程序。 |
|
${yarn.resourcemanager.rm2}:8032 |
| yarn.resourcemanager.scheduler.address.rm2 |
主节点rm2对应的ResourceManager 对ApplicationMaster暴露的访问地址，ApplicationMaster通过该地址向RM申请资源、释放资源等 |
|
${yarn.resourcemanager.rm2}:8030 |
| yarn.resourcemanager.webapp.address.rm2 |
主节点rm2对应的RM 的web访问地址，用户可通过该地址在浏览器中查看集群各类信息 |
|
${yarn.resourcemanager.rm2}:8088 |
| yarn.resourcemanager.resource-tracker.address.rm2 |
主节点rm2对应的ResourcceTracker对外的IPC地址，NodeManager通过该地址向RM汇报心跳，领取任务等 |
|
${yarn.resourcemanager.rm2}:8031 |
| yarn.resourcemanager.admin.address.rm2 |
主节点rm2对应的ResourceManager 对管理员暴露的访问地址，管理员通过该地址向RM发送管理命令等 |
|
${yarn.resourcemanager.rm2}:8033 |
| yarn.resourcemanager.ha.admin.address.rm2 |
|
|
${yarn.resourcemanager.rm2}:8034 |
| yarn.resourcemanager.resource-tracker.client.thread-count |
Resourcemanager启动处理NodeManager RPC请求的Handler数目 |
50 |
|
| yarn.resourcemanager.scheduler.client.thread-count |
处理来自ApplicationMaster的RPC请求的Handler数目 |
50 |
|
| yarn.scheduler.minimum-allocation-mb |
单个任务可申请的最少物理内存量 |
1024 |
|
| yarn.scheduler.maximum-allocation-mb |
单个任务可申请的最多物理内存量 |
8192 |
单台nodemanager上的可用内存 |
| yarn.resourcemanager.nodes.include-path |
nodeManager白名单 |
|
|
| yarn.resourcemanager.nodes.exclude-path |
nodeManager黑名单 |
|
|
| yarn.scheduler.minimum-allocation-vcores |
单个任务可申请的最小虚拟CPU个数 |
1 |
|
| yarn.scheduler.maximum-allocation-vcores |
单个任务可申请的最大虚拟CPU个数 |
32 |
不能超过一台nodemanager的物理cpu |
| yarn.resourcemanager.nodemanagers.heartbeat-interval-ms |
NodeManager与resoucemanager间心跳间隔(单位：毫秒) |
1000 |
|
| yarn.log-aggregation-enable |
是否启动日志聚集功能 |
false |
true |
| yarn.log-aggregation.retain-seconds |
在HDFS上聚集的日志最多保存多长时间 |
-1 |
3天 |
| yarn.nodemanager.resource.cpu-vcores |
nodemanager节点上可使用的虚拟CPU个数 |
8 |
会自动检测，可不设置 |
| yarn.scheduler.fair.allocation.file |
Fair Scheduler调度策略自定义XML配置文件所在位置 |
fair-scheduler.xml |
配置文件所在$HADOOP_HOME/etc/hadoop下 |
| yarn.scheduler.minimum-allocation-mb/yarn.scheduler.maximum-allocation-mb |
单容器可申请的最小/最大内存。 |
1024/8192 |
|
示例：
-
-
- fair-scheduler.xml
-
-
-
- 工作目录
-
mkdir -p /home/hdp/work/hadoop/mapred/tmp
mkdir -p /home/hdp/work/hadoop/mapred/jobstatus
mkdir -p /home/hdp/work/hadoop/mapred/staging
mkdir -p /home/hdp/work/hadoop/mapred/jobhisim
mkdir -p /home/hdp/work/hadoop/mapred/jobhisdone
mkdir -p /home/hdp/work/hadoop/yarn
-
- 分发
将所有配置scp到其它机器上。RM的备节点hm02要改yarn.resourcemanager.ha.id对应的值。
-
- 启动
- 集群启动
- 启动
在hm01上执行。
start-yarn.sh
在hm02上执行，备节点需单启。
yarn-daemon.sh start resourcemanager
-
-
- 单点启动
-
在hm01/hm02上执行。
yarn-daemon.sh start resourcemanager
在hs01/hs02/hs03上执行。
yarn-daemon.sh start nodemanager
-
- 验证
1、在hm01上执行
hadoop fs -mkdir -p /test/in
hadoop fs -put /etc/hosts /test/in
hadoop jar /home/hadoop/soft/hadoop/share/hadoop/mapreduce/hadoop-mapreduce-examples-2.5.0-cdh5.3.0.jar wordcount /test/in /test/out
注意，不能在hdfs中创建/test/out目录，完成后在/test/out/part-r-00000文件里记录了结果。
2、查看ha状态
http://hm01:8088，是active
http://hm02:8088，是standby
或
yarn rmadmin -getServiceState rm1
yarn rmadmin -getServiceState rm2
3、切换
在hm01上执行
yarn-daemon.sh stop resourcemanager
手动切换到active
yarn rmadmin -transitionToActive rm1 --forceactive
手动切换到standby
yarn rmadmin -transitionToStandby rm1 --forceactive
-
- 停止
- 集群停止
- 停止
在hm01上执行。
stop-yarn.sh
在hm02上执行。
yarn-daemon.sh stop resourcemanager
-
-
- 单点停止
-
在hm01/hm02上执行。
yarn-daemon.sh stop resourcemanager
在hs01/hs02/hs03上执行。
yarn-daemon.sh stop nodemanager
-
- 参数说明
必须确切理解参数含义和相关配置。一般为每个磁盘和每个核分配两个容器。
-
-
- MR作业
-
可在客户端的mapred-site.xml中配置，作为MapReduce作业的缺省配置参数。也可以在作业提交时，个性化指定这些参数。
| 参数名称 |
缺省值 |
说明 |
| mapreduce.map.memory.mb |
1024 |
每个map task可申请的内存。
|
| mapreduce.map.cpu.vcores |
1 |
每个map task可申请的虚拟CPU数 |
| mapreduce.reduce.memory.mb |
1024 |
每个reduce task可申请的内存 |
| mapreduce.reduce.cpu.vcores |
1 |
每个Reduce Task可申请的虚拟CPU数 |
-
-
- RM相关
-
1、yarn.resourcemanager.address
参数解释：ResourceManager对客户端暴露的地址。
默认值：${yarn.resourcemanager.hostname}:8032
2、yarn.resourcemanager.scheduler.address
参数解释：ResourceManager对ApplicationMaster暴露的访问地址。ApplicationMaster通过该地址向RM申请资源、释放资源等。
默认值：${yarn.resourcemanager.hostname}:8030
3、yarn.resourcemanager.resource-tracker.address
参数解释：ResourceManager对NodeManager暴露的地址。NodeManager通过该地址向RM汇报心跳，领取任务等。
默认值：${yarn.resourcemanager.hostname}:8031
4、yarn.resourcemanager.admin.address
参数解释：ResourceManager对管理员暴露的访问地址。管理员通过该地址向RM发送管理命令等。
默认值：${yarn.resourcemanager.hostname}:8033
5、yarn.resourcemanager.webapp.address
参数解释：ResourceManager对外web ui地址。用户可通过该地址在浏览器中查看集群各类信息。
默认值：${yarn.resourcemanager.hostname}:8088
6、yarn.resourcemanager.scheduler.class
参数解释：启用的资源调度器主类。目前可用的有FIFO、Capacity Scheduler和Fair Scheduler。
默认值：
org.apache.hadoop.yarn.server.resourcemanager.scheduler.capacity.CapacityScheduler
7、yarn.resourcemanager.resource-tracker.client.thread-count
参数解释：处理来自NodeManager的RPC请求的Handler数目。
默认值：50
8、yarn.resourcemanager.scheduler.client.thread-count
参数解释：处理来自ApplicationMaster的RPC请求的Handler数目。
默认值：50
9、yarn.scheduler.minimum-allocation-mb/ yarn.scheduler.maximum-allocation-mb
参数解释：单容器可申请的最小/最大内存。
默认值：1024/8192
10、yarn.scheduler.minimum-allocation-vcores / yarn.scheduler.maximum-allocation-vcores
参数解释：单容器可申请的最小/最大虚拟CPU个数。
默认值：1/4
11、yarn.resourcemanager.nodes.include-path /yarn.resourcemanager.nodes.exclude-path
参数解释：NodeManager黑白名单。如果发现若干个NodeManager存在问题，比如故障率很高，任务运行失败率高，则可以将之加入黑名单中。注意，这两个配置参数可以动态生效。(调用一个refresh命令即可)
默认值：""
12、yarn.resourcemanager.nodemanagers.heartbeat-interval-ms
参数解释：NodeManager心跳间隔
默认值：1000(毫秒)
-
-
- NM相关
-
1、yarn.nodemanager.resource.memory-mb
参数解释：NodeManager总的可用物理内存。默认8192MB，即使机器内存不够8192MB，YARN也会按照这些内存来使用，因此，这个值一定要配置。
默认值：8192
2、yarn.nodemanager.vmem-pmem-ratio
参数解释：每使用1MB物理内存，最多可用的虚拟内存数。
默认值：2.1
3、yarn.nodemanager.resource.cpu-vcores
参数解释：NodeManager总的可用虚拟CPU个数。
默认值：8
4、yarn.nodemanager.local-dirs
参数解释：中间结果存放位置，类似于1.0中的mapred.local.dir。注意，这个参数通常会配置多个目录，已分摊磁盘IO负载。
默认值：${hadoop.tmp.dir}/nm-local-dir
5、yarn.nodemanager.log-dirs
参数解释：日志存放地址(可配置多个目录)。
默认值：${yarn.log.dir}/userlogs
6、yarn.nodemanager.log.retain-seconds
参数解释：NodeManager上日志最多存放时间(不启用日志聚集功能时有效)。
默认值：10800(3小时)
7、yarn.nodemanager.aux-services
参数解释：NodeManager上运行的附属服务。需配置成mapreduce_shuffle，才可运行MapReduce程序
默认值：""
-
-
- 内存配置
-
1、RM内存配置
RM1：yarn.scheduler.minimum-allocation-mb，分配给AM单个容器的最小内存。
RM2：yarn.scheduler.maximum-allocation-mb，分配给AM单个容器的最大内存。
说明：RM1可计算节点最大Container数。
2、NM内存配置
NM1：yarn.nodemanager.resource.memory-mb，节点最大可用内存。
NM2：yarn.nodemanager.vmem-pmem-ratio，可用虚拟内存比率。
说明：
RM1、RM2的值均不能大于NM1的值。
NM1可计算节点最大Container数量，max(Container)=NM1/RM2。
3、AM内存配置
AM1：mapred.job.map.memory.mb，分配给map Container的内存。
AM2：mapred.job.reduce.memory.mb，分配给reduce Container的内存。
AM3：mapreduce.map.java.opts，运行map的jvm参数，如-Xmx，-Xms等。
AM4：mapreduce.reduce.java.opts，运行reduce的jvm参数，如-Xmx，-Xms等。
说明：
AM1/2应该在RM1和RM2之间，AM2的值最好为AM1的两倍。
AM3/4应该在AM1和AM2之间。
4、Container
(1)、Container是YARN中资源的抽象，它封装了节点上一定量的资源(CPU和内存)，从实现上可看做一个序列化/反序列化的Java类。
(2)、Container是AM向RM申请的，由RM中的资源调度器异步分配给AM。
(3)、Container运行是由AM向资源所在的NM发起的，Container运行时需提供内部执行的任务命令以及该命令执行所需的环境变量和外部资源(比如可执行文件、jar包等)。
一个应用程序所需的Container分为两大类，如下：
a、运行ApplicationMaster的Container，这是由ResourceManager(向内部的资源调度器)申请和启动的，用户提交应用程序时，可指定唯一的ApplicationMaster所需的资源。
b、运行各类任务的Container，这是由ApplicationMaster向ResourceManager申请的，并由ApplicationMaster与NodeManager通信以启动。
以上两类Container可能在任意节点上，它们的位置通常是随机的，即ApplicationMaster可能与它管理的任务运行在一个节点上。
5、计算YARN和MapReduce的可用内存
应考虑预留内存，包括系统进程占用和其它hadoop进程，如Hbase等。
预留内存 = 保留栈内存 + Hbase预留内存(如部署在同一台机器上)
通常用下表来决定预留内存的大小。
| 每个节点的总内存 |
推荐系统保留的内存 |
推荐为hbase保留的内存 |
| 4GB |
1GB |
1GB |
| 8GB |
2GB |
1GB |
| 16GB |
2GB |
2GB |
| 24GB |
4GB |
4GB |
| 48GB |
6GB |
8GB |
| 64GB |
8GB |
8GB |
| 72GB |
8GB |
8GB |
| 96GB |
12GB |
16GB |
| 128GB |
24GB |
24GB |
| 256GB |
32GB |
32GB |
| 512GB |
64GB |
64GB |
a、计算每节点的最大容器数。
containers = min (2*CORES, 1.8*DISKS, (Total available RAM) /MIN_CONTAINER_SIZE)
其中，cores是节点的cpu核数，DISKS是dfs.data.dirs的参数值。
MIN_CONTAINER_SIZE是最小的容器内存大小(RAM)，这个值依赖于RAM的可用数--小的内存节点，最小的容器大小会更小。
最小容器内存的推荐值
| 每个节点的总内存 |
MIN_CONTAINER_SIZE |
| 小于4GB |
256MB |
| 在4GB和8GB之间 |
512MB |
| 在8GB和24GB之间 |
1024MB |
| 大于24GB |
2048MB |
b、计算每个容器的RAM数。
RAM-per-container = max(MIN_CONTAINER_SIZE, (Total Available RAM) / containers))
c、计算YARN和MapReduce内存。
| 配置设定 |
计算值 |
| yarn.nodemanager.resource.memory-mb |
= containers*RAM-per-container |
| yarn.scheduler.minimum-allocation-mb |
= RAM-per-container |
| yarn.scheduler.maximum-allocation-mb |
= containers*RAM-per-container |
| mapred.job.map.memory.mb |
= RAM-per-container |
| mapred.job.reduce.memory.mb |
= 2 * RAM-per-container |
| mapreduce.map.java.opts |
= 0.8 * RAM-per-container |
| mapreduce.reduce.java.opts |
= 0.8 * 2 * RAM-per-container |
举例：
集群每节点拥有12个CPU核，48GB内存和12块磁盘。
保留内存(Reserved Memory) = 6GB系统预留内存 + 8GB的Hbase内存。
最小容器大小(Min container size) = 2GB
容器数(containers) = min(2*12, 1.8*12, (48-6)/2)
= min(24, 21.6, 21) = 21
每个容器的RAM(RAM-per-container) = max(2, (48-6)/21)
= max(2,2) = 2
计算出的参数值。
| 配置 |
计算值 |
| yarn.nodemanager.resource.memory-mb |
= 21 * 2 * 1024 MB |
| yarn.scheduler.minimum-allocation-mb |
= 2 * 1024 MB |
| yarn.scheduler.maximum-allocation-mb |
= 21 * 2 * 1024 MB |
| mapred.job.map.memory.mb |
= 2 * 1024 MB |
| mapred.job.reduce.memory.mb |
= 2 * 2 * 1024 MB |
| mapreduce.map.java.opts |
= 0.8 * 2 * 1024 MB |
| mapreduce.reduce.java.opts |
= 2 * 2 * 1024 MB |
| yarn.app.mapreduce.am.command-opts |
= 0.8 * 2 * 2 * 1024 MB |
如果部署了HBase，则容器数目
containers = min(2*12, 1.8*12, (48-6-8)/2)
= min(24, 21.6, 17) = 17
每个容器的RAM
RAM-per-container = max(2, (48-6-8)/17)
= max(2, 2) = 2
计算出的参数值。
| 配置 |
计算值 |
| yarn.nodemanager.resource.memory-mb |
= 17 * 2 * 1024MB |
| yarn.scheduler.minimum-allocation-mb |
= 2 * 1024MB |
| yarn.scheduler.maximum-allocation-mb |
= 17 * 2 * 1024MB |
| mapred.job.map.memory.mb |
= 2 * 1024MB |
| mapred.job.reduce.memory.mb |
= 2 * 2 * 1024MB |
| mapreduce.map.java.opts |
= 0.8 * 2 * 1024MB |
| mapreduce.reduce.java.opts |
= 0.8 * 2 * 2 * 1024MB |
备注：
1.更新属性值yarn.scheduler.minimum-allocation-mb时，要同时更新
yarn.nodemanager.resource.memory-mb
yarn.scheduler.minimum-allocation-mb
以改变每个节点的容器数。
2.如果有很大的内存，而缺少磁盘和CPU，可将内存释放给其它任务，降低参数yarn.scheduler.minimum-allocation-mb和yarn.nodemanager.resource.memory-mb的值。
3.当在YARN上运行MapReduce时，集群将根据Job的需要动态分配Map和Reduce任务。
d、设置NameNode的堆内存
NameNode的堆大小受很多因数影响，如文件数，块数和系统负载。下表的设定常用于典型Hadoop集群。其中块的数目和文件数目十分接近。系统中平均每个文件的块数比例大约在1.1到1.2，NameNode的堆内存越大越好。
| 文件数(百万) |
堆(Xmx和Xms) |
年轻代大小 (-XX:NewSize-XX:MaxNewSize) |
| <1 million files |
1024m |
128m |
| 1-5million files |
3072m |
512m |
| 5-10 |
5376m |
768m |
| 10-20 |
9984m |
1280m |
| 20-30 |
14848m |
2048m |
| 30-40 |
19456m |
2560m |
| 40-50 |
24320m |
3072m |
| 50-70 |
33536m |
4352m |
| 70-100 |
47872m |
6144m |
| 100-125 |
71424m |
8960m |
| 150-200 |
94976m |
8960m |
Hadoop_NameNode_Opts参数的推荐设置，在hadoop-env.sh中，将【####】替换成-XX:NewSize,-XX:MaxNewSize,-Xms,和-Xmx，可用表中推荐的值。
-server -XX:ParallelGCThreads=8 -XX:+UseConcMarkSweepGC -XX:ErrorFile=/home/hadoop/work/hadoop/hs_err_pid%p.log -XX:NewSize=#### -XX:MaxNewSize=#### -Xms#### -Xmx#### -Xloggc:/home/hadoop/work/hadoop/gc.log-`date+'%Y%m%d%H%M'` -verbose:gc -XX:PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintGCDateStamps -Dhadoop.security.logger=INFO,DRFAS -Dhdfs.audit.logger=INFO,DRFAAUDIT ${HADOOP_NAMENODE_OPTS}
-XX:+HeapDumpOnOutOfMemoryError指明当内存错误时，执行堆的dump操作。也可以使用-XX:HeapDumpPath来指定dump文件的位置。
另一个有用的HADOOP_NAMENODE_OPTS参数是
-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/home/hadoop/work/hadoop/heapdump.hprof
-
-
- 权限相关
-
这里的权限由3部分组成，分别是：
1).管理员和普通用户如何区分；
2).服务级别的权限，比如哪些用户可以向集群提交ResourceManager应用程序；
3).队列级别的权限，比如哪些用户可以向队列A提交作业等。
管理员列表由参数yarn.admin.acl指定。
服务级别的权限是通过配置hadoop-policy.xml实现的。
队列级别的权限是由对应的资源调度器内部配置的，比如Fair Scheduler或者Capacity Scheduler等。
-
-
- 日志聚集相关
-
日志聚集是YARN提供的日志中央化管理功能，它能将运行完成的Container/任务日志上传到HDFS上，从而减轻NodeManager负载，且提供一个中央化存储和分析机制。默认情况下，Container/任务日志存在在各个NodeManager上，如果启用日志聚集功能需要额外的配置。
1、yarn.log-aggregation-enable
参数解释：是否启用日志聚集功能。
默认值：false
2、yarn.log-aggregation.retain-seconds
参数解释：在HDFS上聚集的日志最多保存多长时间。
默认值：-1
3、yarn.log-aggregation.retain-check-interval-seconds
参数解释：多长时间检查一次日志，并将满足条件的删除，如果是0或者负数，则为上一个值的1/10。
默认值：-1
4、yarn.nodemanager.remote-app-log-dir
参数解释：当应用程序运行结束后，日志被转移到的HDFS目录(启用日志聚集功能时有效)。
默认值：/tmp/logs
5、yarn.log-aggregation.retain-seconds
参数解释：远程日志目录子目录名称(启用日志聚集功能时有效)。
默认值：日志将被转移到目录
${yarn.nodemanager.remote-app-log-dir}/${user}/${thisParam}下
MapReduce相关配置参数分为两部分，分别是JobHistory Server和应用程序参数，Job History可运行在一个独立节点上，而应用程序参数则可存放在mapred-site.xml中作为默认参数，也可以在提交应用程序时单独指定，注意，如果用户指定了参数，将覆盖掉默认参数。
以下这些参数全部在mapred-site.xml中设置。
-
-
- MR JobHistory相关
-
在JobHistory所在节点的mapred-site.xml中配置。
1、mapreduce.jobhistory.address
参数解释：MapReduce JobHistory Server地址。
默认值：0.0.0.0:10020
2、mapreduce.jobhistory.webapp.address
参数解释：MapReduce JobHistory Server Web UI地址。
默认值：0.0.0.0:19888
3、mapreduce.jobhistory.intermediate-done-dir
参数解释：MapReduce作业产生的日志存放位置。
默认值：/mr-history/tmp
4、mapreduce.jobhistory.done-dir
参数解释：MR JobHistory Server管理的日志的存放位置。
默认值：/mr-history/done
-
-
- Fair Scheduler相关
-
首先，在yarn-site.xml中，将配置参数yarn.resourcemanager.scheduler.class设置为org.apache.hadoop.yarn.server.resourcemanager.scheduler.fair.FairScheduler。
Fair Scheduler的配置选项包括两部分，其中一部分在yarn-site.xml中，主要用于配置调度器级别的参数，另外一部分在一个自定义配置文件(默认是fair-scheduler.xml)中，主要用于配置各个队列的资源量、权重等信息。
-
-
-
- yarn-site.xml内
-
-
1、yarn.scheduler.fair.allocation.file：自定义XML配置文件所在位置，该文件主要用于描述各个队列的属性，比如资源量、权重等，具体配置格式将在后面介绍。
2、yarn.scheduler.fair.user-as-default-queue：当应用程序未指定队列名时，是否指定用户名作为应用程序所在的队列名。如果设置为false或者未设置，所有未知队列的应用程序将被提交到default队列中，默认值为true。
3、yarn.scheduler.fair.preemption：是否启用抢占机制，默认值是false。
4、yarn.scheduler.fair.sizebasedweight：在一个队列内部分配资源时，默认情况下，采用公平轮询的方法将资源分配给各个应用程序，而该参数则提供了另外一种资源分配方式：按照应用程序资源需求数目分配资源，即需求资源数量越多，分配的资源越多。默认情况下，该参数值为false。
5、yarn.scheduler.assignmultiple：是否启动批量分配功能。当一个节点出现大量资源时，可以一次分配完成，也可以多次分配完成。默认情况下，该参数值为false。
6、yarn.scheduler.fair.max.assign：如果开启批量分配功能，可指定一次分配的container数目。默认情况下，该参数值为-1，表示不限制。
7、yarn.scheduler.fair.locality.threshold.node：当应用程序请求某个节点上资源时，它可以接受的可跳过的最大资源调度机会。当按照分配策略，可将一个节点上的资源分配给某个应用程序时，如果该节点不是应用程序期望的节点，可选择跳过该分配机会，暂时将资源分配给其它应用程序，直到出现满足该应用程序需的节点资源。通常而言，一次心跳代表一次调度机会，而该参数则表示跳过调度机会占节点总数的比例，默认情况下，该值为-1.0，表示不跳过任何调度机会。
8、yarn.scheduler.fair.locality.threshold.rack：当应用程序请求某个机架上资源时，它可以接受的可跳过的最大资源调度机会。
9、yarn.scheduler.increment-allocation-mb：内存规整化单位，默认是1024，这意味着，如果一个Container请求资源是1.5GB，则将被调度器规整化为ceiling(1.5 GB / 1GB) * 1G=2GB。
10、yarn.scheduler.increment-allocation-vcores：虚拟CPU规整化单位，默认是1，含义与内存规整化单位类似。
-
-
-
- 自定义
-
-
Fair Scheduler允许用户将队列信息专门放到一个配置文件(默认是fair-scheduler.xml)，对于每个队列，管理员可配置以下几个选项：
1、minResources：最少资源保证量，设置格式为“X mb, Y vcores”，当一个队列的最少资源保证量未满足时，它将优先于其他同级队列获得资源，对于不同的调度策略(后面会详细介绍)，最少资源保证量的含义不同，对于fair策略，则只考虑内存资源，即如果一个队列使用的内存资源超过了它的最少资源量，则认为它已得到了满足；对于drf策略，则考虑主资源使用的资源量，即如果一个队列的主资源量超过它的最少资源量，则认为它已得到了满足。
2、maxResources：最多可以使用的资源量，fair scheduler会保证每个队列使用的资源量不会超过该队列的最多可使用资源量。
3、maxRunningApps：最多同时运行的应用程序数目。通过限制该数目，可防止超量Map Task同时运行时产生的中间输出结果撑爆磁盘。
4、minSharePreemptionTimeout：最小共享量抢占时间。如果一个资源池在该时间内使用的资源量一直低于最小资源量，则开始抢占资源。
5、schedulingMode/schedulingPolicy：队列采用的调度模式，可以是fifo、fair或者drf。
6、aclSubmitApps：可向队列中提交应用程序的Linux用户或用户组列表，默认情况下为【*】，表示任何用户均可以向该队列提交应用程序。需要注意的是，该属性具有继承性，即子队列的列表会继承父队列的列表。配置该属性时，用户之间或用户组之间用【,】分割，用户和用户组之间用空格分割，比如【user1, user2 group1,group2】。
7、aclAdministerApps：该队列的管理员列表。一个队列的管理员可管理该队列中的资源和应用程序，比如可杀死任意应用程序。
管理员也可为单个用户添加maxRunningJobs属性限制其最多同时运行的应用程序数目。此外，管理员也可通过以下参数设置以上属性的默认值：
(1)、userMaxJobsDefault：用户的maxRunningJobs属性的默认值。
(2)、defaultMinSharePreemptionTimeout ：队列的minSharePreemptionTimeout属性的默认值。
(3)、defaultPoolSchedulingMode：队列的schedulingMode属性的默认值。
(4)、fairSharePreemptionTimeout：公平共享量抢占时间。如果一个资源池在该时间内使用资源量一直低于公平共享量的一半，则开始抢占资源。
【实例】假设要为一个Hadoop集群设置三个队列queueA、queueB和queueC，其中，queueB和queueC为queueA的子队列，且规定普通用户最多可同时运行40个应用程序，但用户userA最多可同时运行400个应用程序，那么可在自定义配置文件中进行如下设置：
- hbase
分布式集群，hm01/hm02互备Master，hs01/hs02/hs03是slave。
-
- 配置
- 环境变量
- 配置
编辑环境变量文件(.bashrc)
export HBASE_HOME="/home/hadoop/soft/hbase"
export PATH="${HADOOP_HOME}/bin:${HADOOP_HOME}/sbin:${HBASE_HOME}/bin:${JAVA_HOME}/bin:${PATH}"
-
-
- hbase-env.sh
-
| 名称 |
说明 |
默认值 |
建议值 |
| HBASE_HEAPSIZE |
进程分配最大内存空间大小，根据机器内存来确定,单位M |
1000 |
主机上面所有hbase进程使用的内存最大量，如果涉及到复用部署(例如，master和regionserver部署在同一台主机上)，若单独指定了master和regionserver的内存使用量，该值应大于复用进程内存使用量之和。如果只部署了thrift server和client，该值应大于这两个进程的内存使用量。 |
| HBASE_OPTS |
jvm运行参数 |
-XX:+UseConcMarkSweepGC |
|
| HBASE_MASTER_OPTS |
Hmaster启动加载参数 |
|
轻量级负载，适度分配内存。主机内存24G以上，建议分配4G。 |
| HBASE_REGIONSERVER_OPTS |
Regionserver启动加载参数 |
|
大部分可用内存分配给regionserver，为操作系统和任务进程留有足够空间。主机内存24G以上，建议分配12G。 同时应该考虑客户端的Write Buffer设置，hbase.client.write.buffer * hbase.regionserver.handler.count * number of region server的值不应超过regionserver分配的内存大小。 其中，hbase.regionserver.handler.count为每个Region Server上配置的RPC Handler线程数。 |
| HBASE_THRIFT_OPTS |
Thrift server启动加载参数 |
|
Thrift Server最好和应用客户端部署在同一台机器上，如果调大了hbase.client.scanner.caching(scanner调用next方法一次获取的数据条数，默认为1)，启动thrift server时需要调大heapsize的大小，否则可能由于java.lang.OutOfMemoryError异常而导致进程被杀掉 |
| HBASE_LOG_DIR |
进程日志存放目录 |
|
/home/hadoop/work/hbase/logs |
| HBASE_PID_DIR |
进程当前进程号存放目录 |
|
/home/hadoop/work/hbase/pids |
| HBASE_MANAGES_ZK |
指定是否使用hbase自带的zookeeper进行管理集群 |
true |
false |
| LD_LIBRARY_PATH |
本地动态库目录 |
|
|
| HBASE_BACKUP_MASTERS |
默认的备份Master文件，需要建个backup-masters文件指定备份主机 |
|
${HBASE_HOME}/conf/backup-masters |
示例
export HBASE_REGIONSERVERS=${HBASE_HOME}/conf/regionservers
#export HBASE_BACKUP_MASTERS=${HBASE_HOME}/conf/backup-masters
export HBASE_MANAGES_ZK=false
export HBASE_LOG_DIR=/home/hadoop/work/hbase/logs
export HBASE_PID_DIR=/home/hadoop/work/hbase/pid
export LD_LIBRARY_PATH=$HADOOP_HOME/lib/native/:$HADOOP_HOME/share/hadoop/common/lib:$LD_LIBRARY_PATH
#本地测试不要开，资源充足可测一下。
export HBASE_MASTER_OPTS="$HBASE_MASTER_OPTS $HBASE_JMX_BASE -Xmx2000m -Xms2000m -Xmn750m -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=70"
export HBASE_REGIONSERVER_OPTS="$HBASE_REGIONSERVER_OPTS $HBASE_JMX_BASE -Xmx3000m -Xms3000m -Xmn1024m -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:CMSInitiatingOccupancyFraction=70"
-
-
- hbase-site.xml
-
| 名称 |
说明 |
默认值 |
建议值 |
| hbase.rootdir |
Hbase数据存储在hdfs中的路径。 在完全分布式模式下，必须设置为HDFS的NameNode的位置。 |
|
hdfs://myhdcluster/hbase myhdcluster为hdfs的文件系统名称，对应hadoop配置文件core-site.xml中fs.defaultFS的配置项内容。 |
| hbase.master |
Hmaster主机，只配置端口，则启动多个，组成主备 |
|
8600 |
| hbase.master.port |
Hmaster通信端口，配多个HM时，可省略 |
60000 |
8600 |
| hbase.master.info.port |
Hmaster web界面端口 |
60010 |
8601 |
| hbase.regionserver.port |
Regionserver通信端口 |
60020 |
8602 |
| hbase.regionserver.info.port |
RegionserverWeb界面端口 |
60030 |
8603 |
| hbase.cluster.distributed |
决定hbase的运行模式是否为完全分布式。
|
false |
|
| hbase.zookeeper.quorum |
zookeeper集群信息，填写格式ip:port，多个主机之间以逗号分隔。配置值与zookeeper安装部署保持一致 |
|
|
| hbase.zookeeper.property.clientPort |
zookeeper服务器端开启的监听端口，用来接受客户端访问请求的端口。配置为8501，与zookeeper的配置文件zoo.cfg中保持一致。 |
|
Zookeeper修改了默认端口，hbase此处随之进行修改。 |
| hbase.zookeeper.peerport |
zookeeper服务之间通信的端口，配置为8502，与zookeeper的配置文件zoo.cfg中保持一致。 |
|
Zookeeper修改了默认端口，hbase此处随之进行修改。 |
| hbase.zookeeper.leaderport |
ZooKeeper用来选择Leader的端口，配置为8503，与zookeeper的配置文件zoo.cfg中保持一致。 |
|
Zookeeper修改了默认端口，hbase此处随之进行修改。 |
| hbase.tmp.dir |
hbase临时文件存放目录。 |
|
/home/hadoop/work/hbase/tmp/hbase-${user.name} |
| hbase.hregion.majorcompaction |
自动进行major compaction的周期，配置为0，说明不进行自动major compation，采用手动方式进行。 |
|
建议配置为0，手动执行 |
| zookeeper.session.timeout |
Hbase与zookeeper之间session超时时间设置，需要结合zookeeper最大超时时间进行设置。 |
|
|
| hbase.regionserver.restart.on.zk.expire |
Regionserver的zookeeper session超时是否重启 |
false |
建议为true |
| hbase.client.scanner.caching |
与hive整合时批量查询，不整合可去掉，可根据实际测试调整 |
|
10000 |
示例
-
-
- regionservers
-
regionservers文件内容如下：
hs01
hs02
hs03
backup-masters文件内容如下：
hm02
-
-
- 集成hdfs
-
将hdfs-site.xml,core-site.xml拷贝到hbase/conf目录下。
-
-
- 工作目录
-
在hm01/hs01/hs02/hs03上执行。
mkdir -p /home/hadoop/work/hbase/logs
mkdir -p /home/hadoop/work/hbase/pid
mkdir -p /home/hadoop/work/hbase/tmp
hadoop fs -mkdir /hbase
-
-
- nativelib
-
在hbase-evn.sh文件中指定了Hadoop的本地库目录，就不需要下面了。
否则就拷贝hadoop/lib/native下的文件到hbase/lib/native下，还有snappy.jar。
-
- 分发
scp hbase到hm02/hs01/hs02/hs03。
-
- 启动
在hm01上执行：
start-hbase.sh
未指定backup-masters时在hm02上执行：
hbase-daemon.sh start master
-
- 验证
在hm01上执行。
hbase-shell.sh
1、创建表test，column family为cf。
表名，行和列需要加引号；Hbase中的列是由column family前缀和列的名字组成的，以冒号间隔。
--普通
create 'test','cf'
--压缩
create 'snpt',{NAME=>'cf',COMPRESSION => 'SNAPPY'}
2、加入记录
在表中插入一行数据，key为row1，列为cf:a，值为value1。
put 'test','row1','cf:a','value1'
put 'snpt','row1','cf:a','value1'
3、查询
get 'test','row1'
get 'snpt','row1'
-
- 停止
在hm01上执行：
stop-hbase.sh
未指定backup-masters时在hm02上执行：
hbase-daemon.sh stop master
-
- 最佳实践
Region数量与大小的重要影响
1、Region数量的影响
通常较少的region数量可使群集运行的更加平稳，官方指出每个RegionServer大约100个regions的时候效果最好，理由如下：
1）Hbase的一个特性MSLAB，它有助于防止堆内存的碎片化，减轻垃圾回收Full GC的问题，默认是开启的。但是每个MemStore需要2MB（一个列簇对应一个写缓存memstore）。所以如果每个region有2个family列簇，总有1000个region，就算不存储数据也要3.95G内存空间.
2）如果很多region，它们中Memstore也过多，内存大小触发Region Server级别限制导致flush，就会对用户请求产生较大的影响，可能阻塞该Region Server上的更新操作。
3）HMaster要花大量的时间来分配和移动Region，且过多Region会增加ZooKeeper的负担。
4）从hbase读入数据进行处理的mapreduce程序，过多Region会产生太多Map任务数量，默认情况下由涉及的region数量决定。
所以，如果一个HRegion中Memstore过多，而且大部分都频繁写入数据，每次flush的开销必然会很大，因此我们也建议在进行表设计的时候尽量减少ColumnFamily的个数。
每个Region都有自己的MemStore，当大小达到了上限（hbase.hregion.memstore.flush.size，默认128MB），会触发Memstore刷新。
计算集群region数量的公式：
((RS Xmx) * hbase.regionserver.global.memstore.size) / (hbase.hregion.memstore.flush.size * (# column families))
假设一个RS有16GB内存，那么16384*0.4/128m 等于51个活跃的region。
如果写很重的场景下，可以适当调高hbase.regionserver.global.memstore.size，这样可以容纳更多的region数量。
总结，建议分配合理的region数量，根据写请求量的情况，一般20-200个之间，可以提高集群稳定性，排除很多不确定的因素，提升读写性能。监控Region Server中所有Memstore的大小总和是否达到了上限（hbase.regionserver.global.memstore.upperLimit ＊ hbase_heapsize，默认 40%的JVM内存使用量），超过可能会导致不良后果，如服务器反应迟钝或compact风暴。
2、region大小的影响
hbase中数据一开始会写入memstore，满128MB（看配置）以后，会flush到disk上而成为storefile。当storefile数量超过触发因子时（可以配置），会启动compaction过程将它们合并为一个storefile。对集群的性能有一定影响。而当合并后的storefile大于max.filesize，会触发分割动作，将它切分成两个region。
1）当hbase.hregion.max.filesize比较小时，触发split的机率更大，系统的整体访问服务会出现不稳定现象。
2）当hbase.hregion.max.filesize比较大时，由于长期得不到split，因此同一个region内发生多次compaction的机会增加了。这样会降低系统的性能、稳定性，因此平均吞吐量会受到一些影响而下降。
总结，hbase.hregion.max.filesize不宜过大或过小，经过实战，生产高并发运行下，最佳大小5-10GB！关闭某些重要场景的hbase表的major_compact！在非高峰期的时候再去调用major_compact，这样可以减少split的同时，显著提供集群的性能，吞吐量、非常有用。
注：通过Hbase的UI控制台都可以监控到region的这两个指标。
- spark
- 概念
Application Master：每个application都有一个Application Master进程，它是Appliaction启动的第一个容器，它负责从ResourceManager中申请资源，分配资源，同时通知NodeManager来为Application启动container。
Job：作业是用户所写的程序。
Driver：一个Spark作业运行时包括一个Driver进程，也是作业的主进程，负责作业的解析、生成Stage并调度Task到Executor上。包括DAGScheduler，TaskScheduler。
Executor：真正执行作业的地方，一个集群一般包含多个Executor，每个Executor接收Driver的命令Launch Task，一个Executor可以执行一到多个Task。
Stage：一个Spark作业一般包含一到多个Stage。
Task：一个Stage包含一到多个Task，通过多个Task实现并行运行的功能。
DAGScheduler：实现将Spark作业分解成一到多个Stage，每个Stage根据RDD的Partition个数决定Task的个数，然后生成相应的Task set放到TaskScheduler中。
TaskScheduler：实现Task分配到Executor上执行。
- Spark运行作业的整体流程
从宏观上看Spark的作业运行，主要由driver和executors组成。driver运行application(SparkContext)、调度作业(schedule tasks)，executor执行具体任务。通常情况下，driver运行在client上(client一般不受整个集群管理)，但在YARN-cluster模式中，driver运行在Application Master上。
当有Action在RDD上执行时，作业被自动提交，提交调用SparkContext的run_job，把作业提交给Scheduler。Scheduler运行在driver上，由两部分组成：
1、DAG Scheduler：负责将作业分解为stage组成的DAG。
2、Task Scheduler：负责把每个stage的Task提交到集群。
- 构造DAG
在介绍作业如何被分解为DAG之前，需要了解stage可以执行的两种任务类型，shuffle map task和result task。
- shuffle map task
这种任务类似于MapReduce中map端的shuffle。每个shuffle map任务在RDD partition上执行计算，并且根据partitioning()方法将结果写入新的partition，这些结果会被下一个stage取走。shuffle map task运行在最后一个stage之外的所有stage上。
- result task
result task运行在作业的最后一个stage上，这个stage将结果返回给用户程序。每个Result task在它的RDD Partition上运行，并将结果发回给driver。driver组合来自每个partition的结果，得到最终结果。
最简单的作业可以只有Result Task，也就是只有一个由Result Task组成的stage。复杂的应用，可能需要组合多个shuffle stage。
例如，想要计算词语的频率分布直方图：
val hist:Map[Int,Long] = sc.textFile(inputPath)
.map(word => (word.toLowerCase(),1))
.reduceByKey((a,b)=>a+b)
.map(_.swap)
.countByKey()
前两个Transformation统计每个词语出现的次数，第三个Transformation对调key和value，得到的是(count，word)，最后的Action是countByKey()得到频率直方图，即出现N词的词语有M个。
DAG Scheduler将这个作业分解为2个Stage，因为reduceByKey()需要通过shuffle stage来完成，DAG如下图。
在一个stage内，RDD也被组织成DAG。
reduceByKey出现在两个Stage中，因为它是使用shuffle实现的，在map端(stage1)reduce()方法作为combiner运行，在reduce端(stage2)作为reducer运行。这类似MapReduce，有时将Reducer的实现直接作为map端的Combinor，对map任务的输出结果先做一次预聚合，可避免在网络上传输大量数据。
shuffle把输出写入到本地的分区文件(partitioned file)，这些文件被下一个stage的RDD取走。
如果RDD已被上一个job(同一个Application)持久化，则DAG Scheduler不会再创建stage重新计算这个RDD(或由这个RDD衍生的其它RDD)。
DAG Scheduler还负责将stage分级为task，然后将task提交给Task Scheduler。此例中输入文件的每一个partition运行一个task(shuffle map)，reduceByKey()的并行度可以通过其第2个参数设置，如果没有设置，则从其上一级RDD推断，这里是输入数据的partition数量。
DAG Scheduler对每一个Task都给出一个位置偏好(placement preference)，Task Scheduler可以根据偏好更有效地利用本地数据的优势(data locality)。例如，如果task处理的数据是来自HDFS的RDD，则倾向于运行在拥有对应数据的节点上(node local)。如果一个task处理的数据来自内存中的RDD partition，则倾向于运行在内存中拥有这些数据的executor上(process local)。
一旦DAG Scheduler构建完stage的DAG后，就把每个stage的任务提交给task scheduler，下级stage只有在其上一级完成之后才提交。
- 任务调度
当task scheduler收到一组任务后，它根据应用持有的executor列表(在YARN中，会申请固定数量的容器，然后自己决定如何使用这些Container，这一点不同于批处理的MapReduce，MapReduce按需申请Container)，结合任务的位置偏好，决定每个任务运行在哪个executor上，即task-executor映射。然后把task分配给空闲的executor，直到任务集都运行完毕。默认情况下，每个task分配1核CPU，CPU数量可以通过spark.task.cpus设置。
对一个给定的executor，作业调度器优先分配有process-local偏好的task，然后依次是node-local，rack-local，最后是没有位置偏好(non-local)的任务或推测执行(speculative)的任务。
已分配的任务通过scheduler backend启动，这个backend发送启动任务的消息给对应的executor backend，告知executor开始运行任务。Spark使用Akka发送远程消息，而不是使用Hadoop的RPC机制。
Executor在任务结束或者失败时，发送状态消息给driver。如果任务失败，task scheduler将重新提交任务到另一个executor。如果启用推测执行(默认没有启用)，对运行慢的任务，会启用speculative任务。
- 任务执行
Executor接到运行任务的消息后，首先，确认任务需要的jar包和文件都是最新的。如果之前的任务运行过，executor会在本地缓存这些jar包和文件，只在发生变更时才重新下载。接着，反序列化任务代码，任务代码以序列化字节的形式通过任务启动消息发送到executor。最后，任务在executor同一个JVM中被执行，因此，无需在任务启动时重新启动JVM。
任务执行的结果在序列化之后，发送给executor backend。然后，作为状态更新消息(status update message)发回给driver。如果是shuffle map task，返回包含的信息用于下一个stage提取数据，类似MapReduce中map任务完成后，通过心跳发送消息给Application Master。然后，Reducer通过心跳得知map已运行完，进而去copy数据。如果是Result task，将对应partition的运行结果发送给driver，driver组合出最终结果。
- Executor和Cluster Manager
Spark中，executor的生命周期通过cluster manager来管理，Spark提供了多种不同的manager。
- Local
Local模式中，只有一个跟driver运行在同一个JVM的executor，对于测试或者运行小型任务，这种模式很有用。该模式下master的url为local(使用一个线程)，local[n](n个线程)或者local(*)(线程数和CPU核数相等)。
- Standalone
Standalone是cluster manager一种简单的分布式实现，运行一个Spark master和一个或多个的worker。当Spark应用启动之后，master代表应用要求worker运行task。master的url为spark://host:port
- Mesos
Mesos是一种通用的集群资源管理框架。在fine-grained模式下，每个Spark Task作为一个Mesos Task运行，这种方式能够更有效地利用集群资源，但是以进程启动负担为代价。在coarse-grained模式下，executor在进程任务运行任务，所以集群资源在Spark应用程序运行过程中一直被executor持有。master的url地址为mesos：//host:port
- YARN
YARN是Hadoop使用的资源管理框架，每个Spark应用对应一个YARN应用实例，每个executor在其自己的Container中运行。master的url为yarn-client或者yarn-cluster。
Mesos和YARN的资源管理方式优于Standalone，它们考虑了集群中其它应用对资源的需求(例如MapReduce作业)，而Standalone采用静态的资源分配方式，没有办法动态地调整以满足集群的其它资源需求。YARN是唯一一个与Hadoop的Kerberos安全机制集成的cluster manager。
- Spark on YARN
Spark通过两种模式运行在YARN上。
1、YARN client mode
Driver运行在client机器上。对于包含有交互式组件的应用，必须使用这种模式，例如spark-shell和pyspark。在开发和调试的时候，这种模式可以立刻查看到debug信息。
2、YARN cluster mode
Driver运行在集群的Application Master上，适合于生产环境。整个应用运行在集群上，方便管理应用的日志文件。YARN在Application Master故障的时候会重试应用。
- YARN client mode
在driver构造出SparkContext实例(step1)的时候，就开始与YARN交互。Context向YARN的资源管理器(RM)提交一个应用(step2)，RM在集群的NodeManager中启动一个Container，并在Container中运行Spark ExecutorLauncher(step3)。ExecutorLauncher的任务是向RM申请资源(step4)，并在申请到资源后将Executor Backend作为容器在相应的NodeManager中启动(step5)。
当executor启动后，会连接到SparkContext并注册自己，注册时给SparkContext提供整个应用的executor信息，以便task scheduler在决定将任务运行在哪个节点(task placement decision)时，可以考虑任务的位置偏好。
executor的数量在启动spark-shell，spark-submit或者pyspark时指定，如果没有指定，默认启动2个executor，每个executor使用的CPU核数(默认1)和内存大小(默认1024M)也可在此设置。
spark-shell --master yarn-client --num-executors 4 --executor-cores 1 -- executor-memory 2g
不同于Standalone或者Mosos，YARN的NM地址并没有在这里配置，而是从Hadoop的配置中提取，配置目录通过HADOOP_CONF_DIR环境变量设置。
- YARN cluster mode
在cluster模式下，用户的驱动程序(driver，下图的Spark Program)运行在YARN的Application Master进程中，使用该模式时，指定master的url类似：
spark-submit --master yarn-cluster ...
其它参数，例如executor数量，jar包或python文件，与client mode一样。如下图，spark-submit客户端启动一个YARN Application(step1通过请求NM)，但它不运行任何用户代码。Application Master在开始为executor申请资源(step4)之前，将启动驱动程序(step3b)，其它过程与client mode一样。
在YARN的两种模式下，启动executor之前并不知道数据放在哪里(data locality)，所以，启动的executor可能与所要处理的数据不在一个节点上(task的位置偏好无法得到满足)。对于交互式的session来说，这是比较容易接受的，因为在启动一个交互会话时，很可能并不知道要处理哪些数据，但在生产环境中就不是这样了。当应用运行在cluster模式时，通过位置提示(placement hint)提高data locality，这可以在构造SparkContext时传入位置偏好达到目的。
构造SparkContext之前，可用InputFormatInfo类来获取位置偏好，例如文本文件，使用TextInputFormat，可以获取位置偏好：
val preferredLocations = InputFormatInfo.computePreferredLocations(
Seq(new InputFormatInfo(new Configuration(), classof[TextInputFormat], inputPath)))
val sc = new SparkContext(conf, preferredLocations)
这些位置偏好信息在Application Master为executor申请资源时可以使用，目前该特性的API还不是很稳定。
运行模式对比1：
| 模式 |
提交模式 |
driver(用户main) |
ApplicationMaster |
| standalone |
–master spark://master1:7077 |
在Master上 |
在Master上 |
| onyarn (client) |
–master yarn –deploy-mode client |
driver运行在提交作业的机器上，可看程序日志 |
运行在某台机器上，向RM申请资源(container)，杀死任务 |
| onyarn (cluster) |
–master yarn –deploy-mode cluster |
driver运行在集群某台机器上，看不到日志，只可看到运行状态，Driver在AppMaster执行 |
运行在集群某台机器上，申请资源(container)，杀死任务 |
对比2：
| 模式 |
ResourceManager |
NodeManager |
Master |
| standalone |
无 |
无 |
用户程序通过与Master节点交互，申请所需资源 |
| onyarn (client) |
管理资源，接受任务 |
根据RM命令，分配container |
无 |
| onyarn (cluster) |
管理资源，接受任务 |
根据RM命令，分配container |
无 |
对比3：
| 模式 |
Worker |
Container |
Executor |
| standalone |
Worker负责Executor的启动运行 |
无 |
运行在Worker上，里面运行Task，CoarseGrainedExecutorBackend进程 |
| onyarn (client) |
无 |
Container里运行Executor |
运行在Container内，里面运行Task |
| onyarn (cluster) |
无 |
Container里运行Executor |
运行在Container内，里面运行Task |
Spark配置不区分模式，应用的部署和运行可分为本地和集群模式，集群模式又分为standalone，yarn，mesos等。
-
- 配置
在onYarn模式中，Jvm的参数配置。
(1)、Driver的JVM参数，-Xmx，-Xms。
yarn-client模式，读取spark-env里的SPARK_DRIVER_MEMORY值，-Xmx，-Xms值一样。
yarn-cluster模式，读取spark-default.conf里的spark.driver.extraJavaOptions的JVM值。
可被spark-submit工具中的--driver-java-options覆盖。
(2)、Executor的JVM参数，-Xmx，-Xms。
yarn-client模式，读取spark-env里的SPARK_EXECUTOR_MEMORY值，-Xmx，-Xms值一样。
yarn-cluster模式，读取spark-default.conf里的spark.executor.extraJavaOptions的JVM值。
GC方式，都读取spark-default.conf里的spark.executor.extraJavaOptions的JVM值。
(3)、Executor数及所占CPU数。
yarn-client模式，Executor数由spark-env中的SPARK_EXECUTOR_INSTANCES指定，每个实例的数目由SPARK_EXECUTOR_CORES指定；
yarn-cluster模式，Executor的数由spark-submit工具的--num-executors参数指定，默认2个实例，而每一个Executor使用的CPU数由--executor-cores指定，默认1核。
-
-
- 环境变量
-
编辑环境变量(.bashrc)
export SPARK_HOME="/home/hadoop/soft/spark"
export SCALA_HOME="/home/hadoop/soft/scala-2.11.4"
export PATH="${SCALA_HOME}/bin:${SPARK_HOME}/bin:${PATH}"
-
-
- spark-env.sh
-
# locally模式加载程序的参数
export HADOOP_CONF_DIR=/home/hdp/soft/hadoop/etc/hadoop
# cluster模式executors和drivers的参数
# 执行shuffle时产生的小文件，临时文件
export SPARK_LOCAL_DIRS=/home/hdp/work/spark/tmp
#扫描Hadoop的包
export SPARK_DIST_CLASSPATH=$(/home/hdp/soft/hadoop/bin/hadoop classpath)
# YARN client模式参数
#默认2
export SPARK_EXECUTOR_INSTANCES=1
#默认1
#export SPARK_EXECUTOR_CORES=1
#默认1G
export SPARK_EXECUTOR_MEMORY=512M
#默认1G
export SPARK_DRIVER_MEMORY=512M
# standalone部署模式参数
#多Master，不能定义该属性，否则无法启动多个Master，可在Application中定义
#export SPARK_MASTER_IP=hm01
#master端口
export SPARK_MASTER_PORT=8090
#master web端口
export SPARK_MASTER_WEBUI_PORT=8091
#master参数，形式"-Dx=y"
#export SPARK_MASTER_OPTS
#无默认
export SPARK_WORKER_CORES=1
#无默认
export SPARK_WORKER_MEMORY=768M
#worker端口
export SPARK_WORKER_PORT=8092
#worker web端口
export SPARK_WORKER_WEBUI_PORT=8093
#worker工作路径
export SPARK_WORKER_DIR=/home/hdp/work/spark
#worker属性，形如"-Dx=y"
#export SPARK_WORKER_OPTS=
#默认1G，master，worker，hisServer分配的内存量
export SPARK_DAEMON_MEMORY=768M
#守护进程的属性，形如"-Dx=y"。恢复模式(Master重新启动)有3种，1-ZOOKEEPER，2-FILESYSTEM，3-NONE
export SPARK_DAEMON_JAVA_OPTS="-Dspark.deploy.recoveryMode=ZOOKEEPER -Dspark.deploy.zookeeper.url=hs01:8501,hs02:8501,hs03:8501 -Dspark.deploy.zookeeper.dir=/spark"
# standalone部署模式通用参数
export SPARK_CONF_DIR=/home/hdp/soft/spark/conf
export SPARK_LOG_DIR=/home/hdp/work/spark/logs
#默认/tmp
export SPARK_PID_DIR=/home/hdp/work/spark/pids
-
-
- spark-defaults.conf
-
影响driver所提交运行的application及为application提供计算资源的executor的参数。只在driver上配置，不需在worker或master机器上配置。
yarn-cluster模式下，spark的入口函数在client上执行，可是Driver的其它功能是在ApplicationMaster中执行。ApplicationMaster在yarn-cluster模式下是由ResourceManager随机指定的。
| 属性名称 |
默认值 |
含义 |
| spark.history.updateInterval |
10 |
以秒为单位，更新日志相关信息的时间间隔 |
| spark.history.retainedApplications |
250 |
保存Application历史记录的个数，如果超过这个值，旧的应用程序信息将被删除 |
| spark.history.ui.port |
18080 |
HistoryServer的web端口 |
| spark.history.kerberos.enabled |
False |
是否使用kerberos方式登录访问HistoryServer，对于持久层位于安全集群的HDFS上是有用的，如果设置为true，就要配置下面的两个属性 |
| spark.history.kerberos.principal |
用于HistoryServer的kerberos主体名称 |
|
| spark.history.kerberos.keytab |
用于HistoryServer的kerberos keytab文件位置 |
|
| spark.history.ui.acls.enable |
False |
授权用户查看应用程序信息的时候是否检查acl。如果启用，只有应用程序所有者和spark.ui.view.acls指定的用户可以查看应用程序信息;否则，不做任何检查 |
| spark.eventLog.enabled |
False |
是否记录Spark事件日志 |
| spark.eventLog.dir |
事件日志路径，可以是hdfs://的路径，也可以是file://的本地路径。 |
|
| spark.history.fs.logDirectory |
|
指定文件系统的日志路径，和上面相同。 |
| spark.yarn.historyServer.address |
Server端的URL：Ip:port 或者host:port |
|
| spark.executor.extraJavaOptions |
|
|
| spark.serializer |
|
org.apache.spark.serializer.KryoSerializer |
| spark.cores.max |
默认所有 |
每个Driver运行的最大核心数 |
| spark.shuffle.manager |
|
在shuffle时采用的管理方式，排序可减少临时文件，但性能稍有下降。 |
| spark.shuffle.consolidateFiles |
|
合并小文件。map时会有很多小文件，这样设置就在map后合并成一个了。 |
| spark.yarn.jars |
|
存放在hdfs上的spark用的公共jar包路径 |
| spark.sql.warehouse.dir |
|
hdfs://myhdcluster/spark/warehouse |
示例：
#把hdfs-site.xml复制到spark/conf下
#日志服务器
spark.eventLog.enabled true
spark.eventLog.dir hdfs://myhdcluster/spark/logs
spark.history.fs.logDirectory hdfs://myhdcluster/spark/logs
spark.yarn.historyServer.address hs03:18080
#shuffle合并小文件
spark.shuffle.consolidateFiles true
#任务
spark.task.cpus 1
spark.task.maxFailures 3
#调度类型
spark.scheduler.mode FAIR
#安全，测试环境下可false
spark.authenticate false
spark.authenticate.secret hdp
#毫秒，测试环境下可false
spark.core.connection.auth.wait.timeout 30000
spark.ui.acls.enable false
spark.ui.view.acls root,hdp
# on yarn
#毫秒
spark.yarn.am.waitTime 300000
spark.yarn.submit.file.replication 2
spark.yarn.preserve.staging.files false
spark.yarn.scheduler.heartbeat.interval-ms 5000
#存放公共包，将spark/jars/*.jar全放入
spark.yarn.jars hdfs://myhdcluster/spark/lib/*
数据库临时目录
spark.sql.warehouse.dir hdfs://myhdcluster/spark/warehouse
#Driver Application设置
#传输消息大小，默认10M，数据量大时可开大些。
spark.rpc.message.maxSize 10
#分区数量(并行线程数)，设置成内核数的2-3倍
spark.default.parallelism 9
#自动清除不再使用的RDD(优化内存存储)
spark.streaming.unpersist true
#把指定毫秒内接到的流数据放入一个block文件(优化磁盘存储)
spark.streaming.blockInterval 1000
#序列化和压缩也可通过SPARK_JAVA_OPTS在conf中导出
#序列化存储,性能优化
spark.serializer org.apache.spark.serializer.KryoSerializer
#启用压缩
spark.broadcast.compress true
#压缩方式，LZF压缩比高，Snappy压缩时间花费长
spark.io.compression.codec LZF
-
-
- log4j.properties
-
# Set everything to be logged to the console
log4j.rootCategory=INFO, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n
# Settings to quiet third party logs that are too verbose
log4j.logger.org.eclipse.jetty=WARN
log4j.logger.org.eclipse.jetty.util.component.AbstractLifeCycle=ERROR
log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=INFO
log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=INFO
-
-
- fair-scheduler.xml
-
-
-
- sql
-
把Hive的配置文件hive-site.xml直接放到$SPARK_HOME/conf下。如果是在Spark集群上本地执行SQL，每个节点都要同样配置。
-
-
- slaves
-
vi slaves
hs01
hs02
hs03
-
-
- 上传jar包
-
spark每次提交任务时，将把相应jar包提交到任务所在机器，同一个任务多次提交后，jar包会重复占用磁盘空间。为了减少jar包重复，需要把应用任务使用到的jar包上传到HDFS中，进行地址引用。
将hdfs-site.xml拷贝到conf/。
-
-
- 工作目录
-
mkdir -p /home/hdp/work/spark/logs
mkdir -p /home/hdp/work/spark/pids
mkdir -p /home/hdp/work/spark/tmp
hadoop fs -mkdir -p /spark/logs
#spark sql
hadoop fs -mkdir -p /spark/warehouse
#jar包存放路径
hadoop fs -mkdir -p /spark/lib
-
- 分发
scp到hm02/hs01/hs02/hs03
-
- 启动
如果在yarn上直接跑，可以不用启动spark。
在hm01上执行。
spark/sbin/start-all.sh
在hm02上执行(备节点)。
spark/sbin/start-master.sh
在hs03上执行。
spark/sbin/start-history-server.sh hdfs://myhdcluster/spark/logs
如果在使用start-all启动spark集群时，发现有hd03: failed to launch: nice -n 0报错，就在root的.bashrc中加入jdk设置。
-
- 验证
pyspark，验证pyspark能否运行。
spark-shell，验证scala能否运行。
一、发布应用(driver)
命令详解见说明。
spark-submit \
--class
--master
--deploy-mode
--conf
# other options
[application-arguments]
说明：
--class，指定需要执行的主类全路径。
--master，指定master地址URL。
--deploy-mode，指定Driver运行模式，默认client，分client和cluster。
--jar，指定应用依赖包。
application-jar，指定应用jar包，该包必须在所有节点可见，应上传到HDFS中，使用hdfs://..jar来引用。如果是client方式，只需在命令最后跟上jar即可自动上传到各worker节点。
application-arguments，表示主类需要传递的参数main(args)。
文件路径【./】是相对于hdfs://namespace/user/hadoop/的。
1、onYarn
计算Pi
./bin/spark-submit --master yarn \
--deploy-mode cluster \
--class org.apache.spark.examples.JavaSparkPi \
/home/hdp/spark-1.2.0/examples/target/scala-2.10/spark-examples-1.0.0-hadoop2.0.0-cdh4.5.0.jar 10
计算WordCount
./bin/spark-submit --master yarn \
--deploy-mode cluster \
--class org.apache.spark.examples.JavaWordCount \
/home/hdp/spark-1.2.0/examples/target/scala-2.10/spark-examples-1.0.0-hadoop2.0.0-cdh4.5.0.jar ./hdfs-site.xml
--master yarn，指默认按"Yarn Client"运行在Yarn集群中。
./hdfs-site.xml，是HDFS中的一个文件，在HDFS中的全路径为"hdfs://namespace/user/hdp/hdfs-site.xml"。
其中，hadoop是当前用户，namespace是hdfs的命名空间。"./hdfs-site.xml"指的是"hdfs://myhdcluster/user/hdp/hdfs-site.xml"。
2、standalone
在hm01上执行：
./bin/spark-submit --master spark://hm01:8090 \
--class org.apache.spark.examples.SparkPi \
--name Spark-Pi
/home/hadoop/spark-1.0.0/examples/target/scala-2.10/spark-examples-1.0.0-hadoop2.0.0-cdh4.5.0.jar
--master，指定Master节点的URI，填的是Host。
每个Executor运行时的信息可通过yarn logs命令查看，类似于如下：
14/08/13 18:12:59 INFO org.apache.spark.Logging$class.logInfo(Logging.scala:58): Setting up executor with commands: List($JAVA_HOME/bin/java, -server, -XX:OnOutOfMemoryError='kill %p', -Xms1024m -Xmx1024m , -XX:PermSize=256M -XX:MaxPermSize=256M -verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -XX:+PrintHeapAtGC -Xloggc:/tmp/spark_gc.log, -Djava.io.tmpdir=$PWD/tmp, -Dlog4j.configuration=log4j-spark-container.properties, org.apache.spark.executor.CoarseGrainedExecutorBackend, akka.tcp://spark@sparktest1:41606/user/CoarseGrainedScheduler, 1, sparktest2, 3, 1>,
其中，akka.tcp://spark@sparktest1:41606/user/CoarseGrainedScheduler表示当前的Executor进程所在节点，后面的1表示Executor编号，sparktest2表示ApplicationMaster的host，接着的3表示当前Executor所占用的CPU数目。
二、停止应用(driver)
1、停止client方式发布的应用
kill -9 SparkSubmit的pid
2、停止cluster方式发布的应用
spark-class org.apache.spark.deploy.Client kill
Master URL表示集群Master地址，如spark://hm01:8090
Driver ID通过Master的http://hm01:8091
在Running Drivers中找到Submission ID。
如，spark-class org.apache.spark.deploy.Client kill spark://hm01:8090 driver-20150505151651-0014
三、查看应用
1、查看整体情况
在服务运行时，用hd01:8091的webUI查看。
2、查看job情况
在应用程序运行时，用hd01:4040的webUI查看job的具体情况。
-
- 停止
在hm01上执行：
spark/sbin/stop-all.sh
在hm02上执行：
spark/sbin/stop-master.sh
在hs03上执行：
spark/sbin/stop-history-server.sh
-
- spark-submit说明
程序提交都使用spark-submit脚本，执行时需要传入参数。
spark-submit [options]
| 参数名称 |
含义 |
| --master MASTER_URL |
MASTER_URL可以是 1、spark://host:port, 以standalone集群运行 2、mesos://host:port, 以mesos集群运行 3、yarn, 以yarn集群运行，客户端模式。 4、yarn-cluster, 以yarn集群运行，集群模式。 5、local, 以本地单线程运行 6、local[N], 以本地多线程运行，K个cpu内核 7、local[*], 以本地多线程运行，所有cpu内核 |
| --deploy-mode DEPLOY_MODE |
Driver程序运行的地方，client或者cluster。 client作为外部客户端在本地运行，默认。 cluster在worker node上运行。 |
| --class CLASS_NAME |
主类名称，含包名 |
| --name NAME |
Application名称 |
| --jars JARS |
第三方jar包，逗号分隔 |
| --py-files PY_FILES |
在Python应用程序PYTHONPATH上的.zip, .egg, .py文件列表，逗号分隔 |
| --files FILES |
放置在每个executor工作目录的文件列表，逗号分隔 |
| --properties-file FILE |
设置应用程序属性的文件路径，默认是conf/spark-defaults.conf |
| --driver-memory MEM |
Driver程序使用内存大小 |
| --driver-java-options |
Driver程序的jvm参数 |
| --driver-library-path |
Driver程序的库路径 |
| --driver-class-path |
Driver程序的类路径 |
| --executor-memory MEM |
executor内存大小，默认1G |
| --driver-cores NUM |
Driver程序的使用CPU个数，仅限于Spark Alone模式 |
| --supervise |
失败后是否重启Driver，仅限于Spark Alone模式 |
| --total-executor-cores NUM |
executor使用的总核数，仅限于Spark Alone、Spark on Mesos模式 |
| --executor-cores NUM |
每个executor使用的内核数，默认为1，仅限于Spark on Yarn模式 |
| --queue QUEUE_NAME |
提交应用程序给哪个YARN的队列，默认是default队列，仅限于Spark on Yarn模式 |
| --num-executors NUM |
启动的executor数量，默认是2个，仅限于Spark on Yarn模式 |
| --archives ARCHIVES |
仅限于Spark on Yarn模式 |
在执行spark-submit.sh进行提交应用之前，可以使用如下方式提前定义好当前Spark Application所使用的CPU Core数目和内存大小：
SPARK_JAVA_OPTS="-Dspark.cores.max=2 -Dspark.executor.memory=600m" \
./bin/spark-submit --master spark://hm01:8090 \
--class org.apache.spark.examples.SparkPi \
-
- 配置参数
Spark参数的配置有3种方式，优先级：SparkConf方式 > 命令行参数方式 > 文件配置方式。
-
-
- 应用属性
-
| 属性名 |
默认值 |
含义 |
| spark.app.name |
应用程序名称 |
|
| spark.master |
要连接的Spark集群Master的URL |
|
| spark.executor.memory |
512m |
每个executor使用的内存大小 |
| spark.serializer |
org.apache.spark .serializer.JavaSerializer |
序列化方式，官方建议使用org.apache.spark.serializer.KryoSerializer，当然也可以任意是定义为org.apache.spark.Serializer子类的序化器 |
| spark.kryo.registrator |
如果要使用 Kryo序化器，需要创建一个继承KryoRegistrator的类并设置系统属性spark.kryo.registrator指向该类 |
|
| spark.local.dir |
/tmp |
用于保存map输出文件或者转储RDD。可以多个目录，之间以逗号分隔。在Spark 1.0 及更高版本此属性会被环境变量 SPARK_LOCAL_DIRS (Standalone、Mesos) 或 LOCAL_DIRS (YARN) 代替 |
| spark.logConf |
False |
SparkContext 启动时是否记录有效 SparkConf信息 |
-
-
- 运行环境变量
-
| 属性名 |
默认值 |
含义 |
| spark.executor.extraJavaOptions |
传递给executor的额外JVM 选项，但是不能使用它来设置Spark属性或堆空间大小 |
|
| spark.executor.extraClassPath |
追加到executor类路径中的附加类路径 |
|
| spark.executor.extraLibraryPath |
启动executor JVM 时要用到的特殊库路径 |
|
| spark.files.userClassPathFirst |
False |
executor在加载类的时候是否优先使用用户自定义的JAR包，而不是Spark带有的JAR包，目前，该属性只是一项试验功能 |
-
-
- Shuffle操作相关属性
-
| 属性名 |
默认值 |
含义 |
| spark.shuffle.consolidateFiles |
False |
如果为true，在shuffle时就合并中间文件，对于有大量Reduce任务的shuffle来说，合并文件可以提高文件系统性能，如果使用的是ext4 或 xfs 文件系统，建议设置为true；对于ext3，由于文件系统的限制，设置为true反而会使内核>8的机器降低性能 |
| spark.shuffle.spill |
True |
如果为true，在shuffle期间通过溢出数据到磁盘来降低了内存使用总量，溢出阈值是由spark.shuffle.memoryFraction指定的 |
| spark.shuffle.spill.compress |
True |
是否压缩在shuffle期间溢出的数据，如果压缩将使用spark.io.compression.codec。 |
| spark.shuffle.compress |
True |
是否压缩map输出文件，压缩将使用spark.io.compression.codec。 |
| spark.shuffle.file.buffer.kb |
100 |
每个shuffle的文件输出流内存缓冲区的大小，以KB为单位。这些缓冲区可以减少磁盘寻道的次数，也减少创建shuffle中间文件时的系统调用 |
| spark.reducer.maxMbInFlight |
48 |
每个reduce任务同时获取map输出的最大大小 (以兆字节为单位)。由于每个map输出都需要一个缓冲区来接收它，这代表着每个 reduce 任务有固定的内存开销，所以要设置小点，除非有很大内存 |
-
-
- SparkUI相关属性
-
| 属性名 |
默认值 |
含义 |
| spark.ui.port |
4040 |
应用程序webUI的端口 |
| spark.ui.retainedStages |
1000 |
在GC之前保留的stage数量 |
| spark.ui.killEnabled |
True |
允许在webUI将stage和相应的job杀死 |
| spark.eventLog.enabled |
False |
是否记录Spark事件，用于应用程序在完成后重构webUI |
| spark.eventLog.compress |
False |
是否压缩记录Spark事件，前提spark.eventLog.enabled为true |
| spark.eventLog.dir |
file:///tmp/spark-events |
如果spark.eventLog.enabled为 true，该属性为记录spark事件的根目录。在此根目录中，Spark为每个应用程序创建分目录，并将应用程序的事件记录到在此目录中。可以将此属性设置为HDFS目录，以便history server读取历史记录文件 |
-
-
- 压缩和序列化相关属性
-
| 属性名 |
默认值 |
含义 |
| spark.broadcast.compress |
True |
是否在发送之前压缩广播变量 |
| spark.rdd.compress |
False |
是否压缩RDD分区 |
| spark.io.compression.codec |
org.apache.spark.io. LZFCompressionCodec |
用于压缩内部数据如 RDD分区和shuffle输出的编码解码器， org.apache.spark.io.LZFCompressionCodec和org.apache.spark.io.SnappyCompressionCodec。其中，Snappy提供更快速的压缩和解压缩，而LZF提供了更好的压缩比 |
| spark.io.compression.snappy .block.size |
32768 |
使用Snappy编码解码器时，编码解码器使用的块大小 (以字节为单位) |
| spark.closure.serializer |
org.apache.spark.serializer. JavaSerializer |
用于闭包的序化器，目前只有支持Java序化器 |
| spark.serializer. objectStreamReset |
10000 |
org.apache.spark.serializer.JavaSerializer序列化时，会缓存对象以防止写入冗余数据，此时会停止这些对象的垃圾收集。通过调用重置序化器，刷新该信息就可以收集旧对象。若要关闭这重定期重置功能将其设置为< = 0 。默认情况下每10000个对象将重置序化器 |
| spark.kryo.referenceTracking |
True |
当使用Kryo序化数据时，是否跟踪对同一对象的引用。如果你的对象图有回路或者同一对象有多个副本，有必要设置为true；其他情况下可以禁用以提高性能 |
| spark.kryoserializer.buffer.mb |
2 |
在Kryo 里允许的最大对象大小(Kryo会创建一个缓冲区，至少和序化的最大单个对象一样大)。每个worker的每个core只有一个缓冲区 |
-
-
- 执行时相关属性
-
| 属性名 |
默认值 |
含义 |
| spark.default.parallelism |
本地模式：机器核数Mesos：8 其他：max(executor的core，2) |
如果用户不设置，系统使用集群中运行shuffle操作的默认任务数(groupByKey、 reduceByKey等) |
| spark.broadcast.factory |
org.apache.spark.broadcast. HttpBroadcastFactory |
广播的实现类 |
| spark.broadcast.blockSize |
4096 |
TorrentBroadcastFactory块大小(以kb为单位)。过大会降低广播速度；过小会使印象BlockManager性能 |
| spark.files.overwrite |
Fale |
通过 SparkContext.addFile() 添加的文件在目标中已经存在并且内容不匹配时，是否覆盖目标文件 |
| spark.files.fetchTimeout |
False |
在获取由driver通过SparkContext.addFile() 添加的文件时，是否使用通信时间超时 |
| spark.storage.memoryFraction |
0.6 |
Java堆用于cache的比例 |
| spark.tachyonStore.baseDir |
System.getProperty("java.io.tmpdir") |
用于存储RDD的techyon目录，tachyon文件系统的URL由spark.tachyonStore.url设置，也可以是逗号分隔的多个techyon目录 |
| spark.storage. memoryMapThreshold |
8192 |
以字节为单位的块大小，用于磁盘读取一个块大小时进行内存映射。这可以防止Spark在内存映射时使用很小块，一般情况下，对块进行内存映射的开销接近或低于操作系统的页大小 |
| spark.tachyonStore.url |
tachyon://localhost:19998 |
基于techyon文件的URL |
| spark.cleaner.ttl |
spark记录任何元数据(stages生成、task生成等)的持续时间。定期清理可以确保将超期的元数据丢弃，这在运行长时间任务是很有用的，如运行7*24的sparkstreaming任务。RDD持久化在内存中的超期数据也会被清理 |
-
-
- 网络相关属性
-
| 属性名 |
默认值 |
含义 |
| spark.driver.host |
运行driver的主机名或 IP 地址 |
|
| spark.driver.port |
随机 |
driver侦听的端口 |
| spark.rpc.message.maxSize |
10 |
以MB为单位的driver和executor之间通信信息的大小，设置值越大，driver可以接受更大的计算结果 |
| spark.akka.threads |
4 |
用于通信的actor线程数，在大型集群中拥有更多CPU内核的driver可以增加actor线程数 |
| spark.akka.timeout |
100 |
以秒为单位的Spark节点之间超时时间 |
| spark.akka.heartbeat.pauses |
600 |
下面3个参数是用于设置Akka自带的故障探测器。启用的话，以秒为单位设置如下这三个参数，有助于对恶意的executor的定位，而对于由于GC暂停或网络滞后引起的情况下，不需要开启故障探测器；另外故障探测器的开启会导致由于心跳信息的频繁交换而引起的网络泛滥。 本参数是设置可接受的心跳停顿时间 |
| spark.akka.failure-detector.threshold |
300.0 |
对应Akka的akka.remote.transport-failure-detector.threshold |
| spark.akka.heartbeat.interval |
1000 |
心跳间隔时间 |
-
-
- 调度相关属性
-
| 属性名 |
默认值 |
含义 |
| spark.task.cpus |
1 |
为每个任务分配的内核数 |
| spark.task.maxFailures |
4 |
Task的最大重试次数 |
| spark.scheduler.mode |
FIFO |
Spark的任务调度模式，还有一种Fair模式 |
| spark.cores.max |
当应用程序运行在Standalone集群或者粗粒度共享模式Mesos集群时，应用程序向集群请求的最大CPU内核总数(不是指每台机器，而是整个集群)。如果不设置，对于Standalone集群将使用spark.deploy.defaultCores中数值，而Mesos将使用集群中可用的内核 |
|
| spark.mesos.coarse |
False |
如果设置为true，在Mesos集群中运行时使用粗粒度共享模式 |
| spark.speculation |
False |
以下几个参数是关于Spark推测执行机制的相关参数。此参数设定是否使用推测执行机制，如果设置为true则spark使用推测执行机制，对于Stage中拖后腿的Task在其他节点中重新启动，并将最先完成的Task的计算结果最为最终结果 |
| spark.speculation.interval |
100 |
Spark多长时间进行检查task运行状态用以推测，以毫秒为单位 |
| spark.speculation.quantile |
0.75 |
推测启动前，Stage必须要完成总Task的百分比 |
| spark.speculation.multiplier |
1.5 |
比已完成Task的运行速度中位数慢多少倍才启用推测 |
| spark.locality.wait |
3000 |
以下几个参数是关于Spark数据本地性的。本参数是以毫秒为单位启动本地数据task的等待时间，如果超出就启动下一本地优先级别的task。该设置同样可以应用到各优先级别的本地性之间(本地进程 -> 本地节点 -> 本地机架 -> 任意节点 )，当然，也可以通过spark.locality.wait.node等参数设置不同优先级别的本地性 |
| spark.locality.wait.process |
spark.locality.wait |
本地进程级别的本地等待时间 |
| spark.locality.wait.node |
spark.locality.wait |
本地节点级别的本地等待时间 |
| spark.locality.wait.rack |
spark.locality.wait |
本地机架级别的本地等待时间 |
| spark.scheduler.revive.interval |
1000 |
复活重新获取资源的Task的最长时间间隔(毫秒)，发生在Task因为本地资源不足而将资源分配给其他Task运行后进入等待时间，如果这个等待时间内重新获取足够的资源就继续计算 |
-
-
- 安全相关属性
-
| 属性名 |
默认值 |
含义 |
| spark.authenticate |
False |
控制spark通信协议是否使用共享秘钥进行认证，基于握手机制。 YARN部署模式下，为true，可以自动产生并分发共享秘钥。每个应用程序都使用唯一的共享秘钥。 其它部署模式下，应当在每个节点上都配置spark.authenticate.secret。此秘钥将由所有Master、worker及应用程序来使用。 |
| spark.authenticate.secret |
设置组件间身份验证的密钥。如果不是在YARN模式下运行，并且spark.authenticate为true时，需要设置密钥。 |
|
| spark.core.connection.auth.wait.timeout |
30 |
进行身份认证的超时时间 |
| spark.ui.filters |
Spark web UI 要使用的以逗号分隔的筛选器名称列表。筛选器要符合javax servlet Filter标准，每个筛选器的参数可以通过设置java系统属性来指定： spark. 例如： -Dspark.ui.filters=com.test.filter1 -Dspark.com.test.filter1.params='param1=foo,param2=testing' |
|
| spark.ui.acls.enable |
False |
Spark webUI存取权限是否启用。如果启用，在用户浏览web界面的时候会检查用户是否有访问权限 |
| spark.ui.view.acls |
以逗号分隔Spark webUI访问用户的列表。默认情况下只有启动Spark job的用户才有访问权限 |
-
-
- SparkStreaming相关属性
-
| 属性名 |
默认值 |
含义 |
| spark.streaming.blockInterval |
200 |
Spark Streaming接收器将接收数据合并成数据块并存储在Spark里的时间间隔，毫秒 |
| spark.streaming.unpersist |
True |
如果设置为true，强迫将SparkStreaming持久化的RDD数据从Spark内存中清理，同样的，SparkStreaming接收的原始输入数据也会自动被清理；如果设置为false，则允许原始输入数据和持久化的RDD数据可被外部的Streaming应用程序访问，因为这些数据不会自动清理 |
-
-
- Standalone特有属性
-
可以在文件conf/spark-env.sh中来设置此模式的特有相关属性：
(1) SPARK_MASTER_OPTS：配置master使用的属性
(2) SPARK_WORKER_OPTS：配置worker使用的属性
(3) SPARK_DAEMON_JAVA_OPTS：配置master和work都使用的属性
配置的时候，使用类似的语句：
export SPARK_MASTER_OPTS="-Dx1=y1 -Dx2=y2"
其中x代表属性，y代表属性值。
SPARK_MASTER_OPTS所支持的属性有：
| 属性名 |
默认值 |
含义 |
| spark.deploy.spreadOut |
True |
Standalone集群管理器是否自由选择节点还是固定到尽可能少的节点，前者会有更好的数据本地性，后者对于计算密集型工作负载更有效 |
| spark.worker.timeout |
60 |
master因为没有收到心跳信息而认为worker丢失的时间(秒) |
| spark.deploy.defaultCores |
如果没有设置spark.cores.max，该参数设置Standalone集群分配给应用程序的最大内核数，如果不设置，应用程序获取所有的有效内核。注意在一个共享的集群中，设置一个低值防止攫取了所有的内核，影响他人的使用 |
SPARK_WORKER_OPTS所支持的属性有
| 属性名 |
默认值 |
含义 |
| spark.worker.cleanup.enabled |
False |
是否定期清理worker的应用程序工作目录，只适用于Standalone模式，清理的时候将无视应用程序是否在运行 |
| spark.worker.cleanup.interval |
1800 |
清理worker本地过期的应用程序工作目录的时间间隔(秒) |
| spark.worker.cleanup.appDataTtl |
7*24*3600 |
worker保留应用程序工作目录的有效时间。该时间由磁盘空间、应用程序日志、应用程序的jar包以及应用程序的提交频率来设定 |
SPARK_DAEMON_JAVA_OPTS所支持的属性有：
| 属性名 |
含义 |
| spark.deploy.recoveryMode |
下面3个参数是用于配置zookeeper模式的master HA。设置为ZOOKEEPER表示启用master备用恢复模式，默认为NONE |
| spark.deploy.zookeeper.url |
zookeeper集群URL |
| spark.deploy.zookeeper.dir |
zooKeeper保存恢复状态的目录，缺省为/spark |
| spark.deploy.recoveryMode |
设成FILESYSTEM启用master单节点恢复模式，缺省值为NONE |
| spark.deploy.recoveryDirectory |
Spark保存恢复状态的目录 |
-
-
- onYarn特有属性
-
| 属性名 |
默认值 |
含义 |
| spark.yarn.am.waitTime |
10 |
在cluster模式下，该属性表示YARN AM等待SparkContext初始化的时间。 在client模式下，该属性表示YARN AM等待驱动器连接的时间。 |
| spark.yarn.submit.file.replication |
3 |
应用程序上传到HDFS的文件的副本数 |
| spark.yarn.preserve.staging.files |
False |
若为true，在job结束后，将stage相关的文件保留而不是删除 |
| spark.yarn.scheduler.heartbeat.interval-ms |
5000 |
Spark AppMaster发送心跳信息给YARN RM的时间间隔 |
| spark.yarn.max.executor.failures |
2倍于executor数 |
导致应用程序宣告失败的最大executor失败次数 |
| spark.yarn.historyServer.address |
Spark history server的地址(不要加http://)。这个地址会在Spark应用程序完成后提交给YARN RM，然后RM将信息从RM UI写到history server UI上。 |
|
| spark.yarn.am.memory |
512m |
client模式下，使用内存总量，与JVM内存设置格式相同（如512m，2g）。 cluster模式下，设置spark.driver.memory。 使用小写的后缀。 |
| spark.driver.cores |
|
cluster模式下，驱动器使用的CPU core个数。 在cluster模式下，驱动器（driver）和YARN AM使用相同的JVM，所以这个属性也可以用来控制YARN AM。 client模式使用spark.yarn.am.cores。 |
| spark.yarn.am.cores |
|
client模式下，用来控制YARN AM的CPU core个数。 cluster模式使用spark.driver.cores。 |
- mysql
hm02单机模式，存放hive的元数据，无root权限安装mysql。
$mysql_home=/home/hdp/soft/mysql
-
- mysql5.6
- 配置
- mysql5.6
环境变量中定义mysql_home。
1、拷贝cp support-files/my-default.cnf到$mysql_home/my.cnf。
[client]
port = 3306
socket = /home/hdp/soft/mysql/mysql.sock
[mysql]
default-character-set=utf8
max_allowed_packet=16M
[mysqld]
user = mysql
port = 3306
basedir = /home/hdp/soft/mysql
datadir = /home/hdp/soft/mysql/data
socket = /home/hdp/soft/mysql/mysql.sock
open_files_limit = 10240
default-storage-engine=INNODB
character-set-server=utf8
max_allowed_packet=16M
max_connections=100
query_cache_size=0
tmp_table_size=9M
thread_cache_size=8
myisam_max_sort_file_size=10G
myisam_sort_buffer_size=18M
key_buffer_size=11M
read_buffer_size=64K
read_rnd_buffer_size=256K
sort_buffer_size=256K
innodb_flush_log_at_trx_commit=2
innodb_log_buffer_size=1M
innodb_buffer_pool_size=18M
innodb_log_file_size=10M
innodb_thread_concurrency=8
skip-name-resolve
#关闭大小写敏感设置
lower_case_table_names = 1
#设置binlog是为了消除hive元数据库中字段超长问题
binlog_format=MIXED
sql-mode=STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
[mysqldump]
max_allowed_packet=16M
[mysqld_safe]
log-error=/home/hdp/soft/mysql/data/mysql.err
2、修改bin/mysqld_safe
目录定义：$mysql_home_up=/home/hdp/soft
修改所有：替换/usr/local为$mysql_home_up(6个)。
修改一个：/tmp/mysql.sock为$mysql_home/mysql.sock
-
-
- 安装
-
1、安装二进制格式
scripts/mysql_install_db --basedir=/home/hdp/soft/mysql --datadir=/home/hdp/soft/mysql/data
指定my.cnf配置文件，则为编译安装方式。
可把data目录清空。
-
-
- 启动
-
1、启动safe模式，mysql.server里也是用这个启动。
必须指定pid，否则会去找/var/run/mysqld/mysqld.pid。
bin/mysqld_safe --pid_file=/home/hdp/soft/mysql/mysqld.pid &
#这个可以跳过授权表，直接用mysql登录。
bin/mysqld_safe --skip-grant-tables &
2、做sock的链接
ln -s /home/hdp/soft/mysql/mysql.sock /tmp/mysql.sock
3、修改root密码
bin/mysqladmin -u root password 'root'
或非--skip-grant-tables启动
mysql -uroot
mysql> SET PASSWORD FOR 'root'@'localhost' = PASSWORD('root');
或忘记密码(--skip-grant-tables启动)
mysql> use mysql;
mysql> update user set password=password('root') where user='root' and host='localhost';
mysql> flush privileges;
4、赋权
mysql>GRANT all ON *.* TO 'root'@'%' IDENTIFIED BY 'root' WITH GRANT OPTION;
mysql>FLUSH PRIVILEGES;
#为执行关闭mysql的命令
mysql>GRANT all ON *.* TO ''@'localhost' WITH GRANT OPTION;
mysql>FLUSH PRIVILEGES;
#收回权限(不包含赋权权限)
mysql>REVOKE ALL PRIVILEGES ON *.* FROM username;
#收回赋权权限
mysql>REVOKE GRANT OPTION ON *.* FROM username;
#重新载入赋权表
mysql>FLUSH PRIVILEGES;
5、新建用户
mysql>CREATE USER 'username'@'localhost' IDENTIFIED BY 'pwd';
mysql>CREATE USER 'username'@'host' IDENDIFIED BY 'pwd';
mysql>CREATE USER 'username'@'%' IDENTIFIED BY 'pwd';
6、创建数据库
mysql>CREATE DATABASE hivedb DEFAULT CHARACTER SET latin1 COLLATE latin1_general_ci;
指定字符集为了消除hive异常。
-
-
- 停止
-
mysql.server里是直接kill。
bin/mysqladmin -u root -p'root' -S mysql.sock shutdown
-
- mysql5.7
- 配置
- mysql5.7
1、编辑/omc/software/mysql/my.cnf
[client]
port=3306
socket=/omc/software/mysql/mysql.sock
[mysqld]
port=3306
basedir=/omc/software/mysql
datadir=/omc/software/mysql/data
pid-file=/omc/software/mysql/mysql.pid
socket=/omc/software/mysql/mysql.sock
log_error=/omc/software/mysql/error.log
server-id=100
2、检查依赖包
rpm -qa | grep libaio
yum -y install libaio
-
-
- 安装
-
1、初始化
bin/mysqld --defaults-file=/omc/software/mysql/my.cnf --initialize --user=omc --basedir=/omc/software/mysql --datadir=/omc/software/mysql/data
--initialize是生成随机密码，在error.log的最后。
--user使用当前系统用户名。
2、打开error.log，查看密码。
3、修改bin/mysqld_safe
目录定义：$mysql_home_up=/home/hdp/soft
修改所有：替换/usr/local为$mysql_home_up(6个)。
修改一个：/tmp/mysql.sock为$mysql_home/mysql.sock
-
-
- 启动
-
1、启动
bin/mysqld_safe --defaults-file=/omc/software/mysql/my.cnf --user=omc &
2、做软链接
ln -s /omc/software/mysql/mysql.sock /tmp/mysql.sock
3、登录
bin/mysql -u root -p
4、改密码
mysql> SET PASSWORD FOR 'root'@'localhost' = PASSWORD('root');
5、赋权
mysql>GRANT all ON *.* TO 'root'@'%' IDENTIFIED BY 'root' WITH GRANT OPTION;
mysql>FLUSH PRIVILEGES;
-
-
- 停止
-
kill
bin/mysqladmin -u root -p'root' -S mysql.sock shutdown
- hive
部署在hd01。
metastore有2种存储方式，本地存储和远程存储，用的是远程存储配置。
HiveServer或者HiveServer2都是基于Thrift的，但HiveSever有时被称为Thrift server，而HiveServer2却不会。因为HiveServer使用的Thrift接口所导致的限制，使它不能处理多于一个客户端的并发请求，而又不能通过代码修正。因此在Hive-0.11.0版本中重写了HiveServer得到了HiveServer2，解决了该问题，HiveServer2支持多客户端的并发和认证。
正式运行时，直接启动server2而不用server了。
-
- 配置
- 环境变量
- 配置
编辑环境变量文件(.bashrc)
export HIVE_HOME="/home/hdp/soft/hive"
export PATH="${HIVE_HOME}/bin:${PATH}"
将mysql的jdbc包拷贝到lib下。
-
-
- hive-env.sh
-
| 名称 |
说明 |
建议值 |
| HADOOP_HOME |
指明hadoop路径 |
/home/hdp/soft/hadoop |
| HIVE_AUX_JARS_PATH |
用户自定义udf存储路径 |
Udf jar包绝对值路径 |
示例
export HADOOP_HOME=/home/hdp/soft/hadoop
export HIVE_CONF_DIR=${HIVE_HOME}/conf
export HIVE_AUX_JARS_PATH=${SPARK_HOME}/jars/spark*.jar
-
-
- hive-site.xml
-
vi hive-site.xml
| 名称 |
说明 |
默认值 |
建议值 |
| Javax.jdo.option.ConnectionURL |
Hive Jdbc链接mysql元数据库的地址 |
|
jdbc:mysql://hd01:3306/hivedb?createDatabaseIfNotExist=true |
| Javax.jdo.option.ConnectionDriverName |
Jdbc链接驱动名称 |
|
com.mysql.jdbc.Driver |
| Javax.jdo.option.ConnectionUserName |
Jdbc链接hive元数据库的用户名 |
|
root |
| Javax.jdo.option.ConnectionPassword |
用户名对应的口令 |
|
root |
| hive.zookeeper.quorm |
链接的Zookeeper集群 |
|
hd01:8501,hd02:8501,hd03:8501 |
| hive.zookeeper.client.timeout |
链接Zookeeper节点超时设置 |
|
60000 |
| hive.zookeeper.clean.extra.nodes |
Zookeeper在会话结束时清除额外的node |
|
true |
| datanucleus.autoCreateSchema |
允许创建元数据库相关信息开关 【注意:第一次启动后该项应该从true修改为false】 |
true |
第一次启动：true 以后启动：false |
| datanucleus.autoCreateTables |
允许创建表开关 |
|
true |
| hive.support.concurrency |
允许并发开关 |
|
true |
| hive.metastore.schema.verification |
Metastore与hive jar包版本校验开关 |
false |
true |
| hive.metastore.uris |
hiverserver2访问metastore的uri |
9083 |
thrift://hd01:9083 |
| hive.server2.thrift.bind.host |
Hiveserver2远程服务的主机 |
localhost |
hd01 |
| hive.server2.thrift.port |
Hiveserver2远程服务的监听端口，客户端使用 |
10000 |
10000 |
| hive.server2.thrift.max.worker.threads |
Hiveserver2远程服务最大并发线程数 |
500 |
1024 |
| hive.server2.transport.mode |
HTTP传输模式 |
binary |
|
| hive.server2.thrift.http.port |
HTTP的监听端口 |
10001 |
|
| hive.server2.thrift.http.path |
服务的端点名称 |
cliservice |
|
| hive.server2.thrift.http.max.worker.threads |
最大线程数 |
500 |
|
| hive.server2.webui.host |
hiveserver2的web服务 |
|
hd01 |
| hive.server2.webui.port |
hiveserver2的web端口 |
10002 |
10002 |
|
|
|
|
|
| hive.hwi.listen.host |
Hive Web服务主机， 用处不大，仅了解 |
localhost |
hd01 |
| hive.hwi.listen.port |
Hive Web服务端口 |
9999 |
|
| hive.hwi.war.file |
服务的jar包 |
无 |
lib/hive-hwi.jar，指定具体包名 |
|
|
|
|
|
| hive.metastore.warehouse.dir |
hive表数据在hdfs上的存储路径 |
/hive/warehouse |
hdfs://myhdcluster/hive/warehouse |
| hive.exec.scratchdir |
hive在hdfs中的临时目录 |
|
hdfs://myhdcluster/hive/tmp |
| hive.downloaded.resources.dir |
资源临时文件存放位置 |
|
/home/hdp/work/hive/tmp/res |
| hive.querylog.location |
hive的日志文件目录 |
|
/home/hdp/work/hive/logs |
| hive.aux.jars.path |
hive用的外部jar包，逗号分隔 |
|
file:// |
| hive.server2.authentication |
认证方式 |
NONE |
NONE |
| hive.server2.thrift.client.user |
beeline客户端用户名 |
|
hdp |
| hive.server2.thrift.client.password |
密码 |
|
d |
示例：
-
-
- hive-log4j.properties
-
hive.log.dir=/home/hdp/work/hive/logs
log4j.appender.EventCounter=org.apache.hadoop.log.metrics.EventCounter
-
-
- 集成Hadoop/hbase
-
cp core-site.xml,hdfs-site.xml,hbase-site.xml到conf。
cp hbase/lib/hbase*.jar，protobuf-java-2.5.0.jar到lib。
cp spark/jars/spark*.jar到lib。
-
-
- 工作目录
-
mkdir -p /home/hdp/work/hive/logs
mkdir -p /home/hdp/work/hive/tmp
hadoop fs -mkdir -p /hive/tmp
hadoop fs -mkdir -p /hive/warehouse
hadoop fs -chmod -R 777 /hive/tmp
-
- 分发
scp到需要的机器上。
-
- 启动
先启动mysql。
1、hd01启动metastore。
hive --service metastore -p 9083 &
如果不用默认端口，在服务启动时直接指定。
可启动多个，要指定端口，hive.metastore.uris也要对应，逗号分隔。
2、hd01启动hiveserver2。
hive --service hiveserver2 &
或
hive --service hiveserver2 --hiveconf hive.server2.thrift.port=10000 &
可启动多个，要指定端口。
3、hd01启动beeline service
hive --service beeline &
-
- 验证
输入：hive。
#> create database mydb;
#> show databases;
输入：beeline，执行命令用!开头。
#> !connect jdbc:hive2://hd01:10000/mydb
-
-
- 单独
-
hive> show databases;
#创建数据库
hive> create database mydb;
hive> use mydb;
#创建外部表
hive> create external table t1(uid int, myname string) row format delimited fields terminated by ',' location '/hive/warehouse/mydb';
hive> show tables;
# Load数据到表
vim testhive.tbl
0001,mic
0002,tome
0003,david
0004,mary
0005,aya
0006,maya
0007,cruse
hive> LOAD DATA LOCAL INPATH '/home/hdp/testhive.tbl' OVERWRITE INTO TABLE t1;
hive> select * from t1;
-
-
- 与Hbase整合
- Hive2Hbase
- 与Hbase整合
-
# Hive中的表数据导入到Hbase
# 创建Hbase能识别的表(带分区)
hive> CREATE TABLE hbase_to_hbase_yousmile_20140704(key int, value string) partitioned by (day string) STORED BY 'org.apache.hadoop.hive.hbase.HBaseStorageHandler' WITHSERDEPROPERTIES ("hbase.columns.mapping" = ":key,cf1:info") TBLPROPERTIES ("hbase.table.name" ="hive_to_hbase_yousmile_20140704");
# 创建Hbase能识别的表(不带分区)
hive> set hive.hbase.bulk=true;
# 创建数据库yting_yousmile_20140704
hive> create database yting_yousmile_20140704;
hive> use yting_yousmile_20140704;
-
-
-
- 创建本地表
-
-
# 创建本地表，用来存储数据，然后插入到Hbase用的，相当于一张中间表
hive> create table hive_to_hbase_middle_yousmile_20140704(uid int, info string) row format delimited fields terminated by ',';
# Load本地数据到Hive的中间表hive_to_hbase_middle_yousmile_20140704去
hive> load data local inpath '/usr/local/yting/hive/data/tdata/hbase_test001.dat' overwrite into table hive_to_hbase_middle_yousmile_20140704;
与hbase整合有分区的表存在个问题select * from table查询不到数据，select key,value from table可以查到数据。
-
-
-
- Hbase2Hive
-
-
# Hbase中的表数据导入到Hive
create 'hbase_to_hive_yousmile_20140704', 'gid', 'info';
#Hive下创建表连接Hbase中的表
create external table hbase_to_hive_yousmile_20140704 (key string, gid map
#查询Hbase表中的数据
hive> select * from hbase_to_hive_yousmile_20140704;
-
- 停止
kill
- impala
- 部署方式
两种集群部署：混合部署和独立部署，下图分别展示了混合部署与独立部署时的各节点结构。
混合部署将Impala集群部署在Hadoop集群之上，共享Hadoop集群的资源；独立部署是单独使用机器只部署HDFS和Impala。
独立部署，每一个Datanode节点上启动一个Impalad进程，这种方式可以使本地化读取最大化，Impalad进程可以利用HDFS的Short Circuit Local Reads机制直接利用Unix Domain Socket获取DN的文件描述符，然后通过共享文件描述符的方式读取数据，当然也会尽可能的使用DN节点的block缓存等，因此性能也是最好的。对于数据的导入有两种方案：1、批量的利用一个共享的Hive元数据库，利用Hive的load data的方式将原集群的数据写入到Impala所在的HDFS；对于准实时的数据使用MR或者Spark任务写入到独立的HDFS集群；2、写入到本地集群，然后使用Distcp方式直接拷贝文件。
混合部署的优势是Impala可以和Hadoop集群共享数据，不需要数据拷贝，但存在Impala和Hadoop集群抢占资源的情况，进而可能影响Impala的查询性能(MR任务也可能被Impala影响)。需要考虑如何分配资源的问题，不能让Impalad进程常驻(这样相当于把每一个NodeManager的资源分出去了一部分，并且不能充分利用集群资源)，但是YARN的资源分配机制延迟太大，对于Impala的查询速度有很大影响。Impala设计了一种在YARN上完成Impala资源调度的方案--Llama(Low Latency Application MAster)，它是一个AM角色，对于Impala而言，它的要求是在查询执行之前必须确保需要的资源可用，否则可能出现一个Impalad的阻塞而影响整个查询的响应速度(木桶原理)，Llama会在Impala查询之前申请足够的资源，并且在查询完成之后尽可能的缓存资源，只有当YARN需要将该部分资源用于其它工作时，Llama才会将资源释放。虽然Llama尽可能的保持资源，但是混合部署的情况下，还是可能存在Impala查询获取不到资源的情况，为了保证高性能，最后独立部署。
Impalad资源隔离
Hadoop资源隔离的方案大多是使用YARN，Impala也可以使用YARN进行调度，通过Llama模块作为一个YARN系统的一个Application Manager模块实现资源的分配和隔离，llama会尽可能的占有资源指导YARN回收，所以对于单独的集群这种资源分配策略是可以使用的，需要配置fair-scheduler.xml和llama-site.xml文件。
-
- 依赖包
yum安装
python-setuptools,bigtop-utils,bigtop-jsvc,lsb
-
- 配置
vi .bashrc
export IMPALA_HOME="/home/hdp/soft/impala"
export CLASSPATH="${IMPALA_HOME}/lib:${CLASSPATH}"
export PATH="${IMPALA_HOME}/bin:${IMPALA_HOME}/shell:${PATH}"
配置文件impala在conf下。
-
-
- impala
-
vi impala
#主节点
IMPALA_CATALOG_SERVICE_HOST=hd01
#主节点
IMPALA_STATE_STORE_HOST=hd01
IMPALA_STATE_STORE_PORT=24000
IMPALA_BACKEND_PORT=22000
IMPALA_LOG_DIR=/home/hdp/work/impala/logs
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=/home/hdp/soft/impala/lib
MYSQL_CONNECTOR_JAR=/home/hdp/soft/impala/lib/mysql-connector-java.jar
HADOOP_HOME=/home/hdp/soft/hadoop
HBASE_HOME=/home/hdp/soft/hbase
HIVE_HOME=/home/hdp/soft/hive
IMPALA_BIN=/home/hdp/soft/impala/sbin
IMPALA_CONF_DIR=/home/hdp/soft/impala/conf
HADOOP_CONF_DIR=/home/hdp/soft/impala/conf
HIVE_CONF_DIR=/home/hdp/soft/impala/conf
HBASE_CONF_DIR=/home/hdp/soft/impala/conf
-
-
- bigtop-utils
-
配置文件在/etc/default/下。
export JAVA_HOME=/home/hdp/soft/jdk1.8.0
-
-
- hdfs-site.xml
-
拷贝hdfs-site.xml到impala/conf，添加内容。
-
-
- hive-site.xml
-
拷贝hive-site.xml到impala/conf，配置。
-
- 脚本
脚本文件在bin下，需要新创建以下各脚本，并根据实际目录调整。
-
-
- impala-state-store
-
原文件/etc/init.d/impala-state-store
新文件${IMPALA_HOME}/bin/impala-state-store.sh
#!/bin/bash
IMPALA_HOME=/home/hdp/soft/impala
IMPALA_WORK=/home/hdp/work/impala
. /lib/lsb/init-functions
BIGTOP_DEFAULTS_DIR=${BIGTOP_DEFAULTS_DIR-/etc/default}
#[ -n "${BIGTOP_DEFAULTS_DIR}" -a -r ${IMPALA_HOME}/conf/hadoop ] && . ${IMPALA_HOME}/conf/hadoop
[ -n "${BIGTOP_DEFAULTS_DIR}" -a -r ${IMPALA_HOME}/conf/impala ] && . ${IMPALA_HOME}/conf/impala
# Autodetect JAVA_HOME if not defined
#. /usr/lib/bigtop-utils/bigtop-detect-javahome
export ENABLE_CORE_DUMPS
export IMPALA_BIN
export IMPALA_CONF_DIR
export HADOOP_CONF_DIR
export HIVE_CONF_DIR
export HBASE_CONF_DIR
export LIBHDFS_OPTS
export HIVE_HOME
export HBASE_HOME
RETVAL_SUCCESS=0
STATUS_RUNNING=0
STATUS_DEAD=1
STATUS_DEAD_AND_LOCK=2
STATUS_NOT_RUNNING=3
STATUS_OTHER_ERROR=102
ERROR_PROGRAM_NOT_INSTALLED=5
ERROR_PROGRAM_NOT_CONFIGURED=6
RETVAL=0
SLEEP_TIME=5
PROC_NAME="java"
DAEMON="statestored"
DESC="Impala State Store Server"
EXEC_PATH="${IMPALA_HOME}/bin/statestored"
EXEC_DIR=""
DAEMON_FLAGS="${IMPALA_STATE_STORE_ARGS}"
CONF_DIR="${IMPALA_HOME}/conf"
PIDFILE="${IMPALA_WORK}/pids/statestored-impala.pid"
LOCKDIR="${IMPALA_WORK}/lock"
LOCKFILE="$LOCKDIR/statestored"
WORKING_DIR="${IMPALA_WORK}"
install -d -m 0755 -o hdp -g hdp ${IMPALA_WORK}/pids 1>/dev/null 2>&1 || :
[ -d "$LOCKDIR" ] || install -d -m 0755 $LOCKDIR 1>/dev/null 2>&1 || :
start() {
[ -x $EXEC_PATH ] || exit $ERROR_PROGRAM_NOT_INSTALLED
[ -d $CONF_DIR ] || exit $ERROR_PROGRAM_NOT_CONFIGURED
checkstatus >/dev/null 2>/dev/null
status=$?
if [ "$status" -eq "$STATUS_RUNNING" ]; then
log_success_msg "${DESC} is running"
exit 0
fi
sh -c "sh -c 'cd ~ && echo \$\$ > ${PIDFILE} && exec ${EXEC_PATH} ${DAEMON_FLAGS} >> ${IMPALA_LOG_DIR}/impala-state-store.log 2>&1' &"
RETVAL=$?
if [ $RETVAL -eq $STATUS_RUNNING ]; then
touch $LOCKFILE
log_success_msg "Started ${DESC} (${DAEMON}): "
else
log_failure_msg "Failed to start ${DESC}. Return value: $RETVAL"
fi
return $RETVAL
}
stop() {
killproc -p $PIDFILE $EXEC_PATH
RETVAL=$?
if [ $RETVAL -eq $RETVAL_SUCCESS ]; then
log_success_msg "Stopped ${DESC}: "
rm -f $LOCKFILE $PIDFILE
else
log_failure_msg "Failure to stop ${DESC}. Return value: $RETVAL"
fi
return $RETVAL
}
restart() {
stop
start
}
checkstatusofproc(){
pidofproc -p $PIDFILE $PROC_NAME > /dev/null
}
checkstatus(){
checkstatusofproc
status=$?
case "$status" in
$STATUS_RUNNING)
log_success_msg "${DESC} is running"
;;
$STATUS_DEAD)
log_failure_msg "${DESC} is dead and pid file exists"
;;
$STATUS_DEAD_AND_LOCK)
log_failure_msg "${DESC} is dead and lock file exists"
;;
$STATUS_NOT_RUNNING)
log_failure_msg "${DESC} is not running"
;;
*)
log_failure_msg "${DESC} status is unknown"
;;
esac
return $status
}
condrestart(){
[ -e $LOCKFILE ] && restart || :
}
service() {
case "$1" in
start)
start
;;
stop)
stop
;;
status)
checkstatus
RETVAL=$?
;;
restart)
restart
;;
condrestart|try-restart)
condrestart
;;
*)
echo $"Usage: $0 {start|stop|status|restart|try-restart|condrestart}"
exit 1
esac
}
service "$@"
exit $RETVAL
-
-
- impala-catalog
-
原文件/etc/init.d/impala-catalog
新文件${IMPALA_HOME}/bin/impala-catalog.sh
#!/bin/bash
export IMPALA_HOME=/home/hdp/soft/impala
export IMPALA_WORK=/home/hdp/work/impala
. /lib/lsb/init-functions
BIGTOP_DEFAULTS_DIR=${BIGTOP_DEFAULTS_DIR-/etc/default}
#[ -n "${BIGTOP_DEFAULTS_DIR}" -a -r ${IMPALA_HOME}/conf/hadoop ] && . ${IMPALA_HOME}/conf/hadoop
[ -n "${BIGTOP_DEFAULTS_DIR}" -a -r ${IMPALA_HOME}/conf/impala ] && . ${IMPALA_HOME}/conf/impala
# Autodetect JAVA_HOME if not defined
#. /usr/lib/bigtop-utils/bigtop-detect-javahome
export ENABLE_CORE_DUMPS
export IMPALA_BIN
export IMPALA_CONF_DIR
export HADOOP_CONF_DIR
export HIVE_CONF_DIR
export HBASE_CONF_DIR
export LIBHDFS_OPTS
export HIVE_HOME
export HBASE_HOME
RETVAL_SUCCESS=0
STATUS_RUNNING=0
STATUS_DEAD=1
STATUS_DEAD_AND_LOCK=2
STATUS_NOT_RUNNING=3
STATUS_OTHER_ERROR=102
ERROR_PROGRAM_NOT_INSTALLED=5
ERROR_PROGRAM_NOT_CONFIGURED=6
RETVAL=0
SLEEP_TIME=5
PROC_NAME="java"
DAEMON="catalogd"
DESC="Impala Catalog Server"
EXEC_PATH="${IMPALA_HOME}/bin/catalogd"
EXEC_DIR=""
DAEMON_FLAGS="${IMPALA_CATALOG_ARGS}"
CONF_DIR="${IMPALA_HOME}/conf"
PIDFILE="${IMPALA_WORK}/pids/catalogd-impala.pid"
LOCKDIR="${IMPALA_WORK}/lock"
LOCKFILE="${LOCKDIR}/catalogd"
WORKING_DIR="${IMPALA_WORK}"
install -d -m 0755 -o hdp -g hdp ${IMPALA_WORK}/pids 1>/dev/null 2>&1 || :
[ -d "$LOCKDIR" ] || install -d -m 0755 $LOCKDIR 1>/dev/null 2>&1 || :
start() {
[ -x $EXEC_PATH ] || exit $ERROR_PROGRAM_NOT_INSTALLED
[ -d $CONF_DIR ] || exit $ERROR_PROGRAM_NOT_CONFIGURED
checkstatus >/dev/null 2>/dev/null
status=$?
if [ "$status" -eq "$STATUS_RUNNING" ]; then
log_success_msg "${DESC} is running"
exit 0
fi
sh -c "sh -c 'cd ~ && echo \$\$ > ${PIDFILE} && exec ${EXEC_PATH} ${DAEMON_FLAGS} >> ${IMPALA_LOG_DIR}/impala-catalog.log 2>&1' &"
RETVAL=$?
if [ $RETVAL -eq $STATUS_RUNNING ]; then
touch $LOCKFILE
log_success_msg "Started ${DESC} (${DAEMON}) : "
else
log_failure_msg "Failed to start ${DESC}. Return value: $RETVAL"
fi
return $RETVAL
}
stop() {
killproc -p $PIDFILE $EXEC_PATH
RETVAL=$?
if [ $RETVAL -eq $RETVAL_SUCCESS ]; then
log_success_msg "Stopped ${DESC}: "
rm -f $LOCKFILE $PIDFILE
else
log_failure_msg "Failure to stop ${DESC}. Return value: $RETVAL"
fi
return $RETVAL
}
restart() {
stop
start
}
checkstatusofproc(){
pidofproc -p $PIDFILE $PROC_NAME > /dev/null
}
checkstatus(){
checkstatusofproc
status=$?
case "$status" in
$STATUS_RUNNING)
log_success_msg "${DESC} is running"
;;
$STATUS_DEAD)
log_failure_msg "${DESC} is dead and pid file exists"
;;
$STATUS_DEAD_AND_LOCK)
log_failure_msg "${DESC} is dead and lock file exists"
;;
$STATUS_NOT_RUNNING)
log_failure_msg "${DESC} is not running"
;;
*)
log_failure_msg "${DESC} status is unknown"
;;
esac
return $status
}
condrestart(){
[ -e $LOCKFILE ] && restart || :
}
service() {
case "$1" in
start)
start
;;
stop)
stop
;;
status)
checkstatus
RETVAL=$?
;;
restart)
restart
;;
condrestart|try-restart)
condrestart
;;
*)
echo $"Usage: $0 {start|stop|status|restart|try-restart|condrestart}"
exit 1
esac
}
service "$@"
exit $RETVAL
-
-
- impala-server
-
原文件/etc/init.d/impala-server
新文件${IMPALA_HOME}/bin/impala-server.sh
#!/bin/bash
export IMPALA_HOME=/home/hdp/soft/impala
export IMPALA_WORK=/home/hdp/work/impala
. /lib/lsb/init-functions
BIGTOP_DEFAULTS_DIR=${BIGTOP_DEFAULTS_DIR-/etc/default}
#[ -n "${BIGTOP_DEFAULTS_DIR}" -a -r ${IMPALA_HOME}/conf/hadoop ] && . ${IMPALA_HOME}/conf/hadoop
[ -n "${BIGTOP_DEFAULTS_DIR}" -a -r ${IMPALA_HOME}/conf/impala ] && . ${IMPALA_HOME}/conf/impala
# Autodetect JAVA_HOME if not defined
#. /usr/lib/bigtop-utils/bigtop-detect-javahome
export ENABLE_CORE_DUMPS
export IMPALA_BIN
export IMPALA_CONF_DIR
export HADOOP_CONF_DIR
export HIVE_CONF_DIR
export HBASE_CONF_DIR
export LIBHDFS_OPTS
export MYSQL_CONNECTOR
export HIVE_HOME
export HBASE_HOME
RETVAL_SUCCESS=0
STATUS_RUNNING=0
STATUS_DEAD=1
STATUS_DEAD_AND_LOCK=2
STATUS_NOT_RUNNING=3
STATUS_OTHER_ERROR=102
ERROR_PROGRAM_NOT_INSTALLED=5
ERROR_PROGRAM_NOT_CONFIGURED=6
RETVAL=0
SLEEP_TIME=5
PROC_NAME="java"
DAEMON="impalad"
DESC="Impala Server"
EXEC_PATH="${IMPALA_HOME}/bin/impalad"
EXEC_DIR=""
DAEMON_FLAGS="${IMPALA_SERVER_ARGS}"
CONF_DIR="${IMPALA_HOME}/conf"
PIDFILE="${IMPALA_WORK}/pids/impalad-impala.pid"
LOCKDIR="${IMPALA_WORK}/lock"
LOCKFILE="${LOCKDIR}/impalad"
WORKING_DIR="${IMPALA_WORK}"
install -d -m 0755 -o hdp -g hdp ${IMPALA_WORK}/pids 1>/dev/null 2>&1 || :
[ -d "$LOCKDIR" ] || install -d -m 0755 $LOCKDIR 1>/dev/null 2>&1 || :
start() {
[ -x $EXEC_PATH ] || exit $ERROR_PROGRAM_NOT_INSTALLED
[ -d $CONF_DIR ] || exit $ERROR_PROGRAM_NOT_CONFIGURED
checkstatus >/dev/null 2>/dev/null
status=$?
if [ "$status" -eq "$STATUS_RUNNING" ]; then
log_success_msg "${DESC} is running"
exit 0
fi
sh -c "sh -c 'cd ~ && echo \$\$ > ${PIDFILE} && exec ${EXEC_PATH} ${DAEMON_FLAGS} >>${IMPALA_LOG_DIR}/impala-server.log 2>&1' &"
RETVAL=$?
if [ $RETVAL -eq $STATUS_RUNNING ]; then
touch $LOCKFILE
log_success_msg "Started ${DESC} (${DAEMON}): "
else
log_failure_msg "Failed to start ${DESC}. Return value: $RETVAL"
fi
return $RETVAL
}
stop() {
killproc -p $PIDFILE $EXEC_PATH
RETVAL=$?
if [ $RETVAL -eq $RETVAL_SUCCESS ]; then
log_success_msg "Stopped ${DESC}: "
rm -f $LOCKFILE $PIDFILE
else
log_failure_msg "Failure to stop ${DESC}. Return value: $RETVAL"
fi
return $RETVAL
}
restart() {
stop
start
}
checkstatusofproc(){
pidofproc -p $PIDFILE $PROC_NAME > /dev/null
}
checkstatus(){
checkstatusofproc
status=$?
case "$status" in
$STATUS_RUNNING)
log_success_msg "${DESC} is running"
;;
$STATUS_DEAD)
log_failure_msg "${DESC} is dead and pid file exists"
;;
$STATUS_DEAD_AND_LOCK)
log_failure_msg "${DESC} is dead and lock file exists"
;;
$STATUS_NOT_RUNNING)
log_failure_msg "${DESC} is not running"
;;
*)
log_failure_msg "${DESC} status is unknown"
;;
esac
return $status
}
condrestart(){
[ -e $LOCKFILE ] && restart || :
}
service() {
case "$1" in
start)
start
;;
stop)
stop
;;
status)
checkstatus
RETVAL=$?
;;
restart)
restart
;;
condrestart|try-restart)
condrestart
;;
*)
echo $"Usage: $0 {start|stop|status|restart|try-restart|condrestart}"
exit 1
esac
}
service "$@"
exit $RETVAL
-
-
- statestored
-
原文件/usr/bin/statestored
新文件${IMPALA_HOME}/bin/statestored
#!/bin/bash
if [ "$ENABLE_CORE_DUMPS" == "true" ] ; then
ulimit -c unlimited
elif [ -z "$ENABLE_CORE_DUMPS" -o "$ENABLE_CORE_DUMPS" == "false" ] ; then
ulimit -c 0
else
echo 'WARNING: $ENABLE_CORE_DUMPS must be either "true" or "false"'
fi
# ensure that java has already been found
#if [ -z "${JAVA_HOME}" ]; then
# echo "Unable to find Java. JAVA_HOME should be set in #/etc/default/bigtop-utils"
# exit 1
#fi
# Autodetect location of native java libraries
for library in libjvm.so libjsig.so libjava.so; do
library_file=`find ${JAVA_HOME}/ -name $library | head -1`
if [ -n "$library_file" ] ; then
library_dir=`dirname $library_file`
export LD_LIBRARY_PATH=$library_dir:${LD_LIBRARY_PATH}
fi
done
export LD_LIBRARY_PATH="${IMPALA_HOME}/lib64:${IMPALA_BIN}:${LD_LIBRARY_PATH}"
for JAR_FILE in ${IMPALA_HOME}/lib/*.jar; do
export CLASSPATH="${JAR_FILE}:${CLASSPATH}"
done
export CLASSPATH="${IMPALA_CONF_DIR}:${HADOOP_CONF_DIR}:${HIVE_CONF_DIR}:${HBASE_CONF_DIR}:${CLASSPATH}"
#export CLASSPATH="${MYSQL_CONNECTOR_JAR}:${CLASSPATH}"
if [ -n "${AUX_CLASSPATH}" ]; then
export CLASSPATH="${AUX_CLASSPATH}:${CLASSPATH}"
fi
# Add non-standard kinit location to PATH
if [ -d /usr/kerberos/bin ]; then
export PATH=/usr/kerberos/bin:${PATH}
fi
exec ${IMPALA_BIN}/statestored "$@"
-
-
- catalogd
-
原文件/usr/bin/catalogd
新文件${IMPALA_HOME}/bin/catalogd
#!/bin/bash
if [ "$ENABLE_CORE_DUMPS" == "true" ] ; then
ulimit -c unlimited
elif [ -z "$ENABLE_CORE_DUMPS" -o "$ENABLE_CORE_DUMPS" == "false" ] ; then
ulimit -c 0
else
echo 'WARNING: $ENABLE_CORE_DUMPS must be either "true" or "false"'
fi
# Autodetect location of native java libraries
for library in libjvm.so libjsig.so libjava.so; do
library_file=`find ${JAVA_HOME}/ -name $library | head -1`
if [ -n "$library_file" ] ; then
library_dir=`dirname $library_file`
export LD_LIBRARY_PATH=$library_dir:${LD_LIBRARY_PATH}
fi
done
export LD_LIBRARY_PATH="${IMPALA_HOME}/lib64:${IMPALA_BIN}:${LD_LIBRARY_PATH}"
for JAR_FILE in ${IMPALA_HOME}/lib/*.jar; do
export CLASSPATH="${JAR_FILE}:${CLASSPATH}"
done
export CLASSPATH="${IMPALA_CONF_DIR}:${HADOOP_CONF_DIR}:${HIVE_CONF_DIR}:${HBASE_CONF_DIR}:${CLASSPATH}"
if [ -n "${AUX_CLASSPATH}" ]; then
export CLASSPATH="${AUX_CLASSPATH}:${CLASSPATH}"
fi
# Add non-standard kinit location to PATH
if [ -d /usr/kerberos/bin ]; then
export PATH=/usr/kerberos/bin:${PATH}
fi
exec ${IMPALA_BIN}/catalogd "$@"
-
-
- impalad
-
原文件/usr/bin/impalad
新文件${IMPALA_HOME}/bin/impalad
#!/bin/bash
if [ "$ENABLE_CORE_DUMPS" == "true" ] ; then
ulimit -c unlimited
elif [ -z "$ENABLE_CORE_DUMPS" -o "$ENABLE_CORE_DUMPS" == "false" ] ; then
ulimit -c 0
else
echo 'WARNING: $ENABLE_CORE_DUMPS must be either "true" or "false"'
fi
# Autodetect location of native java libraries
for library in libjvm.so libjsig.so libjava.so; do
library_file=`find ${JAVA_HOME}/ -name $library | head -1`
if [ -n "$library_file" ] ; then
library_dir=`dirname $library_file`
export LD_LIBRARY_PATH=$library_dir:${LD_LIBRARY_PATH}
fi
done
export LD_LIBRARY_PATH="${IMPALA_HOME}/lib64:${IMPALA_BIN}:${LD_LIBRARY_PATH}"
for JAR_FILE in ${IMPALA_HOME}/lib/*.jar; do
export CLASSPATH="${JAR_FILE}:${CLASSPATH}"
done
export CLASSPATH="${IMPALA_CONF_DIR}:${HADOOP_CONF_DIR}:${HIVE_CONF_DIR}:${HBASE_CONF_DIR}:${CLASSPATH}"
#export CLASSPATH="${MYSQL_CONNECTOR_JAR}:${CLASSPATH}"
if [ -n "${AUX_CLASSPATH}" ]; then
export CLASSPATH="${AUX_CLASSPATH}:${CLASSPATH}"
fi
# Add non-standard kinit location to PATH
if [ -d /usr/kerberos/bin ]; then
export PATH=/usr/kerberos/bin:${PATH}
fi
exec ${IMPALA_BIN}/impalad "$@"
-
-
- impala-shell
-
原文件/usr/bin/impala-shell
新文件${IMPALA_HOME}/shell/impala-shell
#!/bin/bash
export IMPALA_SHELL_HOME=/home/hdp/soft/impala/shell
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
SHELL_HOME=${IMPALA_SHELL_HOME:-${SCRIPT_DIR}}
# Set the envrionment's locale settings to allow for utf-8 compatibility
export LC_CTYPE=${LC_CTYPE:-en_US.UTF-8}
# We should set the EGG_CACHE to a per-user temporary location.
# This follows what hue does.
PYTHON_EGG_CACHE=/tmp/impala-shell-python-egg-cache-${USER}
if [ ! -d ${PYTHON_EGG_CACHE} ]; then
mkdir ${PYTHON_EGG_CACHE}
fi
# External module eggs are located in /ext-py, append them to the PYTHONPATH
EGG_PATH=''
for EGG in $(ls ${SHELL_HOME}/ext-py/*.egg); do
EGG_PATH="${EGG}:${EGG_PATH}"
done
PYTHONPATH="${EGG_PATH}${SHELL_HOME}/gen-py:${SHELL_HOME}/lib:${PYTHONPATH}" \
exec python ${SHELL_HOME}/impala_shell.py "$@"
-
- 目录
mkdir -p /home/hdp/work/impala/logs
mkdir -p /home/hdp/work/impala/lock
mkdir -p /home/hdp/work/impala/pids
mkdir -p /home/hdp/work/impala/tmp
-
- 分发
拷贝到各主机。
-
- 链接
程序文件catalogd和statestored链接自impalad。
ln -s /home/hdp/soft/impala/sbin/impalad /home/hdp/soft/impala/sbin/catalogd
ln -s /home/hdp/soft/impala/sbin/impalad /home/hdp/soft/impala/sbin/statestored
ln -s /home/hdp/soft/impala/lib64/libkudu_client.so.0.1.0 /home/hdp/soft/impala/lib64/libkudu_client.so.0
-
- 启动
1、先启动hive metastore。
2、在namenode启动
impala-state-store.sh start
impala-catalog.sh start
3、在datanode启动
impala-server.sh start
-
- 验证
任意机器，启动impala-shell
#>show databases;
-
- 停止
1、各datanode
impala-server.sh stop
2、namenode
impala-catalog.sh stop
impala-state-store.sh stop