大数目学习系列之四 —– Hadoop+Hive环境搭建图文详解(单机)

五、Hive环境设置和配置

4.修改hosts文件(可选)

修改Windows C:\Windows\System32\drivers\etc
目录下的hosts文件,添加hbase的主机ip和主机名做涉嫌映射。

192.168.238.128 master

注:若是不利用映射,那么将代码中的主机名改成IP即可。

3.2.3修改 hdfs-site.xml

输入:

vim hdfs-site.xml

在添加:

<property>
   <name>dfs.name.dir</name>
   <value>/root/hadoop/dfs/name</value>
   <description>Path on the local filesystem where theNameNode stores the namespace and transactions logs persistently.</description>
</property>
<property>
   <name>dfs.data.dir</name>
   <value>/root/hadoop/dfs/data</value>
   <description>Comma separated list of paths on the localfilesystem of a DataNode where it should store its blocks.</description>
</property>
<property>
   <name>dfs.replication</name>
   <value>2</value>
</property>
<property>
      <name>dfs.permissions</name>
      <value>false</value>
      <description>need not permissions</description>
</property>

工具类

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

import com.alibaba.fastjson.JSONObject;

/**
 * 
 * Title: HBaseUtil
 * Description: HBase工具类 
 * Version:1.0.0
 * @author pancm
 * @date 2017年12月6日
 */
public class HBaseUtil {
    /** hadoop 连接 */
    private static Configuration conf = null;
    /** hbase 连接 */
    private static Connection con = null;
    /** 会话 */
    private static Admin admin = null;

    private static String ip ="master";
    private static String port ="2181";
    private static String port1 ="9001";

   // 初始化连接
   static {
       // 获得配制文件对象
       conf = HBaseConfiguration.create(); 
       // 设置配置参数
        conf.set("hbase.zookeeper.quorum", ip);
        conf.set("hbase.zookeeper.property.clientPort", port);  
        //如果hbase是集群,这个必须加上 
        //这个ip和端口是在hadoop/mapred-site.xml配置文件配置的
        conf.set("hbase.master", ip+":"+port1); 
   }


    /**
     * 获取连接
     * 
     * @return
     */
    public synchronized static Connection getConnection() {
        try {
            if (null == con || con.isClosed()) {
                // 获得连接对象
                con = ConnectionFactory.createConnection(conf);
            }
        } catch (IOException e) {
            System.out.println("获取连接失败!");
            e.printStackTrace();
        }

        return con;
    }

    /**
     * 连接关闭
     */
    public static void close() {
        try {
            if (admin != null) {
                admin.close();
            }
            if (con != null) {
                con.close();
            }
        } catch (IOException e) {
            System.out.println("连接关闭失败!");
            e.printStackTrace();
        }
    }

