kafka最全面试题汇总_kafka面试题

内容很长，先来个目录一览无余吧～

//================kafka其他================//
问题1：什么是Apache Kafka?
问题2：Kafka中有哪几个组件?
问题16：启动Kafka服务器的过程是什么？
问题27：解释多租户是什么？
问题35：解释术语“Log Anatomy”
问题36：Kafka中的数据日志是什么？
问题39：列出所有Apache Kafka业务
问题40：解释Apache Kafka用例？
问题50：Kafka提供的保证是什么？
问题69：kafka数据传输的事务定义有哪三种？
问题70：Kafka判断一个节点是否还活着有那两个条件？
问题71：讲一讲kafka的ack的三种机制
//================重要性与改进================//
问题46：Java在Apache Kafka中的重要性是什么？
问题41：Kafka的一些最显著的应用。
问题47：说明Kafka的一个最佳特征。
问题37：解释如何调整Kafka以获得最佳性能。
//================比较================//

问题61：为什么需要消息系统，mysql不能满足需求吗？
问题62：Kafka与传统MQ消息系统之间有三个关键区别?(持久化日志;分布式系统;实时流式处理)
问题58：消息队列的比较
问题8：为什么Kafka技术很重要/kafka的优点？(5个=高吞吐量+低延迟+容错+耐久性+可扩展性)
问题60：为什么要选择kafka作为消息队列？(5个=缓冲和削峰+解耦和扩展性+冗余+健壮性+异步通信)

问题86：Kafka速度快和高吞吐量的原因---顺序读写+零拷贝+分区+数据压缩+批量发送
问题32：比较RabbitMQ与Apache Kafka
问题33：比较传统队列系统与Apache Kafka
问题19：Kafka和Flume之间的主要区别是什么？
//================生产者|消费者|broker|zookeeper|partition|偏移|消息================//

问题31：解释生产者是什么？
问题17：在生产者中，何时发生QueueFullException？
问题63：如何获取topic主题的列表、生产者和消费者的命令行是什么？
问题75：producer是否直接将数据发送到broker的leader(主节点)？
问题79：Kafka创建Topic时如何将分区放置到不同的Broker中
问题85：kafaka生产数据时数据的分组策略
---------
问题10：什么是消费者或用户？
问题4：什么是消费者组？
问题64：consumer是推还是拉？拉
问题65：消费者故障，出现活锁问题如何解决？
问题66：如何控制消费的位置
问题67：讲讲kafka维护消费状态跟踪的方法
问题76：Kafa consumer是否可以消费指定分区消息？
问题82：Kafka的消费者如何消费数据
问题83：消费者负载均衡策略
问题84：数据有序
---------
问题59：kafka中的broker是干什么的?(消息的代理,是代理保存消息的中转站)
---------
问题5：ZooKeeper在Kafka中的作用是什么？(集群中的不同节点之间协调通信,周期性提交偏移量,leader检测,分布式同步)
问题6：没有ZooKeeper可以使用Kafka吗？

---------
问题81：partition的数据如何保存到硬盘
问题80：Kafka新建的分区会在哪个目录下创建
---------
问题3：解释偏移的作用。
---------
问题23：解释Kafka可以接收的消息最大为多少？
问题24：传统的消息传递方法有哪些类型？
问题77：Kafka存储在硬盘上的消息格式是什么？
问题78：Kafka高效文件存储设计特点
//================消息的保证================//

问题73：kafka的高可用机制是什么？
问题51：消息队列怎么保证高可用？(leader和follower)
问题52：怎么保证消息可靠性传输（如何处理消息丢失问题）？===>4个参数：[partition至少2个副本,replication.factor>1],[至少1个follower,min.insync.replicas>1],[写入所有replication副本后才认为写入成功,acks=all],[一旦写入失败就无限重试,retries=MAX]
问题72：kafka分布式（不是单机）的情况下，如何保证消息的顺序消费?
问题53：如何保证消息的顺序性？(partition中的数据一定是有顺序的;内存队列queue分发+多线程)
问题54：为什么在消息队列里面消费到了重复的数据？(消费者消费完数据向zk提交offset的时候,进程挂了,重启后就会产生重复)
问题55：MQ重复消费的时候如何保证系统的幂等性？(数据库的唯一键;Redis的set天然幂等;每条数据加全局唯一id)
问题74：kafka如何减少数据丢失？
问题56：消息队列满了怎么处理，有几百万条消息持续积压几个小时怎么解决？
问题57：如果让你写一个消息队列，你怎么设计架构？
//================集群|复制|副本|leader================//

问题68：讲一下主从同步
问题12：是什么确保了Kafka中服务器的负载平衡？
问题34：为什么要使用Apache Kafka集群？
问题22：在Kafka集群中保留期的目的是什么？
---------
问题14：为什么Kafka的复制至关重要？
问题45：什么是复制工具及其类型？
问题48：解释术语“主题复制因子”。
---------
问题13：副本和ISR扮演什么角色？
问题15：如果副本长时间不在ISR中，这意味着什么？
问题25：ISR在Kafka环境中代表什么？
问题26：什么是Kafka中的地域复制？
---------
问题11：解释领导者和追随者的概念。
//================API================//
问题9：Kafka的主要API有哪些？
问题18：解释Kafka Producer API的作用。
问题28：消费者API的作用是什么？
问题29：解释流API的作用？
问题30：连接器API的作用是什么？
//================流================//
问题20：Apache Kafka是分布式流处理平台吗？如果是，你能用它做什么？
问题21：你能用Kafka做什么？
问题42：Kafka流的特点。
问题43：Kafka的流处理是什么意思？
问题49：解释一些Kafka流实时用例。
//=================================//

目录

问题1：什么是Apache Kafka?

问题2：Kafka中有哪几个组件?

问题3：解释偏移的作用。

问题4：什么是消费者组？

问题6：没有ZooKeeper可以使用Kafka吗？

问题8：为什么Kafka技术很重要？

问题9：Kafka的主要API有哪些？

