Kafka流处理平台

1. Kafka简介

Kafka是最初由Linkedin公司开发，是一个分布式、支持分区的（partition）、多副本的（replica），基于zookeeper协调的分布式消息系统，它的最大的特性就是可以实时的处理大量数据以满足各种需求场景：比如基于hadoop的批处理系统、低延迟的实时系统、storm/Spark流式处理引擎，web/nginx日志、访问日志，消息服务等等，用scala语言编写，Linkedin于2010年贡献给了Apache基金会并成为顶级开源项目。

Kafka具有以下特性：

• 高吞吐量、低延迟：kafka每秒可以处理几十万条消息，它的延迟最低只有几毫秒，每个topic可以分多个partition, consumer group 对partition进行consume操作。
• 可扩展性：kafka集群支持热扩展
• 持久性、可靠性：消息被持久化到本地磁盘，并且支持数据备份防止数据丢失
• 容错性：允许集群中节点失败（若副本数量为n,则允许n-1个节点失败）
• 高并发：支持数千个客户端同时读写

Kafka的使用场景：

• 日志收集：一个公司可以用Kafka可以收集各种服务的log，通过kafka以统一接口服务的方式开放给各种consumer，例如hadoop、Hbase、Solr等。
• 消息系统：解耦和生产者和消费者、缓存消息等。
• 用户活动跟踪：Kafka经常被用来记录web用户或者app用户的各种活动，如浏览网页、搜索、点击等活动，这些活动信息被各个服务器发布到kafka的topic中，然后订阅者通过订阅这些topic来做实时的监控分析，或者装载到hadoop、数据仓库中做离线分析和挖掘。
• 运营指标：Kafka也经常用来记录运营监控数据。包括收集各种分布式应用的数据，生产各种操作的集中反馈，比如报警和报告。
• 流式处理：比如spark streaming和storm
• 事件源

通过上面的介绍也可以看出：Kafka给自身的定位并不仅仅是一个消息系统，而是通过发布订阅消息机制实现的分布式流平台。

流平台有三个关键的能力：

• 发布订阅记录流，和消息队列或者企业新消息系统类似。
• 以可容错、持久的方式保存记录流
• 当记录流产生时就进行处理

Kafka通常用于应用中的两种广播类型：

• 在系统和应用间建立实时的数据管道，能够可信赖的获取数据。
• 建立实时的流应用，可以处理或者响应数据流。

2. Kafka基本概念及延伸

2.1 基本概念

Producer：数据生产者

• 消息和数据的生产者
• 向Kafka的一个topic发布消息的进程或代码或服务

Consumer：数据消费者

• 消息和数据的消费者
• 向Kafka订阅数据（topic）并且处理其发布的消息的进程或代码或服务

Consumer Group：消费者组

• 对于同一个topic，会广播给不同的Group
• 一个Group中，只有一个Consumer可以消费该消息

Broker：服务节点

• Kafka集群中的每个Kafka节点

Topic：主题

• Kafka消息的类别
• 对数据进行区分、隔离

Partition：分区

• Kafka中数据存储的基本单元
• 一个topic数据，会被分散存储到多个Partition
• 一个Partition只会存在一个Broker上
• 每个Partition是有序的

Replication：分区的副本

• 同一个Partition可能会有多个Replication
• 多个Replication之间数据是一样的

Replication Leader：副本的老大

• 一个Partition的多个Replication上
• 需要一个Leader负责该Partition上与Producer和Consumer交互

Replication Manager：副本的管理者

• 负责管理当前Broker所有分区和副本的信息
• 处理KafkaController发起的一些请求
• 副本状态的切换
• 添加、读取消息等

2.2 概念延伸

Partition：分区

• 每一个Topic被切分为多个Partition
• 消费者数目少于或等于Partition的数目
• Broker Group中的每一个Broker保存Topic的一个或多个Partition
• Consumer Group中的仅有一个Consumer读取Topic的一个或多个Partition，并且是惟一的Consumer

Replication：分区的副本

• 当集群中有Broker挂掉的情况，系统可以主动地使Replication提供服务
• 系统默认设置每一个Topic的Replication系数为1，可以在创建Topic时单独设置
• Replication的基本单位是Topic的Partition
• 所有的读和写都从Replication Leader进行，Replication Followers只是作为备份
• Replication Followers必须能够及时复制Replication Leader的数据
• 增加容错性与可扩展性

3. 基本结构

Kafka功能结构

Kafka数据流势

Kafka消息结构

• Offset：当前消息所处于的偏移
• Length：消息的长度
• CRC32：校验字段，用于校验当前信息的完整性
• Magic：很多分布式系统都会设计该字段，固定的数字，用于快速判定当前信息是否为Kafka消息
• attributes：可选字段，消息的属性
• Timestamp：时间戳
• Key Length：Key的长度
• Key：Key
• Value Length：Value的长度
• Value：Value