    /**
     * 创建表
     * 
     * @param tableName
     *            表名
     * @param columnFamily
     *            列族
     */
    public static void creatTable(String tableName, String[] columnFamily) {
        if(null==tableName||tableName.length()==0){
            return;
        }
        if(null==columnFamily||columnFamily.length==0){
            return;
        }
        // 创建表名对象
        TableName tn = TableName.valueOf(tableName);
        // a.判断数据库是否存在
        try {
            // 获取会话
            admin = getConnection().getAdmin();
            if (admin.tableExists(tn)) {
                System.out.println(tableName + " 表存在,删除表....");
                // 先使表设置为不可编辑
                admin.disableTable(tn);
                // 删除表
                admin.deleteTable(tn);
                System.out.println("表删除成功.....");
            }
            // 创建表结构对象
            HTableDescriptor htd = new HTableDescriptor(tn);
            for (String str : columnFamily) {
                // 创建列族结构对象
                HColumnDescriptor hcd = new HColumnDescriptor(str);
                htd.addFamily(hcd);
            }
            // 创建表
            admin.createTable(htd);
            System.out.println(tableName + " 表创建成功!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            close();
        }
    }

    /**
     * 数据单条插入或更新
     * 
     * @param tableName
     *            表名
     * @param rowKey
     *            行健 (主键)
     * @param family
     *            列族
     * @param qualifier
     *            列
     * @param value
     *            存入的值
     * @return
     */
    public static void insert(String tableName, String rowKey, String family,
            String qualifier, String value) {
        Table t = null;
        try {
            t = getConnection().getTable(TableName.valueOf(tableName));
            Put put = new Put(Bytes.toBytes(rowKey));
            put.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier),
                    Bytes.toBytes(value));
            t.put(put);
            System.out.println(tableName + " 更新成功!");
        } catch (IOException e) {
            System.out.println(tableName + " 更新失败!");
            e.printStackTrace();
        } finally {
            close();
        }
    }

    /**
     * 数据批量插入或更新
     * 
     * @param tableName
     *            表名
     * @param list
     *            hbase的数据 
     * @return
     */
    public static void insertBatch(String tableName, List<?> list) {
        if (null == tableName ||tableName.length()==0) {
            return;
        }
        if( null == list || list.size() == 0){
            return;
        }
        Table t = null;
        Put put = null;
        JSONObject json = null;
        List<Put> puts = new ArrayList<Put>();
        try {
            t = getConnection().getTable(TableName.valueOf(tableName));
            for (int i = 0, j = list.size(); i < j; i++) {
                json = (JSONObject) list.get(i);
                put = new Put(Bytes.toBytes(json.getString("rowKey")));
                put.addColumn(Bytes.toBytes(json.getString("family")),
                        Bytes.toBytes(json.getString("qualifier")),
                        Bytes.toBytes(json.getString("value")));
                puts.add(put);
            }
            t.put(puts);
            System.out.println(tableName + " 更新成功!");
        } catch (IOException e) {
            System.out.println(tableName + " 更新失败!");
            e.printStackTrace();
        } finally {
            close();
        }
    }

    /**
     * 数据删除 
     * @param tableName 表名
     * @param rowKey    行健
     * @return
     */
    public static void delete(String tableName, String rowKey) {
        delete(tableName,rowKey,"","");
    }

    /**
     * 数据删除 
     * @param tableName 表名
     * @param rowKey    行健
     * @param family    列族
     * @return
     */
    public static void delete(String tableName, String rowKey, String family) {
        delete(tableName,rowKey,family,"");
    }

    /**
     * 数据删除 
     * @param tableName 表名
     * @param rowKey    行健
     * @param family    列族
     * @param qualifier 列
     * @return
     */
    public static void delete(String tableName, String rowKey, String family,
            String qualifier) {
        if (null == tableName ||tableName.length()==0) {
            return;
        }
        if( null == rowKey || rowKey.length() == 0){
            return;
        }
        Table t = null;
        try {
            t = getConnection().getTable(TableName.valueOf(tableName));
            Delete del = new Delete(Bytes.toBytes(rowKey));
            // 如果列族不为空
            if (null != family && family.length() > 0) {
                // 如果列不为空
                if (null != qualifier && qualifier.length() > 0) {
                    del.addColumn(Bytes.toBytes(family),
                            Bytes.toBytes(qualifier));
                } else {
                    del.addFamily(Bytes.toBytes(family));
                }
            }      
            t.delete(del);    
        } catch (IOException e) {
            System.out.println("删除失败!");
            e.printStackTrace();
        } finally {
          close();
        }
    }

    /**
     * 查询该表中的所有数据
     * 
     * @param tableName
     *            表名
     */
    public static void select(String tableName) {
        if(null==tableName||tableName.length()==0){
            return;
        }
        Table t = null;
        List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
        try {
            t = getConnection().getTable(TableName.valueOf(tableName));
            // 读取操作
            Scan scan = new Scan();
            // 得到扫描的结果集
            ResultScanner rs = t.getScanner(scan);
            if (null == rs ) {
                return;
            }
            for (Result result : rs) {
                // 得到单元格集合
                List<Cell> cs = result.listCells();
                if (null == cs || cs.size() == 0) {
                    continue;
                }
                for (Cell cell : cs) {
                    Map<String,Object> map=new HashMap<String, Object>();
                    map.put("rowKey", Bytes.toString(CellUtil.cloneRow(cell)));// 取行健
                    map.put("timestamp", cell.getTimestamp());// 取到时间戳
                    map.put("family", Bytes.toString(CellUtil.cloneFamily(cell)));// 取到列族
                    map.put("qualifier", Bytes.toString(CellUtil.cloneQualifier(cell)));// 取到列
                    map.put("value", Bytes.toString(CellUtil.cloneValue(cell)));// 取到值
                    list.add(map);
                }
            }
            System.out.println("查询的数据:"+list);
        } catch (IOException e) {
            System.out.println("查询失败!");
            e.printStackTrace();
        } finally {
            close();
        }
    }

    /**
     * 根据表名和行健查询
     * @param tableName
     * @param rowKey
     */
    public static void select(String tableName, String rowKey) {
        select(tableName,rowKey,"","");
    }

    /**
     * 根据表名、行健和列族查询
     * @param tableName
     * @param rowKey
     * @param family
     */
    public static void select(String tableName, String rowKey, String family) {
        select(tableName,rowKey,family,"");
    }

    /**
     * 根据条件明细查询
     * 
     * @param tableName
     *            表名
     * @param rowKey
     *            行健 (主键)
     * @param family
     *            列族
     * @param qualifier
     *            列
     */
    public static void select(String tableName, String rowKey, String family,
            String qualifier) {
        Table t = null;
        List<Map<String,Object>> list=new ArrayList<Map<String,Object>>();
        try {
            t = getConnection().getTable(TableName.valueOf(tableName));
            // 通过HBase中的 get来进行查询
            Get get = new Get(Bytes.toBytes(rowKey));
            // 如果列族不为空
            if (null != family && family.length() > 0) {
                // 如果列不为空
                if (null != qualifier && qualifier.length() > 0) {
                    get.addColumn(Bytes.toBytes(family),
                            Bytes.toBytes(qualifier));
                } else {
                    get.addFamily(Bytes.toBytes(family));
                }
            }
            Result r = t.get(get);
            List<Cell> cs = r.listCells();
            if (null == cs || cs.size() == 0) {
                return;
            }
            for (Cell cell : cs) {
                Map<String,Object> map=new HashMap<String, Object>();
                map.put("rowKey", Bytes.toString(CellUtil.cloneRow(cell)));// 取行健
                map.put("timestamp", cell.getTimestamp());// 取到时间戳
                map.put("family", Bytes.toString(CellUtil.cloneFamily(cell)));// 取到列族
                map.put("qualifier", Bytes.toString(CellUtil.cloneQualifier(cell)));// 取到列
                map.put("value", Bytes.toString(CellUtil.cloneValue(cell)));// 取到值
                list.add(map);
            }
            System.out.println("查询的数据:"+list);
        } catch (IOException e) {
            System.out.println("查询失败!");
            e.printStackTrace();
        } finally {
            close();
        }
    }
}

