kafka原理 kafka原理详解

Kafka面试题

第十八阶段 SparkMllib机器学习平台

Kafka是分布式发布-消息系统，它最初是由LinkedIn公司开发的，之后成为Apache项目的一部分，Kafka是一个分布式，可划分的，冗余备份的持久性的日志服务，它主要用于处理流式数据。

kafka原理 kafka原理详解

fileChannel.transferTo( ition, count, socketChannel);

为什么要使用 kafka，为什么要使用消息队列

消息发送

解决方案

1.配置ack=all/-1，tries > 1,unclean.leader.election.enable = false

producer发送完消息，等待follower同步完成再返回，如果异常则重试，副本数量可能影响吞吐量

不允许选举ISR的副本作为leader

2.配置min.insync.replicas>1

副本指定必须写作成功的最小副本数量，如果不能满足这个最小值，则生产者引发一个异常（NotEnoughReplicash或者NotEnoughReplicashAfterAppend）

先commit再处理消息，如果处理消息的时候异常了，但offset已经提交了，这条消息对于消费者来说丢失了

broker的刷盘

减少刷盘的间隔

kafka如何保证不重复消费又不丢失数据

1.必须要求至少一个 Follower 在 ISR 列表里。

2.第二条，每次写入数据的时候，要求 Leader 写入成功以外，至少一个 ISR 里的 Follower 也写成功。

pull模式

push模式

缺点：速率固定，忽略了consumer的消费能力，可能导致拒绝服务或者网络阻塞等情况

1. Broker注册 Broker是分布式部署并且相互之间相互，但是需要有一个注册系统能够将整个集群中的Broker管理起来 /brokers/ids

2. Topic注册 在Kafka中，同一个Topic的消息会被分成多个分区并将其分布在多个Broker上，这些分区信息及与Broker的对应关系也都是由Zookeeper在维护 /borkers/topics

3. 生产者负载均衡 由于同一个Topic消息会被分区并将其分布在多个Broker上，因此，生产者需要将消息合理地发送到这些分布式的Broker上，那么如何实现生产者的负载均衡，Kafka支持传统的四层负载均衡，也支持Zookeeper方式实现负载均衡。

5. 分区与消费者 的关系 在Kafka中，规定了每个消息分区 只能被同组的一个消费者进学习目标：Sqoop原理剖析、Sqoop编程实践行消费，因此，需要在 Zookeeper 上记录 消息分区 与 Consumer 之间的关系，每个消费者一旦确定了对一个消息分区的消费权力，需要将其Consumer ID 写入到 Zookeeper 对应消息分区的临时节点上，例如：

/consumers/[group_id]/owners/[topic]/[broker_id-partition_id]

其中，[broker_id-partition_id]就是一个 消息分区 的标识，节点内容就是该 消息分区 上 消费者的Consumer ID。

6. 消息消费进度Offset 记录 在消费者对指定消息分区进行消息消费的过程中，需要定时地将分区消息的消费进度Offset记录到Zookeeper上，以便在该消费者进行重启或者其他消费者重新接管该消息分区的消息消费后，能够从之前的进度开始继续进行消息消费。Offset在Zookeeper中由一个专门节点进行记录，其节点路径为:

/consumers/[group_id]/offsets/[topic]/[broker_id-partition_id]

节点内容就是Offset的值。

7. 消费者注册 消费者在初始化启动时加入消费者分组的步骤如下

注册到消费者分组。每个消费者启动时，都会到Zookeeper的指定节点下创建一个属于自己的消费者节点，例如/consumers/[group_id]/ids/[consumer_id]，完成节点创建后，消费者就会将自己的Topic信息写入该临时节点。

1.顺序写磁盘（相比磁盘的随机写快很多）。如果你是追加文件末尾按照顺序的方式来写数据的话，那么这种磁盘顺序写的性能基本上可以跟写内存的性能本身也是不多的。

2.利用Page Cache（页高速缓冲存储器，简称页高缓）空中接力的方式来实现高效读写，作系统本身有一层缓存，叫做page cache，是在内存里的缓存，我们也可以称之为os cache，意思就是作系统自己管理的缓存。原理就是Page Cache可以把磁盘中的数据缓存到内存中，把对磁盘的访问改为对内存的访问。

3.零拷贝 零拷贝技术是一种避免CPU将数据从一块存储拷贝到另一块存储的技术。Kafka使用零拷贝技术将数据直接从磁盘到网卡设备缓冲区中，而不需要经过应用程序的转发。

通常应用程序将磁盘上的数据传送至网卡需要经过4步：

-调用read()，将数据从磁盘到内核模式的缓冲区；

-CPU会将数据从内核模式到用户模式下的缓冲区；

-将数据从内核模式的Socket缓冲区到网卡设备。

上面的步骤中，第2、3步将数据从内核模式经过用户模式再绕回内核模式，浪费了两次过程。采用零拷贝技术，Kafka可以直接请求内核把磁盘中的数据到Socket缓冲区，而不用再经过用户模式

Rebalance 的触发条件有3个

Rebalance 发生时，Group 下所有 consumer 实例都会协调在一起共同参与，kafka 能够保证尽量达到最公平的分配。但是 Rebalance 过程对 consumer group 会造成比较的影响。在 Rebalance 的过程中 consumer group 下的所有消费者实例都会停止工作，等待 Rebalance 过程完成。

GroupCoordinator(协调者)：协调消费者组完成消费者Rebalance的重要组件，每一个broker都会启动一个GroupCoodinator，Kafka 按照消费者组的名称将其分配给对应的GroupCoodinator进行管理；每一个GroupCoodinator只负责管理一部分消费者组，而非集群中全部的消费者组。通常是partition的leader节点的broker

如果C1消费消息超时，出入rebalance，重新分配后该消息被其他消费者消费，此时C1消费完成提交offset，导致错误

解决：Coordinator每次进行rebalance，会标记一个generation给consumer，每次rebalance该generation会+1,consumer提交offset时，会对比generation，不一致则拒绝提交。

ISR :In-Sync Replicas 副本同步队列

AR :Assigned Replicas 所有副本

ISR是由leader维护，follower从leader同步数据有一些延迟（包括延迟时间replica.lag.time.max.ms和延迟条数两个维度, 当前的版本0.10.x中只支持replica.lag.time.max.ms这个维度），任意一个超过阈值都会把follower剔除出ISR, 存入OSR（Outof-Sync Replicas）列表，新加入的follower也会先存放在OSR中。AR=ISR+OSR。

在 Kafka 中，每个 主题分区下的每条消息都被赋予了一个的 ID 数值，用于标识它在分区中的位置。这个 ID 数值，就被称为位移，或者叫偏移量。一旦消息被写入到分区日志，它的位移值将不能被修改。