4. Kafka安装部署

Kafka依赖于zookeeper实现分布式系统的协调，所以需要同时安装zookeeper。两个的安装包到官网下载。

4.1 zookeeper安装配置

在zookeeper解压后的目录下找到conf文件夹，进入后，复制文件zoo_sample.cfg，并命名为zoo.cfg。zoo.cfg中一共五个配置项，可以使用默认配置。

4.2 Kafka安装配置

进入kafka根目录下的config文件夹下，打开server.properties,修改如下配置项（一般默认即为如下，无需修改）

zookeeper.connect=localhost:2181
broker.id=0
log.dirs=/tmp/kafka-logs

另外，config文件夹下也包含有zookeeper的配置文件，可以在其中设置配置项，启动zookeeper时引用这个配置文件，实现定制化。

Kafka的bin目录包含了大多数功能的启动脚本，可以通过它们控制Kafka的功能开启。

启动Kafka

4.3 使用控制台操作生产者和消费者

创建Topic：sudo ./bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 3 --topic my-kafka-topic
查看Topic：sudo ./bin/kafka-topics.sh --list --zookeeper localhost:2181
启动生产者：sudo ./bin/kafka-console-producer.sh --broker-list localhost:9092 --topic my-kafka-topic
启动消费者：sudo ./bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic my-kafka-topic --from-beginning
生产消息：first message
生产消息：second message

5. 代码示例

引入依赖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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zang</groupId>
    <artifactId>kafka</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>kafka</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <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>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.36</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

相应实体

package com.zang.kafka.common;

import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

/**
 * 〈消息实体〉<br>
 */
@Getter
@Setter
@EqualsAndHashCode
@ToString
public class MessageEntity {
    /**
     * 标题
     */
    private String title;
    /**
     * 内容
     */
    private String body;

}

package com.zang.kafka.common;

import lombok.Getter;
import lombok.Setter;

import java.io.Serializable;

/**
 * 〈REST请求统一响应对象〉<br>
 */
@Getter
@Setter
public class Response implements Serializable{

    private static final long serialVersionUID = -1523637783561030117L;
    /**
     * 响应编码
     */
    private int code;
    /**
     * 响应消息
     */
    private String message;

    public Response(int code, String message) {
        this.code = code;
        this.message = message;
    }
}

package com.zang.kafka.common;

/**
 * 〈错误编码〉<br>
 */
public class ErrorCode {

    /**
     * 成功
     */
    public final static int SUCCESS = 200;
    /**
     * 失败
     */
    public final static int EXCEPTION = 500;

}

生产者

package com.zang.kafka.producer;

import com.alibaba.fastjson.JSON;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

/**
 * 〈生产者〉
 */
@Component
public class SimpleProducer {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;

    public void send(String topic, String key, Object entity) {
        logger.info("发送消息入参：{}", entity);
        ProducerRecord<String, Object> record = new ProducerRecord<>(
                topic,
                key,
                JSON.toJSONString(entity)
        );

        long startTime = System.currentTimeMillis();
        ListenableFuture<SendResult<String, Object>> future = this.kafkaTemplate.send(record);
        future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {
            @Override
            public void onFailure(Throwable ex) {
                logger.error("消息发送失败：{}", ex);
            }

            @Override
            public void onSuccess(SendResult<String, Object> result) {
                long elapsedTime = System.currentTimeMillis() - startTime;

                RecordMetadata metadata = result.getRecordMetadata();
                StringBuilder record = new StringBuilder(128);
                record.append("message(")
                        .append("key = ").append(key).append(",")
                        .append("message = ").append(entity).append(")")
                        .append("send to partition(").append(metadata.partition()).append(")")
                        .append("with offset(").append(metadata.offset()).append(")")
                        .append("in ").append(elapsedTime).append(" ms");
                logger.info("消息发送成功：{}", record.toString());
            }
        });
    }

}

消费者

package com.zang.kafka.consumer;

import com.alibaba.fastjson.JSONObject;
import com.zang.kafka.common.MessageEntity;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import java.util.Optional;

/**
 * 〈消费者〉<br>
 */