5.3.4 添加 数据驱动包

是因为Hive 默许自带的数据库是运用mysql,所以那块就是用mysql
将mysql 的驱动包 上盛传 /opt/hive/hive2.1/lib

图片 1

2.肯定防火墙是还是不是关闭

2,配置文件更改

先切换来 /home/hadoop/hadoop2.8/etc/hadoop/ 目录下

1.肯定hadoop和hbase成功启动

图片 2

3,配置更改

引言

在上一篇中大数据学习种类之二 —–
HBase环境搭建(单机)

中,成功搭建了Hadoop+HBase的环境,本文则第一描述使用Java
对HBase的局地操作。

一、环境准备

三、代码示例

3.2.2修改 hadoop-env.sh

输入:

vim hadoop-env.sh

将${JAVA_HOME} 修改为和谐的JDK路径

export   JAVA_HOME=${JAVA_HOME}

修改为:

export   JAVA_HOME=/home/java/jdk1.8

3.查询数据

各自按照表名、行健、列族、列来询问
图片 3

2,环境布署

编辑 /etc/profile 文件
输入:

vim /etc/profile

添加:

export HIVE_HOME=/opt/hive/hive2.1
export HIVE_CONF_DIR=${HIVE_HOME}/conf
export PATH=.:${JAVA_HOME}/bin:${SCALA_HOME}/bin:${SPARK_HOME}/bin:${HADOOP_HOME}/bin:${ZK_HOME}/bin:${HBASE_HOME}/bin:${HIVE_HOME}/bin:$PATH

