Kafka介绍、安装以及原理解析

Kafka

分布式流处理平台

消息中间件（MQ）

常见的MQ框架

activeMQ，rabbitMQ，zeroMQ，metaMQ，rocketMQ

topic(话题)

kafka将消息分门别类，每一类的消息称之主题，是逻辑上的一个概念，如果是，真正到磁盘上，映射的是一个partition的一个目录。

生产者(producer)

发布消息的对象称之为生产者，只负责数据的产生，生产的来源，可以不在kafka集群上，而是来自其他的业务系统。

消费者(consumer)

订阅消息并处理发布消息的对象，称为消费者

消费者组(consumerGroup)

多个消费者可以构成消费者组，同一个消费者组的消费者，只能消费一个topic的数据，不能重复消费。

broker

kafka本身可以是一个集群，集群中的每一个服务器都是一个代理，这个代理称为broker。只负责消息的存储，不管生产者和消费者没有任何关系。在集群中每个broker有唯一个ID，不能重复。

使用流程

启动zookeeper

zookeeper-server-start.sh -daemon /usr/local/kafka/config/zookeeper.properties
1

启动Kafka服务

kafka-server-start.sh /usr/local/kafka/config/server.properties
1

创建topic

kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic mysql
1

查看topic列表

kafka-topics.sh --list --zookeeper localhost:2181
1

产生消息

kafka-console-producer.sh --broker-list 192.168.224.80:9092 --topic mysql
1

消费消息

kafka-console-consumer.sh --bootstrap-server 192.168.224.80:9092 --topic mysql --from-beginning
1

查看描述 topics 信息

bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic test

Topic:test    PartitionCount:1    ReplicationFactor:1    Configs:
    Topic: test    Partition: 0    Leader: 1    Replicas: 1    Isr: 1
    
第一行给出了所有分区的摘要，每个附加行给出了关于一个分区的信息。 由于我们只有一个分区，所以只有一行。

“Leader”: 是负责给定分区的所有读取和写入的节点。 每个节点将成为分区随机选择部分的领导者。

“Replicas”: 是复制此分区日志的节点列表，无论它们是否是领导者，或者即使他们当前处于活动状态。

“Isr”: 是一组“同步”副本。这是复制品列表的子集，当前活着并被引导到领导者。
1
2
3
4
5
6
7
8
9
10
11
12

集群配置

单机多broker集群配置

cp config/server.properties config/server-2.properties

cp config/server.properties config/server-3.properties

vim config/server-2.properties

vim config/server-3.properties

#修改,连接远程Kafka需修改localhost为本机ip
broker.id=2
listeners = PLAINTEXT://localhost:9093
log.dir=/data/kafka/logs-2

broker.id=3
listeners = PLAINTEXT://localhost:9094
log.dir=/data/kafka/logs-3

#启动服务
bin/kafka-server-start.sh config/server-2.properties &

bin/kafka-server-start.sh config/server-3.properties &
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

多机多broker集群配置

搭建kafka集群
克隆3个台虚拟机（参考前面教程）
上传kafka压缩包，到31上
解压缩：
tar -xzvf kafka_2.11-2.4.0.tgz -C /usr/
修改名称：
mv /usr/kafka_2.11-2.4.0/  /usr/kafka
配置环境变量：
vim /etc/profile

