大数据相关知识点

hadoop是一个开源项目，所以很多公司在这个基础进行商业化，Cloudera对hadoop做了相应的改变。

Cloudera公司的发行版，我们将该版本称为CDH(Cloudera Distribution Hadoop)。

1. Hadoop入门知识

概念：Apache Hadoop是一个开源的、可靠的、可扩展的分布式计算框架

• 可扩展性：大量的普通计算机组成
• 可靠性：不依赖超级计算机的硬件提供可靠性，靠普通计算机在应用层上保障

---

• 2003-2004 的三篇论文
  • GFS：分布式文件系统，演变成HDFS
  • MapReduce：分布式计算框架（Java语言实现，开源）
    • 特点：扩展性&容错性&海量数据离线处理
  • BigTable：大型数据库，后续演变成HBase
  • 大数据计算都只是数数，简单的排序等；不能做复杂的操作
    一般的文件用open函数打开也能统计，但大数据量文件要用MapReduce操作

---

• 09年Cloudera推出CDH（Cloudera’s Dsitribution Including Apache Hadoop) ---- 目前大部分都用CDH，因为其稳定、加入许多新功能，如包含了Apache Hadoop。
• 2018年4月发展到了 ----Apache Hadoop 3.1 Available,目前是3.x系列，国内目前用的广的为2.5、2.6、2.7
• 18、19年Hadoop对1TB的数据进行排序最快在几秒或者十几秒的时间，有自身瓶颈，分布式的原因
• Hadoop出现的原因：
  • 搜索引擎时代：
    • 有保存大量网页的需求（单机、集群）
    • 词频统计 word count PageRank
• 数据仓库时代：
  • FaceBook推出Hive
  • 曾经进行数据分析和统计时，仅限于数据库，受数据量和计算能力的限制，我们只能对最重要的数据进行统计和分析（决策数据、财务相关）
  • Hive可以在Hadoop上运行SQL操作，可以把运行日志，应用采集数据、数据库数据放到一起分析(但是跑起来速度不会太快，但比在hadoop编码容易得多）
• 数据挖掘时代：
  • 啤酒尿不湿
  • 关联分析
  • 用户画像/物品画像
• 机器学习时代–广义大数据：
  • 大数据提高数据存储能力，为机器学习提供燃料
  • alpha go
  • siri 小爱 天猫精灵

1.2 Hadoop核心组件

• Hadoop Common：核心引擎（偏底层，不必深究）
• HDFS（分布式文件系统）：分布式存储作用是文件存储
  • 文件数据切块，每一个block 128MB（太大太小不合适，128MB比较符合）
  • 任意数据块默认3备份
  • NameNode（一般3台机器至少，存总体数据索引表） + DataNode（会有几千台机器做，存数据节点）
  • HDFS是GFS的开源实现
  • 特点：扩展性&容错性&海量数据存储（其它组件特点都是这三个）
    
• Hadoop YARN（资源调度系统）
  • 负责整个集群资源的管理和调度
  • YARN特点：扩展性&容错性&多框架资源统一调度
  • Hadoop1.x时代没有YARN，2.x时代才有，因为其它框架如Pig、Hive、HBase等都用HDFS做底层存储系统，所以用YARN统一调度。
  • YARN防止多进程同时写一个文件，但同时读文件可以

Hadoop优势：

• 高可靠：考数据的多副本，以及计算节点崩溃后，框架保证重新调度计算
• 高可扩展：普通计算机进行扩展，比较廉价
• Hadoop生态系统成熟（Apache基金会支持，用的人多，社区服务好，遇问题解决方便）
  • hadoop是容器，机器学习是门学问，python是语言，机器学习相关算法可以用python写，写好后在hadoop搭建的集群上面运行，机器学习统计计算，三者是相辅相成的
  • Hadoop是由Java编写的；可以说所有的大数据模块都是用java写的；Hadoop的创始人是Doug Cutting， 同时也是著名的基于Java的检索引擎库Apache Lucene的创始人

1.3 HDFS介绍

linux系统中文件的颜色表示：

• 红色文件 ———– 压缩文件或者包文件
• 蓝色文件 ———- 目录
• 白色文件（或黑色）———- 一般性文件，如文本文件，配置文件，源码文件等
• 浅蓝色文件 ———- 链接文件，主要是使用ln命令建立的文件
• 注意：官网下载时，会下载source源码包、目录方式的包以及tar.gz压缩包，尽量选中目录方式的，因为可以直接拿来用
  
  
  
  
  
  NameNode是基础核心，挂掉后其它组件如Pig、Spark都不能使用
• Jps常用命令整理：jps(JavaVirtualMachineProcessStatusTool)是JDK1.5提供的一个显示当前所有java进程pid的命令，简单实用，非常适合在linux/unix平台上简单察看当前运行的java进程
  
  
  
  注意：这里的mv只能在虚拟机本身的linux系统或者hdfs本身系统上去移动文件，不能跨两者移动文件，可以用put命令把linux系统的文件移动到hdfs系统上，get可以从hdfs系统上下载文件到linux系统
  -HDFS的常用命令：
  • 启动：./start-dfs.sh
  • jps查看进程
  • hadoop fs -ls /dir
  • hadoop fs -cat
  • hadoop fs -put
  • hadoop fs -mv
  • hadoop fs -mkdir
  • hadoop fs -rmr
    
    设计思路：在大量的廉价机器上进行部署，依靠3备份+应用层提供高可靠的访问服务
• 最低的集群需要4台集群，一个NameNode，三个DataNodes
• HDFS架构：
  • NameNode：存储元数据，10分钟收不到心跳信息，默认为DataNode挂掉
  • DataNode：存储真实数据，定期发送心跳信息
  • 优点：容错，构建在廉价机器上
  • 缺点：高延迟，不适合小文件（blodk每一块都要占用128MB)
    
    