图片 4
注:实际安插以友好的为准!
输入:

source  /etc/profile

使配置生效

3.maven所要求的依靠架包

<!--hadoop 相关架包 -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-mapreduce-client-core</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-yarn-common</artifactId>
            <version>2.8.2</version>
        </dependency>

<!--HBase相关jar -->
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-hadoop-compat</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>1.1.2</version>
        </dependency>
<dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.1.2</version>
        </dependency>
<dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-common</artifactId>
            <version>1.1.2</version>
        </dependency>

2,做IP和主机名的照耀

修改hosts文件,做涉嫌映射
输入

vim /etc/hosts

添加
主机的ip 和 主机名称

192.168.238.128 master

4.删减数据

除去其中的一条数据
图片 5

3,时间设置

翻看当明天子
输入:

date

查看服务器时间是否一律,若分歧则转移
变更时间命令

date -s ‘MMDDhhmmYYYY.ss’

1.创建表

开创两张表 t_student、t_student_info 那两张表,并添加四个列族
创造成功之后可以在 hbase
shell和16010界面中看到。图片 6

图片 7

图片 8

二、服务器的连锁安顿

在配备Hadoop+Hive从前,应该先做一下安顿。
做那个配置为了方便,使用root权限。

5.HBase的原理

那篇小说介绍得很详细:
http://blog.csdn.net/woshiwanxin102213/article/details/17584043

2,配置选用

JDK:1.8 (jdk-8u144-linux-x64.tar.gz)
Hadoop:2.8.2 (hadoop-2.8.2.tar.gz)
Hive: 2.1 (apache-hive-2.1.1-bin.tar.gz)

2.添加数量

打响创立表之后,在那两张表中插入数据。
因为HBase是动态数据库,所以列是足以激增的。
HBase的新增和改动是一个措施,数据一致的,后来的数据会将前方的掩盖掉!
图片 9

图片 10

其它

更加多的hive使用请参考官方文档
https://cwiki.apache.org/confluence/display/Hive/LanguageManual
环境搭建参考:
http://blog.csdn.net/pucao_cug/article/details/71773665

版权表明:
作者:虚无境
腾讯网出处:http://www.cnblogs.com/xuwujing
CSDN出处:http://blog.csdn.net/qazwsxpcm    
民用博客出处:http://www.panchengming.com
原创不易,转发请标明出处,谢谢!

测试代码

import java.util.ArrayList;
import java.util.List;

import com.alibaba.fastjson.JSONObject;
/**
 * 
* Title: hbaseTest
* Description: HBase 相关测试
* Version:1.0.0  
* @author pancm
* @date 2017年11月23日
 */
public class hbaseTest {

    public static void main(String[] args) {
        test();
    }

    /**
     * 一些测试
     */
    private static void test() {
        String tableName1="t_student",tableName2="t_student_info";
        String []columnFamily1={"st1","st2"};
        String []columnFamily2={"stf1","stf2"};
        HBaseUtil.creatTable(tableName1, columnFamily1);
        HBaseUtil.creatTable(tableName2, columnFamily2);

        HBaseUtil.insert(tableName1, "1001", columnFamily1[0], "name", "zhangsan");
        HBaseUtil.insert(tableName1, "1002", columnFamily1[0], "name", "lisi");
        HBaseUtil.insert(tableName1, "1001", columnFamily1[1], "age", "18");
        HBaseUtil.insert(tableName1, "1002", columnFamily1[1], "age", "20");

        HBaseUtil.insert(tableName2, "1001", columnFamily2[0], "phone", "123456");
        HBaseUtil.insert(tableName2, "1002", columnFamily2[0], "phone", "234567");
        HBaseUtil.insert(tableName2, "1001", columnFamily2[1], "mail", "123@163.com");
        HBaseUtil.insert(tableName2, "1002", columnFamily2[1], "mail", "234@163.com");

        HBaseUtil.select(tableName1); //查询该表所有数据
        HBaseUtil.select(tableName1, "1001"); //根据表名和行健查询
        HBaseUtil.select(tableName2, "1002",columnFamily2[0]); //根据表名、行健和列族查询
        HBaseUtil.select(tableName2, "1002",columnFamily2[1],"mail"); //根据表名、行健、列族、和列查询

        HBaseUtil.select(tableName1, "1002"); //根据表名和行健查询
        HBaseUtil.delete(tableName1, "1002", columnFamily1[0]);//删除数据
        HBaseUtil.select(tableName1, "1002"); //根据表名和行健查询

    }
}

