将设为首页浏览此站
开启辅助访问 天气与日历 收藏本站联系我们切换到窄版

易陆发现论坛

 找回密码
 开始注册
查看: 34|回复: 1
收起左侧

Kafka 快速搭建

[复制链接]
发表于 2022-12-30 09:08:01 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。

您需要 登录 才可以下载或查看,没有帐号?开始注册

x
在了解完 Kafka 的基本概念之后,我们通过搭建 Kafka 集群来进一步深刻认识一下 Kafka。
确保安装环境安装 Java 环境
在安装 Kafka 之前,先确保Linux 环境上是否有 Java 环境,使用 java -version 命令查看 Java 版本,推荐使用Jdk 1.8 ,如果没有安装 Java 环境的话,可以按照这篇文章进行安装(https://www.cnblogs.com/zs-notes/p/8535275.html
安装 Zookeeper 环境
Kafka 的底层使用 Zookeeper 储存元数据,确保一致性,所以安装 Kafka 前需要先安装 Zookeeper,Kafka 的发行版自带了 Zookeeper ,可以直接使用脚本来启动,不过安装一个 Zookeeper 也不费劲
Zookeeper 单机搭建
Zookeeper 单机搭建比较简单,直接从 https://www.apache.org/dyn/closer.cgi/zookeeper/ 官网下载一个稳定版本的 Zookeeper ,这里我使用的是 3.4.10,下载完成后,在 Linux 系统中的 /usr/local 目录下创建 zookeeper 文件夹,使用xftp 工具(xftp 和 xshell 工具都可以在官网 https://www.netsarang.com/zh/xshell/ 申请免费的家庭版)把下载好的 zookeeper 压缩包放到 /usr/local/zookeeper 目录下。
如果下载的是一个 tar.gz 包的话,直接使用 tar -zxvf zookeeper-3.4.10.tar.gz解压即可
如果下载的是 zip 包的话,还要检查一下 Linux 中是否有 unzip 工具,如果没有的话,使用 yum install unzip 安装 zip 解压工具,完成后使用 unzip zookeeper-3.4.10.zip 解压即可。
解压完成后,cd 到 /usr/local/zookeeper/zookeeper-3.4.10 ,创建一个 data 文件夹,然后进入到 conf 文件夹下,使用 mv zoo_sample.cfg zoo.cfg 进行重命名操作
然后使用 vi 打开 zoo.cfg ,更改一下dataDir = /usr/local/zookeeper/zookeeper-3.4.10/data ,保存。
进入bin目录,启动服务输入命令 ./zkServer.sh start 输出下面内容表示搭建成功

/ i- ^; R  K- e+ y                               
登录/注册后可看大图
关闭服务输入命令,./zkServer.sh stop

8 u) h6 ?  i( y$ P                               
登录/注册后可看大图
使用 ./zkServer.sh status 可以查看状态信息。
Zookeeper 集群搭建准备条件
准备条件:需要三个服务器,这里我使用了CentOS7 并安装了三个虚拟机,并为各自的虚拟机分配了1GB的内存,在每个 /usr/local/ 下面新建 zookeeper 文件夹,把 zookeeper 的压缩包挪过来,解压,完成后会有 zookeeper-3.4.10 文件夹,进入到文件夹,新建两个文件夹,分别是 data 和 log 文件夹
注:上一节单机搭建中已经创建了一个data 文件夹,就不需要重新创建了,直接新建一个 log 文件夹,对另外两个新增的服务需要新建这两个文件夹。
设置集群
新建完成后,需要编辑 conf/zoo.cfg 文件,三个文件的内容如下
1- o1 j/ I4 m9 L& W7 X
26 @+ ?1 ^# l/ n$ R- [4 X
3" @' a7 N4 ^; S9 Q  @9 Y- L6 \
4
+ Z/ D# M9 P" T. k55 j6 r0 i9 i% ~" d5 P
6# ?+ s3 v6 j  D% A1 B% e7 @
71 T, O7 M, A4 Y4 \* z
8! B9 ~4 ]0 k. k- B& S3 q6 ^  g% {
9
tickTime=2000initLimit=10syncLimit=5dataDir=/usr/local/zookeeper/zookeeper-3.4.10/datadataLogDir=/usr/local/zookeeper/zookeeper-3.4.10/logclientPort=12181server.1=192.168.1.7:12888:13888server.2=192.168.1.8:12888:13888server.3=192.168.1.9:12888:13888

- t; ?. Y9 Z5 K, s; g
: l, Z" y' t$ }0 f0 ~
server.1 中的这个 1 表示的是服务器的标识也可以是其他数字,表示这是第几号服务器,这个标识要和下面我们配置的 myid 的标识一致可以。
192.168.1.7:12888:13888 为集群中的 ip 地址,第一个端口表示的是 master 与 slave 之间的通信接口,默认是 2888,第二个端口是leader选举的端口,集群刚启动的时候选举或者leader挂掉之后进行新的选举的端口,默认是 3888
现在对上面的配置文件进行解释
tickTime: 这个时间是作为 Zookeeper 服务器之间或客户端与服务器之间维持心跳的时间间隔,也就是每个 tickTime 时间就会发送一个心跳。
initLimit:这个配置项是用来配置 Zookeeper 接受客户端(这里所说的客户端不是用户连接 Zookeeper 服务器的客户端,而是 Zookeeper 服务器集群中连接到 Leader 的 Follower 服务器)初始化连接时最长能忍受多少个心跳时间间隔数。当已经超过 5个心跳的时间(也就是 tickTime)长度后 Zookeeper 服务器还没有收到客户端的返回信息,那么表明这个客户端连接失败。总的时间长度就是 5*2000=10 秒
syncLimit: 这个配置项标识 Leader 与Follower 之间发送消息,请求和应答时间长度,最长不能超过多少个 tickTime 的时间长度,总的时间长度就是5*2000=10秒
dataDir: 快照日志的存储路径
dataLogDir: 事务日志的存储路径,如果不配置这个那么事务日志会默认存储到dataDir指定的目录,这样会严重影响zk的性能,当zk吞吐量较大的时候,产生的事务日志、快照日志太多
clientPort: 这个端口就是客户端连接 Zookeeper 服务器的端口,Zookeeper 会监听这个端口,接受客户端的访问请求。
创建 myid 文件
在了解完其配置文件后,现在来创建每个集群节点的 myid ,我们上面说过,这个 myid 就是 server.1 的这个 1 ,类似的,需要为集群中的每个服务都指定标识,使用 echo 命令进行创建
1" d/ w- t8 T; W! g
24 h/ i( D* d; o9 n9 F" x
3" w" @* J0 r  C
4+ E" H$ w4 I6 l2 _: N9 a2 k
5
) T: A' Q' X+ p! D, J6
# server.1echo "1" > /usr/local/zookeeper/zookeeper-3.4.10/data/myid# server.2echo "2" > /usr/local/zookeeper/zookeeper-3.4.10/data/myid# server.3echo "3" > /usr/local/zookeeper/zookeeper-3.4.10/data/myid
; P+ y' P/ y2 \0 f- H4 h
9 b( _4 r, O% O$ X  S5 y3 u# d  J
启动服务并测试
配置完成,为每个 zk 服务启动并测试,我在 windows 电脑的测试结果如下
启动服务(每台都需要执行)
1
- u2 u2 o& d! c% G' o3 x$ I+ t' w2
cd /usr/local/zookeeper/zookeeper-3.4.10/bin./zkServer.sh start
' Z  A, X/ J2 a+ N
1 }" Y$ n4 v$ y7 W7 H% f
检查服务状态
使用 ./zkServer.sh status 命令检查服务状态
192.168.1.7 — follower

% Y1 T4 |) U7 E                               
登录/注册后可看大图
192.168.1.8 — leader

* f) O6 q: J6 G3 h                               
登录/注册后可看大图
192.168.1.9 — follower

- O! \, g6 }3 }6 k; N& K                               
登录/注册后可看大图
zk集群一般只有一个leader,多个follower,主一般是相应客户端的读写请求,而从主同步数据,当主挂掉之后就会从follower里投票选举一个leader出来。
Kafka 集群搭建准备条件
在 /usr/local 下新建 kafka 文件夹,然后把下载完成的 tar.gz 包移到 /usr/local/kafka 目录下,使用 tar -zxvf 压缩包 进行解压,解压完成后,进入到 kafka_2.12-2.3.0 目录下,新建 log 文件夹,进入到 config 目录下
我们可以看到有很多 properties 配置文件,这里主要关注 server.properties 这个文件即可。
: s0 @" f/ C9 C
                               
登录/注册后可看大图
kafka 启动方式有两种,一种是使用 kafka 自带的 zookeeper 配置文件来启动(可以按照官网来进行启动,并使用单个服务多个节点来模拟集群http://kafka.apache.org/quickstart#quickstart_multibroker),一种是通过使用独立的zk集群来启动,这里推荐使用第二种方式,使用 zk 集群来启动
修改配置项
需要为每个服务都修改一下配置项,也就是server.properties, 需要更新和添加的内容有
1* U) j9 c; _- A$ n; C+ {* C' c
2+ E5 g7 `) I& e- G8 I2 W9 f
3
# l$ ?, n8 ?! U% f$ i" L; f- y0 j4. D4 w( S8 D7 q. z- P1 x4 `# U
5
  N) d/ t+ Z9 h  Z- Y6