1.3 HDFS环境搭建

下载jdk 和 hadoop 放到 ~/software目录下 然后解压到 ~/app目录下
tar -zxvf 压缩包名字 -C ~/app/
配置环境变量

vi ~/.bash_profile
export JAVA_HOME=/home/hadoop/app/jdk1.8.0_91
export PATH=$JAVA_HOME/bin:$PATH
export HADOOP_HOME=/home/hadoop/app/hadoop......
export PATH=$HADOOP_HOME/bin:$PATH

#保存退出后
source ~/.bash_profile
进入到解压后的hadoop目录 修改配置文件

配置文件作用
core-site.xml 指定hdfs的访问方式
hdfs-site.xml 指定namenode 和 datanode 的数据存储位置
mapred-site.xml 配置mapreduce
yarn-site.xml 配置yarn
修改hadoop-env.sh

cd etc/hadoop
vi hadoop-env.sh
#找到下面内容添加java home
export_JAVA_HOME=/home/hadoop/app/jdk1.8.0_91
修改 core-site.xml 在 节点中添加
<property>
  <name>fs.default.name</name>
  <value>hdfs://hadoop000:8020</value>
</property>
修改hdfs-site.xml 在 configuration节点中添加
<property>
    <name>dfs.namenode.name.dir</name>
    <value>/home/hadoop/app/tmp/dfs/name</value>
</property>
<property>
    <name>dfs.datanode.data.dir</name>
    <value>/home/hadoop/app/tmp/dfs/data</value>
</property>
<property>
    <name>dfs.replication</name>
    <value>1</value>
</property>
修改 mapred-site.xml
默认没有这个 从模板文件复制
cp mapred-site.xml.template mapred-site.xml
​ 在mapred-site.xml 的configuration 节点中添加

<property>
    <name>mapreduce.framework.name</name>
    <value>yarn</value>