问题10：什么是消费者或用户？

问题11：解释领导者和追随者的概念。

问题12：是什么确保了Kafka中服务器的负载平衡？

问题13：副本和ISR扮演什么角色？

问题14：为什么Kafka的复制至关重要？

问题15：如果副本长时间不在ISR中，这意味着什么？

问题16：启动Kafka服务器的过程是什么？

问题17：在生产者中，何时发生QueueFullException？

问题18：解释Kafka Producer API的作用。

问题19：Kafka和Flume之间的主要区别是什么？

问题20：Apache Kafka是分布式流处理平台吗？如果是，你能用它做什么？

问题21：你能用Kafka做什么？

问题22：在Kafka集群中保留期的目的是什么？

问题23：解释Kafka可以接收的消息最大为多少？

问题24：传统的消息传递方法有哪些类型？

问题25：ISR在Kafka环境中代表什么？

问题26：什么是Kafka中的地域复制？

问题27：解释多租户是什么？

问题28：消费者API的作用是什么？

问题29：解释流API的作用？

问题30：连接器API的作用是什么？

问题31：解释生产者是什么？

问题32：比较RabbitMQ与Apache Kafka

问题33：比较传统队列系统与Apache Kafka

问题34：为什么要使用Apache Kafka集群？

问题35：解释术语“Log Anatomy”

问题36：Kafka中的数据日志是什么？

问题37：解释如何调整Kafka以获得最佳性能。

问题38：Apache Kafka的缺陷

问题39：列出所有Apache Kafka业务

问题40：解释Apache Kafka用例？

问题41：Kafka的一些最显著的应用。

问题42：Kafka流的特点。

问题43：Kafka的流处理是什么意思？

问题44：系统工具有哪些类型？

问题45：什么是复制工具及其类型？

问题46：Java在Apache Kafka中的重要性是什么？

问题47：说明Kafka的一个最佳特征。

问题48：解释术语“主题复制因子”。

问题49：解释一些Kafka流实时用例。

问题50：Kafka提供的保证是什么？

问题51: 消息队列怎么保证高可用？

问题52: 怎么保证消息可靠性传输(如何处理消息丢失问题)？

问题53: 如何保证消息的顺序性？

问题54: 为什么在消息队列里面消费到了重复的数据？

问题55: MQ重复消费的时候如何保证系统的幂等性？

问题56: 消息队列满了怎么处理，有几百万条消息持续积压几个小时怎么解决？

问题57:如果让你写一个消息队列，你怎么设计架构？

问题58：消息队列的比较

问题60：为什么要选择kafka作为消息队列？

问题61：为什么需要消息系统，mysql不能满足需求吗？

问题62：Kafka与传统MQ消息系统之间有三个关键区别?(持久化日志;分布式系统;实时流式处理)

问题63：如何获取topic主题的列表、生产者和消费者的命令行是什么？

问题64：consumer是推还是拉？拉

问题65：消费者故障，出现活锁问题如何解决？

问题66：如何控制消费的位置

问题67：讲讲kafka维护消费状态跟踪的方法

问题68：讲一下主从同步

问题69：kafka数据传输的事务定义有哪三种？

问题70：Kafka判断一个节点是否还活着有那两个条件？

问题71：讲一讲kafka的ack的三种机制

问题72：kafka分布式（不是单机）的情况下，如何保证消息的顺序消费?

问题73：kafka的高可用机制是什么？

问题74：kafka如何减少数据丢失？

问题75：producer是否直接将数据发送到broker的leader(主节点)？

问题76：Kafa consumer是否可以消费指定分区消息？

问题77：Kafka存储在硬盘上的消息格式是什么？

问题78：Kafka高效文件存储设计特点

问题79：Kafka创建Topic时如何将分区放置到不同的Broker中

问题80：Kafka新建的分区会在哪个目录下创建

问题81：partition的数据如何保存到硬盘

问题82：Kafka的消费者如何消费数据

问题83：消费者负载均衡策略

问题84：数据有序

问题85：kafaka生产数据时数据的分组策略

问题86：Kafka速度快和高吞吐量的原因---顺序读写+零拷贝+分区+数据压缩+批量发送

---

问题1：什么是Apache Kafka?

答：Apache Kafka是一个发布 - 订阅开源消息代理应用程序。这个消息传递应用程序是用“scala”编码的。基本上，这个项目是由Apache软件启动的。Kafka的设计模式主要基于事务日志设计。

问题2：Kafka中有哪几个组件?

答：Kafka最重要的元素是：

• 主题：Kafka主题是一堆或一组消息。
• 生产者：在Kafka，生产者发布通信以及向Kafka主题发布消息。
• 消费者：Kafka消费者订阅了一个主题，并且还从主题中读取和处理消息。
• 经纪人：在管理主题中的消息存储时，我们使用Kafka Brokers。

问题3：解释偏移的作用。

答：给分区中的消息提供了一个顺序ID号，我们称之为偏移量。因此，为了唯一地识别分区中的每条消息，我们使用这些偏移量。

问题4：什么是消费者组？

答：消费者组的概念是Apache Kafka独有的。基本上，每个Kafka消费群体都由一个或多个共同消费一组订阅主题的消费者组成。

问题5：ZooKeeper在Kafka中的作用是什么？

答：Apache Kafka是一个使用Zookeeper构建的分布式系统。虽然，Zookeeper的主要作用是在集群中的不同节点之间建立协调。但是，如果任何节点失败，我们还使用Zookeeper从先前提交的偏移量中恢复，因为它做周期性提交偏移量工作。除此之外，它还执行其他活动，如: leader 检测、分布式同步、配置管理、识别新节点何时离开或连接、集群、节点实时状态等等。

除此之外，它还执行其他活动，如: leader 检测、分布式同步、配置管理、识别新节点何时离开或连接、集群、节点实时状态等等。

问题6：没有ZooKeeper可以使用Kafka吗？

