0
0

kafka基础概念二

1.Kafka中主题和分区的概念

1.主题Topic

主题-topic在kafka中是一个逻辑的概念，kafka通过topic将消息进行分类。不同的topic会被订阅该topic的消费者消费

但是有一个问题，如果说这个topic中的消息非常非常多，多到需要几T来存，因为消息是会被保存到10g日志文件中的。为了解决这个文件过大的问题，kafka提出了Partition分区的概念

2.分区Partition

1）分区的概念

通过partition将一个topic中的消息分区来存储。这样的好处有多个:

  • 分区存储，可以解决统一存储文件过大的问题
  • 提供了读写的吞吐量:读和写可以同时在多个分区中进行在这里插入图片描述
2）创建多分区的主题
[root@k8s-master bin]# kafka-topics.sh --create --bootstrap-server 10.0.8.2:9092 --replication-factor 1 --partitions 2 --topic test1

分区的作用:

  • 可以分布式存储
  • 可以并行写

实际上是存在data/kafka-logs/test-0 和 test-1中的0000000.log文件中,且消费者定期将自己消费分区的ofset提交给kafka内部 topic

小细节:

  • 00000.og:这个文件中保存的就是消息
  • __consumer_offsets-49: kafka内部自己创建了_consumer_offsets主题包含了50个分区。这个主题用来存放消费者消费某个主题的偏移量。因为每个消费者都会自己维护着消费的主题的偏移量，也就是说每个消费者会把消费的主题的偏移量自主上报给kafka中的默认主题:__consumer_offsets。因此kafka为了提升这个主题的并发性，默认设置了50个分区。 提交到哪个分区:通过hash函数:hash(consumerGroupld)%consumer offsets主题的分区数。提交到该主题中的内容是:key是consumerGroupld+topic+分区号，value就是当前offset的值
  • 文件中保存的消息，默认保存7天。七天到后消息会被删除。

2.kafka集群操作

kafka集群搭建之前博客有介绍，且部署文档百度搜索很多，不过多赘述；

1.搭建kafka集群(三个broker)

创建三个server.properties文件.
#012
broker.id=2// 9092 9093 9094
listenerS=PLAINTEXT://192.168.65.60:9094//kafka-logs kafka-logs-l kafka-logs-2log.dir=/usr/local/data/kafka-logs-2
通过命令来启动三台broker.
kafka-server-start.sh-daemon  ../config/server.properties
kafka-server-start.sh-daemon  ../config/serverl.properties 
kafka-server-start.sh-daemon  ../config/server2.properties

校验是否启动成功
进入到zk中查看/brokers/ids中过是否有三个znode(0，1，2)

2. 副本的概念

在创建主题时，除了指明了主题的分区数以外，还指明了副本数，那么副本是一个什么概念呢?
副本是为了为主题中的分区创建多个备份，多个副本在kafka集群的多个broker中，会有一个副本作为leader，其他是follower。
在这里插入图片描述
在这里插入图片描述

  • leader: kafka的写和读的操作，都发生在leader上。leader负责把数据同步给folower。当leader挂了，经过主从选举，从多个follower中选举产生一个新的leader
  • follower 接收leader的同步的数据
  • isr: 可以同步和已同步的节点会被存入到isr集合中。这里有一个细节:如果isr中的节点性能较差，会被提出isr集合

此时，broker、主题、分区、副本 这些概念就全部展现了;
集群中有多个broker，创建主题时可以指明主题有多个分区(把消息拆分到不同的分区中存储)，可以为分区创建多个副本，不同的副本存放在不同的broker里。

3.关于集群消费

  • 向集群发送消息:
kafka-console-consumer.sh--bootstrap-server 172.16.253.38:9092,172.16.253.38:9093,172.16.253.38:9094--from-beginning --consumer-property group.id=testGroupl --topic my-replicated-topic
  • 从集群中消费消息
kafka-console-producer.sh--broker-list 172.16.253.38:9092,172.16.253.38:9093,172.16.253.38:9094--topicmy-replicated-topic
  • 指定消费组来消费消息
kafka-console-consumer.sh --bootstrap-server 172.16.253.38:9092,172.16.253.38:9093,172.16.253.38:9094--from-beginning  --consumer-property group.id=testGroup1 --topicmy-replicated-topic

