分布式消息队列框架kafka的入门学习

一 kafka的介绍

Apache Kafka是一个开源消息系统，是由Apache软件基金会开发的一个开源消息系统项目。kafka是linkedin公司开源捐献给apache的一个消息队列的框架，底层语言用的是scala。Kafka是一个分布式消息队列：生产者、消费者的功能。它提供了类似于JMS的特性，但是在设计实现上完全不同，此外它并不是JMS规范的实例，Kafka对消息保存时根据Topic进行归类，发送消息者称为Producer,消息接受者称为Consumer,此外kafka集群有多个kafka实例组成，每个实例(server)成为broker。无论是kafka集群，还是producer和consumer都依赖于zookeeper集群保存一些meta信息，来保证系统可用性。

二 消息队列的核心作用：

解耦，异步和并行

三 kafka与传统的JMS（activeMQ）的区别：

1、  activeMQ是一个标准的JMS的实现，kafka不是的
2、  activeMQ当中的消费者，订阅某一类主题之后，等着服务端把消息给推送过来，kafka当中是消费者主动去拉取消息。
3、  activeMQ当中可以有事务的保证，kakfa当中没有
4、  activeMQ当中的消息消费完了就没了，kafka当中的消息都是保存在磁盘当
5、  kafka当中采用的是zookeeper保存一些topic，以及一些其他的元数据信息

四 kafka的架构模型以及组件介绍

producer：生产者，主要用于消息的生产，消息可以从flume当中来，可以从ftp推送过来，可以通过javaAPI直接生成等

topic：kafka当中的主题，与activeMQ当中的topic的功能类似，也是某一类消息高度抽象的一个集合，说白了topic里面就是装各种各样的消息

broker：就是我们一台台的服务器，在kafka当中，一台服务器就是一个broker

partition：分区，kafka当中一个topic可以有多个分区，每个分区里面保存一部分topic的数据，为了解决某个partitiond数据的单点故障问题，引入了副本机制，每个paritition可以有多个副本，这样就保证了数据不会丢失

segment文件：每个paritition里面有多个segment文件，这些segment文件就是保存了我们的数据信息，一个segment由两个文件组成，一个是.log文件，一个是.index文件

.log文件：主要保存了我们各种各样的数据
.index文件：索引数据 ，索引了.log文件里面的数据在哪里，查找数据的时候，先查找.index文件，找到对应数据的索引之后，直接去.log文件里面获取即可，这样会比较快

zookeeper集群：记录了kafka里面所有topic的一些元数据信息，例如topic的名字，topic的分区数，副本数，分区在哪些机器上，副本在哪些机器上

consumer：消费者，主动去拉取消息，通过zk可以找到我们需要的数据的元数据信息，然后通过这些元数据信息，去找我们对应的数即可。

五 kafka的配置文件详解

server.properties的配置说明

#broker的全局唯一编号，不能重复
broker.id=0

#用来监听链接的端口，producer或consumer将在此端口建立连接
port=9092

#处理网络请求的线程数量
num.network.threads=3

#用来处理磁盘IO的线程数量
num.io.threads=8

#发送套接字的缓冲区大小
socket.send.buffer.bytes=102400

#接受套接字的缓冲区大小
socket.receive.buffer.bytes=102400

#请求套接字的缓冲区大小
socket.request.max.bytes=104857600

#kafka运行日志存放的路径，根据我们的磁盘路径来定，多个磁盘用逗号隔开
log.dirs=/export/data/kafka/

#topic在当前broker上的分片个数，分区的数量值，一般都需要我们在创建topic的时候手动指定，覆盖这个配置
num.partitions=2

#用来恢复和清理data下数据的线程数量
num.recovery.threads.per.data.dir=1

#segment文件保留的最长时间，超时将被删除
log.retention.hours=1

#滚动生成新的segment文件的最大时间
log.roll.hours=1

#日志文件中每个segment的大小，默认为1G
log.segment.bytes=1073741824

