It's our wits that make us men.

搭建Hadoop生态环境

Posted on Aug 12, 2019 By huism

搭建hadoop平台
Hadoop大数据生态圈环境搭建


  1. Apache 大数据平台

Node1
Node2
Node3
Node4
Jdk
✔️
✔️
✔️
✔️
Zookeeper

✔️
✔️
✔️
Hadoop
✔️主
✔️主
✔️
✔️
Scala
✔️
✔️
✔️
✔️
Kafka
✔️

✔️
✔️
Mysql

✔️


Hbase

✔️主
✔️
✔️
Spark
✔️主

✔️
✔️






  1. 安装VirtualBox虚拟机软件
        1）下载VirtualBox软件https://www.virtualbox.org/wiki/Downloads，之后安装即可（傻瓜式安装）。
        2）配置网卡
    • 增加仅主机(Host-Only)网络，配置IP地址和IPv4网络掩码，并设置不启动DHCP服务器。
IPv4地址：192.168.56.1
IPv4网络掩码：255.255.255.0
    • 设置NAT网络（若无则创建），支持DHCP，一般有默认此项不必改变。
        3）新建虚拟机，系统选择CentOS 7，版本是CentOS-7-x86_64-Minimal-1511。
    • 第一步：创建虚拟机。 选择Linux、Linux版本，创建动态分配的VHD虚拟硬盘，创建好虚拟机之后进入下一步，
    • 第二步：设置创建的虚拟机。存储中光盘需要选择你IOS系统文件所在的目录文件。之后设置网络，网卡1设为NAT网络；网卡2启动，并设为仅主机(Host-Only)网络选择相应的网卡。
    • 第三步：安装系统。首先，启动系统，之后选择语言：English；选择日期时区Data&Time设置为Asia/Shanghai；选择安装硬盘位置INSTALLATION SOURCE为默认；设置INSTALLATION DESTINATION为默认（需要进入并选择Done）；设置NETWORK & HOST NAME，启动两个网卡，并设置Host Name为node1（数字1为虚拟机编号，之后通过node*来通信）；最后确认后开始安装；在安装时可以设置root用户密码。
        4）重复3）步骤创建5台同样的CentOS虚拟机，可以选择复制虚拟机快速创建多台虚拟机。
            注意：如果复制虚拟机，需要勾选重新分配MAC地址。复制虚拟机时，主机名也一同复制，需要修改/etc/hostname文件中的内容来修改主机名，否则会在之后（查看hdfs的datanode节点）产生影响
  1. CentOS虚拟机网络配置
  • 通过命令 ip addr 可以查看所有网卡信息（l0可以忽略）。
  • 通过命令 vi /etc/sysconfig/network-scripts/ifcfg-enp0s3 设置enp0s3网卡（主要是集群内访问）属性：
ONBOOT=“yes”       //设置网卡开机自启，默认为yes，本注释不用写入配置文件中
  • 通过命令 vi /etc/hosts 配置hosts文件，集群中集群需要通过此配置文件来连通。可以通过命令 ping node2 来测试是否配置连接成功。
10.0.2.7 node1        // 地址是通过命令 ip addr 查看的enp0s3的IP地址，node1是集群中虚拟机中名字用于记忆使用方便
10.0.2.8 node2
10.0.2.9 node3
10.0.2.10 node4
10.0.2.11 node5
  • 通过命令 vi /etc/sysconfig/network-scripts/ifcfg-enp0s8 设置enp0s8网卡（主要是外界访问）属性：
ONBOOT=“yes”
BOOTPROTO=none
IPADDR=192.168.56.101        //新增，IP地址
NETMASK=255.255.255.0        //新增，掩码
NETWORK=192.168.56.0         //新增，网关
        注意：其中BOOTPROTO是设置不启动DHCP服务器；IPADDR是设置网卡IPv4地址；NETMASK是网络掩码；NETWORK是网关地址。
  • 重启网络服务，命令：service network restart
  • 将集群所有虚拟机都重新配置以上两张网卡。
  1. 新建Hadoop用户，SSH免密登录连接
        新建hadoop用户，来管理所有的hadoop生态圈内的应用程序，并且在hadoop用户下使用此Hadoop生态圈应用程序，并且设置免密连接。如果不想添加用户，可以由root用户来管理所有程序，跳过新建用户，直接进行免密连接操作。
     （由此开始规定：#后面的命令是root用户执行的命令，$后面的命令是hadoop用户执行的命令）
  • 新建用户