</property>
修改yarn-site.xml configuration 节点中添加
<property>
    <name>yarn.nodemanager.aux-services</name>
    <value>mapreduce_shuffle</value>
</property>
来到hadoop的bin目录

./hadoop namenode -format (这个命令只运行一次)
启动hdfs 进入到 sbin

./start-dfs.sh
启动启动yarn 在sbin中
./start-yarn.sh

1.3 YARN

• YARN的工作原理和流程
  • YARN产生于Hadoop2.x时代，主要用来协调不同的计算框架(如Pig、Spark等）
  • 更好的利用集群，让不同的框架可以并行的访问HDFS资源
  • ResourceManager：有且仅有一个，总体的资源协调者
  • NodeManager：节点管理器，收到RM命令并启动Container
  • Container：一个封装的抽象，可以理解为一个小型计算机
  • 好处：Yet Another Resource Negotiator, 另一种资源协调者
    通用资源管理系统
    为上层应用提供统一的资源管理和调度，为集群在利用率、资源统一管理和数据共享等方面带来了巨大好处
    
    

1.4 MapReduce — 分布式处理框架

1. 什么是MapReduce？
   • 源于Google的MapReduce论文(2004年12月)
   • Hadoop的MapReduce是Google论文的开源实现
   • MapReduce优点：海量数据离线处理&易开发
   • MapReduce缺点：实时流式计算
2. MapReduce编程模型
   
   
3. Hadoop Streaming实现wordcount

############## Mapper的实现##################
import sys

for line in sys.stdin:
    line = line.strip()
    words = line.split()
    for word in words:
        print("%s %s"%(word,1))

################Reducer的实现######################
import sys

current_word = None
current_count = 0
word = None

#获取标准输入，即mapper.py的标准输出（也可以从命令行获取输入）
for line in sys.stdin:
    #删除开头和结尾的空行
    line = line.strip()
    #解析mapper.py输出作为程序的输入，以tab作为分隔符
    word, count = line.split()
    
    try:
        count = int(count)    ##转换count从字符型到整型
    except ValueError:
        continue

    if current_word == word:        # 一开始：None 是不等于word，走else
        current_count += count
    else:
        #出现了一个新词
        #输出当前word统计结果到标准输出
        if current_word:
            print("%s\t%s" %( current_word, current_count)  #一开始输出：None：0
        #开始对新词的统计
        current_count = count
        current_word = word

#输出最后一个word统计
if current_word == word:
    print("%s\t%s" % (current_word, current_count))

• cat xxx.txt|python3 map.py|sort|python3 red.py

• 得到最终的输出

• 注：hadoop-streaming会主动将map的输出数据进行字典排序

通过Hadoop Streaming 提交作业到Hadoop集群

HADOOP_CMD="/usr/local/src/hadoop-1.2.1/bin/hadoop" #hadoop安装路径
STREAM_JAR_PATH="/usr/local/src/hadoop-1.2.1/contrib/streaming/hadoop-streaming-1.2.1.jar"    # hadoop streaming jar包所在位置

INPUT_FILE_PATH_1="/The_Man_of_Property.txt"  #要进行词频统计的文档在hdfs中的路径
OUTPUT_PATH="/output"                         #MR作业后结果的存放路径

$HADOOP_CMD fs -rmr -skipTrash $OUTPUT_PATH    # 输出路径如果之前存在 先删掉否则会报错

$HADOOP_CMD jar $STREAM_JAR_PATH \   
        -input $INPUT_FILE_PATH_1 \ # 指定输入文件位置
        -output $OUTPUT_PATH \      #指定输出结果位置
        -mapper "python map.py" \   #指定mapper执行的程序
        -reducer "python red.py" \  # 指定reduce阶段执行的程序
        -file ./map.py \            # 通过-file 把python源文件分发到集群的每一台机器上  
        -file ./red.py

以下为直接可以执行的程序：
HADOOP_CMD="/home/hadoop/app/hadoop-2.6.0-cdh5.7.0/bin/hadoop"
STREAM_JAR_PATH="/home/hadoop/app/hadoop-2.6.0-cdh5.7.0/share/hadoop/tools/lib/hadoop-streaming-2.6.0-cdh5.7.0.jar"

INPUT_FILE_PATH_1="/b.txt"
OUTPUT_PATH="/output"

$HADOOP_CMD fs -rm -R -skipTrash $OUTPUT_PATH

$HADOOP_CMD jar $STREAM_JAR_PATH \
 -input $INPUT_FILE_PATH_1 \
 -output $OUTPUT_PATH \
 -mapper "python map.py" \
 -reducer "python red.py" \
 -file ./map.py \
 -file ./red.py

sh hadoop-streaming.sh运行任务
到Hadoop集群查看运行结果—如命令hadoop fs -cat /tmp/output/20190518/prat-00000

利用MRJob编写和运行MapReduce代码

MapReduce实战

mrjob 简介

使用python开发在Hadoop上运行的程序, mrjob是最简单的方式
mrjob程序可以在本地测试运行也可以部署到Hadoop集群上运行
如果不想成为hadoop专家, 但是需要利用Hadoop写MapReduce代码,mrJob是很好的选择
mrjob 安装

使用pip安装
pip install mrjob
mrjob实现WordCount

from mrjob.job import MRJob

class MRWordFrequencyCount(MRJob):

    def mapper(self, _, line):
        yield "chars", len(line)
        yield "words", len(line.split())
        yield "lines", 1

    def reducer(self, key, values):
        yield key, sum(values)


if __name__ == '__main__':
    MRWordFrequencyCount.run()
运行WordCount代码

打开命令行, 找到一篇文本文档, 敲如下命令:

python mr_word_count.py my_file.txt
3.3.2 运行MRJOB的不同方式
1、内嵌(-r inline)方式

特点是调试方便，启动单一进程模拟任务执行状态和结果，默认(-r inline)可以省略，输出文件使用 > output-file 或-o output-file，比如下面两种运行方式是等价的

python word_count.py -r inline input.txt > output.txt python word_count.py input.txt > output.txt

2、本地(-r local)方式

用于本地模拟Hadoop调试，与内嵌(inline)方式的区别是启动了多进程执行每一个任务。如：

python word_count.py -r local input.txt > output1.txt

3、Hadoop(-r hadoop)方式

用于hadoop环境，支持Hadoop运行调度控制参数，如：

1)指定Hadoop任务调度优先级(VERY_HIGH|HIGH),如：--jobconf mapreduce.job.priority=VERY_HIGH。

2)Map及Reduce任务个数限制，如：--jobconf mapreduce.map.tasks=2 --jobconf mapreduce.reduce.tasks=5