auto.offset.reset：消费规则，默认earliest 。

earliest: 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费

Kafka 副本当前分为副本和追随者副本。只有Leader副本才能 对外提供读写服务，响应s端的请求。Follower 副本只是采用拉(PULL)的方 式，被动地同步Leader副本中的数据，并且在Leader副本所在的 Broker 宕机后，随时准备应聘 Leader 副本。

kafka在所有broker中选出一个controller，所有Partition的Leader选举都由controller决定。controller会将Leader的改变直接通过RPC的方式（比Zookeeper Queue的方式更高效）通知需为此作出响应的Broker。同时controller也负责增删Topic以及Replica的重新分配。

分区的 Leader 副本选举对用户是完全透明的，它是由 Controller 完成的。你需要回答的是，在哪些场景下，需要执行分区 Leader 选举。每一种场景对应于一种选举策略。当前，Kafka 有 4 种分区 Leader 选举策略。

集群 partition 备份 Kafka 支持设置针对每个 partition 备份，可以将 partition 备份到不同的 broker 上，其中 leader partition 负责读写，其他 follower 仅负责同步，当 leader 挂掉后会从 follower 中选取新的 leader 。

消息消费顺序 一个 partition 同一时刻在一个 consumer group 中只能有一个 consumer 实例在消费，从而保证了消费顺序。consumer group 中的 consumer 实例的数量不能比一个 topic 中的 partition 的数量多，否则，多出来的 consumer 无法消费到消息。Kafka 的消息在单个 partition 上是可以保证顺序的，但是在整体上无法保证顺序消费

消息消费模式 关于消费模式，Kafka 通过 消费组的概念可以灵活设置。如常见的 队列模式 即 所有的 consumer 在同一个 consumer group 下。发布模式 则设置多个 consumer group 进行消费即可

acks:消息的确认机制，默认值是0。

acks=0：如果设置为0，生产者不会等待kafka的响应。

acks=1：这个配置意味着kafka会把这条消息写到本地日志文件中，但是不会等待集群中其他机器的成功响应。

acks=all：这个配置意味着leader会等待所有的follower同步完成。这个确保消息不会丢失，除非kafka集群中所有机器挂掉。这是最强的可用性保证。

Kafka零拷贝

4. 消费者负载均衡 与生产者类似，Kafka中的消费者同样需要进行负载均衡来实现多个消费者合理地从对应的Broker上接收消息，每个消费者分组包含若干消费者，每条消息都只会发送给分组中的一个消费者，不同的消费者分组消费自己特定的Topic下面的消息，互不干扰。

用kafka做存储层，为什么呢？一大堆可以做数据存储的 MySQL、MongoDB、HDFS……

因为kafka数据是持久化磁盘的，还速度快；还可靠、支持分布式……

啥！用了磁盘，还速度快！！！

没错，kafka就是速度，本文将探究kafka性能背后的秘密。

首先要有个概念，kafka高性能的背后，是多方面协同后、最终的结果，kafka从宏观架构、分布式partition存储、ISR数据同步、以及“无孔不入”的高效利用磁盘/作系统特性，这些多方面的协同，是kafka成为性能的必然结果。

本文将从kafka零拷贝，探究其是如何“无孔不入”的高效利用磁盘/作系统特性的。

零拷贝并不是不需要拷贝，而是减少不必要的拷贝次数。通常是说在IO读写过程中。

实际上，零拷贝是有广义和狭义之分，目前我们通常听到的零拷贝，包括上面这个定义 减少不必要的拷贝次数 都是广义上的零拷贝。其实了解到这点就足够了。

我们知道，减少不必要的拷贝次数，就是为了提高效率。那零拷贝之前，是怎样的呢？

比如：读取文件，再用socket发送出去

传统方式实现：

先读取、再发送，实际经过1~4四次copy。

1、次：将磁盘文件，读取到作系统内核缓冲区；

2、第二次：将内核缓冲区的数据，copy到application应用程序的buffer；

3、第三步：将application应用程序buffer中的数据，copy到socket网络发送缓冲区(属于作系统内核的缓冲区)；

4、第四次：将socket buffer的数据，copy到网卡，由网卡进行网络传输。

传统方式，读取磁盘文件并进行网络发送，经过的四次数据copy是非常繁琐的。实际IO读写，需要进行IO中断，需要CPU响应中断(带来上下文切换)，尽管后来引入DMA来接管CPU的中断请求，但四次copy是存在“不必要的拷贝”的。

重新思考传统IO方式，会注意到实际上并不需要第二个和第三个数据副本。应用程序除了缓存数据并将其传输回套接字缓冲区之外什么都不做。相反，数据可以直接从读缓冲区传输到套接字缓冲区。

显然，第二次和第三次数据copy 其实在这种场景下没有什么帮助反而带来开销，这也正是零拷贝出现的意义。

这种场景 ：是指读取磁盘文件后，不需要做其他处理，直接用网络发送出去。试想，如果读取磁盘的数据需要用程序进一步处理的话，必须要经过第二次和第三次数据copy，让应用程序在内存缓冲区处理。

kafka作为MQ也好，作为存储层也好，无非是两个重要功能，一是Producer生产的数据存到broker，二是 Consumer从broker读取数据；我们把它简化成如下两个过程：

1、网络数据持久化到磁盘 (Producer 到 Broker)

下面，先给出“kafka用了磁盘，还速度快”的结论

1、顺序读写

磁盘顺序读或写的速度400M/s，能够发挥磁盘的速度。

随机读写，磁盘速度慢的时候十几到几百K/s。这就看出了距。

kafka将来自Producer的数据，顺序追加在partition，partition就是一个文件，以此实现顺序写入。

Consumer从broker读取数据时，因为自带了偏移量，接着上次读取的位置继续读，以此实现总的来说Kafka快的原因：顺序读。

顺序读写，是kafka利用磁盘特性的一个重要体现。

2、零拷贝 sendfile(in,out)

数据直接在内核完成输入和输出，不需要拷贝到用户空间再写出去。

kafka数据写入磁盘前，数据先写到进程的内存空间。

3、mmap文件映射

虚拟映射只支持文件；

在进程 的非堆内存开辟一块内存空间，和OS内核空间的一块内存进行映射，

kafka数据写入、是写入这块内存空间，但实际这块内存和OS内核内存有映射，也就是相当于写在内核内存空间了，且这块内核空间、内核直接能够访问到，直接落入磁盘。

这里，我们需要清楚的是：内核缓冲区的数据，flush就能完成落盘。

