Kafka

基础操作

异步处理：

把核心的数据先处理完毕，其他不重要的数据放到消息队列里慢慢处理

主题命令行操作

bin/kafka-topics.sh --bootstrap-server hadoop102:9092 --create --partitions 1 --replication-factor 3 --topic first

bin/kafka-topics.sh --bootstrap-server hadoop102:9092 --describe --topic first

生产者命令操作

bin/kafka-console-producer.sh --bootstrap-server hadoop102:9092 --topic first

消费者命令行操作

bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first

生产者生产经验

生产经验——生产者如何提高吞吐量

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class CustomProducerParameters {

    public static void main(String[] args) {

        //0配置
        Properties properties = new Properties();
        //连接Kafka集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092,haddoop103:9092");

        //序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //缓冲区大小
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
        //批次大小
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
        //linger.ms
        properties.put(ProducerConfig.LINGER_MS_CONFIG,1);
        // 压缩
        properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");
        //1创建生产者

        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);



        //2发送数据
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("first","atguigu"+i));
        }

        //3关闭资源
        kafkaProducer.close();
    }
}

思考：ACK应答级别：-1

Leader收到数据，所有Follower都开始同步数据，
但有一个Follower，因为某种故障，迟迟不能与Leader进行
同步，那这个问题怎么解决呢？

Leader维护了一个动态的in-sync replica set（ISR），意为和
Leader保持同步的Follower+Leader集合(leader：0，isr:0,1,2)。
如果Follower长时间未向Leader发送通信请求或同步数据，则
该Follower将被踢出ISR。该时间阈值由replica.lag.time.max.ms参
数设定，默认30s。例如2超时，(leader:0, isr:0,1)。 这样就不用等长期联系不上或者已经故障的节点。

数据完全可靠条件 = ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2

在生产环境中，acks=0很少使用
acks=1，一般用于传输普通日志，允许丢个别数据；acks=-1，一般用于传输和钱相关的数据，对可靠性要求比较高的场景。

生产经验——数据去重

数据重复分析：

幂等性就是指Producer不论向Broker发送多少次重复数据，Broker端都只会持久化一条，保证了不重复。 精确一次（Exactly
Once） = 幂等性 + 至少一次（ ack=-1 + 分区副本数>=2 + ISR最小副本数量>=2） 。
开启参数 enable.idempotence 默认为 true，false 关闭。

PID是Kafka每次重启都会分配一个新的；Partition 表示分区号；Sequence Number是单调自增的。
所以幂等性只能保证的是在单分区单会话内不重复。

生产者事务

Producer 在使用事务功能前，必须先 自定义一个唯一的 transactional.id。有 了
transactional.id，即使客户端挂掉了， 它重启后也能继续处理未完成的事务

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

public class CustomProducerTranactions {
    public static void main(String[] args) {
        //0配置
        Properties properties = new Properties();

        //连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092,hadoop103:9092");
        //制定对应的key和value的数列化类型
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());


        //指定事务id
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"transactiona_id_01");

        //1创建kafka生产者对象

        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        kafkaProducer.initTransactions();
        kafkaProducer.beginTransaction();

        try{
            //2发送数据
            for (int i = 0; i < 5; i++) {
                kafkaProducer.send(new ProducerRecord<>("first","atguigu"+i));
            }
            kafkaProducer.commitTransaction();
        }catch (Exception e){
            kafkaProducer.abortTransaction();
        }finally {
            //3关闭资源
            kafkaProducer.close();
        }





    }
}

生产经验——数据有序

生产经验——数据乱序

如果某批数据没发送成功，会再次请求发送，但是下一个数据成功了，已经发过去了（1,2,4,3） 这样会导致数据乱序。

1）kafka在1.x版本之前保证数据单分区有序，条件如下：
max.in.flight.requests.per.connection=1（不需要考虑是否开启幂等性）。 2）kafka在1.x及以后版本保证数据单分区有序，条件如下：
（2）开启幂等性（幂等性有序列号，按顺序落盘）
max.in.flight.requests.per.connection需要设置小于等于5。 （1）未开启幂等性
max.in.flight.requests.per.connection需要设置为1。
原因说明：因为在kafka1.x以后，启用幂等后，kafka服务端会缓存producer发来的最近5个request的元数据，
故无论如何，都可以保证最近5个request的数据都是有序的。

Kafka Broker 工作流程

