Kafka消息队列

最新推荐文章于 2024-09-19 22:40:25 发布

松myth

最新推荐文章于 2024-09-19 22:40:25 发布

阅读量9.9k

点赞数 5

分类专栏： Kafka 文章标签： kafka

本文链接：https://blog.csdn.net/song_myth/article/details/93177614

版权

Kafka 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Kafka消息队列

1. 概述

Kafka是Linkedin于2010年12月份开源的消息系统，它主要用于处理活跃的流式数据。活跃的流式数据在web网站应用中非常常见，这些数据包括网站的pv、用户访问了什么内容，搜索了什么内容等。这些数据通常以日志的形式记录下来，然后每隔一段时间进行一次统计处理。

传统的日志分析系统提供了一种离线处理日志信息的可扩展方案，但若要进行实时处理，通常会有较大延迟。而现有的消（队列）系统能够很好的处理实时或者近似实时的应用，但未处理的数据通常不会写到磁盘上，这对于Hadoop之类（一小时或者一天只处理一部分数据）的离线应用而言，可能存在问题。Kafka正是为了解决以上问题而设计的，它能够很好地离线和在线应用。

kafka对消息保存时根据Topic进行归类，发送消息者成为Producer,消息接受者成为Consumer,此外kafka集群有多个kafka实例组成，每个实例(server)成为broker。无论是kafka集群，还是producer和consumer都依赖于zookeeper来保证系统可用性集群保存一些meta信息。

官方文档: http://kafka.apache.org/documentation.html#producerconfigs

2. 基础名词

消息指的是通信的基本单位。由消息生产者（producer）发布关于某话题（topic）的消息，这句话的意思是，消息以一种物理方式被发送给了作为代理（broker）的服务器（可能是另外一台机器）。若干的消息使用者（consumer）订阅（subscribe）某个话题，然后生产者所发布的每条消息都会被发送给所有的使用者。

主要有以下一些消息术语（terminology）需要掌握：

Kafka用来区分消息的类，成为Topic
向Kafka的主题发布消息的进程成为producer
向Kafka主题注册，并且接收发布到主题的消息的进程成为consumer
Kafka是运行在一个集群上的，这个集群由一台或者多台服务器组成，其中每个组成的服务器都被叫做Broker

3. 部署结构

Introduction

kafka是显式分布式架构，producer、broker（Kafka）和consumer都可以有多个。Kafka的作用类似于缓存，即活跃的数据和离线处理系统之间的缓存。几个基本概念：

（1）message（消息）是通信的基本单位，每个producer可以向一个topic（主题）发布一些消息。如果consumer订阅了这个主题，那么新发布的消息就会广播给这些consumer。

（2）Kafka是显式分布式的，多个producer、consumer和broker可以运行在一个大的集群上，作为一个逻辑整体对外提供服务。对于consumer，多个consumer可以组成一个group，这个message只能传输给某个group中的某一个consumer.

（1）一个Topic可以认为是一类消息，每个topic将被分成多个partition(区),每个partition在存储层面是append log文件。任何发布到此partition的消息都会被直接追加到log文件的尾部，每条消息在文件中的位置称为offset（偏移量），offset为一个long型数字，它是唯一标记一条消息。它唯一的标记一条消息。kafka并没有提供其他额外的索引机制来存储offset，因为在kafka中几乎不允许对消息进行“随机读写”。

（2）消息被消费,消息仍然不会被立即删除.日志文件将会根据broker中的配置要求,保留一定的时间之后删除;比如log文件保留2天,那么两天后,文件会被清除,无论其中的消息是否被消费.kafka通过这种简单的手段,来释放磁盘空间,以及减少消息消费之后对文件内容改动的磁盘IO开支.

（3）分布式：一个Topic的多个partitions,被分布在kafka集群中的多个server上;每个server(kafka实例)负责partitions中消息的读写操作;此外kafka还可以配置partitions需要备份的个数(replicas),每个partition将会被备份到多台机器上,以提高可用性.基于replicated方案,那么就意味着需要对多个备份进行调度;每个partition都有一个server为"leader";leader负责所有的读写操作,如果leader失效,那么将会有其他follower来接管(成为新的leader);follower只是单调的和leader跟进,同步消息即可..由此可见作为leader的server承载了全部的请求压力,因此从集群的整体考虑,有多少个partitions就意味着有多少个"leader",kafka会将"leader"均衡的分散在每个实例上,来确保整体的性能稳定.