我们来重点探究 kafka两个重要过程、以及是如何利用两个零拷贝技术sendfile和mmap的。

传统方式实现：

先接收生产者发来的消息，再落入磁盘。

实际会经过四次copy，如下图的四个箭头。

数据落盘通常都是非实时的，kafka生产者数据持久化也是如此。Kafka的数据 并不是实时的写入硬盘 ，它充分利用了现代作系统分页存储来利用内存提高I/O效率。

在此 特殊场景 下：接收来自socket buffer的网络数据，应用进程不需要中间处理、直接进行持久化时。——可以使用mmap内存文件映射。

简称mmap，简单描述其作用就是：将磁盘文件映射到内存, 用户通过修改内存就能修改磁盘文件。

它的工作原理是直接利用作系统的Page来实现文件到物理内存的直接映射。完成映射之后你对物理内存的作会被同步到硬盘上（作系统在适当的时候）。

通过mmap，进程像读写硬盘一样读写内存（当然是虚拟机内存），也不必关心内存的大小有虚拟内存为我们兜底。

使用这种方式可以获取很大的I/O提升，省去了用户空间到内核空间的开销。

mmap也有一个很明显的缺陷——不可靠，写到mmap中的数据并没有被真正的写到硬盘，作系统会在程序主动调用flush的时候才把数据真正的写到硬盘。Kafka提供了一个参数——producer.type来控制是不是主动flush；如果Kafka写入到mmap之后就立即flush然后再返回Producer叫同步(sync)；写入mmap之后立即返回Producer不调用flush叫异步(async)。

Ja NIO，提供了一个 MappedByteBuffer 类可以用来实现内存映射。

MappedByteBuffer只能通过调用FileChannel的map()取得，再没有其他方式。

FileChannel.map()是抽象方法，具体实现是在 FileChannelImpl.c 可自行查看JDK源码，其map0()方法就是调用了Linux内核的mmap的API。

使用 MappedByteBuffer类要注意的是：mmap的文件映射，在full gc时才会进行释放。当close时，需要手动清除内存映射文件，可以反射调用sun.misc.Cleaner方法。

传统方式实现：

先读取磁盘、再用socket发送，实际也是进过四次copy。

而 Linux 2.4+ 内核通过 sendfile 系统调用，提供了零拷贝。磁盘数据通过 DMA 拷贝到内核态 Buffer 后，直接通过 DMA 拷贝到 NIC Buffer(socket buffer)，无需 CPU 拷贝。这也是零拷贝这一说法的来源。除了减少数据拷贝外，因为整个读文件 - 网络发送由一个 sendfile 调用完成，整个过程只有两次上下文切换，因此大大提高了性能。零拷贝过程如下图所示。

相比于文章开始，对传统IO 4步拷贝的分析，sendfile将第二次、第三次拷贝，一步完成。

其实这项零拷贝技术，直接从内核空间（DMA的）到内核空间（Socket的)、然后发送网卡。

应用的场景非常多，如Tomcat、Nginx、Apache等web返回静态资源等，将数据用网络发送出去，都运用了sendfile。

简单理解 sendfile(in,out)就是，磁盘文件读取到作系统内核缓冲区后、直接扔给网卡，发送网络数据。

Ja NIO对sendfile的支持 就是FileChannel.transferTo()/transferFrom()。

把磁盘文件读取OS内核缓冲区后的fileChannel，直接转给socketChannel发送；底层就是sendfile。消费者从broker读取数据，就是由此实现。

具体来看，Kafka 的数据传输通过 TransportLayer 来完成，其子类 PlaintextTranspor-调用write()，将数据从用户模式下到内核模式下的Socket缓冲区；tLayer 通过Ja NIO 的 FileChannel 的 transferTo 和 transferFrom 方法实现零拷贝。

注： transferTo 和 transferFrom 并不保证一定能使用零拷贝。实际上是否能使用零拷贝与作系统相关，如果作系统提供 sendfile 这样的零拷贝系统调用，则这两个方通过这样的系统调用充分利用零拷贝的优势，否则并不能通过这两个方法本身实现零拷贝。

1、partition顺序读写，充分利用磁盘特性，这是基础；

2、Producer生产的数据持久化到broker，采用mmap文件映射，实现顺序的快速写入；

3、Customer从broker读取数据，采用sendfile，将磁盘文件读到OS内核缓冲区后，直接转到socket buffer进行网络发送。

1、都是Linux内核提供、实现零拷贝的API；

2、sendfile 是将读到内核空间的数据，转到socket buffer，进行网络发送；

3、mmap将磁盘文件映射到内存，支持读和写，对内存的作会反映在磁盘文件上。

RocketMQ 在消费消息时，使用了 mmap。kafka 使用了 sendFile。

大数据运营的核心课程都有哪些？

在实际生产环境中，使用单个实例的消息队列服务，如果遇到宕机、重启等系统问题，消息队列就无法提供服务了，因此很多场景下，我们希望消息队列有高可用性支持，例如RabbitMQ的镜像集群模式的高可用性方案，ActiveMQ也有基于LlDB+ZooKeeper的高可用性方案，以及Kafka的Replication机制等。

阶段：Ja设计与编程思想

学习内容：Ja设计与编程思想

学习效果：熟练掌握Ja语法并灵活运用，能够开发后台应用

第二阶段 Web前端开发

学习内容：Web前端开发

学习目标：HTML基础、CSS3基础、JS脚本编程

学习效果：能够基于HTML+CSS+JQuery进行前端开发

第三阶段 JaEE进阶

学习内容：JaEE进阶

学习效果：掌握主流JaWeb框架并灵活运用

第四阶段 大数据基础

学习内容：大数据基础

学习目标：Linux基础、Men基础

第五阶段 HDFS分布式文件系统

学习目标：HDFS原理剖析、HDFS编程

学习效果：深入理解HDFS的原理并灵活运用

第六阶段MapReduce分布式计算模型

学习内容：MapReduce分布式计算模型

学习目标：MapReduce原理剖析、MapReduce实践

学习效果：熟练掌握MapReduce原理并灵活运用

第七阶段 Yarn分布式资源管理器

学习内容：Yarn分布式资源管理器

学习目标：Yarn原理剖析、Yarn实践

学习效果：深入理解Yarn的原理并调优

第学习效果：熟练掌握Linux及Men等相关知识并灵活运用八阶段 Zookeeper分布式协调服务

学习内容：Zookeeper分布式协调服务

学习目标：Zookeeper原理剖析、Zookeeper实践

学习效果：深入理解Zookeeper的原理并灵活运用

第九阶段 Hbase分布式数据库

学习内容：Hbase分布式数据库

学习效果：深入理解Hbase的原理并灵活运用及调优