答：绕过Zookeeper并直接连接到Kafka服务器是不可能的，所以答案是否定的。如果以某种方式，使ZooKeeper关闭，则无法为任何客户端请求提供服务。

问题8：为什么Kafka技术很重要？

答：Kafka有一些优点，因此使用起来很重要：

• 高吞吐量：我们在Kafka中不需要任何大型硬件，因为它能够处理高速和大容量数据。此外，它还可以支持每秒数千条消息的消息吞吐量。

• 低延迟：Kafka可以轻松处理这些消息，具有毫秒级的极低延迟，这是大多数新用例所要求的。

• 容错：Kafka能够抵抗集群中的节点/机器故障。

• 耐久性：由于Kafka支持消息复制，因此消息永远不会丢失。这是耐久性背后的原因之一。

• 可扩展性：卡夫卡可以扩展，而不需要通过添加额外的节点而在运行中造成任何停机。

问题9：Kafka的主要API有哪些？

答：Apache Kafka有4个主要API:

   * 生产者API
   * 消费者API
   * 流 API
   * 连接器API

• 1
• 2
• 3
• 4

问题10：什么是消费者或用户？

答：Kafka消费者订阅一个主题，并读取和处理来自该主题的消息。此外，有了消费者组的名字，消费者就给自己贴上了标签。换句话说，在每个订阅使用者组中，发布到主题的每个记录都传递到一个使用者实例。确保使用者实例可能位于单独的进程或单独的计算机上。

Apache Kafka对于新手的面试问题：1,2,4,7,8,9,10

Apache Kafka对于有经验的人的面试问题：3,5,6

3.比较棘手的Kafka面试问题和答案

问题11：解释领导者和追随者的概念。

答：在Kafka的每个分区中，都有一个服务器充当领导者，0到多个服务器充当追随者的角色。

问题12：是什么确保了Kafka中服务器的负载平衡？

答：由于领导者的主要角色是执行分区的所有读写请求的任务，而追随者被动地复制领导者。因此，在领导者失败时，其中一个追随者接管了领导者的角色。基本上，整个过程可确保服务器的负载平衡。

问题13：副本和ISR扮演什么角色？

答：基本上，复制日志的节点列表就是副本。特别是对于特定的分区。但是，无论他们是否扮演领导者的角色，他们都是如此。
此外，ISR指的是同步副本。在定义ISR时，它是一组与领导者同步的消息副本。

问题14：为什么Kafka的复制至关重要？

答：由于复制，我们可以确保发布的消息不会丢失，并且可以在发生任何机器错误、程序错误或频繁的软件升级时使用。

问题15：如果副本长时间不在ISR中，这意味着什么？

答：简单地说，这意味着跟随者不能像领导者收集数据那样快速地获取数据。

问题16：启动Kafka服务器的过程是什么？

答：初始化ZooKeeper服务器是非常重要的一步，因为Kafka使用ZooKeeper，所以启动Kafka服务器的过程是：

要启动ZooKeeper服务器：>bin/zooKeeper-server-start.sh config/zooKeeper.properties

接下来，启动Kafka服务器：>bin/kafka-server-start.sh config/server.properties

问题17：在生产者中，何时发生QueueFullException？

答：每当Kafka生产者试图以代理的身份在当时无法处理的速度发送消息时，通常都会发生QueueFullException。但是，为了协作处理增加的负载，用户需要添加足够的代理，因为生产者不会阻止。

问题18：解释Kafka Producer API的作用。

答：允许应用程序将记录流发布到一个或多个Kafka主题的API就是我们所说的Producer API。

问题19：Kafka和Flume之间的主要区别是什么？

答：Kafka和Flume之间的主要区别是：

• 工具类型

  Apache Kafka——Kafka是面向多个生产商和消费者的通用工具。

  Apache Flume——Flume被认为是特定应用程序的专用工具。

• 复制功能

  Apache Kafka——Kafka可以复制事件。

  Apache Flume——Flume不复制事件。

问题20：Apache Kafka是分布式流处理平台吗？如果是，你能用它做什么？

答：毫无疑问，Kafka是一个流处理平台。它可以帮助：

1.轻松推送记录

2.可以存储大量记录，而不会出现任何存储问题

3.它还可以在记录进入时对其进行处理。

Apache Kafka对于新手的面试问题：11,13,14,16,17,18,19

Apache Kafka对于有经验的人的面试问题：12,15,20

4.高级Kafka面试问题

问题21：你能用Kafka做什么？

答：它可以以多种方式执行，例如：

• 为了在两个系统之间传输数据，我们可以用它构建实时的数据流管道。

• 另外，我们可以用Kafka构建一个实时流处理平台，它可以对数据快速做出反应。

问题22：在Kafka集群中保留期的目的是什么？

答：保留期限保留了Kafka群集中的所有已发布记录。它不会检查它们是否已被消耗。此外，可以通过使用保留期的配置设置来丢弃记录。而且，它可以释放一些空间。

问题23：解释Kafka可以接收的消息最大为多少？

答：Kafka可以接收的最大消息大小约为1000000字节。

问题24：传统的消息传递方法有哪些类型？

答：基本上，传统的消息传递方法有两种，如：

• 排队：这是一种消费者池可以从服务器读取消息并且每条消息转到其中一个消息的方法。

• 发布-订阅：在发布-订阅中，消息被广播给所有消费者。

问题25：ISR在Kafka环境中代表什么？

答：ISR指的是同步副本。这些通常被分类为一组消息副本，它们被同步为领导者。

问题26：什么是Kafka中的地域复制？

答：对于我们的集群，Kafka MirrorMaker提供地理复制。基本上，消息是通过MirrorMaker跨多个数据中心或云区域复制的。因此，它可以在主动/被动场景中用于备份和恢复；也可以将数据放在离用户更近的位置，或者支持数据位置要求。

问题27：解释多租户是什么？

答：我们可以轻松地将Kafka部署为多租户解决方案。但是，通过配置主题可以生成或使用数据，可以启用多租户。此外，它还为配额提供操作支持。

