目录
联邦机制
虽然HDFS HA解决了“单点故障”问题,但是在系统扩展性、整体性能和隔离性方面仍然存在问题:
(1)系统扩展性方面,元数据存储在NN内存中,受内存上限的制约。
(2)整体性能方面,吞吐量受单个NN的影响。
(3)隔离性方面,一个程序可能会影响其他运行的程序,如一个程序消耗过多资源导致其他程序无法顺利运行。
HDFS HA本质上还是单名称节点。HDFS联邦可以解决以上三个方面问题。
在HDFS联邦中,设计了多个相互独立的NN,使得HDFS的命名服务能够水平扩展,这些NN分别进行各自命名空间和块的管理,不需要彼此协调。每个DN要向集群中所有的NN注册,并周期性的发送心跳信息和块信息,报告自己的状态。
HDFS联邦拥有多个独立的命名空间,其中,每一个命名空间管理属于自己的一组块,这些属于同一个命名空间的块组成一个“块池”。每个DN会为多个块池提供块的存储,块池中的各个块实际上是存储在不同DN中的。
Hadoop租约机制
HDFS文件是write-once-read-many,并且不支持客户端的并行写操作,这就需要一种机制来保证对HDFS文件的互斥操作。租约(Lease)机制是Namenode给予租约持有者在规定时间内拥有写文件权限的合同。每个客户端用户持有一个租约。每个租约内部包含1个租约持有者的信息,还有此租约对应的文件id列表,表示当前租约持有者正在写这些文件id对应的文件。每个租约包含有一个最新的更新时间,最新更新时间将会决定此租约是否过期,过期的租约会导致租约持有者无法继续执行写数据到文件中,除非进行租约的更新。
与租约关系密切的类是LeaseManager类,Lease类,Monitor类以及客户端的LeaseRenewer类,其中Lease类和Monitor类是LeaseManager类的内部类。
LeaseManager是Namenode中维护所有租约操作的类,它主要有三大功能:保存HDFS中所有租约的信息;提供租约的增删改查方法;维护一个Monitor线程定期对超过硬限制时间的文件进行租约恢复。
Lease类即是租约类,它内部有3个字段和一些供LeaseManager管理租约时调用的方法。holder字段代表客户端租约持有者,files字段保存了该租约内的所有文件Id,lastUpdate字段保存了租约的最后更新时间。
Monitor是一个Runnable类,其内部就实现了一个run()方法,调用LeaseManager.checkLeases()方法实现业务逻辑,它的作用是定期对超过硬限制时间的文件进行租约恢复操作。
客户端可以通过LeaseRenewer更新自己的租约。其中有个线程定期检测租约的软限制时间,并调用LeaseRenewer.run()方法对租约过半的lease进行续约。
租约恢复
租约恢复就是将处于构建状态的文件进行租约释放并关闭。以下四种情况会进行租约恢复操作:
(1)Monitor线程
(2)客户端调用recoverLease()方法
(3)appendFile
(4)startFile
第一种情况直接调用internalReleaseLease()方法实现租约恢复,其中参数newHolder为”HDFS_NameNode-时间”;后面三种情况调用recoverLeaseInternal()方法,在recoverLeaseInternal()方法内部调用internalReleaseLease()方法实现租约恢复,第二种情况的参数force为true,newHolder为当前客户端,第三四种情况的参数force为false,newHolder为null。
MapReduce为什么需要排序
MapReduce中需要对数据进行分组,排序的目的是为了对key进行分组,可以说是一种实现方式。如果需要算法或计算逻辑中不需要任何的有序性,那么可以去采用其他更快的分组实现方式,如Hash实现对key的分组。虽然也有并不关心数据是否局部有序的应用场景,但在数据访问和计算中,保证数据有序性是一个必要功能。在通过sort实现数据分组的同时保证了分组内数据有序性,也算是一举两得,并且这样在要求数据有序性的场景中,对局部有序的数据再进行全局排序将会有不少帮助。
Hadoop运行模式
(1)本地模式(默认模式):不需要启用单独进程,直接可以运行,测试和开发时使用
(2)伪分布式模式:等同于完全分布式,只有一个节点
(3)完全分布式模式:多个节点一起运行
伪分布式运行Hadoop 案例
伪分布式模式是在一台单机上运行,但用不同的Java进程模仿分布式运行中的各类结点(NameNode,DataNode,ResourceManager,SecondaryNameNode)
2.1 启动HDFS并运行MapReduce 程序
1)执行步骤
(1)配置集群
(a)配置:hadoop-env.sh
Linux系统中获取jdk的安装路径:
修改JAVA_HOME 路径:
(b)配置:core-site.xml
(c)配置:hdfs-site.xml
(2)启动集群
(a)格式化namenode(第一次启动时格式化,以后就不要总格式化)
(b)启动namenode
(c)启动datanode
(3)查看集群
(a)查看是否启动成功
(b)查看产生的log日志
(c)web端查看HDFS文件系统
(4)操作集群
(a)在hdfs文件系统上创建一个input文件夹
(b)将测试文件内容上传到文件系统上
(c)查看上传的文件是否正确
(d)运行mapreduce程序
(e)查看输出结果
命令行查看:
浏览器查看
浏览器查看.png
(f)将测试文件内容下载到本地
(g)删除输出结果
2.2 YARN上运行MapReduce 程序
1)执行步骤
(1)配置集群
(a)配置yarn-env.sh
配置一下JAVA_HOME
(b)配置yarn-site.xml
(c)配置:mapred-env.sh
配置一下JAVA_HOME
(d)配置: (对mapred-site.xml.template重新命名为) mapred-site.xml
(2)启动集群
(a)启动前必须保证namenode和datanode已经启动
(b)启动resourcemanager
(c)启动nodemanager
(3)集群操作
(a)yarn的浏览器页面查看
http://192.168.1.101:8088/cluster
(b)删除文件系统上的output文件
(c)执行mapreduce程序
(d)查看运行结果
完全分布式
集群部署规划
– | hadoop1 | hadoop2 | hadoop3 |
---|---|---|---|
HDFS | NameNode、DataNode | DataNode | SecondaryNameNode、DataNode |
YARN | NodeManager | ResourceManager、NodeManager | NodeManager |
配置文件
core-site.xml
<!-- 指定 HDFS 中 NameNode 的地址 -->
<property>
<name>fs.defaultFS</name>
<value>hdfs://hadoop132:9000</value>
</property>
<!-- 指定 hadoop 运行时产生文件的存储目录 -->
<property>
<name>hadoop.tmp.dir</name>
<value>/opt/module/hadoop-2.7.2/data/tmp</value>
</property>
hadoop-env.sh
export JAVA_HOME=/opt/module/jdk1.8.0_144
hdfs-site.xml
<configuration>
<property>
<name>dfs.replication</name>
<value>3</value>
</property>
<property>
<name>dfs.namenode.secondary.http-address</name>
<value>hadoop134:50090</value>
</property>
</configuration>
slaves
hadoop132
hadoop133
hadoop134
yarn
yarn-env.sh
export JAVA_HOME=/opt/module/jdk1.8.0_144
yarn-site.xml
<configuration>
<!-- reducer 获取数据的方式 -->
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
<!-- 指定 YARN 的 ResourceManager 的地址 -->
<property>
<name>yarn.resourcemanager.hostname</name>
<value>hadoop133</value>
</property>
</configuration>
mapreduce
mapred-env.sh
export JAVA_HOME=/opt/module/jdk1.8.0_144
mapred-site.xml
<configuration>
<!-- 指定 mr 运行在 yarn 上 -->
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
</configuration>
集群同步以上配置文件
启动集群
如果集群是第一次启动,需要格式化 namenode
$ bin/hdfs namenode -format
$ sbin/start-dfs.sh
第二台机器上启动yarn
$ sbin/start-yarn.sh
Hadoop搭建过程为什么修改IP
让节点机器的ip固定下来,让Hadoop能找到机器,需要进行静态ip配置。
Hadoop搭建过程SSH免密登录有什么作用
在集群中,Hadoop控制脚本依赖SSH来执行针对整个集群的操作。所以,需要安装SSH,但是,SSH远程登陆的时候,需要密码验证,集群中数千台计算机,数千台计算机都需要手工输入密码,这是不太现实的,所以,就需要配置SSH无密码登录。
(0)这里有A、B两台服务器,首先让A生成两个密钥,一个公钥,一个私钥
(1)A携带主机名和用户以及公钥访问公钥B
(2)B接收到A的请求后,把A的公钥去授权列表authorized_keys中核查看看有没有A的公钥,如果没有把A的公钥放进去,然后用A的公钥加密一个随机字符串返回给A
(3)这时A拿到该加密字符串解密成功后携带A的私钥返回给B,这时候B通过去授权列表验证,验证通过返回到A
(4)A就可以免密登录成功
实现免密登录
ssh-genkey是生成密钥的工具,执行完成后生成公钥和密钥,这两个文件会默认保存在~ /.ssh/路径下。直接执行来生成密钥,所有的参数都可以为空,即一直回车确认。此时,生成的文件在~/.ssh/目录下,我们会看到这些文件:
id_rsa // 私钥文件
id_rsa.pub // 公钥文件
authorized_keys // 存放客户端公钥的文件
known_hosts // 确认过公钥指纹的可信服务器列表的文件
config // 指定不同域名使用哪个密钥的配置文件
因为一台机器即能是客户端,又能是服务端,因此同时存在authorized_keys(在该机器为服务端时使用)和Known_hosts(在该机器为客户端时使用)。
我们的服务器会有很多的用户,如果所有的用户都用同一份密钥,可能就没办法划分权限或者区分用户,如多个用户提交git就需要按照用户名来生成密钥,用于区分用户。同时你可能也希望针对不同的服务器使用不同的密钥对,因此需要config配置文件来配置针对不同服务器的配置,这样在连接不同的服务器时,就会使用不同的密钥文件来登录。
在客户端生成密钥对之后,将公钥追加到服务器的authorized_keys文件中即可。此时,即可免密登录服务器。
Hadoop搭建过程为什么关闭防火墙
因为都是内网搭建的,对外还有一个服务器的,那个服务器有防火墙,由它来访问内网集群,如果内网内开启防火墙,内网集群通讯会出现很多问题。
正常的Hadoop集群会启动哪些进程
- NameNode它是Hadoop中的主服务器,管理文件系统名称空间和对集群中存储的文件的访问,保存有metadate
- SecondaryNameNode它不是NameNode的冗余守护进程,而是提供周期检查点和清理任务。帮助NameNode合并editslog,减少NameNode启动时间
- DataNode它负责管理连接到节点的存储(一个集群中可以有多个节点)。每个存储数据的节点运行一个DataNode守护进程
- ResourceManager
- NodeManager
- DFSZKFailoverController高可用时它负责监控NameNode的状态,并及时的把状态信息写入ZooKeeper。它通过一个独立线程周期性的调用NameNode上的一个特定接口来获取NameNode的健康状态
- JournalNode 高可用情况下存放NameNode的editlog文件
用MapReduce实现top10
public class TopNWritable implements WritableComparable<TopNWritable> {
private String word;
private int value;
public TopNWritable(String word, int value) {
this.word = word;
this.value = value;
}
public int compareTo(TopNWritable o) {
int tmp = o.value - this.value; //降序
if(tmp != 0){
return tmp;
}
return this.word.compareTo(o.word);
}
}
public class TopN {
//自定义的mapper类
public static class MyMapper extends Mapper<Object, Text, Text, LongWritable> {
Text k = new Text();
@Override
protected void map(Object key, Text value,Context context) throws IOException, InterruptedException {
String row = value.toString();
String [] words = row.split(" ");
for (String s : words) {
k.set(s);
context.write(k, new LongWritable(1L));
}
}
}
//自定义reducer类
public static class MyReducer extends Reducer<Text, LongWritable, Text, IntWritable> {
IntWritable v = new IntWritable();
final static int N = 3;
TreeSet<TopNWritable> ts = new TreeSet<TopNWritable>();
@Override
protected void reduce(Text key, Iterable<LongWritable> value,Context context) throws IOException, InterruptedException {
int counter = 0;
for (LongWritable i : value) {
counter += i.get();
}
v.set(counter);
TopNWritable tw = new TopNWritable(key.toString(),counter);
ts.add(tw);
if(ts.size() > N){
ts.remove(ts.last());
}
}
@Override
protected void cleanup(Context context) throws IOException, InterruptedException {
for (TopNWritable tn : ts){
context.write(new Text(tn.getWord()), new IntWritable(tn.getValue()));
}
}
}
public static void main(String[] args) {
try {
Configuration conf = new Configuration();
Job job = Job.getInstance(conf, "topN");
job.setJarByClass(TopN.class);
job.setMapperClass(MyMapper.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(LongWritable.class);
job.setReducerClass(MyReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
FileInputFormat.addInputPath(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
int success = job.waitForCompletion(true) ? 0 : 1;
System.exit(success);
} catch (IOException | ClassNotFoundException | InterruptedException e) {
e.printStackTrace();
}
}
}
MapReduce实现矩阵乘法
Cij其实就是A矩阵的第i行和B矩阵的第j列的点积,所以只要能最终将参与计算Cij的所有元素(A矩阵的第i行和B矩阵的第j列)都归到一组来参与计算就能算出Cij。这个所谓的“归到一组”,结合MR模型和矩阵乘法规则,其实就是Map将这些元素输出为相同的Key—C矩阵中元素的坐标,然后通过Shuffle就能把所有相同Key的元素输入到Reduce中,由Reduce来进行点积运算,得出该C元素最终的值。
回到输入数据,即A和B两个矩阵,只需要将矩阵中的每个元素处理一下(该过程需要在Map中进行),根据每一个元素即将参与哪些Cij的计算,为每一个元素打上(i,j)坐标即可,这样最终这些元素就会被shuffle到目标Cij的计算数据源分组中。
具体举例,A12会参与到C11,C12的计算中;B22会参与到C12,C22的计算中。所以,从A和B的元素坐标,就完全可以得知它们即将参与计算的C元素的坐标。通过以上的分析,对于一个i行j列的A矩阵,和j行k列的B矩阵乘法:
我们将每个Aij元素处理为如下格式:
key=i,n(n=1,2,3...k) value='a',j,aij
我们将每个Bjk处理为如下格式:
key= m,k(m=1,2,3...i) value='b',i,bij
A12最终会参与C11,C12的计算,所以我们处理A12时需将其处理为两个{key,value}对:{(1,1),(‘a’ , 2 , 2)} /* (1,1)是A12将参与计算的C11的坐标;'a’代表该数据来自A矩阵,因为A和B需要相乘,所以需要做一个标志位;头一个2代表这是计算C11时对应A向量的坐标,因为要知道A向量的第几个元素和B向量的第几个元素相乘;最后一个2就是当前元素的值 * /。 {(1,2),(‘a’ , 2 , 2)}/ * 参考以上描述 * /
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
public class MapReduceDemo extends Configured implements Tool{
static class DemoMapper extends Mapper<LongWritable,Text,Text,Text>{
private String filename;
private int rownum=2;
private int colnum=2;
private int rowA=1;
private int rowB=1;
protected void setup(Context context)throws IOException,InterruptedException{
InputSplit split=context.getInputSplit();
filename=((FileSplit)split).getPath().getName();
}
protected void map(LongWritable key,Text value,Context context)throws IOException,InterruptedException{
String[] token=value.toString().split(",");
if(filename.equals("A")){
for(int i=1;i<=colnum;++i){
Text k=new Text(rowA+","+i);
for(int j=1;j<=token.length;++j){
Text v=new Text(filename+":"+j+","+token[j-1]);
context.write(k, v);
System.out.println(k.toString()+" "+v.toString());
}
}
++rowA;
}
else if(filename.equals("B")){
for(int i=1;i<=rownum;++i){
for(int j=1;j<=token.length;++j){
Text k=new Text(i+","+j);
Text v=new Text(filename+":"+rowB+","+token[j-1]);
context.write(k, v);
System.out.println(k.toString()+" "+v.toString());
}
}
++rowB;
}
}
}
static class DemoReducer extends Reducer<Text,Text,Text,IntWritable>{
private Map<String,String> mapA=new HashMap<String,String>();
private Map<String,String> mapB=new HashMap<String,String>();
protected void reduce(Text key,Iterable<Text> values,Context context)throws IOException,InterruptedException{
for(Text line:values){
String filename=line.toString().substring(0,1);
if(filename.equals("A")){
mapA.put(line.toString().substring(2,3), line.toString().substring(4));
}else if(filename.equals("B")){
mapB.put(line.toString().substring(2, 3),line.toString().substring(4));
}
}
int result=0;
Iterator<String> it=mapA.keySet().iterator();
while(it.hasNext()){
String mapk=it.next();
result+=Integer.parseInt(mapA.get(mapk))*Integer.parseInt(mapB.get(mapk));
}
context.write(key, new IntWritable(result));
System.out.println();
}
}
public static void main(String[] args) throws Exception {
int exitcode=ToolRunner.run(new MapReduceDemo(), args);
System.exit(exitcode);
}
@Override
public int run(String[] arg0) throws Exception {
Configuration conf=new Configuration();
Job job=new Job(conf);
job.setJarByClass(getClass());
FileInputFormat.setInputPaths(job, new Path(arg0[0]),new Path(arg0[1]));
FileOutputFormat.setOutputPath(job, new Path(arg0[2]));
job.setMapperClass(DemoMapper.class);
job.setReducerClass(DemoReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
return job.waitForCompletion(true)? 1:0;
}
}
MR求共同好友
以下是qq的好友列表数据,冒号前是一个用户,冒号后是该用户的所有好友(数据中的好友关系是单向的)
A:B,C,D,F,E,O
B:A,C,E,K
C:F,A,D,I
D:A,E,F,L
E:B,C,D,M,L
F:A,B,C,D,E,O,M
G:A,C,D,E,F
H:A,C,D,E,O
I:A,O
J:B,O
K:A,C,D
L:D,E,F
M:E,F,G
O:A,H,I,J
https://www.cnblogs.com/songhaowan/p/7239578.html
求出哪些人两两之间有共同好友,及他俩的共同好友都有谁?
解题思路:
第一步
map
读一行 A:B,C,D,F,E,O
输出
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
public class SharedFriendsStepOne {
static class SharedFriendsStepOneMapper extends Mapper<LongWritable, Text, Text, Text>{
@Override
protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
throws IOException, InterruptedException {
//A:B,C,D,F,E,O
// B:A,C,E,K
String line = value.toString();
//每个用户的粉丝列表
String[] person_friends = line.split(":");
String user = person_friends[0];
String friends = person_friends[1];
for (String friend : friends.split(",")) {
//map输出用户的粉丝<粉丝,用户>给reduce
context.write(new Text(friend), new Text(user));
}
}
}
static class SharedFriendsStepOneReducer extends Reducer<Text, Text, Text, Text> {
@Override
protected void reduce(Text friend, Iterable<Text> persons, Context context) throws IOException, InterruptedException {
StringBuffer sb = new StringBuffer();
for (Text person : persons) {
sb.append(person).append(",");
}
context.write(friend, new Text(sb.toString()));
}
}
public static void main(String[] args) throws Exception {
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
job.setJarByClass(SharedFriendsStepOne.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
job.setMapperClass(SharedFriendsStepOneMapper.class);
job.setReducerClass(SharedFriendsStepOneReducer.class);
FileInputFormat.setInputPaths(job, new Path("srcdata/friends"));
FileOutputFormat.setOutputPath(job, new Path("temp/out"));
job.waitForCompletion(true);
}
}
第二步:找出 <人-人,好友> ,这样,相同的“人-人”对的所有好友就会到同1个reduce中去
import java.io.IOException;
import java.util.Arrays;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
public class SharedFriendsStepTwo {
static class SharedFriendsStepTwoMapper extends Mapper<LongWritable, Text, Text, Text> {
// 拿到的数据是上一个步骤的输出结果
// A I,K,C,B,G,F,H,O,D,
// 友 人,人,人
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
String line = value.toString();
String[] friend_persons = line.split("\t");
String friend = friend_persons[0];
String[] persons = friend_persons[1].split(",");
//对用户排序
Arrays.sort(persons);
for (int i = 0; i < persons.length - 1; i++) {
for (int j = i + 1; j < persons.length; j++) {
// 发出 <人-人,好友> ,这样,相同的“人-人”对的所有好友就会到同1个reduce中去
context.write(new Text(persons[i] + "-" + persons[j]), new Text(friend));
}
}
}
}
static class SharedFriendsStepTwoReducer extends Reducer<Text, Text, Text, Text> {
@Override
protected void reduce(Text person_person, Iterable<Text> friends, Context context) throws IOException, InterruptedException {
StringBuffer sb = new StringBuffer();
for (Text friend : friends) {
sb.append(friend).append(" ");
}
context.write(person_person, new Text(sb.toString()));
}
}
public static void main(String[] args) throws Exception {
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
job.setJarByClass(SharedFriendsStepTwo.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
job.setMapperClass(SharedFriendsStepTwoMapper.class);
job.setReducerClass(SharedFriendsStepTwoReducer.class);
FileInputFormat.setInputPaths(job, new Path("/temp/out/part-r-00000"));
FileOutputFormat.setOutputPath(job, new Path("/temp/out2"));
job.waitForCompletion(true);
}
}
MapReduce求二度好友
https://blog.csdn.net/u013926113/article/details/51539306