Hadoop笔记详解

痛定思痛。 2022-06-05 23:15 176阅读 0赞

![Center][]

Hadoop

本机集群机器：  
211 212 215 216   
四台对应  
s100 s101 s102 s103 s104   
Ubuntu204-server-64-2-00  100  s100   211   
node1   
Ubuntu204-server-64-2-01  101  s101  212   
node2   
Ubuntu204-server-64-2-02  102  s102  215   
node3   
Ubuntu204-server-64-2-03  103  s103  215   
node3   
Ubuntu204-server-64-2-04  104   s104  216   
node4  
 a)  
bigdate   
   
海量数据：    
1byte  = 8bit        
1024B = 1M 2^10           
1024M = 1G 2^10   
1024G = 1T 2^10   
1024T = 1P 2^10   
1024P = 1E 2^10   
1024E = 1Z 2^10   
1024Z = 1Y 2^10    
1024Y = 1N 2^10     
  
存储  
分布式存储  
计算  
分布式计算  
 Hadoop(一头大象)  Doug cutting    
Hadoop 可靠，可伸缩，分布式计算的开源软件。  
 HDFS     
去  
IOE (IBM+oracle+EMC)    
MapReduce     MR  //  
映射和化简，编程模型  
推荐   
Big  data    
4V 1)  
Volumn   //  
题量大  
2)  
Variaty  //  
样式多  
3)  
Velocity  //  
速度快   
4)  
Valueless   //  
价值密度低  
b)  
Hadoop的安装：  
       （安装ubuntu系统）  
 安装  
jdk  
   Ln –s /soft/jdk-xxx  jdk    
  
配置环境变量  
  JAVA\_HOME = /soft/jdk  PATH=”…:/soft/jdk/bin”    
Source /etc/environment   
Java –version   
  
安装  
hadoop    
Hadoop.tar.gz    
Hadoop version    
配置环境变量  
HADOOP\_HOME  PATH   
配置  
hadoop  
分三个模式：  
1.  
standelone |local           
//  
独立  
/  
本地模式，使用的本地文件系统  
 Nothing   
查看文件系统的方式：  
查看文件系统  
  hadoop fs –ls /   
没有守护进程，所有程序运行在同一JVM中，利用test和debug.   
2.  
Paeudo distributed Mode  //  
伪分布模式  
3.  
Fully distributed mode  //  
完全分布式

配置SSH

1)安装ssh

$sudo apt-get install ssh

2)生成密钥对

Ssh-keygen –t rsa –P ‘’ –f ~/.ssh/ Cd ~/.ssh   
3)导入公钥数据到授权库中  
 Cat ~/.ssh/id\_rsa.pub >> ~/.ssh/authorized\_keys

4)登录到localhost

Ssh localhost

5)  
格式化  
hdfs  
文件系统  
 Hadoop namenode -format   
6)  
   
启动所以进程  
 Start-all.sh 7)  
   
查看进程  
 Jps              
//5   RM NM NN DN 2NN   
8)  
 查看文件系统  
 Hadoop fs -ls   
9)创建文件系统  
   
Hadoop fs –mkdir –p /user/Ubuntu/data   
Hadoop fs –ls –R /    
  
c)  
Hadoop包含三个模块  
1)  
Hadoop common：  
支持其他模块的工具模块  
2)  
Hadoop Distributed File System (HDFS)     
分布式文件系统，提供了对应用程序数据的高吞吐量访问。  
     
进程：  
    NameNode        
名称节点  
   NN      
DataNode       
数据节点  
   DN      
SecondaryNamenode    
辅助名称节点  
    2ndNN   
3)  
 Hadoop YARN：     
作业调度与集群资源管理的框架。

进程

ResourceManager

资源管理

—RM    NodeManager

节点管理器  
—NM   
4)  
 Hadoop MapReduce:   
基于yarn系统的对大数据集进行并行处理技术  
    
配置hadoop   
1)  
Standelone/local       
d)  
完全分布式安装：  
   
1)准备5台客户机  
   
本人集群机器：  
211 212 215 216   
四台对应  
s100 s101 s102 s103 s104              
       ip   主机名           ip  主机名  
   
1.  
 Ubuntu204-server-64-2-00  100  s100  211 node1   
2.  
 Ubuntu204-server-64-2-01  101  s101  212 node2   
3.  
 Ubuntu204-server-64-2-02  102  s102  215 node3   
4.  
 Ubuntu204-server-64-2-03  103  s103  215 node3   
5.  
 Ubuntu204-server-64-2-04  104   s104  216 node4   
  
2)  
 安装ssh    
1)

安装ssh

$sudo apt-get install ssh

2)  
生成密钥对  
  
ssh-keygen –t rsa –P ‘’ –f ~/.ssh/ cd ~/.ssh   
3)   
导入公钥数据到授权库中  
   
cat ~/.ssh/id\_rsa.pub >> ~/.ssh/authorized\_keys   
scp /root/.ssh/\*  node2@:/root/.ssh/   
  
scp /root/.ssh/\*  node3@:/root/.ssh/   
  
scp /root/.ssh/\*  node2@:/root/.ssh/   
4)  
   
登录其他机器：  
 ssh  node1 ifconfig    
3)安装jdk   
1.  
rpm -ivh /opt/jdk-7u79-linux-x64.rpm   
2.   
ln –s /soft/jdk-xxx  jdk  
3.  
配置环境变量  
4.  
 JAVA\_HOME = /soft/jdk   
5.  
 PATH=”…;/soft/jdk/bin”   
6.  
 source /etc/profile   
7.  
   java –version    
4)  
安装hadoop   
1.  
   tar –zxvf hadoop-2.7.3.tar.gz   
2.   
 Hadoop version   
3.  
配置环境变量  
4.  
 HADOOP\_HOME=/soft/hadoop-2.7.3    
5.  
PATH=…:$HADOOP\_HOME/bin:$HADOOP\_HOME/sbin   
6.  
配置hadoop 查看文件系统  
    
hadoop fs –ls /   
配置文件  
/etc/hadoop/   
core-site.xml   
   
<configuration>           
<property>   
<name>fs.default.name</name>                   
<value>hdfs://node1:8020</value>           
</property>   
</configuration>    
  
Hdfs-site.xml   
  
<configuration>           
<property>                   
<name>dfs.replication</name>                   
<value>3</value>           
</property>  
</configuration>   
  
Mapred-site.xml   
  
<configuration>           
<property>                   
<name>mapreduce.framework.name</name>                   
<value>yarn</value>           
</property>   
</configuration>   
  
Yarn-site.xml   
  
<configuration>           
<property>                   
<name>yarn.resourcemanager</name>                   
<value>localhost</value>           
</property>           
<property>                   
<name>yarn.nodemanager.aux-services</name>                   
<value>mapreduce\_shuffle</value>   
</property>   
</configuration>     
5)  
配置文件  
   
\-rw-r--r--. 1 root root   861 6  
月  
   6 10:41 core-site.xml   