让配置文件生效：
source /etc/profile
测试：
echo $KAFKA_HOME
进入kafka目录：
cd /usr/kafka
创建目录（存放消息），为后面配置做准备   	
mkdir logs
修改配置server.properties文件：
vim config/server.properties
修改下面内容：
#broker的全局唯一编号，不能重复 21行
broker.id=0
#是否允许删除topic    22行
delete.topic.enable=true
#处理网络请求和响应的线程数量 42行
num.network.threads=3
#用来处理磁盘IO的线程数量  45
num.io.threads=8
#发送套接字的缓冲区大小   48
socket.send.buffer.bytes=102400
#接收套接字的缓冲区大小   51
socket.receive.buffer.bytes=102400
#请求套接字的最大缓冲区大小  54
socket.request.max.bytes=104857600
#kafka运行日志存放的路径  60
log.dirs=/usr/kafka/logs
#topic在当前broker上的分区个数  65
num.partitions=1
#用来恢复和清理data下数据的线程数量   69
num.recovery.threads.per.data.dir=1
#segment文件保留的最长时间，超时将被删除，单位小时，默认是168小时，也就是7天   103
log.retention.hours=168
#配置连接Zookeeper集群地址  123
zookeeper.connect=hdcluster1:2181,hdcluster2:2181,hdcluster3:2181
因为配置文件中使用的zk主机名称链接，所以配置本地域名：
vim /etc/hosts
完整的hosts：
192.168.23.31 kafka1
192.168.23.32 kafka2
192.168.23.33 kafka3
192.168.23.20 zk
修改producer.properties:
vim config/producer.properties 
修改21行为：
bootstrap.servers=kafka1:9092,kafka2:9092,kafka3:9092
修改consumer.properties:
vim config/consumer.properties 
修改19行为：
bootstrap.servers=kafka1:9092,kafka2:9092,kafka3:9092
发送配置好的kafka到另外两台机子（先做免密登录）：
ssh-keygen -t rsa
ssh-copy-id kafka2
ssh-copy-id kafka3

scp -r  kafka/ kafka2:/usr/
scp -r  kafka/ kafka3:/usr/
检查发送是否成功,在all session执行：
ls /usr
修改broker.id（切记）
在kafka2和kafka3上修改broker.id
vim config/server.properties
修改21行为
broker.id=1    broker.id=2

发送环境变量配置文件：
scp -r  /etc/profile  kafka2:/etc/
scp -r  /etc/profile  kafka3:/etc/
在all session执行：
source  /etc/profile
echo  $KAFKA_HOME
发送hosts配置文件：
scp -r  /etc/hosts  kafka2:/etc/
scp -r  /etc/hosts  kafka3:/etc/
测试是否成功：
在all session执行：
ping kakfa1
3.6.3 集群的启动和关闭
启动kafka之前一定要保证zk在启动，并且可用：
启动zk:
zkServer.sh start
测试是否启动:
jps  
启动kafka:
在all session中 进入主目录：
cd /usr/kafka
kafka-server-start.sh -daemon  config/server.properties
jps 


停止kafka:
kafka-server-stop.sh
jps

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

常用命令

常用命令
查看当前服务器中的所有topic主题：
kafka-topics.sh --zookeeper zk:2181 --list
如果是zk集群可以使用这样的命令：
kafka-topics.sh --zookeeper zk1:2181,zk2:2181,zk3:2181 --list
创建topic:
kafka-topics.sh --zookeeper zk:2181 --create --replication-factor 3 --partitions 3 --topic tp1
kafka-topics.sh --zookeeper zk:2181 --create --replication-factor 2 --partitions 2 --topic tp1
kafka-topics.sh --zookeeper zk:2181 --create --replication-factor 1 --partitions 1 --topic tp1	
参数说明：
--zookeeper    链接zk
--replication-factor   指定副本数目（副本数目不能大于总的brokers数目）
--partitions  指定分区数
--topic 指定topic名称
删除topic:
kafka-topics.sh --zookeeper zk:2181 --delete --topic tp3
This will have no impact if delete.topic.enable is not set to true    
生产消息：
kafka-console-producer.sh --broker-list kafka1:9092  --topic tp1      
消费消息：
kafka-console-consumer.sh --bootstrap-server kafka1:9092  --from-beginning --topic tp1
同组消费者消费消息（多个窗口）：
kafka-console-consumer.sh --bootstrap-server kafka1:9092 --consumer-property group.id=gtest  --from-beginning --topic tp1
查看一个topic详情：
kafka-topics.sh --zookeeper zk:2181 --describe --topic tp1


partitioncount   分区总数量
replicationfactor    副本数量
partition 分区
leader  每个分区有3个副本，每个副本都有leader
replicas   所有副本节点，不管leader follower
isr: 正在服务中的节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

Kafka工作流程

zk中保存Kafka数据的目录结构

1，broker在zk中注册：集群启动时，每个broker都会在/brokers/ids/下注册(创建临时有序的节点)，如果broker挂掉了，zk就会删除该节点。
2，topick会在zk中注册：创建topic是，每个topic都会在/brokers/topics/下注册,topic删除，节点失效。每个broker和topic的对应关系也是由zk进行维护。
3，consumer(消费者)在zk注册：当新的消费者都会zk进行注册，zk在/consumers/consumer-group/ 创建3个节点   ids    offsets(偏移量)  owners
ids:  记录当前消费者组所有的消费者id
offsets:消费者在消费topic每个partition时，消费到哪个位置（offset 偏移量）
owners:记录该消费者组消费的topic信息（订阅了哪些topic）
1
2
3
4
5
6