; \, n1 b( ^% Y* Q7
4 h: v' E' I$ m$ H; Y1 _80 K8 \+ ?9 S% X6 S
9
+ ], G7 I# T  V% L10
broker.id=0 //初始是0,每个 server 的broker.id 都应该设置为不一样的,就和 myid 一样 我的三个服务分别设置的是 1,2,3log.dirs=/usr/local/kafka/kafka_2.12-2.3.0/log#在log.retention.hours=168 下面新增下面三项message.max.byte=5242880default.replication.factor=2replica.fetch.max.bytes=5242880#设置zookeeper的连接端口zookeeper.connect=192.168.1.7:2181,192.168.1.8:2181,192.168.1.9:2181
/ J% C+ d7 p! a' T
: B: b; k$ i6 b
配置项的含义
1" a5 k' _/ J: k  E7 b0 Q6 J
2
1 H  F: E( k' i; p; F1 W6 \) F39 u9 u$ F; g# i+ J
4
& T+ p5 F( O& Z% ]! t5) i8 O& O* P$ L/ r4 L' U& S
6
& Q% t# K" [) p7
8 l% V. q3 b( o0 [+ d% q& I8
( @# E% X7 \7 b7 r5 J9
' d4 A) C( U. K3 N: h9 Q10( F4 f; G# u- `* T1 x9 |( C
11
% o4 n- E2 B$ E* Z12
1 z. D1 c) d$ X132 \1 r- ~* K1 `. v2 H# u/ K$ I  O
14
9 z1 ?2 K6 X$ w6 a4 }' Z( T/ ^# M4 f0 |150 H4 z# j2 w- C. t* Z
16
6 H  e+ ^5 k8 A% z$ k  ?( ?17$ m0 W, M6 M5 i: M" ]
18
broker.id=0  #当前机器在集群中的唯一标识,和zookeeper的myid性质一样port=9092 #当前kafka对外提供服务的端口默认是9092host.name=192.168.1.7 #这个参数默认是关闭的,在0.8.1有个bug,DNS解析问题,失败率的问题。num.network.threads=3 #这个是borker进行网络处理的线程数num.io.threads=8 #这个是borker进行I/O处理的线程数log.dirs=/usr/local/kafka/kafka_2.12-2.3.0/log #消息存放的目录,这个目录可以配置为“,”逗号分割的表达式,上面的num.io.threads要大于这个目录的个数这个目录,如果配置多个目录,新创建的topic他把消息持久化的地方是,当前以逗号分割的目录中,那个分区数最少就放那一个socket.send.buffer.bytes=102400 #发送缓冲区buffer大小,数据不是一下子就发送的,先回存储到缓冲区了到达一定的大小后在发送,能提高性能socket.receive.buffer.bytes=102400 #kafka接收缓冲区大小,当数据到达一定大小后在序列化到磁盘socket.request.max.bytes=104857600 #这个参数是向kafka请求消息或者向kafka发送消息的请请求的最大数,这个值不能超过java的堆栈大小num.partitions=1 #默认的分区数,一个topic默认1个分区数log.retention.hours=168 #默认消息的最大持久化时间,168小时,7天message.max.byte=5242880  #消息保存的最大值5Mdefault.replication.factor=2  #kafka保存消息的副本数,如果一个副本失效了,另一个还可以继续提供服务replica.fetch.max.bytes=5242880  #取消息的最大直接数log.segment.bytes=1073741824 #这个参数是:因为kafka的消息是以追加的形式落地到文件,当超过这个值的时候,kafka会新起一个文件log.retention.check.interval.ms=300000 #每隔300000毫秒去检查上面配置的log失效时间(log.retention.hours=168 ),到目录查看是否有过期的消息如果有,删除log.cleaner.enable=false #是否启用log压缩,一般不用启用,启用的话可以提高性能zookeeper.connect=192.168.1.7:2181,192.168.1.8:2181,192.168.1.9:2181 #设置zookeeper的连接端口

& `6 @! ]" o) G6 W
+ J- V$ K* p7 W5 {8 }5 G+ T
启动 Kafka 集群并测试
  • 启动服务,进入到 /usr/local/kafka/kafka_2.12-2.3.0/bin 目录下# A* M+ C* a5 W4 u, j
1
7 g. [# c4 d2 H7 s$ T2 R* Z2
# 启动后台进程./kafka-server-start.sh -daemon ../config/server.properties
% l, U- j1 L* H6 L; M

& I, Z8 I6 ~# n8 q2 \+ I: A& J7 K
  • 检查服务是否启动6 |) q. [( l8 k; F: V, V$ |
12 x7 J4 e. O  p+ W
2' Q& v; G" t7 ]) E4 h! U+ O7 ]
3
2 \- h4 N' ~0 u9 j$ v0 s4
# 执行命令 jps6201 QuorumPeerMain7035 Jps6972 Kafka
4 a5 {) `5 I1 I2 z, N3 ]0 o" S6 J
* C0 P+ w* G0 T4 L
  • kafka 已经启动
  • 创建 Topic 来验证是否创建成功* n7 v" K0 w; ~. s. \
1* c/ W7 v4 E8 V6 s, w
2
# cd .. 往回退一层 到 /usr/local/kafka/kafka_2.12-2.3.0 目录下bin/kafka-topics.sh --create --zookeeper 192.168.1.7:2181 --replication-factor 2 --partitions 1 --topic cxuan

7 ?1 y% @$ K, y; T3 T
4 T' B2 ~/ \, P+ d; w5 N' m$ \
对上面的解释
–replication-factor 2 复制两份
–partitions 1 创建1个分区
–topic 创建主题
查看我们的主题是否出创建成功
1
bin/kafka-topics.sh --list --zookeeper 192.168.1.7:2181

  I% b8 O4 F$ V/ i; e; |( w  a

+ W2 q: Y, ~6 _7 r# R
3 g( [) A) ~3 U% K! O" {( b
                               
登录/注册后可看大图
启动一个服务就能把集群启动起来
在一台机器上创建一个发布者
1
5 s9 j( M4 }2 S7 l: d, s3 e2
# 创建一个broker,发布者./kafka-console-producer.sh --broker-list 192.168.1.7:9092 --topic cxuantopic
3 A$ ]& g5 _, [" o: @  x9 s' U
. m5 W1 A9 z3 _$ S, T4 b9 B5 x
在一台服务器上创建一个订阅者
1
/ c! s6 q9 ~# j9 _( r+ B2
# 创建一个consumer, 消费者bin/kafka-console-consumer.sh --bootstrap-server 192.168.1.7:9092 --topic cxuantopic --from-beginning

; ~1 z/ s$ d3 s3 _! k5 E

' x/ [. ]0 r1 \( X
注意:这里使用 –zookeeper 的话可能出现 zookeeper is not a recognized option 的错误,这是因为 kafka 版本太高,需要使用 --bootstrap-server 指令
测试结果
发布

2 o8 H6 ]) @: ?) e" l( b- `                               
登录/注册后可看大图
消费

( ?& \0 P4 W' g                               
登录/注册后可看大图
其他命令
显示 topic
1; g$ b9 H  `& s
2! d2 ]- ]  F& |
3+ u# [+ G& b9 H0 H' {6 T  n
4
bin/kafka-topics.sh --list --zookeeper 192.168.1.7:2181# 显示cxuantopic

; b1 A! R  m$ l2 X  {
! w; V, X$ s" X6 l8 r% h
查看 topic 状态
1/ K/ U1 y5 `8 M, g% g5 J* ^
2
- m  R" C  j5 ]2 _0 G( l3 O* q3 \3  l7 G1 Q; b4 {4 S. L
40 _, s7 I6 \! ?" \# y/ R
5
1 \$ R( v, p& N. r, w7 j7 _6! R9 L9 P9 Z' `4 W7 O( \$ f
7
$ y4 `; F9 B1 I2 v/ L# I+ j# M7 J8
bin/kafka-topics.sh --describe --zookeeper 192.168.1.7:2181 --topic cxuantopic# 下面是显示的详细信息Topic:cxuantopic PartitionCount:1 ReplicationFactor:2 Configs:Topic: cxuantopic Partition: 0 Leader: 1 Replicas: 1,2 Isr: 1,2# 分区为为1  复制因子为2   主题 cxuantopic 的分区为0 # Replicas: 0,1   复制的为1,2
- J4 c$ C3 P7 w& ?. Z, k$ z7 t

9 F& F2 K; s) F  Y" u; b/ q
Leader 负责给定分区的所有读取和写入的节点,每个节点都会通过随机选择成为 leader。
Replicas 是为该分区复制日志的节点列表,无论它们是 Leader 还是当前处于活动状态。
Isr 是同步副本的集合。它是副本列表的子集,当前仍处于活动状态并追随Leader。
至此,kafka 集群搭建完毕。
验证多节点接收数据
刚刚我们都使用的是 相同的ip 服务,下面使用其他集群中的节点,验证是否能够接受到服务
在另外两个节点上使用
1
bin/kafka-console-consumer.sh --bootstrap-server 192.168.1.7:9092 --topic cxuantopic --from-beginning

6 ?5 {' P- |. t5 Q$ n% U
2 B: k9 n7 E" N2 L2 |
然后再使用 broker 进行消息发送,经测试三个节点都可以接受到消息。
配置详解
在搭建 Kafka 的时候我们简单介绍了一下 server.properties 中配置的含义,现在我们来详细介绍一下参数的配置和概念
常规配置
这些参数是 kafka 中最基本的配置
  • broker.id0 I9 g& X. v) R' {# v
每个 broker 都需要有一个标识符,使用 broker.id 来表示。它的默认值是 0,它可以被设置成其他任意整数,在集群中需要保证每个节点的 broker.id 都是唯一的。
  • port
    1 g# N/ E+ W; ]2 t6 X! I
如果使用配置样本来启动 kafka ,它会监听 9092 端口,修改 port 配置参数可以把它设置成其他任意可用的端口。
  • zookeeper.connect
    ( v! z6 K9 S; p) I4 |8 d4 x
用于保存 broker 元数据的地址是通过 zookeeper.connect 来指定。 localhost:2181 表示运行在本地 2181 端口。该配置参数是用逗号分隔的一组 hostname:port/path 列表,每一部分含义如下:
hostname 是 zookeeper 服务器的服务名或 IP 地址
port 是 zookeeper 连接的端口
/path 是可选的 zookeeper 路径,作为 Kafka 集群的 chroot 环境。如果不指定,默认使用跟路径
  • log.dirs
    % J5 d7 |% ^+ D5 S  V
Kafka 把消息都保存在磁盘上,存放这些日志片段的目录都是通过 log.dirs 来指定的。它是一组用逗号分隔的本地文件系统路径。如果指定了多个路径,那么 broker 会根据 “最少使用” 原则,把同一分区的日志片段保存到同一路径下。要注意,broker 会向拥有最少数目分区的路径新增分区,而不是向拥有最小磁盘空间的路径新增分区。
  • num.recovery.threads.per.data.dir8 h  n* P9 P, X7 o" P$ b0 A/ ?0 t
对于如下 3 种情况,Kafka 会使用可配置的线程池来处理日志片段
服务器正常启动,用于打开每个分区的日志片段;
服务器崩溃后启动,用于检查和截断每个分区的日志片段;
服务器正常关闭,用于关闭日志片段
默认情况下,每个日志目录只使用一个线程。因为这些线程只是在服务器启动和关闭时会用到,所以完全可以设置大量的线程来达到井行操作的目的。特别是对于包含大量分区的服务器来说,一旦发生崩愤,在进行恢复时使用井行操作可能会省下数小时的时间。设置此参数时需要注意,所配置的数字对应的是 log.dirs 指定的单个日志目录。也就是说,如果 num.recovery.threads.per.data.dir 被设为 8,并且 log.dir 指定了 3 个路径,那么总共需要 24 个线程。
  • auto.create.topics.enable3 l/ l) c5 m5 f0 X' Y! ~& n* W0 F+ A
默认情况下,Kafka 会在如下 3 种情况下创建主题
当一个生产者开始往主题写入消息时
当一个消费者开始从主题读取消息时
当任意一个客户向主题发送元数据请求时
  • delete.topic.enable# n. A8 n; _: w1 t7 J0 x
如果你想要删除一个主题,你可以使用主题管理工具。默认情况下,是不允许删除主题的,delete.topic.enable 的默认值是 false 因此你不能随意删除主题。这是对生产环境的合理性保护,但是在开发环境和测试环境,是可以允许你删除主题的,所以,如果你想要删除主题,需要把 delete.topic.enable 设为 true。
主题默认配置
Kafka 为新创建的主题提供了很多默认配置参数,下面就来一起认识一下这些参数
  • num.partitions; w, V, A8 n# T6 Y
num.partitions 参数指定了新创建的主题需要包含多少个分区。如果启用了主题自动创建功能(该功能是默认启用的),主题分区的个数就是该参数指定的值。该参数的默认值是 1。要注意,我们可以增加主题分区的个数,但不能减少分区的个数。
  • default.replication.factor
    7 E$ R$ J% f1 Y3 ]8 e
这个参数比较简单,它表示 kafka保存消息的副本数,如果一个副本失效了,另一个还可以继续提供服务default.replication.factor 的默认值为1,这个参数在你启用了主题自动创建功能后有效。
  • log.retention.ms1 M, X2 C9 w, z5 X
Kafka 通常根据时间来决定数据可以保留多久。默认使用 log.retention.hours 参数来配置时间,默认是 168 个小时,也就是一周。除此之外,还有两个参数 log.retention.minutes 和 log.retentiion.ms 。这三个参数作用是一样的,都是决定消息多久以后被删除,推荐使用 log.retention.ms。
  • log.retention.bytes
    - O  _8 r: j  W$ r. I) t
另一种保留消息的方式是判断消息是否过期。它的值通过参数 log.retention.bytes 来指定,作用在每一个分区上。也就是说,如果有一个包含 8 个分区的主题,并且 log.retention.bytes 被设置为 1GB,那么这个主题最多可以保留 8GB 数据。所以,当主题的分区个数增加时,整个主题可以保留的数据也随之增加。
  • log.segment.bytes
    / ]- K0 h0 L- }% z! c
上述的日志都是作用在日志片段上,而不是作用在单个消息上。当消息到达 broker 时,它们被追加到分区的当前日志片段上,当日志片段大小到达 log.segment.bytes 指定上限(默认为 1GB)时,当前日志片段就会被关闭,一个新的日志片段被打开。如果一个日志片段被关闭,就开始等待过期。这个参数的值越小,就越会频繁的关闭和分配新文件,从而降低磁盘写入的整体效率。
  • log.segment.ms* g. A) `$ T2 ^7 o
上面提到日志片段经关闭后需等待过期,那么 log.segment.ms 这个参数就是指定日志多长时间被关闭的参数和,log.segment.ms 和 log.retention.bytes 也不存在互斥问题。日志片段会在大小或时间到达上限时被关闭,就看哪个条件先得到满足。
  • message.max.bytes
    3 L1 s7 U3 H9 g
broker 通过设置 message.max.bytes 参数来限制单个消息的大小,默认是 1000 000, 也就是 1MB,如果生产者尝试发送的消息超过这个大小,不仅消息不会被接收,还会收到 broker 返回的错误消息。跟其他与字节相关的配置参数一样,该参数指的是压缩后的消息大小,也就是说,只要压缩后的消息小于 mesage.max.bytes,那么消息的实际大小可以大于这个值
这个值对性能有显著的影响。值越大,那么负责处理网络连接和请求的线程就需要花越多的时间来处理这些请求。它还会增加磁盘写入块的大小,从而影响 IO 吞吐量。

! g+ z" `$ w. X0 y8 h. D8 g
 楼主| 发表于 2022-12-30 09:09:23 | 显示全部楼层
1、软件下载1.1 kakfa 下载
地址:http://kafka.apache.org/downloads
: Z5 c3 {  V/ o2 o: ^- x

2 e! e& U7 [; \# t/ L
) V( Q  {+ o1 A! y" v
                               
登录/注册后可看大图

4 F5 X3 }* e& k3 P
. }- L, ]: ]% u
1.2 zookeeper 下载
(1)因为 kafka 要依赖于 zookeeper 做调度,kafka 中实际自带的有 kafka,但是一般建议使用独立的 zookeeper,方便后续升级及公用。

5 ~0 G1 ]: ]* z5 k
(2)下载地址:

  [; }! e; z1 H$ c/ M
http://zookeeper.apache.org/
% Z7 {# U2 Q# d- R3 F
6 Y3 t6 [# ^7 N) ~
2 z' L3 |7 L' n+ R! o
                               
登录/注册后可看大图
5 o) C! E% l' D3 w4 P* \
" n) ^! ^& R$ ?* e/ S
1.3 下载说明
文件都不大,zk 是 9m 多,kafka 是 50 多兆

& d8 Q0 }+ O$ A% b

* P: j( c; W. v: M6 c                               
登录/注册后可看大图
! c+ V/ B( h; A, k' O
' l7 z% T; }8 i+ O$ M
2、 kafka 单机部署及集群部署
**说明:**北游在本地弄了三台虚拟机,ip 分别为:

) e+ C* _8 G7 P5 k* _7 z. z' Q8 u6 `, n& p! k) m

( C# [  t$ c9 v) r9 C3 q  `192.168.85.158192.168.85.168192.168.85.178& o# G% v$ z! I6 E( i# H3 X

  x/ D3 M- _) W
$ o  P4 A6 C* q( c! E- |/ J
2 D& Z+ o0 U( T$ w+ B* Y+ J1 K8 [& F

" n, [- {) W. N# T% z0 Z5 D; v
9 T# P# P$ x; q* N7 h* D& b5 t$ m, n6 e/ i9 P1 N( c
; j( l4 t! U% R7 E

' |) ~, I. p8 n( o  V( x
/ n9 e# M$ f7 l' P' a7 I) a! u复制代码+ u" t1 _( T2 |$ ^
7 _2 F, @% w: o: |7 y

- U, r* J# P  s+ q# W
. o& m1 o% A! Y* j$ ^5 y
; M: E- x) K: k1 F" I: i9 N) {3 V2 X

8 `, v  d* w9 e/ k
, J# p& f4 d8 K; f  s$ A% [
2.1 单机部署
(1)上传 jar 包,就不再新建用户了,直接在 root 账户下执行,将 kafka 和 zookeeper 的 tar 包上传到/root/tools 目录下。
1 G8 Q. V1 P# Y" F8 l
(2)解压
+ e$ T& G4 A1 A6 t0 h

8 H6 a  B" F0 @5 T! p* V
: \" Z! D( G# t: |6 N% {
[root@ruanjianlaowang158 tools]# tar -zxvf kafka_2.12-2.4.1.tgz [root@ruanjianlaowang158 tools]# tar -zxvf apache-zookeeper-3.5.7-bin.tar.gz  
, X  {; ?( W7 @/ q
8 d! J, z% a) L* c) W2 g3 F
9 A# r* |) [) i$ \
6 e% R8 ~* ~4 L; O* r  c: }% n% z7 T! T5 D7 j4 O

9 [+ d# A. H/ b4 B- j) {
8 V- N* _% C9 Z, `' ?, j( k" f
; w& n! x6 A5 w
- u: r. v$ @; t- h3 ?, J( l! o6 w. w" D1 s# m
4 h4 a+ I: d, c
复制代码9 K, M0 s, s" h! J+ d

5 y# v2 i" o8 ]- C) @; v9 [/ h3 r9 O$ Y6 b$ O
5 ?8 n& ^2 J% H5 k

3 v  m8 m  E; [! u# |9 i0 o5 Z9 U6 q: U6 r) ~1 D- _3 n; \

9 [% v* o2 r8 w# b2 B  {9 C5 ~$ o; c8 H! G  Q9 U
(3)配置 zookeeper 及启动
. }' G8 p# [# d3 i( z
: w+ I6 D5 h: L4 I5 A1 N, E
6 i  i7 M+ X& c( j
[root@ruanjianlaowang158 apache-zookeeper-3.5.7-bin]# cd /root/tools/apache-zookeeper-3.5.7-bin#北游,首先创建个空文件夹,在接下来的配置文件中配置[root@ruanjianlaowang158 apache-zookeeper-3.5.7-bin]# mkdir data[root@ruanjianlaowang158 conf]# cd /root/tools/apache-zookeeper-3.5.7-bin/conf[root@ruanjianlaowang158 conf]# cp zoo_sample.cfg  zoo.cfg [root@ruanjianlaowang158 conf]# vi  zoo.cfg #单机只改一个值,保存退出。#dataDir=/tmp/zookeeperdataDir=/root/tools/apache-zookeeper-3.5.7-bin/data! I4 X) V1 x! ]9 t% s9 A( d
#启动zookeeper[root@ruanjianlaowang158 bin]# cd /root/tools/apache-zookeeper-3.5.7-bin/bin[root@ruanjianlaowang158 bin]# ./zkServer.sh  start
; e; P; B3 ], ?3 _5 ]9 o  Z( \9 C
3 c0 O' k+ b4 t3 v& c

. P4 n, @+ f4 ?' n" Q! w4 M3 R2 S" {/ H% h/ D

- N9 {3 p7 X6 b
& Z3 a( x0 F+ a2 B: j; b) e
& V. f: @! j9 C5 C' ~" ~0 p' E$ s$ B" t6 E' E/ G2 k* i- c

0 i% y2 G! ^0 r9 m
2 w$ K: d( x5 R" w( a复制代码
# D6 L7 Y8 w: ^3 f& }: _& F4 i, H2 z$ |( N- K2 ]
0 I2 f' @" d: ^* V+ O, r7 |7 \
. G- H) i; B7 A6 h, {

7 g" r1 V; A! P$ A% I
5 e3 N: e$ @/ [+ o  P1 W5 q+ n+ v1 e4 ]. v

( g  g1 x2 A0 @5 G
! u9 \7 k( d* K+ P
3 J1 A4 E% H3 C( x- z- U4 @. T! }2 a3 P0 M) Z2 O9 P- ^3 V; ^
" X, N* {  J+ _0 Z/ y' V* P1 X

+ w4 U6 |9 ?1 g5 K' a* ]4 Q3 `" h$ }6 e, d& g( I, z
/ @1 Q: M5 q: a  J
8 j: D1 W: B/ {" K1 q3 ]) d

1 M* {, v1 M3 Q  s, n

& `8 ^2 B5 g; ^2 G( V- F) ~
/ g8 Q3 [& t' z  r% d: T  W5 J
(4)配置 kafka 及启动
9 N6 U  k/ g% A

. q2 A' R. x% r8 g* J% r: Y" ]: w$ }' J
- A' N: l/ e0 \/ J4 ^* |+ S. u5 W7 F
[root@ruanjianlaowang158 kafka_2.12-2.4.1]# cd /root/tools/kafka_2.12-2.4.1. V* {3 O" s( v4 S8 D2 h2 w9 A
#北游,新建个空文件夹[root@ruanjianlaowang158 kafka_2.12-2.4.1]# mkdir data
6 D/ O# o9 _1 u/ A#北游,更改配置文件[root@ruanjianlaowang158 config]# cd /root/tools/kafka_2.12-2.4.1/config[root@ruanjianlaowang158 config]# vi server.properties
, }& G5 D" @# `/ ^4 l6 P/ j#需要改3个值#log.dirs=/tmp/kafka-logslog.dirs=/root/tools/kafka_2.12-2.4.1/data#listeners = PLAINTEXT://your.host.name:9092listeners=PLAINTEXT://192.168.85.158:9092#zookeeper.connect=localhost:2181zookeeper.connect=192.168.85.158:2181$ U4 ?) ?( R* Z1 Y5 }3 E/ r
#启动kafka[root@ruanjianlaowang158 bin]# cd /root/tools/kafka_2.12-2.4.1/bin[root@ruanjianlaowang158 bin]# ./zookeeper-server-start.sh ../config/server.properties &# v9 x! Z+ B8 X* N) X8 ]; ^) K
4 D: f# F) k. h8 A/ E9 q5 ^+ x# C

2 ~$ F( }/ S; H) X5 X' l; x  U/ M4 P3 Y
) G5 E) D' i! }* y/ O

6 ]! Y/ C( ]3 \( a$ |; I' M3 e; |  c* x0 H
  H/ p& u) ~- G  k8 {- W& g

% P1 x# v6 R% J" f- s# B" R7 s2 Z  E( k$ Z' }  ^# t

8 z$ ?/ ~2 |$ C' ^: K- [7 i复制代码8 v+ d- m: K  @; F/ d; J0 Q7 }) x9 I
3 r! U* ^( K. K, k
1 R* U& R8 E7 N4 y1 m

& Q4 ?7 i& F. `; L( @' ^7 }
" g( ]. G0 c; b; z4 D) n' o2 q$ \* M

) [* T0 E: L! a1 Q( o
* p# \7 O- ?, r% W( Q* W+ S1 ^% K; M- @7 W/ v; C7 u+ J0 ?
3 p; F$ C! O* X* [7 t( z; ?

# E2 V) f' W+ A1 I9 R- B& j
  |' l; K5 P6 Q& _
$ J* Z. C7 G3 B1 Q
( K# V( n; `' [9 R5 ^; N1 u; G' m  _. y; _- @0 |6 t

1 H- n+ G% E8 d* y, W$ E. L
6 R6 I" U' K# s  W$ e1 C( m& K' |0 b$ q3 Z! I8 l$ F, |1 {+ g

/ T& j9 q/ P% N/ T2 z* D: K/ h7 E! C; [, m
: o4 I: J& T- ]6 p

: }- N7 Z$ t+ c: b# }; ~. e) \) Q! Q1 Z! I

6 R. v9 r: L: D, j. P
4 C( N( Y7 Y. B  S# Y1 O  ]
* t# C0 C/ h; o) o0 _8 _( A
启动完毕,单机验证就不验证了,直接在集群中进行验证。
2.2 集群部署
(1)集群方式,首先把上面的单机模式,再在 192.168.85.168 和 192.168.85.178 服务器上先解压配置一遍。
3 }! Q+ b: _! f, G
(2)zookeeper 是还是更改 zoo.cfg
8 l. Q* x/ A$ f' @& c) m. j
158,168,178 三台服务器一样:

+ D* g! \/ O9 f5 J: l5 s; L3 {4 f9 ]6 p
$ z. k: {+ G: {% E* r3 o
[root@ruanjianlaowang158 conf]# cd /root/tools/apache-zookeeper-3.5.7-bin/conf( U/ N6 T* |5 s
[root@ruanjianlaowang158 conf]# vi zoo.cfg#其他不变,最后面新加,三行,三台服务器配置一样,北游server.1=192.168.85.158:2888:3888server.2=192.168.85.168:2888:3888server.3=192.168.85.178:2888:38884 e* j7 X. Z( p2 [7 P
158服务器执行:echo "1" > /root/tools/apache-zookeeper-3.5.7-bin/data/myid168服务器执行:echo "2" > /root/tools/apache-zookeeper-3.5.7-bin/data/myid178服务器执行:echo "3" > /root/tools/apache-zookeeper-3.5.7-bin/data/myid7 l- R9 I# M) w" ~  F8 K, C

* L. g$ t9 J% Q. M2 f6 z* P! ?9 f  H  \

5 ?3 t* P! K3 |+ Y* ?% y: H$ }, u, j8 ^$ e" ]" s" K

) \; g- Q: D9 O5 r! E, S  \  ~
5 D9 `6 M- G- g5 G: {
9 o* J  N  Q2 J3 Z( l$ ?8 K% P) M7 w( e, t

' S6 ]* R! L6 [! w8 Q8 Q0 Y6 T
9 Q4 f% ~5 v* `# N0 j复制代码
' O( m, l/ Z8 x7 M6 T1 u( S9 p0 z. v4 R. o+ s

  P2 ]" W( m. L- S* i/ f( S3 I8 p9 q% P- l
: y+ C" G; w1 p6 ?7 |

9 D) y/ E, X6 A, [: c8 B' I) N
- L1 c+ x; g+ @- d4 }+ a  q' l0 F1 w9 W# l& y
& d- S% P; x2 h  G2 y( e
6 Z- z5 @- u6 S/ t

. |3 E  C1 N/ g8 U
5 ]' q7 e  B" X
5 H" n0 ?% h* a0 p. C3 [% c+ X" L1 n( c. `& Y: t
3 Q7 T; i% W7 ~* {7 |
/ u. \( f1 a9 L4 E6 d! l
. d1 f% K3 C* Q  }+ }
( J6 X0 J* w( Z/ N7 V3 |3 J
& b8 u9 H) T9 P" B9 o9 O
1 e! r! m% I5 U* s" i
(3)kafka 集群配置
3 c; R  u+ i8 e! b% ?
" Q6 t$ ^( ]! b6 T6 b* h- e2 L8 U$ x
  A" x7 P. x: z! K0 q
[root@ruanjianlaowang158 config]# cd /root/tools/kafka_2.12-2.4.1/config[root@ruanjianlaowang158 config]# vi server.properties #broker.id 三台服务器不一样,158服务器设置为1,168服务器设置为2,178服务器设置为3
8 v# U; n) m' B3 G; Jbroker.id=1#三个服务器配置一样zookeeper.connect=192.168.85.158:2181,192.168.85.168:2181,192.168.85.178:2181' r8 e* v. r3 n, b* ?$ o

1 S/ P  u; X# Y$ ^5 X2 h: R- U
9 B5 ?$ O# ~  E9 {6 E9 @2 ~- Y; z3 W
6 Q9 d4 E1 F! H$ i) L1 m$ {

$ d% y4 _- j1 K2 j8 N' R7 r! o6 s, |4 ~) y1 S7 r& E  Z

5 t" K0 t8 H8 [2 E- _
) U+ i4 ^6 ?% \# _0 X% S) p5 i/ x/ {. P! D
4 W3 c- ?& n* O
复制代码* P8 A7 L! T3 t( f8 \8 z0 g

; p/ `, E& u. I* f  a7 A9 i/ s8 C0 g2 t) N! I
/ c0 X' T6 A' L& ^5 H0 {: ~
8 U! i" {; C8 X

+ H% r, J' n; E6 v* n
4 M- \4 @2 f: m; K, K( ?( |
& S8 p( V# }8 t/ b. `) ]0 X% N4 h; k# A- ]0 f& G, K& f

8 ^% v1 p2 [. P
  p9 W8 L1 V9 r3 G% Q
+ \6 {$ t- ~6 @
' n! E7 R& b! {1 X0 L4 f2 b' t
Kafka 常用 Broker 配置说明:

0 _* I3 H4 b. J) G7 S$ e
2 J, Q* D* O1 {/ l- r8 L/ R$ o
9 {0 o# n8 K+ R
& J5 C& {( C: C# B
192.168.85.168:2181,192.168.85.178:2181 | ZooKeeper 服务器地址,多台用","间隔 |

% V" i: N( M: o% s, Y- j8 Z6 [2 S$ u% \
(4)集群启动

7 g3 u1 C' G  i! v# b4 L/ P* Z% d
启动方式跟单机一样:
3 [6 ~3 a$ j8 K3 ^

/ l' z" |1 ]" |1 h; ?

# Q3 m( o) P" s#启动zookeeper[root@ruanjianlaowang158 bin]# cd /root/tools/apache-zookeeper-3.5.7-bin/bin[root@ruanjianlaowang158 bin]# ./zkServer.sh  start( b9 a* @9 r6 P! k  Z
#启动kafka[root@ruanjianlaowang158 bin]# cd /root/tools/kafka_2.12-2.4.1/bin[root@ruanjianlaowang158 bin]# ./zookeeper-server-start.sh ../config/server.properties &% K1 \1 B, B0 {* n

, e6 d/ C: D" H" S4 P: Q/ s. V0 W
; {8 g' A* r: g& E
  F2 }$ L" p0 s% y& l' X) b6 Z5 j" Q
6 m* a7 O$ v) H' T! `1 y* q- l# L

* K/ W  I* |, H8 ?9 s
, o1 R- U! T1 m( S" q7 m
* _, W: A+ B2 V. G3 S4 R
& P0 R  ]! Z7 m  l; i0 }
; q0 z" |# q5 i- s8 b4 T复制代码' s. x9 C: f# @0 y, F

2 M  k( v% d2 K) P! o  \; j. r& t4 o* f1 L

1 ?5 B0 o/ A4 }8 E+ ^# s/ l9 i; p- W4 R( I& g) n

  Y+ Z% U- I2 E$ s& K( y( m9 [8 X, Y$ G1 l4 p, G

; k, U& i1 e9 ^' W) X0 g' B; u& I, ~7 a7 W+ y3 F

6 o, l$ m8 s% o1 n5 O
" w; ?9 U6 b1 q1 V! c. u5 D
4 t; j, I1 H2 z* o1 m' y
2 U" x! b! [/ _3 v
(5)注意点
; T$ D0 U8 r' W# I6 ^% ]. S# i

: t  x% K% B' W+ T* Q+ a* C/ T

) a, a' e) R- q. N. m! \- `  A! Z集群启动的时候,单机那台服务器(158)可能会报:Kafka:Configured broker.id 2 doesn't match stored broker.id 0 in meta.properties.方案:在158服务器data中有个文件:meta.properties,文件中的broker.id也需要修改成与server.properties中的broker.id一样,所以造成了这个问题。: S; \+ Y' U% ^+ g) Y

/ y+ ~2 k/ Y/ o- o2 F3 r/ w7 P, c. ]0 I3 A
8 X6 Y& {7 Z# R" A
8 v1 i: z' h6 n2 l

& s6 _8 U2 L1 I, r: R; ~; W3 x4 h+ I7 `; d/ L% Q* N. \: n% Y
) l- g" a; b: d8 ]5 ]
* ^3 n9 V0 f5 a/ V
: E, C9 K1 L$ x0 u

' ^) g: @. V+ t6 |7 c
8 l! M  ^9 N0 W3 @8 X6 B2 M3 s复制代码
( u+ Y7 p- r: h6 u
1 R1 f$ s, g; y9 v* a# Z5 P1 e: W& Z( e- i. L. c4 K2 c

3 j" `% s  u9 z2 m
8 H7 d$ Y( i3 _; y: E3 E) l) O, T, o; e; E- g
. S  P" q: M2 g# y/ E/ N& o
# y; k9 f5 f  W6 T2 Z4 g
(6)创建个 topic,后面 springboot 项目测试使用。
6 V8 @5 t+ |; k& b4 o- q
8 T* Z6 I+ \! K  n4 k' ?% l
6 A( N- k1 A- K: O- H( t
[root@ruanjianlaowang158 bin]# cd /root/tools/kafka_2.12-2.4.1/bin[root@ruanjianlaowang158 bin]# ./kafka-topics.sh --create --zookeeper 192.168.85.158:2181,192.168.85.168:2181,192.168.85.178:2181 --replication-factor 3 --partitions 5 --topic aaaa
+ @! t1 N& H8 H  d& \% {( M% m; w" G& y; q. ?
3 U" q1 M3 u4 Y

1 L4 l% F+ ?' T7 ~9 B3 ~) r6 B, R: ^. m) a) r' q
: U* w2 x+ k' y: ^7 A: Q

9 e( h# a; g1 U- Z/ g/ X( ?3 D7 H4 g) z/ ^& f

  @) b1 U4 c- m; B: F
, i, |8 T; j; P5 T' o+ {# S. r1 [  W9 c8 K! V' R3 d

0 f) c2 j0 ~: i9 q# f" e$ ]  o复制代码
- l$ N1 m: K. J/ u/ Z  R8 M% ~; v% \* k( W1 x
7 m9 t% I3 [, g! ?  D

) o/ c, \9 N: w, ^6 Q  z/ ~
% Y6 T, P/ y5 N1 m. a; H! N& R9 ~/ t* m' I( B
/ F4 j# h6 b7 `+ V: s1 Z
3、结合 springboot 项目3.1 pom 文件
2 Y" v& j* [! c
* D6 R4 _0 G' l! d
<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">    <modelVersion>4.0.0</modelVersion>    <parent>        <groupId>org.springframework.boot</groupId>        <artifactId>spring-boot-starter-parent</artifactId>        <version>2.2.0.RELEASE</version>        <relativePath/> <!-- lookup parent from repository -->    </parent>    <groupId>com.itany</groupId>    <artifactId>kafka</artifactId>    <version>0.0.1-SNAPSHOT</version>    <name>kafka</name>    <description>Demo project for Spring Boot</description>
, z4 s5 f0 O3 R' a  t: N# ?    <properties>        <java.version>1.8</java.version>    </properties>    <dependencies>        <dependency>            <groupId>org.springframework.boot</groupId>            <artifactId>spring-boot-starter-web</artifactId>        </dependency>        <dependency>            <groupId>org.springframework.kafka</groupId>            <artifactId>spring-kafka</artifactId>        </dependency>    </dependencies>    <build>        <plugins>            <plugin>                <groupId>org.springframework.boot</groupId>                <artifactId>spring-boot-maven-plugin</artifactId>            </plugin>        </plugins>    </build>
8 ~& U* z. t1 G" g</project>1 l0 R6 F! V6 F
7 @/ ]' o% N; _% p
7 D: a) O8 K* `; v& C6 E- G  C

4 ?, @8 x1 @. u  F. C& J3 Z" o7 w. S
2 w9 k; N" |. c; A9 Z7 P+ A0 W3 ^- J- |4 P- k# B

' T  T6 q: [( v  I: x7 s) V# K' [. c$ Q* M; o2 D0 e8 ], U

1 c0 c5 B$ ], M3 _
, c9 i( x4 q% E/ x) e" @. d3 D& {
! A8 Q2 T$ \9 E& D. M9 r
复制代码$ B# \, \6 O  s( S* Q
7 L3 M4 Z/ f; U5 e# t

; W% W7 q3 l1 L* m" _3 z0 s' \7 I* R0 h

* Z, H; l1 i  R4 o+ j; D( w. v. ^
3 h# U1 [) w; ?2 C( t/ ]1 R
. }% B6 o. g- p  D" Q
4 i1 I0 B- k! ^# ?0 l: X
, N3 W' E! j2 P: X# Q& Q0 Z1 c% A, S8 A7 A1 c4 Z- w; c

9 R8 Y7 k+ ], J& W2 ~3 _0 a$ G9 n# b9 C2 N/ W

' e6 E3 E4 a2 ]; b
; ^1 x! `; K( W4 ~9 ?
5 h- S1 M. F7 i9 B3 e" M
& X3 T* Y# ~0 I$ ?5 i: L' i9 J
( P; T/ M2 {% ?) e* x% e# w) {3 d% J; Z; X) F

7 J- i; ~3 T$ t8 j1 `; i9 k
1 [0 U- K: \: g0 a( P+ }' Q* v9 E) d7 X: E
% J" y! c; @9 P1 T# k
$ \: l& P  p2 W; W  s0 Y. s% a
* V" d& i6 ]3 ^) N- I  k/ p

& K# y/ z) F' t. o3 o7 `; G. W) P+ |( f- |6 ^" j. G

4 l) g* t/ g! v/ i" k* I8 U8 m8 L

, P# [, O6 w9 i9 U& }, F1 m
- r* ~# T' @* ~& ]1 q
; q# N7 N- N7 i5 {+ S0 c9 w5 s! W8 l7 g( B7 G% s

- H7 ~- S* k& l
' T9 @5 P4 p5 Q* p4 [
) ?7 B5 r" ^- q- |' w- z% Z9 e; [) E/ p# k, O

9 Q; r: u1 [/ N' v& \  |! [( _6 r3 r0 s1 s) k4 y3 a9 \
" i+ G8 a) d, ~% V- h
( a3 b1 u! m" }
; l6 t  x/ [5 k( X, c* c( X7 N( b

3 r' m) t5 t2 D1 l0 s% x6 f1 G$ ^% B

* g( q2 U! ^- A9 M. z& A
4 b, ?. B% i$ k; a# _; ^% o9 P
说明:

" V$ L) g0 }4 N
主要就两个 gav,一个是 spring-boot-starter-web,启动 web 服务使用;一个是 spring-kafka,这个是 springboot 集成额 kafka 核心包。
3.2 application.yml
# {9 z5 d3 {( @; V$ w- L( [: f

* r: X- Z/ r: C. z# `5 m3 [5 o. V7 Q( w/ \* Kspring:  kafka:    # 北游,kafka集群服务器地址    bootstrap-servers: 192.168.85.158:9092,192.168.85.168:9092,192.168.85.178:9092    producer:      key-serializer: org.apache.kafka.common.serialization.StringSerializer      value-serializer: org.apache.kafka.common.serialization.StringSerializer    consumer:      group-id: test      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer. t, o6 w8 ]! ^1 V* G# u

# m, S/ v( T: N( d6 i  Z" Y" x) e" S9 v. o) f) k& V5 D9 ?5 k
& `$ t, W0 n! P9 Z& D3 m& ?

5 W# H  G7 P5 p! {( q. |! e2 t2 S% F# X  G: w) H/ G! \9 j

& w( m8 Y- B4 H
& m5 e. C5 m" r) K+ I2 F1 z+ k$ q" m# q( l- n7 F

/ O8 U. F. C" Z; w: @7 q( ~& K0 f1 }8 W. A! p7 G/ |& k, [; A  M
复制代码) s/ p2 f0 r/ l  e' M4 t

0 O8 I( b0 E" [+ {" b3 u
; ^; l# h8 N; x" w9 b, |& D* k/ Y8 w+ K* v9 k

4 L% j4 C, S6 r. [( g' u
9 ~; r  t( Z/ f! [; L9 K' W% \
) y) c- N: @  j; k9 e7 k) {# i2 w
7 V" W. B+ W3 ]' P6 n: A2 ]
4 [+ `  Q8 j1 d( x  ^; ~" s" d" P$ q5 p
4 Z; A! L6 D+ ^- F4 l
; m" c8 F/ r6 R) x: t3 W9 y1 J9 q  P, W" B

3 _, U1 {2 {  ^6 U9 p5 i8 T- _" Q* k' T' U8 L: ^  {' V( J. s# p
0 A6 Q3 A% q1 V  r8 n8 i2 B0 w$ _

  }& Q1 ^' y; D; K& Q  F3.3 producer(消息生产者)
+ e; K6 b9 S* F7 Y

; w! ~" O. ~5 H: _, P" r@RestControllerpublic class KafkaProducer {    @Autowired    private KafkaTemplate template;     //北游,topic使用上测试创建的aaaa    @RequestMapping("/sendMsg")    public String sendMsg(String topic, String message){        template.send(topic,message);        return "success";    }}7 d1 k( i! @4 v* K

, I$ N' w6 T$ L$ r, I- i. I& }) `6 b: _. P, p

1 u5 N/ Q) i) o2 v
+ }: ]2 F8 i3 b
4 Q2 _5 M" j" x  M, ]3 z% g6 s7 b
% J( d8 U0 S" ?$ Z0 j/ b
' d) a0 _! v. {$ L& s
9 W& H- M; _' n. z" h: `, N, v
) V3 k8 O) B; k$ O0 L! x7 F$ O: L
复制代码
9 O6 F4 N' j$ B: ]# `& U+ [1 b3 K  _

  L2 A1 r4 ]6 Z
* V) \% E& U, K8 M1 W
, L) k0 Q. N( S; K2 n8 A3 c
# c/ H  z9 E$ M5 m) \6 O$ T" V; K5 U1 y
: z$ R- p% u- c/ x
; @0 _: `2 m. }4 b# c

$ z% F* r  B  f8 ^4 m4 z" A
8 @: ~& l6 J2 U: c  {  A
$ K  ~+ R8 s& L' y
! y( y  v4 W% C6 n* ^! c) n4 b* s
- Q  U" z9 l4 i8 H3 I) O/ ]% I2 o$ U9 C) J: A2 c
$ M" i5 H8 s3 I6 c
3.4 consumer(消费者)
0 }. f. M( a- X( X1 C
$ l3 ~8 i% l6 l+ p9 Z$ \! y
@Componentpublic class KafkaConsumer {   //北游,这里是监控aaaa这个topic,直接打印到idea中,北游    @KafkaListener(topics = {"aaaa"})    public void listen(ConsumerRecord record){        System.out.println(record.topic()+":"+record.value());    }}4 C) k/ A+ K: t- h4 J' e
" {* P8 p2 _3 ^

' _$ U# E2 I5 }2 F
; o" d: Z+ `# b2 i3 j8 ?
; z% y% h: }6 e1 W$ {+ ~" Z; W8 h& C0 p% l& d% ?7 o
+ u' U$ N9 q; Q' Y, w
; l2 u$ O% l+ X1 S  B4 j1 n. e

0 \! j8 f) q( M0 s7 q+ G  g
# p# s( A4 r& n% {5 n
( W* w: M" [1 `. p0 j& j# h( t( \9 n复制代码) Y) R) ?* D% t, m

0 E% w1 S+ K) H- [4 R; e; E$ z% e" d+ O2 d( d) ?* @
  J7 V+ @  J; s

0 F+ D0 I/ k4 I/ x1 k$ B5 c% Z2 G) l( N$ d) M
4 X- h, B% _: g+ r

; x4 z0 k& \; l$ z6 F, b- U2 t/ d# y2 ~7 T

4 m2 N& }' E' _4 e& d: M& E. x  H: x! w

# r$ s8 }+ e% l2 A

* E5 }8 w7 Q  X) P: c' r3.5 验证结果
(1)浏览器上输入

9 T/ k$ X0 ~2 C* d, l
1 x1 l( ^% @& Z$ o

8 W9 s+ ?: e7 z) khttp://localhost:8080/sendMsg?topic=aaaa&message=bbbb1 |% r/ R4 g# G. b, E( h7 `
2 E5 ^" h" C2 k+ v) W3 t& F
8 I$ c6 W5 v* \/ a* [
: u4 k& n, _( E: m/ Z+ E5 i; Y! X# a

- f( Y! @5 p  E/ |
+ l$ D' u! \0 r4 S- I  t- s$ v/ H: _" [/ ^. g

- ^/ N: S2 f& ~* [) _/ b' L7 s& X& I, ^- X8 {

6 x  g( v; _0 b% O& t  e' l9 ~0 v& J9 ^* A+ g9 t8 |
复制代码
$ E, I) ]) A. {5 ~& E. T! I: J1 Y/ A2 J! v

& O: K. J( j, B% Q
0 _' y# Z* M: R5 Z& _$ q8 L) }
5 V2 L8 H2 ?. k7 C+ Q. d* z

. o( O; Y  s: {4 |! Y5 ^: P7 x( r
(2)北游的 idea 控制台打印信息

! \! w  H0 @0 f- h9 M3 v# M
( m. j: E0 `* v7 \( Q3 J
                               
登录/注册后可看大图

0 i4 n$ r& `! [) X

% X6 t7 d6 O* }$ K
* E, R% l& E- T% I8 {2 _) c二、Kafka 副本机制1、什么是副本机制:
通常是指分布式系统在多台网络互联的机器上保存有相同的数据拷贝
2、副本机制的好处:2.1 提供数据冗余
系统部分组件失效,系统依然能够继续运转,因而增加了整体可用性以及数据持久性
2.2 提供高伸缩性
支持横向扩展,能够通过增加机器的方式来提升读性能,进而提高读操作吞吐量
2.3 改善数据局部性
允许将数据放入与用户地理位置相近的地方,从而降低系统延时。
3、kafka 的副本
(1)、 本质就是一个只能追加写消息的日志文件

/ D2 R, i/ K$ R8 L6 y0 P% F
(2)、同一个分区下的所有副本保存有相同的消息序列
  S- P# t3 y) [& ?
(3)、副本分散保存在不同的 Broker 上,从而能够对抗部分 Broker 宕机带来的数据不可用(Kafka 是有若干主题概,每个主题可进一步划分成若干个分区。每个分区配置有若干个副本)

& Q# o% O7 {6 _
如下:有 3 台 Broker 的 Kafka 集群上的副本分布情况

0 J# D2 X# L5 s6 P& t# E

/ M' c4 A% x$ ~: G                               
登录/注册后可看大图
4 A0 h1 o4 u. I! w2 k9 Y3 X
2 \! Q8 E. ?4 O3 L/ X: r( g7 U
4、kafka 如何保证同一个分区下的所有副本保存有相同的消息序列:
基于领导者(Leader-based)的副本机制
/ X, u, {1 {% }6 T  w
工作原理如图:
3 p1 y+ Z, ?" y4 B
: H, L7 h2 |8 O" l
                               
登录/注册后可看大图
6 O: o( t( u8 ~1 {, Y

* h  E' P4 F7 c9 Y) P
9 K6 q) r3 i4 \
(1)、Kafka 中分成两类副本:领导者副本(Leader Replica)和追随者副本(Follower Replica)。每个分区在创建时都要选举一个副本,称为领导者副本,其余的副本自动称为追随者副本。
* V' b; ~/ G! |5 r
(2)、Kafka 中,追随者副本是不对外提供服务的。追随者副本不处理客户端请求,它唯一的任务就是从领导者副本,所有的读写请求都必须发往领导者副本所在的 Broker,由该 Broker 负责处理。(因此目前 kafka 只能享受到副本机制带来的第 1 个好处,也就是提供数据冗余实现高可用性和高持久性)

- s! Z, P5 v, f8 m% z5 g+ o
(3)、领导者副本所在的 Broker 宕机时,Kafka 依托于 ZooKeeper 提供的监控功能能够实时感知到,并立即开启新一轮的领导者选举,从追随者副本中选一个作为新的领导者。老 Leader 副本重启回来后,只能作为追随者副本加入到集群中。
5、kafka 追随者副本到底在什么条件下才算与 Leader 同步
Kafka 引入了 In-sync Replicas,也就是所谓的 ISR 副本集合。ISR 中的副本都是与 Leader 同步的副本,相反,不在 ISR 中的追随者副本就被认为是与 Leader 不同步的
6、kafka In-sync Replicas(ISR)
(1)、ISR 不只是追随者副本集合,它必然包括 Leader 副本。甚至在某些情况下,ISR 只有 Leader 这一个副本

  k$ o: G) d8 F4 X- O% T3 h1 O7 H8 W
(2)、通过 Broker 端 replica.lag.time.max.ms 参数(Follower 副本能够落后 Leader 副本的最长时间间隔)值来控制哪个追随者副本与 Leader 同步?只要一个 Follower 副本落后 Leader 副本的时间不连续超过 10 秒,那么 Kafka 就认为该 Follower 副本与 Leader 是同步的,即使此时 Follower 副本中保存的消息明显少于 Leader 副本中的消息。

) Y" u5 |3 ?& o
(3)、ISR 是一个动态调整的集合,而非静态不变的。

) N( Q9 I/ K) B: m/ \. [
某个追随者副本从领导者副本中拉取数据的过程持续慢于 Leader 副本的消息写入速度,那么在 replica.lag.time.max.ms 时间后,此 Follower 副本就会被认为是与 Leader 副本不同步的,因此不能再放入 ISR 中。此时,Kafka 会自动收缩 ISR 集合,将该副本“踢出”ISR。

: G# I. G; \; s
倘若该副本后面慢慢地追上了 Leader 的进度,那么它是能够重新被加回 ISR 的。

. S- m( @# o$ X9 [( T% y  {
(4)、ISR 集合为空则 leader 副本也挂了,这个分区就不可用了,producer 也无法向这个分区发送任何消息了。(反之 leader 副本挂了可以从 ISR 集合中选举 leader 副本)
7、kafka leader 副本所在 broker 挂了,leader 副本如何选举
(1)、ISR 不为空,从 ISR 中选举
- G( V/ s7 r$ O2 R+ u
(2)、ISR 为空,Kafka 也可以从不在 ISR 中的存活副本中选举,这个过程称为 Unclean 领导者选举,通过 Broker 端参数unclean.leader.election.enable控制是否允许 Unclean 领导者选举。

1 p9 Q% j% ~( r
开启 Unclean 领导者选举可能会造成数据丢失,但好处是,它使得分区 Leader 副本一直存在,不至于停止对外提供服务,因此提升了高可用性。反之,禁止 Unclean 领导者选举的好处在于维护了数据的一致性,避免了消息丢失,但牺牲了高可用性。
% q' ^) K3 D/ ~  D
一个分布式系统通常只能同时满足一致性(Consistency)、可用性(Availability)、分区容错性(Partition tolerance)中的两个。显然,在这个问题上,Kafka 赋予你选择 C 或 A 的权利。
3 X6 l; C: l3 [% v4 L1 d
强烈建议不要开启 unclean leader election,毕竟我们还可以通过其他的方式来提升高可用性。如果为了这点儿高可用性的改善,牺牲了数据一致性,那就非常不值当了。
6 b. T* O/ y' l( i7 I% ]1 }
ps1:leader 副本的选举也可以理解为分区 leader 的选举

4 }0 E. T3 Q" K* |8 F4 ]
ps2:broker 的 leader 选举与分区 leader 的选举不同,

- `" y! y. e$ ~' q1 u
Kafka 的 Leader 选举是通过在 zookeeper 上创建/controller 临时节点来实现 leader 选举,并在该节点中写入当前 broker 的信息
; p; u1 \. r0 u% g# z8 z

: W! p- [9 I6 E, h) E2 B$ w; k

8 J+ M3 T7 I6 u% \7 w{“version”:1,”brokerid”:1,”timestamp”:”1512018424988”}
1 U/ g7 R' l6 V$ P5 T, t6 _+ j& @9 _8 v9 m# s1 @

1 h  j2 X2 z4 b/ Q* t3 G. N% e
& W$ Z* h7 o! p) g3 d  T, u4 M( u) L/ _. \/ _+ p0 G. `( e
5 ]) V2 C: W" n% t- ?& N

& ^( `( N+ u( [# }1 s& ~( D" f$ f2 @8 k1 E" C% e
/ {9 ^3 W) z" Z

; K  r7 P/ |+ x1 s! M
6 I. G. _" r7 R# d复制代码8 u, @; a; w0 b9 T
  S' H4 N5 ^8 q0 V2 k; p6 t' u
  S- s1 p+ M$ h+ d% B! f! }% n
+ O) G* ^( e) A, x9 o2 v

; h. N* \6 M& v( K: E! ^0 R& p( v
7 L) T% i$ I; ]; L0 m' U- S6 _

( t( k6 g% j% k. x8 @  ?1 ]
利用 Zookeeper 的强一致性特性,一个节点只能被一个客户端创建成功,创建成功的 broker 即为 leader,即先到先得原则,leader 也就是集群中的 controller,负责集群中所有大小事务。
/ p7 L& l  d( x/ j4 m9 Z/ T; J* P8 k% `+ ^
当 leader 和 zookeeper 失去连接时,临时节点会删除,而其他 broker 会监听该节点的变化,当节点删除时,其他 broker 会收到事件通知,重新发起 leader 选举
1 q0 R6 J. T  [' R
再给你们留个小问题:如果允许 Follower 副本对外提供读服务,你觉得应该如何避免或缓解因 Follower 副本与 Leader 副本不同步而导致的数据不一致的情形?
三、实时日志统计流程1、项目流程
在整合这套方案的时候,项目组也是经过一番讨论,在讨论中,观点很多,有人认为直接使用 Storm 进行实时处理,去掉 Kafka 环节;也有认为直接使用 Kafka 的 API 去消费,去掉 Storm 的消费环节等等,但是最终组内还是一致决定使用这套方案,原因有如下几点:
' M) c+ [6 G7 m) ^$ }
  • 业务模块化
  • 功能组件化
    ! o% K9 s# i$ \: J0 \
  i8 p9 w6 I4 t7 Q- g; l3 F
我们认为,Kafka 在整个环节中充当的职责应该单一,这项目的整个环节她就是一个中间件,下面用一个图来说明这个原因,如下图所示:

: N9 s( y; Q' f- p) p3 N
% ]4 W% I+ i. c+ I
                               
登录/注册后可看大图

( ~3 Q  y6 S: w; ^

" C0 ~# l% c3 Z, j3 T
! V4 ~! o8 @2 D: P6 I- g
整个项目流程如上图所示,这样划分使得各个业务模块化,功能更加的清晰明了。
0 o" p9 m1 E  `6 V4 c: S: g* E
  • Data Collection

    , Z# b( T( H& \. i
1 p1 a2 _& P3 u" G" k: u; T3 [# V  ]& g
负责从各个节点上实时收集用户上报的日志数据,我们选用的是 Apache 的 Flume NG 来实现。

8 a. H2 ^. V8 C' Y1 O
  • Data Access
    8 k1 H% g1 G, a: f9 E. u0 j* w" Z0 O

- m# G, v, Y0 m4 m( b) \) t1 c
由于收集的数据的速度和数据处理的速度不一定是一致的,因此,这里添加了一个中间件来做处理,所使用的是 Apache 的 Kafka,关于 Kafka 集群部署。另外,有一部分数据是流向 HDFS 分布式文件系统了的,方便于为离线统计业务提供数据源。
/ j3 s, K# x$ ?% j1 O6 U- r
  • Stream Computing
    1 m8 m( N5 ]7 h
% ~, v1 M+ F& \
在收集到数据后,我们需要对这些数据做实时处理,所选用的是 Apache 的 Storm。关于 Storm 的集群搭建部署博客后面补上,较为简单。
/ \" n; G' {* |5 @! V
  • Data Output
    ) Q3 C2 i$ U# m; X' i3 B

: y: n; |7 B9 h! o( d$ _/ H" j/ E
在使用 Storm 对数据做处理后,我们需要将处理后的结果做持久化,由于对响应速度要求较高,这里采用 Redis+MySQL 来做持久化。整个项目的流程架构图,如下图所示:

! n* U4 O* k) Z2 [* [

) y/ G3 i, A- t& f  u; \, W4 A                               
登录/注册后可看大图

& W. [0 q- F  _8 o. G) w; f
2 B. W; I( _  Y
2、Flume
Flume 是一个分布式的、高可用的海量日志收集、聚合和传输日志收集系统,支持在日志系统中定制各类数据发送方(如:Kafka,HDFS 等),便于收集数据。Flume 提供了丰富的日志源收集类型,有:Console、RPC、Text、Tail、Syslog、Exec 等数据源的收集,在我们的日志系统中目前我们所使用的是 spooldir 方式进行日志文件采集,配置内容信息如下所示:
- u( H' _$ i, \4 W9 e0 m

# r- t5 K! U' j4 ~1 r" m
  y$ J* G8 c) A9 l  L
producer.sources.s.type = spooldirproducer.sources.s.spoolDir = /home/hadoop/dir/logdfs! `5 d0 o2 P0 A) q- I& X/ Y$ z

9 I" e2 j$ w$ `: s4 J% J" h$ \
, s2 A7 ^" O1 k) F; V! @
+ j2 k' A' P# i
5 d* Z2 p/ |# z2 s* T! N  C
( l" z* y0 F* ]& k2 P* v/ f5 h7 g  u! q# H

+ B# d, L9 z) G2 f
& r  U' Y" g) \1 e/ H0 |
) f* G* }  A8 F; J; ~2 n1 U8 J( O' i  \
复制代码: K5 u5 L- l8 Y' g! {
! M( \# I" a! u" z4 j7 H

1 f  I, J: i' l/ ~7 f. ]0 `* D4 g: ?& w4 E  \$ [  o- w' t1 w
4 d# v$ C) [' Z5 T3 [) O  Q* h8 c

2 c7 a% \6 K; H' D: t0 F, M
# T# A; I! o  @& J- j

3 |/ l( d- T3 z
当然,Flume 的数据发送方类型也是多种类型的,有:Console、Text、HDFS、RPC 等,这里我们系统所使用的是 Kafka 中间件来接收,配置内容如下所示:
  A$ X9 V6 P2 K/ W
* \% F6 b5 y; q  {  o7 g9 J

4 f5 x% N/ N0 s2 a: `producer.sinks.r.type = org.apache.flume.plugins.KafkaSinkproducer.sinks.r.metadata.broker.list=dn1:9092,dn2:9092,dn3:9092producer.sinks.r.partition.key=0producer.sinks.r.partitioner.class=org.apache.flume.plugins.SinglePartitionproducer.sinks.r.serializer.class=kafka.serializer.StringEncoderproducer.sinks.r.request.required.acks=0producer.sinks.r.max.message.size=1000000producer.sinks.r.producer.type=syncproducer.sinks.r.custom.encoding=UTF-8producer.sinks.r.custom.topic.name=test6 f' a: z9 d" g( j* u& r' H' O
! b8 T( v0 B1 i+ z. P. F& ?
' `+ X: [1 r2 x& `) B
- |, p0 Q. y. d$ O- }7 z) `

! q% {# X1 Y5 [, m( H8 I  H. _3 g) Q  u  c0 D4 V

' F+ R* P8 n8 K3 c% t
5 C+ x2 B# j1 D+ k+ r7 @) ]$ I- t2 u3 J- s* _( O1 X+ W5 t
# D+ {, s3 m" [# `4 @. V

4 J/ U. u& F- Z' l% n复制代码+ t( m5 v( f/ [9 W" g- O3 a" B
6 a) f% e( ?( U
4 h, s$ e# v, Z( D% l
: f- X) E  |- Z" X! p

8 W4 |' p( a6 Z& Z' B" e  A  X, b) u- n3 Y8 O, ~' ~* B- k

' F8 `' A) L% ?- f* D! b/ ^( b* e; e  G( A1 f/ x6 F! Y
. ^2 N' G% w" a# Y* G8 m

4 @: r& V2 B) i1 [- a6 }2 S7 ]) h5 F! \" R2 b8 x% L3 ~! X9 S
; N! y& z0 [$ T6 r4 R# O0 M

" S6 s4 j  o3 N2 A+ E/ B4 R2 b1 p0 `, A& G* V
' H/ u6 C' n9 b
3、Kafka
Kafka 是一种提供高吞吐量的分布式发布订阅消息系统,她的特性如下所示:

* a' }: g+ U$ q1 F1 a
  • 通过磁盘数据结构提供消息的持久化,这种结构对于即使数据达到 TB+级别的消息,存储也能够保持长时间的稳定。
  • 搞吞吐特性使得 Kafka 即使使用普通的机器硬件,也可以支持每秒数 10W 的消息。
  • 能够通过 Kafka Cluster 和 Consumer Cluster 来 Partition 消息。

    , J, \* J  Z9 M  R$ q% B* s

' f/ c: H2 W; t
Kafka 的目的是提供一个发布订阅解决方案,他可以处理 Consumer 网站中的所有流动数据,在网页浏览,搜索以及用户的一些行为,这些动作是较为关键的因素。这些数据通常是由于吞吐量的要求而通过处理日志和日志聚合来解决。对于 Hadoop 这样的日志数据和离线计算系统,这样的方案是一个解决实时处理较好的一种方案。
, R& s% ]/ c8 G$ K! E
关于 Kafka 集群的搭建部署和使用,上面已经写了,不会的朋友翻上去再看一下,这里就不赘述了。
4、Storm
Twitter 将 Storm 开源了,这是一个分布式的、容错的实时计算系统,已被贡献到 Apache 基金会,下载地址如下所示:

, t9 k4 n) R/ I# D+ d: f- }; K
, @7 d0 V; P$ s+ _( d

+ g4 I! I( m4 G' R4 x8 |http://storm.apache.org/downloads.html- T' o! A, U# [0 s9 P! k& @1 j

1 {: k% m: o. o% c3 u& C2 T4 _4 s3 b; K* `

* x0 T, Z, D$ t" c2 p3 _7 `1 D# c+ v9 s" o: d
$ a0 D: E. y- ~6 y' R

( W9 _8 x; ~' ]5 c7 t- e  w6 H8 T3 a! B0 z8 w; k5 o
9 d1 D% u" q( \+ H
& F' v" z1 C9 g5 J9 m$ g

3 V$ f1 x( {) c/ W; g复制代码. U+ f- ~( W4 J$ N* D& g+ o9 b6 J
: _; [! t5 e0 L# u: D) E

! [( J# L( B6 _/ o8 ~, F2 ?# L
' ^- Y6 S: j. e3 Y" J7 t; d6 }
" v4 u8 r8 d+ u! X2 w6 s, B
9 l% U5 k  U9 `2 c: @2 q* {
Storm 的主要特点如下:
" C4 U, T3 r6 t6 A4 E
  • 简单的编程模型。类似于 MapReduce 降低了并行批处理复杂性,Storm 降低了进行实时处理的复杂性。
  • 可以使用各种编程语言。你可以在 Storm 之上使用各种编程语言。默认支持 Clojure、Java、Ruby 和 Python。要增加对其他语言的支持,只需实现一个简单的 Storm 通信协议即可。
  • 容错性。Storm 会管理工作进程和节点的故障。
  • 水平扩展。计算是在多个线程、进程和服务器之间并行进行的。
  • 可靠的消息处理。Storm 保证每个消息至少能得到一次完整处理。任务失败时,它会负责从消息源重试消息。
  • 快速。系统的设计保证了消息能得到快速的处理,使用ØMQ 作为其底层消息队列。
  • 本地模式。Storm 有一个本地模式,可以在处理过程中完全模拟 Storm 集群。这让你可以快速进行开发和单元测试。
    ( `$ U* S  r6 h4 k- z/ m3 B, u1 M
5 c8 J% Y, F" w+ V
Storm 集群由一个主节点和多个工作节点组成。主节点运行了一个名为“Nimbus”的守护进程,用于分配代码、布置任务及故障检测。每个工作节 点都运行了一个名为“Supervisor”的守护进程,用于监听工作,开始并终止工作进程。
2 d5 P" W/ ^' J9 g
Nimbus 和 Supervisor 都能快速失败,而且是无 状态的,这样一来它们就变得十分健壮,两者的协调工作是由 Apache 的 ZooKeeper 来完成的。
- H) a2 Z" Z& b5 x3 N" |
Storm 的术语包括Stream、Spout、Bolt、Task、Worker、Stream Grouping和Topology。

" N0 V/ t5 a1 J% X. a+ x* p2 l; p
  • Stream 是被处理的数据。
  • Spout 是数据源。
  • Bolt 处理数据。
  • Task 是运行于 Spout 或 Bolt 中的 线程。
  • Worker 是运行这些线程的进程。
  • Stream Grouping 规定了 Bolt 接收什么东西作为输入数据。数据可以随机分配(术语为 Shuffle),或者根据字段值分配(术语为 Fields),或者广播(术语为 All),或者总是发给一个 Task(术语为 Global),也可以不关心该数据(术语为 None),或者由自定义逻辑来决定(术语为 Direct)。
  • Topology 是由 Stream Grouping 连接起来的 Spout 和 Bolt 节点网络。在 Storm Concepts 页面里对这些术语有更详细的描述。
    9 k/ ^; n& V& ~. {9 L0 |
% b+ m. b8 W! B: g0 F
关于 Storm 集群的搭建部署,博客在下一篇中更新,到时候会将更新地址附在这里,这里就先不对 Storm 集群的搭建部署做过多的赘述了。
5、总结
Kafka 日志消息保存时间总结 Kafka 作为一个高吞吐的消息中间件和传统的消息中间件一个很大的不同点就在于它的日志实际上是以日志的方式默认保存在/kafka-logs 文件夹中的。虽然默认有 7 天清楚的机制,但是在数据量大,而磁盘容量不足的情况下,经常出现无法写入的情况。如何调整 Kafka 的一些默认参数就显得比较关键了。这里笔者整理了一些常见的配置参数供大家参考:
9 g  x, c3 {5 N1 p9 k! ^$ ~
分段策略属性

" M6 U0 [* G# z* O# j) k1 M$ V, P% g
0 u, n; D3 ~0 x& ~

( S: O* y3 p+ F- Y2 ~  x, d7 q4 ?/ N/ r5 `; w, F- `
日志刷新策略
: V0 p# b, {6 b) p7 f# U
Kafka 的日志实际上是开始是在缓存中的,然后根据策略定期一批一批写入到日志文件中去,以提高吞吐率。

! a" ~( I' `% F& Z
: b3 i6 V7 }# V7 p# E/ ?  m
$ Z( F; n( O3 K5 @; N

2 {- _+ l2 L. b% X$ ~! L8 P
日志保存清理策略

: D& A% r! A% ^1 U- ^* S) P* z! [  I" @
; l# J# Z0 ]% V  r4 L+ H
; b& y* t- [9 Z! s/ q
这里特别说明一下,日志的真正清楚时间。当删除的条件满足以后,日志将被“删除”,但是这里的删除其实只是将该日志进行了“delete”标注,文件只是无法被索引到了而已。

7 s8 u4 ?0 S& u, ~& M
但是文件本身,仍然是存在的,只有当过了 log.segment.delete.delay.ms 这个时间以后,文件才会被真正的从文件系统中删除。
! l0 V. R" L# a  u" e; L* b

) L) Y8 G! {% Y+ x1 |
文章写到这里差不多了,比我预计要写得短一些,因为还有一些东西要写出来难免长篇大论,篇幅不允许,想更透彻的掌握 kafka 的同学可以领取我整理的完整版kafka学习笔记,最近要准备面试的同学可以看看我这份kafka高频面试题整理
5 D! M9 U0 H& Q7 o1 C! p
后面我会把另外两个中间件也分别写文章分析,可以给我点个关注第一时间接到通知

( w# A# R3 [9 q" W- T, M
您需要登录后才可以回帖 登录 | 开始注册

本版积分规则

关闭

站长推荐上一条 /4 下一条

如有购买积分卡请联系497906712

QQ|返回首页|Archiver|手机版|小黑屋|易陆发现 点击这里给我发消息

GMT+8, 2023-2-1 02:03 , Processed in 0.296713 second(s), 22 queries .

Powered by LR.LINUX.cloud bbs168x X3.2 Licensed

© 2012-2022 Comsenz Inc.

快速回复 返回顶部 返回列表