\-rw-r--r--. 1 root root   950 6  
月  
   6 10:41 hdfs-site.xml   
\-rw-r--r--. 1 root root   844 6  
月  
   6 10:41 mapred-site.xml   
\-rw-r--r--. 1 root root   728 6  
月  
   6 10:43 yarn-site.xml   
\-rw-r--r--. 1 root root    12 6  
月  
   6 10:43 slaves     
/soft/hadoop/etc/hadoop/core-site.xml   
fs.defaultFS=hdfs://node1/    
/soft/hadoop/etc/hadoop/hdfs-site.xml   
replication=3   
dfs.namenode.secondary.http-address=node4:50090    
/soft/hadoop/etc/hadoop/mapred-site.xml   
mapreduce.framework.name=yarn    
soft/hadoop/etc/hadoop/yarn-site.xml   
yarn.resourcemanager.hostname=node1    
/soft/hadoop/etc/hadoop/slaves node2 node3    
  
在集群上分发以上三个文件  
   
cd /soft/hadoop/etc/hadoop   
xsync core-site.xml   
xsync yarn-site.xml   
xsync slaves    
6)  
   
首次启动  
hadoop   
1)  
格式化文件系统  
 $>hadoop namenode -format   
2)  
启动所有进程  
 $>start-all.sh   
3)  
查询进程 jsp   
4)  
停止所有进程  
 Stop-all.sh    
  
使用webui访问hadoop  hdfs   
1）  
hdfs       http:/node1:50070   
2) dataNode  http://node2:50075   
  
3) 2nn     http://node4:50090   
   
删除hadoop临时目录数据：

默认:/tmp/

adoop-root         
hadoop-root-datanode.pid(  
伪分布式产生  
)     
e)  
 几种脚本  
 scp  rsync xsync xcall

1)scp

2) rsync    
远程同步工具   
主要备份和镜像支持链接，设备。       
rsync –rvl /soft/\* ubuntu@s101:/soft    
3)  
自定义脚本  
xsync,  
在集群上分发文件  
    
循环复制文件到所以节点的相同目录下  
  