使用 Kafka Connect 来导入/导出数据

创建test.txt文件测试

echo -e "zhisheng\ntian" > test.txt
1

接下来，我们将启动两个以独立模式运行的连接器，这意味着它们将在单个本地专用进程中运行。我们提供三个配置文件作为参数。首先是 Kafka Connect 过程的配置，包含常见的配置，例如要连接的 Kafka 代理以及数据的序列化格式。其余的配置文件都指定一个要创建的连接器。这些文件包括唯一的连接器名称，要实例化的连接器类以及连接器所需的任何其他配置。

bin/connect-standalone.sh config/connect-standalone.properties config/connect-file-source.properties config/connect-file-sink.properties
1

Kafka Connect 进程启动后，源连接器应该开始读取 test.txt topic connect-test，并将其生成 topic ，并且接收器连接器应该开始读取 topic 中的消息 connect-test 并将其写入文件 test.sink.txt。我们可以通过检查输出文件的内容来验证通过整个管道传输的数据：

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic connect-test --from-beginning
1

向test.txt中连续添加数据

echo zhishengtian>> test.txt
echo zhishengtian2>> test.txt
echo zhishengtian3>> test.txt
echo zhishengtian4>> test.txt
1
2
3
4

Springboot整合Kafka

可在控制台接收，也可运行消费信息命令来接收

application.yml

spring:
  kafka:
  	#指定kafka server的地址，集群配多个，中间，逗号隔开
    bootstrap-servers: 192.168.224.131:9092,192.168.224.131:9093 
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      group-id: default_consumer_group #群组ID
      enable-auto-commit: true
      auto-commit-interval: 1000
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
1
2
3
4
5
6
7
8
9
10
11
12
13

KafkaProducer

package com.cloudwise.kafka;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author IvanZ
 * @version 1.0
 * @date Created on 2021/1/28 16:07
 * @description Kafka生产者
 * @modifiedBy
 */
@RestController
public class KafkaProducer {
    @Autowired
    private KafkaTemplate<String,Object> kafkaTemplate;
    @RequestMapping("message/send")
    public String send(String msg){
        //使用kafka模板发送信息
        kafkaTemplate.send("demo", msg);
        return "success";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

KafkaConsumer

package com.cloudwise.kafka;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

/**
 * @author IvanZ
 * @version 1.0
 * @date Created on 2021/1/28 16:08
 * @description Kafka消费者
 * @modifiedBy
 */
@Component
public class KafkaConsumer {
    /**
     * 定义此消费者接收topics = "demo"的消息，与controller中的topic对应上即可
     * @param record 变量代表消息本身，可以通过ConsumerRecord类型的record变量来打印接收的消息的各种信息
     */
    @KafkaListener(topics = "demo")
    public void listen (ConsumerRecord<?, ?> record){
        System.out.printf("topic is %s, offset is %d, value is %s \n", record.topic(), record.offset(), record.value());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

在页面上访问

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fca2FFBj-1623322886752)(images/image-20210128163147213.png)]

控制台输出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ToFCfGjw-1623322886753)(images/image-20210128163219346.png)]

 springboot整合kafka
         3.1.1  pom.xml添加jar 
      <!-- kafka的jar包 -->
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
            <version>2.6.6</version>
        </dependency>
        <!-- fastjson的jar包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>
注意：此处使用的springboot版本为2.4.1  kafka是编写课件时最新版本2.6.6，不是任意版本都兼容
     3.1.2  配置文件application.properties
#springboot 整合kafka
#Kafka集群配置，注意如果集群搭建时用的是名字 需要配置对应的主机名称  C:\Windows\System32\drivers\etc\hosts
spring.kafka.bootstrap-servers=kafka1:9092,kafka2:9092,kafka3:9092
#生产者配置