分区分消费组的集群消费中的细节
在这里插入图片描述

  • 一个partition只能被一个消费组中的一个消费者消费，目的是为了保证消费的顺序性，但是多个partion的多个消费者消费的总的顺序性是得不到保证的，那怎么做到消费的总顺序性呢?
  • partition的数量决定了消费组中消费者的数量，建议同一个消费组中消费者的数量不要超过partition的数量，否则多的消费者消费不到消息
  • 如果消费者挂了，那么会触发rebalance机制(后面介绍)，会让其他消费者来消费该分区

3.kafka的java客户端-生产者的实现

1.生产者的基本实现

  • 引入依赖
<dependency><groupId>org.apache.kafka</groupId><artifactId>kafka-clients</artifactIdA
    <version>2.4.1</version></dependency>

具体实现

packagecom.qf.kafka;importorg.apache.kafka.clients.producer**importorg.apache.kafka.common.serialization.StringSerializer;importjava.util.Properties;importjava.util.concurrent.ExecutionExceptioon;publicclassMySimpleProducer{privatefinalstaticStringTOPIC_NAME="my-reeplicated-topic";publicstaticvoidmain(String[] args)throwsExecutiionException,InterruptedException//1.设置参数Properties props=newProperties();
    props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG"172.16.253.38:9092,172.16.253.38:9093,1722.16.253.38:9094");//把发送的key从字符串序列化为字节数组
    props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName())//把发送消息value从字符串序列化为字节数组
    props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());//2.创建生产消息的客户端,传入参数Producer<String,String> producer =newKafkaProducer<String,String>(props)//3.创建消息//key:作用是决定了往哪个分区上发,value:具体要发送的消息内容ProducerRecord<String,String> producerRecord =newProducerRecord<>(TOPIC_NAME,"mykeyvalue","hellokafka");//4.发送消息,得到消息发送的元数据并输出 --同步发送RecordMetadata metadata = producer.send(producerRecord).get()System.out.println("同步方式发送消息结果:"+" topiic-"+ metadata.topic()+"| partition-"+ metadata.partition()+"| offset-"+ metadata.offset())}）

2.生产者同步发消息

在这里插入图片描述
如果生产者发送消息没有收到ack,生产者会阻塞,阻塞到3s的时间,如果还没有收到消息,会进行重试。重试的次数3次。

RecordMetadata metadata = producer.send(producerRecord).get()System.out.println("同步方式发送消息结果: "+" topiic-"+ metadata.topic()+" |partition-"+ metadata.partition()+"|offset-"+ metadata.offset())

3.生产者的异步发送消息

异步发送,生产者发送完消息后就可以执行之后的业务,broker在收到消息后异步调用生产者提供的callback回调方法。
在这里插入图片描述

//5.异步发送消息
producer.send(producerRecord,newCallback(){publicvoidonCompletion(RecordMetadata metadata,Exception exception)if(exception !=null){System.err.println("发送消息失败:"+exception.getsStackTrace())；
        }if(metadata !=null){System.out.println("异步方式发送消息结果:    "+"topic-"+ metadata.topic()+" | partition-"metadata.partition()+"| offset-"+ metadata.offset());}}});

4.生产者中的ack的配置

在同步发送的前提下,生产者在获得集群返回的ack之前会一直阻塞。那么集群什么时候返回ack呢?此时ack有3个配置:

  • ack=0kafka-cluster不需要任何的broker收到消息,就立即返回ack给生产者,最容易丢消息的,效率是最高的
  • ack=1(默认):多副本之间的leader已经收到消息,并把消息写/入到本地的log中,才会返回ack给生产者,性能和安全性是最均衡的
  • ack=-1/all。里面有默认的配置min.insync.replicas=2(默认为1,推荐配置大于等于2),此时就需要leader和一个follower同步完后, 才会返回ack给生产者(此时集群中有2个broker已完成数据的接收),这种方式最安全,但性能最差。在这里插入图片描述

下面是关于ack和重试(如果没有收到ack,就开启重试)的配置

    props.put(ProducerConfig.ACKS_CONFIG,"1");/* 发送失败会重试,默认重试间隔100ms,重试能保证消息发送的可靠性,但是也可能造成消息重复发送,比如网络抖动,所以需要在
接收者那边做好消息接收的幂等性处理 */
    props.put(ProducerConfig.RETRIES_CONFIG,3);//重试间隔设置
    props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG,300);

5.关于消息发送的缓冲区

在这里插入图片描述

kafka默认会创建一个消息缓冲区,用来存放要发送的消息,缓冲区是32m

props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);

