kafka笔记

kafka

启动kafka：kafka-server-start.sh -daemon $KAFKA_HOME/config/server.properties
停止：kafka-server-stop.sh
官网：kafka.apache.org
kafka:
1.distributed event streaming platform kafka是一个流式 分布式平台
2.构建 实时的数据通道 、流式数据分析、流式的app
1.版本：
1.apache
2.cdk
2.版本选择：
1.稳定版本即可 可以选择最新版本【bug就是多】
2.根据 Sparkstreaming 来选择kafka的版本 ！！！！
1.spark对接kafka 的最低版本 0.10版本 【spark 3.x版本】
2.【spark 2.x版本】
kafka:
0.10
0.11
0.11之后的版本
3.版本选择
建议 kafka 2.2.1 或者 最新版
kafka的特性：
1.HIGH THROUGHPUT 高吞吐量
2.SCALABLE 高扩展性
3.PERMANENT STORAGE 数据过期时间
4.HIGH AVAILABILITY 高可用
kafka特点
1.发布&订阅
2. store 存储
3. process 处理 ：
1.kafka后面接一个 实时计算的框架 ： spark/flink 正确使用
2. kafkaStreaming 组件 【不要使用】
kafka的架构
生产者(producer)：消息发送端
event：表示 produce 发送的一条数据
broker：kafka集群里面某一个节点
消费者(consumer)：消息消费端
1.topic 主题
1.负责存储events
2.消息订阅和发送基于topic
消息订阅 ：
消费者 订阅topic：即可以消费topic里面存储的数据
消息发送：
生产者 往指定topic发送数据
3.kafka中可以有多个topic
2.topic：
partition:分区
1.一个topic可 以有多个partition
2.每个partition是一个有序的队列 =》单分区有序
3.partition linux上的文件夹

kafka shell命令

1.查看kafka的topic

kafka-topics.sh \
--list \
--zookeeper bigdata12:2181/kafka

2.创建topic

kafka-topics.sh \
--create \
--zookeeper bigdata12:2181/kafka \
--topic dl2262 \
--partitions 3 \
--replication-factor 1

partition的随便指定
replication-factor topic的副本数 小于等于 broker数量
副本 =》 容错
3.查看详细的topic

kafka-topics.sh \
--describe \
--zookeeper bigdata12:2181/kafka \
--topic dl2262

第一行： topic总体情况：topic名字、分区数量、副本数量
Partition：分区号
Leader、Replicas、Isr：kafka 机器broker 对应的编号
Leader 1：该分区 负责对外读写的节点编号
Replicas：当前分区副本都在哪些机器上
Isr：负责对外提供读写请求的 leader顺序
4.删除topic： 【生产上不要删除 topic】

kafka-topics.sh \
--delete \
--zookeeper bigdata12:2181/kafka \
--topic dl2262

topic:
linux磁盘数据
元数据 zookeeper里面的
5.修改topic： 【不要做】

kafka-topics.sh \
--alter \
--zookeeper bigdata12:2181/kafka \
--topic dl2262 \
--partitions 4 \
--replication-factor 3

6.生产数据

kafka-console-producer.sh \
--broker-list bigdata12:9092 \
--topic dl2262

kafka-console-producer.sh \
kafka地址
--broker-list bigdata12:9092 \
往哪个topic发送数据
--topic dl2262

7.消费数据

kafka-console-consumer.sh \
--bootstrap-server bigdata12:9092 \
--topic dl2262 \
--from-beginning

kafka-console-consumer.sh \
kafka地址
--bootstrap-server bigdata12:9092 \
朝哪个topic消费数据
--topic dl2262 \
从头开始消费
--from-beginning

java代码实现生产和消费

生产者：

static Logger logger = LoggerFactory.getLogger(ProduceAPP.class);
    public static void main(String[] args) {

        // 配置kafka信息
        Properties props = new Properties();
        props.put("bootstrap.servers", "bigdata12:9092");// kafka地址
        props.put("acks", "all");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // 发送数据到kafka topic:dl2262
        Producer<String, String> producer = new KafkaProducer<>(props);
        for (int i = 0; i < 9; i++) {
            logger.warn("mes:{}",i);
            // key是分区号 value是真正要发送的数据
            int partition = new Random().nextInt(3);
            producer.send(new ProducerRecord<>("dl2262",partition+"" ,i+""));
        }
        producer.close();
       }

消费者：

Properties props = new Properties();
        props.setProperty("bootstrap.servers", "bigdata12:9092");
        props.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "test");
        props.setProperty("enable.auto.commit", "true");
        props.setProperty("auto.commit.interval.ms", "1000");//提交offset时间
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");
        props.setProperty(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG,"30000");//延时时间
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        // 订阅topic
        // consumer.subscribe(Arrays.asList("d1","d2"));
        consumer.subscribe(Collections.singletonList("dl2262"));
        // 消费数据
        while (true){
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));//每隔一秒消费一次数据
            Iterator<ConsumerRecord<String, String>> iterator = records.iterator();
            while (iterator.hasNext()){
                ConsumerRecord<String, String> record = iterator.next();
                Thread.sleep(1000);
                System.out.println("partition"+record.partition()+", "+"offset"+record.offset()+", "+"value"+record.value());
            }
        }