（4）partitions的设计目的有多个.最根本原因是kafka基于文件存储.通过分区,可以将日志内容分散到多个server上,来避免文件尺寸达到单机磁盘的上限,每个partiton都会被当前server(kafka实例)保存;可以将一个topic切分多任意多个partitions,来消息保存/消费的效率.此外越多的partitions意味着可以容纳更多的consumer,有效提升并发消费的能力.

Distributed

日志的分区分布在kafka集群的多台服务器上，每台服务器保存数据以及对每个分区数据的请求。每个分区会在多台服务器上进行副本备份以便容错，副本的数量是可配置的。

每个分区分有一个“leader”的服务器，剩下的都是“follower”。leader处理对这个分区的所有读写请求，与此同时，follower会被动地去复制leader上的数据。如果leader发生故障，其中一个follower会自动成为新的leader。每台服务器可以作为一些分区的leader，同时也作为其他一些分区的follower，这样在集群内部就可以做到一个很好的负载均衡。

Producer

生产者（producer）可以根据具情况将消息发布（publish）到一个主题（topic）上。生产者可以选择将哪条消息发布到这个主题下的某一个分区（partition）。这可以用传统的轮询方式以保证负载均衡，也可以根据一些语义分区函数来做。更多的有关分区的内容后面会讲到。

Consumer

传统的消息系统有两种模型：队列和发布-订阅模式。在队列模型中，一堆消费者会从一台机子上读消息，每一条消息只会被一个消费者读到；在发布订阅模型中，消息会向所有的消费者广播。Kafka提供了一种单一的将这两种模型进行抽象的消费者模式——消费者组（consumer group）。

消费者会属于某一个组，发布到每个主题的消息会递送给订阅了这个主题的消费者组中的一个消费者。消费者实例可以是不同的进程或者在不同的机器上。如果所有的消费者从属于同一个组，这就跟传统的队列模式一样了。如果每个消费者自成一组，那么这就是发布订阅模式了，所有的消息会被广播给所有的消费者。但是通常情况下，我们发现，主题会有多个消费者组，每个组对应一个逻辑上的订阅者，每个组由多个消费者实例组成以保证扩展性和容错性。

Kafka处理定序问题上也去传统的消息系统不一样。传统的队列允许消息被任何一个消费者实例所消费。这意味着消息的顺序丢失了。也就是说，尽管在队列中消息是有顺序的，但这些消息会到达不同的消费者并且被无序地处理。在Kafka里，因为有并行的概念——分区，Kafka可以同时提供顺序保证和负载均衡。这可以通过将主题中的分区分配给消费者组中的消费者来实现，这样的话每个分区只被这个组中的一个消费者所消费。这样我们还可以保证这个消费者是这个分区的唯一消费者，并且是按原来的顺序来处理数据的。因为有许多分区，所以也就可以在多个消费者实例中实现负载均衡。需要注意的是，消费者实例的数量不可能比分区多。

A two server Kafka cluster hosting four partitions (P0-P3) with two consumer groups. Consumer group A has two consumer instances and group B has four.

Guaratees

1. 由生产者发送给特定主题分区的消息会以发送的顺序追加（appended）。也就是说，如果一条消息M1被同一个生产者以M2来发送，并且M1先发，那么M1的offset就会比M2更小，并且先出现在日志中。简言之就是先进先出的队列形式

2. 一个消费者实例会按消息在日志中的存储顺序看到它们。

3. 对于副本因子为N的主题，我们可以承受N-1个服务器发生故障而保证提交到日志的消息不会丢失

4. 配置文件结构

kafka master节点配置摘录

/usr/local/kafka/config/server.properties

最为核心的三个配置 broker.id、log.dir、zookeeper.connect