kafka本地线程会去缓冲区中一次拉16k的数据,发送到broker

props.put(ProducerConfig.BATCH_SIZE_CONFIG,161384)

如果线程拉不到16k的数据,间隔10ms也会将已拉到的数据发到到broker

props.put(ProducerConfig.LINGER_MS_CONFIG,10);

3.Java客户端消费者的实现细节

1.消费者的基本实现

importjava.time.Duration;importjava.util.Arrays;importjava.util.Properties;publicclassMySimpleConsumer{privatefinalstaticStringTOPIC_NAME="my-replicated-topic";privatefinalstaticStringCONSUMER_GROUP_NAME="testGroup";publicstaticvoidmain(String[] args){Properties props=newProperties();
    props.put (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"172.16.253.38:9092,172.16.253.38:9093,172.16.253.388:9094");//消费分组名
    props.put(ConsumerConfig.GROUP_ID_CONFIG,CONSUMER_GROUP_NAME);
    props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
    props.put (ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONPIG,SStringDeserializer.class.getName())//创建一个消费者的客户端KafkaConsumer<String,String> consumer =newKafkaconsumer<String,String>(props)//消费者订阅主题列表
    consumer.subscribe (Arrays.asList(TOPIC_NAME));while(true){/*
         *poll()API是拉取消息的长轮询
        */ConsumerRecords<String,String> records = coonsumer.poll(Duration.ofMillis(1000))for(ConsumerRecord<String,String>record:records){System.out.printf("收到消息:partition= %d, offset = %d, key = is, value = %s%n", record.partition(),
        record.offset(),record.key(), record.value())}}}

在这里插入图片描述

2.关于消费者自动提交和手动提交offset

1) 提交的内容

消费者无论是自动提交还是手动提交,都需要把所属的消费组消费的某个主题+消费的某个分区及消费的偏移量,这样的信息是交到集群的_consumer_offsets主题里面。

2) 自动提交

消费者poll消息下来以后就会自动提交offset