消费者与消费者组

消费者消费kafka里面的数据 是以 消费者组的方式进行消费
consumer group: 消费者组
1.一个组内 共享一个消费者组的id 【group id】
2.组内的所有消费者协调在一起去消费指定的topic的所有分区数据：
“每个分区只能由一个消费者组的一个消费者来消费”
绝对不会出现一个分区被一个消费者组的多个消费者进行重复消费
对接kafka常见的消费者：
1.ss、sss、flume、flink
2.java代码
生产上：
一般都是一个消费者+一个消费者组
即：一个消费者组 就一个消费者 可以消费全部分区数据
超大公司：
会用到消费者组 不同消费者 处理不同分区数据 【很少见】

kafka数据存储

一个partition：下面存储就是数据，一段一段相同大小的segment文件
segment：逻辑概念 log.segment.bytes------segment默认大小，segment包括：
log文件 【kafka topic里面的数据+event 元数据】 默认大小
:log.segment.bytes=1073741824 1G
index文件 【索引文件，维护是log文件内 大部分数据的位置信息】
segment命名规则：
1.parititon的全局的第一个segment 编号从0开始的
2.后续的segment名称 是上一个segment文件的最后一条消息的【offset值+1】 来表示
offset:偏移量 =》 event 编号 存储在topic下的编号
指 该条数据在partition的位置 从0开始
log文件 【kafka topic里面的数据+event 元数据】 默认大小
index文件 【索引文件，维护是log文件内 大部分数据的位置信息】
-rw-rw-r–. 1 hadoop hadoop 2008 Dec 22 03:12 00000000000000000000.index
-rw-rw-r–. 1 hadoop hadoop 1048550 Dec 22 03:12 00000000000000000000.log

kafka-run-class.sh \
kafka.tools.DumpLogSegments \
--files /home/hadoop/data/kafka/bigdata-0/00000000000000000000.log \
--print-data-log \
> 0.log

kafka-run-class.sh \
kafka.tools.DumpLogSegments \
--files /home/hadoop/data/kafka/bigdata-0/00000000000000000000.index \
--print-data-log \
> 0.index

index:
offset: 47 position: 4174
offset: 94 position: 8357
offset: 140 position: 12492
offset: 186 position: 16632
offset: 232 position: 20772
1.维护partition的消息对应offset信息和物理地址
2.稀疏表的方式维护的，并不是每一个消息的offset和物理地址都维护

如何查找 offset 为 11865的数据 ，简述过程？

-rw-rw-r–. 1 hadoop hadoop 2008 Dec 22 03:12 00000000000000000000.index
-rw-rw-r–. 1 hadoop hadoop 1048550 Dec 22 03:12 00000000000000000000.log

-rw-rw-r–. 1 hadoop hadoop 2024 Dec 22 03:12 00000000000000011518.index
-rw-rw-r–. 1 hadoop hadoop 1048524 Dec 22 03:12 00000000000000011518.log

-rw-rw-r–. 1 hadoop hadoop 10485760 Dec 22 03:12 00000000000000022915.index
-rw-rw-r–. 1 hadoop hadoop 651820 Dec 22 03:12 00000000000000022915.log

11518.index：
offset: 11750 position: 158143
offset: 11796 position: 162329
offset: 11842 position: 166515
offset: 11900 position: 166515
1.【二分查找】 <= offset 为 11865 的最大segment文件组 =》11518组
2.去11518.index 文件 【二分查找】<= offset 为 11865 最大的offset
=》offset: 11842 =>position: 166515 物理地址
3.根据166515 物理地址 去信息定位 这个位置，按顺序查找 一直找到 offset为11865的数据

交付语义 ： 生产者/消费者

At most once： Messages may be lost but are never redelivered.
At least once：Messages are never lost but may be redelivered.
Exactly once：this is what people actually want, each message is delivered once and only once.
至多一次：消息会丢失，不会重复发送/消费
至少一次：消息不会丢失 重复发送/消费
精准一次：消息不会丢失 不会重复发送/消费 完美的
produder：
1.kafka 0.11.0之前版本 采用至少一次 会导致重复数据
2.kafka 0.11.0之后包括 采用精准一次 发送数据

0.11.0之前版本：
1 2 3 4 5
3 挂了

producer =》 kafka
0.发送1 2 数据ok offset信息 也ok 记录到kafka
1.发送数据3 producer 程序挂了 offset信息 没有记录
2.程序重启 ：
producer 程序 会继续从 3 这个数据 接着发送数据 =》 导致 kafka 有重复数据