# groupadd hadoop         //新建用户组，组名为hadoop
# useradd -s /bin/bash -g hadoop -d /home/hadoop -m hadoop        //新建用户，用户名为hadoop
# passwd hadoop         //设置用户hadoop的登录密码，需要输入相同的两次
  • 免密连接
# su hadoop
// 在node1上执行，可以使node1向获得其密钥的节点免密登录连接，如命令 $ ssh node2
$ ssh-keygen -t rsa         //生成密钥
$ ssh-copy-id node1         //分发密钥
$ ssh-copy-id node2         //分发密钥
  1. 集群时间同步
        同一集群内机器需要同步时间，避免不必要的麻烦。
  • 安装时间同步软件
# yum install -y ntpdate
# yum install -y ntp
  • 选择一台节点作为时间服务器（如node1），其他为客户端节点向服务器节点时间同步，配置时间服务器节点
# vi /etc/ntp.conf
// 注释掉文件中的以下四行，即在行首添加“#”
server 0.centos.pool.ntp.org iburst 
server 1.centos.pool.ntp.org iburst 
server 2.centos.pool.ntp.org iburst 
server 3.centos.pool.ntp.org iburst
// 文件最下面加入 
restrict default ignore 
restrict 10.0.2.0 mask 255.255.255.0 nomodify notrap 
server 127.127.1.0
  • 重启ntpd服务
# service ntpd restart
  • 设置ntpd服务开机自启
# chkconfig ntpd on
  • 余下的客户端节点，配置如下：
# crontab -e       // 设定每天 00:00 向服务器同步时间，并写入日志
// 输入以下内容，保存，退出。
0 0 * * * /usr/sbin/ntpdate cluster1>> /root/ntpd.log
  • 手动向时间服务器节点同步时间：
# ntpdate node1         //假设时间服务器节点为node1
  1. JDK环境安装配置
  • 将jdk安装包上传到虚拟机节点中，我下载的是jdk1.8.0_201版本的。jdk安装到/usr/local目录下。
  • 将安装包解压。
# cp ./jdk-8u201-linux-x64.tar.gz /usr/local/
# cd /usr/local 
# tar -zxvf ./jdk-8u201-linux-x64.tar.gz
  • 配置JDK环境变量
export JAVA_HOME=/usr/local/jdk1.8.0_201             // Java家目录
export JRE_HOME=/usr/local/jdk1.8.0_201/jre         // jre家目录
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH 
export PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin:$JAVA_HOME
  • 测试安装是否成功，使用如下命令，若不报错，出现版本信息，则安装成功。
# java -version
以上是集群所有节点的基础安装环境配置

  1. Hadoop集群部署（搭建高可用(HA)集群）


Namenode-1
Namenode-2
Datanode
Zookeeper
ZKFC
JournalNode
Node1
*



*
*
Node2

*
*
*
*
*
Node3


*
*

*
Node4


*
*


Node5






  1. Hadoop安装（HA of HDFS）
  • 版本：Hadoop 3.1.1
  • 上传hadoop-2.6.5 安装包到虚拟机节点node1中，解压到/opt目录中。
# cp ./hadoop-2.6.5.tar.gz  /opt      // 复制安装包到/opt目录下
# cd /opt
# tar -zxvf hadoop-2.6.5.tar.gz       // 解压
  • 修改配置文件
# cd /opt/hadoop-2.6.5/etc/hadoop        // 进入Hadoop配置文件所在目录，配置文件都在 etc/hadoop 目录下
    • 修改 hadoop-env.sh 配置文件，在文末尾添加如下配置：
