大数据相关知识点

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 的使用情况。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值