问题28：消费者API的作用是什么？

答：允许应用程序订阅一个或多个主题并处理生成给它们的记录流的API，我们称之为消费者API。

问题29：解释流API的作用？

答：一种允许应用程序充当流处理器的API，它还使用一个或多个主题的输入流，并生成一个输出流到一个或多个输出主题，此外，有效地将输入流转换为输出流，我们称之为流API。

问题30：连接器API的作用是什么？

答：一个允许运行和构建可重用的生产者或消费者的API，将Kafka主题连接到现有的应用程序或数据系统，我们称之为连接器API。

---

Apache Kafka对于新手的面试问题：21, 23, 25, 26, 27, 28, 29, 30

Apache Kafka对于有经验的人的面试问题：24, 22

---

问题31：解释生产者是什么？

答：生产者的主要作用是将数据发布到他们选择的主题上。基本上，它的职责是选择要分配给主题内分区的记录。

问题32：比较RabbitMQ与Apache Kafka

答：Apache Kafka的另一个选择是RabbitMQ。那么，让我们比较两者：

• 功能：Apache Kafka– Kafka是分布式的、持久的和高度可用的，这里共享和复制数据；RabbitMQ中没有此类功能
• 性能速度：Apache Kafka–达到每秒100000条消息。RabbitMQ–每秒20000条消息。

问题33：比较传统队列系统与Apache Kafka

答：让我们比较一下传统队列系统与Apache Kafka的功能：

• 消息保留

传统的队列系统 - 它通常从队列末尾处理完成后删除消息。
Apache Kafka中，消息即使在处理后仍然存在。这意味着Kafka中的消息不会因消费者收到消息而被删除。

• 1
• 2

*基于逻辑的处理

传统队列系统不允许基于类似消息或事件处理逻辑。
 
Apache Kafka允许基于类似消息或事件处理逻辑。

• 1
• 2
• 3

问题34：为什么要使用Apache Kafka集群？

答：为了克服收集大量数据和分析收集数据的挑战，我们需要一个消息队列系统。因此Apache Kafka应运而生。其好处是：

• 只需存储/发送事件以进行实时处理，就可以跟踪Web活动。

• 通过这一点，我们可以发出警报并报告操作指标。

• 此外，我们可以将数据转换为标准格式。

• 此外，它允许对主题的流数据进行连续处理。

由于它的广泛使用，它秒杀了竞品，如ActiveMQ，RabbitMQ等。

问题35：解释术语“Log Anatomy”

答：我们将日志视为分区。基本上，数据源将消息写入日志。其优点之一是，在任何时候，都有一个或多个消费者从他们选择的日志中读取数据。下面的图表显示，数据源正在写入一个日志，而用户正在以不同的偏移量读取该日志。

问题36：Kafka中的数据日志是什么？

答：我们知道，在Kafka中，消息会保留相当长的时间。此外，消费者还可以根据自己的方便进行阅读。尽管如此，有一种可能的情况是，如果将Kafka配置为将消息保留24小时，并且消费者可能停机超过24小时，则消费者可能会丢失这些消息。但是，我们仍然可以从上次已知的偏移中读取这些消息，但仅限于消费者的部分停机时间仅为60分钟的情况。此外，关于消费者从一个话题中读到什么，Kafka不会保持状态。

问题37：解释如何调整Kafka以获得最佳性能。

答：因此，调优Apache Kafka的方法是调优它的几个组件：

1. 调整Kafka生产者

2. Kafka代理调优

3. 调整Kafka消费者

问题38：Apache Kafka的缺陷

答：Kafka的局限性是：

1. 没有完整的监控工具集
2. 消息调整的问题
3. 不支持通配符主题选择
4. 速度问题

问题39：列出所有Apache Kafka业务

答：Apache Kafka的业务包括：

1. 添加和删除Kafka主题

2. 如何修改Kafka主题

3. 如何关机

4. 在Kafka集群之间镜像数据

5. 找到消费者的位置

6. 扩展您的Kafka群集

7. 自动迁移数据

8. 退出服务器

9. 数据中心

问题40：解释Apache Kafka用例？

答：Apache Kafka有很多用例，例如：

• Kafka指标

  可以使用Kafka进行操作监测数据。此外，为了生成操作数据的集中提要，它涉及到从分布式应用程序聚合统计信息。

• Kafka日志聚合

     从组织中的多个服务收集日志。
  

  • 1

• 流处理

  在流处理过程中，Kafka的强耐久性非常有用。

Apache Kafka对于新手的面试问题：31, 32, 33, 34, 38, 39, 40

Apache Kafka对于有经验的人的面试问题：35, 36, 37

---

5.基于特征的Kafka面试问题

问题41：Kafka的一些最显著的应用。

答：Netflix，Mozilla，Oracle

问题42：Kafka流的特点。

答：Kafka流的一些最佳功能是

• Kafka Streams具有高度可扩展性和容错性。

• Kafka部署到容器，VM，裸机，云。

• 我们可以说，Kafka流对于小型，中型和大型用例同样可行。

• 此外，它完全与Kafka安全集成。

• 编写标准Java应用程序。

• 完全一次处理语义。

• 而且，不需要单独的处理集群。

问题43：Kafka的流处理是什么意思？

答：连续、实时、并发和以逐记录方式处理数据的类型，我们称之为Kafka流处理。

问题44：系统工具有哪些类型？

答：系统工具有三种类型：

1. Kafka迁移工具：它有助于将代理从一个版本迁移到另一个版本。

2. Mirror Maker：Mirror Maker工具有助于将一个Kafka集群的镜像提供给另一个。

3. 消费者检查:对于指定的主题集和消费者组，它显示主题，分区，所有者。

问题45：什么是复制工具及其类型？

答：为了增强持久性和更高的可用性，这里提供了复制工具。其类型为

• 创建主题工具

• 列表主题工具

• 添加分区工具

问题46：Java在Apache Kafka中的重要性是什么？

