本文详细介绍了Kafka集群的控制台操作，包括创建Topic、查看主题、生产者和消费者数据操作，以及通过Java API进行操作。同时，深入探讨了Kafka的原理，如生产者和消费者的写读数据流程、日志存储机制、消息不丢失机制，并讨论了CAP理论在Kafka中的应用。此外，还涉及了Kafka与Zookeeper的交互。
文章目录
- **9、Kafka集群操作**
- **10、kafka原理部分**
- 11、kafka消息不丢失机制
- **11、CAP理论以及kafka当中的CAP机制**
- 12、kafka in zookeeper
9、Kafka集群操作
9.1、kafka集群操作-控制台操作
9.1.1、创建一个Topic
创建了一个名字为test的主题， 有三个分区，有两个副本
node02执行以下命令来创建topic
cd /export/servers/kafka_2.11-0.10.0.0
bin/kafka-topics.sh --create --zookeeper node02:2181 --replication-factor 2 --partitions 3 --topic test
9.1.2、查看主题命令
查看kafka当中存在的主题
node02使用以下命令来查看kafka当中存在的topic主题
cd /export/servers/kafka_2.11-0.10.0.0
bin/kafka-topics.sh --list --zookeeper node02:2181,node03:2181,node04:2181
9.1.3、生产者生产数据
模拟生产者来生产数据
node02服务器执行以下命令来模拟生产者进行生产数据
cd /export/servers/kafka_2.11-0.10.0.0
bin/kafka-console-producer.sh --broker-list node02:9092,node03:9092,node04:9092 --topic test
9.1.4、消费者消费数据
node03服务器执行以下命令来模拟消费者进行消费数据
cd /export/servers/kafka_2.11-0.10.0.0
bin/kafka-console-consumer.sh --from-beginning --topic test --zookeeper node02:2181,node03:2181,node04:2181
9.1.5、运行describe topics命令
node02执行以下命令运行describe查看topic的相关信息
cd /export/servers/kafka_2.11-0.10.0.0
bin/kafka-topics.sh --describe --zookeeper node02:2181 --topic test
结果说明：
这是输出的解释。第一行给出了所有分区的摘要，每个附加行提供有关一个分区的信息。由于我们只有一个分 区用于此主题，因此只有一行。
“leader”是负责给定分区的所有读取和写入的节点。每个节点将成为随机选择的分区部分的领导者。（因为在kafka中 如果有多个副本的话，就会存在leader和follower的关系，表示当前这个副本为leader所在的broker是哪一个）
“replicas”是复制此分区日志的节点列表，无论它们是否为领导者，或者即使它们当前处于活动状态。（所有副本列表 0 ，1,2）
“isr”是“同步”复制品的集合。这是副本列表的子集，该列表当前处于活跃状态并且已经被领导者捕获。（可用的列表 数）
9.1.6、修改topic属性
9.1.6.1、增加topic分区数
任意kafka服务器执行以下命令可以增加topic分区数
cd /export/servers/kafka_2.11-0.10.0.0
bin/kafka-topics.sh --zookeeper zkhost:port --alter --topic topicName --partitions 8
9.1.6.2、增加配置
动态修改kakfa的配置
任意kafka服务器执行以下命令可以增加topic分区数
cd /export/servers/kafka_2.11-0.10.0.0
bin/kafka-topics.sh --zookeeper node02:2181 --alter --topic test --config flush.messages=1
9.1.6.3、删除配置
动态删除kafka集群配置
cd /export/servers/kafka_2.11-0.10.0.0
bin/kafka-topics.sh --zookeeper node02:2181 --alter --topic test --delete-config flush.messages
9.1.6.4、删除topic
目前删除topic在默认情况下知识打上一个删除的标记，在重新启动kafka后才删除。如果需要立即删除，则需要在
server.properties中配置：
delete.topic.enable=true
然后执行以下命令进行删除topic
kafka-topics.sh --zookeeper zkhost:port --delete --topic topicName
9.2、kafka集群操作-JavaAPI操作
9.2.1、添加依赖
创建maven工程并添加以下依赖jar包的坐标到pom.xml
<dependencies>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version> 0.10.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-streams</artifactId>
<version>0.10.0.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- java编译插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
9.2.2、生产者代码
/**
\* 订单的生产者代码，
*/
public class OrderProducer {
public static void main(String[] args) throws InterruptedException {
Properties props = new Properties();
props.put("bootstrap.servers", "node02:9092");
props.put("acks", "all");
props.put("retries", 0);
props.put("batch.size", 16384);
props.put("linger.ms", 1);
props.put("buffer.memory", 33554432);
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(props);
for (int i = 0; i < 1000; i++){
kafkaProducer.send(new ProducerRecord<String,String>("order","订单"+i));
Thread.sleep(1000);
}
//kafkaProducer.flush();
//kafkaProducer.close();
}
}
9.2.3、消费者代码
使用消费者进行消费kafka当中的数据
/**
\* 消费订单数据--- javaben.tojson
*/
public class OrderConsumer {
public static void main(String[] args) {
// 1\连接集群
Properties props = new Properties();
props.put("bootstrap.servers", "node02:9092");
props.put("group.id", "test");
//以下两行代码 ---消费者自动提交offset值
props.put("enable.auto.commit", "true");
props.put("auto.commit.interval.ms", "1000");
props.put("session.timeout.ms","30000")
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>
(props);
// 2、发送数据 发送数据需要，订阅下要消费的topic。 order
kafkaConsumer.subscribe(Arrays.asList("order")); while (true) {
ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(100);
// jdk queue offer插入、poll获取元素。 blockingqueue put插入原生， take获取元素
for (ConsumerRecord<String, String> record : consumerRecords) {
System.out.println("消费的数据为：" + record.value());
}
}
}
}
9.2.4、kafka Streams API开发
需求：使用StreamAPI获取test这个topic当中的数据，然后将数据全部转为大写，写入到test2这个topic当中去
第一步：创建一个topic
node01服务器使用以下命令来常见一个topic 名称为test2
cd /export/servers/kafka_2.11-0.10.0.0/
bin/kafka-topics.sh --create --partitions 3 --replication-factor 2 --topic test2 --zookeeper node01:2181,node02:2181,node03:2181
第二步：开发StreamAPI
public class StreamAPI {
public static void main(String[] args) {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "wordcount-application");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "node01:9092");
props.put(StreamsConfig.KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
props.put(StreamsConfig.VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
KStreamBuilder builder = new KStreamBuilder();
builder.stream("test").mapValues(line -> line.toString().toUpperCase()).to("test2");
KafkaStreams streams = new KafkaStreams(builder, props);
streams.start();
}
}
需要自己在wins上创建文件夹
第三步：生产数据
node02执行以下命令，向test这个topic当中生产数据
cd /export/servers/kafka_2.11-0.10.0.0
bin/kafka-console-producer.sh --broker-list node02:9092,node03:9092,node04:9092 --topic test
第四步：消费数据
node02执行一下命令消费test2这个topic当中的数据
cd /export/servers/kafka_2.11-0.10.0.0
bin/kafka-console-consumer.sh --from-beginning --topic test2 --zookeeper node02:2181,node03:2181,node04:2181
10、kafka原理部分
生产-消费流程
数据从生产-消费-提交offset过程，分以下几个阶段来进行
10.1、生产者
生产者是一个向kafka Cluster发布记录的客户端；生产者是线程安全的，跨线程共享单个生产者实例通常比具有多个实例更快。
10.1.1、必要条件
生产者要进行生产数据到kafka Cluster中，必要条件有以下三个：
#1、地址
bootstrap.servers=node01:9092
#2、序列化
key.serializer=org.apache.kafka.common.serialization.StringSerializer value.serializer=org.apache.kafka.common.serialization.StringSerializer
#3、主题（topic） 需要制定具体的某个topic（order）即可。
10.1.2、生产者（Producer）写数据
10.1.2.1、生产者（Producer）写数据流程图
10.1.2.2、流程描述
1、总体流程
Producer连接任意活着的Broker，请求指定Topic，Partition的Leader元数据信息，然后直接与对应的Broker直接连接，发布数据
2、开放分区接口(生产者数据分发策略)
2.1、用户可以指定分区函数，使得消息可以根据key，发送到指定的Partition中。
2.2、kafka在数据生产的时候，有一个数据分发策略。默认的情况使用DefaultPartitioner.class类。 这个类中就定义数据分发的策略。
2.3、如果是用户制定了partition，生产就不会调用DefaultPartitioner.partition()方法
2.4、当用户指定key，使用hash算法。如果key一直不变，同一个key算出来的hash值是个固定值。如果是固定 值，这种hash取模就没有意义。
Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions
2.5 、 当用既没有指定partition也没有key。
/**
The default partitioning strategy:
<ul>
<li>If a partition is specified in the record, use it
<li>If no partition is specified but a key is present choose a partition based on a hash of the key
<li>If no partition or key is present choose a partition in a round-robin fashion
*/
2.6、数据分发策略的时候，可以指定数据发往哪个partition。当ProducerRecord 的构造参数中有partition的时 候，就可以发送到对应partition上。
10.1.2.3、生产者数据分发策略
生产者数据分发策略有如下四种：(总的来说就是调用了一个方法，参数不同而已)
//可根据主题和内容发送
public ProducerRecord(String topic, V value)
//根据主题，key、内容发送
public ProducerRecord(String topic, K key, V value)
//根据主题、分区、key、内容发送
public ProducerRecord(String topic, Integer partition, K key, V value)
//根据主题、分区、时间戳、key，内容发送
public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value)
a、可根据主题和内容发送
Producer<String, String> producer = new KafkaProducer<String, String>(props);
//可根据主题和内容发送
producer.send(new ProducerRecord<String, String>("my-topic","具体的数据"));
b、根据主题，key、内容发送
Producer<String, String> producer = new KafkaProducer<String, String>(props);
//可根据主题、key、内容发送
producer.send(new ProducerRecord<String, String>("my-topic","key","具体的数据"));
c、根据主题、分区、key、内容发送
Producer<String, String> producer = new KafkaProducer<String, String>(props);
//可根据主题、分区、key、内容发送
producer.send(new ProducerRecord<String, String>("my-topic",1,"key","具体的数据"));
d、根据主题、分区、时间戳、key，内容发送
Producer<String, String> producer = new KafkaProducer<String, String>(props);
//可根据主题、分区、时间戳、key、内容发送
producer.send(new ProducerRecord<String, String>("my-topic",1,12L,"key","具体的数据"));
10.2、消费者
消费者是一个从kafka Cluster中消费数据的一个客户端；该客户端可以处理kafka brokers中的故障问题，并且可以适应在集群内的迁移的topic分区；该客户端还允许消费者组使用消费者组来进行负载均衡。
消费者维持一个TCP的长连接来获取数据，使用后未能正常关闭这些消费者问题会出现，因此消费者不是线程安全 的。
10.2.1、必要条件
消费者要从kafka Cluster进行消费数据，必要条件有以下四个
#1、地址
bootstrap.servers=node01:9092
#2、反序列化
key.serializer=org.apache.kafka.common.serialization.StringSerializer
value.serializer=org.apache.kafka.common.serialization.StringSerializer
#3、主题（topic） 需要制定具体的某个topic（order）即可。
#4、消费者组 group.id=test
10.2.2、消费者代码-自动提交offset值
/**
\* 消费订单数据--- javaben.tojson
*/
public class OrderConsumer {
public static void main(String[] args) {
// 1\连接集群
Properties props = new Properties(); props.put("bootstrap.servers", "hadoop-01:9092"); props.put("group.id", "test");
//以下两行代码 ---消费者自动提交offset值
props.put("enable.auto.commit", "true");
props.put("auto.commit.interval.ms", "1000");
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);
// 2、发送数据 发送数据需要，订阅下要消费的topic。 order
kafkaConsumer.subscribe(Arrays.asList("order"));
while (true) {
ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(100);
// jdk queue offer插入、poll获取元素。 blockingqueue put插入原生， take获取元素
for (ConsumerRecord<String, String> record : consumerRecords) {
System.out.println("消费的数据为：" + record.value());
}
}
}
}
10.2.3、消费者代码-手动提交offset
如果Consumer在获取数据后，需要加入处理，数据完毕后才确认offset，需要程序来控制offset的确认？ 关闭自动提交确认选项
props.put(“enable.auto.commit”, “false”);
手动提交offset值
kafkaConsumer.commitSync();
完整代码如下所示：
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("group.id", "test");
//关闭自动提交确认选项
props.put("enable.auto.commit", "false");
props.put("key.deserializer","org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer","org.apache.kafka.common.serialization.StringDeserializer");
KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
consumer.subscribe(Arrays.asList("foo", "bar"));
final int minBatchSize = 200;
List<ConsumerRecord<String, String>> buffer = new ArrayList<>();
while (true) {
ConsumerRecords<String, String> records = consumer.poll(100);
for (ConsumerRecord<String, String> record : records) {
buffer.add(record);
}
if (buffer.size() >= minBatchSize) {
insertIntoDb(buffer);
// 手动提交offset值
consumer.commitSync();
buffer.clear();
}
}
10.2.4、消费者代码-完成处理每个分区中的记录后提交偏移量
上面的示例使用commitSync将所有已接收的记录标记为已提交。 在某些情况下，您可能希望通过明确指定偏移量 来更好地控制已提交的记录。 在下面的示例中，我们在完成处理每个分区中的记录后提交偏移量。
try {
while(running) {
ConsumerRecords<String, String> records = consumer.poll(Long.MAX_VALUE);
for (TopicPartition partition : records.partitions()) {
List<ConsumerRecord<String, String>> partitionRecords = records.records(partition);
for (ConsumerRecord<String, String> record : partitionRecords) {
System.out.println(record.offset() + ": " + record.value());
}
long lastOffset = partitionRecords.get(partitionRecords.size() -1).offset();
consumer.commitSync(Collections.singletonMap(partition, new OffsetAndMetadata(lastOffset + 1)));
}
}
} finally {
consumer.close();
}
注意事项：
提交的偏移量应始终是应用程序将读取的下一条消息的偏移量。 因此，在调用commitSync（偏移量）时，应该 在最后处理的消息的偏移量中添加一个
10.2.5、消费者代码-使用消费者消费指定分区的数据
1、如果进程正在维护与该分区关联的某种本地状态（如本地磁盘上的键值存储），那么它应该只获取它在磁盘上 维护的分区的记录。
2、如果进程本身具有高可用性，并且如果失败则将重新启动（可能使用YARN，Mesos或AWS工具等集群管理框 架，或作为流处理框架的一部分）。 在这种情况下，Kafka不需要检测故障并重新分配分区，因为消耗过程将在另 一台机器上重新启动。
Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092"); props.put("group.id", "test");
props.put("enable.auto.commit", "true");
props.put("auto.commit.interval.ms", "1000");
props.put("key.deserializer","org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer","org.apache.kafka.common.serialization.StringDeserializer");
KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
//consumer.subscribe(Arrays.asList("foo", "bar"));
//手动指定消费指定分区的数据---start
String topic = "foo";
TopicPartition partition0 = new TopicPartition(topic, 0);
TopicPartition partition1 = new TopicPartition(topic, 1);
consumer.assign(Arrays.asList(partition0, partition1));
//手动指定消费指定分区的数据---end
while (true) {
ConsumerRecords<String, String> records = consumer.poll(100);
for (ConsumerRecord<String, String> record : records)
System.out.printf("offset = %d, key = %s, value = %s%n",
record.offset(), record.key(), record.value());
}
注意事项：
1、要使用此模式，您只需使用要使用的分区的完整列表调用assign（Collection），而不是使用subscribe订阅 主题。
2、主题与分区订阅只能二选一
10.2.6、消费者数据丢失-数据重复
说明：
1、已经消费的数据对于kafka来说，会将消费组里面的offset值进行修改，那什么时候进行修改了？是在数据消费 完成之后，比如在控制台打印完后自动提交；
2、提交过程：是通过kafka将offset进行移动到下个message所处的offset的位置。
3、拿到数据后，存储到hbase中或者mysql中，如果hbase或者mysql在这个时候连接不上，就会抛出异常，如果在处理数据的时候已经进行了提交，那么kafka伤的offset值已经进行了修改了，但是hbase或者mysql中没有数据，这个时候就会出现数据丢失。
4、什么时候提交offset值？在Consumer将数据处理完成之后，再来进行offset的修改提交。默认情况下offset是 自动提交，需要修改为手动提交offset值。
5、如果在处理代码中正常处理了，但是在提交offset请求的时候，没有连接到kafka或者出现了故障，那么该次修 改offset的请求是失败的，那么下次在进行读取同一个分区中的数据时，会从已经处理掉的offset值再进行处理一 次，那么在hbase中或者mysql中就会产生两条一样的数据，也就是数据重复
10.2.7、消费者（Consumer）读数据
10.2.7.1、消费者（Consumer）读数据流程图
10.2.7.2、流程描述
Consumer连接指定的Topic partition所在leader broker，采用pull方式从kafkalogs中获取消息。对于不同的消费模式，会将offset保存在不同的地方
官网关于high level API 以及low level API的简介
http://kafka.apache.org/0100/documentation.html#impl_consumer
10.2.7.3、高阶API（High Level API）
kafka消费者高阶API简单；隐藏Consumer与Broker细节；相关信息（offset）保存在zookeeper中。
/* create a connection to the cluster */
ConsumerConnector connector = Consumer.create(consumerConfig);
interface ConsumerConnector {
/**
This method is used to get a list of KafkaStreams, which are iterators over
MessageAndMetadata objects from which you can obtain messages and their
associated metadata (currently only topic).
Input: a map of <topic, #streams>
Output: a map of <topic, list of message streams>
*/
public Map<String,List<KafkaStream>> createMessageStreams(Map<String,Int> topicCountMap);
/**
You can also obtain a list of KafkaStreams, that iterate over messages
from topics that match a TopicFilter. (A TopicFilter encapsulates a
whitelist or a blacklist which is a standard Java regex.)
*/
public List<KafkaStream> createMessageStreamsByFilter( TopicFilter topicFilter, int numStreams);
/* Commit the offsets of all messages consumed so far. */ public commitOffsets()
/* Shut down the connector */ public shutdown()
}
说明：大部分的操作都已经封装好了，比如：当前消费到哪个位置下了，但是不够灵活（工作过程推荐使用）
10.2.7.4、低级API(Low Level API)
kafka消费者低级API非常灵活；需要自己负责维护连接Controller Broker。保存offset，Consumer Partition对应 关系。由kafka创建一个topic维护offset，从broker选出一个leader维护topic
class SimpleConsumer {
/* Send fetch request to a broker and get back a set of messages. */
public ByteBufferMessageSet fetch(FetchRequest request);
/* Send a list of fetch requests to a broker and get back a response set. */ public MultiFetchResponse multifetch(List<FetchRequest> fetches);
/**
Get a list of valid offsets (up to maxSize) before the given time.
The result is a list of offsets, in descending order.
@param time: time in millisecs,
if set to OffsetRequest$.MODULE$.LATEST_TIME(), get from the latest
offset available. if set to OffsetRequest$.MODULE$.EARLIEST_TIME(), get from the earliest
available. public long[] getOffsetsBefore(String topic, int partition, long time, int maxNumOffsets);
\* offset
*/
说明：没有进行包装，所有的操作有用户决定，如自己的保存某一个分区下的记录，你当前消费到哪个位置。
10.3、kafka的log-存储机制
10.3.1、kafka中log日志目录及组成
kafka在我们指定的log.dir目录下，会创建一些文件夹；名字是【主题名字-分区名】所组成的文件夹。 在【主题名字-分区名】的目录下，会有两个文件存在，如下所示：
#索引文件
00000000000000000000.index
#日志内容
00000000000000000000.log
在目录下的文件，会根据log日志的大小进行切分，.log 文件的大小为 1G的时候，就会进行切分文件；
[外链图片转存失败(img-FYpSMICQ-1567779649710)(assets/wps57.png)]
在kafka的设计中，将offset值作为了文件名的一部分
比如：topic的名字为：test，有三个分区，生成的目录如下如下所示：
test-0
test-1
test-2
kafka日志的组成
segment file组成：由两个部分组成，分别为index file和data file，此两个文件一一对应且成对出现； 后缀.index和.log分别表示为segment的索引文件、数据文件。
segment文件命名规则：partion全局的第一个segment从0开始，后续每个segment文件名为上一个全局 partion的最大offset（偏移message数）。数值最大为64位long大小，19位数字字符长度，没有数字就用0 填充。
通过索引信息可以快速定位到message。通过index元数据全部映射到memory，可以避免segment file的IO磁盘操作；
通过索引文件稀疏存储，可以大幅降低index文件元数据占用空间大小。 稀疏索引：为了数据创建索引，但范围并不是为每一条创建，而是为某一个区间创建；
好处：就是可以减少索引值的数量。
不好的地方：找到索引区间之后，要得进行第二次处理。
10.3.2、kafka的offset查找过程
比如：要查找绝对offset为7的Message：
上图的左半部分是索引文件，里面存储的是一对一对的key-value，其中key是消息在数据文件（对应的log文件）中的编号，比如“1,3,6,8……”，
分别表示在log文件中的第1条消息、第3条消息、第6条消息、第8条消息……，那么为什么在index文件中这些编号不是连续的呢？
这是因为index文件中并没有为数据文件中的每条消息都建立索引，而是采用了稀疏存储的方式，每隔一定字节的数据建立一条索引。
这样避免了索引文件占用过多的空间，从而可以将索引文件保留在内存中。
但缺点是没有建立索引的Message也不能一次定位到其在数据文件的位置，从而需要做一次顺序扫描，但是这次顺序扫描的范围就很小了。
其中以索引文件中元数据3,4597为例，其中3代表在右边log数据文件中从上到下第3个消息(在全局partiton表示第4597个消息)，
其中4597表示该消息的物理偏移地址（位置）为4597。
10.3.3、kafka Message的物理结构及介绍
kafka Message的物理结构，如下图所示：
10.3.4、kafka中log CleanUp
kafka中清理日志的方式有两种：delete和compact。
删除的阈值有两种：过期的时间和分区内总日志大小。
在kafka中，因为数据是存储在本地磁盘中，并没有像hdfs的那样的分布式存储，就会产生磁盘空间不足的情 况，可以采用删除或者合并的方式来进行处理
可以通过时间来删除、合并：默认7天 还可以通过字节大小、合并
合并过程
相同的key，保存offset值大的（最新的消息记录）
| log.retention.hours | The number of hours to keep a log file before deleting it (in hours), tertiary to log.retention.ms property | int | 168 | high | read- only | |
|---|---|---|---|---|---|---|
| log.retention.minutes | The number of minutes to keep a log file before deleting it (in minutes), secondary to log.retention.ms property. If not set, the value in log.retention.hours is used | int | null | high | read- only | |
| log.retention.ms | The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used | long | null | high | cluster- wide | |
11、kafka消息不丢失机制
11.1、生产者生产数据不丢失
11.1.1、生产者数据不丢失过程图
说明：有多少个分区，就启动多少个线程来进行同步数据
11.1.2、发送数据方式
可以采用同步或者异步的方式-过程图
可以采用同步或者异步的方式
同步：发送一批数据给kafka后，等待kafka返回结果
1、生产者等待10s，如果broker没有给出ack相应，就认为失败。
2、生产者重试3次，如果还没有相应，就报错
异步：发送一批数据给kafka，只是提供一个回调函数。
1、先将数据保存在生产者端的buffer中。buffer大小是2万条
2、满足数据阈值或者数量阈值其中的一个条件就可以发送数据。
3、发送一批数据的大小是500条
说明：如果broker迟迟不给ack，而buffer又满了，开发者可以设置是否直接清空buffer中的数据。
11.1.3、ack机制（确认机制）
生产者数据不抵事，需要服务端返回一个确认码，即ack响应码；ack的响应有三个状态值
0：生产者只负责发送数据，不关心数据是否丢失，响应的状态码为0（丢失的数据，需要再次发送 ）
1：partition的leader收到数据，响应的状态码为1
-1：所有的从节点都收到数据，响应的状态码为-1
说明：如果broker端一直不给ack状态，producer永远不知道是否成功；producer可以设置一个超时时间10s，超 过时间认为失败。
11.2、kafka的broker中数据不丢失
在broker中，保证数据不丢失主要是通过副本因子（冗余），防止数据丢失
11.3、消费者消费数据不丢失
在消费者消费数据的时候，只要每个消费者记录好offset值即可，就能保证数据不丢失。
11、CAP理论以及kafka当中的CAP机制
11.1、分布式系统当中的CAP理论
分布式系统（distributed system）正变得越来越重要，大型网站几乎都是分布式的。
分布式系统的最大难点，就是各个节点的状态如何同步。
为了解决各个节点之间的状态同步问题，在1998年，由加州大学的计算机科学家 Eric Brewer 提出分布式系统的三个指标，分别是
Consistency：一致性
Availability：可用性
Partition tolerance：分区容错性
Eric Brewer 说，这三个指标不可能同时做到。这个结论就叫做 CAP 定理
11.2、Partition tolerance
先看 Partition tolerance，中文叫做"分区容错"。
大多数分布式系统都分布在多个子网络。每个子网络就叫做一个区（partition）。分区容错的意思是，区间通信可能失败。比如，一台服务器放在中国，另一台服务器放在美国，这就是两个区，它们之间可能无法通信。
上图中，G1 和 G2 是两台跨区的服务器。G1 向 G2 发送一条消息，G2 可能无法收到。系统设计的时候，必须考虑到这种情况。
一般来说，分区容错无法避免，因此可以认为 CAP 的 P 总是存在的。即永远可能存在分区容错这个问题
11.3、Consistency
Consistency 中文叫做"一致性"。意思是，写操作之后的读操作，必须返回该值。举例来说，某条记录是 v0，用户向 G1 发起一个写操作，将其改为 v1。
接下来，用户的读操作就会得到 v1。这就叫一致性。
问题是，用户有可能向 G2 发起读操作，由于 G2 的值没有发生变化，因此返回的是 v0。G1 和 G2 读操作的结果不一致，这就不满足一致性了。
为了让 G2 也能变为 v1，就要在 G1 写操作的时候，让 G1 向 G2 发送一条消息，要求 G2 也改成 v1。
这样的话，用户向 G2 发起读操作，也能得到 v1。
11.4、Availability
Availability 中文叫做"可用性"，意思是只要收到用户的请求，服务器就必须给出回应。
用户可以选择向 G1 或 G2 发起读操作。不管是哪台服务器，只要收到请求，就必须告诉用户，到底是 v0 还是 v1，否则就不满足可用性。
11.5、kafka当中的CAP应用
kafka是一个分布式的消息队列系统，既然是一个分布式的系统，那么就一定满足CAP定律，那么在kafka当中是如何遵循CAP定律的呢？kafka满足CAP定律当中的哪两个呢？
kafka满足的是CAP定律当中的CA，其中Partition tolerance通过的是一定的机制尽量的保证分区容错性。
其中C表示的是数据一致性。A表示数据可用性。
kafka首先将数据写入到不同的分区里面去，每个分区又可能有好多个副本，数据首先写入到leader分区里面去，读写的操作都是与leader分区进行通信，保证了数据的一致性原则，也就是满足了Consistency原则。然后kafka通过分区副本机制，来保证了kafka当中数据的可用性。但是也存在另外一个问题，就是副本分区当中的数据与leader当中的数据存在差别的问题如何解决，这个就是Partition tolerance的问题。
kafka为了解决Partition tolerance的问题，使用了ISR的同步策略，来尽最大可能减少
Partition tolerance的问题
每个leader会维护一个ISR（a set of in-sync replicas，基本同步）列表
ISR列表主要的作用就是决定哪些副本分区是可用的，也就是说可以将leader分区里面的数据同步到副本分区里面去，决定一个副本分区是否可用的条件有两个
· replica.lag.time.max.ms=10000 副本分区与主分区心跳时间延迟
· replica.lag.max.messages=4000 副本分区与主分区消息同步最大差
12、kafka in zookeeper
kafka在zookeeper中注册的图如下所示：
kafka集群中：包含了很多的broker，但是在这么的broker中也会有一个老大存在；是在kafka节点中的一个临时节 点，去创建相应的数据，这个老大就是 Controller Broker。
Controller Broker 职责：管理所有的broker。
扫一扫
1915
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