python word_count.py -r hadoop hdfs:///test.txt -o hdfs:///output

3.3.3 mrjob 实现 topN统计（实验）
统计数据中出现次数最多的前n个数据

import sys
from mrjob.job import MRJob,MRStep
import heapq

class TopNWords(MRJob):
    def mapper(self, _, line):
        if line.strip() != "":
            for word in line.strip().split():
                yield word,1

    #介于mapper和reducer之间，用于临时的将mapper输出的数据进行统计
    def combiner(self, word, counts):
        yield word,sum(counts)

    def reducer_sum(self, word, counts):
        yield None,(sum(counts),word)

    #利用heapq将数据进行排序，将最大的2个取出
    def top_n_reducer(self,_,word_cnts):
        for cnt,word in heapq.nlargest(2,word_cnts):
            yield word,cnt

    #实现steps方法用于指定自定义的mapper，comnbiner和reducer方法
    def steps(self):
        return [
            MRStep(mapper=self.mapper,
                   combiner=self.combiner,
                   reducer=self.reducer_sum),
            MRStep(reducer=self.top_n_reducer)
        ]

def main():
    TopNWords.run()

if __name__=='__main__':
    main()

 MRJOB 文件合并
需求描述

两个文件合并 类似于数据库中的两张表合并
mrjob 实现