答：为了满足Kafka标准的高处理速率需求，我们可以使用java语言。此外，对于Kafka的消费者客户，Java也提供了良好的社区支持。所以，我们可以说在Java中实现Kafka是一个正确的选择。

问题47：说明Kafka的一个最佳特征。

答：Kafka的最佳特性是“各种各样的用例”。

这意味着Kafka能够管理各种各样的用例，这些用例对于数据湖来说非常常见。例如日志聚合、Web活动跟踪等。

问题48：解释术语“主题复制因子”。

答：在设计Kafka系统时，考虑主题复制是非常重要的。

问题49：解释一些Kafka流实时用例。

答：《纽约时报》：该公司使用它来实时存储和分发已发布的内容到各种应用程序和系统，使其可供读者使用。基本上，它使用Apache Kafka和Kafka流。

Zalando：作为ESB（企业服务总线）作为欧洲领先的在线时尚零售商，Zalando使用Kafka。

LINE：基本上，为了相互通信，LINE应用程序使用Apache Kafka作为其服务的中心数据中心。

问题50：Kafka提供的保证是什么？

答：他们是生产者向特定主题分区发送的消息的顺序相同。

此外，消费者实例按照它们存储在日志中的顺序查看记录。

此外，即使不丢失任何提交给日志的记录，我们也可以容忍最多N-1个服务器故障。

---

Apache Kafka对于新手的面试问题：41, 42, 43, 44, 45, 47, 49

Apache Kafka对于有经验的人的面试问题：46, 48

 

问题51: 消息队列怎么保证高可用？

答：  kafka：leader和follower;       (非分布式)RabbitMQ：镜像集群模式，每个节点上都有一个完整的queue的数据

问题52: 怎么保证消息可靠性传输(如何处理消息丢失问题)？

答：消费端保证数据：kafka的消费者关闭自动提交offset，改为手动提交offset

        kafka保证数据不丢：leader还没同步到follower时宕机了

设置4个参数：
1.给topic设置replication.factor参数，必须大于1，要求partition至少2个副本
2.在kafka服务端设置min.insync.replicas参数，必须大于1，要求leader至少感知有一个follower跟自己保持通信
3.生产者端设置acks=all：要求每条数据必须是写入所有replication副本后才认为写入成功
4.生产者端设置retries=MAX（一个很大的值），一旦写入失败就无限重试，卡在这里
 

问题53: 如何保证消息的顺序性？

答：kafka可保证写入一个partition中的数据一定是有顺序的，一个消费者消费一个partition，一定是有顺序的。一个消费者开启多线程处理就可能出现顺序问题，利用内存队列queue分发+多线程，即可保证顺序也可保证高吞吐量。

问题54: 为什么在消息队列里面消费到了重复的数据？

答：kafka消费者在消费完数据，正要向zk提交offset的时候，消费者进程挂了，已消费的数据offset没有被提交，下次重启就会产生重复消费。（因为消费者是定期向zk提交offset的，而不是消费一条数据提交一条）

问题55: MQ重复消费的时候如何保证系统的幂等性？

答：结合具体业务分析，基于数据库的唯一键来保证数据不会重复插入；若数据写入Redis中，保存为set格式，天然幂等；亦或给每条数据加一条全局唯一id，每次消费之前去Redis判断一下是否消费过了即可。

问题56: 消息队列满了怎么处理，有几百万条消息持续积压几个小时怎么解决？

答：系统故障，消费者挂了，积压了几百万的数据，现在系统恢复了，只能操作临时紧急扩容来消积数据：先修复consumer消费速度，然后新建一个topic，partition为原来的10倍，将积压的数据通过临时分发的consumer程序，轮询的写入新建的topic中，就有10倍数量的消息队列，接着临时征用10倍的机器来部署consumer，每一批消费一个消息队列的数据，这样相当于以正常10倍的速度消费积压的数据。

问题57:如果让你写一个消息队列，你怎么设计架构？

首先要支持可伸缩性（扩容）：设计一个分布式的系统，参照kafka，broker->topic->partition
其次要考虑mq的数据要落磁盘：保证数据不会丢失，磁盘顺序写入磁盘
继而要考虑mq的可用性：kafka的高可用保障机制，多副本->leader&follower->broker挂了重新选举leader对外服务
最后还有考虑mq的数据0丢失：参考问题52答案

问题58：消息队列的比较

activeMQ:吞吐量万级，但社区维护慢
RabbitMQ:吞吐量万级，社区好性能可以，有后台管理界面，但是erlang语言开发，源码不好解读（中小型公司推荐）
RocketMQ:10万级吞吐量，阿里开源，分布式扩展方便，java源码（大型公司推荐）
kafka:单机10万级吞吐量，大数据实时计算，日志采集，功能简单，易于扩展（大数据领域）

问题59：kafka中的broker 是干什么的?
Kafka以集群的方式运行，可以由一个或多个服务组成，每个服务叫做一个broker。broker 是消息的代理，Producers往Brokers里面的指定Topic中写消息，Consumers从Brokers里面拉取指定Topic的消息，然后进行业务处理，broker在中间起到一个代理保存消息的中转站。

问题60：为什么要选择kafka作为消息队列？

缓冲和削峰：上游数据时有突发流量，下游可能扛不住，或者下游没有足够多的机器来保证冗余，kafka在中间可以起到一个缓冲的作用，把消息暂存在kafka中，下游服务就可以按照自己的节奏进行慢慢处理。
解耦和扩展性：项目开始的时候，并不能确定具体需求。消息队列可以作为一个接口层，解耦重要的业务流程。只需要遵守约定，针对数据编程即可获取扩展能力。
冗余：可以采用一对多的方式，一个生产者发布消息，可以被多个订阅topic的服务消费到，供多个毫无关联的业务使用。
健壮性：消息队列可以堆积请求，所以消费端业务即使短时间死掉，也不会影响主要业务的正常进行。
异步通信：很多时候，用户不想也不需要立即处理消息。消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。

问题61：为什么需要消息系统，mysql不能满足需求吗？

