大数据面试题大全
卡夫卡的消息包括哪些信息
一个卡夫卡的消息由一个固定长度的报头和一个变长的消息体体组成
标题部分由一个字节的魔法（文件格式）和四个字节的CRC32（用于判断身体消息体是否正常）构成。当魔术的值为1的时候，会在魔术和CRC32之间多一个字节的数据：属性（保存一些相关属性，比如是否压缩，压缩格式等等）;如果魔术的值为0时，那么不存在属性属性
文教释义体育的英文由ñ个字节构成的一个消息体，包含了具体的键/值消息
怎么查看卡夫卡的偏移
0.9版本以上，可以用最新的Consumer client客户端，有consumer.seekToEnd（）/ consumer.position（）可以用于得到当前最新的偏移量：
Hadoop的的的洗牌的过程
一，Map端的shuffle
Map端会处理输入数据并产生中间结果，这个中间结果会写到本地磁盘，而不是HDFS。每个地图的输出会先写到内存缓冲区中，当写入的数据达到设定的阈值时，系统将会启动一个线程将缓冲区的数据写到磁盘，这个过程叫做溢出。
在溢出写入之前，会先进行二次排序，首先根据数据所属的分区进行排序，然后每个分区中的数据再按键来排序.partition的目是将记录划分到不同的减速上去，以期望能够达到负载均衡，以后的减速器就会根据分区来读取自己对应的数据。接着运行组合器（如果设置了的话），组合器的本质也是一个减速器，其目的是对将要写入到磁盘上的文件先进行一次处理，这样，写入到磁盘的数据量就会减少。最后将数据写到本地磁盘产生溢出文件（溢出文件保存在{} mapred.local.dir指定的目录中，地图任务结束后就会被 ）。
最后，每个地图的任务可能产生多个溢出文件，在每个地图任务完成前，会通过多路归并算法将这些溢出文件归并成一个文件。至此，地图的洗牌过程就结束了。
二，降低端的洗牌
降低端的洗牌主要包括三个阶段，复印，排序（合并）和减少。
首先要将地图端产生的输出文件拷贝到减少端，但每个减速如何知道自己应该处理哪些数据呢？因为地图端进行分区的时候，实际上就相当于指定了每个减速要处理的数据（分区就对应了减速），所以减速器在拷贝数据的时候只需拷贝与自己对应的分区中的数据即可。每个减速会处理一个或者多个分区，但需要先将自己对应的分区中的数据从每个地图的输出结果中拷贝过来。
接下来就是排序阶段，也成为合并阶段，因为这个阶段的主要工作是执行了归并排序。从地图端拷贝到减少端的数据都是有序的，所以很适合归并排序。最终在降低端生成一个较大的文件作为降低的输入。
最后就是降低过程了，在这个过程中产生了最终的输出结果，并将其写到HDFS上。
火花集群运算的模式
星火有很多种模式，最简单就是单机本地模式，还有单机特分布式模式，复杂的则运行在集群中，目前能很好的运行在纱线和Mesos中，当然星火还有自带的独立模式，对于大多数情况Standalone模式就足够了，如果企业已经有Yarn或者Mesos环境，也是很方便部署的
.standalone（集群模式）：典型的Mater / slave模式，不过也能看出Master是有单点故障的; Spark支持ZooKeeper来实现HA
on yarn（集群模式）：运行在纱资源管理器框架之上，由yarn负责资源管理，Spark负责任务调度和计算
on mesos（集群模式）：运行在mesos资源管理器框架之上，由mesos负责资源管理，星火负责任务调度和计算
on cloud（集群模式）：比如AWS的EC2，使用这个模式能很方便的访问亚马逊的S3; 星火支持多种分布式存储系统：HDFS和S3
HDFS读写数据的过程
读取：
1，跟着namenode通信查询元数据，找到文件块所在的datanode服务器
2，挑选一台datanode（就近原则，然后随机）服务器，请求建立socket flow
3，datanode开始发送数据（从磁盘里面读取数据放入流，以包为单位来做校验）
4，客户端以包为单位接收，现在本地缓存，然后写入目标文件
写：
1，根namenode通信请求上传文件，namenode检查目标文件是否已存在，父目录是否存在
2，namenode返回是否可以上传
3，client请求第一个块该传输到哪些datanode服务器上
4，namenode返回3个datanode服务器ABC
5，client请求3台dn中的一台A上传数据（本质上是一个RPC调用，建立管道），A收到请求会继续调用B，然后乙调用C，将真个管道建立完成，逐级返回客户端
6，客户端开始往甲上传第一个块（先从磁盘读取数据放到一个本地内存缓存），以分组为单位，A收到一个数据包就会传给B，B传 ç一个每传一个数据包会放入一个应答队列等待应答
如图7所示，当一个块传输完成之后，客户端再次请求名称节点上传第二个块的服务器。
RDD中reduceBykey与groupByKey哪个性能好，为什么
reduceByKey：reduceByKey会在结果发送至减速器之前会对每个映射器在本地进行合并，有点类似于在MapReduce的的的中的组合这样做的好处在于，在地图端进行一次降低之后，数据量会大幅度减小，从而减小传输，保证减少端能够更快的进行结果计算。
.groupByKey：groupByKey会对每一个RDD中的值值进行聚合形成一个序列（迭代），此操作发生在减少端，所以势必会将所有的数据通过网络进行传输，造成不必要的浪费。同时如果数据量十分大，可能还会造成的的OutOfMemoryError错误。
通过以上对比可以发现在进行大量数据的减少操作时候建议使用reduceByKey不仅。可以提高速度，还是可以防止使用groupByKey造成的内存溢出问题。
spark sql怎么取数据的差集
好像不支持
spark2.0的了解
更简单：ANSI SQL与更合理的API
速度更快：用Spark作为编译器
更智能：Structured Streaming
RDD怎么分区宽依赖和窄依赖
宽依赖：父RDD的分区被子RDD的多个分区使用例如groupByKey，reduceByKey，sortByKey等操作会产生宽依赖，会产生洗牌
窄依赖：父RDD的每个分区都只被子RDD的一个分区使用例如地图，过滤器，工会等操作会产生窄依赖
火花流读取卡夫卡数据的两种方式
这两种方式分别是：
接收器-基
。使用卡夫卡的高层次消费者API来实现。接收机从卡夫卡中获取的数据都存储在火花执行人的内存中，然后火花流启动的工作会去处理那些数据然而，在默认的配置下，这种方式可能会因为底层的失败而丢失数据。如果要启用高可靠机制，让数据零丢失，就必须启用Spark Streaming的预写日志机制（Write Ahead Log，WAL）。机制会同步地将接收到的卡夫卡数据写入分布式文件系统（比如HDFS）上的预写日志中。所以，即使底层节点出现了失败，也可以使用预写日志中的数据进行恢复。
直接
Spark1 0.3中引入直接方式，用来替代掉使用接收器接收数据，这种方式会周期性地查询卡夫卡，获得每个主题+分区的最新的偏移量，从而定义每个批次的偏移的范围。当处理数据的工作启动时，就会使用卡夫卡的简单消费者API来获取卡夫卡指定偏移 围的数。
卡夫卡的数据存在内存还是磁盘
卡夫卡最核心的思想是使用磁盘，而不是使用内存，可能所有人都会认为，内存的速度一定比磁盘快，我也不例外。在看了卡夫卡的设计思想，查阅了相应资料再加上自己的测试后，发现磁盘的顺序读写速度和内存持平。
而且Linux的的的对于磁盘的读写优化也比较多，包括预读和后写，磁盘缓存等。如果在内存做这些操作的时候，一个是JAVA对象的内存开销很大，另一个是随着堆内存数据的增多，JAVA的GC时间会变得很长，使用磁盘操作有以下几个好处：
磁盘缓存由Linux的的的系统维护，减少了程序员的JVM的GC效率低，内存占用大，使用磁盘可以避免这一问题。系统冷启动后，磁盘缓存依然可用。
不少工作。磁盘顺序读写速度超过内存随机读写。
怎么解决卡夫卡的数据丢失
生产端：
宏观上看保证数据的可靠安全性，肯定是依据分区数做好数据备份，设立副本数。
券商端：
主题设置多分区，分区自适应所在机器，为了让各分区均匀分布在所在的券商中，分区数要大于经纪人数。
分区是卡夫卡进行并行读写的单位，是提升卡夫卡速度的关键。
消费者端的的
消费者端的的丢失消息的情形比较简单：如果在消息处理完成前就提交了偏移，那么就有可能造成数据的丢失。由于卡夫卡消费者默认是自动提交位移的，所以在后台提交位移前一定要保证消息被正常处理了，因此不建议采用很重的处理逻辑，如果处理耗时很长，则建议把逻辑放到另一个线程中去做为了避免数据丢失，现给出两点建议：
enable.auto.commit =假自动关闭提交位移
在消息被完整处理之后再手动提交位移
1.简述大数据的生态组件
参考链接：
http://wenku.baidu.com/link?url=OYTVLe1e5zvBn8CBy4TSmoRkg4See5GEoX8h8bHcwGBsMKeJCiet7Pr7G_hrc6Q-SHZwMWU0fDrcufpatVgIPfsYgsX3FS1doMI0G4iJoE50A9rJmh2wSc3BYcx_6SBJ
2.简要描述如何配置一个的阿帕奇的的hadoop的分布式
http://www.cnblogs.com/juncaoit/p/5874568.html
注意点：JDK的安装
3.mapreduce的原理
“地图（映射）”和“减约（归约），以及中间的洗牌过程
可以分成5个部分来讲解
4.讲述组合器与分区的作用
结合的作用是映射端的减少聚合
分区的作用是分区，知道关键到哪一个减少
5.讲述的hadoop的怎么实现二次排序
讲键与值进行合并来形成新的键，定义新的数据类型
6.hadoop启动的进程，以及作用
HDFS
纱
历史
7.hdfs的数据压缩算法
参考链接：
http://blog.csdn.net/yangbutao/article/details/8474731
8.使用MapReduce的的处理数据倾斜？
map / reduce程序执行时，减少节点大部分执行完毕，但是有一个或者几个减少节点运行很慢，导致整个程序的处理时间很长，这是因为某一个key的条数比其他key多很多（有时是百倍或者千倍之多），这条关键所在的减少节点所处理的数据量比其他节点就大很多，从而导致某几个节点迟迟运行不完，此称之为数据倾斜。
可以进行二次排序。（........）
9.datanode什么情况下不会进行备份
在配置文件中数据节点的数量设置为1时
10.hdfs的体系结构
11.介绍/等下的配置文件
/ etc / sysconfig / network修改主机名
/ etc / hosts网络的修改
/ etc / sysconfig / network-scripts / ifcfg-eth0网关的修改
/ etc / sysconfig / selinux权限的修改
/etc/ntp.conf中同步时间
12.描述的Hadoop的中哪些地方使用了缓存技术，作用分别是什么？
洗牌中
13.请随意使用各种类型的脚本语言实现：批量将指定目录下的所有文件中的$ HADOOP_HOME $替换成/家庭/ ocetl /应用/ Hadoop的
find / home / ocetl / app / hadoop -exec sed -i's / \ $ HADOOP_HOME \ $ / \ / home \ / ocetl \ / app \ / hadoop / g'{} \;
14.Yarn中运行应用程序的基本流程
15.hdfs的存储机制
HDFS主要是一个分布式的文件存储系统，由名称节点来接收用户的操作请求，然后根据文件大小，以及定义的块块的大小，将大的文件切分成多个块块来进行保存。
在HDFS中，文件的读写过程就是客户端和的的NameNode以及DataNode会会一起交互的过程。我们已经知道的NameNode的管理着文件系统的元数据，数据节点存储的是实际的数据，那么客户就会联系的的NameNode以获取文件的元数据，而真正的文件读取操作是直接和DataNode会会进行交互的。
参考链接：
http://www.2cto.com/database/201412/357371.html
16.mapreduce中创建DataWritable的作用是什么？
17.实现TOP10
http://blog.csdn.net/mylittlered/article/details/43272013
18.mapreduce开发中使用过哪些算法
单词统计PV
数据去重紫外线
TOPN最受欢迎的排序
19.map中如何调用减少的？
一，大数据面试要准备一些应试须知：
1，让面试官记住你的名字。很多人在介绍自己名字的时候仅仅仅有简单的一句“，我就某某某”，直到你的自我介绍完毕，面试官也没有记住你的名字，如果后续的自我介绍中没有突出的表现，那么这样的自我介绍注定是失败的
.2，告诉面试官和应聘职位相关的工作经历。在自我介绍自己的工作经历时，一定要注意哪些经历是和应聘职位相关，对应聘有帮助，哪些是毫无意义的。例如应聘技术人员的职位，我们主要讲从事本职工作的经历，如果有从事其他行业的经历，比如从事过销售，组织，管理工作的，也可以略微提一下，往往会对应聘起到一定的帮助
.3，在面试官面前展现性格阳光的一面。性格也是面试官需要考察的一项，一般来说活泼，外向的性格始终会受到大家的亲睐，所以我们在面试官面前一定要展示性格阳光的一面，使内向，也不能表现出来。
4，简单的介绍一下自己的未来规划。未来规划这一项是为了告诉面试官，我是一个有计划，有目标，有理想的人，我参加面试是因为我对这份工作比较热爱，而不是为了混口饭吃而应聘这项工作。很多老板最怕找到以混日子为目的的员工
.5，注意扬长避短。扬长避短也就是说在面试时尽量选择自己好的方面来说，只说自己的优点，避免谈及自己的缺点。从人性的角度来讲，人们总是对负面的新闻感兴趣，因此在面试时，面试官会千方百计的发现你的缺点，你的弱项，如果我们主动将缺点暴露给对方，那么产生的影响往往是负面的。
细节决定成败，一个简单的自我介绍虽然只有短短的几分钟，但是其内容却包罗万象，因此在面试时自我介绍的完美与否是举足轻重的。
二，大数据面试要准备一些常见的面试题：
？1，你会的Java语言吗熟悉到什么 度？
2，你最喜欢的编程语言是什么？为什么？
3，处理过的最大的数据量？你是如何处理他们的？处理的结果如何
.2，在处理大数据过程中，如何保证得到期望值？
3，如何让一个网络爬虫速度更快，抽取更好的信息以及更好总结数据从而得到一干净的数据库？
4，点击流数据应该是实时处理？为什么？哪部分应该实时处理？
6，如何把非结构化的数据转换成结构化的数据？这是否真的有必要做这样的转换？把数据存成平面文本文件是否比存成关系数据库
更好？7，如何判别mapreduce过程有好的负载均衡？什么是负载均衡？
8，Spark和Hive的区别，以及Spark和Hive的数据倾斜调优问题？
9，Hive和Hbase的区别？
10，MapReduce的思想，以及MapReduce调优问题？
11，你所了解的开源网站？
12，有两个集群，每个集群有3个节点，使用蜂巢分析相同的数据，SQL语句完全一样，一个集群的分析结果比另外一个慢的多，给 造成这种现象的可能原因？
13，HBASE的优化？
14，集群的版本，以及集群的瓶颈问题？
15，CRM项目，怎么跟火花结合？
16，如何创建一个关键字分类？
17，海量日志数据，提取出某某访问百度次数最多的那个IP？
18，
有一个1G大小的一个文件，里面每一是一个词，词的大小不超过16字节，内存大小限制大小1M，返回频率最高的50个词。
20，你是如何处理缺少数据的？你是推荐使用什么样的处理技术，或者说你是用什么样的技术处理呢？
JAVA相关
1-1）List 与set 的区别？
老掉牙的问题了，还在这里老生常谈：List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复。
1-2）数据库的三大范式？
原子性、一致性、唯一性
1-3）java 的io类的图解
1-4）对象与引用对象的区别
对象就是好没有初始化的对象，引用对象即使对这个对象进行了初始化，这个初始化可以使自己的直接new的也可以是直接其他的赋值的，那么背new或者背其他赋值的我们叫做是引用对象，最大的区别于
1-5）谈谈你对反射机制的理解及其用途？
反射有三种获取的方式，分别是：forName / getClass / 直接使用class方式 使用反射可以获取类的实例
1-6）列出至少五种设计模式
设计方式有工厂法，懒加载，观察者模式，静态工厂，迭代器模式，外观模式、、、、
1-7）RPC 原理？
Rpc分为同步调用和一部调用，异步与同步的区别在于是否等待服务器端的返回值。Rpc的组件有RpcServer,RpcClick,RpcProxy,RpcConnection,RpcChannel,RpcProtocol,RpcInvoker等组件，
1-8）ArrayList、Vector、LinkedList 的区别及其优缺点？HashMap、HashTable 的区别及优缺点？
ArrayList 和 Vector 是采用数组方式存储数据的,是根据索引来访问元素的，都可以
根据需要自动扩展内部数据长度，以便增加和插入元素，都允许直接序号索引元素，但
是插入数据要涉及到数组元素移动等内存操作，所以索引数据快插入数据慢，他们最大
的区别就是 synchronized 同步的使用。
LinkedList 使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但
是插入数据时只需要记录本项的前后项即可，所以插入数度较快！
如果只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用 Vector
或 ArrayList 都可以。如果是对其它指定位置的插入、删除操作，最好选择 LinkedList
HashMap、HashTable 的区别及其优缺点：
HashTable 中的方法是同步的 HashMap 的方法在缺省情况下是非同步的 因此在多线程环境下需要做额外的同步机制。
HashTable 不允许有 null 值 key 和 value 都不允许，而 HashMap 允许有 null 值 key和 value 都允许 因此 HashMap 使用 containKey（）来判断是否存在某个键。
HashTable 使用 Enumeration ，而 HashMap 使用 iterator。
Hashtable 是 Dictionary 的子类，HashMap 是 Map 接口的一个实现类。
1-9）使用 StringBuffer 而不是 String
当需要对字符串进行操作时，使用 StringBuffer 而不是 String，String 是 read-only 的，如果对它进行修改，会产生临时对象，而 StringBuffer 是可修改的，不会产生临时对象。
1-10）集合的扩充
ArrayList list = new ArrayList(90000); list扩充多少次？？
public ArrayList() {
this(10);
}
默认的扩充是10由此计算
1-11）java的拆包与封包的问题
System.out.println("5" + 2);
52
1-12）Java中Class.forName和ClassLoader.loadClass的区别
Class.forName("xx.xx")等同于Class.forName("xx.xx",true,CALLClass.class.getClassLoader())，第二个参数(bool)表示装载类的时候是否初始化该类，即调用类的静态块的语句及初始化静态成员变量。
ClassLoader loader = Thread.currentThread.getContextClassLoader(); //也可以用(ClassLoader.getSystemClassLoader())
Class cls = loader.loadClass("xx.xx"); //这句话没有执行初始化
forName可以控制是否初始化类，而loadClass加载时是没有初始化的。
1-13）hashMap与hashTable的区别
HashMap Hashtable
父类 AbstractMap Dictiionary
是否同步 否 是
k，v可否null 是 否
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
1-14）怎样实现数组的反转
ArrayList arrayList = new ArrayList();
arrayList.add("A");
arrayList.add("B");
对数组进行反转
Collections.reverse(arrayList);
1-15）请使用JAVA实现二分查找
一般的面试者都是些向看看你的思路，所以一般答题时只需要把思路写出来即可。
具体的实现如下：
二分查找就是折半查找，要想折半就必须把原来的数据进行排序，才能方便的查找：
实现代码如下：
public static int binarySearch(int[] srcArray, int des){
int low = 0;
int high = srcArray.length-1;
while(low <= high) {
int middle = (low + high)/2;
if(des == srcArray[middle]) {
return middle;
}else if(des high = middle - 1; }else { low = middle + 1; } } return -1; } 可以使用join关键字 hashmap hashtable 的醉的的区别在于hashtable 是线程安全的，而hashmap 不是线程安全的，currentHashMap也是线程安全的。 ConcurrentHashMap是使用了锁分段技术技术来保证线程安全的。所分段的技术是：讲数据分成一段一段的储存，给每一段的数据添加一把锁，当线程访问一个数据时，其他的数据可以被访问。 1、程序在运行时会产生很多的对象的信息，当这些对象的信息没有用时，则会被gc回收 2、调优的方式主要是调节年轻代与老年代的内存的大小 3、OOM是OutOfMemory的缩写(搞得跟多高大上似的)就是线程创建的多了，没有及时的回收过来所产生的，代码如下： public class JavaVMStackOOM { private void dontStop() { while (true) { } } public void stackLeakByThread() { while (true) { Thread thread = new Thread(new Runnable() { @Override public void run() { dontStop(); } }); thread.start(); } } public static void main(String[] args) { JavaVMStackOOM oom = new JavaVMStackOOM(); oom.stackLeakByThread(); } 4、既然知道以上的现象，在写代码时应该注意，不要过多的创建线程的数目。 A、使用ntsysv命令查看开启与关闭的服务 B、停止打印服务 [root@hadoop1 /]# /etc/init.d/cups stop [root@hadoop1 /]# chkconfig cups off [root@hadoop1 /]# vim /etc/modprobe.conf 在下面添加一下配置： alias net-pf-10 off alias ipv6 off 查看当前的文件的数量：[root@hadoop1 /]#ulimit -a 修改配置： * soft nofile 65535 * hard nofile 65535 * soft nproc 65535 * hard nproc 65535 [root@hadoop1 /]# vi /etc/sysctl.conf 在文本的最后追加一下内容： net.core.somaxconn = 32768 表示物理内存使用到 90%（100-10=90）的时候才使用 swap 交换区 在最后追加一下内容 /dev/sda2 /data ext3 noatime,nodiratime 0 0 Scp -r /user/local hadoop2:/user/local [root@hadoop1 ~]# echo 1+1 && echo "1+1" 1+1 1+1 [root@hadoop1 ~]# echo 1+1 && echo "1+1" && echo "1+" 1 1+1 1+1 1+ 1 [root@hadoop1 test]# find .| grep -ri "a" a.text:a 后半句没有写出来，有时间在搞 Top 命令 1、客户端向 nameNode 发送要上传文件的请求 2、nameNode 返回给用户是否能上传数据的状态 3、加入用户端需要上传一个 1024M 的文件，客户端会通过 Rpc 请求 NameNode，并返回需要上传给那些DataNode(分配机器的距离以及空间的大小等),namonode会选择就近原则分配机器。 4、客户端请求建立 block 传输管道 chnnel 上传数据 5、在上传是 datanode 会与其他的机器建立连接并把数据块传送到其他的机器上 6、dataNode 向 namenode 汇报自己的储存情况以及自己的信息 7、档第一个快上传完后再去执行其他的复制的传送 1、当执行mr程序是，会执行一个Job 2、客户端的jobClick会请求namenode的jobTracker要执行任务 3、jobClick会去HDFS端复制作业的资源文件 4、客户端的jobClick会向namenode提交作业,让namenode做准备 5、Namenode的jobTracker会去初始化创建的对象 6、Namenode会获取hdfs的划分的分区 7、Namenode去检查TaskTracker的心跳信息，查看存活的机器 8、当执行的datenode执行任务时Datenode会去HDFS获取作业的资源的文件 9、TaskTracker会去执行代码，并登陆JVM的执行渠道 10、JVM或执行MapTask或者ReduceTask 11、执行终结 这是linux上的知识，只需要在IF[ -f ] 括号中加上-f参数即可判断文件是否存在 大家都知道namenode与secondary namenode 的关系，当他们要进行数据同步时叫做checkpoint时就用到了fsimage与edit，fsimage是保存最新的元数据的信息，当fsimage数据到一定的大小事会去生成一个新的文件来保存元数据的信息，这个新的文件就是edit，edit会回滚最新的数据。 不管是hadoop1.x 还是hadoop2.x 都是默认的保存三份，可以通过参数dfs.replication就行修改，副本的数目要根据机器的个数来确定。 Core-site.xml 文件的优化 fs.trash.interval 默认值： 0 说明： 这个是开启hdfs文件删除自动转移到垃圾箱的选项，值为垃圾箱文件清除时间。一般开启这个会比较好，以防错误删除重要文件。单位是分钟。 dfs.namenode.handler.count 默认值：10 说明：hadoop系统里启动的任务线程数，这里改为40，同样可以尝试该值大小对效率的影响变化进行最合适的值的设定。 mapreduce.tasktracker.http.threads 默认值：40 说明：map和reduce是通过http进行数据传输的，这个是设置传输的并行线程数。 数据的倾斜主要是两个的数据相差的数量不在一个级别上，在只想任务时就造成了数据的倾斜，可以通过分区的方法减少reduce数据倾斜性能的方法，例如;抽样和范围的分区、自定义分区、数据大小倾斜的自定义侧咯 1.创建 hadoop 帐户。 2.setup.改 IP。 3.安装 java，并修改/etc/profile 文件，配置 java 的环境变量。 4.修改 Host 文件域名。 5.安装 SSH，配置无密钥通信。 6.解压 hadoop。 7.配置 conf 文件下 hadoop-env.sh、core-site.sh、mapre-site.sh、hdfs-site.sh。 8.配置 hadoop 的环境变量。 9.Hadoop namenode -format 10.Start-all.sh Namenode:负责管理元数据的信息 SecondName:做namenode冷备份，对于namenode的机器当掉后能快速切换到制定的Secondname上 DateNode:主要做储存数据的。 JobTracker:管理任务，并把任务分配到taskTasker TaskTracker：执行任务的 1、执行hadoop job -list 拿到job-id 2、Hadoop job kill hadoop-id Hadoop-daemon.sh start datanode 开发mapReduce只用过java与hive,不过使用java开发mapreduce显得笨拙，效率也慢，基于java慢的原因于是hive，这样就方便了查询与设计 Hadoop 常用的jion有reduce side join , map side join , SemiJoin 不过reduce side join 与 map side join 比较常用，不过都是比较耗时的。 combine和partition都是函数，中间的步骤应该只有shuffle！ combine分为map端和reduce端，作用是把同一个key的键值对合并在一起，可以自定义的,partition是分割map每个节点的结果，按照key分别映射给不同的reduce，也是可以自定义的。这里其实可以理解归类。 Hadoop 的压缩算法有很多，其中比较常用的就是gzip算法与bzip2算法，都可以可通过CompressionCodec来实现 Hadoop 的调度有三种其中fifo的调度hadoop的默认的，这种方式是按照作业的优先级的高低与到达时间的先后执行的，还有公平调度器：名字见起意就是分配用户的公平获取共享集群呗!容量调度器:让程序都能货到执行的能力，在队列中获得资源。 输出的数据量还不是取决于map端给他的数据量，没有数据reduce也没法运算啊!! Hadoop保存的三个副本如果不算备份的话，那就是在正常运行的情况下不会备份，也是就是在设置副本为1的时候不会备份，说白了就是单台机器呗！！还有datanode 在强制关闭或者非正常断电不会备份。 Hadoop的map过程，根据意思就知道结合的意思吗，剩下的你们就懂了。想想wordcound HDFS有 namenode、secondraynamenode、datanode 组成。 namenode 负责管理 datanode 和记录元数据 secondraynamenode 负责合并日志 datanode 负责存储数据 Flush 就是把数据落到磁盘，把数据保存起来呗! 队列的实现是链表，消费的顺序是先进先出。 第一不会给储存带来影响，因为有其他的副本保存着，不过建议尽快修复，第二会影响运算的效率，机器少了，reduce在保存数据时选择就少了，一个数据的块就大了所以就会慢。 首先map端会Text 接受到来自的数据，text可以把数据进行操作，最后通过context把key与value写入到下一步进行计算，一般的reduce接受的value是个集合可以运算，最后再通过context把数据持久化出来。 · Cloudera manager · Tarball · Yum · Rpm http://blog.csdn.net/jiangheng0535/article/details/16800415 看图说话 数据块会优先储存在离namenode进的机器或者说成离namenode机架近的机器上，正好是验证了那句话不走网络就不走网络，不用磁盘就不用磁盘。 这样减少了namenode的处理能力，数据的元数据保存在namenode上，如果在网络不好的情况下会增到datanode的储存速度。可以根据自己的网络来设置大小。 这样处理是不合理的，因为那么 namenode 格式化操作，是对文件系统进行格式 化，namenode 格式化时清空 dfs/name 下空两个目录下的所有文件，之后，会在目 录 dfs.name.dir 下创建文件。 文本不兼容，有可能时 namenode 与 datanode 的 数据里的 namespaceID、 clusterID 不一致，找到两个 ID 位置，修改为一样即可解决。 提示：指的是用其它语言处理 一个 MapReduce 作业由 Map 阶段和 Reduce 阶段两部分组成，这两阶段会对数 据排序，从这个意义上说，MapReduce 框架本质就是一个 Distributed Sort。在 Map 阶段，在 Map 阶段，Map Task 会在本地磁盘输出一个按照 key 排序（采用的是快速 排序）的文件（中间可能产生多个文件，但最终会合并成一个），在 Reduce 阶段，每 个 Reduce Task 会对收到的数据排序，这样，数据便按照 Key 分成了若干组，之后以 组为单位交给 reduce（）处理。很多人的误解在 Map 阶段，如果不使用 Combiner 便不会排序，这是错误的，不管你用不用 Combiner，Map Task 均会对产生的数据排 序（如果没有 Reduce Task，则不会排序，实际上 Map 阶段的排序就是为了减轻 Reduce 端排序负载）。由于这些排序是 MapReduce 自动完成的，用户无法控制，因此，在 hadoop 1.x 中无法避免，也不可以关闭，但 hadoop2.x 是可以关闭的。 Shuffer是一个过程，实在map端到reduce在调reduce数据之前都叫shuffer,主要是分区与排序，也就是内部的缓存分分区以及分发（是reduce来拉数据的）和传输 1、优化的思路可以从配置文件和系统以及代码的设计思路来优化 2、配置文件的优化：调节适当的参数，在调参数时要进行测试 3、代码的优化：combiner的个数尽量与reduce的个数相同，数据的类型保持一致，可以减少拆包与封包的进度 4、系统的优化：可以设置linux系统打开最大的文件数预计网络的带宽MTU的配置 5、为 job 添加一个 Combiner，可以大大的减少shuffer阶段的maoTask拷贝过来给远程的 reduce task的数据量，一般而言combiner与reduce相同。 6、在开发中尽量使用stringBuffer而不是string，string的模式是read-only的，如果对它进行修改，会产生临时的对象，二stringBuffer是可修改的，不会产生临时对象。 7、修改一下配置： 一下是修改 mapred-site.xml 文件 修改最大槽位数 槽位数是在各个 tasktracker 上的 mapred-site.xml 上设置的，默认都是 2 task 的最大数 ducetask 的最大数 调整心跳间隔 集群规模小于 300 时，心跳间隔为 300 毫秒 mapreduce.jobtracker.heartbeat.interval.min 心跳时间 北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090 mapred.heartbeats.in.second 集群每增加多少节点，时间增加下面的值 mapreduce.jobtracker.heartbeat.scaling.factor 集群每增加上面的个数，心跳增多少 启动带外心跳 mapreduce.tasktracker.outofband.heartbeat 默认是 false 配置多块磁盘 mapreduce.local.dir 配置 RPC hander 数目 mapred.job.tracker.handler.count 默认是 10，可以改成 50，根据机器的能力 配置 HTTP 线程数目 tasktracker.http.threads 默认是 40，可以改成 100 根据机器的能力 选择合适的压缩方式 以 snappy 为例： 这个 datanode 的数据会在其他的 datanode 上重新做备份。 在mapreduce中map是有块的大小来决定的，reduce的数量可以按照用户的业务来配置。 给定a、b两个文件，各存放50亿个url，每个url各占用64字节，内存限制是4G，如何找出a、b文件共同的url？ 主要的思想是把文件分开进行计算，在对每个文件进行对比，得出相同的URL,因为以上说是含有相同的URL所以不用考虑数据倾斜的问题。详细的解题思路为： 可以估计每个文件的大小为5G*64=300G，远大于4G。所以不可能将其完全加载到内存中处理。考虑采取分而治之的方法。 map的数量通常是由hadoop集群的DFS块大小确定的，也就是输入文件的总块数，reduce端是复制map端的数据，相对于map端的任务，reduce节点资源是相对于比较缺少的，同时运行的速度会变慢，争取的任务的个数应该是0.95过着1.75。 1、hadoop的序列化(sequencefile)是一二进制的形式来保存的 2、Java的序列化是讲对象的内容进行流化 3、实现序列化需要实现Serializable接口便可以了 Hadoop2与hadoop1最大的区别在于HDFS的架构与mapreduce的很大的区别，而且速度上有很大的提升，hadoop2最主要的两个变化是：namenode可以集群的部署了，hadoop2中的mapreduce中的jobTracker中的资源调度器与生命周期管理拆分成两个独立的组件，并命名为YARN YARN是hadoop2.x之后才出的，主要是hadoop的HA(也就是集群)，磁盘的容错，资源调度器 实现两个表的join首先在map端需要把表标示一下，把其中的一个表打标签，到reduce端再进行笛卡尔积的运算，就是reduce进行的实际的链接操作。 Hadoop默认的是HashPartitioner排序，当map端一个文件非常大另外一个文件非常小时就会产生资源的分配不均匀，既可以使用setPartitionerClass来设置分区，即形成了二次分区。 发生在两个阶段即使map与reduce阶段 Mapreduce的shuffer是出在map task到reduce task的这段过程中，首先会进入到copy过程，会通过http方式请求map task所在的task Tracker获取map task 的输出的文件，因此当map task结束，这些文件就会落到磁盘中，merge实在map端的动作，只是在map拷贝过来的数值，会放到内存缓冲区中，给shuffer使用，reduce阶段，不断的merge后最终会把文件放到磁盘中。 Mapreduce中的Combiner就是为了避免map任务和reduce任务之间的数据传输而设置的，Hadoop允许用户针对map task的输出指定一个合并函数。即为了减少传输到Reduce中的数据量。它主要是为了削减Mapper的输出从而减少网络带宽和Reducer之上的负载。 在数据量较少时不宜使用。 3-47） 随着大数据的快速发展，多机器的协调工作，避免主要机器单点故障的问题，于是就引入管理机器的一个软件，他就是zookeeper来协助机器正常的运行。 Zookeeper有两个角色分别是leader与follower ，其中leader是主节点，其他的是副节点，在安装配置上一定要注意配置奇数个的机器上，便于zookeeper快速切换选举其他的机器。 在其他的软件执行任务时在zookeeper注册时会在zookeeper下生成相对应的目录，以便zookeeper去管理机器。 主要是配置文件zoo.cfg 配置dataDir 的路径一句dataLogDir 的路径以及myid的配置以及server的配置，心跳端口与选举端口 保存元数据的方式有：内存数据库rerdy，本地mysql数据库，远程mysql数据库，但是本地的mysql数据用的比较多，因为本地读写速度都比较快 先来说下Hive中内部表与外部表的区别： Hive 创建内部表时，会将数据移动到数据仓库指向的路径；若创建外部表，仅记录数据所在的路径，不对数据的位置做任何改变。在删除表的时候，内部表的元数据和数据会被一起删除，而外部表只删除元数据，不删除数据。这样外部表相对来说更加安全些，数据组织也更加灵活，方便共享源数据。 UDF: user defined function 的缩写，编写hive udf的两种方式extends UDF 重写evaluate第二种extends GenericUDF重写initialize、getDisplayString、evaluate方法 order by 会对输入做全局排序，因此只有一个reducer（多个reducer无法保证全局有序）只有一个reducer，会导致当输入规模较大时，需要较长的计算时间。 sort by不是全局排序，其在数据进入reducer前完成排序. 因此，如果用sort by进行排序，并且设置mapred.reduce.tasks>1， 则sort by只保证每个reducer的输出有序，不保证全局有序。 1、Hive有内存数据库derby数据库，特点是保存数据小，不稳定 2、mysql数据库，储存方式可以自己设定，持久化好，一般企业开发都用mysql做支撑 1、外部表不会加载到hive中只会有一个引用加入到元数据中 2、在删除时不会删除表，只会删除元数据，所以不必担心数据的 分区表，动态分区 insert into：将某一张表中的数据写到另一张表中 override write：覆盖之前的内容。 Rowkey是一个二进制码流，Rowkey的长度被很多开发者建议说设计在10~100个字节，不过建议是越短越好，不要超过16个字节。在查找时有索引会加快速度。 Rowkey散列原则 、 Rowkey唯一原则 、 针对事务数据Rowkey设计 、 针对统计数据的Rowkey设计 、 针对通用数据的Rowkey设计、 支持多条件查询的RowKey设计。 总结设计列族： 1、一般不建议设计多个列族 2、数据块的缓存的设计 3、激进缓存设计 4、布隆过滤器的设计(可以提高随机读取的速度) 5、生产日期的设计 6、列族压缩 7、单元时间版本 Hbase 的实现原理是rpc Protocol 感觉这个问题有问题，过滤器多的是啦，说的是哪一个不知道!!!! Hbase的过滤器有：RowFilter、PrefixFilter、KeyOnlyFilter、RandomRowFilter、InclusiveStopFilter、FirstKeyOnlyFilter、ColumnPrefixFilter、ValueFilter、ColumnCountGetFilter、SingleColumnValueFilter、SingleColumnValueExcludeFilter、WhileMatchFilter、FilterList 你看这么多过滤波器呢，谁知道你问的那个啊！！ 比较常用的过滤器有：RowFilter 一看就知道是行的过滤器，来过滤行的信息。PrefixFilter前缀的过滤器，就是把前缀作为参数来查找数据呗！剩下的不解释了看过滤器的直接意思就OK了很简单。 Zookeeper 的问题楼上爬爬有步骤，hbase 主要的配置文件有hbase.env.sh 主要配置的是JDK的路径以及是否使用外部的ZK，hbase-site.xml 主要配置的是与HDFS的链接的路径以及zk的信息，修改regionservers的链接其他机器的配置。 在优化时要注意数据的问题，尽量减少数据倾斜的问题，减少job的数量，同事对小的文件进行成大的文件，如果优化的设计那就更好了，因为hive的运算就是mapReduce所以调节mapreduce的参数也会使性能提高，如调节task的数目。 Hive的权限需要在hive-site.xml文件中设置才会起作用，配置默认的是false，需要把hive.security.authorization.enabled设置为true，并对不同的用户设置不同的权限，例如select ,drop等的操作。 1. 首先，Client通过访问ZK来请求目标数据的地址。 2. ZK中保存了-ROOT-表的地址，所以ZK通过访问-ROOT-表来请求数据地址。 3. 同样，-ROOT-表中保存的是.META.的信息，通过访问.META.表来获取具体的RS。 4. .META.表查询到具体RS信息后返回具体RS地址给Client。 5. Client端获取到目标地址后，然后直接向该地址发送数据请求。 HBase的RegionServer宕机超过一定时间后，HMaster会将其所管理的region重新分布到其他活动的RegionServer上，由于数据和日志都持久在HDFS中， Hbase的metastore是用来保存数据的，其中保存数据的方式有有三种第一种于第二种是本地储存，第二种是远程储存这一种企业用的比较多 Hbase使用JAVA来运算的，索引Java的优化也适用于hbase，在使用过滤器事记得开启bloomfilter可以是性能提高3-4倍，设置HBASE_HEAPSIZE设置大一些 如何去进行预分区，可以采用下面三步： 不能使用 sqoop，速度太慢了，提示如下： A、一种可以加快批量写入速度的方法是通过预先创建一些空的 regions，这样当 数据写入 HBase 时，会按照 region 分区情况，在集群内做数据的负载均衡。 B、hbase 里面有这样一个 hfileoutputformat 类，他的实现可以将数据转换成 hfile 格式，通过 new 一个这个类，进行相关配置,这样会在 hdfs 下面产生一个文件，这个 时候利用 hbase 提供的 jruby 的 loadtable.rb 脚本就可以进行批量导入。 需要注意的地方是 ZooKeeper 的配置。这与 hbase-env.sh 文件相关，文件中 HBASE_MANAGES_ZK 环境变量用来设置是使用 hbase 默认自带的 Zookeeper 还 是使用独立的 ZooKeeper。HBASE_MANAGES_ZK=false 时使用独立的，为 true 时 使用默认自带的。 某个节点的 HRegionServer 启动失败，这是由于这 3 个节点的系统时间不一致相 差超过集群的检查时间 30s。 Hbase主要的瓶颈就是传输问题，在操作时大部分的操作都是需要对磁盘操作的 Redis 是基于内存的数据库，注重实用内存的计算，hbase是列式数据库，无法创建主键，地从是基于HDFS的，每一行可以保存很多的列，hive是数据的仓库，是为了减轻mapreduce而设计的，不是数据库是用来与红薯做交互的。 因为hbase是列式数据库，列非表schema的一部分，所以只需要考虑rowkey和columnFamily 即可，rowkey有为的相关性，最好数据库添加一个前缀，文件越小，查询速度越快，再设计列是有一个列簇，但是列簇不宜过多。 Apache HBase是一种Key/Value系统，它运行在HDFS之上。和Hive不一样，Hbase的能够在它的数据库上实时运行，而不是运行MapReduce任务。Hive被分区为表格，表格又被进一步分割为列簇。列簇必须使用schema定义，列簇将某一类型列集合起来（列不要求schema定义）。例如，“message”列簇可能包含：“to”, ”from” “date”, “subject”, 和”body”. 每一个 key/value对在Hbase中被定义为一个cell，每一个key由row-key，列簇、列和时间戳。在Hbase中，行是key/value映射的集合，这个映射通过row-key来唯一标识。Hbase利用Hadoop的基础设施，可以利用通用的设备进行水平的扩展。 HBase的查询实现只提供两种方式： 1、按指定RowKey获取唯一一条记录，get方法（org.apache.hadoop.hbase.client.Get） 2、按指定的条件获取一批记录，scan方法（org.apache.hadoop.hbase.client.Scan） 实现条件查询功能使用的就是scan方式 can可以通过setCaching与setBatch方法提高速度（以空间换时间）， setCaching设置的值为每次rpc的请求记录数，默认是1；cache大可以优化性能，但是太大了会花费很长的时间进行一次传输。 setBatch设置每次取的column size；有些row特别大，所以需要分开传给client，就是一次传一个row的几个column。 cell中的数据是没有类型的，全部是字节码形式存贮。 Hbase的region会自动split，当region太时，regio太大时分布会不均衡，同时对于大批量的代入数据建议如下： 1、还是必须让业务方对rowkey进行预分片，对业务数据rowkey进行md5或者其他的hash策略，让数据尽量随机分布而不是顺序写入。 2、随时观察region的大小，是否出现大region的情况。 在nginx采集日志时无法获取session的信息，然而logger4j则可以获取session的信息，logger4j的方式比较稳定，不会宕机。缺点：不够灵活，logger4j的方式和项目结合过滤紧密，二flume的方式就比较灵活，便于插拔式比较好，不会影响项目的性能。 Flume 采集日志是通过流的方式直接将日志收集到存储层，而 kafka 试讲日志缓存在 kafka 集群，待后期可以采集到存储层。Flume 采集中间停了，可以采用文件的方式记录之前的日志，而 kafka 是采用offset(偏移量) 的方式记录之前的日志。 1、topic 是按照“主题名-分区”存储的 2、分区个数由配置文件决定 3、每个分区下最重要的两个文件是 0000000000.log 和 000000.index，0000000.log 以默认 1G 大小回滚。 Mr 是文件方式的分布式计算框架，是将中间结果和最终结果记录在文件中，map 和 reduce的数据分发也是在文件中。 spark 是内存迭代式的计算框架，计算的中间结果可以缓存内存，也可以缓存硬盘，但是不是每一步计算都需要缓存的。 Spark-rdd 是一个数据的分区记录集合，是利用内存来计算的，spark之所以快是因为有内存的模式 scala> sc.textFile("/usr/local/words.txt") res0: org.apache.spark.rdd.RDD[String] = /usr/local/words.txt MapPartitionsRDD[1] at textFile at scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")) res2: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[4] at flatMap at scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1)) res3: org.apache.spark.rdd.RDD[(String, Int)] = MapPartitionsRDD[8] at map at scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_) res5: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[17] at reduceByKey at scala> sc.textFile("/usr/local/words.txt").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect res6: Array[(String, Int)] = Array((dageda,1), (xiaoli,1), (hellow,4), (xisdsd,1), (xiaozhang,1)) A、当前文件a.text的格式为，请统计每个单词出现的个数 A,b,c,d B,b,f,e A,a,c,f sc.textFile(“/user/local/a.text”).flatMap(_.split(“,”)).map((_,1)).ReduceByKey(_+_).collect() 或： package cn.bigdata import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.rdd.RDD object Demo { /* a,b,c,d b,b,f,e a,a,c,f c,c,a,d * 计算第四列每个元素出现的个数 */ def main(args: Array[String]): Unit = { val conf: SparkConf = new SparkConf().setAppName("demo").setMaster("local") val sc: SparkContext = new SparkContext(conf) val data: RDD[String] = sc.textFile("f://demo.txt") //数据切分 val fourthData: RDD[(String, Int)] = data.map { x => val arr: Array[String] = x.split(",") val fourth: String = arr(3) (fourth, 1) } val result: RDD[(String, Int)] = fourthData.reduceByKey(_ + _); println(result.collect().toBuffer) } } B、HDFS中有两个文件a.text与b.text,文件的格式为(ip,username),如：a.text,b.text a.text 127.0.0.1 xiaozhang 127.0.0.1 xiaoli 127.0.0.2 wangwu 127.0.0.3 lisi B.text 127.0.0.4 lixiaolu 127.0.0.5 lisi 每个文件至少有1000万行，请用程序完成一下工作， 1）每个文件的个子的IP 2)出现在b.text而没有出现在a.text的IP 3)每个user出现的次数以及每个user对应的IP的个数 代码如下： 1）各个文件的ip数 package cn.bigdata import java.util.concurrent.Executors import org.apache.hadoop.conf.Configuration import org.apache.hadoop.fs.FileSystem import org.apache.hadoop.fs.LocatedFileStatus import org.apache.hadoop.fs.Path import org.apache.hadoop.fs.RemoteIterator import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.rdd.RDD import org.apache.spark.rdd.RDD.rddToPairRDDFunctions //各个文件的ip数 object Demo2 { val cachedThreadPool = Executors.newCachedThreadPool() def main(args: Array[String]): Unit = { val conf: SparkConf = new SparkConf().setAppName("demo2").setMaster("local") val sc: SparkContext = new SparkContext(conf) val hdpConf: Configuration = new Configuration val fs: FileSystem = FileSystem.get(hdpConf) val listFiles: RemoteIterator[LocatedFileStatus] = fs.listFiles(new Path("f://txt/2/"), true) while (listFiles.hasNext) { val fileStatus = listFiles.next val pathName = fileStatus.getPath.getName cachedThreadPool.execute(new Runnable() { override def run(): Unit = { println("=======================" + pathName) analyseData(pathName, sc) } }) } } def analyseData(pathName: String, sc: SparkContext): Unit = { val data: RDD[String] = sc.textFile("f://txt/2/" + pathName) val dataArr: RDD[Array[String]] = data.map(_.split(" ")) val ipAndOne: RDD[(String, Int)] = dataArr.map(x => { val ip = x(0) (ip, 1) }) val counts: RDD[(String, Int)] = ipAndOne.reduceByKey(_ + _) val sortedSort: RDD[(String, Int)] = counts.sortBy(_._2, false) sortedSort.saveAsTextFile("f://txt/3/" + pathName) } } 2）出现在b.txt而没有出现在a.txt的ip package cn.bigdata import java.util.concurrent.Executors import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.rdd.RDD /* * 出现在b.txt而没有出现在a.txt的ip */ object Demo3 { val cachedThreadPool = Executors.newCachedThreadPool() def main(args: Array[String]): Unit = { val conf = new SparkConf().setAppName("Demo3").setMaster("local") val sc = new SparkContext(conf) val data_a = sc.textFile("f://txt/2/a.txt") val data_b = sc.textFile("f://txt/2/b.txt") val splitArr_a = data_a.map(_.split(" ")) val ip_a: RDD[String] = splitArr_a.map(x => x(0)) val splitArr_b = data_b.map(_.split(" ")) val ip_b: RDD[String] = splitArr_b.map(x => x(0)) val subRdd: RDD[String] = ip_b.subtract(ip_a) subRdd.saveAsTextFile("f://txt/4/") } } 3） package cn.bigdata import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.rdd.RDD import scala.collection.mutable.Set /* * 每个user出现的次数以及每个user对应的ip数 */ object Demo4 { def main(args: Array[String]): Unit = { val conf = new SparkConf().setAppName("Demo4").setMaster("local") val sc = new SparkContext(conf) val data: RDD[String] = sc.textFile("f://txt/5/") val lines = data.map(_.split(" ")) val userIpOne = lines.map(x => { val ip = x(0) val user = x(1) (user, (ip, 1)) }) val userListIpCount: RDD[(String, (Set[String], Int))] = userIpOne.combineByKey( x => (Set(x._1), x._2), (a: (Set[String], Int), b: (String, Int)) => { (a._1 + b._1, a._2 + b._2) }, (m: (Set[String], Int), n: (Set[String], Int)) => { (m._1 ++ n._1, m._2 + n._2) }) val result: RDD[String] = userListIpCount.map(x => { x._1 + ":userCount:" + x._2._2 + ",ipCount:" + x._2._1.size }) println(result.collect().toBuffer) } } 10-1）sqoop在导入到MySql数据库是怎样保证数据重复，如果重复了该怎么办？？ 在导入时在语句的后面加上一下命令作为节点： --incremental append \ --check-column id \ --last-value 1208 # Note: you can disable saving at all commenting all the "save" lines. # # It is also possible to remove all the previously configured save # points by adding a save directive with a single empty string argument # like in the following example: # # save "" save 900 1 save 300 10 save 60 10000 这个得看个人在公司的规模，下面介绍一下我们公司的一些配置： 联想System x3750 服务器，价格3.5万，内存容量32G，产品类型机架式，硬盘接口SSD,CPU频率2.6GH,CPU数量2颗，三级缓存15MB,cpu核心6核，cpu线程数12线程,最大内存支持1.5T,网络是千兆网卡,可插拔时硬盘接口12个卡槽,配置1T的容量 详细：http://detail.zol.com.cn/server/index1101243.shtml 名字 软件 运行管理 Hadoop1 JDK,hadoop namenode Hadoop2 JDK,hadoop namenode Hadoop3 JDK,hadoop secondaryNamenode Hadoop4 JDK,hadoop secondaryNamenode Hadoop5 JDK,hadoop datanode Hadoop6 JDK,hadoop datanode Hadoop7 JDK,hadoop datanode Hadoop8 JDK,hadoop datanode Hadoop9 JDK,hadoop datanode Hadoop10 JDK,zookeeper,tomcat,mvn,kafka leader Hadoop11 JDK,zookeeper,tomcat,mvn,kafka follower Hadoop12 JDK,zookeeper,tomcat,mvn,kafka follower Hadoop13 JDK,hive,mysql,svn,logstarh hive,mysql,svn Hadoop14 JDK,hbase,mysql备份 datanode Hadoop15 JDK,nginx,Log日志手机 datanode 数据就是每天访问的Log日志不是很大，有的时候大有的时候小的可怜 1、在执行任务时发现副本的个数不对，经过一番的查找发现是超时的原因，修改了配置文件hdfs-site.xml：中修改了超时时间。 2、由于当时在分配各个目录空间大小时，没有很好的分配导致有的目录的空间浪费，于是整体商量后把储存的空间调大了一些。 1-1）采集nginx产生的日志，日志的格式为user ip time url htmlId 每天产生的文件的数据量上亿条，请设计方案把数据保存到HDFS上，并提供一下实时查询的功能（响应时间小于3s） A、某个用户某天访问某个URL的次数 B、某个URL某天被访问的总次数 实时思路是：使用Logstash + Kafka + Spark-streaming + Redis + 报表展示平台 离线的思路是：Logstash + Kafka + Elasticsearch + Spark-streaming + 关系型数据库 A、B、数据在进入到Spark-streaming 中进行过滤，把符合要求的数据保存到Redis中 1-16）java 中有两个线程怎样等待一个线程执行完毕
1-17）hashmap hashtable currentHashMap的使用区别
1-18）简单描述一下java的gc机制，常用的JAVA调优的方法，OOM如何产生的，如何处理OOM问题？？？
Linux 相关
2-1）关闭不必要的服务
2-2）关闭IP6
2-3）调整文件的最大的打开数
[root@hadoop1 /]# vi /etc/security/limits.conf 在文件最后加上：2-4）修改 linux 内核参数
2-5）关闭 noatime
2-6)请用shell命令把某一个文件下的所有的文件分发到其他的机器上
2-7）echo 1+1 && echo "1+1" 会输出什么
2-8）在当前的额目录下找出包含祖母a并且文件的额大小大于55K的文件
2-9）linux用什么命令查看cpu,硬盘，内存的信息？
Hadoop相关
3-1）简单概述hdfs原理，以及各个模块的职责
3-2）mr的工作原理
3-3）怎样判断文件时候存在
3-4）fsimage和edit的区别？
3-5）hdfs中的block默认保存几份？
3-6）列举几个配置文件优化？
3-7) 谈谈数据倾斜，如何发生的，并给出优化方案
3-8）简单概括安装hadoop的步骤
3-9）简单概述hadoop中的角色的分配以及功能
3-10）怎样快速的杀死一个job
3-11)新增一个节点时怎样快速的启动
3-12)你认为用java , streaming , pipe 方式开发map/reduce,各有什么优点
3-13）简单概述hadoop的join的方法
3-14）简单概述hadoop的combinet与partition的区别
3-15 ) hdfs 的数据压缩算法
3-16）hadoop的调度
3-17）reduce 后输出的数据量有多大？
3-18) datanode 在什么情况下不会备份？
3-19）combine 出现在那个过程？
3-20) hdfs 的体系结构？
3-21) hadoop flush 的过程？
3-22) 什么是队列
3-23）三个 datanode，当有一个 datanode 出现错误会怎样？
3-24）mapReduce 的执行过程
3-25）Cloudera 提供哪几种安装 CDH 的方法
3-26）选择题与判断题
3-27）hadoop的combinet与partition效果图
3-28）hadoop 的机架感知（或者说是扩普）
3-29）文件大小默认为 64M，改为 128M 有啥影响？
3-30）datanode 首次加入 cluster 的时候，如果 log 报告不兼容文件版本，那需要namenode 执行格式化操作，这样处理的原因是？
3-31）什么 hadoop streaming？
3-32）MapReduce 中排序发生在哪几个阶段？这些排序是否可以避免？为什么？
3-33）hadoop的shuffer的概念
3-34）hadoop的优化
3-35)3 个 datanode 中有一个 个datanode 出现错误会怎样？
3-36）怎样决定mapreduce的中的map以及reduce的数量
3-37）两个文件合并的问题
遍历文件a，对每个url求取hash(url)%1000，然后根据所得值将url分别存储到1000个小文件（设为a0,a1,...a999）当中。这样每个小文件的大小约为300M。遍历文件b，采取和a相同的方法将url分别存储到1000个小文件(b0,b1....b999)中。这样处理后，所有可能相同的url都在对应的小文件(a0 vs b0, a1 vs b1....a999 vs b999)当中，不对应的小文件（比如a0 vs b99）不可能有相同的url。然后我们只要求出1000对小文件中相同的url即可。
比如对于a0 vs b0，我们可以遍历a0，将其中的url存储到hash_map当中。然后遍历b0，如果url在hash_map中，则说明此url在a和b中同时存在，保存到文件中即可。
如果分成的小文件不均匀，导致有些小文件太大（比如大于2G），可以考虑将这些太大的小文件再按类似的方法分成小小文件即可3-38）怎样决定一个job的map和reduce的数量
3-39）hadoop的sequencefile的格式，并说明下什么是JAVA的序列化，如何实现JAVA的序列化
3-40）简单概述一下hadoop1与hadoop2的区别
3-41）YARN的新特性
3-42）hadoop join的原理
3-43）hadoop的二次排序
3-44）hadoop的mapreduce的排序发生在几个阶段？
3-45）请描述mapreduce中shuffer阶段的工作流程，如何优化shuffer阶段的？
3-46）mapreduce的combiner的作用是什么，什么时候不易使用？？
Zookeeper 相关
4-1）写出你对zookeeper的理解
4-2）zookeeper 的搭建过程
Hive 相关
5-1）hive是怎样保存元数据的
5-2）外部表与内部表的区别
5-3）对于 hive，你写过哪些 UDF 函数，作用是什么
5-4)Hive 的 sort by 和 order by 的区别
5-5）hive保存元数据的方式以及各有什么特点？
5-6）在开发中问什么建议使用外部表？
5-7）hive partition 分区
5-8）insert into 和 override write 区别？
Hbase 相关
6-1）Hbase 的 rowkey 怎么创建比较好？列族怎么创建比较好？
6-2）Hbase 的实现原理
6-3) hbase 过滤器实现原则
6-4）描述 HBase, zookeeper 搭建过程
6-5）hive 如何调优？
6-6）hive的权限的设置
6-7 ) hbase 写数据的原理
6-8）hbase宕机了如何处理？
该操作不会导致数据丢失。所以数据的一致性和安全性是有保障的。
但是重新分配的region需要根据日志恢复原RegionServer中的内存MemoryStore表，这会导致宕机的region在这段时间内无法对外提供服务。
而一旦重分布，宕机的节点重新启动后就相当于一个新的RegionServer加入集群，为了平衡，需要再次将某些region分布到该server。
因此，Region Server的内存表memstore如何在节点间做到更高的可用，是HBase的一个较大的挑战。6-9）Hbase 中的 metastore 用来做什么的？
6-10)hbase客户端在客户端怎样优化？
6-11）hbase是怎样预分区的？
1.取样，先随机生成一定数量的rowkey,将取样数据按升序排序放到一个集合里
2.根据预分区的region个数，对整个集合平均分割，即是相关的splitKeys.
3.HBaseAdmin.createTable(HTableDescriptor tableDescriptor,byte[][] splitkeys)可以指定预分区的splitKey，即是指定region间的rowkey临界值6-12）怎样将 mysql 的数据导入到 hbase 中？
6-13）谈谈 HBase 集群安装注意事项？
6-14)简述 HBase 的瓶颈
6-15）Redis, 传统数据库,hbase,hive 每个之间的区别
6-16）Hbase 的特性,以及你怎么去设计 rowkey 和 columnFamily ,怎么去建一个 table
6-17）Hhase与hive的区别
6-18）描述hbase的scan和get功能以及实现的异同
6-19）HBase scan setBatch和setCaching的区别
6-20）hbase 中cell的结构
6-21）hbase 中region太多和region太大带来的冲突
Flume相关
7-1）flume 不采集 Nginx 日志，通过 Logger4j 采集日志，优缺点是什么？
7-2）flume 和 kafka 采集日志区别，采集日志时中间停了，怎么记录之前的日志。
Kafka 相关
8-1）kafka 中怎样储存数据，哟及结构的，data.....目录下有多少个分区，每个分区的存储格式是什么样的？
Spark 相关
9-1）mr 和 spark 区别，怎么理解 spark-rdd
9-2）简单描述spark的wordCount的执行过程
9-3）按照需求使用spark编写一下程序
Sqoop 相关
Redis 相关
10-1）redis保存磁盘的时间
环境配置
1）你们的集群规模？
2)你在项目中遇到了哪些难题，是怎么解决的？
设计题