0.11.0之后版本：
1 2 3 4 5
3 挂了
精准一次【事务，数据+ offset】
0.发送1 2 数据ok offset信息 也ok 记录到kafka
1.发送数据3 producer 程序挂了 offset信息 没有记录 事务 3写入的数据 标记清除
2.程序重启 ：
producer 程序 会继续从 3 这个数据 接着发送数据 =》kafka没有重复数据
kafka版本：
首选 kafka 版本 一定要大于等于0.11.0版本
精准一次【事务，数据+ offset】
0.发送1 2 数据ok offset信息 也ok 记录到kafka
1.发送数据3 producer 程序挂了 offset信息 没有记录 事务 3写入的数据 标记清除
2.程序重启 ：
producer 程序 会继续从 3 这个数据 接着发送数据 =》kafka没有重复数据
kafka版本：
首选 kafka 版本 一定要大于等于0.11.0版本
至少一次：
1 2 3 4 5
1.consumer 消费 3 offset 信息也提交了
consumser挂了
启动consumer
从4继续消费=》
消费5 处理完了 offset 没有提交
程序挂了=》
重启程序=》
从5开始消费数据
数据重复消费 重复处理
精准一次：
事务
数据消费 + offset提交
sparkstreaming/struedstreaming/flink ： 消费 交付语义选择：
1.至少一次 =》 可能有数据消费重复问题 [90%] code 简单
2.精准一次 =》 完美的 【开发起来太麻烦了 】

sparkstreaming

sparkstreaming：【了解】
offset信息如何维护？
1.Checkpoints 【生产上，不能用 问题】
1.offset 信息 =》 hdfs 会有小文件问题
2.代码发生变更 spark项目就不能用了 之前记录的Checkpoints 信息就失效了
2.Kafka itself 【推荐】
【至少一次】 代码简单 不需要用户自己开发 维护offset信息的代码
3.Your own data store 【外部数据源存储 offset】
redis、mysql、hbase 事务的
10s发送一次请求 存储数据
【精准一次】
code

副本与数据同步

8个节点
1个分区 1个副本
8个分区 1副本
leader 与 follower：
leader： 该分区负责对外读写的节点
follower：负责拉取leader分区数据 进行数据备份
机制：
ack 消息发送确认机制 【producer】
all, -1, 0, 1
1.ack =1 producer 发送数据 只要一个分区副本成功写入的通知 就认为推送消息成功
2.ack =-1 producer 发送数据 producer收到所有分区副本写入成功的通知才任务推送消息成功
3.ack=0 producer 发送一次数据即可 不管是否发送成功
all => -1
选择：
1. 0 不要选择
2. 1 选择这个【其次】
3. all 建议【安全】

kafka监控

kafka监控：
1.kafka manager [首选 ]： 二开 【了解】
https://github.com/yahoo/CMAK
按量计费
2.kafka eagle =》 也好用 【low 一点点 】 用起来简单
部署简单 简单好用
http://www.kafka-eagle.org/
https://github.com/smartloli/EFAK
需求：1.flume:netcat采集数据到kafka上消费

a1.sources = r1
a1.sinks = k1
a1.channels = c1

a1.sources.r1.type = netcat
a1.sources.r1.bind = localhost
a1.sources.r1.port = 44444

a1.channels.c1.type = memory

a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.k1.kafka.topic = dl2262
a1.sinks.k1.kafka.bootstrap.servers = bigdata12:9092
a1.sinks.k1.kafka.flumeBatchSize = 20
a1.sinks.k1.kafka.producer.acks = 1
a1.sinks.k1.kafka.producer.linger.ms = 1
a1.sinks.k1.kafka.producer.compression.type = snappy

a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1

flume-ng agent \
--name a1 \
--conf ${FLUME_HOME}/conf \
--conf-file /home/hadoop/project/flume/nc-mem-kafka.conf \
-Dflume.root.logger=info,console

telnet localhost 44444

kafka-console-consumer.sh \
--bootstrap-server bigdata12:9092 \
--topic dl2262 \
--from-beginning

2.用flume采集kafka数据到hdfs/logger

a1.sources = r1
a1.sinks = k1
a1.channels = c1

a1.sources.r1.type = org.apache.flume.source.kafka.KafkaSource
a1.sources.r1.batchSize = 5000
a1.sources.r1.batchDurationMillis = 2000
a1.sources.r1.kafka.bootstrap.servers = bigdata12:9092
a1.sources.r1.kafka.topics = dl2262
a1.sources.r1.kafka.consumer.group.id = b1

a1.channels.c1.type = memory

a1.sinks.k1.type = hdfs
a1.sinks.k1.hdfs.path = hdfs://bigdata12:9000/flume/kafka/
a1.sinks.k1.hdfs.fileType=DataStream
a1.sinks.k1.hdfs.writeFormat=Text
a1.sinks.k1.hdfs.filePrefix=events
a1.sinks.k1.hdfs.fileSuffix=.log
a1.sinks.k1.hdfs.useLocalTimeStamp=true
a1.sinks.k1.hdfs.rollInterval=60
a1.sinks.k1.hdfs.rollSize=134217728
a1.sinks.k1.hdfs.rollCount=100

a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1

flume-ng agent \
--name a1 \
--conf ${FLUME_HOME}/conf \
--conf-file /home/hadoop/project/flume/kafka-mem-hdfs.conf \
-Dflume.root.logger=info,console