第十阶段 Hive分布式数据仓库

学习内容：Hive分布式数据仓库

学习目标：Hive原理剖析、Hive编程实践

学习效果：深入理解Hive的原理并灵活运用

第十一阶段 FlumeNG分布式数据采集系统

学习内容：FlumeNG分布式数据采集系统

学习目标：FlumeNG原理剖析、FlumeNG编程实践

学习效果：熟练掌握FlumeNG的各种应用场景

第十二阶段 Sqoop大数据迁移系统

学习内容：Sqoop大数据迁移系统

学习效果：熟练掌握Sqoop并灵活运用

第十三阶段 Scala大数据黄金语言

以上的引用是kafka对于参数 acks 的解释（在老版本中，该参数是 request.required.acks ）。学习内容：Scala大数据黄金语言

学习目标：Scala语法剖析、Scala应用实践

学习效果：熟练掌握Scala各种语法并灵活运用

第十四阶段 kafka分布式总线系统

学习内容：kafka分布式总线系统

学习目标：kafka原理剖析、kafka编程实践

学习效果：深入理解kafka原理并灵活运用及调优

第十五阶段 SparkCore大数据计算基石

学习内容：SparkCore大数据计算基石

学习目标：SparkCore核心原理、SparkCore实践

学习效果：深入理解SparkCore原理并灵活运用及调优

第十六阶段 SparkSQL数据挖掘利器

学习内容：SparkSQL数据挖掘利器

学习目标：SparkSQL核心原理、SparkSQL实践

学习效果：熟练掌握SparkSQL的各种应用场景并灵活运用

第十七阶段 SparkStreaming流失计算平台

学习内容：SparkStreaming流失计算平台

学习目标：SparkStreaming核心原理、SparkStreaming实践

学习效果：深入理解SparkStreaming原理及各种应用场景和调优

学习内容：SparkMllib机器学习平台

学习目标：SparkMllib算法模型及核心原理、SparkMllib实践

学习效果：熟练掌握SparkMllib的常用算法并灵活运用

第十九阶段 SparkGraphx图计算平台

学习内容：SparkGraphx图计算平台

学习目标：SparkGraphx核心原理、SparkGraphx实践

学习效果：深入理解SparkGraphx的原理并灵活运用

第二十阶段 大数据项目实战

学习内容：大数据项目实战

学习目标：4个大数据项目的实战

学习效果：能够基于所学知识在真实的项目中练

消息队列核心原理

学习目标：Hbase原理剖析、Hbase编程实践

消息队列已经逐渐成为分布式应用场景、内部通信、以及秒杀等高并发业务场景的核心手段，它具有低耦合、可靠投递、广播、流量控制、最终一致性 等一系列功能。

Linux系统&Hadoop生态体系

无论是 RabbitMQ、RocketMQ、ActiveMQ、Kafka还是其它等，都有的一些基本原理、术语、机制等，总结分享出来，希望大家在使用消息队列技术的时候能够快速理解。

【达内教育】推出了全新的六维全息课程体系，分为基础课、专业课、项目课、企业课、就业课、职后课，全方位的提升学员的技能能力，并且全程小班面授确保教学品质。如需学习大数据，选择【达内教育】。

1.消息生产者Producer：发送消息到消息队列。

2.消息消费者Consumer：从消息队列接收消息。

3.Broker：概念来自与Apache ActiveMQ，指MQ的服务端，帮你把消息从发送端传送到接收端。

4.消息队列Queue：一个先进先出的消息存储区域。消息按照顺序发送接收，一旦消息被消费处理，该消息将从队列中删除。

1）消息的转储：在更合适的时间点投递，或者通过一系列手段辅助消息最终能送达消费机。

2）规范一种范式和通用的模式，以满足解耦、最终一致性、错峰等需求。

3）其实简单理解就是一个消息转发器，把一次RPC做成两次RPC。发送者把消息投递到broker，broker再将消息转发一手到接收端。

总结起来就是两次RPC加一次转储，如果要做消费确认，则是三次RPC。

点对点模型 用于 消息生产者 和 消息消费者 之间 点到点 的通信。

点对点模式包含三个角色：

发布模型包含三个角色：

生产者发送一条消息到队列queue，只有一个消费者能收到。

发布者发送到topic的消息，只有了topic的者才会收到消息。

基于Queue消息模型，利用FIFO先进先出的特性，可以保证消息的顺序性。

即消息的Ackownledge确认机制，为了保证消息不丢失，消息队列提供了消息Acknowledge机制，即ACK机制，当Consumer确认消息已经被消费处理，发送一个ACK给消息队列，此时消息队列便可以删除这个消息了。如果Consumer宕机/关闭，没有发送ACK，消息队列将认为这个消息没有被处理，会将这个消息重新发送给其他的Consumer重新消费处理。

主要是用“记录”和“补偿”的方式。

1.本地事务维护业务变化和通知消息，一起落地，然后RPC到达broker，在broker成功落地后，RPC返回成功，本地消息可以删除。否则本地消息一直靠定时任务轮询不断重发，这样就保证了消息可靠落地broker。

2.broker往consumer发送消息的过程类似，一直发送消息，直到consumer发送消费成功确认。

3.我们先不理会重复消息的问题，通过两次消息落地加补偿，下游是一定可以收到消息的。然后依赖状态机版本号等方式做判重，更新自己的业务，就实现了最终一致性。

4.如果出现消费方处理过慢消费不过来，要允许消费方主动ack error，并可以与broker约定下次投递的时间。

5.对于broker投递到consumer的消息，由于不确定丢失是在业务处理过程中还是消息发送丢失的情况下，有必要记录下投递的IP地址。决定重发之前询问这个IP，消息处理成功了吗？如果询问无果，再重发。

6.事务：本地事务，本地落地，补偿发送。本地事务做的，是业务落地和消息落地的事务，而不是业务落地和RPC成功的事务。消息只要成功落地，很大程度上就没有丢失的风险。

消息的收发处理支持事务，例如：在任务中心场景中，一次处理可能涉及多个消息的接收、处理，这应该处于同一个事务范围内，如果一个消息处理失败，事务回滚，消息重新回到队列中。

消息的持久化，对于一些关键的核心业务来说是非常重要的，启用消息持久化后，消息队列宕机重启后，消息可以从持久化存储恢复，消息不丢失，可以继续消费处理。

软件开发中的Kafka和数据库的关系是什么呢？

Rebalance 本质上是一种协议，规定了一个 Consumer Group 下的所有consumer如何达成一致，来分配 Topic 的每个分区。

