Kafka的一些总结和心得

QuickyStart和概念

发布/订阅模式的消息队列

• Broker
  kafka集群中一个单独的节点，broker用来存储topic中的数据
  
  某个topic中N个partition 将会存储在N个broker上
  
  topic中N个partition，broker>N,partition将存储在N个broker上，剩下的broker不进行存储
  
  topic中N个partition，broker<N,partition进行存储，将会有broker中存储多个partition
• Topic
  生产者和消费者面向topic
  0.9版本后的offset存储在kafka内置的topic中 (__consumer_offsets)
• Partition
  一个 topic 可以分为多个 partition，每个 partition 是一个有序的队列
• Producer
  消息生产者，向kafka broker端发送消息的客户端
• Consumer
  消息消费者，向kafka broker端消费消息的客户端
• Consumer Group
  消费者组，多个consumer组成，一个分区只能被一个consumer消费，每个消费者消费不同分区的数据。
• Leader
  partition中的一个副本作为leader，生产者发送数据的对象，以及消费者消费数据的对 象
• Follower
  每个分区多个副本中的“从”，实时从 leader 中同步数据，保持和 leader 数据 的同步。leader 发生故障时，某个 follower 会成为新的 follower。
• Replica
  副本，保障kafka集群中某个几点挂掉，而不会导致partition的数据丢失

顺序读写，生产消息时，向partition对应的文件中追加数据，消费消息时由consumer来维护。
consumer消费消息时，kafka会根据该topic下consumer记录的offset，进行相应的消费。
consumer采取pull模式从broker中拉取数据

使用说明：

–topic 定义 topic 名
–replication-factor 定义副本数
–partitions 定义分区数

1. 解压安装kafka

tar -xzf kafka_2.13-2.8.0.tgz

2. 准备kafka环境

bin/zookeeper-server-start.sh config/zookeeper.properties
bin/kafka-server-start.sh config/server.properties

3. 创建一个topic来存储events

bin/kafka-topics.sh --create --zookeeper cluster01:2181 --replication-factor 3 --partitions 3 --topic topic2

bin/kafka-topics.sh --describe --topic quickstart-events --bootstrap-server localhost:9092

>Topic:quickstart-events  PartitionCount:1    ReplicationFactor:1 Configs:
    Topic: quickstart-events Partition: 0    Leader: 0   Replicas: 0 Isr: 0

4. 写一些events到topic里面

bin/kafka-console-producer.sh --broker-list cluster01:9092 --topic topic2

5. 读出events

bin/kafka-console-consumer.sh --topic quickstart-events --from-beginning --bootstrap-server localhost:9092

6. 修改分区数

  bin/kafka-topics.sh --zookeeper cluster01:2181 --alter --topic first --partitions 6

7. 删除topic

bin/kafka-topics.sh --zookeeper cluster01:2181 --delete --topic first

Kafka文件存储机制

topic 是逻辑上的概念，而 partition 是物理上的概念，每个 partition 对应于一个 log 文 件，该 log 文件中存储的就是 producer 生产的数据。Producer 生产的数据会被不断追加到该 log 文件末端，且每条数据都有自己的 offset。消费者组中的每个消费者，都会实时记录自己 消费到了哪个 offset，以便出错恢复时，从上次的位置继续消费。生产者生产的消息会不断追加到 log 文件末尾，为防止 log 文件过大导致数据定位 效率低下，Kafka 采取了分片和索引机制，将每个 partition 分为多个 segment。每个 segment 对应两个文件——“.index”文件和“.log”文件。这些文件位于一个文件夹下，该文件夹的命名 规则为：topic 名称+分区序号。

Kafka怎么保证数据可靠性？

为了保证Producer发送的数据能够可靠的到达topic中
topic中每个partition接收到数据后，将会向producer发送ack，如果接受到ack，将发送下一轮的数据，否则将重新发送。
当partition中全部的follower和leader同步完成后，才发送ack(0,1,all)。
假设partition中有一个follower出错，那么leader将一直等待其同步，lsr用来解决这个问题。
（ in-sync replica set）
可以理解为leader和其同步的follower的集合，当这个集合中的某个follower长时间没有和leader进行同步的时候，这个follower将会被t出集合，（这个时间replica.lag.time.max.ms 参数决定）
故障细节：
HW(high watermark) LEO(log end offset)
leader 123456
follower1 1234

API操作Kafka

Producer API

<dependency>
	<groupId>org.apache.kafka</groupId>
	<artifactId>kafka-clients</artifactId>
	<version>2.8.0</version>
</dependency>

KafkaProducer ：生产者对象，用来发送数据
ProducerConfig ：获取需要的配置参数
ProducerRecord ：每条数据要封装成一个ProducerRecord对象来发送

public class KafkaProducerTest {
    public static void main(String[] args) throws ExecutionException,InterruptedException {
        //创建配置信息
        Properties props = new Properties();
        //kafka集群，broker-list
        props.put("bootstrap.servers","cluster01:9092");
        //设置ack应答机制
        props.put("acks", "all");
        //重试次数
        props.put("retries", 1);
        //batch大小决定sender发送
        props.put("batch.size", 16384);
        //如果没有达到batch大小，达到linger.time发送数据
        props.put("linger.ms", 1);
        //缓冲区大小设置
        props.put("buffer.memory", 33554432);
        //k-v序列化
        props.put("key.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");
        //kafkaproducer 用来创建生产者对象，用来发送数据
        Producer<String, String> producer = new org.apache.kafka.clients.producer.KafkaProducer<>(props);
        for (int i = 0; i < 100; i++) {
            //每条数据需要封装成一个producerecord对象
            producer.send(new ProducerRecord<String, String>("first", Integer.toString(i), Integer.toString(i)));
        }
        producer.close();
    }
}

Consumer API

<dependency>
	<groupId>org.apache.kafka</groupId>
	<artifactId>kafka-clients</artifactId>
	<version>2.8.0</version>
</dependency>

public class KafkaConsumerTest {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "cluster01: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> consumer = new KafkaConsumer<>(props);
        //消费者订阅主题
        consumer.subscribe(Arrays.asList("first"));
        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());
        }

    }
}

Flume对接Kafka

1. 配置flume

# define
a1.sources = r1
a1.sinks = k1
a1.channels = c1
# source
a1.sources.r1.type = exec
a1.sources.r1.command = tail -F -c +0 /opt/module/data/flume.log
a1.sources.r1.shell = /bin/bash -c
# sink
a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.k1.kafka.bootstrap.servers = 
cluster01:9092,cluster02:9092,cluster03:9092
a1.sinks.k1.kafka.topic = first
a1.sinks.k1.kafka.flumeBatchSize = 20
a1.sinks.k1.kafka.producer.acks = 1
a1.sinks.k1.kafka.producer.linger.ms = 1
# channel
a1.channels.c1.type = memory
a1.channels.c1.capacity = 1000
a1.channels.c1.transactionCapacity = 100
# bind
a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1

2. 启动kafka消费者
3. 启动flume

bin/flume-ng agent -c conf/ -n a1 -f jobs/flume-kafka.conf

4. 向 /opt/module/data/flume.log 里追加数据，查看 kafka 消费者消费情况
   echo hello >> /opt/module/data/flume.log