// 是否自动提交offset,默认就是true
props.put (ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");//自动提交offset的间隔时间
props.put (ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");
3) 手动提交

需要把自动提交的配置改成false

props.put (ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false")

手动提交又分成了两种:
在这里插入图片描述

  • 手动同步提交 在消费完消息后调用同步提交的方法,当集群返回ack前一直阻塞,返回ack后表示提交成功,执行之后的逻辑
while(true){/*
    *poll()API是拉取消息的长轮询
    */ConsumerRecords<String,String> records = consumer.poll(Duration.ofMillis(1000))for(ConsumerRecord<String,String> record : records){System.out.printf("收到消息:partition=1d,offset=td,key = ts,value = ts@n",
        record.partition(),record.offset(),record.key(),record.value())；
    }//所有的消息已消费完if(records.count()>0){//有消息//手动同步提交offset,当前线程会阻塞直到offset提交房成功//一般使用同步提交,因为提交之后一般也没有什么逻辑代码了
        consumer.commitSync();//==========提交成功}}}
  • 异步提交
while(true){/*
    *poll()API是拉取消息的长轮询
    */ConsumerRecords<String,String> records = consumer.poll(Duration.ofMillis(1000))for(ConsumerRecord<String,String> record : records){System.out.printf("收到消息:partition = %d,offset = %d,key = %s,value = %s%n",
        record.partition(),record.offset(),record.key(),record.value())；
    }//所有的消息已消费完if(records.count()>0){//手动异步提交offset,当前线程提交offset不会阻塞,可以继续处理后面的程序逻辑
    consumer.commitAsync(newOffsetCommitCallback(){@OverridepublicvoidonComplete(Map<TopicPartition,OffsetAndMetadata> offsets,Exception exception){if(exception!=null){System.err.println("Commit failed for "+ offsets);System.err.println("Commit failed exception: "+ exception.getStackTrace())}}}
3.长轮询poll消息

默认情况下,消费者一次会poll500条消息。
//一次pol1最大拉取消息的条数,可以根据消费速度的快慢来设置

props.put (ConsumerConfig.MAX_POLL_RECORDS_COMNFIG,500);

代码中设置了长轮询的时间是1000毫秒

while(true){*poll()API是拉取消息的长轮询
    ConsumerRecords<String,String> records = consumer.poll(Duration.ofMillis(1000))for(ConsumerRecord<String,String> record : records)System.out.printf("收到消息:partition= %d,offset= %d, key = %s, value = %s%n", record.partition(),
        record.offset(),record.key(), record.vaalue())}

意味着：1秒内拉到500条就循环去消费,1秒内如果没拉到500条时间到了也直接循环消费；

    • 如果一次poll到500条,就直接执行for循环- 如果这一次没有poll到500条。且时间在1秒内,那么长轮询继续poll,要么到500条,要么到1s- 如果多次poll都没达到500条,且1秒时间到了,那么直接执行for循环
  • 如果两次poll的间隔超过30s,集群会认为该消费者的消费能力过弱,该消费者被踢出消费组,(意思是第一次拉取后执行for循环，消费结束后，再执行whilex循环poll拉取时，这期间执行的时间超过了30s) 触发rebalance机制,rebalance机制 会造成性能开销。可以通过设置这个参数,让一次poll的消息条数少一点。
//一次poll最大拉取消息的条数,可以根据消费速度的快慢来设置 
props.put(ConsumerConfig.MAX_POLL_RECORDS_CODNFIG,500)//如果两次pol1的时间如果超出了30s的时间间隔,kafka会认为其消费能力过弱,将其踢出消费组。将分区分配给其他消费者。-rebalance
props.put(ConsumerConfig.MAX_POLL_INTERVAL_MIS_CONFIG,30*1000);
4.消费者的健康状态检查

消费者每隔1s向kafka集群发送心跳,集群发现如果有超过10s没有续约的消费者,将被踢出消费组,触发该消费组的rebalance机制,将
该分区交给消费组里的其他消费者进行消费。

//consumer给broker发送心跳的间隔时间
props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MSS_CONFIG,1000);//kafka如果超过10秒没有收到消费者的心跳,则会把消费者踢出消费组,进行rebalance,把分区分配给其他消费者。
props.put(ConsumerConfig.SESSION_TIMEOUT_MS_COONFIG,10*1000);
5.指定分区和偏移量、时间消费

指定分区消费

consumer.assign (Arrays.asList(newTopicPartition(TOPIC_NAME,0)))

从头消费

consumer.assign(Arrays.asList(newTopicPartition(TOPIC_NAME,0)))
consumer.seekToBeginning (Arrays.asList(newTopicPartition(TOPIC_NAME,0)))

指定offset消费

consumer.assign(Arrays.asList(newTopicPartition(TOPIC_NAME,0)))
consumer.seek(newTopicPartition(TOPIC_NAME2,0),10)

指定时间消费
根据时间,去所有的partition中确定该时间对应的offset,然后去去所有的partition中找到该offset之后的消息开始消费

List<PartitionInfo> topicPartitions = consumer.partitionsFor (TOPIC_NAME);//从1小时前开始消费long fetchDataTime =newDate().getTime()-1000*60*60Map<TopicPartition,Long> map =newHashMap<>())for(PartitionInfo par : topicPartitions){
        map.put(newTopicPartition(TOPIC_NAME, par.par.pairtition()), fetchDataTime);}Map<TopicPartition,OffsetAndTimestamp> parMapp = consumer.offsetsForTimes(map);for(Map.Entry<TopicPartition,OffsetAndTimestcamp>entry:parMap.entrySet()){TopicPartition key = entry.getkey();OffsetAndTimestamp value = entry.getValue();if(key ==null|| value =null)continue;Long offset = value.offset();System.out.println("partition-"+ key.partitieon()+"|offset-"+ offset);System.out.println();//根据消费里的timestamp确定offsetif(value!=null){
            consumer.assign(Arrays.asList(key));
            consumer.seek(key,offset);}}
6.新消费组的消费offset规则

新消费组中的消费者在启动以后,默认会从当前分区的最后一条消息的offset+1开始消费(消费新消息)。可以通过以下的为设置,让新的消费者第一次从头开始消费。之后开始消费新消息(最后消费的位置的偏移量+1)

  • Latest:默认的,消费新消息
  • earliest:
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");
标签： kafka 分布式
本文转载自: https://blog.csdn.net/wyl9527/article/details/140730067
版权归原作者 wyl9527 所有， 如有侵权，请联系我们删除。
登录后发布评论

“kafka基础概念二”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

ELK 8.15.3 版本Logstash和Kibana与KS配置SSL实现https安全连接

服务攻防之开发组件安全

ubuntu设置共享文件夹

在 Spring 中编写单元测试

【The Art of Unit Testing 3_自学笔记04】第二章：编写第一个单元测试（下）

git submodule update --init --recursive 解读

Git的基本使用入门

文章导航