# 重试次数
spring.kafka.producer.retries=0
# 应答级别:多少个分区副本备份完成时向生产者发送ack确认(可选0、1、all/-1)
spring.kafka.producer.acks=1
# 批量大小
spring.kafka.producer.batch-size=16384
# 提交延时
spring.kafka.producer.properties.linger.ms=0
# 当生产端积累的消息达到batch-size或接收到消息linger.ms后,生产者就会将消息提交给kafka
# linger.ms为0表示每接收到一条消息就提交给kafka,这时候batch-size其实就没用了

# 生产端缓冲区大小
spring.kafka.producer.buffer-memory = 33554432
# Kafka提供的序列化和反序列化类
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
# 自定义分区器
# spring.kafka.producer.properties.partitioner.class=com.felix.kafka.producer.CustomizePartitioner

#消费者配置
# 默认的消费组ID
spring.kafka.consumer.properties.group.id=defaultConsumerGroup
# 是否自动提交offset
spring.kafka.consumer.enable-auto-commit=true
# 提交offset延时(接收到消息后多久提交offset)
spring.kafka.consumer.auto.commit.interval.ms=1000
# 当kafka中没有初始offset或offset超出范围时将自动重置offset
# earliest:重置为分区中最小的offset;
# latest:重置为分区中最新的offset(消费分区中新产生的数据);
# none:只要有一个分区不存在已提交的offset,就抛出异常;
spring.kafka.consumer.auto-offset-reset=latest
# 消费会话超时时间(超过这个时间consumer没有发送心跳,就会触发rebalance操作)
spring.kafka.consumer.properties.session.timeout.ms=120000
# 消费请求超时时间
spring.kafka.consumer.properties.request.timeout.ms=180000
# Kafka提供的序列化和反序列化类
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
# 消费端监听的topic不存在时，项目启动会报错(关掉)
spring.kafka.listener.missing-topics-fatal=false
# 设置批量消费
# spring.kafka.listener.type=batch
# 批量消费每次最多消费多少条消息
# spring.kafka.consumer.max-poll-records=50


 3.1.3   生成者代码(结合springcloud微服务使用)
   @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    //发送消息方法
    @GetMapping("productDept")
    public String send() {
         Dept dept =new Dept();
         dept.setDeptno(100);
         dept.setDname("测试生产者");
         dept.setLoc("测试生产者");
        log.info("+++++++++++++++++++++  message = {}",  JSON.toJSONString(dept));
        //topic-dept为主题
        kafkaTemplate.send("topic-dept", JSON.toJSONString(dept));
        return "suc";
    }
 3.1.4  消费者代码(结合springcloud微服务使用) 
package com.aaa.sbm.util;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
import java.util.Optional;

/**
 * @ fileName:KafkaConsumer
 * @ description:
 * @ author:zhz
 * @ createTime:2021/2/20 15:02
 */
@Component
@Slf4j
public class KafkaConsumer {

    @KafkaListener(topics = {"topic-dept"})
    public void consumer(ConsumerRecord<?, ?> record){
        Optional<?> kafkaMessage = Optional.ofNullable(record.value());
        if (kafkaMessage.isPresent()) {
            Object message = kafkaMessage.get();
            log.info("----------------- record =" + record);
            log.info("------------------ message =" + message);
        }
    }
}
          3.1.5 测试
                     生产信息
                     http://localhost:11950/dept/productDept      
                     消费消息
                      
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

Kafka定时任务

Kafka启动报错处理：/opt/module/kafka/bin/kafka-run-class.sh: 第 258 行:exec: java: 未找到

今天在学习Kafka的时候，写了个脚本，用于集群中kafka的群起。发现启动不了。😧

去掉-daemon参数后，继续启动，看到了它报的错误(日志中也有显示)。找不到java？？？

看了相关资料后，知道了，原来是Kafka的默认/usr/bin/java路径与我们实际的$JAVA_HOME/bin/java路径不一致导致的。
.
这里我们有两种修改方式

修改我们的实际路径(太麻烦，而且可能会引起其它配置的变化，我大数据有些配置中直接使用JAVA_HOME的实际路径，没有使用环境变量)
设置一个软连接就可以了
这里用第二种方式就行了

在窗口输入

echo $JAVA_HOME
1
查看我们的JAVA_HOME路径，下面会用到。

建立软连接

ln -s $JAVA_HOME/bin/java /usr/bin/java

ln -s /opt/module/jdk1.8.0_144/bin/java /usr/bin/java
1
2
然后重新尝试就可以了！！！