六、Hive Shell 测试

在中标启动Hadoop之后
切换到Hive目录下
输入:

cd /opt/hive/hive2.1/bin

先是初步化数据库
开头化的时候注意要将mysql启动
输入:

schematool  -initSchema -dbType mysql 

图片 11

实施成功之后,可以见见hive数据库和一堆表已经创办成功了

图片 12

切换到 cd /opt/hive/hive2.1/bin
跻身hive (确保hadoop以及成功启动)
输入:

hive

图片 13

进入hive 之后
做一些简练的操作
新建一个库,然后在建一张表
基本操作和平时的关系型数据库大约
创建库:

create database db_hiveTest;

创建表:

create  table  db_hiveTest.student(id int,name string)  row  format  delimited  fields   terminated  by  '\t';

图片 14

说明: terminated by ‘\t’
代表文本分隔符要使用Tab,行与行直接不能有空格。

加载数据
新开拓一个窗口
因为hive 不扶助写,所以添加数据运用load加载文本获取。
新建一个文本

touch  /opt/hive/student.txt

编辑该文本添加数据
输入:

vim /opt/hive/student.txt

加上数据:
中级的空格符使用Tab建

1001    zhangsan
1002    lisi
1003    wangwu

图片 15
注解:
文本可以在Windows上边新建,然后通过ftp上传到linux中,须求留意文本的格式为unix
格式。

切换到hive shell
加载数据
输入:

load data local inpath '/opt/hive/student.txt'  into table db_hivetest.student;

然后查询该数量
输入:

select * from db_hiveTest.student;

图片 16

本文的Hadoop+Hive的布署就到此截至了,谢谢阅读!

一、事前备选

1,服务器选取

地点虚拟机
操作系统:linux CentOS 7
Cpu:2核
内存:2G
硬盘:40G

说明:因为使用阿里云服务器每一回都要重新配置,而且还要考虑互连网传输问题,于是协调在该地便搭建了一个虚拟机,方便文件的传输以及有关配置,缺点是本来卡的处理器就变得更卡了。具体科目和选拔在上三次博文中。
地址: http://blog.csdn.net/qazwsxpcm/article/details/78816230

二、测试示例

引言

大数据学习连串之一 —–
Hadoop环境搭建(单机)

成功的搭建了Hadoop的环境,在大数据学习体系之二 —–
HBase环境搭建(单机)
得逞搭建了HBase的条件以及有关应用介绍。本文紧要教授如何搭建Hadoop+Hive的环境。

5.3.2 修改hive-site.xml

切换到 /opt/hive/hive2.1/conf 目录下
将hive-default.xml.template 拷贝一份,不偏不倚命名为hive-site.xml
然后编辑hive-site.xml文件

cp hive-default.xml.template hive-site.xml
vim hive-site.xml

编辑hive-site.xml文件,在 中添加:

<!-- 指定HDFS中的hive仓库地址 -->  
  <property>  
    <name>hive.metastore.warehouse.dir</name>  
    <value>/root/hive/warehouse</value>  
  </property>  

<property>
    <name>hive.exec.scratchdir</name>
    <value>/root/hive</value>
  </property>

  <!-- 该属性为空表示嵌入模式或本地模式,否则为远程模式 -->  
  <property>  
    <name>hive.metastore.uris</name>  
    <value></value>  
  </property>  

<!-- 指定mysql的连接 -->
 <property>
        <name>javax.jdo.option.ConnectionURL</name>
        <value>jdbc:mysql://master:3306/hive?createDatabaseIfNotExist=true</value>
    </property>