export JAVA_HOME=/usr/local/jdk1.8.0_201            // 指定Java安装路径，自己机器上真实路径
export HDFS_NAMENODE_USER=hadoop
export HDFS_DATANODE_USER=hadoop
export HDFS_SECONDARYNAMENODE_USER=hadoop
    • 修改 core-site.xml 配置文件，添加如下：
 <!-- 在<configurations></configuration>内添加    —>
    <property>
        <name>fs.defaultFS</name>               <!-- 集群的逻辑名    —>
        <value>hdfs://mycluster</value>
    </property>
    <property>
    <!-- 集群数据存放本地路径，namenode,datanode数据都会存在这里，会自动生成./ha/dfs/name 目录和 ./ha/dfs/data —->
        <name>hadoop.tmp.dir</name> 
        <value>/home/hadoop/hadoop_files/ha</value>
    </property>
    <property>
        <name>fs.trash.interval</name>
        <value>1440</value>
    </property>
    <property>
        <name>ha.zookeeper.quorum</name>        <!-- zookeeper集群节点，ip:port，用“,”分割    —>
        <value>node2:2181,node3:2181,node4:2181</value>
    </property>
    • 修改 hdfs-site.xml 配置文件，添加如下：
    <!—- 添加到<configuration></configuration>中    —->
    <property>
        <!—- 备份个数  —->
        <name>dfs.replication</name>
        <value>2</value>
    </property>
    <property>
        <!—- 集群逻辑名，同core-site.xml文件中的fs.defaultFS逻辑名保持一致  —->
        <name>dfs.nameservices</name>
        <value>mycluster</value>
    </property>
    <property>
        <!—- NameNode节点逻辑名  —->
          <name>dfs.ha.namenodes.mycluster</name>
          <value>nn1,nn2</value>
    </property>
    <property>
        <!—- NameNode节点逻辑名对应的节点物理地址，ip:port，指向namenode1 —->
          <name>dfs.namenode.rpc-address.mycluster.nn1</name>
          <value>node1:8020</value>
    </property>
    <property>
        <!—- NameNode节点逻辑名对应的地址，ip:port，指向namenode2  —->
          <name>dfs.namenode.rpc-address.mycluster.nn2</name>
          <value>node2:8020</value>
    </property>    
    <property>
        <!—- NameNode节点的web ui访问地址和端口，ip:port，namenode1的web UI —->
          <name>dfs.namenode.http-address.mycluster.nn1</name>
        <!—- ip地址填真实的地址，若有两张网卡，注意区分  —->
          <value>192.168.56.101:50070</value>
    </property>
    <property>
          <name>dfs.namenode.http-address.mycluster.nn2</name>
          <value>192.168.56.102:50070</value>
    </property>
    <property>
        <!—- 指向journalnode节点，qjournal://ip:port,ip:port   —->
        <name>dfs.namenode.shared.edits.dir</name>
        <value>qjournal://node1:8485;node2:8485;node3:8485/mycluster</value>
    </property>
    <property>
        <!—- namenode向journalnode同步数据存储的本地路径，自己设置  —->
      <name>dfs.journalnode.edits.dir</name>
      <value>/home/hadoop/hadoop_files/ha/journal</value>
    </property>
    <property>
        <!—- 代理，只需照着设置即可  —->
      <name>dfs.client.failover.proxy.provider.mycluster</name>
      <value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
    </property>
    <property>
          <name>dfs.ha.fencing.methods</name>
          <value>shell(/bin/true)</value>
    </property>
    <property>
       <name>dfs.ha.automatic-failover.enabled</name>
       <value>true</value>    
    </property>
    • 修改 slaves 配置文件，添加如下：
 // 文件中删除其他内容，添加如下内容，注意，此注释勿写进文件，配置的是datanode节点的主机名，3.x版本中是worker文件
node2
node3
node4
  • 启动Hadoop集群
    • 启动 Zookeeper 集群