参数	用途
broker.id =0	每一个broker在集群中的唯一表示，要求是正数。当该服务器的IP地址发生改变时，broker.id没有变化，则不会影响consumers的消息情况
log.dirs=/data0/kafka_data	kafka数据的存放地址，多个地址的话用逗号分割,多个目录分布在不同磁盘上可以提高读写性能
port =9092	broker server服务端口
num.network.threads =4	broker处理消息的最大线程数，一般情况下数量为cpu核数
num.io.threads =8	broker处理磁盘IO的线程数，数值为cpu核数2倍
background.threads =4	一些后台任务处理的线程数，例如过期消息文件的删除等，一般情况下不需要去做修改
queued.max.requests =500	等待IO线程处理的请求队列最大数，若是等待IO的请求超过这个数值，那么会停止接受外部消息
host.name	broker的主机地址，若是设置了，那么会绑定到这个地址上，若是没有，会绑定到所有的接口上，并将其中之一发送到ZK，一般不设置
socket.send.buffer.bytes=100*1024	socket的发送缓冲区，socket的调优参数SO_SNDBUFF
socket.receive.buffer.bytes =100*1024	socket的接受缓冲区，socket的调优参数SO_RCVBUFF
socket.request.max.bytes =10010241024	socket请求的最大数值，防止serverOOM，message.max.bytes必然要小于socket.request.max.bytes，会被topic创建时的指定参数覆盖
log.segment.bytes =102410241024	topic的分区是以一堆segment文件存储的，这个控制每个segment的大小，会被topic创建时的指定参数覆盖
log.roll.hours =24*7	这个参数会在日志segment没有达到log.segment.bytes设置的大小，也会强制新建一个segment会被 topic创建时的指定参数覆盖
log.cleanup.policy = delete	日志清理策略选择有：delete和compact主要针对过期数据的处理，或是日志文件达到限制的额度，会被 topic创建时的指定参数覆盖
log.retention.minutes=300 或 log.retention.hours=24	数据文件保留多长时间，存储的最大时间超过这个时间会根据log.cleanup.policy设置数据清除策略log.retention.bytes和log.retention.minutes或log.retention.hours任意一个达到要求，都会执行
log.retention.bytes=-1	topic每个分区的最大文件大小，一个topic的大小限制 = 分区数*log.retention.bytes。-1没有大小限log.retention.bytes和log.retention.minutes任意一个达到要求，都会执行删除，会被topic创建时的指定参数覆盖
log.cleaner.enable=false	是否开启日志压缩
log.cleaner.threads = 2	日志压缩线程
log.cleaner.io.buffer.size=512*1024	日志清理时候用到的IO块大小一般不需要修改
log.cleaner.io.buffer.load.factor =0.9	日志清理中hash表的扩大因子一般不需要修改
log.cleaner.min.cleanable.ratio=0.5	日志清理的频率控制，越大意味着更高效的清理，同时会存在一些空间上的浪费，会被topic创建时的指定参数覆盖
log.cleaner.delete.retention.ms =1day	对于压缩的日志保留的最长时间，也是客户端消费消息的最长时间，同log.retention.minutes的区别在于一个控制未压缩数据，一个控制压缩后的数据。会被topic创建时的指定参数覆盖
log.index.size.max.bytes =1010241024	对于segment日志的索引文件大小限制，会被topic创建时的指定参数覆盖
log.index.interval.bytes =4096	当执行一个fetch操作后，需要一定的空间来扫描最近的offset大小，设置越大，代表扫描速度越快，但是也更好内存，一般情况下不需要搭理这个参数
log.flush.interval.messages=1000	log文件”sync”到磁盘之前累积的消息条数,因为磁盘IO操作是一个慢操作,但又是一个”数据可靠性"的必要手段,所以此参数的设置,需要在"数据可靠性"与"性能"之间做必要的权衡.如果此值过大,将会导致每次"fsync"的时间较长(IO阻塞),如果此值过小,将会导致"fsync"的次数较多,这也意味着整体的client请求有一定的延迟.物理server故障,将会导致没有fsync的消息丢失
auto.create.topics.enable =true	是否允许自动创建topic，若是false，就需要通过命令创建topic
num.partitions =1	每个topic的分区个数，若是在topic创建时候没有指定的话会被topic创建时的指定参数覆盖

kafka Consumer配置摘录

最为核心的配置是group.id、zookeeper.connect