（1）解耦：
允许你独立的扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束。
（2）冗余：
消息队列把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。许多消息队列所采用的”插入-获取-删除”范式中，在把一个消息从队列中删除之前，需要你的处理系统明确的指出该消息已经被处理完毕，从而确保你的数据被安全的保存直到你使用完毕。
（3）扩展性：
因为消息队列解耦了你的处理过程，所以增大消息入队和处理的频率是很容易的，只要另外增加处理过程即可。
（4）灵活性 & 峰值处理能力：
在访问量剧增的情况下，应用仍然需要继续发挥作用，但是这样的突发流量并不常见。如果为以能处理这类峰值访问为标准来投入资源随时待命无疑是巨大的浪费。使用消息队列能够使关键组件顶住突发的访问压力，而不会因为突发的超负荷的请求而完全崩溃。
（5）可恢复性：
系统的一部分组件失效时，不会影响到整个系统。消息队列降低了进程间的耦合度，所以即使一个处理消息的进程挂掉，加入队列中的消息仍然可以在系统恢复后被处理。
（6）顺序保证：
在大多使用场景下，数据处理的顺序都很重要。大部分消息队列本来就是排序的，并且能保证数据会按照特定的顺序来处理。（Kafka 保证一个 Partition 内的消息的有序性）
（7）缓冲：
有助于控制和优化数据流经过系统的速度，解决生产消息和消费消息的处理速度不一致的情况。
（8）异步通信：
很多时候，用户不想也不需要立即处理消息。消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。

问题62：Kafka与传统MQ消息系统之间有三个关键区别?(持久化日志;分布式系统;实时流式处理)

(1).Kafka 持久化日志，这些日志可以被重复读取和无限期保留
(2).Kafka 是一个分布式系统：它以集群的方式运行，可以灵活伸缩，在内部通过复制数据提升容错能力和高可用性
(3).Kafka 支持实时的流式处理

问题63：如何获取topic主题的列表、生产者和消费者的命令行是什么？

答：(1)topic的列表：bin/kafka-topics.sh --list --zookeeper localhost:2181
(2)生产者在主题上发布消息：bin/kafka-console-producer.sh --broker-list 192.168.43.49:9092 --topicHello-Kafka
注意这里的 IP 是 server.properties 中的 listeners 的配置。接下来每个新行就是输入一条新消息。
(3)消费者接受消息：bin/kafka-console-consumer.sh --zookeeper localhost:2181 --topicHello-Kafka --from-beginning

问题64：consumer是推还是拉？拉

答：Kafka 最初考虑的问题是，customer 应该从 brokes 拉取消息还是 brokers 将消息推送到 consumer，也就是 pull 还 push。在这方面，Kafka 遵循了一种大部分消息系统共同的传统的设计：producer 将消息推送到 broker，consumer 从broker 拉取消息。
一些消息系统比如 Scribe 和 Apache Flume 采用了 push 模式，将消息推送到下游的 consumer。这样做有好处也有坏处：由 broker 决定消息推送的速率，对于不同消费速率的 consumer 就不太好处理了。消息系统都致力于让 consumer 以最大的速率最快速的消费消息，但不幸的是，push 模式下，当 broker 推送的速率远大于 consumer 消费的速率时，consumer 恐怕就要崩溃了。最终 Kafka 还是选取了传统的 pull 模式。
Pull 模式的另外一个好处是 consumer 可以自主决定是否批量的从 broker 拉取数据 。Push 模式必须在不知道下游 consumer 消费能力和消费策略的情况下决定是立即推送每条消息还是缓存之后批量推送。如果为了避免 consumer 崩溃而采用较低的推送速率，将可能导致一次只推送较少的消息而造成浪费。Pull 模式下，consumer 就可以根据自己的消费能力去决定这些策略。
Pull 有个缺点是，如果 broker 没有可供消费的消息，将导致 consumer 不断在循环中轮询，直到新消息到 t 达。为了避免这点，Kafka 有个参数可以让 consumer阻塞知道新消息到达(当然也可以阻塞知道消息的数量达到某个特定的量这样就可以批量发送)。

问题65：消费者故障，出现活锁问题如何解决？

出现“活锁”的情况，是它持续的发送心跳，但是没有处理。为了预防消费者在这种情况下一直持有分区，我们使用 max.poll.interval.ms 活跃检测机制。 在此基础上，如果你调用的 poll 的频率大于最大间隔，则客户端将主动地离开组，以便其他消费者接管该分区。 发生这种情况时，你会看到 offset 提交失败（调用commitSync（）引发的 CommitFailedException）。这是一种安全机制，保障只有活动成员能够提交 offset。所以要留在组中，你必须持续调用 poll。
消费者提供两个配置设置来控制 poll 循环：
max.poll.interval.ms：增大 poll 的间隔，可以为消费者提供更多的时间去处理返回的消息（调用 poll(long)返回的消息，通常返回的消息都是一批）。缺点是此值越大将会延迟组重新平衡。
max.poll.records：此设置限制每次调用 poll 返回的消息数，这样可以更容易的预测每次 poll 间隔要处理的最大值。通过调整此值，可以减少 poll 间隔，减少重新平衡分组的
对于消息处理时间不可预测地的情况，这些选项是不够的。 处理这种情况的推荐方法是将消息处理移到另一个线程中，让消费者继续调用 poll。 但是必须注意确保已提交的 offset 不超过实际位置。另外，你必须禁用自动提交，并只有在线程完成处理后才为记录手动提交偏移量（取决于你）。 还要注意，你需要 pause 暂停分区，不会从 poll 接收到新消息，让线程处理完之前返回的消息（如果你的处理能力比拉取消息的慢，那创建新线程将导致你机器内存溢出

问题66：如何控制消费的位置

kafka 使用 seek(TopicPartition, long)指定新的消费位置。用于查找服务器保留的最早和最新的 offset 的特殊的方法也可用（seekToBeginning(Collection) 和seekToEnd(Collection)）