$ zkServer.sh start         //在每个zookeeper集群节点上运行一次
    • 启动 JouranlNode 进程（在node1,node2,node3上启动）
$ hadoop-daemon.sh start journalnode        //在需要的节点启动
    • 格式化 ZKFC 
$ hdfs zkfc -formatZK        // 在node1上运行
    • 格式化 NameNode 节点，并且启动NameNode
 // （只在node1节点上运行）
$ hdfs namenode –format
$ hadoop-daemon.sh start namenode
 // （只在node2节点上运行）
$ hdfs namenode –bootstrapStandby
$ hadoop-deamon.sh start namenode
 // （关闭所有nodenode进程，在node1和node2节点上分别运行如下命令）
$ hadoop-daemon.sh stop namenode    
    • 启动 Hadoop
$ start-dfs.sh    // 只在node1节点上运行，并是hadoop用户，journal进程已启动，会提示先关闭，可忽略。
    • 正常启动后，集群节点内有如下进程，可进行验证。


Namenode
Datanode
Zookeeper
DFSZKFailoverController(zkfc)
Journalnode
Node1
*


*
*
Node2
*
*
*
*
*
Node3

*
*

*
Node4

*
*


  1. 安装Scala
  • 将Scala安装到集群所有节点上，并分配给hadoop用户使用
  • 将安装包解压到 /opt/ 目录下（在node1上执行）
  • 将Scala分发到其他节点上（在node1上执行）
# scp -r /opt/scala-2.10.6 node2:/opt/            // 分发到所有节点，node2,node3,node4
  • 配置环境变量 命令：vi /etc/profile 在末尾追加如下内容（在所有节点上执行）
export SCALA_HOME=/opt/scala-2.10.6            # Scala的安装路径
export PATH=$PATH:$SCALA_HOME/bin
  • 刷新环境变量（在所有节点上执行）
# source /etc/profile
  • 修改用户所有者（在所有节点上执行）
# chown -R hadoop:hadoop /opt/scala-1.10.6        // 修改所有节点的Scala安装目录所拥有的用户

  1. 安装Kafka
  • 规划在node1,node3,node4上安装kafka。
  • 将kafka安装包拷贝到/opt/ 目录下，解压（以下在node1上执行）
# cp ./kafka_2.10-0.8.2.1.tgz /opt/
# tar -zxvf kafka_2.10-0.8.2.1.tgz
# cd /opt/
# mv kafka_2.10-0.8.2.1 kafka
  • 添加环境变量 
# vi /etc/profile
// 在文件末尾中添加如下内容
 export KAFKA_HOME=/opt/kafka
 export PATH=$PATH:$KAFKA_HOME/bin

// 保存退出后，更新环境变量
# source /etc/profile
  • 修改配置文件 /opt/kafka/config/server.properties 
// 修改内容如下
Broker.id=0        //指定broker的ID，从0开始，每个节点不同，node3是1，node4是2
log.dirs=/home/hadoop_files/kafka-logs        // 指定kafka存储日志数据的路径
zookeeper.connect=node2:2181,node3:2181,node4:2181     // 指定zookeeper集群节点
advertised.host.name=192.168.56.101        // 指定本节点(node1)的IP地址，其他kafka集群节点更改成自己的IP地址
  • 创建kafka数据存放路径（是log.dirs配置的值）
# mkdir -p /home/hadoop/hadoop_files/kafka-logs
  • 修改文件权限，更改为hadoop用户权限
# chown -R hadoop:hadoop /opt/kafka 
# chown -R hadoop:hadoop /home/hadoop_files/kafka-logs
  • 分发安装好的程序到kafka集群其他节点（node3,node4），在node1上执行
# cd /opt/
# scp -r ./kafka/  node3:`pwd`        // 分发到node3节点上
# scp -r ./kafka/  node4:`pwd`        // 分发到node4节点上
  • 在node3上修改 server.properties 中的broker.id （在node3上执行）
broker.id=1
  • 在node4上修改 server.properties 中的broker.id（在node4上执行）