Broker生产经验

生产经验——节点服役和退役

创建一个要均衡的主题。

 vim topics-to-move.json

{
 "topics": [
 {"topic": "first"}
 ],
 "version": 1
}

生成一个负载均衡的计划

bin/kafka-reassign-partitions.sh --bootstrap-server hadoop102:9092 --topics-to-move-json-file topics-to-move.json --broker-list "0,1,2,3" --generate

创建副本存储计划（所有副本存储在 broker0、broker1、broker2、broker3 中）

 vim increase-replication-factor.json
 

```bash
bin/kafka-reassign-partitions.sh --bootstrap-server hadoop102:9092 --reassignment-json-file increase-replication-factor.json --execute

验证副本存储计划。

 bin/kafka-reassign-partitions.sh --bootstrap-server hadoop102:9092 --reassignment-json-file increase-replication-factor.json --verify

生产经验——手动调整分区副本存储

（1）创建一个新的 topic，名称为 three。

 bin/kafka-topics.sh --bootstrap-server hadoop102:9092 --create --topic three --partitions 4 --replication-factor 2

（2）查看分区副本存储情况

 bin/kafka-topics.sh --bootstrap-server hadoop102:9092 --describe --topic three

（3）创建副本存储计划（所有副本都指定存储在 broker0、broker1 中）

  vim increase-replication-factor.json

（4）执行副本存储计划。

bin/kafka-reassign-partitions.sh --bootstrap-server hadoop102:9092 --reassignment-json-file increase-replication-factor.json --execute

（5）验证副本存储计划。

bin/kafka-reassign-partitions.sh --bootstrap-server hadoop102:9092 --reassignment-json-file increase-replication-factor.json --verify

（6）查看分区副本存储情况

 bin/kafka-topics.sh --bootstrap-server hadoop102:9092 --describe --topic three

生产经验——Leader Partition 负载平衡

正常情况下，Kafka本身会自动把Leader Partition均匀分散在各个机器上，来保证每台机器的读写吞吐量都是均匀的。但是如果某
些broker宕机，会导致Leader
Partition过于集中在其他少部分几台broker上，这会导致少数几台broker的读写请求压力过高，其他宕机的
broker重启之后都是follower partition，读写请求很低，造成集群负载不均衡。

会自动实现负载均衡：不建议开启

auto.leader.rebalance.enable，默认是true。
自动Leader Partition 平衡
• leader.imbalance.per.broker.percentage，
默认是10%。每个broker允许的不平衡
的leader的比率。如果每个broker超过
了这个值，控制器会触发leader的平衡。
• leader.imbalance.check.interval.seconds，
默认值300秒。检查leader负载是否平衡
的间隔时间。

生产经验——增加副本因子

在生产环境当中，由于某个主题的重要等级需要提升，我们考虑增加副本。副本数的
增加需要先制定计划，然后根据计划执行。
1）创建 topic
2）手动增加副本存储
（1）创建副本存储计划（所有副本都指定存储在 broker0、broker1、broker2 中）。
（2）执行副本存储计划。

高效读写数据

1）Kafka 本身是分布式集群，可以采用分区技术，并行度高
2）读数据采用稀疏索引，可以快速定位要消费的数据
3）顺序写磁盘
（Kafka 的 producer 生产数据，要写入到 log 文件中，写的过程是一直追加到文件末端，
为顺序写。官网有数据表明，同样的磁盘，顺序写能到 600M/s，而随机写只有 100K/s。这
与磁盘的机械机构有关，顺序写之所以快，是因为其省去了大量磁头寻址的时间。）
4）页缓存 + 零拷贝技术 （未深入理解）

Kafka 消费者

pull（拉）模 式：

push（推）模式：
consumer采用从broker中主动拉取数据。
Kafka采用这种方式。
Kafka没有采用这种方式，因为由broker
决定消息发送速率，很难适应所有消费者的
消费速率。例如推送的速度是50m/s，
Consumer1、Consumer2就来不及处理消息。

pull模式不足之处是，如 果Kafka没有数
据，消费者可能会陷入循环中，一直返回
空数据。

消费者总体工作流程

消费者组原理

Consumer Group（CG）：消费者组，由多个consumer组成。形成一个消费者组的条件，是所有消费者的groupid相同。 • 消费者组内每个消费者负责消费不同分区的数据，一个分区只能由一个组内消费者消费。 • 消费者组之间互不影响。所有的消费者都属于某个消费者组，即消费者组是逻辑上的一个订阅者。
意思是每个消费者可以消费任何分区，而消费者组的消费者们不同消费同一个分区。
如果向消费组中添加更多的消费者，超过主题分区数量，则有一部分消费者就会闲置，不会接收任何消息。

生产经验——分区的分配以及再平衡

1、一个consumer group中有多个consumer组成，一个 topic有多个partition组成，现在的问题是，到底由哪个consumer来消费哪个
partition的数据。 2、Kafka有四种主流的分区分配策略： Range、RoundRobin、Sticky、CooperativeSticky。
可以通过配置参数partition.assignment.strategy，修改分区的分配策略。默认策略是Range + CooperativeSticky。Kafka可以同时使用多个分区分配策略。
1）每个consumer都发送JoinGroup请求
2）选出一个consumer作为leader
3）把要消费的topic情况发送给leader 消费者
4）leader会负
责制定消费方案
5）把消费方案发给coordinator
6）Coordinator就把消费方案下发给各个consumer
7）每个消费者都会和coordinator保持心跳（默认3s），一旦超时
（session.timeout.ms=45s），该消费者会被移除，并触发再平衡；
或者消费者处理消息的过长（max.poll.interval.ms5分钟），也会触发再
平衡

Range 以及再平衡

Range 是对每个 topic 而言的。
首先对同一个 topic 里面的分区按照序号进行排序，并
对消费者按照字母顺序进行排序。
假如现在有 7 个分区，3 个消费者，排序后的分区将会
是0,1,2,3,4,5,6；消费者排序完之后将会是C0,C1,C2。
例如，7/3 = 2 余 1 ，除不尽，那么 消费者 C0 便会多
消费 1 个分区。 8/3=2余2，除不尽，那么C0和C1分别多
消费一个。
通过 partitions数/consumer数 来决定每个消费者应该
消费几个分区。如果除不尽，那么前面几个消费者将会多
消费 1 个分区。
分区分配策略之Range
注意：如果只是针对 1 个 topic 而言，C0消费者多消费1
个分区影响不是很大。但是如果有 N 多个 topic，那么针对每
个 topic，消费者 C0都将多消费 1 个分区，topic越多，C0消 费的分区会比其他消费者明显多消费 N 个分区。
容易产生数据倾斜！

再平衡：
（1）停止掉 0 号消费者，快速重新发送消息观看结果（45s 以内，越快越好）。 1 号消费者：消费到 3、4 号分区数据。 2 号消费者：消费到 5、6 号分区数据。 0 号消费者的任务会整体被分配到 1 号消费者或者 2 号消费者。
说明：0 号消费者挂掉后，消费者组需要按照超时时间 45s 来判断它是否退出，所以需
要等待，时间到了 45s 后，判断它真的退出就会把任务分配给其他 broker 执行。
（2）再次重新发送消息观看结果（45s 以后）。 1 号消费者：消费到 0、1、2、3 号分区数据。 2 号消费者：消费到 4、5、6 号分区数据。
说明：消费者 0 已经被踢出消费者组，所以重新按照 range 方式分配。

RoundRobin 以及再平衡

RoundRobin 针对集群中所有Topic而言。
RoundRobin 轮询分区策略，是把所有的 partition 和所有的
consumer 都列出来，然后按照 hashcode 进行排序，最后
通过轮询算法来分配 partition 给到各个消费者。

再平衡
（1）停止掉 0 号消费者，快速重新发送消息观看结果（45s 以内，越快越好）。 1 号消费者：消费到 2、5 号分区数据
2 号消费者：消费到 4、1 号分区数据
0 号消费者的任务会按照 RoundRobin 的方式，把数据轮询分成 0 、6 和 3 号分区数据，
分别由 1 号消费者或者 2 号消费者消费。
说明：0 号消费者挂掉后，消费者组需要按照超时时间 45s 来判断它是否退出，所以需
要等待，时间到了 45s 后，判断它真的退出就会把任务分配给其他 broker 执行。
（2）再次重新发送消息观看结果（45s 以后）。 1 号消费者：消费到 0、2、4、6 号分区数据
2 号消费者：消费到 1、3、5 号分区数据
说明：消费者 0 已经被踢出消费者组，所以重新按照 RoundRobin 方式分配。

Sticky 以及再平衡

粘性分区定义：可以理解为分配的结果带有“粘性的”。即在执行一次新的分配之前，
考虑上一次分配的结果，尽量少的调整分配的变动，可以节省大量的开销。
粘性分区是 Kafka 从 0.11.x 版本开始引入这种分配策略，首先会尽量均衡的放置分区
到消费者上面，在出现同一消费者组内消费者出现问题的时候，会尽量保持原有分配的分
区不变化。

再平衡
（1）停止掉 0 号消费者，快速重新发送消息观看结果（45s 以内，越快越好）。 1 号消费者：消费到 2、5、3 号分区数据。 2 号消费者：消费到 4、6 号分区数据。 0 号消费者的任务会按照粘性规则，尽可能均衡的随机分成 0 和 1 号分区数据，分别
由 1 号消费者或者 2 号消费者消费。
说明：0 号消费者挂掉后，消费者组需要按照超时时间 45s 来判断它是否退出，所以需
要等待，时间到了 45s 后，判断它真的退出就会把任务分配给其他 broker 执行。
（2）再次重新发送消息观看结果（45s 以后）。 1 号消费者：消费到 2、3、5 号分区数据。 2 号消费者：消费到 0、1、4、6 号分区数据。
说明：消费者 0 已经被踢出消费者组，所以重新按照粘性方式分配。

offset 位移

__consumer_offsets 主题里面采用 key 和 value 的方式存储数据。key 是 group.id+topic+
分区号，value 就是当前 offset 的值。每隔一段时间，kafka 内部会对这个 topic 进行
compact，也就是每个 group.id+topic+分区号就保留最新数据

offset消费案例
（0）思想：__consumer_offsets 为 Kafka 中的 topic，那就可以通过消费者进行消费。 （1）在配置文件 config/consumer.properties 中添加配置 exclude.internal.topics=false，
默认是 true，表示不能消费系统主题。为了查看该系统主题数据，所以该参数修改为 false。
（2）采用命令行方式，创建一个新的 topic。

bin/kafka-topics.sh --bootstrap-server hadoop102:9092 --create --topic atguigu --partitions 2 --replication-factor 2

（3）启动生产者往 atguigu 生产数据。

bin/kafka-console-producer.sh --topic atguigu --bootstrap-server hadoop102:9092

（4）启动消费者消费 atguigu 数据。

bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic atguigu --group test

（5）查看消费者消费主题__consumer_offsets。

 bin/kafka-console-consumer.sh --topic __consumer_offsets --bootstrap-server hadoop102:9092 --consumer.config config/consumer.properties --formatter "kafka.coordinator.group.GroupMetadataManager\$OffsetsMessageFormatter" --from-beginning

[test-consumer-group,__consumer_offsets,10]::OffsetAndMetadata(offset=0, leaderEpoch=Optional.empty, metadata=, commitTimestamp=1654440783867, expireTimestamp=None)
[test-consumer-group,__consumer_offsets,32]::OffsetAndMetadata(offset=0, leaderEpoch=Optional.empty, metadata=, commitTimestamp=1654440783867, expireTimestamp=None)
[test-consumer-group,__consumer_offsets,40]::OffsetAndMetadata(offset=0, leaderEpoch=Optional.empty, metadata=, commitTimestamp=1654440783867, expireTimestamp=None)
^C[test,atguigu,1]::OffsetAndMetadata(offset=3, leaderEpoch=Optional[0], metadata=, commitTimestamp=1654440785102, expireTimestamp=None)
[test,atguigu,0]::OffsetAndMetadata(offset=3, leaderEpoch=Optional[0], metadata=, commitTimestamp=1654440785102, expireTimestamp=None)

手动提交offset

虽然自动提交offset十分简单便利，但由于其是基于时间提交的，开发人员难以把握offset提交的时机。因 此Kafka还提供了手动提交offset的API。
手动提交offset的方法有两种：分别是commitSync（同步提交）和commitAsync（异步提交）。两者的相
同点是，都会将本次提交的一批数据最高的偏移量提交；不同点是，同步提交阻塞当前线程，一直到提交成
功，并且会自动失败重试（由不可控因素导致，也会出现提交失败）；而异步提交则没有失败重试机制，故
有可能提交失败。

• commitSync（同步提交）：必须等待offset提交完毕，再去消费下一批数据。
• commitAsync（异步提交） ：发送完提交offset请求后，就开始消费下一批数据了。

 // 同步提交 offset
 consumer.commitSync();

 // 异步提交 offset
 consumer.commitAsync();

指定 Offset 消费

auto.offset.reset = earliest | latest | none 默认是 latest。 当 Kafka 中没有初始偏移量（消费者组第一次消费）或服务器上不再存在当前偏移量
时（例如该数据已被删除），该怎么办？
（1）earliest：自动将偏移量重置为最早的偏移量，–from-beginning。 （2）latest（默认值）：自动将偏移量重置为最新偏移量。

（3）none：如果未找到消费者组的先前偏移量，则向消费者抛出异常。

 //指定位置进行消费
 Set<TopicPartition> assignment= new HashSet<>();
 while (assignment.size() == 0) {
 kafkaConsumer.poll(Duration.ofSeconds(1));
 // 获取消费者分区分配信息（有了分区分配信息才能开始消费）
 assignment = kafkaConsumer.assignment();
 }
 // 遍历所有分区，并指定 offset 从 1700 的位置开始消费
 for (TopicPartition tp: assignment) {
 kafkaConsumer.seek(tp, 1700);
 }

指定时间消费

需求：在生产环境中，会遇到最近消费的几个小时数据异常，想重新按照时间消费。
例如要求按照时间消费前一天的数据，怎么处理？

 Set<TopicPartition> assignment = new HashSet<>();
 while (assignment.size() == 0) {
 kafkaConsumer.poll(Duration.ofSeconds(1));
 // 获取消费者分区分配信息（有了分区分配信息才能开始消费）
 assignment = kafkaConsumer.assignment();
 }
 HashMap<TopicPartition, Long> timestampToSearch = new 
HashMap<>();
 // 封装集合存储，每个分区对应一天前的数据
 for (TopicPartition topicPartition : assignment) {
 timestampToSearch.put(topicPartition, 
System.currentTimeMillis() - 1 * 24 * 3600 * 1000);
 }
 // 获取从 1 天前开始消费的每个分区的 offset
 Map<TopicPartition, OffsetAndTimestamp> offsets = 
kafkaConsumer.offsetsForTimes(timestampToSearch);
 // 遍历每个分区，对每个分区设置消费时间。
 for (TopicPartition topicPartition : assignment) {
 OffsetAndTimestamp offsetAndTimestamp = 
offsets.get(topicPartition);
 // 根据时间指定开始消费的位置
 if (offsetAndTimestamp != null){
 kafkaConsumer.seek(topicPartition, 
offsetAndTimestamp.offset());

生产经验———消费者事务

如果想完成Consumer端的精准一次性消费，那么需要Kafka消费端将消费过程和提交offset
过程做原子绑定。此时我们需要将Kafka的offset保存到支持事务的自定义介质（比 如
MySQL）。这部分知识会在后续项目部分涉及。

生产经验——数据积压（消费者如何提高吞吐量）

1）如果是Kafka消费能力不足，则可以考虑增 加Topic的分区数，并且同时提升消费组的消费者
数量，消费者数 = 分区数。（两者缺一不可）

2）如果是下游的数据处理不及时：提高每批次拉取的数
量。批次拉取数据过少（拉取数据/处理时间 < 生产速度），
使处理的数据小于生产的数据，也会造成数据积压。
可以从一次最多拉取500条，调整为一次最多拉取1000条。

项目经验值Kafka分区数计算

（1）创建一个只有1个分区的topic
（2）测试这个topic的producer吞吐量和consumer吞吐量。
（3）假设他们的值分别是Tp和Tc，单位可以是MB/s。
（4）然后假设总的目标吞吐量是Tt，那么分区数 = Tt / min（Tp，Tc）
例如：producer吞吐量 = 20m/s；consumer吞吐量 = 50m/s，期望吞吐量100m/s；
分区数 = 100 / 20 = 5分区

学习总结

一、概述
1、定义
1）传统定以
分布式 发布订阅 消息队列
发布订阅：分为多种类型，订阅者根据需求选择性订阅
2）最新定义
流平台（存储、计算）
2、消息队列应用场景
1）缓存消峰（数据量过多，比如双11）
2）解耦（比如超市，超市可以从很多地方进货，消费者可以直接从超市拿东西，省去了各种接口的麻烦）
3）异步通信（先解决核心的事）
3、两种模式
1）点对点模式
（1）一个生产者 一个消费者 一个topic 会删除数据 用得不多
(2) 多个生产者 多个消费者 相互独立 多个topic 不会删除数据
4、架构
1）生产者
100T数据
2）broker集群
（1）broker 服务器 hadoop102 103 104
（2）topic 主题 对数据分类
（3）分区
（4）可靠性 副本
（5）leader follower
（6）生产者和消费者 只针对leader操作
3）消费者
（1）消费者和消费者相互独立
（2）消费者组（某个分区，只能由一个消费者消费）
4）zookeeper(外部集群)
（1）broker.ids （0 1 2）
（2）leader isr
二、入门
1、安装
1）broker.id 必须全局唯一
2）borker.id 、log.dirs zk/kafaka
3）自动停止，先停止kafka，再停止zk
4）脚本
2、常用命令行
1）主题 kafka-topic.sh
2) 生产者 kafka-producer.sh
3) 消费者 kafka-console-consumer,sh
三 生产者
1、原理
2、异步发送API
0）配置
（1） 连接 bootstrap_server
（2） key value 序列化
1）创建生产者
KafkaProduce<String,String>
2）发送数据
send() send(,new Callback)
3）关闭资源
3、同步发送
。。。
send() send(,new Callback).get()
4、分区
（1）好处
存储
计算
2）默认分区规则
（1）指定分区 按分区走
（2）key key的hashcode值%分区数
（3）没有指定key 没有指定分区 粘性
第一随机
3）自定义分区
定义类 实现partitioner接口
5、吞吐量提高
1）批次大小 16k=> 32k
2）linger.ms 0=> 5-100ms
3）压缩
4）缓存大小 32m=>64m
6、可靠性
acks
0 丢失数据
1 也可能会丢 传输普通日志
-1 完全可靠 +副本大鱼等于2 ISR>= 2 => 数据重复
7、数据重复
1）幂等性
<pid，分区好，序列号>
默认打开
2）事务
底层基于幂等性
API
（1）初始化
（2）启动
（3）消费者offset
（4）提交
（5）终止
8、数据有序
单分区有序（有条件）
多分区有序
9、乱序
1）inflight =1
2） 没有幂等性 inflight =1
3） 有幂等性（把数据缓存在内存中，幂等性有序列号，按顺序落盘）
四、borker集群
1、zk存储了哪些信息
（1）borker.ids
（2）leader
（3）辅助选举 controller
2、工作流程
3、服役
1）准备一台干净服务器 hadoop100
2）对哪个主题操作
3） 行程计划
4）执行计划
5）验证计划
4、退役
1）要退役节点不让存储数据
2）退出节点
5、副本
1）副本的好处 提高可靠性
2）要适可而止，在生产环境中通常2个 默认1个
3）有leader follower
4) isr
5) 选举机制：controller 规则：在 isr存活，ar中排最前面
6）leader 挂了，follwer上位，需要数据一致性，高的部分去掉，低的部分追赶
7）follwer挂了，回复通信后需要截取之前的水位线，重新追赶
8）副本分配 默认
9）手动副本分配：制定计划，执行计划，验证计划
10）leader partition的负载均衡 10%
11） 手动增加副本因子
6、存储机制
borker topic partition log segment(1g) (.log .index .timeindex)
7、删除数据
默认7天 3天
策略：直接删除 、压缩
直接删除：如果数据有些没过期，需要等过期
压缩：按照每个key的最新的value进行保存
8、高效读写
1）集群 采用分区
2） 稀疏索引
3）顺序读写
4）零拷贝 和 页缓存
五、消费者
1、总体流程
2、消费者组
3、按照主题进行消费
0）配置信息
连接
反序列化
组id
1）创建消费者
2）订阅主题
3）消费数据
4、按照分区
5、消费者组案例（组id相同）
6、分区分配策略 再平衡（7分区，3消费者）
range ： 再平衡：（45秒以内会把 第一个消费者的数据全部 给到其中一个消费者）
0 1 2
3 4
5 6
roudrobin 再平衡：（45以内会把数据轮循发给其他消费者）
轮循
0 3 6
1 4
2 5
粘性
随机+均匀
7、offset
1）默认存在系统主题
2）自动提交 5s 默认
3）手动提交 同步 异步
4）指定offset消费 seek()
5）按照时间消费
6）漏消费 重复消费
8、事务
生产端=》集群=》消费者=》下游框架
9、数据挤压