大数据学习过程笔记——第一阶段

大数据学习过程笔记

大数据学习视频网址推荐博客
Hadoop安装配置说明页
Hadoop架构介绍

—> CentOS可能会用到的依赖：
yum -y install gcc gcc-c++ autoconf libjpeg libjpeg-devel libpng libpng-devel freetype freetype-devel libxml2 libxml2-devel zlib zlib-devel glibc glibc-devel glib2 glib2-devel bzip2 bzip2-devel ncurses ncurses-devel curl-devel e2fsprogs e2fsprogs-devel krb5 krb5-devel libidn libidn-devel openssl openssl-devel openldap openldap-devel nss_ldap openldap-clients openldap-servers

—>linux中一些开发工具的默认地址：
jdk(rpm安装)的安装目录是：/usr/java/jdk1.7
vsftpd(yum安装)的安装目录是：/etc/vsftpd
nginx(make编译)的安装目录是：/usr/local/nginx
cmake(gmake编译安装依赖)的版本是：3.6对应低版本的gcc、gcc-c++，这样才能够兼容

伪分布式模式安装步骤(在一台主机模拟多主机，其中的每个守护进程都以Java进程的形式运行，其在单机模式的基础上增加了代码调试功能，并允许检查内存使用情况，HDFS输入输出以及其他守护进程交互)：
安装请参考文档

——>首先是配置hadoop-evn.sh文件中的Java路径
——>主要是修改三个配置文件——>core-site.xml, hdfs-site.xml, mapred-site.xml(并需要更改yarn-site.xml文件)
修改yarn-site.xml时，此处有不同的地方：
  
  
    yarn.resourcemanager.hostname
    weekend110
  
  
  
    yarn.nodemanager.aux-services
    mapreduce_shuffle
  
——>格式化文件系统:
没有将Hadoop的bin目录添加到/etc/profile情况下，需要cd到Hadoop2.x.x/bin目录下执行以下命令，否则可以直接执行该命令：
hadoop namenode -format (格式化成功之后，会看到success字样)
在hadoop-2.x.x/data/dfs/name/current目录下会看到一些文件即为元数据

---

传智播客Hadoop八天培训
(总共71个视频101-807)

Hadoop应用场景：
——>解决问题：
    海量数据的存储(HDFS)
    海量数据的分析(MapReduce)
    资源管理调度(YARN)
——>Hadoop擅长日志分析(海量的离线日志分析)
——>实时的位置数据(实现广告的推送)

Hadoop对海量数据处理的解决思路：
——>海量数据存储
——>海量数据计算

Hadoop版本：
——>Apache
——>CDH(Cloudra)
——>HDP

---

让普通用户具备sudo执行权限：
切换到root
然后 vim /etc/sudoers 加入一行
root	ALL=(ALL)	ALL
hadoop    ALL=(ALL)	ALL

让Linux服务器在启动时不要启动图形界面：
sudo vim /etc/inittab
将启动级别改成3
id:3:initdefault

---

HDFS的实现思想：
    1.hdfs是通过分布式集群来存储文件(为客户端提供了一个便捷的访问方式，就是一个虚拟的目录结构)
    2.文件存储到hdfs集群汇中去的时候是被切分成block的
    3.文件的block存放在若干台datanode节点上
    4.hdfs文件系统中的文件与真实的block之间的映射关系，由namenode管理
    5.每一个block在集群中会存储多个副本，好处是可以提高数据的可靠性，还可以提高访问的吞吐量

远程拷贝：(以dfss和hadoop02两台主机为例，在dfss主机上进行操作)
scp id_rsa.pub hadoop02:[FilePath]
追加一个文件的内容到另一个文件中去：
cat ../id_rsa.pub >> ./authorized_keys

namenode记录元数据：
  1.客户端上传文件时，NN首先往edits log文件中记录元数据操作日志
  2.客户端开始上传文件，完成后返回成功信息给NN，NN就在内存中写入这次上传操作的新产生的元数据信息
  3.每当editslog写满时，需要将这一段时间新的元数据刷到fsimage文件中去
  SecondaryNameNode：将editslog文件合并到fsimage文件中

datanode提供真实的文件数据存储服务：
  1.文件块(block)：最基本的存储单位(HDFS默认block大小是128M)；
  2.不同于普通文件系统的是，HDFS中，如果一个文件小于一个数据块的大小，并不占用整个数据块存储空间；
  3.Replication，多副本，默认是三个(hdfs-site.xml的dfs.replication属性)

---

====>HDFS读写文件过程

读文件过程：
  1.使用HDFS提供的客户端开发库Client，向远程的Namenode发起RPC请求；
  2.Namenode会视情况返回文件的部分或者全部block列表，对于每个block，Namenode都会返回有该block拷贝的DataNode地址；
  3.客户端开发库Client会选取离客户端最接近的DataNode来读取block；如果客户端本身就是DataNode，那么将从本地直接获取数据。
  4.读取完当前block的数据后，关闭与当前的DataNode连接，并为读取下一个block寻找最佳的DataNode；
  5.当读完列表的block后，且文件读取还没有结束，客户端开发库会继续向Namenode获取下一批的block列表。
  6.读取完一个block都会进行checksum验证，如果读取datanode时出现错误，客户端会通知Namenode，然后再从下一个拥有该block拷贝的datanode继续

写文件过程：
  1.使用HDFS提供的客户端开发库Client，向远程的Namenode发起RPC请求；
  2.Namenode会检查要创建的文件是否已经存在，创建者是否有权限进行操作，成功则会为文件创建一个记录，否则会让客户端抛出异常；
  3.当客户端开始写入文件的时候，开发库会将文件切分成多个packets，并在内部以数据队列"data queue"的形式管理这些packets，并向Namenode申请新的blocks，获取用来存储replicas的合适的datanodes列表，列表的大小根据在Namenode中对replication的设置而定。
  4.开始以pipeline（管道）的形式将packet写入所有的replicas中。开发库把packet以流的方式写入第一个datanode，该datanode把该packet存储之后，再将其传递给在此pipeline中的下一个datanode，直到最后一个datanode，这种写数据的方式呈流水线的形式。
  5.最后一个datanode成功存储之后会返回一个ack packet, 在packet里传递至客户端，在
  客户端的开发库内部维护着"ack queue", 成功收到datanode返回的ack packet后会从
  "ack queue"移除相应的packet。
  6.如果传输过程中，有某个datanode出现了故障，那么当前的pipeline会被关闭，出现故障的datanode会从当前的pipeline中移除，剩余的block会继续剩下的datanode中继续以pipeline的形式传输，同时Namenode会分配一个新的datanode，保持replicas设定的数量。