那么到底什么是数据库呢？或者说什么特性使得一个系统可以被称为数据库？经典的教科书是这么说的：数据库是提供 ACID 特性的，我们依次讨论下ACID。

1、持久性(durability)

我们先从最容易的持久性开始说起，因为持久性最容易理解。在80年代持久性指的是把数据写入到磁带中，这是一种很古老的存储设备，现在应该已经绝迹了。目前实现持久性更常见的做法是将数据写入到物理磁盘上，而这也只能实现单机的持久性。当演进到分布式系统时代后，持久性指的是将数据通过备份机制拷贝到多台机器的磁盘上。很多数据库厂商都有自己的分布式系统解决方案，如GreenPlum和Oracle RAC。它们都提供了这种多机备份的持久性。和它们类似，Apache Kafka天然也是支持这种持久性的，它提供的副本机制在实现原理上几乎和数据库厂商的方案是一样的。

2、原子性(atomicity)

数据库中的原子性和多线程领域内的原子性不是一回事。我们知道在Ja中有AtomicInteger这样的类能够提供线程安全的整数作服务，这里的atomicity关心的是在多个线程并发的情况下如何保证正确性的问题。而在数据库领域，原子性关心的是如何应对错误或异常情况，特别是对于事务的处理。如果服务发生故障，之前提交的事务要保证已经持久化，而当前运行的事务要终止(abort)，它执行的所有作都要回滚，最终的状态就好像该事务从未运行过那样处理消息需要是幂等的，消息的生产方和接收方都需要做到幂等性；发送放需要添加一个定时器来遍历重推未处理的消息，避免消息丢失，造成的事务执行断裂。。举个实际的例子，

第三个方法是采用基于日志结构的消息队列来实现，比如使用Kafka来做，如下图所示：

在这个架构中app仅仅是向Kafka写入消息，而下面的数据库、cache和index作为的consumer消费这个日志——Kafka分区的顺序性保证了app端更新作的顺序性。如果某个consumer消费速度慢于其他consumer也没关系，毕竟消息依然在Kafka中保存着。总而言之，有了Kafka所有的异质系统都能以相同的顺序应用app端的更新作，

3、隔离性(什么是rebalance？isolation)

在传统的关系型数据库中最强的隔离级别通常是指serializability，国内一般翻译成可串行化或串行化。表达的思想就是连接数据库的每个客户端在执行各自的事务时数据库会给它们一个假象：仿佛每个客户端的事务都顺序执行的，即执行完一个事务之后再开始执行下一个事务。其实数据库端同时会处理多个事务，但serializability保证了它们就像单独执行一样。举个例子，在一个系统中，每个新用户都需要注册一个的用户名。一个简单的app实现逻辑大概是这样的：

4、一致性(consistency)

说说一致性。按照Kelppmann大神的原话，这是一个很奇怪的属性：在所有ACID特性中，其他三项特性的确属于数据库层面需要实现或保证的，但只有一致性是由用户来保证的。严格来说，它不属于数据库的特性，而应该属于使用数据库的一种方式。坦率说次听到这句话时我本人还是有点震惊的，因为从没有往这个方面考虑过，但仔细想想还真是这么回事。比如刚才的注册用户名的例子中我们要求每个用户名是的。这种一致性约束是由我们用户做出的，而不是数据库本身。数据库本身并不关心或并不知道用户名是否应该是的。针对Kafka而言，这种一致性又意味着什么呢？Kelppmann没有具体展开，

希望能帮到你，谢谢！

大数据培训课题有哪些

Kafka不基于内存，而是硬盘存储，因此消息堆积能力更强

现在的大数据开发技术让大数据成为了2017年移动互联网追逐的热点，想要自学的话也是可以的，但是你找到不错的教程，不然怕越学越乱。

南京 kafka 集群有 200+ kafka topic 数据需要镜像同步到重庆集群，源 kafka 现状如下：

大数据培训内容课程:

基础阶段：Linux、Docker、KVM、MySQL基础、Oracle基础、MongoDB、redis。

hadoop mapreduce hdfs yarn：hadoop：Hadoop 概念、版本、历史，HDFS工作原理，YARN介绍及组件介绍。

大数据存储阶段：hbase、hive、sqoop。

大数据架构设计阶段：Flume分布式、Zookeeper、Kafka。

大数据实时计算阶段：Mahout、Spark、storm。

大数据数据采集阶段：Python、Scala。

大数据商业实战阶段：实企业大数据处理业务场景，分析需求、解决方案实施，综合技术实战应用。

学习大数据不是一朝一夕的事情，想要学好大数据可以看口扣丁学堂的视频，希望对你有帮助。

大数据培训的话分开发方向和运维方向，主要包括前端、ja、数据库、大数据自身的一些课程

老男孩教育大数据培训内容：Ja、Linux、Hadoop、Hive、Avro与Protobuf、ZooKeeper、HBase、Phoenix、Redis、Flume、SSM、Kafka、Scala、Spark、azkaban、Python与大数据分析等，懂行的都知道其中的含金量！

阶段

Ja语言基础阶段

第学习内容：HDFS分布式文件系统二阶段

第三阶段

分布式计算框架

第四阶段

大数据实战项目

第五阶段

大数据分析

大数据培训内容

kafka系列之(3)——Coordinator与offset管理和Consumer Rebalance

学习目标：JaWeb后端开发、SSM框架

consumer group是kafka提供的可扩展且具有容错性的消费者机制。组内可以有多个消费者或消费者实例(consumer instance)，它们共享一个公共的ID，即group ID。组内的所有消费者协调在一起来消费主题(subscribed topics)的所有分区(partition)。

consumer group下可以有一个或多个consumer instance，consumer instance可以是一个进程，也可以是一个线程

group.id是一个字符串，标识一个consumer group

consumer group下的topic下的每个分区只能分配给某个group下的一个consumer(当然该分区还可以被分配给其他group)

Coordinator一般指的是运行在broker上的group Coordinator，用于管理Consumer Group中各个成员，每个Kafka都有一个GroupCoordinator实例，管理多个消费者组，主要用于offset位移管理和Consumer Rebalance。

对于每个Cons对于kafka来说，Producer生产的数据存到broker，这个过程读取到socket buffer的网络数据，其实可以直接在OS内核缓冲区，完成落盘。并没有必要将socket buffer的网络数据，读取到应用进程缓冲区；在这里应用进程缓冲区其实就是broker，broker收到生产者的数据，就是为了持久化。umer Group，Coordinator会存储以下信息：

consumer group如何确定自己的coordinator是谁呢？ 简单来说分为两步：

消费者在消费的过程中需要记录自己消费了多少数据，即消费位置信息。在Kafka中这个位置信息有个专门的术语：位移(offset)。