#周期性检查文件大小的时间
log.retention.check.interval.ms=300000

#日志清理是否打开
log.cleaner.enable=true

#broker需要使用zookeeper保存meta数据
zookeeper.connect=zk01:2181,zk02:2181,zk03:2181

#zookeeper链接超时时间
zookeeper.connection.timeout.ms=6000

#partion buffer中，消息的条数达到阈值，将触发flush到磁盘
log.flush.interval.messages=10000

#消息buffer的时间，达到阈值，将触发flush到磁盘
log.flush.interval.ms=3000

#删除topic需要server.properties中设置delete.topic.enable=true否则只是标记删除
delete.topic.enable=true

#此处的host.name为本机IP(重要),如果不改,则客户端会抛出:Producer connection to localhost:9092 unsuccessful 错误!
host.name=kafka01
#如果我们需要通过公网连接我们的kafka的时候，才需要配置这个，一般我们的kafka不会放在公网里面
advertised.host.name=192.168.140.128

生产者配置文件说明

#指定kafka节点列表，用于获取metadata，不必全部指定
metadata.broker.list=node01:9092,node02:9092,node03:9092
# 指定分区处理类。默认kafka.producer.DefaultPartitioner，表通过key哈希到对应分区
#partitioner.class=kafka.producer.DefaultPartitioner
# 是否压缩，默认0表示不压缩，1表示用gzip压缩，2表示用snappy压缩。压缩后消息中会有头来指明消息压缩类型，故在消费者端消息解压是透明的无需指定。
compression.codec=none
# 指定序列化处理类
serializer.class=kafka.serializer.DefaultEncoder
# 如果要压缩消息，这里指定哪些topic要压缩消息，默认empty，表示不压缩。
#compressed.topics=

# 设置发送数据是否需要服务端的反馈,有三个值0,1,-1
# 0: producer不会等待broker发送ack 
# 1: 当leader接收到消息之后发送ack 
# -1: 当所有的follower都同步消息成功后发送ack. 
request.required.acks=1

# 在向producer发送ack之前,broker允许等待的最大时间 ，如果超时,broker将会向producer发送一个error ACK.意味着上一次消息因为某种原因未能成功(比如follower未能同步成功) 
request.timeout.ms=10000

# 同步还是异步发送消息，默认“sync”表同步，"async"表异步。异步可以提高发送吞吐量,
也意味着消息将会在本地buffer中,并适时批量发送，但是也可能导致丢失未发送过去的消息
producer.type=async

# 在async模式下,当message被缓存的时间超过此值后,将会批量发送给broker,默认为5000ms
# 此值和batch.num.messages协同工作.
queue.buffering.max.ms = 5000

# 在async模式下,producer端允许buffer的最大消息量
# 无论如何,producer都无法尽快的将消息发送给broker,从而导致消息在producer端大量沉积
# 此时,如果消息的条数达到阀值,将会导致producer端阻塞或者消息被抛弃，默认为10000
queue.buffering.max.messages=20000

# 如果是异步，指定每次批量发送数据量，默认为200
batch.num.messages=500

# 当消息在producer端沉积的条数达到"queue.buffering.max.meesages"后 
# 阻塞一定时间后,队列仍然没有enqueue(producer仍然没有发送出任何消息) 
# 此时producer可以继续阻塞或者将消息抛弃,此timeout值用于控制"阻塞"的时间 
# -1: 无阻塞超时限制,消息不会被抛弃 
# 0:立即清空队列,消息被抛弃 
queue.enqueue.timeout.ms=-1


# 当producer接收到error ACK,或者没有接收到ACK时,允许消息重发的次数 
# 因为broker并没有完整的机制来避免消息重复,所以当网络异常时(比如ACK丢失) 
# 有可能导致broker接收到重复的消息,默认值为3.
message.send.max.retries=3