broker.id=2
  • 新建存储日志数据的路径目录，并其修改权限和 /opt/kafka的权限为hadoop用户。（在node3和node4上分别执行）
  • 新建启动脚本和关闭脚本，
# cd /opt/kafka/bin
# vi start-kafka.sh
// 在文件中添加如下内容（一行内容，无换号），保存
 nohup kafka-server-start.sh /opt/kafka/config/server.properties > /home/hadoop/hadoop_files/kafka-logs/kafka-start.log 2>&1 &

# vi stop-kafka.sh
// 在文件中添加如下内容,一行内容，无换号，保存
 kafka-server-stop.sh

# chmod u+x start-kafka.sh                // 添加可执行权限
# chmod u+x start-kafka.sh                // 添加可执行权限
# chown -R hadoop:hadoop /opt/kafka       // 修改所属用户
  • 完成安装，通过如下测试
# su hadoop
// 保证zookeeper集群已经启动
$ start-kafka.sh        // 启动kafka
$ kafka-topics.sh --create --zookeeper cluster1:2181,cluster2:2181,cluster3:2181 --replication-factor 3 --partitions 1 --topic mykafka            // 创建topic
$ stop-kafka.sh         // 关闭kafka

  1. 安装MySQL
  • 在集群节点node2上安装MySQL，其他节点不需要安装。（以下只在node2中执行）
  • 预先安装 screen ，perl， perl-devel， autoconf 四个软件
  • 将安装包上传到节点上，解压到/usr/local/ 目录下，并重命名为mysql
# cd /usr/local/
# tar -zxvf /usr/local/mysql-5.6.37-linux-glibc2.12-x86_64.tar.gz
# mv mysql-5.6.37-linux-glibc2.12-x86_64 mysql
  • 修改环境变量
# vi /etc/profile 
// 在最下面添加 
 export MYSQL_HOME=/usr/local/mysql 
 export PATH=$PATH:$MYSQL_HOME/bin
// 刷新环境变量
# source /etc/profile
  • 新建 mysql 用户
# groupadd mysql 在/etc/group 中可以看到 
# useradd -r -g mysql -s /bin/false mysql 在/etc/passwd 中可以看到 
# cd /usr/local/mysql 
# chown -R mysql:mysql .
# scripts/mysql_install_db --user=mysql
注意：若运行 scripts/mysql_install_db --user=mysql 报错，需要安装 perl , perl-devel , autoconf，再次运行，即可解决。
  • 修改当前目录拥有者为 root 用户
# chown -R root .
# chown -R mysql data        // 修改当前 data 目录拥有者为 mysql 用户
  • 新建一个虚拟窗口，叫 mysql，运行命令
# screen -S mysql
# bin/mysqld_safe --user=mysql &
// 退出虚拟窗口 
# Ctrl+A+D 
# cd /usr/local/mysql
// 登陆 mysql 
# bin/mysql
// 登陆成功后退出即可 
# exit;
  • 进行 root 账户密码的修改等操作
# bin/mysql_secure_installation

首先要求输入 root 密码，由于我们没有设置过 root 密码，括号里面说了，如果没有 root 密码就直接按回车。 是否设定 root 密码，选 y，设定密码为 cluster，是否移除匿名用户：y。然后有个是否关闭 root 账户的远程 登录，选 n，删除 test 这个数据库？y，更新权限？y，然后 ok。

# cp support-files/mysql.server /etc/init.d/mysql.server


// 进入 mysql 虚拟窗口 
# screen -r mysql 
// 查看 mysql 的进程号 
# ps -ef | grep mysql 
// 如果有的话就 kill 掉，保证 mysql 已经中断运行了，一般 kill 掉/usr/local/mysql/bin/mysqld 开头的即可 
# kill 进程号
// 退出虚拟窗口
# Ctrl+A+D
  • 启动MySQL服务
# /etc/init.d/mysql.server start -user=mysql           //（-user参数可省略）
  • 配置一下访问权限