(1)、很多消息引擎都把这部分信息保存在端(broker端)。这样做的好处当然是实现简单，但会有三个主要的问题：

1. broker从此变成有状态的，会影响伸缩性；

2. 需要引入应答机制(acknowledgement)来确认消费成功。

3. 由于要保存很多consumer的offset信息，必然引入复杂的数据结构，造成资源浪费。

而Kafka选择了不producer同的方式：每个consumer group管理自己的位移信息，那么只需要简单的一个整数表示位置就够了；同时可以引入checkpoint机制定期持久化，简化了应答机制的实现。

(2)、Kafka默认是定期帮你自动提交位移的(enable.automit = true)，你当然可以选择手动提交位移实现自己控制。

(3)、另外kafka会定期把group消费情况保存起来，做成一个offset map，如下图所示：

上图中表明了test-group这个组当前的消费情况。

老版本的位移是提交到zookeeper中的，目录结构是：/consumers//offsets//

，但是zookeeper其实并不适合进行大批量的读写作，尤其是写作。

__consumers_offsets topic配置了compact策略，使得它总是能够保存的位移信息，既控制了该topic总体的日志容量，也能实现保存offset的目的。compact的具体原理请参见： Log Compaction

至于每个group保存到__consumers_offsets的哪个分区，如何查看的问题请参见这篇文章： Kafka 如何读取offset topic内容 (__consumer_offsets)

offset提交消息会根据消费组的key(消费组名称)进行分区. 对于一个给定的消费组,它的所有消息都会发送到的broker(即Coordinator)

Coordinator上负责管理offset的组件是 Offset mar 。负责存储,抓取,和维护消费者的offsets. 每个broker都有一个offset mar实例. 有两种具体的实现:

ZookeeperOffsetMar: 调用zookeeper来存储和接收offset（老版本的位移管理）。

DefaultOffsetMar: 提供消费者offsets内置的offset管理。

通过在config/server.properties中的offset.storage参数选择。

DefaultOffsetMar

除了将offset作为logs保存到磁盘上,DefaultOffsetMar维护了一张能快速服务于offset抓取请求的 consumer offsets表 。这个表作为缓存，包含的含仅仅是”offsets topic”的partitions中属于leader partition对应的条目(存储的是offset)。

对于DefaultOffsetMar还有两个其他属性: “和””,默认值都是1。这两个属性会用来自动地创建”offsets topic”。

offset mar接口的概要：

rebalance本质上是一种协议，规定了一个consumer group下的所有consumer如何达成一致来分配topic的每个分区。比如某个group下有20个consumer，它了一个具有100个分区的topic。正常情况下，Kafka平均会为每个consumer分配5个分区。这个分配的过程就叫rebalance。Kafka新版本consumer默认提供了两种分配策略：range和round-robin。

rebalance的触发条件有三种：

组成员发生变更(新consumer加入组、已有consumer主动离开组或已有consumer崩溃了——这两者的区别后面会谈到)

主题数发生变更——这当然是可能的，如果你使用了正则表达式的方式进行，那么新建匹配正则表达式的topic就会触发rebalance

主题的分区数发生变更

refer

Kafka 使用 MirrorMaker 跨机房数据同步实践

根据上图，可以想到几个解决的思路：

使用 kafka rormaker 可以满足此需求，rormaker 是 kafka 提供的工具: $KAFAK_HOME/bin/kafka-ror-maker.sh，在目标 kafka 集群创建好同名 topic，根据使用说明，配置 consumer procuder 配置，topic 信息等，就可以启动 ror 了。

2、Kafka工作流程基础总结：1）broker：broker代表kafka的节点，Broker是分布式部署并且相互之间相互的，启动的时候向zookeeper注册，在Zookeeper上会有一个专门用来进行Broker列表记录的节点：/brokers/ids。

ror-maker 的原理大概是启动 consumer 消费南京的 topic message，发送到重庆的 kafka 集群。数据流向：南京 kafka -> rormaker -> 重庆 kafka ，其中 rormaker 部署在重庆集群。

首先明确说明Kafka不是数据库，它没有schema，也没有表，更没有索引。

需要 ror 的 topic 可以使用 ja-style 正则表达式，两个 topic A ，B 可以写成 --whiist 'A|B' ，如果要 ror 所有的 topic 可以使用 --whiist ''

对方反馈，集群内，单线程消费大 topic 速度是够的，能达到 6w+ message/sec，试图举证单分区没问题。其中的异在于 kafka rormaker 是走了公网传输，先消费再 push 到目标 kafka 集群。为了验证是否是单 partition 的问题，做了如下测试：

测试结果如下，也验证了 kafka rormaker 跨集群环境下，多 parititon 的必要性

单分区优化前：

单分区优化后峰值：

（kafka topic parititon 为 1） = （数据只在一个 broker 上读写） = （消费端只能单线程消费），增加 parititon，数据可以水平扩展，topic 数据落在均衡的落在不同的 broker 上，生产和消费都是多对多，并行的关系，性能肯定优于单 partition。多对多的读写性能肯定优于单点的点对点读写。

这里有一份 kafka 性能测试报告 ，很明显的看出，多 partition 在性能上的优势，不管是 produer 写，还是消费者消费，性能都是成倍增长。

当然由此也可以看出 kafka 的性能还是很强悍的，万兆网卡的集群内，即使是单 partition 平均写入速度可达 10w records/sec。单线程 consumer 消费速度可达 34w records/sec。也解释了对方说的单 partition 性能能满足的问题。

通过 parititon 数，romaker 速度基本能跟上源集群，但是 lag 依然存在，处于一个不太可接受的值，超过 2w，部分数据量不大的 topic lag 值也超过 1000。

原因在于 kafka rormaker 的参数 --offsetmit.interval.ms，消费 offset 提交间隔，默认使用率 60s，60s 对于生产速度快的 topic 来说很长。

研究了一下这个参数，kafka consumer 配置里面有 old 和 new 之分，其中有个参数 automit.interval.ms 的默认值有变更，旧的 60s 变为 5s，这样能侧面说明新的consumer 是觉得老的这个 60s 的默认配置不够合理，调整到 5s，一个比较合理的值。

3.3.1 Old Consumer Configs

3.3.2 New Consumer Configs

如下图，kafka rormaker 默认是使用 new consumer 见下图，但是 commit.interval.ms 配置还是沿用了 old consumer 的默认配置 60s。

Kafka数据丢失分析

2、磁盘文件通过网络发送（Broker 到 Consumer）

Kafka存在丢消息的问题，消息丢失会发生在Broker，Producer和Consumer三种。