Rack Awareness策略：
  1.第一个block副本放在和client所在的node里（如果client不在集群范围内，则这第一个node是随机选取的，系统会尝试不选择哪些太满或者太忙的node）。
  2.第二个副本放置在与第一个节点不同的机架中的node中（随机选择）。 
  3.第三个副本和第二个在同一个机架，随机放在不同的node中。

常用管理命令：
hadoop-daemon.sh
hdfs 
hdfs dfs
hdfs dfsadmin
hadoop namenode -format (格式化成功之后，会看到success字样)

启动Hadoop过程中遇到的namenode节点启动失败的问题：(logs中的namenode日志中报错txid启动错误)

——>原因：
Hadoop NN中的元数据包括：
fsimage:包含某个时间点的文件系统的完整状态
edit logs:包含在最近的fsimage之后进行的每个文件系统更改(文件创建/删除/修改)

当NN启动时，Hadoop将加载fsimage并应用所有编辑日志，同时进行大量的一致性检查，如果检查失败，它将终止。当我们将NN该工作区中的edits_00...0001-00...002删掉时，然后尝试sbin/start-dfs.sh,将在日志中收到edits-logs信息不匹配的日志并且启动失败。

——>解决办法：
在Hadoop家目录下执行：./bin/hadoop namenode -recover
在一堆提示后选择yes, 然后选择c, 之后日志内容将会改变
使用单一节点启动命令: hadoop-daemon.sh start namenode 重新启动namenode节点
jps查看各节点启动状态，即发现namenode节点启动成功

修改namenode日志后启动hadoop时datanode节点启动失败的问题：(logs中的datanode日志中报错添加文件失败)

——>原因：
会出现该问题以及上一个问题，是因为多次对namenode进行format, 每一次format主节点NameNode产生新的clusterID、namespaceID, 于是导致主节点的clusterID、namespaceID、与各个子节点DataNode不一致。当format过后再启动hadoop, hadoop尝试创建新的current目录, 但是由于已存在current目录, 导致创建失败, 最终引起DataNode节点的DataNode进程启动失败, 从而引起hadoop集群完全启动失败。

——>解决办法：
重命名原current文件为current-bak文件(文件名随意，文件在/hadoop-2.7.7/data/tmp/dfs/data目录下)，再重新启动hadoop，可以发现datanode节点成功启动，并且可以顺利的上传文件到节点内。