问题67：讲讲kafka维护消费状态跟踪的方法

大部分消息系统在 broker 端的维护消息被消费的记录：一个消息被分发到consumer 后 broker 就马上进行标记或者等待 customer 的通知后进行标记。这样也可以在消息在消费后立马就删除以减少空间占用。
但是这样会不会有什么问题呢？如果一条消息发送出去之后就立即被标记为消费过的，旦 consumer 处理消息时失败了（比如程序崩溃）消息就丢失了。为了解决这个问题，很多消息系统提供了另外一个个功能：当消息被发送出去之后仅仅被标记为已发送状态，当接到 consumer 已经消费成功的通知后才标记为已被消费的状态。这虽然解决了消息丢失的问题，但产生了新问题，首先如果 consumer处理消息成功了但是向 broker 发送响应时失败了，这条消息将被消费两次。第二个问题时，broker 必须维护每条消息的状态，并且每次都要先锁住消息然后更改状态然后释放锁。这样麻烦又来了，且不说要维护大量的状态数据，比如如果消息发送出去但没有收到消费成功的通知，这条消息将一直处于被锁定的状态，Kafka 采用了不同的策略。Topic 被分成了若干分区，每个分区在同一时间只被一个 consumer 消费。这意味着每个分区被消费的消息在日志中的位置仅仅是一个简单的整数：offset。这样就很容易标记每个分区消费状态就很容易了，仅仅需要一个整数而已。这样消费状态的跟踪就很简单了。
这带来了另外一个好处：consumer 可以把 offset 调成一个较老的值，去重新消费老的消息。这对传统的消息系统来说看起来有些不可思议，但确实是非常有用的，谁规定了一条消息只能被消费一次呢？

问题68：讲一下主从同步

问题69：kafka数据传输的事务定义有哪三种？

（1）最多一次: 消息不会被重复发送，最多被传输一次，但也有可能一次不传输
（2）最少一次: 消息不会被漏发送，最少被传输一次，但也有可能被重复传输.
（3）精确的一次（Exactly once）: 不会漏传输也不会重复传输,每个消息都传输被一次而且仅仅被传输一次，这是大家所期望的

问题70：Kafka判断一个节点是否还活着有那两个条件？

（1）节点必须可以维护和ZooKeeper的连接，Zookeeper通过心跳机制检查每个节点的连接
（2）如果节点是个follower,他必须能及时的同步leader的写操作，延时不能太久

问题71：讲一讲kafka的ack的三种机制

request.required.acks 有三个值 0 1 -1(all)
0:生产者不会等待 broker 的 ack，这个延迟最低但是存储的保证最弱当 server 挂掉的时候就会丢数据。
1：服务端会等待 ack 值 leader 副本确认接收到消息后发送 ack 但是如果 leader挂掉后他不确保是否复制完成新 leader 也会导致数据丢失。
-1(all)：服务端会等所有的 follower 的副本受到数据后才会受到 leader 发出的ack，这样数据不会丢失

问题72：kafka分布式（不是单机）的情况下，如何保证消息的顺序消费?

Kafka 分布式的单位是 partition，同一个 partition 用一个 write ahead log 组织，所以可以保证 FIFO 的顺序。不同 partition 之间不能保证顺序。但是绝大多数用户都可以通过 message key 来定义，因为同一个 key 的 message 可以保证只发送到同一个 partition。
Kafka 中发送 1 条消息的时候，可以指定(topic, partition, key) 3 个参数。partiton 和 key 是可选的。如果你指定了 partition，那就是所有消息发往同 1个 partition，就是有序的。并且在消费端，Kafka 保证，1 个 partition 只能被1 个 consumer 消费。或者你指定 key（ 比如 order id），具有同 1 个 key 的所有消息，会发往同 1 个 partition。

问题73：kafka的高可用机制是什么？

这个问题比较系统，回答出 kafka 的系统特点，leader 和 follower 的关系，消息读写的顺序即可。

问题74：kafka如何减少数据丢失？

Kafka到底会不会丢数据(data loss)? 通常不会，但有些情况下的确有可能会发生。下面的参数配置及Best practice列表可以较好地保证数据的持久性(当然是trade-off，牺牲了吞吐量)。
block.on.buffer.full = true
acks = all
retries = MAX_VALUE
max.in.flight.requests.per.connection = 1
使用KafkaProducer.send(record, callback)
callback逻辑中显式关闭producer：close(0)
unclean.leader.election.enable=false
replication.factor = 3
min.insync.replicas = 2
replication.factor > min.insync.replicas
enable.auto.commit=false
消息处理完成之后再提交位移

问题75：producer是否直接将数据发送到broker的leader(主节点)？

producer直接将数据发送到broker的leader(主节点)，不需要在多个节点进行分发，为了帮助producer做到这点，所有的Kafka节点都可以及时的告知:哪些节点是活动的，目标topic目标分区的leader在哪。这样producer就可以直接将消息发送到目的地了

问题76：Kafa consumer是否可以消费指定分区消息？

Kafa consumer消费消息时，向broker发出"fetch"请求去消费特定分区的消息，consumer指定消息在日志中的偏移量（offset），就可以消费从这个位置开始的消息，customer拥有了offset的控制权，可以向后回滚去重新消费之前的消息，这是很有意义的

问题77：Kafka存储在硬盘上的消息格式是什么？

消息由一个固定长度的头部和可变长度的字节数组组成。头部包含了一个版本号和CRC32校验码。
消息长度: 4 bytes (value: 1+4+n)
版本号: 1 byte
CRC校验码: 4 bytes
具体的消息: n bytes

问题78：Kafka高效文件存储设计特点

(1).Kafka把topic中一个parition大文件分成多个小文件段，通过多个小文件段，就容易定期清除或删除已经消费完文件，减少磁盘占用。
(2).通过索引信息可以快速定位message和确定response的最大大小。
(3).通过index元数据全部映射到memory，可以避免segment file的IO磁盘操作。
(4).通过索引文件稀疏存储，可以大幅降低index文件元数据占用空间大小。