实现对两个数据表进行join操作，显示效果为每个用户的所有订单信息

"01:user1"    "01:80,02:90"
"02:user2"    "03:82,04:95"
from mrjob.job import MRJob
import os
import sys
class UserOrderJoin(MRJob):
    SORT_VALUES = True
    # 二次排序参数：http://mrjob.readthedocs.io/en/latest/job.html
    def mapper(self, _, line):
        fields = line.strip().split('\t')
        if len(fields) == 2:
            # user data
            source = 'A'
            user_id = fields[0]
            user_name = fields[1]
            yield  user_id,[source,user_name]
        elif len(fields) == 3:
            # order data
            source ='B'
            user_id = fields[0]
            order_id = fields[1]
            price = fields[2]
            yield user_id,[source,order_id,price]
        else :
            pass

    def reducer(self,user_id,values):
        '''
        每个用户的订单列表
        "01:user1"    "01:80,02:90"
        "02:user2"    "03:82,04:95"

        :param user_id:
        :param values:
        :return:
        '''
        values = [v for v in values]
        if len(values)>1 :
            user_name = values[0][1]
            order_info = [':'.join([v[1],v[2]]) for v in values[1:]]
            yield ':'.join([user_id,user_name]),','.join(order_info)




def main():
    UserOrderJoin.run()

if __name__ == '__main__':
    main()
实现对两个数据表进行join操作，显示效果为每个用户所下订单的订单总量和累计消费金额

"01:user1"    [2, 170]
"02:user2"    [2, 177]
from mrjob.job import MRJob
import os
import sys
class UserOrderJoin(MRJob):
    # 二次排序参数：http://mrjob.readthedocs.io/en/latest/job.html
    SORT_VALUES = True

    def mapper(self, _, line):
        fields = line.strip().split('\t')
        if len(fields) == 2:
            # user data
            source = 'A'
            user_id = fields[0]
            user_name = fields[1]
            yield  user_id,[source,user_name]
        elif len(fields) == 3:
            # order data
            source ='B'
            user_id = fields[0]
            order_id = fields[1]
            price = fields[2]
            yield user_id,[source,order_id,price]
        else :
            pass



    def reducer(self,user_id,values):
        '''
        统计每个用户的订单数量和累计消费金额
        :param user_id:
        :param values:
        :return:
        '''
        values = [v for v in values]
        user_name = None
        order_cnt = 0
        order_sum = 0
        if len(values)>1:
            for v in values:
                if len(v) ==  2 :
                    user_name = v[1]
                elif len(v) == 3:
                    order_cnt += 1
                    order_sum += int(v[2])
            yield ":".join([user_id,user_name]),(order_cnt,order_sum)



def main():
    UserOrderJoin().run()

if __name__ == '__main__':
    main()

MapReduce原理 （了解即可）

• MapReduce执行流程
  • 第一步：数据从HDFS上面分块并进行data split
  • 第二步：执行mapper函数，用户自定义逻辑
  • 第三步：mapper的结果不停的写缓冲区，达到80%开始执行spill溢写操作，溢写到磁盘上
  • 第四步：归并排序
  • 第五步：外部文件的合并，merge操作，是在多台机器之间进行
  • 第六步：执行reducer函数，用户自定义逻辑
    

1.5 Hadoop概念扩展

• hadoop集群最大是15000台机器工作
  