# producer刷新topic metada的时间间隔,producer需要知道partition leader的位置,以及当前topic的情况 
# 因此producer需要一个机制来获取最新的metadata,当producer遇到特定错误时,将会立即刷新 
# (比如topic失效,partition丢失,leader失效等),此外也可以通过此参数来配置额外的刷新机制，默认值600000 
topic.metadata.refresh.interval.ms=60000

消费者配置文件说明

# zookeeper连接服务器地址
zookeeper.connect=zk01:2181,zk02:2181,zk03:2181
# zookeeper的session过期时间，默认5000ms，用于检测消费者是否挂掉
zookeeper.session.timeout.ms=5000
#当消费者挂掉，其他消费者要等该指定时间才能检查到并且触发重新负载均衡
zookeeper.connection.timeout.ms=10000
# 指定多久消费者更新offset到zookeeper中。注意offset更新时基于time而不是每次获得的消息。一旦在更新zookeeper发生异常并重启，将可能拿到已拿到过的消息
zookeeper.sync.time.ms=2000
#指定消费 
group.id=itcast
# 当consumer消费一定量的消息之后,将会自动向zookeeper提交offset信息 
# 注意offset信息并不是每消费一次消息就向zk提交一次,而是现在本地保存(内存),并定期提交,默认为true
auto.commit.enable=true
# 自动更新时间。默认60 * 1000
auto.commit.interval.ms=1000
# 当前consumer的标识,可以设定,也可以有系统生成,主要用来跟踪消息消费情况,便于观察
conusmer.id=xxx 
# 消费者客户端编号，用于区分不同客户端，默认客户端程序自动产生
client.id=xxxx
# 最大取多少块缓存到消费者(默认10)
queued.max.message.chunks=50
# 当有新的consumer加入到group时,将会reblance,此后将会有partitions的消费端迁移到新  的consumer上,如果一个consumer获得了某个partition的消费权限,那么它将会向zk注册 "Partition Owner registry"节点信息,但是有可能此时旧的consumer尚没有释放此节点, 此值用于控制,注册节点的重试次数. 
rebalance.max.retries=5

# 获取消息的最大尺寸,broker不会像consumer输出大于此值的消息chunk 每次feth将得到多条消息,此值为总大小,提升此值,将会消耗更多的consumer端内存
fetch.min.bytes=6553600

# 当消息的尺寸不足时,server阻塞的时间,如果超时,消息将立即发送给consumer
fetch.wait.max.ms=5000
socket.receive.buffer.bytes=655360
# 如果zookeeper没有offset值或offset值超出范围。那么就给个初始的offset。有smallest、largest、anything可选，分别表示给当前最小的offset、当前最大的offset、抛异常。默认largest
auto.offset.reset=smallest
# 指定序列化处理类
derializer.class=kafka.serializer.DefaultDecoder

* kafka的安装*

在这里我的集群有三台虚拟机，三台虚拟机的主机名分别node01,node02,node03

1 ，集群中每台服务器安装zookeeper(集群中的服务器要进行时钟同步)
2，在第一台服务器上上传kafka的软件包，并解压到指定的目录

cd  /export/softwares
tar -zxvf kafka_2.11-1.0.0.tgz  -C ../servers/

3 在第一台服务器上更改kafka的配置文件

cd /export/servers/kafka_2.11-1.0.0/config
vim  server.properties

第一台机器更改server.properties

broker.id=0
num.network.threads=3
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
log.dirs=/export/servers/kafka_2.11-1.0.0/logs
num.partitions=2
num.recovery.threads.per.data.dir=1
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
log.flush.interval.messages=10000
log.flush.interval.ms=1000
log.retention.hours=168
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000
zookeeper.connect=node01:2181,node02:2181,node03:2181
zookeeper.connection.timeout.ms=6000
group.initial.rebalance.delay.ms=0
delete.topic.enable=true
host.name=node01

4 第一台机器的安装包发送到第二台，第三台机器上面去

scp -r kafka_2.11-1.0.0/ node02:$PWD
scp -r kafka_2.11-1.0.0/ node03:$PWD