@Component
public class SimpleConsumer {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @KafkaListener(topics = "${kafka.topic.default}")
    public void listen(ConsumerRecord<?, ?> record, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {
        //判断是否NULL
        Optional<?> kafkaMessage = Optional.ofNullable(record.value());
        if (kafkaMessage.isPresent()) {
            //获取消息
            Object message = kafkaMessage.get();

            MessageEntity messageEntity = JSONObject.parseObject(message.toString(), MessageEntity.class);

            logger.info("接收消息Topic：{}", topic);
            logger.info("接收消息Record：{}", record);
            logger.info("接收消息Message：{}", messageEntity);
        }
    }

}

控制器

package com.zang.kafka.controller;

import com.alibaba.fastjson.JSON;
import com.zang.kafka.common.ErrorCode;
import com.zang.kafka.common.MessageEntity;
import com.zang.kafka.common.Response;
import com.zang.kafka.producer.SimpleProducer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

/**
 * 〈生产者〉<br>
 */
@RestController
@RequestMapping("/producer")
public class ProducerController {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private SimpleProducer simpleProducer;

    @Value("${kafka.topic.default}")
    private String topic;
    private static final String KEY = "key";/**
     * 消息发送
     * @param message
     * @return
     */
    @PostMapping("/send")
    public Response sendKafka(@RequestBody MessageEntity message) {
        try {
            logger.info("kafka的消息：{}", JSON.toJSONString(message));
            this.simpleProducer.send(topic, KEY, message);
            logger.info("kafka消息发送成功！");
            return new Response(ErrorCode.SUCCESS,"kafka消息发送成功");
        } catch (Exception ex) {
            logger.error("kafka消息发送失败：", ex);
            return new Response(ErrorCode.EXCEPTION,"kafka消息发送失败");
        }
    }
}

配置application.properties

##----------kafka配置
## TOPIC
kafka.topic.default=my-kafka-topic
# kafka地址
spring.kafka.bootstrap-servers=47.88.156.142:9092
# 生产者配置
spring.kafka.producer.retries=0
# 批量发送消息的数量
spring.kafka.producer.batch-size=4096
# 缓存容量
spring.kafka.producer.buffer-memory=40960
# 指定消息key和消息体的编解码方式
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
# 消费者配置
spring.kafka.consumer.group-id=my
spring.kafka.consumer.auto-commit-interval=100
spring.kafka.consumer.auto-offset-reset=latest
spring.kafka.consumer.enable-auto-commit=true
# 指定消息key和消息体的编解码方式
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
# 指定listener 容器中的线程数，用于提高并发量
spring.kafka.listener.concurrency=3

启动类

package com.zang.kafka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.EnableKafka;

@SpringBootApplication
@EnableKafka
public class KafkaApplication {

    public static void main(String[] args) {
        SpringApplication.run(KafkaApplication.class, args);
    }

}

6. Kafka的高级特性

6.1 消息事务

为什么要支持事务

• 满足“读取-处理-写入”模式
• 流处理需求的不断增强
• 不准确的数据处理的容忍度不断降低

数据传输的事务定义

• 最多一次：消息不会被重复发送，最多被传输一次，但也有可能一次不传输
• 最少一次：消息不会被漏发送，最少被传输一次，但也有可能被重复传输
• 精确的一次（Exactly once）：不会漏传输也不会重复传输，每个消息都被传输一次且仅仅被传输一次，这是大家所期望的

事务保证

• 内部重试问题：Procedure幂等处理
• 多分区原子写入

• 避免僵尸实例

  • 　每个事务Procedure分配一个 transactionl. id，在进程重新启动时能够识别相同的Procedure实例
  • 　Kafka增加了一个与transactionl.id相关的epoch，存储每个transactionl.id内部元数据
  • 　一旦epoch被触发，任务具有相同的transactionl.id和更旧的epoch的Producer被视为僵尸，Kafka会拒绝来自这些Producer的后续事务性写入

6.2 零拷贝

零拷贝简介

• 通过网络传输持久性日志块
• 使用Java Nio channel.transforTo()方法实现
• 底层使用Linux sendfile系统调用

文件传输到网络的公共数据路径

• 第一次拷贝：操作系统将数据从磁盘读入到内核空间的页缓存
• 第二次拷贝：应用程序将数据从内核空间读入到用户空间缓存中
• 第三次拷贝：应用程序将数据写回到内核空间到socket缓存中
• 第四次拷贝：操作系统将数据从socket缓冲区复制到网卡缓冲区，以便将数据经网络发出

零拷贝过程（指内核空间和用户空间的交互拷贝次数为零）

• 第一次拷贝：操作系统将数据从磁盘读入到内核空间的页缓存
• 将数据的位置和长度的信息的描述符增加至内核空间（socket缓存区）
• 第二次拷贝：操作系统将数据从内核拷贝到网卡缓冲区，以便将数据经网络发出

来源：

慕课网课程：https://www.imooc.com/learn/1043

参考：

https://blog.csdn.net/liyiming2017/article/details/82790574

https://blog.csdn.net/YChenFeng/article/details/74980531