Hive:数据仓库
R:数据分析
Mahout:机器学习库
pig：脚本语言，跟Hive类似（基本被Hive取代）
Oozie:工作流引擎，管理作业执行顺序
Zookeeper:用户无感知，主节点挂掉选择从节点作为主的
Flume:日志收集框架
Sqoop:数据交换框架，例如：关系型数据库与HDFS之间的数据交换
Hbase : 海量数据中的查询，相当于分布式文件系统中的数据库
Spark: 分布式的计算框架（可以达到秒级）
Kafka: 消息队列
Storm: 分布式的流式计算框架（可以达到毫秒级）（缺点：只能拿阶段性数据跑）
Flink: 分布式的流式计算框架（可以达到毫秒级）

######################Hadoop生态系统的特点#####################

• 开源、社区活跃
• 囊括了大数据处理的方方面面
• 成熟的生态圈

1.6 Flume

• Flume 是 Cloudera 提供的一个高可用的，高可靠的，分布式的海量日志采集、聚合和传输的软件。

• Flume 的核心是把数据从数据源(source)收集过来，再将收集到的数据送到指定的目的地(sink)。为了保证输送的过程一定成功，在送到目的地(sink)之前，会先缓存数据(channel),待数据真正到达目的地(sink)后，flume 在删除自己缓存的数据。

• Flume 支持定制各类数据发送方，用于收集各类型数据；同时，Flume 支持定制各种数据接收方，用于最终存储数据。一般的采集需求，通过对 flume 的简单配置即可实现。针对特殊场景也具备良好的自定义扩展能力。因此，flume 可以适用于大部分的日常数据采集场景。

• 下图保证结尾的cdh版本一致即可对应使用
  

• Flume发展史

  • 当前 Flume 有两个版本。Flume 0.9X 版本的统称 Flume OG（original generation），Flume1.X 版本的统称 Flume NG(Flume-728)（next generation）。由于 Flume NG 经过核心组件、核心配置以及代码架构重构，与 Flume OG 有很大不同，使用时请注意区分。改动的另一原因是将 Flume 纳入 apache 旗下，Cloudera Flume 改名为 Apache Flume。

1.7 Spark

• 概念：基于内存的计算引擎，它的计算速度非常快。但是仅仅只涉及数据的计算，并没有涉及数据的储存。
• Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎
• 为什么学习spark？
  • MapReduce框架局限性
    • Map结果写磁盘，Reduce写HDFS，多个MR之间通过HDFS交换数据
    • 任务调度和启动开销大
    • 无法充分利用内存
    • 不适合迭代计算（如机器学习、图计算等等），交换式处理（数据挖掘）
    • 不适合流式处理（点击日志分析）
    • MapReduce变成不够灵活，仅支持Map和Reduce两种操作
      Hadoop生态圈
• 批处理：MapReduce、Hive、Pig
• 流式计算：Storm
• 交互式计算：Impala、presto
• 需要一种灵活的框架可同时进行批处理、流式计算、交互式计算— Spark

内存计算引擎，提供cache机制来支持需要反复迭代计算或者多次数据共享，减少数据读取的IO开销
DAG引擎，较少多次计算之间中间结果写到HDFS的开销
使用多线程模型来减少task启动开销，shuffle过程中避免不必要的sort操作以及减少磁盘IO
spark的缺点是：吃内存，不太稳定

spark特点
1、速度快（比mapreduce在内存中快100倍，在磁盘中快10倍）
spark中的job中间结果可以不落地，可以存放在内存中。
mapreduce中map和reduce任务都是以进程的方式运行着，而spark中的job是以线程方式运行在进程中。
2、易用性（可以通过java/scala/python/R开发spark应用程序）
3、通用性（可以使用spark sql/spark streaming/mlib/Graphx）
4、兼容性（spark程序可以运行在standalone/yarn/mesos）

Spark2.x 新特性
SparkSession：新的上下文入口，统一SQLContext和HiveContext
dataframe和dataset统一，dataframe只是dataset[ROW]的类型别名
dataset在spark1.6出现，在spark2.x时，dataframe只是dataset[ROW]的类型别名，但是dataset是一种强类型语言设定，由于python是弱类型语言，只能使用DataFrame