$ mysql -u root -p 
mysql> GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'cluster' WITH GRANT OPTION;
mysql> FLUSH PRIVILEGES;
  • 关闭MySQL
// 关闭 mysql 的指令（不需要执行） 
# mysqladmin -u root -p shutdown
  • 注意：每次启动节点，若执行 mysql -u root -p 报错
                ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/tmp/mysql.sock' (2)
        解决：需要启动MySQL服务，执行启动MySQL命令：
# /etc/init.d/mysql.server start -user=mysql

  1. 安装Hbase
  • 规划在node2, node3, node4 节点中安装Hbase，其中node2作为主节点，node2, node3, node4作为从节点
  • 在 node2 节点 /opt/ 解压 hbase 安装包，（在node2上执行）
# cd /opt/
# tar -zxvf hbase-1.2.6-bin.tar.gz
  • 修改配置环境，（在node2上执行）
修改 hbase-env.sh 
# vi hbase-env.sh 

将 JAVA_HOME, HADOOP_HOME, HBASE_LOG_DIR, HBASE_MANAGES_ZK 修改为以下内容： 记得去掉前面的#
 export JAVA_HOME=/usr/local/jdk1.8.0_201         # 配置 JDK 安装路径
 export HADOOP_HOME=/opt/hadoop-2.6.5      # 配置 Hadoop 安装路径  
 export HBASE_LOG_DIR=/home/hadoop_files/hbase/logs      # 设置 HBase 的日志目录
 export HBASE_MANAGES_ZK=false        # 使用独立的 ZooKeeper 集群
 export HBASE_PID_DIR=/home/hadoop_files/hbase        # 设置 pid 的路径

配置 hbase-site.xml
# vi hbase-site.xml
添加如下配置
<property>
    <name>hbase.zookeeper.quorum</name>
    <value>node2,node3,node4</value>
    <description>zookeeper集群节点</description>
</property>
<property>
    <name>hbase.rootdir</name>
    <value>hdfs://node1:8020/hbase</value>    <value>hdfs://mycluster/hbase</value>若是HA的hadoop则需要修改为集群名称
    <description>hbase数据存放到HDFS中的路径</description>
</property>
<property>
    <name>hbase.cluster.distributed</name>
    <value>true</value>
    <description>是否启动分布式
      false: standalone and pseudo-distributed setups with managed ZooKeeper
      true: fully-distributed with unmanaged ZooKeeper Quorum (see hbase-env.sh)
    </description>
</property>
<property>
    <name>hbase.zookeeper.property.dataDir</name>
    <value>/home/hadoop/hadoop_files/zk</value>
    <description>Property from ZooKeeper config zoo.cfg.指向zookeeper的存放数据路径</description>
</property>
<property>
    <name>hbase.tmp.dir</name>
    <value>/home/hadoop/hadoop_files/hbase/tmp</value>
    <description>存储临时数据路径</description>
</property>
<property>
     <name>zookeeper.session.timeout</name>
     <value>120000</value>
</property>
<property>
    <name>hbase.master.info.port</name>
    <value>16010</value>
    <description>Hbase Master的web UI访问端口</description>
</property>
<property>
    <name>hbase.regionserver.info.port</name>    
    <value>16030</value>
    <description>Hbase regionServer的web UI访问端口</description>
</property>
<property>
    <name>hbase.zookeeper.property.clientPort</name>
    <value>2181</value>
</property>

// 配置 regionservers节点
# vi regionservers 
删除 localhost 添加如下内容： 
node2
node3
node4

// 删除 hbase 的 slf4j-log4j12-1.7.5.jar，解决 hbase 和 hadoop 的 LSF4J 包冲突 
# cd /opt/hbase-1.2.6/lib 
# mv slf4j-log4j12-1.7.5.jar slf4j-log4j12-1.7.5.jar.bk
  • 将 hbase 工作目录同步到集群其它节点，（在node2上执行）
# scp -r /opt/hbase-1.2.6/ cluster3:/opt/ 
# scp -r /opt/hbase-1.2.6/ cluster4:/opt/
  • 创建hbase缓存、日志路径（所有节点）