<!-- 指定驱动类 -->
    <property>
        <name>javax.jdo.option.ConnectionDriverName</name>
        <value>com.mysql.jdbc.Driver</value>
    </property>
   <!-- 指定用户名 -->
    <property>
        <name>javax.jdo.option.ConnectionUserName</name>
        <value>root</value>
    </property>
    <!-- 指定密码 -->
    <property>
        <name>javax.jdo.option.ConnectionPassword</name>
        <value>123456</value>
    </property>
    <property>
   <name>hive.metastore.schema.verification</name>
   <value>false</value>
    <description>
    </description>
 </property>

接下来将配备文件中具备的

${system:java.io.tmpdir}

变更为 /opt/hive/tmp (假使没有该文件则创建),
并将此文件夹赋予读写权限,将
${system:user.name}
更改为 root

例如:
改变此前的:
图片 17
变动之后:
图片 18

配置图:
图片 19

注: 由于hive-site.xml
文件中的配置过多,可以因此FTP将它下载下来实行编辑。也可以直接配置自己所需的,其余的可以去除。
MySQL的连接地址中的master是主机的别名,可以换成ip。

1,环境变量设置

编辑 /etc/profile 文件 :

vim /etc/profile

安顿文件:

export HADOOP_HOME=/opt/hadoop/hadoop2.8
export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native
export HADOOP_OPTS="-Djava.library.path=$HADOOP_HOME/lib"
export PATH=.:${JAVA_HOME}/bin:${HADOOP_HOME}/bin:$PATH

三、Hadoop安装和布置

Hadoop的具体配置在大数量学习系列之一 —–
Hadoop环境搭建(单机)

中介绍得很详细了。所以本文就几乎介绍一下。
注:具体安顿以投机的为准。

5.3.1新建文件夹

在修改配置文件之前,必要先在root目录下树立部分文本夹。

mkdir /root/hive
mkdir /root/hive/warehouse

新建完该公文之后,必要让hadoop新建/root/hive/warehouse 和 /root/hive/
目录。
执行命令:

$HADOOP_HOME/bin/hadoop fs -mkdir -p /root/hive/
$HADOOP_HOME/bin/hadoop fs -mkdir -p /root/hive/warehouse

给刚刚新建的目录赋予读写权限,执行命令:

$HADOOP_HOME/bin/hadoop fs -chmod 777 /root/hive/
$HADOOP_HOME/bin/hadoop fs -chmod 777 /root/hive/warehouse 

自我批评那三个目录是或不是中标成立
输入:

$HADOOP_HOME/bin/hadoop fs -ls /root/
$HADOOP_HOME/bin/hadoop fs -ls /root/hive/

图片 20

可以看看已经打响制造

1,文件准备

将下载下来的Hive 的陈设文件举行解压
在linux上输入:

 tar -xvf  apache-hive-2.1.1-bin.tar.gz

接下来移动到/opt/hive 里面,将文件夹重命名为 hive2.1
输入

mv  apache-hive-2.1.1-bin  /opt/hive
mv apache-hive-2.1.1-bin hive2.1

3,Hadoop启动

开行从前需求先格式化
切换到/home/hadoop/hadoop2.8/bin目录下
输入:

./hadoop  namenode  -format

格式化成功后,再切换来/home/hadoop/hadoop2.8/sbin目录下
启动hdfs和yarn
输入:

start-dfs.sh
start-yarn.sh

开行成功后,输入jsp查看是或不是启动成功
在浏览器输入 ip+8088 和ip +50070 界面查看是不是能访问
能正确访问则启动成功

1,yum安装

第一查看mysql 是不是早已设置
输入:

rpm -qa | grep mysql   

设若已经设置,想删除的话
输入:
一般删除命令:

rpm -e mysql

武力删除命令:

rpm -e --nodeps mysql    

依傍文件也会删除

安装mysql
输入:

yum list mysql-server  

要是没有,则经过wget命令下载该包
输入:

wget http://repo.mysql.com/mysql-community-release-el7-5.noarch.rpm   

下载成功未来,再输入指令安装

yum install mysql-server

在设置过程中境遇选拔输入y就行了
图片 21
图片 22

安装成功后,输入 service mysqld start 启动服务
输入:
mysqladmin -u root -p password ‘123456’
来安装密码
输入之后直接回车(默许是不曾密码的)
接下来再输入
mysql -u root -p
图片 23
经过授权法更改长途连接权限
输入: grant all privileges on . to ‘root’@’%
identified by ‘123456’;
注:第二个’root’是用户名,第一个’%’是具有的ip都得以中距离访问,第五个’123456’表示
用户密码 假如不常用 就倒闭掉
输入:flush privileges; //刷新