参数	用途
group.id	Consumer归属的组ID，broker是根据group.id来判断是队列模式还是发布订阅模式，非常重要
consumer.id	消费者的ID，若是没有设置的话，会自增
client.id = group id value	一个用于跟踪调查的ID ，最好同group.id相同
zookeeper.connect=localhost:2182	对于zookeeper集群的指定，可以是多个 hostname1:port1,hostname2:port2,hostname3:port3 必须和broker使用同样的zk配置
zookeeper.session.timeout.ms = 6000	zookeeper的心跳超时时间，查过这个时间就认为是dead消费者
zookeeper.connection.timeout.ms = 6000	zookeeper的等待连接时间
zookeeper.sync.time.ms = 2000	zookeeper的follower同leader的同步时间
auto.offset.reset = largest	当zookeeper中没有初始的offset时候的处理方式。smallest ：重置为最小值 largest:重置为最大值 anything else：抛出异常
socket.timeout.ms= 30 * 1000	socket的超时时间，实际的超时时间是：max.fetch.wait + socket.timeout.ms.
socket.receive.buffer.bytes=64 * 1024	socket的接受缓存空间大小
fetch.message.max.bytes = 1024 * 1024	从每个分区获取的消息大小限制
auto.commit.enable = true	是否在消费消息后将offset同步到zookeeper，当Consumer失败后就能从zookeeper获取最新的offset
auto.commit.interval.ms = 60 * 1000	自动提交的时间间隔
queued.max.message.chunks = 10	用来处理消费消息的块，每个块可以等同于fetch.message.max.bytes中数值
rebalance.max.retries = 4	当有新的consumer加入到group时,将会reblance,此后将会有partitions的消费端迁移到新,的consumer上,如果一个consumer获得了某个partition的消费权限,那么它将会向zk注册,"Partition Owner registry"节点信息,但是有可能此时旧的consumer尚没有释放此节点,此值用于控制,注册节点的重试次数.
rebalance.backoff.ms = 2000	每次再平衡的时间间隔
refresh.leader.backoff.ms	每次重新选举leader的时间
fetch.min.bytes = 1	server发送到消费端的最小数据，若是不满足这个数值则会等待，知道满足数值要求
fetch.wait.max.ms = 100	若是不满足最小大小(fetch.min.bytes)的话，等待消费端请求的最长等待时间
consumer.timeout.ms = -1	指定时间内没有消息到达就抛出异常，一般不需要改

kafka Producer配置摘录

比较核心的配置：metadata.broker.list、request.required.acks、producer.type、serializer.class

参数	用途
metadata.broker.list	消费者获取消息元信息(topics, partitions and replicas)的地址,配置格式是：host1:port1,host2:port2，也可以在外面设置一个vip
request.required.acks = 0	消息的确认模式,0：不保证消息的到达确认，只管发送，低延迟但是会出现消息的丢失，在某个server失败的情况下，有点像TCP,1：发送消息，并会等待leader 收到确认后，一定的可靠性,-1：发送消息，等待leader收到确认，并进行复制操作后，才返回，最高的可靠性
request.timeout.ms = 10000	消息发送的最长等待时间
send.buffer.bytes=100*1024	socket的缓存大小
key.serializer.class	key的序列化方式，若是没有设置，同serializer.class
partitioner.class=kafka.producer.DefaultPartitioner	分区的策略，默认是取模
compression.codec = none	消息的压缩模式，默认是none，可以有gzip和snappy
compressed.topics=null	可以针对默写特定的topic进行压缩
message.send.max.retries = 3	消息发送失败后的重试次数
retry.backoff.ms = 100	每次失败后的间隔时间
topic.metadata.refresh.interval.ms = 600 * 1000	生产者定时更新topic元信息的时间间隔，若是设置为0，那么会在每个消息发送后都去更新数据
client.id=""	用户随意指定，但是不能重复，主要用于跟踪记录消息
producer.type=sync	生产者的类型 async:异步执行消息的发送 sync：同步执行消息的发送
queue.buffering.max.ms = 5000	异步模式下，那么就会在设置的时间缓存消息，并一次性发送
queue.buffering.max.messages = 10000	异步的模式下最长等待的消息数
queue.enqueue.timeout.ms = -1	异步模式下，进入队列的等待时间若是设置为0，那么要么进入队列，要么直接抛弃
batch.num.messages=200	异步模式下，每次发送的最大消息数，前提是触发了queue.buffering.max.messages或是queue.buffering.max.ms的限制
serializer.class = kafka.serializer.DefaultEncoder	消息体的系列化处理类，转化为字节流进行传输