5 第二台与第三台机器修改配置文件

第二台机器修改配置文件

broker.id=1
num.network.threads=3
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
log.dirs=/export/servers/kafka_2.11-1.0.0/logs
num.partitions=2
num.recovery.threads.per.data.dir=1
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
log.flush.interval.messages=10000
log.flush.interval.ms=1000
log.retention.hours=168
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000
zookeeper.connect=node01:2181,node02:2181,node03:2181
zookeeper.connection.timeout.ms=6000
group.initial.rebalance.delay.ms=0
delete.topic.enable=true
host.name=node02

第三台机器修改配置文件

broker.id=2
num.network.threads=3
num.io.threads=8
socket.send.buffer.bytes=102400
socket.receive.buffer.bytes=102400
socket.request.max.bytes=104857600
log.dirs=/export/servers/kafka_2.11-1.0.0/logs
num.partitions=2
num.recovery.threads.per.data.dir=1
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1
log.flush.interval.messages=10000
log.flush.interval.ms=1000
log.retention.hours=168
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000
zookeeper.connect=node01:2181,node02:2181,node03:2181
zookeeper.connection.timeout.ms=6000
group.initial.rebalance.delay.ms=0
delete.topic.enable=true
host.name=node03

6 启动kafka集群(三台虚拟机都要启动)

cd /export/servers/kafka_2.11-1.0.0
nohup bin/kafka-server-start.sh config/server.properties  2>&1 &

7 通过jps命令查看进程是否有kafka的进程号，存在则安装成功

jps

六 kafka的一些命令行的使用

1 命令行来创建一个topic

cd /export/servers/kafka_2.11-1.0.0/bin
./kafka-topics.sh --create --partitions 3 --replication-factor 2 --topic test --zookeeper node01:2181,node02:2181,node03:2181

2 kafka通过控制台模拟发送数据

cd /export/servers/kafka_2.11-1.0.0/bin
./kafka-console-producer.sh --broker-list  node01:9092,node02:9092,node03:9092 --topic test

kafka通过控制台模拟消费数据

cd /export/servers/kafka_2.11-1.0.0/bin

./kafka-console-consumer.sh --bootstrap-server node01:9092,node02:9092,node03:9092 --from-beginning --topic test

七 kafka的javaAPI的使用
1 创建maven的java工程 并导入jar包

<dependencies>

    <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>1.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>

2 生产者的api发送数据 创建java类 push的过程

public class MyKafkaProducer  {
    public static void main(String[] args) {
        Properties props = new Properties();
        //指定我们kafka服务器的所有的broker在哪里
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        // kafka的一个消息的确认机制
        props.put("acks", "all");
        //如果出现发送数据异常，重试多少次
        props.put("retries", 0);
        // 多少条数据一起发送一次
        props.put("batch.size", 16384);
        props.put("linger.ms", 1);
        //缓冲区的大小，pageCache的缓冲区大小
        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");

        //使用kafkaPrdoucer来进行数据的发送
        Producer<String, String> producer = new KafkaProducer<String,String>(props);
        for (int i = 0; i < 100; i++){
            //kakfaproducer调用send方法，将我们的数据发送到kafka集群当中去，需要一个producerRecord的参数
            producer.send(new ProducerRecord<String, String>("test", Integer.toString(i), Integer.toString(i)));

        }
        //关闭我们的数据发送的客户端
        producer.close();
    }

}

3 消费者的api 创建java类 — pull拉取数据

public class MyKafkaConsumer  {
    public static void main(String[] args) {
        //配置属性
        Properties props = new Properties();
        props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
        //kafka消费的组，这个一定要给
        props.put("group.id", "test");
        //自动提交offset，偏移量，消息消费到了哪里，都记录在这个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来实现的
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String,String>(props);
        //订阅我们的topic是哪些
        consumer.subscribe(Arrays.asList("test"));
        while (true) {
            //消费者调用poll方法，将数据主动拉取过来
            ConsumerRecords<String, String> records = consumer.poll(100);//不是叫做pull
            //循环遍历ConsumerRecords  得到一个个的consumerRecord，consumerRecord里面记录了我们的所有的数据信息，包括我们数据的key，数据的value，数据的offset等等

            for (ConsumerRecord<String, String> record : records)
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
        }
    }
}

