Kafka流处理平台
导航:
一.课程介绍:
1.1 概述
- 图示:
二. 什么是Kafka
2.1 概述
- LinkedIn开源产品[领英]
- LinkedIn的产品有:
- 分布式数据同步系统Databus[来源无关的数据也可以同步]
- 高性能计算引擎 Cubert
- Java 异步处理框架ParSeq
- Kafka流处理平台
2.2 Kafka过程:
- LinkedIn开发
- 2011年初开源,加入Apache基金会
- 2012年从Apache Incubator毕业
- Apache顶级开源项目
2.3 官方描述:
-
消息队列,支持发布订阅
- 数据流存储的平台
- 数据产生的时候就可以对其进行处理
-
适用功能:[实时流处理和流传输的管道]
- 实时数据流处理管道
- 实时的数据传输管道
说明它是一个消息队列,但又不仅仅是一个消息队列
三. Kafka的设计和结构
3.1 Kafka的基本概念
- 物理观念
- 逻辑概念
是隔离的,但有时候也有交叉和交流的;
3.2 关键词
- Producer: 消息和数据的生产者,向Kafka的一个topic发布消息的进程/代码/服务
- Consumer:消息和数据的消费者,订阅数据(Topic)并且处理其发布的消息的进程/代码/服务
- Consumer Group:逻辑概念,对于同一个topic,会广播给不同的group,一个group中,只有一个consumer可以消费该消息;
- Broker:物理概念,kafka集群中的每个Kafka节点
- Topic:逻辑概念,Kafka消息的类别,对数据进行区分、隔离
- Partition:物理概念,Kafka下数据存储的基本单元。一个Topic数据,会被分散存储到多个Partition,每一个partition是有序的;
- Replication:同一个Partiton可能会有多个Replica,多个Replica之间数据是一样的;
- Replication Leader: 一个partition的多个Replica上,需要一个Leader负责该Partition上与Producer和Consumer交互 【Leader只有一个】
- ReplicaManager:负责管理当前broker所有分区和副本的信息,处理KafkaController发起的一些请求,副本状态的切换、添加/读取消息等;【管理者】
3.3 Kafka的概念延伸
-
Partiton:
- 每一个Topic被切分为多个Partitons
- 消费者数目少于或等于Partition的数目
- Broker Group中的每一个Broker保存Topic的一个或多个Partitions
- Consumer Group中的仅有一个Consumer读取Topic的一个或多个Partitons,并且是唯一的Consumer
-
Replication:
- 当集群中有Broker挂掉的情况,系统可以主动地使Replicas提供服务
- 系统默认设置每一个Topic的replication系数为1,可以在创建Topic时单独设置;
-
Replication特点
- Replication的基本单位是Topic的Partition;
- 所有的读和写都从Leader进,Followers只是做为备份
- Follower必须能够及时复制Leader的数据
- 增加容错性与可扩展性
-
图示:
这里面,Producers作为消息的提供者,从其他的App途径给予KafkaCluster数据进行消费,在Kafka流平台中可以对数据进行流传输,也可以进行流处理,当操作过后可以通过Connectors API 保存到 DB 数据库中,也可以继续作为流Stream Processors继续进行流传输或流处理【流式交互】,也可以通过Consumers给予其他的App进行消费【比较复杂】
- 图示:
作为一个消息队列的图示信息,Kafka将Broker的信息、Topic等的信息都是存放在Zookeeper上面;Hadoop Cluster:大数据流处理 Real-time monitoring 实时监控 Data warehouse数据仓库
- 消息结构:图示:
Offset: 数据偏移 Length: 数据长度 CRC32:校验数据完整性 Magic: 判断是否为Kafka消息 attributes: 可选,消息的属性,会有枚举值 Timestamp: 时间戳 Key Length 和Value Length分别为其的长度,而Key和Value 则为其的key,value;
3.4 Kafka特点
- 分布式:
- 多分区
- 多副本:增强容灾,容错
- 多订阅者
- 基于ZooKeeper调度
- 高性能:
- 高吞吐量
- 低延迟[实时流处理]
- 高并发
- 时间复杂度为O(1)
- 持久性和扩展性
- 数据可持久化
- 容错性
- 支持在线水平扩展
- 消息自动平衡: 避免消息过于集中在一些个别机器上,导致热点机器,性能降低;
四. Kafka应用场景和实战
4.1 应用场景
- 消息队列
- 行为跟踪
- 元信息监控
- 日志收集【改变了传统的以文件为中心,让日志"活"起来】
- 流处理: 保存收集一些数据,对接到下游的一些系统,将所有数据串联起来,到最终的展示;
- 事件源:将状态转移,按照时间序列记录,可以进行回溯
- 持久性日志(commit log): 在节点中,日志外对日志进行压缩,持久性保存为文件,容错容灾等的功能;
4.2 Kafka的简单案例
-
概述:
- 环境启动
- 简单生产者
- 简单消费者
-
下载与安装:
- Zookeeper下载:http://zookeeper.apache.org/release.html#download
- Kafka下载: http://kafka.apache.org/downloads
- 安装:解压,配置环境变量
- Mac便捷安装 brew install Kafka
-
启动生产者 具体操作如下:
如果没有配置环境变量就需要指向zookeeper.properties
- 启动Zookeeper 输入命令: zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties
启动后展示了端口号等信息
- 进入文件目录:cd /usr/local/Cellar/kafka/1.1.0/
- 启动并指向配置 ./bin/kafka-server-start /usr/local/etc/kafka/server.properties
- 创建一个Topic目录
- 命令1: cd/usr/local/C
- 命令2: ./bin/kafka-topics --create --zookeeper localhost:2181 --replication-factor 1 --partitions 3 --topic myfirst-kafka-topic
这里创建Topic的时候,对ip,端口,replicationp-factor,partitions,以及topic名称等进行了配置;
- 查看topic命令: ./bin/kafka-topics --list --zookeeper localhost:2181
输入这个命令后就会展示Topic的列表,包括刚刚创建的Topic也会显示其中;
- 我们来看看bin下面有哪些命令可供使用: ./bin/
- 启动生产者: ./bin/kafka-console-producer --broker-list localhost:9092 --topic myfirst-kafka-topic
- 启动消费者:
- 打开新窗口
- 进入文件目录: cd /usr/local/Cellar/kafka/1.1.0/
- 创建消费者: ./bin/kafka-console-consumer --bootstrap-server localhost:9092 --topic myfirst-kafka-topic --from-beginning
- 生产者发送消息:
- 输入消息 fristMessage [直接在窗口中输入此数据]
- 消费者接收消息
- 当生产者发出消息后,消费者窗口会立即显示:
./bin/kafka-console-consumer --bootstrap-server localhost:9092 --topic myfirst-kafka-topic --from-beginning 这串命令是创建一个消费者,在结尾的"–from-beginning"决定了消费者是否从头开始消费,如果不带这个的话,那么消费者被创立后,在它创立之前生产者发出的消息将不会被它所接收并使用;
4.3 kafka代码案例
- pom.xml :
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.imooc.kafka</groupId>
<artifactId>examples</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>examples</name>
<description>Demo project for Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.3.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.0.7.RELEASE</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
- common/ErrorCode.java
package com.imooc.kafka.common;
public class ErrorCode {
public final static int SUCCESS = 200;
public final static int EXCEPTION = 500;
}
- common/MessageEntity.java
package com.imooc.kafka.common;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@EqualsAndHashCode
public class MessageEntity {
private String title;
private String body;
@Override
public String toString() {
return "MessageEntity{" +
"title='" + title + '\'' +
", body='" + body + '\'' +
'}';
}
}
- common/Response.java
package com.imooc.kafka.common;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class Response {
private int code;
private String message;
public Response(int code, String message) {
this.code = code;
this.message = message;
}
}
- config/KafkaConsumerConfig.java
package com.imooc.kafka.config;
import com.imooc.kafka.common.MessageEntity;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;
import org.springframework.kafka.support.serializer.JsonDeserializer;
import java.util.HashMap;
import java.util.Map;
@Configuration
@EnableKafka
public class KafkaConsumerConfig {
@Value("${kafka.consumer.servers}")
private String servers;
@Value("${kafka.consumer.enable.auto.commit}")
private boolean enableAutoCommit;
@Value("${kafka.consumer.session.timeout}")
private String sessionTimeout;
@Value("${kafka.consumer.auto.commit.interval}")
private String autoCommitInterval;
@Value("${kafka.consumer.group.id}")
private String groupId;
@Value("${kafka.consumer.auto.offset.reset}")
private String autoOffsetReset;
@Value("${kafka.consumer.concurrency}")
private int concurrency;
@Bean
public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, MessageEntity>> kafkaListenerContainerFactory() {
ConcurrentKafkaListenerContainerFactory<String, MessageEntity> factory = new ConcurrentKafkaListenerContainerFactory<>();
factory.setConsumerFactory(consumerFactory());
factory.setConcurrency(concurrency);
factory.getContainerProperties().setPollTimeout(1500);
return factory;
}
private ConsumerFactory<String, MessageEntity> consumerFactory() {
return new DefaultKafkaConsumerFactory<>(
consumerConfigs(),
new StringDeserializer(),
new JsonDeserializer<>(MessageEntity.class)
);
}
private Map<String, Object> consumerConfigs() {
Map<String, Object> propsMap = new HashMap<>();
propsMap.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
propsMap.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);
propsMap.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitInterval);
propsMap.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeout);
propsMap.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
propsMap.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
propsMap.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
propsMap.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
return propsMap;
}
}
~~~java
- config/KafkaProducerConfig.java
~~~java
package com.imooc.kafka.config;
import java.util.HashMap;
import java.util.Map;
import com.imooc.kafka.common.MessageEntity;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.support.serializer.JsonDeserializer;
import org.springframework.kafka.support.serializer.JsonSerializer;
@Configuration
@EnableKafka
public class KafkaProducerConfig {
@Value("${kafka.producer.servers}")
private String servers;
@Value("${kafka.producer.retries}")
private int retries;
@Value("${kafka.producer.batch.size}")
private int batchSize;
@Value("${kafka.producer.linger}")
private int linger;
@Value("${kafka.producer.buffer.memory}")
private int bufferMemory;
public Map<String, Object> producerConfigs() {
Map<String, Object> props = new HashMap<>();
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
props.put(ProducerConfig.RETRIES_CONFIG, retries);
props.put(ProducerConfig.BATCH_SIZE_CONFIG, batchSize);
props.put(ProducerConfig.LINGER_MS_CONFIG, linger);
props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, bufferMemory);
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
return props;
}
public ProducerFactory<String, MessageEntity> producerFactory() {
return new DefaultKafkaProducerFactory<>(producerConfigs(),
new StringSerializer(),
new JsonSerializer<MessageEntity>());
}
@Bean
public KafkaTemplate<String, MessageEntity> kafkaTemplate() {
return new KafkaTemplate<>(producerFactory());
}
}
- consumer/SimpleConsumer.java
package com.imooc.kafka.consumer;
import com.google.gson.Gson;
import com.imooc.kafka.common.MessageEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class SimpleConsumer {
private final Gson gson = new Gson();
@KafkaListener(topics = "${kafka.topic.default}", containerFactory = "kafkaListenerContainerFactory")
public void receive(MessageEntity message) {
log.info(gson.toJson(message));
}
}
- controller/ProduceController.java
package com.imooc.kafka.controller;
import com.google.gson.Gson;
import com.imooc.kafka.common.ErrorCode;
import com.imooc.kafka.common.MessageEntity;
import com.imooc.kafka.common.Response;
import com.imooc.kafka.producer.SimpleProducer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
@Slf4j
@RestController
@RequestMapping("/kafka")
public class ProduceController {
@Autowired
private SimpleProducer simpleProducer;
@Value("${kafka.topic.default}")
private String topic;
private Gson gson = new Gson();
@RequestMapping(value = "/hello", method = RequestMethod.GET, produces = {"application/json"})
public Response sendKafka() {
return new Response(ErrorCode.SUCCESS, "OK");
}
@RequestMapping(value = "/send", method = RequestMethod.POST, produces = {"application/json"})
public Response sendKafka(@RequestBody MessageEntity message) {
try {
log.info("kafka的消息={}", gson.toJson(message));
simpleProducer.send(topic, "key", message);
log.info("发送kafka成功.");
return new Response(ErrorCode.SUCCESS, "发送kafka成功");
} catch (Exception e) {
log.error("发送kafka失败", e);
return new Response(ErrorCode.EXCEPTION, "发送kafka失败");
}
}
}
- producer/ProducerCallback.java
package com.imooc.kafka.producer;
import com.google.gson.Gson;
import com.imooc.kafka.common.MessageEntity;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.springframework.kafka.support.SendResult;
import org.springframework.lang.Nullable;
import org.springframework.util.concurrent.ListenableFutureCallback;
@Slf4j
public class ProducerCallback implements ListenableFutureCallback<SendResult<String, MessageEntity>> {
private final long startTime;
private final String key;
private final MessageEntity message;
private final Gson gson = new Gson();
public ProducerCallback(long startTime, String key, MessageEntity message) {
this.startTime = startTime;
this.key = key;
this.message = message;
}
@Override
public void onSuccess(@Nullable SendResult<String, MessageEntity> result) {
if (result == null) {
return;
}
long elapsedTime = System.currentTimeMillis() - startTime;
RecordMetadata metadata = result.getRecordMetadata();
if (metadata != null) {
StringBuilder record = new StringBuilder();
record.append("message(")
.append("key = ").append(key).append(",")
.append("message = ").append(gson.toJson(message)).append(")")
.append("sent to partition(").append(metadata.partition()).append(")")
.append("with offset(").append(metadata.offset()).append(")")
.append("in ").append(elapsedTime).append(" ms");
log.info(record.toString());
}
}
@Override
public void onFailure(Throwable ex) {
ex.printStackTrace();
}
}
- producer/SimpleProducer.java
package com.imooc.kafka.producer;
import com.google.gson.Gson;
import com.imooc.kafka.common.MessageEntity;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
@Component
public class SimpleProducer {
@Autowired
@Qualifier("kafkaTemplate")
private KafkaTemplate<String, MessageEntity> kafkaTemplate;
public void send(String topic, MessageEntity message) {
kafkaTemplate.send(topic, message);
}
public void send(String topic, String key, MessageEntity entity) {
ProducerRecord<String, MessageEntity> record = new ProducerRecord<>(
topic,
key,
entity);
long startTime = System.currentTimeMillis();
ListenableFuture<SendResult<String, MessageEntity>> future = kafkaTemplate.send(record);
future.addCallback(new ProducerCallback(startTime, key, entity));
}
}
- ExamplesApplication.java 启动类
package com.imooc.kafka;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@EnableAutoConfiguration
@SpringBootApplication
public class ExamplesApplication {
public static void main(String[] args) {
SpringApplication.run(ExamplesApplication.class, args);
}
}
- resources/application.properties
#============== kafka ===================
kafka.consumer.zookeeper.connect=127.0.0.1:2181
kafka.consumer.servers=127.0.0.1:9092
kafka.consumer.enable.auto.commit=true
kafka.consumer.session.timeout=6000
kafka.consumer.auto.commit.interval=100
kafka.consumer.auto.offset.reset=latest
kafka.consumer.topic=imooc-kafka
kafka.consumer.group.id=imooc
kafka.consumer.concurrency=10
kafka.producer.servers=127.0.0.1:9092
kafka.producer.retries=0
kafka.producer.batch.size=4096
kafka.producer.linger=1
kafka.producer.buffer.memory=40960
kafka.topic.default=imooc-kafka
源码地址: https://gitee.com/zhang199/kafka_demo
五. Kafka的高级特性
5.1 为什么要支持事务
- 满足"读取-处理-写入" 模式
- 流处理需求的不断增强
- 不准确的数据处理的零容忍度
5.2 数据传输的事务定义
- 最多一次:消息不会被重复发送,最多被传输一次,但也有可能一次不传输
- 最少一次:消息不会被漏发送,最少被传输一次,但也有可能被重复传输
- 精确的一次(Exactly once):不会漏传输也不会重复传输,每个消息都传输被一次而且仅仅被传输一次,这是大家所期望的;
5.3 事务保证
- 内部重试问题:Procedure幂等处理
- 多分区原子写入
5.4 事务保证–避免僵尸实例
- 每个事务Producer分配一个transactional.id,在进程重新启动时能够识别相同的Producer实例
- Kafka增加了一个与transactional.id相关的epoch,存储每个transactional.id内部元数据
- 一旦epoch被触发,任何具有相同的transactional.id和更旧的epoch的Producer被视为僵尸,Kafka会拒绝来自这些Procedure的后续性事务写入;
简单来说,Kafka会为每个带事务的生产者配一个专属的id,这样有便于区分并且增加的epoch存储了其内部的数据,当进行版本迭代时,也只有最新的生效,而老的版本和已经通过transactional.id识别为僵尸的,直接拒绝事务写入。能让我们更简易的使用Kafka的事务;
5.5 零拷贝简介
- 网络传输持久性日志块
- Java Nio channel.transforTo()方法
- Linux sendfile系统调用
5.6 文件传输到网络的公共数据路径(常规拷贝)
- 操作系统将数据从磁盘读入到内核空间的页缓存
- 应用程序将数据从内核空间读入到用户空间缓存中
- 应用程序将数据写回到内核空间到socket缓存中
- 操作系统将数据从socket缓冲区复制到网卡缓冲区,以便将数据经网络发出;
5.7 零拷贝过程
- 操作系统将数据从磁盘读入到内核空间的页缓存
- 将数据的位置和长度的信息的描述符增加至内核空间(socket缓冲区)
- 操作系统将数据从内核拷贝到网卡缓冲区,以便于将数据经网络发出
5.8 文件传输到网络的公共数据路径演变
拷贝的过程减少了,提高的效率;