上传文件报错，未能识别hdfs文件系统(Wrong FS: hdfs://hadoop20:9000/word.txt, expected: file:///):

解决办法有两种：
1.直接通过在代码，在conf中设置默认文件系统
2.直接将hadoop文件配置中的core-site.xml和hdfs-site.xml文件拷贝到项目的src文件目录下，代码在运行的时候就会先读取core-site.xml文件中的配置信息。

NameNode职责：
1.维护元数据信息
2.维护hdfs目录树
3.响应客户端请求

Hadoop中的RPC框架实现机制：

hdfs中下载数据的源代码解析：

hdfs中打开数据流的源代码解析：

---

MapReduce编程：
每个map都要继承Mapper
在上述Mapper类的4个泛型中，前两个是指定mapper输入数据的类型，KEYIN是输入的key的类型, VALUEIN是输入的value的类型；
map和reduce的数据输入输出是以 key-value对的形式封装的
默认情况下，框架传递给我们的mapper的输入数据中，key是要处理的文本中一行的起始偏移量，这一行的内容作为value

——>Hadoop中特有的数据类型：(因为数据在不同节点之间进行通信的时候需要对数据进行序列化处理，而jdk自带的数据类型在进行序列化处理的时候会添加一些冗余的信息，这对海量数据的处理非常不友好，所以Hadoop自定义了一些数据类型以消除序列化冗余所带来的影响)
如：
Long -> LongWritable
String -> Text等等

---

MR程序的几种提交运行模式：

本地模式运行：
1.在Windows中的eclipse里直接运行main方法，就会将job提交给本地执行器localjobRunner执行
    ————输入输出数据可以放在本地路径下(D:/xx/xx/)
    ————输入输出数据也可以放在hdfs中(hdfs://hadoop:9000/xx/xx/)
2.在Linux的eclipse里直接运行main方法，但是不要添加yarn相关的配置，也会提交给localjobRunner执行
    ————输入输出数据可以放在本地路径下(/home/hadoop/Desktop/xx/xx/)
    ————输入输出数据也可以放在hdfs中(hdfs://hadoop:9000/xx/xx/)

集群模式运行：
1.将工程打成jar包，上传到服务器，然后用hadoop命令提交 hadoop jar your.jar package.WCRunner(main方法所在类)
2.在Linux的eclipse中直接运行main方法，也可以提交到集群中去运行，但是，必须采取以下措施：
    ————在工程src目录下加入mapred-site.xml和yarn-site.xml
    ————将工程打成jar包(your.jar), 同时在main方法中添加一个conf的配置参数 conf.set("mapreduce.job.jar", "your.jar")

3.在Windows的eclipse中直接运行main方法，也可以提交给集群中运行，但是因为平台不兼容，需要做很多的设置：
    ————要在Windows中存放一份hadoop的安装包(解压好的)
    ————要将其中的lib和bin目录替换成根据你的Windows版本重新编译出的文件
    ————再配置系统环境变量 HADOOP_HOME 和 PATH
    ————修改YarnRunner这个类的源码

Yarn的通用性意义：
使得Hadoop框架的可扩展性大大增强(在HDFS文件系统的加持下，通过yarn对各种运算框架进行任务分配及管理，如MP的海量批处理、Spark的迭代处理以及Storm的实时流处理，各种计算框架只需要实现yarn框架中的AppMaster接口即可完成扩展)

Yarn提交Job的源码分析：

---

Hadoop中的序列化机制：
.....
——>在实际编码过程中，可以通过实现Writable接口或者是WritableComprable接口来完成IO流的序列化与反序列化

hadoop自定义排序实现：
——>在序列化的基础上，封装的数据对象可以通过实现Comprable接口来实现最终的排序

hadoop自定义分组实现(例如将全国的号码分成各个省的号码分别进行处理)：
默认是根据key的hash 值进行分组
1.自定义过程中是通过将分组字典加载在缓存中，以map的形式实现，在加载类(该类继承了Hadoop中的Partitioner类，重写getPartition来返回一条数据的组号)的时候，static变量只初始化一次于缓存内，这样可以通过该逻辑来确定最终的分组
2.默认是只生成1个reduce任务，可以通过job.setNumReduce(tasks)来指定Reducer任务数量，从而对应各个分组进行任务处理。

1.map task的并发数量是由切片的数量决定的，有多少个切片，就启动多少个map task
2.切片是一个逻辑的概念，指的就是文件中数据的偏移量范围
3.切片的具体大小应该根据所处理的文件的大小来调整

shuffle机制(分组与排序以及各种缓存机制)：

综合上述几个点就构成了mapreduce的组件全貌(包括InputFormat和OutputFormat):

textinputformat对切片规划的源码分析：

Hadoop权威指南——>内容详细，但是实战性的内容不多，主要是从技术机制上进行分析(即理论)
老师提到有一本关于Hadoop源码分析的书，可能会与实战有关

——>关于多个job在同一个main中提交的做法是不提倡的，解决办法可以在shell脚本中指定若干job先后在任务中进行提交运行。

zookeeper高可用：
提供少量的数据的存储和管理(即一些状态信息，非业务信息)
提供对数据节点的监听器功能
——>是什么： 分布式应用服务组件
——>为什么： 1.大部分分布式应用需要一个主控、协调器或控制器来管理物理分布的子进程(如资源、任务分配等)
2.大部分应用需要开发私有的协调程序，缺乏一个通用的机制
3.协调程序的反复变谢谢诶浪费，且难以形成通用、伸缩性好的协调器
4.ZooKeeper提供通用的分布式锁服务，用以协调分布式应用
——>怎么用：
1.ZooKeeper的安装和配置(集群模式)：
创建myid文件，server.1机器的内容为：1，server.2机器的内容为：2，server.3机器的内容为：3
2.在conf目录下创建一个配置文件zoo.cfg，
tickTime=2000
dataDir=/xxx/xxx/zookeeper/data
dataLogDir=/xxx/xxx/zookeeper/dataLog
clientPort=2181
initLimit=5
syncLimit=2
server.1=server1:2888:3888
server.2=server2:2888:3888
server.3=server3:2888:3888
3.将配置好的zk拷贝到其他节点：
    scp -r xx/xx/zookeeper3.x.x/ hostname:xx/xx/
    scp -r xx/xx/zookeeper3.x.x/ hostname:xx/xx/
4.注意：在其他节点上一定要修改myid的内容(见步骤1)
5. /bin/zkServer.sh start启动zookeeper

配置Linux虚拟机静态IP：
...
IPV4_FAILURE_FATAL=no
IPV6INIT=yes
IPV6_AUTOCONF=yes
IPV6_DEFROUTE=yes
IPV6_FAILURE_FATAL=yes
IPV6_ADDR_GEN_MODE=stable-privacy
NAME=ens33
...

zookeeper集群启动过程中遇到的问题：
1.启动zookeeper之后，查看状态，显示为ERROR，说明集群机器数量没有达到标准或者是各机器之间没有识别到各自的存在：
(在启动每台机器的时候，可以通过命令./zkServer.sh start-foreground来启动，这样在启动以及后续的过程中就能实时查看到集群中的各机器在启动过程中抛出的错误，这样就可以根据出现的错误解决问题)
2.在挂起客户机并重新开启后，查看状态，QuorumPeerMain没有开启，并且也无法重新开启，在关闭占用2181端口的进程之后，重启zookeeper后，查看状态，显示Follwer，并且其他两台机器一台显示Follwer一台显示Leader，但是一段时间后再观察状态，ERROR又出现了...，之后重启集群中的各机器(使用上面的命令)，恩，奇迹又出现了，有点捉摸不透。
3.关于zookeeper的初始配置：
重命名conf/下的zoo.sample.cfg为zoo.cfg，并编辑修改其中的内容(更改其中的dataDir路径并在最后添加server.?=hostname:2888:3888，其中?是自定义的机器编号，需要和接下来在data/下新建的myid中的内容一致，2888是指首选通信端口，3888即为次选端口)
在data/下新建myid文件，并向其中写入机器对应的编号

zookeeper应用场景：
1.统一命名服务：
2.配置管理：
——>Dubbo(阿里开源框架)
3.集群管理：Zookeeper不仅能够维护当前的集群中机器的服务状态，而且能够选出一个“总管”，让这个总管来管理集群(即Leader Election)
4.共享锁

Zookeeper提供了一套很好的分布式集群管理的机制，就是它这种基于层次型的目录树的数据结构，并对树中的节点进行有效管理，从而可以设计出多种多样的分布式的数据管理模型 。

NameNode高可用方案(HA)要点1：
hdfs中的Namenode只有一个，虽然有SecondaryNamenode提供保障，但是高可用性还是不能实现，所以就需要考虑提供另外一台Namenode节点

Hadoop-HA机制的配置文件：(共需启动7台机器来组成高可用HA的Hadoop集群)
1. NameNode   zkfc
2. NameNode   zkfc
3. resourcemanager
4. resourcemanager
5. ZooKeeper  journalnode   datanode  nodemanager
6. ZooKeeper  journalnode   datanode  nodemanager
7. ZooKeeper  journalnode   datanode  nodemanager


集群规划：
  主机名       IP                安装的软件                     运行的进程
  hadoop    192.168.79.139  jdk、hadoop、zookeeper、nginx、....  DataNode、NodeManager、JournalNode、QuorumPeerMain
  hadoop02  192.168.79.138  jdk、hadoop、zookeeper              DataNode、NodeManager、JournalNode、QuorumPeerMain
  hadoop03  192.168.79.140  jdk、hadoop、zookeeper              DataNode、NodeManager、JournalNode、QuorumPeerMain
  hadoop04  192.168.79.128  jdk、hadoop                        NameNode、DFSZKFailoverController(zkfc)  
  hadoop05  192.168.79.129  jdk、hadoop                        NameNode、DFSZKFailoverController(zkfc)
  hadoop06  192.168.79.130  jdk、hadoop                        ResourceManager
  hadoop07  192.168.79.131  jdk、hadoop                        ResourceManager

说明：
  1.在hadoop2.0中通常由两个NameNode组成，一个处于active状态，另一个处于standby状态。Active NameNode对外提供服务...
  hadoop2.0官方提供了两种HDFS HA的解决方案，一种是NFS，一种是QJM，这里我们使用简单的QJM。在该方案中...
  这里还配置了一个zookeeper集群，用于ZKFC(DFSZKFailoverController)故障转移，当Active NameNode挂掉了，会自动切换到Standby NameNode节点....
  2.hadoop-2.2.0中依然存在一个问题，就是ResourceManager只有一个，存在单点故障，hadoop2.4.1解决了这个问题，

集群配置：
1.安装、配置环境变量
...(基础配置)
2.修改hadoop配置文件：
->修改core-site.xml
  
    
    
        fs.defaultFS
        hdfs://ns1/
    
    
    
        hadoop.tmp.dir
        /home/xxxx/software/hadoop-2.7.7/data/tmp
    
    
    
        ha.zookeeper.quorum
        hadoop:2181,hadoop02:2181,hadoop03:2181
    
  

->修改hdfs-site.xml
  
      
      
          dfs.nameservices
          ns1
      
      
      
          dfs.ha.namenodes.ns1
          nn1,nn2
      
      
      
          dfs.namenode.rpc-address.ns1.nn1
          hadoop04:9000
      
      
      
          dfs.namenode.http-address.ns1.nn1
          hadoop04:50070
      
      
      
          dfs.namenode.rpc-address.ns1.nn2
          hadoop05:9000
      
      
      
          dfs.namenode.http-address.ns1.nn2
          hadoop05:50070
      
      
      
          dfs.namenode.shared.edits.dir
          qjournal://hadoop:8485;hadoop02:8485;hadoop03:8485/ns1
      
      
      
          dfs.journalnode.edits.dir
          /home/xxxx/software/hadoop-2.7.7/journaldata
      
      
      
          dfs.ha.automatic-failover.enabled
          true
      
      
      
          dfs.client.failover.proxy.provider.ns1
          org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider
      
      
      
          dfs.ha.fencing.methods
          
            sshfence
            shell(/xxx/xxx/xx.sh或者是/bin/true (系统自带的？))
          
      
      
      
          dfs.ha.fencing.ssh.private-key-files
          ~/.ssh/id_rsa
      
      
      
          dfs.ha.fencing.ssh.connect-timeout
          30000
      
  

->修改mapred-site.xml

    
        mapreduce.framework.name
        yarn
    


->修改yarn-site.xml

    
    
        yarn.resourcemanager.ha.enabled
        true
    
    
    
        yarn.resourcemanager.cluster-id
        yrc
    
    
    
        yarn.resourcemanager.ha.rm-ids
        rm1,rm2
    
    
    
        yarn.resourcemanager.hostname.rm1
        hadoop06
    
    
        yarn.resourcemanager.hostname.rm2
        hadoop07
    
    
    
        yarn.resourcemanager.zk-address
        hadoop:2181,hadoop02:2181,hadoop03:2181
    
    
        yarn.nodemanager.aux-services
        mapreduce_shuffle
    

---

集群之间配置无密登录：
->为了不会发生混乱，先清除之前配置的ssh文件，之后重新生成
->ssh-keygen -t rsa 生成rsa加密文件
->ssh-copy-id hostname (复制rsa公钥到指定机器上，从而实现无密登录，中间要输入yes)
->验证ssh登录是否需要密码
——>普通用户ssh到另一台电脑上：
最初尝试：ssh hostname；可能是没有指定username的原因，会出现未能识别正确密码的情况，并报错Permission denied (publickey,gssapi-keyex,gssapi-with-mic)
试试：ssh username@hostname；输入密码后能够正常登录，所以有了下面的解决方案(原因是在没有指定连接的用户名的情况下，它会默认使用当前的用户名，所以会错误)
方便起见：可以使用映射关系，即在.ssh文件下创建config配置文件，配置如下：
[hadoop04@hadoop04 home]$ cat ~/.ssh/config 
Host    hadoop
user    hadoop
Host    hadoop02
user    hadoop02
Host    hadoop03
user    hadoop03
Host    hadoop05
user    hadoop05

其中
Host  hostname
user  username

将配置好的hadoop拷贝到其他节点：
  scp -r /hadoop/ hadoop02:/
  scp -r /hadoop/ hadoop03:/
  scp -r /hadoop//hadoop-2.7.7/ hadoop04:/hadoop03/
  scp -r /hadoop//hadoop-2.7.7/ hadoop05:/hadoop03/
  scp -r /hadoop//hadoop-2.7.7/ hadoop06:/hadoop03/
  scp -r /hadoop//hadoop-2.7.7/ hadoop07:/hadoop03/

###注意：严格按照下面的步骤
——>启动zookeeper集群(分别在hadoop、hadoop02、hadoop03上启动zk)
  cd /home/hadoop03/software/zookeeper-3.4.9/bin/
  ./zkServer.sh start
  #查看状态：一个leader，两个follower
  ./zkServer.sh status
——>启动journalnode(分别在hadoop、hadoop02、hadoop03上执行)
  cd /home/hadoop03/software/hadoop-2.7.7
  sbin/hadoop-daemon.sh start journalnode
  #运行jps命令检验，hadoop、hadoop02、hadoop03上多了JournalNode进程
——>格式化HDFS
  #在hadoop04(机器根据集群搭建指定的该机器功能来选择)上执行命令
  hdfs namenode -format
  #格式化后会在根据core-site.xml中的hadoop.tmp.dir配置生成个文件，这里配置的是/hadoop03/software/hadoop-2.7.7/tmp，然后将/hadoop/hadoop-2.7.7/tmp拷贝到hadoop05的/hadoop/hadoop-2.7.7/下。
  ##也可以这样，建议hdfs namenode --bootstrapStandby
——>格式化ZKFC(在hadoop04上执行即可)
  hdfs zkfc -formatZK
——>启动HDFS(在hadoop04上执行)
  sbin/start-dfs.sh
——>启动YARN(#####注意#####：是在hadoop06上执行start-yarn.sh(单独在hadoop07上启动yarn，执行命令yarn-daemon.sh start resourcemanager)，把namenode和resourcemanager分开是因为性能问题，...，执行sbin/start-yarn.sh即可进行启动)

到此，hadoop-2.7.7配置完毕，可以统计浏览器访问

hdfs指定tmp目录中内容简介：
——>执行hadoop格式化指令后，会在指定的tmp目录下生成dfs目录(/data、/name、/namesencondary)
/data: 是DataNode节点存储数据块的目录
/namesencondary: 对于集群是没用的，它只在伪分布式模式时才会出现，所以不用关心
/name: 该目录存储Namenode元数据信息，格式化后，启动hdfs前，在/name/current/目录下，会生成一个最初的fsimage_0000000和类似的文件(关于fsimage和eidits在前面已经介绍过了)
——>格式化的危险：
当执行格式化之后，相当于把tmp下的内容清掉，以前的数据将不存在，另外重新更新了clusterID，该clusterID表示的是当前namenode的标识，如果它变了，那原本连接该Namenode的DataNode将找不到它，当然可以将新的clusterID更新到每个datanode里，即可重新连接。
——>启动后：
启动hdfs后，首先会在/name下生成一个in_use.lock，这个文件的作用可以防止同一台服务器上启动多个Namenode，避免管理紊乱。
——>查看元数据文件：
不能直接打开，都是乱码，需要输入下面的命令才能查看
hdfs oev -i edits_0000001 -o edits.xml
hdfs oiv -i fsimage_00000012 -o fsimage.xml -p XML


datanode:
03: clusterID=CID-c7630be5-7d43-4f92-98f2-f1d01b1b57f1
02: clusterID=CID-c7630be5-7d43-4f92-98f2-f1d01b1b57f1
01: clusterID=CID-b0b743f4-6489-41be-9839-bd1bce40ad7f

03: datanodeUuid=ed19b20d-0162-4068-89c1-92839f877a99
02: datanodeUuid=ed19b20d-0162-4068-89c1-92839f877a99
01: datanodeUuid=0a02f0a2-a903-4657-a18a-15f5459edbd7

namenode:
04: clusterID=CID-b0b743f4-6489-41be-9839-bd1bce40ad7f
05: clusterID=CID-b0b743f4-6489-41be-9839-bd1bce40ad7f

04: namespaceID=47811340
05: namespaceID=47811340

04: blockpoolID=BP-1966791895-192.168.79.128-1560673371040
05: blockpoolID=BP-1966791895-192.168.79.128-1560673371040

集群搭建到上传文件到集群的hdfs系统过程中遇到的问题：
1.启动集群过程中总是出现DataNode节点启动失败或者是Namenode节点启动失败的状况

——>查看日志：FileNotFundException找不到相关文件(Namenode节点在启动时，会从fsimage文件中读取相关元数据，但是过程中更改了其中一个DataNode的配置，所以DataNode与元数据不符，就出现找不到文件的错误，从而造成节点启动失败).从而导致节点启动失败
——>解决方案：
目前只知道暴力的解决办法：即删除hadoop集群中的各DataNode和Namenode节点下的data/目录下的tmp文件夹(备份)，之后重新在Namenode节点对集群中的各节点进行格式化。接下来的步骤还需要严格按照集群启动步骤进行启动，最后可以看到成功启动各节点。

2.mkdir: Permission denied: user=hadoop, access=WRITE, inode="/":hadoop04:supergroup:drwxr-xr-x

(相关描述：在DataNode节点上向hdfs系统上传一个文件，但是Namenode节点存在权限问题导致DataNode节点上传文件不成功)
——>可以大致确定原因是权限相关问题，网上有建议在hdfs-site.xml文件中添加permission.enabled=true相关配置的；也有sudo -u username hadoop fs -operation ***进行操作的。
——>解决方案：
第一种会涉及到重启集群，比较麻烦；
第二种在不同机器上执行该命令，会出现识别不了用户名的错误提示
所以就需要在Namenode节点上使用方法二更改用户权限( sudo -u hadoop04 /home/hadoop03/software/hadoop-2.7.7/bin/hadoop fs -chmod 777 /)

——>hdfs-HA测试未进行实践(主要是对高可用的实践验证)

——>hdfs动态增加节点和副本数量管理
->命令行中查看和管理Namenode状态：
hdfs haadmin
hdfs haadmin -transitionToStandby nn1
(由于自动状态管理已经开启，而且手动管理可能会造成其他状态，所以系统拒绝此命令，但可以通过下面命令进行强制状态转换)
hdfs haadmin -transitionToStandby nn1 --forcemanual
hdfs haadmin -transitionToActive nn2 --forcemanual(Namenode节点2转换成活跃状态)
->hadoop DataNode节点超时时间设置：
DataNode进程死亡或者网络故障造成DataNode无法与Namenode通信，
Namenode不会立即把该节点判定为死亡，要经过一段时间，这段时间暂称作超时时长
HDFS默认的超时时长为10分钟+30秒。如果定义超时时间为timeout，则超时时长的计算公式为：
  timeout = 2*heartbeat.recheck.interval+10*dfs.heartbeat.interval
  而默认的heartbeat.recheck.interval 大小为5分钟，dfs.heartbeat.interval默认为3秒
  需要注意的是hdfs-site.xml配置文件中的
  heartbeat.recheck.interval的单位为毫秒，
  dfs.heartbeat.interval的单位为秒。

  所以，举个例子，如果heartbeat.recheck.interval设置为5000(毫秒)，dfs.heartbeat.interval设置为3(秒，默认)
  hdfs-site.xml中的参数设置格式：
  
    heartbeat.recheck.interval
    2000
  
  
    dfs.heartbeat.interval
    1
  

->HDFS冗余数据块的自动删除：
在日常维护hadoop集群的过程中发现这样一种情况：
  某个节点由于网络故障或者DataNode进程死亡，被NameNode判定为死亡：
  HDFS马上自动开始数据块的容错拷贝；
  当该节点重新添加到集群中时，由于该节点上的数据其实并没有损坏，
  所以造成HDFS上某些block的备份数超过了设定的备份数。
  通过观察发现，这些多余的数据块经过很长的一段时间才会被完全删除掉，
  那么这个时间取决于什么呢？
  该时间的长短跟数据块报告的间隔时间有关。
  DataNode会定期将当前该节点上所有的BLOCK信息报告给NameNode，
  参数dfs.blockreport.intervalMsec就是控制这个报告间隔的参数。
  hdfs-site.xml文件中有一个参数：
  
    dfs.blockreport.intervalMsec
    10000
    Determines block reproting interval in millseconds
  
  其中3600000为默认设置，3600000毫秒，即1个小时，也就是说，块报告的时间间隔为1个小时，所以经过了很长时间
需要再克隆一台虚拟机，并重新配置，最后再测试关闭一台DataNode后Namenodeu关于Live Nodes和Dead Nodes的统计，之后开启新机器，查看各节点数量，再恢复刚关闭的DataNode，再次查看各节点数量。

——>放翁：
->大公司的流水线——>技术的狭隘
->大部分人需要得到的是沉默的肯定，而不是明确的表态
->主动改变一切，找到自己的特点，没有问题的时候最可怕，不同阶段追求不同的收获，先听再说，永远都要清楚自己想要的是什么。
->怎么看待开源：有时候国内的公司的开源，其实更贴合“晒代码”，只有自己参与了，一旦自己不用就over。多把设计细节和代码片段分析说明作详细了就好了，
->如何学习技术？
不用着急什么都学，珍惜每一次不同工作的机会，挖深做细，几年以后回过头来原来自己积攒了那么多！xml解析分成几种模式，各种解析的优劣？http 1.1协议中的Header中的缓存设置，返回头里面的trunked什么用途？分布式计算关键问题是什么（调度，协同，数据交互）？应用压力测试瓶颈如何评定，导致瓶颈的代码所属操作可能分成哪几类? …… 要留下更多疑问背后的答案，而不仅仅是那一点代码，那一些入门文档。

重新启动挂起状态的虚拟机时突然出现远程连接不上其中一台虚拟机的情况：

试了几遍连接不上的情况，则直接通过虚拟机客户端登录虚拟机，ifconfig查看网络，发现IP地址不再显示(可能是网卡出了问题)，尝试重启network服务，但是出现Bring up interface eth0: Error: Connection activation failed: Device not managed by NetworkManager or available的错误
—>解决方案(依次执行以下命令)：
service NetworkManager stop        #停止NetworkManager服务
chkconfig NetworkManager off       #关闭NetworkManager随系统启动
service network restart            #重启网络服务
chkconfig network on               #网络服务设为开机自启动

——>hive入门：
->hive元数据库MySQL方式安装配置：
  配置hive-site.xml文件：
  
    javax.jdo.option.ConnectURL
    jdbc:mysql://hadoop04:3306/hive?createDatabaseIfNotExist=true
  
  
    javax.jdo.option.ConnectDriverName
    com.mysql.jdbc.Driver
  
  
    javax.jdo.option.ConnectUserName
    root
  
  
    javax.jdo.option.ConnectPassword
    123456
  

——>关于虚拟机不定期自动更改IP地址的解决方案：
网上有很多种方法，但按照其中的几种解决方案执行之后，发现，有时候ping不同外网(未识别的ping)，有时候SecureRT无法远程连接虚拟机。我的做法是将/etc/sysconfig/network-scripts/ifcfg-eth0中的BOOTPROTO="static"直接设置成static，并在下面添加IP地址、网关(务必保证和编辑虚拟机网络中的网关保持一致)以及子网和DNS的相关设置。
重启网络服务之后发现IP地址重新设置为设置中的IP地址，至于后来是否会变，我就不去研究原理了，等待时间来验证。

---

——>centOs6.x安装MySQL笔记：
->根据Linux版本下载对应的MySQL版本(red hat类型5.7版本的MySQL，下载下来的是.tar压缩文件，解压的时候使用参数-xvf即可)
->依次通过rpm -ivh命令安装common、libs、libs-compact、client、server文件(在此之前需要查看系统内默认安装的老版本的MySQL是否存在，若存在需要卸载，一般情况下使用rpm -e即可，若提示相关依赖不能进行卸载，则使用rpm -e --nodeps进行强制卸载)
->安装完成之后需要更改用户密码等信息
->需要通过sudo service mysqld stop命令停止MySQL
->一般情况下执行mysqld --skip-grant-tables &命令之后即可直接通过mysql命令进入MySQL
->若还是无法直接通过命令mysql进入MySQL，则可以指定用户名进行登录(mysqld --user=root --skip-grant-tables &)
->进入数据库之后，通过以下命令修改用户名以及密码：
mysql5.7以下版本：UPDATE mysql.user SET Password=PASSWORD('123456') where USER='root';
mysql5.7版本：UPDATE mysql.user SET authentication_string=PASSWORD('123456') where USER='root';
刷新权限：flush privileges;
退出重登(中间需要开启mysqld服务)mysql：exit或quit

->关于解决Navicat 报错:1130-host ... is not allowed to connect to this MySql server,MySQL不允许从远程访问的方法：
1.改表法
可能是你的帐号不允许从远程登陆，只能在localhost。这个时候只要在localhost的那台电脑，登入mysql后，更改 "mysql" 数据库里的 "user" 表里的 "host" 项，从"localhost"改称"%"
mysql -u root -pvmwaremysql>use mysql;
mysql>update user set host = '%' where user = 'root'
mysql>select host, user from user;
2.授权法：...

Navicat破解(win10,mac同理)

Navicat Premium历史版本下载地址：
http://download.navicat.com/download/navicat9_premium_cs.exe
http://download.navicat.com/download/navicat100_premium_cs.exe
http://download.navicat.com/download/navicat110_premium_cs_x86.exe
http://download.navicat.com/download/navicat110_premium_cs_x64.exe
http://download.navicat.com/download/navicat120_premium_cs_x86.exe
http://download.navicat.com/download/navicat120_premium_cs_x64.exe
http://download.navicat.com/download/navicat121_premium_cs_x86.exe
http://download.navicat.com/download/navicat121_premium_cs_x64.exe

GitHub上下载破解工具
GitHub：https://github.com/DoubleLabyrinth/navicat-keygen/releases

.\navicat-patcher.exe ".....\Navicat Premium 12" PrivateKey.pem
(Input index)> 1
(Input index)> 1
(range:0 ~ 15, default: 12)> 12
Serial number:
NAVH-2YAT-7JC7-2ZAX
Your name: trb331617
Your organization: trb331617
Input request code in Base64:
手动激活后，复制出现的code到这里
Activation Code:
回车后，此处生成的code即为手动激活码。

IntelliJ系列破解

Idea付费版安装破解+Pycharm付费版安装破解：修改hosts文件(将0.0.0.0 account.jetbrains.com添加到hosts文件最后)+激活码链接(http://idea.lanyus.com/)，即可成功激活。

关于Navicat更多破解信息可以查看破解工具下载

---

->安装hive的时候，可能是由于hive-site.xml文件配置错误，导致在不同目下启动hive时都会在该目录下新建一个metastore_db的文件夹用于存储数据库文件，删除hive之后，重新解压并配置hive-site.xml文件，出现Hivemetastore之类的错误可能是由于hive在lib库中没有找到mysql-connector-xxx.jar数据库连接文件(添加即可)。

——>hive HQL(常用语法介绍)：
set hive.cli.print.header=true;

CREATE TABLE page_view(viewTime INT, userid BIGINT, page_url STRING, referrer_url STRING, ip STRING COMMENT 'IP Address of the User')
COMMENT 'This is the page view table'
PARTITIONED BY(dt STRING, country STRING)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\001'
STORED AS SEQUENCEFILE;    //TEXTFILE

//create & load(导数据)
create table tab_ip(id int, name string, ip string, country string)
row format delimited
fields terminated by ','
stored as textfile;
load data local inpath '/home/hadoop/ip.txt' into table tab_ext;

//external(该方法键的表的数据所使用的文件不是必须位于指定的hdfs文件夹下面，这样就不会干扰业务系统调用该文件了，因为manage_table在load文件系统hdfs上的文件时直接将该文件移动到对应的文件夹下了)
CREATE EXTERNAL TABLE tab_ip_ext(id INT, name STRING, ip STRING, country STRING)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
STORED AS TEXTFILE
LOCATION '/external/hive';
->在drop table的时候，MANAGE_TABLE在删除之后，其hdfs中的文件也会随之而删除；EXTERNAL_TABLE在删除之后，其hdfs中的文件仍然存在，系统只是删除了其元数据而已。

//CTAS    用于创建一些临时表存储中间结果
CREATE TABLE tab_ip_ctas 
AS 
SELECT id new_id, name new_name, ip new_ip, country new_country
FROM tab_ip_ext
SORT BY new_id;

//insert from select    用于向临时表中追加中间结果数据
create table tab_ip_like like tab_ip;

insert overwrite table tab_ip_like
    select * from tab_ip;

//CLUSTER <--相对高级一点，你可以放在有精力的时候去学习>
create table tab_ip_cluster(id int, name string, ip string, country string)
clustered by(id) into 3 buckets;

load data local inpath '/home/hadoop/ip.txt' overwrite into table tab_ip_cluster;
set hive.enforce.bucketing=true;
insert into table tab_ip_cluster select * from tab_ip;
select * from tab_ip_cluster tablesample(bucket 2 out of 3 on id);

//PARTITION
create table tab_ip_part(id int, name string, ip string, country string)
    partitioned by (part_flag string)
    row format delimited fields terminated by ',';

load data local inpath '/home/hadoop03/software/hivetestdata/ip.txt' overwrite into table tab_ip_part
    partition(part_flag='part1');

load data local inpath '/home/hadoop03/ip_part2.txt' overwrite into table tab_ip_part
    partition(part_flag='part2');

select * from tab_ip_part where part_flag='part2';
select count(*) from tab_ip_part where part_flag='part2';

alert table tab_ip change id id_alter string;
ALTER TABLE tab_cts ADD PARTITION (partCol = 'dt') location '/external/hive/dt';

show partitions tab_ip_part;


//write to hdfs
insert overwrite local directory '/home/hadoop/hivetemp/test.txt' select * from tab_ip_part where part_flag='part1';
insert overwrite directory '/hiveout.txt' select * from tab_ip_part where part_flag='part1';

//cli shell
hive -$ -e 'select country, count(*) from tab_ext' > /home/hadoop/hivetemp/e.txt
有了这种执行机制，就使得我们可以利用脚本语言(bash shell, python)进行hql语句的批量执行

select * from tab_ext sort by id desc limit 5;

select a.ip, b.book from tab_ext a join tab_ip_book b on(a.name==b.name);



//array
create table tab_array(a array, b array)
row format delimited
fields terminated by '\t'
collection items terminated by ',';

示例数据
tobenbrone,laihama,woshishei    13866987898,13287654321
abc,iloveou,itcat    13866987898,13287654321

select a[0] from tab_array;
select * from tab_array where array_contains(b, 'word');
insert into table tab_array select array(0), array(name, ip) from tab_ext t;

//map
create table tab_map(name string, info map)
row format delimited
fields terminated by '\t'
collection items terminated by ';'
map keys terminated by ':';

示例数据
fengjie    age:10;size:36A;addr:usa
furong    age:20;size:39C;addr:beijing;weight:180KG

load data local inpath '/home/hadoop/hivetemp/tab_map.txt' overwrite into table tab_map;
insert into table tab_map select name, map('name', name, 'ip', ip) from tab_ext;

//struct
create table tab_struct(name string, info struct)
row format delimited
fields terminated by '\t'
collection items terminated by ','

load data local inpath '/home/hadoop/hivetemp/tab_st.txt' overwrite into table tab_struct;
insert into table tab_struct select name, named_struct('age', id, 'tel', name, 'addr', country) from tab_ext;

//UDF 用户自定义函数
select if(id=1, first, no-first), name from tab_ext;

hive>add jar /home/hadoop/myudf.jar
hive>CREATE TEMPORARY FUNCTION my_lower AS 'org.dht.Lower';
select my_upper(name) from tab_ext;

->启动mysql时遇到的问题(ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/var/lib/mysql/mysql.sock' (111)):
->启动mysqld时总是失败:
->解决办法：查看/var/lib/mysql文件夹下的文件，可以看到文件mysql.sock的用户名和用户组都是mysql,
执行命令chown -R mysql:mysql /var/lib/mysql
执行命令service mysqld restart
之后mysqld服务重启成功
再执行命令mysql -uroot -p 就可以成功进入数据库

0000101    iphone6plus    64G    6888
0000102    xiaominote     64G    2388
0000103    iphone5s     64G    4388
0000104    mi4     64G    2388
0000105    mi3     64G    2388
0000106    meizu     64G    1388
0000107    huawei     64G    3388
0000108    zhongxing     64G    788


create table t_order(id int, name string, rongliang string, price double)
row format delimited            #表示一行就是一条记录
fields terminated by '\t'

==>2019.7.19(ios系统设置代理方法)：
——>ios系统搜索Outline App下载安装

安装完成进入App之后，需要输入accesskey:
->access-key生成方法：
首先需要把配置内容拼接在一起：
    ss://method:password@hostname:port
eg: ss://aes-256-gcm:p*****[email protected].***:****
将[method:password]部分通过Base64编码转换后得到:
    ss://[email protected].***:****

复制上面得到的access，进入Outline App后，App自动识别粘贴板的内容，点击进入连接即可

跳过Day06-05-hql语法及自定义函数(31'31'')等关于hql和hbase相关的课程简介

——>Storm

->Storm的基本概念：
Topologies:拓扑，俗称一个任务
Spouts:拓扑的消息源
Bolts:拓扑的处理逻辑单元
tuple：消息元组 Spouts和Bolts以及Bolts和Bolts之间传递信息的数据格式
Streams: 流
Tasks: 任务处理单元(实例)
Executor: 工作线程
Workers: 工作进程
Configuration: topology的配置

->Storm安装手册：
1.安装一个zookeeper集群
2.上传storm的安装包，解压
3.修改配置文件storm.yaml

#所使用的zookeeper集群主机
storm.zookeeper.servers:
     - "hadoop"
     - "hadoop02"
     - "hadoop03"

#Nimbus所在的主机名
nimbus.host: "hadoop"

supervisor.slots.ports #slot(工作槽位)就是一个worker进程，一个进程占一个端口
-6701
-6702
-6703
-6704
-6705

启动storm
在nimbus主机上
nohup ./storm nimbus 1>/dev/null 2>&1 & (启动storm)
nohup ./storm ui 1>/dev/null 2>&1 &     (启动storm的ui界面)

在supervisor主机上
nohup ./storm supervisor 1>/dev/null 2>&1 &

storm编程规范及demo编写：(其中的类RandomWorldSpout、UpperBolt、ShuffixBolt都是继承自接口自定义的与业务相关的类)
  Topologybuilder builder = new Topologybuilder();
  //将spout组件设置到topology中去
  //指定该组件有四个executor来执行
  //四个executor运行8个tasks
  builder.setSpout("randomspout", new RandomWorldSpout(), 4).setNumTasks(8);
  //将大写转换bolt组件设置到topology,并且指定它接收randomspout组件的消息
  builder.setBolt("upperbolt", new UpperBolt(), 4).shuffleGrouping("randomspout");
  //将添加后缀的bolt组件设置到topology，并且指定它接收upperbolt组件的消息
  builder.setBolt("suffixbolt", new SuffixBolt(), 4).shuffleGrouping("upperbolt");
  //用builder来创建一个topology
  StormTopology topology = builder.createTopology();

  //配置一些topology在集群上运行时的参数
  Config conf = new Config();
  //指定集群中有运行四个槽位，即四个worker
  conf.setNumWorkers(4);
  ....

  //将这个topology提交给storm集群运行
  StormSubmitter.submitTopology("demotopo", conf, topology);

->Storm中的Stream groupings:
  定义一个topology的关键一步是定义每个bolt接收什么样的流作为输入；
  stream grouping就是用来定义一个stream应该如何分配数据给bolts;
  Storm里面有7中类型的stream grouping:
    ->Shuffle Grouping——随机分组，随机派发stream里面的tuple,保证每个bolt接收到的tuple数量大致相同。
    ->Fields Grouping——按字段分组，比如按userid来分组，具有同样的userid的tuple会被分到相同的Bolts里的一个task,而不同的userid则会被分配到不同的bolts里的task
    ->All Grouping-广播发送
    ->Global Grouping-全局分组
    ->Non Grouping-不分组
    ->Direct Grouping-直接分组
    ->Local or shuffle grouping
->Storm 与 Hadoop的对比：
  ->Topology与Mapreduce的一个关键区别是：一个Mapreduce job最终会结束，而一个topology永远 会运行(除非你手动kill掉)
  ->Nimbus与ResourceManager：在Storm集群里面有两种节点：控制节点和工作节点。控制节点上面运行一个叫Nimbus后台程序，它的作用类似Hadoop里的Jobtracker。Nimbus负责在集群里分发代码，分配计算任务给机器，并且监控状态。
  ->Supervisor与NodeManager:每一个工作节点上面运行一个叫做Supervisor的节点。Supervisor会监听分配给它那台机器的工作，根据需要启动/关闭工作进程。每个工作进程执行一个topology的一个子集；一个运行的topology由运行在很多机器上的很多工作进程组成
->Storm中的Nimbus和Supervisor:
  Nimbus和Supervisor之间的所有协调工作都是通过Zookeeper集群完成的。
  Nimbus进程和Supervisor进程都是快速失败(fail-fast)和无状态的。所有的状态要么在zookeeper里面，要么在本地磁盘。
  即你可以kill -9 来杀死Nimbus和Supervisor进程，然后再重启它们，就好像什么都没有发生过。这个设计使得Storm异常的稳定。

->Storm常用命令：
  ./storm list (列出当前正在执行的topology, 即任务)
  ./storm kill 【拓扑名称】 停止Topologies

->Storm深入学习：
  分布式共享锁的实现
  事务topology的实现机制及开发模式
  在具体场景中的跟其他框架的整合(flume、activeMQ、kafka(分布式消息队列系统)、redis、hbase、mysql cluster)

——>Kafka

->kafka基本概念：
  Fast: 非常快，单个Kafka broker每秒能够读写数百兆字节从数千台客户端，
  Scalable： 可扩展，容量不够之后，可以通过增加机器来解决
  Durable: 消息可以持久化到硬盘上
  Distributed by Design

  kafka是一个分布式的消息缓存系统
  kafka集群中的服务器都叫做broker
  kafka有两类客户端，一类叫producer(消息生产者)，一类叫做consumer(消费者)，客户端和broker服务器之间采用tcp协议连接
  kafka中不同业务系统的消息可以通过topic进行区分，而且每一个消息topic都会被分区，以分担消息读写的负载
  每一个分区都可以有多个副本，以防止数据的丢失
  某一个分区中的数据如果需要更新，都必须通过该分区所有副本中的leader进行更新
  消费者可以分组，比如有两个消费者组A和B，共同消费一个topic: order_info, A和B所消费的消息不会重复，比如：order_info中有100个消息，每个消息有一个id, 编号从0-99，那么，如果A组消费0-49号，B组就消费50-99号
  消费者在具体消费某个topic中的消息时，可以指定起始偏移量(宕机后，可以从指定地方读起)

  ->kafka快速入门实际操作(基于独立的zookeeper集群环境下，多机器 现在最新版本的kafka 执行命令中用--bootstrap-server代替了--zookeeper是什么意思)：
    ->启动zookeeper集群和kafka集群：(在kafka根目录下，在后台运行时，需要在命令后加1>/dev/null 2>&1 &)
      ./bin/kafka-server-start.sh ./config/server.properties
    ->创建topic：(3个副本数，一个分区，topic名称是youshuo_test_topic)
      ./bin/kafka-topics.sh --create --zookeeper hadoop:2181 --replication-factor 3 --partitions 1 --topic test01
    ->查看topic列表：
      ./bin/kafka-topics.sh --list --zookeeper hadoop:2181
      hadoopTopic2
      test01
      youshuo_test_topic
    ->创建生产者：
      ./bin/kafka-console-producer.sh --broker-list hadoop:9092 --topic test01
    ->创建消费者：
      ./bin/kafka-console-consumer.sh --zookeeper hadoop:9092 --topic test01 --from-beginning
    ->查看某个话题状态信息 ：
      ./bin/kafka-topics.sh --describe --zookeeper hadoop:2181 --topic test01
->kafka客户端编程：
//生产者
public class ProducerDemo {
  public static void main(String[] args) {
    Properties props = new Properties();
    props.put("zk.connect", "hadoop:2181,hadoop02:2181,hadoop03:2181");
    props.put("metadata.broker.list", "hadoop:9092,hadoop02:9092,hadoop03:9092");
    props.put("serializer.class", "kafka.serializer.StringEncoder");
    ProducerConfig config = new ProducerConfig(props);
    Producer producer = new Producer(config);
   
    //发送业务消息
    //读取文件 读取内存数据库 读socket端口
    for (int i = 1; i <= 1000; i++) {
      producer.send(new KeyedMessage("Hey ", "i said i love you for " + i + "times"));
      Thread.sleep(500);
    }
  }
}
//消费者
public class ConsumerDemo {
  private static final String topic = "order";
  private static final Integer threads = 1;

  public static void main(String[] args) {
    Properties props = new Properties();
    props.put("zk.connect", "hadoop:2181,hadoop02:2181,hadoop03:2181");
    props.put("group.id", "1111");
    props.put("auto.offset.reset", "smallest");

    ConsumerConfig = config = new ConsumerConfig(props);
    ConsumerConnector consumer = Consumer.createJavaConsumerConnector(config);
    Map topicCountMap = new HashMap();
    topicCountMap.put("test01", 1); //param1: topicName; param2: threads
    topicCountMap.put("test02", 10);
    Map>> consumerMap = consumer.createMessageStreams(topicCountMap);
    List> streams = consumerMap.get(topic);

    for (final KafkaStream KafkaStream : streams) {
      new Thread(new Runnable() {
        @Override
        public void run() {
          for(MessageAndMetadata mm : kafkaStream) {
            String msg = new String(mm.message);
            sout(msg);
          }
        }
      }).start();
    }
  }
}

flink中国github社区

  ->flink介绍
    bound (bound、unbound)
    state (stateful、)
    time (Event Time、Processing Time)
    API
  ->flink基本概念：有状态流式处理引擎的基石
    有状态流式处理
    有状态流式处理的挑战
      状态容错(State Fault Tolerance)
      状态维护(State Managerment)
      Event-time处理(Event-time Processing)
      状态保存与迁移(Savepoints and Job Migration)