# mkdir -p /home/hadoop_files/hbase/tmp
# mkdir -p /home/hadoop_files/hbase/logs
  • 改权限（所有节点）
# chown -R hadoop:hadoop /opt/hbase-1.2.6
# chown -R hadoop:hadoop /home/hadoop_files/hbase
  • 修改环境变量
# vi /etc/profile 
添加如下内容
export HBASE_HOME=/usr/local/hbase-1.2.6 
export PATH=$HBASE_HOME/bin:$PATH 

# source /etc/profile
  • 启动 HBase（主节点node2 上），需要切换到hadoop用户下
注意：先启动 zookeeper，Hadoop 的 HDFS 和 YARN，然后才能启动 HBase
$ start-dfs.sh
$ start-yarn.sh
$ start-hbase.sh
$ stop-hbase.sh
  • 测试，可以访问web UI ，node2:16010

  1. 安装Spark
  • 规划在node1, node3, node4节点上安装spark。
  • 上传spark安装包到node1节点上，解压到 /opt/ 目录下，（在node1节点上执行）
# cd /opt
# tar -zxvf spark-1.6.3-bin-hadoop2.6.tgz
# mv spark-1.6.3-bin-hadoop2.6.tgz spark-1.6.3        // 重命名为spark-1.6.3
  • 配置环境变量
# vi /etc/profile 
添加以下内容： 
 export SPARK_HOME=/usr/local/spark-1.6.3
 export PATH=$SPARK_HOME/bin:$PATH
主节点要再加一行（node1）： 
 export PATH=$SPARK_HOME/sbin:$PATH
  • 修改配置文件，（在node1上执行）
# cd /opt/spark-1.6.3

复制 conf 文件夹里面 template 一份，改名为 spark-env.sh 
# cp conf/spark-env.sh.template conf/spark-env.sh

在spark-env.sh文件中添加如下内容
 export SPARK_MASTER_IP=node1            // 主节点的主机名
 export SPARK_MASTER_PORT=7077           // 主节点的端口
 export SPARK_WORKER_CORES=2
 export SPARK_MASTER_WEBUI_PORT=8888        // 主节点web ui的端口,默认是8080
 export SPARK_WORKER_MEMORY=1g           // 运行内存
 export HADOOP_CONF_DIR=/opt/hadoop-2.6.5/etc/hadoop        // hadoop的配置文件所在目录的路径
 export SPARK_PID_DIR=/home/hadoop/hadoop_files/spark        // spark存储数据的目录路径，可以填自己的
 export JAVA_HOME=/usr/local/jdk1.8.0_201                // jdk安装路径，根据自己实际的填写

# vi conf/slaves         // 从节点的主机名
添加以下几行 
 node3
 node4
  • 分发到从节点上（这里是node3, node4），在node1上执行
// 复制到所有的服务器上 
# scp -r /opt/spark-1.6.3 node3:/opt/
# scp -r /opt/spark-1.6.3 node4:/opt/
  • 修改 spark 文件夹的权限（每个 spark 结点）
# chown -R hadoop:hadoop /opt/spark-1.6.3
  • 运行spark集群，（在主节点node1上执行）
        注意：
    • spark应用中 sbin/start-all.sh 命令是和Hadoop中start-all.sh 命令重名，并且路径都在PATH中，谁在前，启动谁。所以，需要修改spark的运行命令名为start-spark.sh。同样stop-all.sh也需如此。
    • 若不将 spark的 sbin/ 路径加入到PATH中，则不需要上一步，但是每次启动需要进入 /opt/spark-1.6.3/sbin 目录下启动命令 start-all.sh 。
运行 spark 前需启动 hadoop 的 HDFS 和 YARN
在主节点中，启动全部spark集群。
$ start-spark.sh
关闭
$ stop-spark.sh

分别启动spark集群中主，从节点
$ start-master.sh
$ start-slaves.sh
  • 测试可以查看进程，访问web界面更 node1:8888