dataframe本身是scala实现，而spark也是scala语言写的，python只是一个壳子，对于python编写的spark代码性能不变

Spark SQL支持sql 2003标准
支持ansi-sql
支持ddl命令
支持子查询：in/not in、exists/not exists
提升catalyst查询优化器的性能
code generation技术将spark sql和dataset的性能提升2~10倍(钨丝计划)
vectorization技术提升parquet文件的扫描吞吐量
spark mllib基于rdd的api转为维护阶段
未来将主要基于dataset api的ml，向量和矩阵使用性能更高的序列化机制

• 任意一个框架都有自身特殊的数据结构
• RDD（Resilient Distributed Dataset）叫做弹性分布式数据集，是Spark中最基本的数据抽象，他代表一个不可变、可分区、里面的元素可并行计算的集合。

Spark SQL

• 它是spark中用于处理结构化数据的一个模块
• 为什么要学习sparksql
• sparksql特性
  1、易整合
  2、统一的数据源访问
  3、兼容hive
  4、提供了标准的数据库连接（jdbc/odbc）

kafka消息中间件

Kafka 是一种高吞吐量 [2] 的分布式发布订阅消息系统，有如下特性：
通过O(1)的磁盘数据结构提供消息的持久化，这种结构对于即使数以TB的消息存储也能够保持长时间的稳定性能。
高吞吐量：即使是非常普通的硬件Kafka也可以支持每秒数百万的消息。
支持通过Kafka服务器和消费机集群来分区消息。
支持Hadoop并行数据加载。
Kafka通过官网发布了最新版本2.5.0

Kafka三代 - Broker集群
很明显，为了解决高可用问题，我们需要集群。

Kafka对集群的支持也是非常友好的。在Kafka中，集群里的每个实例叫做Broker，就像这样：

每个partition不再只有一个，而是有一个leader(红色)和多个replica(蓝色)，生产者根据消息的topic和key值，确定了消息要发往哪个partition之后（假设是p1），会找到partition对应的leader(也就是broker2里的p1)，然后将消息发给leader，leader负责消息的写入，并与其余的replica进行同步。

一旦某一个partition的leader挂掉了，那么只需提拔一个replica出来，让它成为leader就ok了，系统依旧可以正常运行。

通过Broker集群的设计，我们不仅解决了系统高可用的问题，还进一步提升了系统的吞吐量，因为replica同样可以为消费者提供数据查找的功能。

zookeeper默认端口号
代码访问client的端口号： 2181
leader和flower通信的端口号： 2888
选举leader时通信的端口号： 3888
其他服务与监控中心通信端口： 7070

kafka监控的点：
1 CPU的使用率 top 查看的 %CPU 真实含义是进程使用的所有 CPU 的平均使用率，只是 top 命令在显示的时候转换成了单个 CPU。因此，如果是在多核的主机上，这个值就可能会超过 100。在这个例子中，我的主机有 4 个 CPU 核，总 CPU 使用率是 102.3，那么，平均每个 CPU 的使用率大致是 25%。
2 JVM监控 监控 JVM 进程主要是全面了解 Broker 进程。比如，Broker 进程的堆大小是多少、各自的新生代和老年代是多大？用的是什么 GC 回收器？这些监控指标和配置参数林林总总，至少要搞清楚 Broker 端 JVM 进程的 Minor GC 和 Full GC 的发生频率和时长、活跃对象的总大小和 JVM 上应用线程的大致总数，因为这些数据都是日后调优 Kafka Broker 的重要依据。
JVM 进程监控 3 个指标：
Full GC 发生频率和时长。这个指标评估 Full GC 对 Broker 进程的影响。长时间的停顿会令 Broker 端抛出各种超时异常。
活跃对象大小。这个指标是设定堆大小的重要依据，同时它还能细粒度地调优 JVM 各个代的堆大小。
应用线程总数。这个指标帮助了解 Broker 进程对 CPU 的使用情况。