在防火墙关闭之后,使用SQLYog之类的工具测试是不是能正确连接

图片 24

Mysql文件准备

将下载好的mysql安装包上传到linux服务器
解压mysql解压包,并活动到/usr/local目录下,重命名为mysql。
命令:

tar -xvf mysql-5.6.21-linux-glibc2.5-x86_64.tar.gz
mv mysql-5.6.21-linux-glibc2.5-x86_64 /usr/local
cd /usr/local
mv mysql-5.6.21-linux-glibc2.5-x86_64 mysql

图片 25

注: mysql默许的途径是就是/usr/local/mysql
,若是设置的地方转移,须要转移相应的布署文件。

2,编译包安装

安装mysql

切换到mysql的目录 /usr/local/mysql
输入:

 ./scripts/mysql_install_db --user=mysql

图片 26
成功安装mysql之后,输入
service mysql start 或 /etc/init.d/mysql start

图片 27
查阅是还是不是启动成功
输入:

 ps -ef|grep mysql

切换到 /usr/local/mysql/bin 目录下
设置密码
mysqladmin -u root password ‘123456’入mysql
输入:

mysql -u root -p

设置远程连接权限
输入:
grant all privileges on . to ‘root’@’%‘ identified
by ‘123456’;
下一场输入:
flush privileges;

评释:
首个’root’是用户名,第三个’%’是拥有的ip都足以长距离访问,第多个’123456’表示用户密码
倘若不常用就倒闭掉。

行使本地连接工具连接测试

图片 28

5.3.3 修改 hive-env.sh

修改hive-env.sh 文件,没有就复制 hive-env.sh.template
,视同一律命名为hive-env.sh
图片 29
在那些布局文件中添加

export  HADOOP_HOME=/opt/hadoop/hadoop2.8
export  HIVE_CONF_DIR=/opt/hive/hive2.1/conf
export  HIVE_AUX_JARS_PATH=/opt/hive/hive2.1/lib

图片 30

四、Mysql安装

因为Hive的默许元数据是Mysql,所以先要安装Mysql。
Mysql有三种安装形式,可自行拔取。

3.2.1 修改 core-site.xml

输入:

vim core-site.xml

在添加:

<configuration>
<property>
        <name>hadoop.tmp.dir</name>
        <value>/root/hadoop/tmp</value>
        <description>Abase for other temporary directories.</description>
   </property>
   <property>
        <name>fs.default.name</name>
        <value>hdfs://master:9000</value>
   </property>
</configuration>

3.2.4 修改mapred-site.xml

假如没有 mapred-site.xml
该公文,就复制mapred-site.xml.template文件视同一律命名为mapred-site.xml。
输入:

vim mapred-site.xml

修改那些新建的mapred-site.xml文件,在节点内参预配置:

<property>
    <name>mapred.job.tracker</name>
    <value>master:9001</value>
</property>
<property>
      <name>mapred.local.dir</name>
       <value>/root/hadoop/var</value>
</property>
<property>
       <name>mapreduce.framework.name</name>
       <value>yarn</value>
</property>

3,关闭防火墙

关门防火墙,方便访问。
CentOS 7版本以下输入:
关门防火墙

service   iptables stop

CentOS 7 以上的本子输入:

systemctl stop firewalld.service

3,下载地址

JDK:
http://www.oracle.com/technetwork/java/javase/downloads
Hadopp:
http://www.apache.org/dyn/closer.cgi/hadoop/common
Hive
http://mirror.bit.edu.cn/apache/hive/

百度云盘:
链接:https://pan.baidu.com/s/1slxBsHv 密码:x51i

1,更改主机名

先是更改主机名,目的是为了方便管理。
输入:

hostname 

查看本机的称谓
下一场改变主机名为master
输入:

hostnamectl set-hostname master

注:主机名称改变之后,要重启(reboot)才会收效。

发表评论

电子邮件地址不会被公开。 必填项已用*标注