rsync –rvl /home/Ubuntu ubuntu@s101:   
xsync hello.txt    
\[/usr/local/bin/xsync\]   
\[root@node1 bin\]\# vim xsync   
\#!/bin/bash   
pcount=$\#    
if((pcount<1)) ; then           
echo no args;           
exit;   
fi    
p1=$1;   
\#  
获取文件名称  
 fname=\`basename $p1\`   
echo fname=$fname;    
\#  
获取上级目录的绝对路径  
 pdir=\`cd -P $(dirname $p1);pwd\`   
echo pdir=$pdir;   
\#echo $p1;    
cuser=\`whoami\`   
for ((host=2; host<5;host=host+1)); do           
echo ---------- node$host ---------           
\#echo $pdir/$fname $cuser@node$host:$pdir           
scp $pdir/$fname $cuser@node$host:$pdir   
done        
4  
）  
   
编写  
/usr/local/bin/xcall  
脚本，在所有主机上执行相同的命令  
   
xcall rm –rf /soft/jdk   
\[/usr/local/bin/xcall\]        
\[root@node1 bin\]\# cd /usr/local/bin   
\[root@node1 bin\]\# xcall ls -l /soft/   
\[root@node1 bin\]\# xcall rm hello.txt   
\[root@node1 bin\]\# vim xcall    
\#!/bin/bash   
pcount=$\#   
if((pcount<1)) ; then           
echo no args;           
exit;   
fi    
echo -------- localhost -------   
$@   
echo $@   
for ((host=2; host<5;host=host+1)); do           
echo ---------- node$host ---------           
\#scp $pdir/$fname $cuser@node$host:$pdir           
ssh node$host $@   
done      
  
f)  
整理hadoop的所有类库和配置文件  
   
解压缩hadoop-2.7.2.tar.gz 到目录下  
 整理jar包  
    
抽取所有配置文件  
     
\[core\_default.xml\]    
 hadoop-common-2.7.2.jar/core-default.xml      
\[hdfs-default.xml\]  
hadoop-hdfs-2.7.2.jar/hdfs-default.xml      
\[yarn-default.xml\]     
hadoop-yarn-common-2.7.3.jar/hdfs-default.xml       
\[mapred-default.xml\]     
hadoop-mapreduce-client-core-2.7.2.jar/mapred-default.xml    
  
g)  
 hadoop fs /   
使用：  
   
hadoop fs –mkdir –p /user/Ubuntu/data   
hadoop fs –put hello.txt /user/Ubuntu/data/   
hdfs dfs -lsr /   
hdfs dfs -cat /user/hello.txt      
./hadoop fs -ls /   
./hadoop fs –ls –R /   
./hadoop fs -mkdir test   
./hadoop fs -put /opt/test.sh /user      
将本地文件存储至  
  
hadoop ./hadoop fs –get /user/t/ok.txt /home/t   将hadoop上某个文件down至本地已有目录下  
     
./hadoop fs -cat /user/test.sh     
hadoop fs –rmr /user/t   删除hadoop上指定文件夹（包含子目录等）  
   
hadoop  fs  -touchz  /user/new.txt   
在hadoop指定目录下新建一个空文件  
  
hadoop  fs  –mv  /user/test.txt  /user/ok.txt   （将test.txt重命名为ok.txt）  
  
hadoop dfs –getmerge /user /home/t        将hadoop指定目录下所有内容保存为一个文件，同时down至本地  
   
hadoop job –kill  \[job-id\]        将正在运行的hadoop作业kill掉  
h)   
修改本地的临时目录hadoop.tmp.dir   
  
1)  
修改  
hadoop.tmp.dir   
\[core-site.xml\]   
<property>    
<name>hadoop.tmp.dir</name>     
<value>/soft/hadoop-root</value>     
</property>   
2)  
分发  
core-site.xml   
3)   
hadoop namenode –format    
后重启  
hadoop    
xcall  mkdir /soft/hadoop-root    
xcall rm –rf /soft/hadoop/logs    
  
i)   
hadoop  
模块  
   
1.  
common   
2.  
hdfs   
start-dfs.sh/stop-dfs.sh  (先启动它)   
nn   
dn   
2nn   
3.  
   
yarn   
start-yarn.sh/stop-dfs.sh   
rn   
nn   
4.  
mapred    
j)  
   
hadoop  
脚本分析  
   
1.start-all.sh     
libexec/hadoop-config.sh                              --设置变量  
     
sbin/start-dfs.sh –config $HADOOP\_CONF\_DIR    -- 启动  
hdfs    
sbin/start-yarn.sh –config $HADOOP\_CONF\_DIR  --启动  
yarn   
2.libexec/hadoop-config.sh            --设置变量  
    
COMMON\_DIR  …    
HADOOP\_CONF\_DIR=…    
HEAP\_SIEZ=1000M,    
CLASSPATH=…   
3.sbin/start-dfs.sh –config $HADOOP\_CONF\_DIR    
启动  
hdfs     
1.libexec/hdfs-config.sh     
2.  
获取名称节点主机名  
    NAMENODES= hdfs getconf –namenodes   
3.  
启动名称节点  
        $HADOOP\_prefix/sbin/hadoop-daemons.sh      
\--config $hadoop\_conp\_dir     
\--hostnames $namenodes      
\--script $bin/hdfs start namenode $nameStartOpt   
4.  
启动  
datanode $HADOOP\_prefix/sbin/hadoop-daemons.sh      
\--config $hadoop\_conp\_dir      
\--script $bin/hdfs start datanode $nameStartOpt   
5.  
启动  
2nn $HADOOP\_prefix/sbin/hadoop-daemons.sh      
\--config $hadoop\_conp\_dir   
\--hostnames $secondarynamenode      
\--script $bin/hdfs start secondarynamenode    
4.libexec/hdfs-config.sh    
libexec/hadoop-config.sh   
5.sbin/hadoop-daemons.sh        
\--  
启动守护进程脚本  
     
1.libexec/hdfs-config.sh      
\--  
执行配置脚本  
     
2.slaves.sh  --config $HADOOP\_CONF\_DIR cd $hadoop\_prefic \\;   
$bin/hadoop-daemon.sh –config $hadoop\_conf\_dir “$@”    
  
循环  
slaves  
文件，通过  
ssh  
方式登录远程主机，执行相应命令  
    
\[bin/hadoop-daemon.sh\]    
hadoop-config.sh    
\[bin/hdfs\]     
hdfs getconf –namenodes   
hdfs getconf –secondaryNameNdoes   
  
k)  
在各个机子上启动节点：  
   
hadoop-daemon.sh start namenode   
hadoop-daemon.sh start secondarynamenode     
hadoop-daemon.sh start datanode   
hadoop-daemon.sh stop  datanode    
  
数据库四个特点：  
a  atomic           
原子性  
c consistent    
一致性   
i isolation     
隔离性  
d durable      
永久性  
  
l)  
常用命令：  
格式化系统  
   
hadoop namenode –format   
put === copyFormLocal    
hadoop fs –put //hdfs dsf –put    
hdfs dfs –put //   
  
重命名  
    
hdfs dfs –mv ./sshd.txt ./how.txt   
  
下载   
hdfs dfs –get ./ssh.txt ./kk.txt    
hdfs dfs –copyToLocal   
  
移动到hdfs    
hdfs dfs –moveFromLocal hello.txt .   
  
从hdfs移动到本地，没有实现。  
   
删除文件  
  hdfs dfs –rmdir …   
  
在hdfs上进行文件复制  
hdfs dfs –cp /user/Ubuntu/hello.txt /user/hello2.txt     
hadoop   
配置信息  
    
namenode  
的本地目录配置成多个，则每个目录存放内容相同，可靠性。  
    
【hdfs-site.xml】  
dfs.namenode.name.dir=file:///$\{hadoop.tmp.dir\}/dfs/name1,file:///$\{hadoop.tmp.dir\}/dfs/name2   
   
datanode   
也可以配置多个目录，不是副目录。  
     
【hdfs-site.xml】  
   dfs.datanode.name.dir=file:///$\{hadoop.tmp.dir\}/dfs/name1,file:///  
  
$\{hadoop.tmp.dir\}/dfs/name2   
   
hadoop hdfs  
文件大小  
 128M    
磁盘的寻道时间  
=10ms  
磁盘的  
IO  
速率：  
100MB/s     
10 \* 100 = 1s \* 100M/s = 100M    
  
通过API访问hdfs    
 @Test    
public void writeFile() throwsException \{     
Configuration conf= newConfiguration();     
FileSystem fs = FileSystem.get(conf);   
 Path path = new Path("hdfs://node1:8020/user/hello");     
//  
数据输出流  
   
FSDataOutputStream dos = fs.create(path);   dos.write("hello world !!!".getBytes());     
dos.close();     
System.  
out  
.println("over");    
\}  
m)  
   
在eclipse 安装hadoop插件，方便访问hdfs   
下载  
hadoop2x-eclipse-plugin.zip    
解压  
hadoop2x-eclipse-plugin.zip/release/\*.jar(3)  
到  
eclipse  
安装目录下  
/plugins/下  
   
重启eclipse    
  
验证hadoop插件是否成功  
    
剖析文件写入过程，  
   
副本节点的选择（机架感知）  
   
自定义机架感知  
    
创建类实现  
DNSToSwitchMapping  
接口  
   
配置文件  
core-site.xml   
\[core-site.xml\]   
net.topology.node.switch.mapping.impl=com.it18zhang.rackaware.MyDNSToSwichmapping   
  
分发core-site.xml    
增加一个数据节点：  
   
克隆一台机器，一个节点  
启动新节点  
   
hdfs是master /slave 架构，由一个名称节点以及多个数据节点构成，  
nn负责namespace管理以及client的访问。  
    
Namenode        
存放元数据（名称，副本数，权限，快列表），不包含数据节点。  
rack aware  
策略  
   
使用oie和oev查看namenode的镜像文件和编辑日志文件  
   
离线工具：  
   
hdfs oiv –p XML –I dfs/name1/current/fsimage\_000 –o ~/image.xml   
hdfs oiv –p XML –i xxx –o ~/xxx.xml //fsimage   
hdfs oev –p XML  -i xxx –o ~/xxx.xml //edit log    
hadoop-daemon.sh stop namenode   
hadoop-daemon.sh start namenode   
hdfs dfsadmin –help saveNamespace    
  
查看  
nn  
的镜像文件  
hdfs  oiv –p XML –I faimage –o xxx    
查看  
nn  
的编辑日志文件  
hdfs oev –p  XML faedit-xxx –o xxx     
n)  
   
hadoop  
集群启动是首先进入安全模式  
如果集群出于安全模式，不能执行重要操作（写操作）。  
集群启动完成后，自动退出安全模式。  
   
安全模式操作  
hdfs dfsadmin –safemode get //  
查看安全模式状态  
   
hdfs dfsadmin –safemode anter //  
进入安全模式状态  
   
hdfs dfsadmin –safemode leave //  
离开安全模式状态  
   
hdfs dfsadmin –safemode wait //  
等待安全模式状态  
保存名字空间  
/  
融合镜像和编辑日志：  
进入安全模式

hdfs dfsadmin –safemode enter

进行保存  
 hdfs dfsadmin –saveNamespace    
  
退出安全模式  
     
hdfs dfsadmin –safemode leave    
  
一致性模型  
scp   
实现二个远程主机之间的文件复制。  
   
$>scp –r hello.txt  root@node4:/user/xx.txt   
  
$>scp –r root@node4:/user/xx.txt ~/   
  
$>scp –r -3 root@node4:/user/hello.txt  root@noed1:/user/    
distcp     
  
实现二个 hadoop集群之间的递归数据复制  
hadoop distcp hdfs://s101:8020/user/hello.txt hdfs://s102:8020/user/kk.txt    
distcp和archive都是运行的一个MR作业，需要在yarn的框架上运行。  
归档文件  
    
hadoop archive –archiveName myhar.har –p /user/Ubuntu /user/my    
  
查看归档：  
  
hdfs dfs –lsr har:///user/my/myhar.har    
  
解归档：  
  
hdfs dfs –cp har:///user/my/myhar.har /user/your    
  
数据完整性  
o)  
在ubuntu上安装eclipse   
 下载  
eclipase-jee-mars-R-linux-gtk-x86\_64.tar.gz    
tar考到ubuntu /soft下  
tar –xzvf eclise-xxx.tar.gz    
配置环境变量：  
PATH=…:/soft/eclipse    
  
启动（后台）  
 eclipse &    
p)  
codec    
编码解码器  
   
1.deflate   .deflate   
2.gzip    .gz   
3.bzip2   .bz2   
4.lzo   .lzo   
5.lz4   .lz4   
6.snappy   .snappy     
deflateCodec: length=2054672, compressTime=1766, decompress=615   
GzipCodec:  length=2054684, compressTime=680,  decompress=341   
BZip2Codec:  length=1457864, compressTime=10271, decompress=1695   
LzoCodec:   length=3636556, compressTime=499,  decompress=303   
Lz4Code:   length=3644382, compressTime=177,  decompress=392   
SnappyCode:  length=3987117, compressTime=424,  decompress=434    
  
空间效能：  
 Bzip2  > deflate  > Gzip  > lzo  > lz4      > snappy   
  
压缩时间：  
 lz4  > snappy   > lzo   > Gzip > deflate > Bzip2   
 解压缩时间：  
lzo  > Gzip     > lz4   > snappy > deflate > Bzip2      
  
使用  
hadoop的checknative命令检查本地库安装情况  
hadoop  checknative –a   
  
安装lzo-2.06版  
  
lzo-2.06.tat.gz   
./configure –enable-shared make make install   
  
检查是否生成lzo库文件  
 find /usr/local/lib |grep lzo   
编译  
hadoop-lzo-master  
项目：  
hadoop-lzo-master.zip   
  
编译  
hadoop-lzo    
c\_INCLUDE\_PATH=/usr/local/include    
LIBRARY\_PATH=/usr/local/lib    
  
参考下文搭建maven环境。  
mvn clean test    
出现lzo共享库找不到，将liblzo2.so.xxx文件复制/lib目录下,   
$>rsync –l /usr/local/lib/\*lzo\* root@node1:/lib   
重新  
mvn clean package    
在hadoop 项目中集成hadoop-lzo-master的jar包   
1.  
复制生成的jar包到项目lib下

cp target/hadoop-lzo-0.4.20-SNAPSHOT.jar ~/workspace/hadoop2-01/lib/

3.修改代码  
q)  
centos上安装和使用 maven：apache-maven-3.3.9-bin.tar.gz到/soft下  
  
配置maven的环境变量  
etc/environment    
M2\_HOME=/soft/maven   
PATH=…:/soft/maven/bin   
  
配置maven的setting.xml文件，连接到本地仓库服务器。  
   
注意：  
maven安装在centos上nexus安装在win10上  
   
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"   
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 https://maven.apache.org/xsd/settings-  
1.0.0.xsd">   
<localRepository/>  
<interactiveMode/>   
<usePluginRegistry/>   
<offline/>   
<pluginGroups/>   
<servers/>   
<mirrors/>   
<proxies/>   
<profiles/>   
<activeProfiles/>   
</settings>   
     
配置maven插件  
eclipse  ->windows ->首选项-》maven ->user settings -> 右侧进行设置：  
user settings :/soft/maven/conf/settings.xml   
local repository :/home/Ubuntu/.m2/repository   
完成  
r)  
 win10安装maven:   
1.  
 安装tomcat   
2.  
 安装nexus.war文件  
3.  
复制nexus.war到$\{tomcat\_home\}/webapps/   
4.  
 启动tomcat   
5.  
http://localhost:8080/nexus/   
  
6.  
本地服务器maven的配置  
  
 tomcat/webapps/nexus/WEB-INF/classes/nexus.properties   
nexus-work=E:/maven-repo/nexus runtime=$\{bundleBasedir\}   
nexus-app=$\{runtime\}    
  
在win10 使用maven    
1.  
创建hello-world项目所在的文件夹  
    
在hello-world文件夹下创建pom.xml    
/hello-world/pom.xml       
  
打开pom.xml   
<?xml version="1.0"?>   
<project xmlns="http://maven.apache.org/POM/4.0.0"   
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
  
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4\_0\_0.xsd">    
  
<modelVersion>4.0.0</modelVersion>   
<groupId>com.it18zhang.heloo-world</groupId>   
<artifactId>heloo-world</artifactId>   
<version>1.0-SNAPSHOT</version>   
<name>maven hello world project</name>   
 <dependencies>    
<dependency>    
<groupId>junit</groupId>    
<artifactId>junit</artifactId>  
  <version>4.11</version>   
 <scope>test</scope>    
</dependency>   
</dependencies>  
 </project>   
2.  
创建文件夹：  
   
cd \\workspace\_eclipse\\hello-world    
mkdir    
\\src\\main\\java\\com\\it18zhang\\helloworld   
3.  
创建  
HelloWorld.java  
文件  
package com.it18zhang.helloworld;   
public class HelloWorld \{

public static void main(String\[\] args)\{

System.out.println("Hello world!!!");

\} \}   
4.  
在pom.xml文件所在目录运行：  
   
(需要安装maven apache-maven-3.5.0， 配置环境变量D:\\software\\apache-maven-3.5.0\\bin  验证：mvn  -v )   
mvn clean compile   
mvn clean   
5.创建测试类包。。。  
6.  
 创建包。。。  
s)文件格式：   
1.  
 txt  纯文本格式，若干行记录   
2.  
 SequenceFile      key-value  //map   
3.  
   
编写  
sequence  
文件代码：  
public class TestSequenceFile\{   
 /\*     
\* 写入  
sequenceFile     
\* sequenceFile key-value  
类似  
map     
\*/    
@Test    
public void write() throws Exception\{     
Configuration conf= new Configuration();     
conf.set("fs.defaultFS", "hdfs://node1:8020/");    
 FileSystem fs = FileSystem.get.(conf);     
Path path = new Path("hdfs://node1:8020/user/myseqfile.seq");     
Writer  writer = SequenceFile.createWriter(fs,conf,path,IntWritable.class,Text.class  
);    
//  //  
写入数据   
//  writer.append(new IntWritable(1),new Text("tom1"));   
//  writer.append(new IntWritable(1),new Text("tom2"));   
//  writer.append(new IntWritable(1),new Text("tom3"));   
//  writer.append(new IntWritable(1),new Text("tom4"));   
//  writer.append(new IntWritable(1),new Text("tom5"));   
//  writer.close();   
//  System.out.println("-------------over-------------");        
IntWritable key = new IntWritable();     
Text value = newText();     
for(int i=0;i<100;i++)\{      
key.set(i);   
value.set("star"+i);      
writer.append(key, value);     
\}     
System.out.println("-------------over-------------");        
 \}    
/\*    
\*   
读取  
seqfile    
\*/    
@Test   
  public void readSeq() throws Exception\{       
Configuration conf = new Configuration();       
conf.set("fs.defaultFS", "hdfs://node1:8020/");      
 FileSystem fs = FileSystem.get(conf);       
Path path = new Path("hdfs://node1:8020/user/myseqfile.seq");       
Reader reader = new SequenceFile.Reader(fs,path,conf);         
IntWritable key = new IntWritable();       
Text value=new Text();      
while(reader.next(key,value))\{        
System.out.println(key + " = " + value);       
 \}       
reader.close();      
\}      
 \}   
  
4.  
查看是否写入：  
   
hdfs dfs -cat /user/myseqfile.seq  
hdfs dfs –test /user/myseqfile.seq     
MapFile   是排序的seqfile具有索引。  
index(seq)  data(seq)   
  
要求key按照大小顺序添加的。  
  
index:   
索引和偏移量的映射（seq），可以设置间隔值，默认128，  
     
通过配置文件  
io.map.index.interval  
设置间隔值，可以进行折半查找。  
   
data :key – value   
  
可以寻找与指定key最近的key,可以设置是否向前寻找。  
   
ArrayFile     
key : index      
value : value    
SetFile      
key : WritebleComparable      
value : null     
hadoo  
序列化  
    
没有元数据，数据间是独立的。数据量小，两边需要知道数据顺序，精简  
   
1.  
Writable   
2.  
IntWritable + Text + LongWritable   
3.  
DataOuputStream   
4.  
Text       //java.lang.String     
java  
串行化  
  
有元数据（数据类型）写入，数据量比较大，数据间不是独立的，存在相互引用的情况。  
   
java : 3867297    
hadoop : 47591150   
class Address\{    
String province;    
String city;    
String street;  
 \}    
class Persion\{    
id    
name    
age    
Address addr;    
\}   
DataOutputStream   
1.  
writeUTF(“xxx”)   
采用utf8存放数据。（字符采用1/2/3/字节数据存储）；  
   
2.  
writeBytes(“xxx”) 每个字符只写入一个字节。  
   
3.   
writeChars(“xxx”) 每个字符两个字节。  
   
4.  
ArrayWritable   
Array   
5.  
MapWritable   
Map   
6.  
NullWritable   
  
没有串行化  
/  
反串行过程，不涉及数据操作和网络传输，仅仅是一个占位符。单例模式（饿汉式）  
.    
SecondaryNamenode     
1.  
辅助名称节点  
       2ndNN     
2.oiv    off image viewer     
3.oev     
4.创建检查点过程  
5.2nn  
创建检查点的周期  
     
hdfs dfsadmin     
1.  
设置配额管理  
        
目录配额  
      
控制的目录所有文件  
/  
文件夹的个数，1  
表示空目录。  
      
包含子文件。      
$>hdfs dfsmain –setQuota 1 /user/Ubuntu/data  //  
设置配额  
      
$>hdfs dfsadmin –clrQuota /user/Ubuntu/data      
空间配额  
       
副本数计算在内，控制的所有文件总大小。值至少大于  
>384m,  
磁盘空间最少消耗就是  
384m.   
$>hdfs dfsadmin –help setSpaceQuota  //  
查看空间配额  
      
$>hdfs dfsadmin –setSpaceQuota 20m data  //  
设置空间配额  
      
$>hdfs dfsadmin –clrSpaceQuota data //  
清理空间配额  
     
2.  
快照  
快照相当于对目录做一个备份。并不会立刻复制所有文件，而是指向同一个文件。当写入发生时，才会产生新文件。  
      
$>hdfs dfs –help createSnapShot      //  
查看快照  
      
$>hdfs dfsadmin –allowSnapshot data //  
开启指定目录的快照功能，默认是禁用  
      
$>hdfs dfs –createSnapShot /user/Ubuntu/data  //  
对目录创建快照  
      
$>hdfs dfs –createSnapShot /user/Ubuntu/data  xpc-0902  //  
指定名称命名快照  
      
$>hdfs dfs –renameSnapshot data s0902-0040.890 ubuntu\_902  //  
重命名快照    
$>hdfs lsSnapshottableDir //  
列出当前用户所有快照目录  
      
$>hdfs diffSnapshot data . xpc\_0902  //  
比较两个快照目录的不同之处  
  
3.  
回收站  
trash,对应的一个文件夹。  
fs.trash.interval=0   //分钟数，  
0表示禁用回收站，删除文件的存活时间。  
fs.trash.checkpoint.interval //  
检查回收站间隔时间，应该<= 存活时间，0表示和fs.trash.interval一致。   
1.  
启动回收站  
 core-site.xml fs.trash.interval=1   
2.  
分发文件，立刻生效  
       
回收站位置：  
/user/Ubuntu/.Trash/…     
3.  
通过程序删除的文件不会移过回收站，需要通过moveToTrash()才进入回收站。  
      
Trash trash = new Treash(conf);      
trash.moveToTrash(path);   
4.丢弃回收站  
     
hdfs dfs –expunge  //  
清空回收站  
   
5.修改hdfs的webui的静态用户的名称。  
     
core-site.xml     
<property>     
<name>hadoop.http.staticuser.user</name>      
<value>Ubuntu</value>      
</property>   
  
  
t)大数据：  
  
1存储  
 hdfs:hadoop distributed file system. GFS   
分布式存储  
   
2.运输  
 分布式运算。  
MapReduce(MR)  //映射 + 化简.编程模型  
 Key – Value  
编写默认程序  
1.  
创建Mapper类（年份气温案例）  
   
2.  
创建Reducer   
3.  
创建MapReducer   
4.  
运行  
5.  
通过代码验证map和reduce分别运行在节点上？  
   
MapReduce:Job    
术语       
MapTask:map任务

Reduce :task

编程模型  
map（映射）+reduce （简化）  
    
Mapreduce  
作业执行过程：  
   
1.  
 编程源代码  
2.  
导出jar包  
   
修改pom.xml文件  
    
删除junit的scope部分  
    
<dependency>      
<groupId>junit</groupId>      
<artifactId>junit</artifactId>      
<version>3.8.1</version>   
</dependency>   
  
在项目下的  
pom.xml文件右键运行  
maven build…   
Globals : package   
  
确认  
 生产jar包  
3.  
 上传ubuntu   
4.  
在ubuntu上提交job     
hadoop jar xxx.jar com.xxx.xxx.xxxApp   
/user/Ubuntu/data/ncdc /user/Ubuntu/out2    
5.  
win10无法提交作业给ubuntu.   
交叉平台的问题。  
eclipse中的maven项目需要查看源代码时，  
   
项目不能够正常下载可以使用手动命令强制下载源代码  
$>mvn dependency:sources –DdownloadSources=true    
远程调试：  
\[远端（s100,namenode）\]   
1.  
查看java远程调试的帮助  
 c:/>java –agentlib:jdwp=help   
2.  
 设置java虚拟机的远程调试  
java –agentlib:jdwp=transport=dt\_socket,server=y,suspend=y,address=8000    
//设置java虚拟机的参数，启用远程调试  
3.  
给namenode启动是增加jvm的远程调试功能，  
a.  
修改bin/hadfs启动脚本  
 HADOOP\_NAMENODE\_OPTS=$HADOOP\_NAMENODE\_OPTS –  
  
agentlib:jdwp=transport=dt\_socket,server=y,suspend=y,address=8000   
b.  
在shell当中直接设置环境变量  
 $>export HADOOP\_NAMENODE\_OPTS =”$HADOOP\_NAMENODE\_OPTS –  
  
agentlib:jdwp=transport=dt\_socket,server=y,suspend=y,address=8000”   
c.  
完成远程调试后，关闭远程调试功能  
 $>export HADOOP\_NAMENODE\_OPTS=   
4.  
启动名称节点  
   
$>hadoop-daemon.sh start namenode       
\[客户端\]   
1.  
 找namenode类，在main函数上打断点.   
2.   
eclipse  
右键调试  
\->remote java application   
项目：  
myhadoop ConnectionType : standard(socket attach)   
host:s100   
port:8000   
3.  
调试  
开始调试  
  
在win和ubuntu上通过远程调试，查看job在hadoop集群上的执行过远程  
     
\[远程s100,Ubuntu\]   
1.  
 传递jar到ubuntu   
2.  
设置  
HADOOP\_CLIENT\_OPTS  
环境变量  
  
$>export HADOOP\_CLIENT\_OPTS=”$HADOOP\_CLIENT\_OPTS –  
  
agentlib:jdwp=transport=dt\_socket,server=y,suspend=y,address=8000”   
3.   
启动  
job  
提交命令  
  
$>hadoop jar xxx.jar com.xx.x.x.App data/ncdc out3     
\[  
客户端，  
win7,eclipse\]   
1.  
在源代码中设置断点  
 App.main()…   
2.  
eclipse  
右键调试  
\->remote java application   
  
项目：  
myhadoop   
ConnectionType : standard(socket attach)   
host:a100   
port:8000   
3.  
调试开始  
 MR AM  :MapReduce App master   
resMgrDelegate :ResourceManager  
代理  
   
YARM   ResourceManager   NodeManager   
google   PB:protocal buffer,  
协议缓存区。  
    
RPC     
google protobuf     
Remote procedure call,  
远程过程调用  
    
eclipse  
启动服务端，客户端  
  ipc   
切片大小和block相当，   
优化策略（map）,   
1.  
数据本地化优化策略  
  
2.  
机架本地化策略   
3.  
不同机架运行任务  
Partition     
  
分区  
 Combiner:  
合成器  
    
减低map和reduce之间的传输量。  
   
启动  
mr  
作业历史服务器  
   
1.启动  
   
xcal mr –jobhistory-daemon.sh stop   
historyserver

wordcount

单词统计  
空格分割的单词  
block设置：  
hdfs //  
存储范围，  
hdfs-site.xml    
512的倍数  
 //512是校验和设置  
   
切片   
split             //mr  
作业范畴  
minSplit , maxSplit , blocksize    //  
取中间值：  
    
切片的数量决定了map task的数量  
    
集群转换本地：  
    
mapred-site.xml   <value>local</value>    
yarn-site.xml    <value>localhost</value>    
core-site.xml    <value>file:///</value>   
   
Debug Configurations -> Argunents  D:/mr d:/mr/out/         
  
u) 最后  
命令：  
which start-all.sh   
find .    
cat  h1 >> h0   
hdfs getconf -nnRpcAddresses   
eclipse 单步跳过  单步进入

![Center 1][]

![Center 2][]

</configuration>    
vim hdfs-site.xml   
<configuration>        
<property>            
<name>dfs.replication</name>            
<value>2</value>        
</property> </configuration>     
\[root@localhost conf\]\# vim slaves    
10.10.1.212   
10.10.1.215    
\[root@localhost conf\]\# vim masters    
10.10.1.212      
ssh-keygen  -t dsa -P '' -f ~/.ssh/id\_dsa   
cat ~/.ssh/id\_dsa.pub >> ~/.ssh/authorized\_keys     
  
格式化：  
   
./hadoop namenode -format    
java --version     
vim hadoop-env.sh   
\# The java implementation to use.  Required. export JAVA\_HOME=/usr/java/jdk1.8.0\_101    
./start-dfs.sh   
./stop-dfs.sh    
jps    
http://10.10.1.206:50070   
http://10.0.27.206:50070    
(二) MapReduce   
分布式计算框架  
MapReduce    
移动计算，而不是移动数据  
   
split -> map -> sort -> reduce     
(三) Shuffler    
计算框架  
   
在mapper和reducer中间的一个步骤    
安装部署：  
MapReduce   主JobTracker, 从TaskTracker.    
安装DataName上  
     
vim mapred-site.xml        
<property>            
<name>mapred.job.tracker</name>            
<value>10.0.27.206:9001</value>        
</property>     
http://10.0.27.206:50030        
date -s "2017-05-17 15:03:00"    
Hadoop fs  
命令：  
1，  
Hadoop fs –fs \[local | <file system URI>\]  
：声明hadoop使用的文件系统。  
   
2，  
hadoop fs –ls <path>  
：等同于本地系统的ls，列出在指定目录下的文件内容，支持pattern匹配。输出格式如  
filename(full path)   <r n>  size.其中n代表replica的个数，size代表大小（单位bytes）。  
3，  
hadoop fs –lsr <path>  
：递归列出匹配pattern的文件信息，类似ls，只不过递归列出所有子目录信息。   
4，  
hadoop fs –du <path>  
：列出匹配pattern的指定的文件系统空间总量（单位bytes），等价于unix下的针对目录的du –sb <path>/\*  
和针对文件的du –b <path> ，输出格式如name(full path)  size(in bytes)。  
   
5，  
hadoop fs –dus <path>  
：等价于-du，输出格式也相同，只不过等价于unix的du -sb。   
6，  
hadoop fs –mv <src> <dst>  
：将制定格式的文件  
move到指定的目标位置。当src为多个文件时，dst必须是个目录。  
   
7，  
hadoop fs –cp <src> <dst>  
：拷贝文件到目标位置，当src为多个文件时，dst必须是个目录。  
8，  
hadoop fs –rm \[-skipTrash\] <src>  
：删除匹配pattern的指定文件，等价于unix下的rm <src>。  
   
9，  
hadoop fs –rmr \[skipTrash\] <src>  
：递归删掉所有的文件和目录，等价于unix下的rm –rf <src>。  
   
10，  
hadoop fs –rmi \[skipTrash\] <src>  
：等价于unix的rm –rfi <src>。  
   
11，  
hadoop fs –put <localsrc>   
…  
 <dst>：从本地系统拷贝文件到DFS  
。  
   
12，  
hadoop fs –copyFromLocal <localsrc>   
…  
 <dst>  
：等价于-put  
。   
13，  
hadoop fs –moveFromLocal <localsrc>   
…  
 <dst>  
：等同于-put，只不过源文件在拷贝后被删除。  
14，  
hadoop fs –get \[-ignoreCrc\] \[-crc\] <src> <localdst>  
：从DFS拷贝文件到本地文件系统，文件匹配pattern，若是多个文件，则dst必须是目录。  
15，  
hadoop fs –getmerge <src> <localdst>  
：顾名思义，从DFS拷贝多个文件、合并排序为一个文件到本地文件系统。  
16，  
hadoop fs –cat <src>  
：展示文件内容。  
17，  
hadoop fs –copyToLocal \[-ignoreCrc\] \[-crc\] <src> <localdst>  
：等价于-get  
。  
18，  
hadoop fs –mkdir <path>  
：在指定位置创建目录。  
   
19，  
hadoop fs –setrep \[-R\] \[-w\] <rep> <path/file>  
：设置文件的备份级别，  
\-R标志控制是否递归设置子目录及文件。  
   
20，  
hadoop fs –chmod \[-R\] <MODE\[,MODE\]  
…  
|OCTALMODE> PATH  
…：修改文件的权限，  
\-R  
标记递归修改。  
MODE为a+r,g-w,+rwx等，  
OCTALMODE为755这样。  
   
21，  
hadoop fs -chown \[-R\] \[OWNER\]\[:\[GROUP\]\] PATH  
…：修改文件的所有者和组。  
\-R表示递归。  
22，  
hadoop fs -chgrp \[-R\] GROUP PATH  
…：等价于  
\-chown   
…  
 :GROUP   
…。  
23，  
hadoop fs –count\[-q\] <path>  
：计数文件个数及所占空间的详情，输出表格的列的含义依次为：  
DIR\_COUNT,FILE\_COUNT,CONTENT\_SIZE,FILE\_NAME  
或者如果加了  
\-q  
的话，还会列出  
QUOTA,REMAINING\_QUOTA,SPACE\_QUOTA,REMAINING\_SPACE\_QUOTA  
。  
转载路径：  
http://www.blogjava.net/changedi/archive/2013/08/12/402696.html    
\[root@node1 bin\]\# ./hadoop fs -ls /      
./hadoop fs -mkdir test    
./hadoop fs -put /opt/test.sh /user      
将本地文件存储至  
hadoop    
./hadoop fs –get /user/t/ok.txt /home/t     
将hadoop上某个文件down至本地已有目录下  
      
./hadoop fs -cat /user/test.sh  
hadoop fs –rmr /user/t     
删除hadoop上指定文件夹（包含子目录等）  
   
hadoop  fs  -touchz  /user/new.txt   
在  
hadoop  
指定目录下新建一个空文件  
   
hadoop  fs  –mv  /user/test.txt  /user/ok.txt   （将test.txt重命名为ok.txt）   
hadoop dfs –getmerge /user /home/t        将hadoop指定目录下所有内容保存为一个文件，同时down至本地  
  
hadoop job –kill  \[job-id\]          
将正在运行的hadoop作业kill掉  
     
java打jar包：  
   
项目  
\-> export ->java -> JAR file ->   
选择导出目录。  
下一步  
./hadoop jar /opt/MapReduceTools.jar mr01.JobRun      
ssh-keygen  -t dsa -P '' -f ~/.ssh/id\_dsa   
cat ~/.ssh/id\_dsa.pub >> ~/.ssh/authorized\_keys   
============================================    
hadoop 2.7.3   
============================================================   
cd /opt/hadoop2.7.3/etc   
vim hadoop-env.sh   
export JAVA\_HOME=$\{JAVA\_HOME\}           
export JAVA\_HOME=/usr/java/jdk1.8.0\_101     
vim  hdfs-site.xml    
vim core-site.xml  
vim slaves   
node2   
node3   
node4    
  
  
启动  
  JournalNode   
cd /opt/hadoop-2.7.3/sbin/   
./hadoop-daemon.sh start journalnode    
./hdfs namenode -format        
在node1上  
   
格式化  
    
cd /opt/2hadoop/dfs/name/current       
原数据文件  
 node1    
./hadoop-daemon.sh  start namenode    node1  
上启动  
namenode    
cd ../logs tail -n100 hadoop-root-namenode-node1.out   
vim /opt/hadoop-2.7.3/logs/hadoop-root-namenode-node1.out    
cd /opt/hadoop-2.7.3/bin/ ./hdfs namenode -bootstrapStandby      node2  
上拷贝  
    
cd /opt/hadoop2/dfs/name/current        node2     
/opt/hadoop-2.7.3/bin ./hdfs zkfc -formatZK        
格式化  
zkfc    
cd /opt/hadoop-2.7.3/sbin/ ./stop-dfs.sh     
cd /opt/hadoop-2.7.3/sbin/ ./start-dfs.sh      
./hdfs dfs -mkdir -p /opt/file    
./hdfs dfs -put /opt/jdk-7u79-linux-x64.rpm   /opt/file     
http://10.0.27.206:50070   Utilities ->Browse Directory   
查看文件大小  
 http://10.0.27.212:50070         
ResourceManager   
启动：  
    
cd  /opt/hadoop-2.7.3/etc/hadoop    
vim mapred-site.xml   
vim yarn-site.xml   
sbin\]\# ./start-yarn.sh           
ResourceManager  nodemanager     
http://10.0.27.206:8088     
eclipse安装hadoop    
  
导包：  
hadoop-2.7.3\\share\\hadoop\\common   
hadoop-2.7.3\\share\\hadoop\\common\\lib   
hadoop-2.7.3\\share\\hadoop\\mapreduce   
hadoop-2.7.3\\share\\hadoop\\yarn   
hadoop-2.7.3\\share\\hadoop\\hdfs      
java打jar包：  
   
项目  
\-> export ->java -> JAR file ->   
选择导出目录。  
下一步   
1003  cd hadoop-2.7.3/bin/    
1006  ./hdfs dfs -mkdir -p /usr/input/hot    
1007  ./hdfs dfs -put data /usr/input/hot    
1016  ./hadoop jar /opt/hadoop2.7.3.jar  com.bjsxt.mr.RunJob     
  
http://10.0.27.212:50070/explorer.html\#/usr/output/hot   
./hdfs dfs -cat /usr/output/hot/part\* |head -n10    
hive     
Hive  
是数据仓库，  
Hive 是解释器，编译器，优化器等。  
hive  
安装：  
https://my.oschina.net/jackieyeah/blog/735424     
apache-hive-2.1.1-bin.tar.gz   
cd /opt/apache-hive-2.1.1-bin/conf/   
cp hive-env.sh.template hive-env.sh   
cp hive-default.xml.template hive-site.xml   
cp hive-log4j2.properties.template hive-log4j2.properties   
cp hive-exec-log4j2.properties.template hive-exec-log4j2.properties    
  
修改  
hive-env.sh    
  
因为Hive 使用了Hadoop, 需要在hive-env.sh 文件中指定Hadoop 安装路径：  
JAVA\_HOME=/opt/java    \#\#Java  
路径  
export    
HADOOP\_HOME=/opt/hadoop   \#\#Hadoop  
安装路径  
   
HIVE\_HOME=/opt/hive    \#\#Hive  
安装路径  
   
HIVE\_CONF\_DIR=/opt/hive/conf    \#\#Hive  
配置文件路径  
    
  
  
创建HDFS目录  
    
在Hive 中创建表之前需要创建以下HDFS 目录并给它们赋相应的权限。  
    
hdfs dfs -mkdir -p /user/hive/warehouse   
hdfs dfs -mkdir -p /user/hive/tmp   
hdfs dfs -mkdir -p /user/hive/log   
hdfs dfs -chmod 777  /user/hive/warehouse   
hdfs dfs -chmod 777  /user/hive/tmp   
hdfs dfs -chmod 777  /user/hive/log   
修改  
hive-site.xml    
  
将  
 hive-site.xml   
文件中以下几个配置项的值设置成上一步中创建的几个路径。  
    
<property>       
<name>hive.exec.scratchdir</name>       
<value>/user/hive/tmp</value>       
<description>HDFS root scratch dir for Hive jobs which gets created with write all (733) permission.   
  
For each connecting user, an HDFS scratch dir: $\{hive.exec.scratchdir\}/<username> is created,   
  
with $\{hive.scratch.dir.permission\}.</description>     
</property>     
<property>       
<name>hive.metastore.warehouse.dir</name>       
<value>/user/hive/warehouse</value>       
<description>location of default database for the warehouse</description>     
</property>  
<property>       
<name>hive.querylog.location</name>       
<value>/user/hive/log</value>       
<description>Location of Hive run time structured log file</description>     
</property>      
  
安装  
mysql   
yum  install  mariadb   mariadb-server  mariadb-devel   
service   mariadb  restart   
mysql   
\----------------   
yum install mysql-server   
service mysqld restart   
\--------------------------      
  
创建数据库和用户  
  
假定你已经安装好MySQL。下面创建一个hive 数据库用来存储 Hive 元数据，且数据库访问的用户名和密码都为hive  
。  
mysql> CREATE DATABASE hive;    
mysql> USE hive;    
mysql> CREATE USER 'hive'@'localhost' IDENTIFIED BY 'hive';   
mysql> GRANT ALL ON hive.\* TO 'hive'@'localhost' IDENTIFIED BY 'hive';    
mysql> GRANT ALL ON hive.\* TO 'hive'@'%' IDENTIFIED BY 'hive';    
mysql> FLUSH PRIVILEGES;    
mysql> quit;      
  
运行  
Hive    
  
在命令行运行  
 hive   
命令时必须保证以下两点：  
    
HDFS   
已经启动。可以使用  
 start-dfs.sh   
脚本来启动  
 HDFS  
。  
MySQL Java   
连接器添加到  
 $HIVE\_HOME/lib   
目录下。我安装时使用的是  
mysql-connector-java-5.1.39.jar  
。  
schematool -dbType mysql -initSchema    
  
要使用  
 Hive CLI  
（  
Hive command line interface  
）  
,   
可以在终端输入以下命令：  
  
hive    
hive> show tables;   
OK    
MariaDB \[(none)\]> use hive;   
MariaDB \[hive\]> show tables;    
hive>create table t\_emp(id int,name string,age int,dept\_name string)row format delimited fields   
  
terminated by ',';   
  
导入数据：  
load  data local inpath '/opt/emp.txt' into table t\_emp;   
hive>select \* from t\_emp;      
\---------------------------------export LANG=zh\_CN.UTF-8    
HQL   
脚本三种方式执行：  
   
1,hive-e  'hql'    
2,hive -f  'hql.file'    
3,hive jdbc   
代码执行脚本  
     
eclipse  创建hive  添加jar包      
C:\\workspace\_eclipse\\apache-hive-2.1.1-bin\\lib    
  
启动  
hiveserver2  
服务：  
   
vim hive-site.xml          
<property>       
<name>hive.server2.thrift.bind.host</name>       
<value>node1</value>   
<description>Bind host on which to run the HiveServer2 Thrift service.</description>     
</property>   
\[root@node1 bin\]\# ./hive --service hiveserver2   
netstat -an|grep 10000    
./beeline   
!connect jdbc:hive2://node1/default    
Error: Could not open client transport with JDBC Uri: jdbc:hive2://node1:-1/default: Cannot open   
  
without port. (state=08S01,code=0)    
hive   
有二种函数：  
UDF ,UDAF    
1,udf:  
输入数据为一条数据，输出数据也为一条数据，  
    
2,udaf:  
输入数据为多条数据，  
count   
聚合函数，  
Avg,min,    
  
计数框架  
Mapper   
mr    
hadoop  
生态系统  
hdfs   hbase   MapReduce    Mahout  Pig  Hive  zookeeper   Flume  Sqoop     
hbase:    
hbase-1.2.5-bin.tar.gz   
vim hbase-env.sh   
export JAVA\_HOME=/usr/java/jdk1.8.0\_101    
vim hbase-site.xml   
vim regionservers  
vim hbase-env.sh   
export HBASE\_MANAGES\_ZK=false    
cp -a /opt/hadoop-2.7.3/etc/hadoop/hdfs-site.xml  .  /opt/hbase-1.2.5/bin   
sh start-hbase.sh    
./hbase-daemon.sh start master    
  
同步时间：  
ntpdate 1.asia.pool.ntp.org service ntpd start    
  
修改给上海时区：  
 cp -f /usr/share/zoneinfo/Asia/Shanghai     /etc/localtime   
\* \*/2 \* \* \* root ntpdate 1.asia.pool.ntp.org;hwclock -w     
http://10.0.27.206:16010/master-status    
./hbase shell    
hbase(main):002:0> create 't\_person','cf1'   
hbase(main):003:0> list hbase(main):004:0> put 't\_person','007','cf1:name','zs'   
hbase(main):005:0> flush 't\_person'    
./hbase hfile -p -f /../../      
anptl

[Center]: /images/20220606/f67c243ea94847a1b0e606aa187d5e35.png
[Center 1]: /images/20220606/2b42d1266f6c4121bdbc8ded788bf238.png
[Center 2]: /images/20220606/e382a3b19846408fa901e3b24923658e.png