八 kafka的分区策略 （可以通过java代码来实现）

第一种分区策略：如果指定了分区号，那么我们的数据就会到我们指定的分区里面去
第二种分区策略：如果没有给定分区号，通过key的hash取值进行分区，只不过key一定不要写死了，一定要是变动的，保证数据均匀的发送到每一个分区里面去
第三种分区策略 ：没有给定分区号，也没有给key值，使用轮循的方式将数据均匀的发送到每一个分区里面去
第四种分区策略：自定义分区

九 flume与kafka的整合使用

1 、开发flume的配置文件（在flume的conf的配置文件下新建文件 flume.conf）
2、 编辑flume.conf文件(事先创建目录/export/servers/flumedata)

#为我们的source channel  sink起名
a1.sources = r1
a1.channels = c1
a1.sinks = k1
#指定我们的source收集到的数据发送到哪个管道
a1.sources.r1.channels = c1
#指定我们的source数据收集策略
a1.sources.r1.type = spooldir
a1.sources.r1.spoolDir = /export/servers/flumedata
a1.sources.r1.deletePolicy = never
a1.sources.r1.fileSuffix = .COMPLETED
a1.sources.r1.ignorePattern = ^(.)*\\.tmp$
a1.sources.r1.inputCharset = GBK
#指定我们的channel为memory,即表示所有的数据都装进memory当中
a1.channels.c1.type = memory
#指定我们的sink为kafka  sink，并指定我们的sink从哪个channel当中读取数据
a1.sinks.k1.channel = c1
a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.k1.kafka.topic = test
a1.sinks.k1.kafka.bootstrap.servers = node01:9092,node02:9092,node03:9092
a1.sinks.k1.kafka.flumeBatchSize = 20
a1.sinks.k1.kafka.producer.acks = 1

3 启动flume

bin/flume-ng agent --conf conf --conf-file conf/flume.conf --name a1 -Dflume.root.logger=INFO,console

4、启动kafka的消费者模拟消费

./kafka-console-consumer.sh --bootstrap-server node01:9092,node02:9092,node03:9092 --from-beginning --topic test

5、 在/export/servers/flumedata目录下上传新的文件

6、在kafka的消费者的服务器上是否有数据的出现

十 kafka如何保证数据的不丢失

1、 生产者如何保证数据不丢失：

kafka的ack机制（消息确认机制），取值有1  0   -1 

分为同步和异步模式：
同步模式主要就是设置我们的ack机制为-1或者1就可以避免数据的丢失

异步模式：除了要设置我们的ack机制为1或者-1之外，还可以控制多长时间，或者多少条数据刷新一次到磁盘上面去

producer.type=async 
request.required.acks=1 
queue.buffering.max.ms=5000 
queue.buffering.max.messages=10000 
queue.enqueue.timeout.ms = -1 
batch.num.messages=200

2 、 消费者如何保证数据的不丢失

主要通过记录offset来保证数据的不丢失，以及数据的不会重复消费
offset的值一般都是记录在kafka自己的内部的一个topic当中
实际工作当中，可以通过手动的提交offset，保证数据的不会丢失

十一 kafkaManager监控工具的使用

1 、上传压缩包并解压

unzip kafka-manager-1.3.3.15.zip  -d ../servers/

2、修改配置文件

vim  application.conf

3、启动脚本添加执行权限

cd /export/servers/kafka-manager-1.3.3.15/bin
chmod  777  ./*

4、 启动kafkamanager

nohup bin/kafka-manager  -Dconfig.file=/export/servers/kafka-manager-1.3.3.15/conf/application.conf -Dhttp.port=8070   2>&1 &

thank you!