在Kafka中，每个Topic会包含多个分区，默认情况下个分区只能被个消费组下的个消费者消费，这就产了分区分配的问题。

Broker丢失消息是由于Kafka本身的原因造成的，kafka为了得到更高的性能和吞吐量，将数据异步批量的存储在磁盘中。消息的刷盘过程，为了提高性能，减少刷盘次数，kafka采用了批量刷盘的做法。即，按照一定的消息量，和时间间隔进行刷盘。这种机制也是由于linux作系统决定的。将数据存储到linux作系统种，会先存储到页缓存（Page cache）中，按照时间或者其他条件进行刷盘（从page cache到file），或者通过fsync命令强制刷盘。数据在page cache中时，如果系统挂掉，数据会丢失。

Broker在linux上高速读写以及同步到Replica

上图简述了broker写数据以及同步的一个过程。broker写数据只写到PageCache中，而pageCache位于内存。这部分数据在断电后是会丢失的。pageCache的数据通过linux的flusher程序进行刷盘。刷盘触发条件有三：latest: 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据

Broker配置刷盘机制，是通过调用fsync函数接管了刷盘动作。从单个Broker来看，pageCache的数据会丢失。

Kafka没有提供同步刷盘的方式。同步刷盘在RocketMQ中有实现，实现原理是将异步刷盘的流程进行阻塞，等待响应，类似ajax的callback或者是ja的future。下面是一段rocketmq的源码。

也就是说，理论上，要完全让kafka保证单个broker不丢失消息是做不到的，只能通过调整刷盘机制的参数缓解该情况。比如，减少刷盘间隔，减少刷盘数据量大小。时间越短，性能越，可靠性越好（尽可能可靠）。这是一个选择题。

为了解决该问题，kafka通过producer和broker协同处理单个broker丢失参数的情况。一旦producer发现broker消息丢失，即可自动进行retry。除非retry次数超过阀值（可配置），消息才会丢失。此时需要生产者客户端手动处理该情况。那么producer是如何检测到数据丢失的呢？是通过ack机制，类似于的三次握手的方式。

上面第三点提到了ISR的列表的follower，需要配合另一个参数才能更好的保证ack的有效性。ISR是Broker维护的一个“可靠的follower列表”，in-sync Replica列表，broker的配置包含一个参数： min.insync.replicas 。该参数表示ISR中最少的副本数。如果不设置该值，ISR中的follower列表可能为空。此时相当于acks=1。

如上图中：

性能依次递减，可靠性依次升高。

Producer丢失消息，发生在生产者客户端。

为了提升效率，减少IO，producer在发送数据时可以将多个请求进行合并后发送。被合并的请求咋发送一线缓存在本地buffer中。缓存的方式和前文提到的刷盘类似，producer可以将请求打包成“块”或者按照时间间隔，将buffer中的数据发出。通过buffer我们可以将生产者改造为异步的方式，而这可以提升我们的发送效率。

但是，buffer中的数据就是危险的。在正常情况下，客户端的异步调用可以通过callback来处理消息发送失败或者超时的情况，但是，一旦producer被非法的停止了，那么buffer中的数据将丢失，broker将无法收到该部分数据。又或者，当Producer客户端内存不够时，如果采取的策略是丢弃消息（另一种策略是block阻塞），消息也会被丢失。抑或，消息产生（异步产生）过快，导致挂起线程过多，内存不足，导致程序崩溃，消息丢失。

Consumer消费消息有下面几个步骤：

Consumer的消费方式主要分为两种：

上面的示例是自动提交的例子。如果此时，insertIntoDB(record)发生异常，消息将会出现丢失。接下来是手动提交的例子：

将提交类型改为手动以后，可以保证消息“至少被消费一次”(at least once)。但此时可能出现重复消费的情况，重复消费不属于本篇讨论范围。

上面两个例子，是直接使用Consumer的High ll API，客户端对于offset等控制是透明的。也可以采用Low ll API的方式，手动控制offset，也可以保证消息不丢，不过会更加复杂。

RabbitMQ和Kafka对比，总结了以下几个点

学习目标：Ja基础、Ja面向对象、Ja高级、数据库与JDBC

前言

开源社区有好多的队列中间件，比如RabbitMQ和Kafka，每个队列都貌似有其特性，在进行工程选择时，往往眼花缭乱，不知1、一般是先会创建一个主题，比如说TopicA，有三个分区，有两个副本(leader+follower总共2个)，同一个分区的两个副本肯定不在一个。所措。对于RabbitMQ和Kafka，到底应该选哪个？

RabbitMQ架构

概念

RabbitMQ是一个分布式系统

broker：每个节点运行的服务程序，功能为维护该节点的队列的增删以及转发队列作请求。

queue：每个队列都分为一个主队列和若干个镜像队列。

ror queue：镜像队列，作为 queue的备份。在 queue所在节点挂掉之后，系统把ror queue提升为 queue，负责处理客户端队列作请求。注意，ror queue只做镜像，设计目的不是为了承担客户端读写压力。

如上图所示，集群中有两个节点，每个节点上有一个broker，每个broker负责本机上队列的维护，并且borker之间可以互相通信。集群中有两个队列A和B，每个队列都分为 queue和ror queue（备份）。那么队列上的生产消费怎么实现的呢？

队列消费

如上图有两个consumer消费队列A，这两个consumer连在了集群的不同机器上。RabbitMQ集群中的任何一个节点都拥有集群上所有队列的元信息，所以连接到集群中的任何一个节点都可以，主要区别在于有的consumer连在 queue所在节点，有的连在非 queue节点上。

因为ror queue要和 queue保持一致，故需要同步机制，正因为一致性的限制，导致所有的读写作都必须都作在 queue上（想想，为啥读也要从 queue中读？和数据库读写分离是不一样的。），然后由节点同步作到ror queue所在的节点。即使consumer连接到了非 queue节点，该consumer的作也会被路由到 queue所在的节点上，这样才能进行消费。

原理和消费一样，如果连接到非 m队列生产aster queue 节点，则路由过去。

不足

由于 queue单节点，导致性能瓶颈，吞吐量受限。虽然为了提高性能，内部使用了Erlang这个语言实现，但是终究摆脱不了架构设计上的致命缺陷。

Kafka

说实话，Kafka我觉得就是看到了RabbitMQ这个缺陷才设计出的一个改进版，改进的点就是：把一个队列的单一变成多个，即一台机器扛不住qps，那么我就用多台机器扛qps，把一个队列的流量均匀分散在多台机器上不就可以了么？注意，多个之间的数据没有交集，即一条消息要么发送到这个 queue，要么发送到另外一个 queue。