问题79：Kafka创建Topic时如何将分区放置到不同的Broker中

副本因子不能大于 Broker 的个数；
第一个分区（编号为0）的第一个副本放置位置是随机从 brokerList 选择的；
其他分区的第一个副本放置位置相对于第0个分区依次往后移。也就是如果我们有5个 Broker，5个分区，假设第一个分区放在第四个 Broker 上，那么第二个分区将会放在第五个 Broker 上；第三个分区将会放在第一个 Broker 上；第四个分区将会放在第二个 Broker 上，依次类推；
剩余的副本相对于第一个副本放置位置其实是由 nextReplicaShift 决定的，而这个数也是随机产生的

问题80：Kafka新建的分区会在哪个目录下创建

在启动 Kafka 集群之前，我们需要配置好 log.dirs 参数，其值是 Kafka 数据的存放目录，这个参数可以配置多个目录，目录之间使用逗号分隔，通常这些目录是分布在不同的磁盘上用于提高读写性能。
当然我们也可以配置 log.dir 参数，含义一样。只需要设置其中一个即可。
如果 log.dirs 参数只配置了一个目录，那么分配到各个 Broker 上的分区肯定只能在这个目录下创建文件夹用于存放数据。
但是如果 log.dirs 参数配置了多个目录，那么 Kafka 会在哪个文件夹中创建分区目录呢？答案是：Kafka 会在含有分区目录最少的文件夹中创建新的分区目录，分区目录名为 Topic名+分区ID。注意，是分区文件夹总数最少的目录，而不是磁盘使用量最少的目录！也就是说，如果你给 log.dirs 参数新增了一个新的磁盘，新的分区目录肯定是先在这个新的磁盘上创建直到这个新的磁盘目录拥有的分区目录不是最少为止。

问题81：partition的数据如何保存到硬盘

topic中的多个partition以文件夹的形式保存到broker，每个分区序号从0递增，且消息有序
Partition文件下有多个segment（xxx.index，xxx.log）
segment 文件里的 大小和配置文件大小一致可以根据要求修改 默认为1g
如果大小大于1g时，会滚动一个新的segment并且以上一个segment最后一条消息的偏移量命名

问题82：Kafka的消费者如何消费数据

消费者每次消费数据的时候，消费者都会记录消费的物理偏移量（offset）的位置，等到下次消费时，他会接着上次位置继续消费

问题83：消费者负载均衡策略

一个消费者组中的一个分片对应一个消费者成员，他能保证每个消费者成员都能访问，如果组中成员太多会有空闲的成员

问题84：数据有序

一个消费者组里它的内部是有序的，消费者组与消费者组之间是无序的

问题85：kafaka生产数据时数据的分组策略

生产者决定数据产生到集群的哪个partition中，每一条消息都是以（key，value）格式，Key是由生产者发送数据传入，所以生产者（key）决定了数据产生到集群的哪个partition

问题86：Kafka速度快和高吞吐量的原因---顺序读写+零拷贝+分区+数据压缩+批量发送

1、顺序读写---顺序写入和MMFile
Kafka会把收到的消息都写入到硬盘中，它绝对不会丢失数据。为了优化写入速度Kafka采用了两个技术：顺序写入和MMFile 
（1）顺序写入---每秒百万级
参考Apache Kafka基准测试：每秒写入2百万(在三台廉价机器上)
因为硬盘是机械结构，每次读写都会寻址->写入，其中寻址是一个“机械动作”，它是最耗时的。磁盘读写的快慢取决于使用的是顺序读写还是随机读写。在顺序读写的情况下，磁盘的顺序读写速度和内存持平，且比内存随机读写快。
这样做会导致数据无法删除，时间一长，磁盘空间会满，kafka提供了2种策略来删除数据：基于时间删除和基于partition文件的大小删除。
（2）MMF(Memory Mapped Files-内存映射文件)
MMF直接利用操作系统的Page来实现文件到物理内存的映射，完成之后对物理内存的操作会直接同步到硬盘。
优点：提速。MMF通过内存映射的方式大大提高了IO速率，省去了用户空间到内核空间的复制。
缺点：不可靠。当发生宕机而数据未同步到硬盘时，数据会丢失，Kafka提供了produce.type参数来控制是否主动的进行刷新，如果kafka写入到mmp后立即flush再返回给生产者则为同步模式，反之为异步模式。
2、读入数据零拷贝---(内核空间-用户空间-内核空间-网卡 ---> 内核空间-内核空间-网卡)
零拷贝(Zero copy)：平时从服务器读取静态文件时，服务器先将文件从复制到内核空间，再复制到用户空间，最后再复制到内核空间并通过网卡发送出去，而零拷贝则是直接从内核到内核再到网卡，省去了用户空间的复制,系统上下文切换减少为2次，可以提升一倍的性能。
零拷贝对应的是Linux中sendfile函数，这个函数会接受一个offsize来确定从哪里开始读取。现实中不可能将整个文件全部发给消费者，他通过消费者传递过来的偏移量来使用零拷贝读取指定内容的数据返回给消费者。
3、分区
kafka中的topic中的内容可以被分为多分partition存在,每个partition又分为多个段segment,所以每次操作都是针对一小部分做操作，很轻便，并且增加并行操作的能力。
4、数据压缩
Kafka还支持对消息集合进行压缩，Producer可以通过GZIP或Snappy格式对消息集合进行压缩。压缩的好处就是减少传输的数据量，减轻对网络传输的压力。
Producer压缩之后，在Consumer需进行解压，虽然增加了CPU的工作，但在对大数据处理上，瓶颈在网络上而不是CPU，所以这个成本很值得。
注意：如果批量发送和数据压缩一起使用,单条做数据压缩的话，效果不明显。
5、批量发送
kafka允许进行批量发送消息，producter发送消息的时候，可以将消息缓存在本地,等到了固定条件发送到kafka。1.等消息条数到固定条数; 2.一段时间发送一次