这里面的每个 queue 在Kafka中叫做Partition，即一个分片。一个队列有多个主分片，每个主分片又有若干副分片做备份，同步机制类似于RabbitMQ。

如上图，我们省略了不同的queue，假设集群上只有一个queue（Kafka中叫Topic）。每个生产者随机把消息发送到主分片上，之后主分片再同步给副分片。

队列读取的时候虚拟出一个Group的概念，一个Topic内部的消息，只会路由到同Group内的一个consumer上，同一个Group中的consumer消费的消息是不一样的；Group之间共享一个Topic，看起来就是一个队列的多个拷贝。所以，为了达到多个Group共享一个Topic数据，Kafka并不会像RabbitMQ那样消息消费完毕立马删除，而是必须在后台配置保存日期，即只保存最近一段时间的消息，超过这个时间的消息就会从磁盘删除，这样就保证了在一个时间段内，Topic数据对所有Group可见（这个特性使得Kafka非常适合做一个公司的数据总线）。队列读同样是读主分片，并且为了优化性能，消费者与主分片有一一的对应关系，如果消费者数目大于分片数，则存在某些消费者得不到消息。

由此可见，Kafka是为了高吞吐量设计的，比如设置分片数为100，那么就有100台机器去扛一个Topic的流量，当然比RabbitMQ的单机性能好。

总结

本文只做了Kafka和RabbitMQ的对比，但是开源队列岂止这两个，ZeroMQ，RocketMQ，JMQ等等，时间有限也就没有细看，故不在本文比较范围之内。

所以，别再被这些五花八门的队列迷惑了，从架构上找出关键别，并结合自己的实际需求（比如本文就只单单从吞吐量一个需求来考察）轻轻松松搞定选型。总结如下：

吞吐量较低：Kafka和RabbitMQ都可以。

吞吐量高：Kafka。

下面哪个功能是kafka无法保证的

Kafka工作流程

3、流程描述：用户首先构建待发送的消息对象ProducerRecord，然后调用KafkaProducer#send方法进行发送。

4、Kafka的工作流程Kafka中消息是以Topic进行分类的，生产者生产消息，消费者消费消息，读取和消费的都是同一个Topic。

5、和其他的中间件一样，kafka每次发送数据都是向Leader分区发送数据，并顺序写入到磁盘，然后Leader分区会将数据同步到各个从分区Follower，即使主分区挂了，也不会影响服务的正常运行。

Kafka——分区partition

在之前的例子里(Kafka生产者——向Kafka写入数据)，ProducerRecord对象包含了目标主题、键和值。

步：将所有主题分区组成TopicAndPartition列表，然后对TopicAndPartition列表按照hashCode进行排序，按照轮询的方式发给每一个消费线程。

分区越多所需要的文件句柄也就越多，可以通过配置作系统的参数增加打开文件句柄数。

一句话，Kafka的Message存储采用了分区(partition)，分段(LogSegment)和稀疏索引这几个手段来达到了高效性。

kafka是一个分布式的、支持分区的（partition）、多副本的（replica），基于zookeeper协调1.它仅仅是生产消息流、消费消息流而已。从这个角度来说Kafka的确不像数据库，至少不像我们熟知的关系型数据库。的分布式消息系统。

消息队列(三)kafka的一致性和失败处理策略

高吞吐：Kafka拥有很高的吞吐量，即使是在单节点性能比较低下的商用集群中，也能保证单节点每秒10万条消息的传输。高容错：Kafka在设计上支持多分区、多副本的策略，拥有很强的容错性。

如果要保证一致性，需要生产者在失败后重试，不过重试又会导致消息重复的问题，一个解决方案是每个消息给一个的id，通过服务端的主动去重来避免重复消息的问题，不过这一机制目前Kafka还未实现。

这时rahbitMQ会立即将消息删除，这种情况下如果消费者出现异常而没能处理该消息(但是消息队列那边已经认为消息被消费了)，就会丢失该消息。至于解决方案，采用手动确认消息即可。

Kafka存储机制此时Producer端生产的消息会不断追加到log文件末尾，这样文件就会越来越大，为了防止log文件过大导致数据定位效率低下，那么Kafka采取了分片和索引机制。

Kafka是一个分布式消息队列，具有高性能、持久化、多副本备份、横向扩展能力。生产者往队列里写消息，消费者从队列里取消息进行业务逻辑。一般在架构设计中起到解耦、削峰、异步处理的作用。

kafka的原理是什么?

1、Kafka是一个消息系统，原本开发自LinkedIn，用作LinkedIn的活动流数据（ActivityStream）和运营数据处理管道（Pipeline）的基础。现在它已被多家公司作为多种类型的数据管道和消息系统使用。

2、Kafka的副本机制是多个服务端节点对其他节点的主题分区的日志进行。当集群中的某个节点出现故障，访问故障节点的请求会被转移到其他正常节点(这一过程通常叫Reblance)。

3、Kafka使用了全局的数字来指代每个Broker，不同的Broker必须使用不同的BrokerID进行注册，创建完节点后，每个Broker就会将自己的IP地址和端口信息记录到该节点中去。

4、kafka消息的有序性，是采用消息键保序策略来实现的。一个topic，一个partition(分割)，一个consumer，内部单线程消费，写N个内存queue，然后N个线程分别消费一个内存queue。

Kafka面试题

1、谈谈你对Kafka幂等性的理解？Producer的幂等性指的是当发送同一条消息时，数据在端只会被持久化一次，数据不丢不重，但是这里的幂等性是有条件的：Kafka是在0.11版本开始引入了事务支持。

2、给大家分享一些Linux面试题的笔记，从负载均衡、nginx、MySQL、redis、kafka、zabbix、k8s等方面拆解Linux知识点。用来对个人技术点进行查漏补缺。

3、大型公司，基础架构研发实力较强，用RocketMQ是很好的选择。如果是大数据领域的实时计算、日志采集等场景，用Kafka是业内标准的，没问题，社区活跃度很高，不会黄，何况几乎是全世界这个领域的事实性规范。

4、比如你写了擅长MySQL，Jquery，bootstrap，那么我们就会提问这些内容，当然都不会特别困难，只需要证明你确实知道，不是在吹嘘就行。

5、其包括远程服务框架中间件消费，例如阿里（Apache）的RPC框架Dubbo等；消息队列中间件，例如：阿里巴巴开源分布式中间件RocketMQ、高吞吐量消息发布和流处理服务Kafknone: topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常a等。

6、人人皆知kafka性能好，但真正了解原因的人就少了很多。说起来也是悲伤的故事，我的某次面试就凉在此题。那么从设计的角度看，kafka是如何实现高性能的呢？Kafka会把消息写入到硬盘，不会丢失数据。