大数据学习_消息中间件_Kafka架构与实战

最新推荐文章于 2023-04-28 11:15:04 发布

Shawlizao

最新推荐文章于 2023-04-28 11:15:04 发布

阅读量423

点赞数

分类专栏：大数据 kafka

本文链接：https://blog.csdn.net/qq_41612830/article/details/114557192

版权

大数据同时被 2 个专栏收录

23 篇文章 0 订阅

订阅专栏

kafka

1 篇文章 0 订阅

订阅专栏

1 概念和基本架构

1.1 Kafka介绍

Kafka是最初由Linkedin公司开发，是一个分布式、分区的、多副本的、多生产者、多订阅者，基于zookeeper协调的分布式日志系统（也可以当做MQ系统），常见可以用于web/nginx日志、访问日志，消息服务等等，Linkedin于2010年贡献给了Apache基金会并成为顶级开源项目。
主要应用场景是：日志收集系统和消息系统。
Kafka主要设计目标如下：

以时间复杂度为O(1)的方式提供消息持久化能力，即使对TB级以上数据也能保证常数时间的访问性能。
高吞吐率。即使在非常廉价的商用机器上也能做到单机支持每秒100K条消息的传输。
支持Kafka Server间的消息分区，及分布式消费，同时保证每个partition内的消息顺序传输。
同时支持离线数据处理和实时数据处理。
支持在线水平扩展

有两种主要的消息传递模式：点对点传递模式、发布-订阅模式。大部分的消息系统选用发布-订阅模式。Kafka就是一种发布-订阅模式。
对于消息中间件，消息分推拉两种模式。Kafka只有消息的拉取，没有推送，可以通过轮询实现消息的推送。
什么是轮询？

//简单的轮询实现 基于取模
public static void main(String[] args) {
        int[] arr = { 1,2,3,4,5,6 };
        int index = 5; // 索引:指定起始位置
        for (int i = 0; i < 10; i++) {
            int nextIndex = (index + 1) % arr.length;
            index = nextIndex;
            System.out.println(arr[index] + " ,index=" + index);
        }
}

Kafka具有四个核心API：

Producer API：允许应用程序将记录流发布到一个或多个Kafka主题。
Consumer API：允许应用程序订阅一个或多个主题并处理为其生成的记录流。
Streams API：允许应用程序充当流处理器，使用一个或多个主题的输入流，并生成一个或多个输出主题的输出流，从而有效地将输入流转换为输出流。
Connector API：允许构建和运行将Kafka主题连接到现有应用程序或数据系统的可重用生产者或使用者。例如，关系数据库的连接器可能会捕获对表的所有更改。

1.2 Kafka优势

高吞吐量：单机每秒处理几十上百万的消息量。即使存储了许多TB的消息，它也保持稳定的性能。
高性能：单节点支持上千个客户端，并保证零停机和零数据丢失。
持久化数据存储：将消息持久化到磁盘。通过将数据持久化到硬盘以及replication防止数据丢失。
1. 零拷贝
2. 顺序读，顺序写
3. 利用Linux的页缓存
分布式系统，易于向外扩展。所有的Producer、Broker和Consumer都会有多个，均为分布式的。无需停机即可扩展机器。多个Producer、Consumer可能是不同的应用。
可靠性 - Kafka是分布式，分区，复制和容错的。
客户端状态维护：消息被处理的状态是在Consumer端维护，而不是由server端维护。当失败时能自动平衡。
支持online和offline的场景。
支持多种客户端语言。Kafka支持Java、.NET、PHP、Python等多种语言。

1.3 Kafka应用场景

日志收集：一个公司可以用Kafka可以收集各种服务的Log，通过Kafka以统一接口服务的方式开放给各种Consumer；
消息系统：解耦生产者和消费者、缓存消息等；
用户活动跟踪：Kafka经常被用来记录Web用户或者App用户的各种活动，如浏览网页、搜索、点击等活动，这些活动信息被各个服务器发布到Kafka的Topic中，然后消费者通过订阅这些Topic来做实时的监控分析，亦可保存到数据库；
运营指标：Kafka也经常用来记录运营监控数据。包括收集各种分布式应用的数据，生产各种操作的集中反馈，比如报警和报告；
流式处理：比如Spark Streaming和Storm。

kafka很大的一个作用，流量削峰：
首先来理解为什么要削峰呢？或者说峰值会带来哪些坏处？
我们知道服务器的处理资源是恒定的，你用或者不用它的处理能力都是一样的，所以出现峰值的话，很容易导致忙到处理不过来，闲的时候却又没有什么要处理。但是由于要保证服务质量，我们的很多处理资源只能按照忙的时候来预估，而这会导致资源的一个浪费。
这就好比因为存在早高峰和晚高峰的问题，所以有了错峰限行的解决方案。
削峰的存在，一是可以让服务端处理变得更加平稳，二是可以节省服务器的资源成本。
针对秒杀这一场景，削峰从本质上来说就是更多地延缓用户请求的发出，以便减少和过滤掉一些无效请求，它遵从“请求数要尽量少”的原则。
接着流量削峰的一些操作思路有：排队、答题、分层过滤。

排队
要对流量进行削峰，最容易想到的解决方案就是用消息队列来缓冲瞬时流量，把同步的直接调用转换成异步的间接推送，中间通过一个队列在一端承接瞬时的流量洪峰，在另一端平滑地将消息推送出去。在这里，消息队列就像“水库”一样，拦蓄上游的洪水，削减进入下游河道的洪峰流量，从而达到减免洪水灾害的目的。
答题
你是否还记得，最早期的秒杀只是纯粹地刷新页面和点击购买按钮，它是后来才增加了答题功能的。那么，为什么要增加答题功能呢？
这主要是为了增加购买的复杂度，从而达到两个目的。
第一个目的是防止部分买家使用秒杀器在参加秒杀时作弊。2011年秒杀非常火的时候，秒杀器也比较猖獗，因而没有达到全民参与和营销的目的，所以系统增加了答题来限制秒杀器。增加答题后，下单的时间基本控制在2s后，秒杀器的下单比例也大大下降。答题页面如下图所示。
分层过滤
前面介绍的排队和答题要么是少发请求，要么对发出来的请求进行缓冲，而针对秒杀场景还有一种方法，就是对请求进行分层过滤，从而过滤掉一些无效的请求。分层过滤其实就是采用“漏斗”式设计来处理请求的，如下图所示。

而kafka-即是解决上述这类问题的一个框架，它实现了生产者和消费者之间的无缝连接。消息队列可驻留在内存或磁盘上, 队列存储消息直到它们被应用程序读走。通过消息队列，应用程序可独立地执行–它们不需要知道彼此的位置、或在继续执行前不需要等待接收消息。

1.4 kafka基本架构

消息和批次
Kafka的数据单元称为消息。可以把消息看成是数据库里的一个“数据行”或一条“记录”。消息由字节数组组成。
消息有键，键也是一个字节数组。当消息以一种可控的方式写入不同的分区时，会用到键。为了提高效率，消息被分批写入Kafka。批次就是一组消息，这些消息属于同一个主题和分区。
把消息分成批次可以减少网络开销。批次越大，单位时间内处理的消息就越多，单个消息的传输时间就越长。批次数据会被压缩，这样可以提升数据的传输和存储能力，但是需要更多的计算处理。
模式（序列化反序列化方式）
消息模式（schema）有许多可用的选项，以便于理解。如JSON和XML，但是它们缺乏强类型处理能力。Kafka的许多开发者喜欢使用Apache Avro。Avro提供了一种紧凑的序列化格式，模式和消息体分开。当模式发生变化时，不需要重新生成代码，它还支持强类型和模式进化，其版本既向前兼容，也向后兼容。
主题和分区
Kafka的消息通过主题进行分类。主题可比是数据库的表或者文件系统里的文件夹。主题可以被分为若干分区，一个主题通过分区分布于Kafka集群中，提供了横向扩展的能力。**主题是跟业务相关的，相同业务的消息会被分为同一主题。**一个FIFO的消息队列被称为一个分区。一个主题由多个分区组成。
在这里插入图片描述
生产者和消费者
生产者创建消息。消费者消费消息。一个消息被发布到一个特定的主题上。生产者在默认情况下把消息均衡地分布到主题的所有分区上：

直接指定消息的分区
根据消息的key散列取模得出分区
轮询指定分区。

消费者通过偏移量来区分已经读过的消息，从而消费消息。消费者是消费组的一部分。消费组保证每个分区只能被一个消费者使用，避免重复消费。
broker和集群
一个独立的Kafka服务器称为broker。broker接收来自生产者的消息，为消息设置偏移量，并提交消息到磁盘保存。broker为消费者提供服务，对读取分区的请求做出响应，返回已经提交到磁盘上的消息。单个broker可以轻松处理数千个分区以及每秒百万级的消息量。
在这里插入图片描述
每个集群都有一个broker是集群控制器（自动从集群的活跃成员中选举出来，基于zk的分布式锁）。
控制器负责管理工作：

将分区分配给broker
监控broker
集群中一个分区属于一个broker，该broker称为分区首领。一个分区可以分配给多个broker，此时会发生分区复制生成副本分区(高可用，防止集群节点宕机)。分区的复制提供了消息冗余，高可用。副本分区不负责处理消息的读写。

1.5 核心概念

Producer
生产者创建消息。
该角色将消息发布到Kafka的topic中。broker接收到生产者发送的消息后，broker将该消息追加到当前用于追加数据的 segment 文件（磁盘中）中。一般情况下，一个消息会被发布到一个特定的主题上。

默认情况下通过轮询把消息均衡地分布到主题的所有分区上。
在某些情况下，生产者会把消息直接写到指定的分区。这通常是通过消息键和分区器来实现
的，分区器为键生成一个散列值，并将其映射到指定的分区上。这样可以保证包含同一个键的
消息会被写到同一个分区上。
生产者也可以使用自定义的分区器，根据不同的业务规则将消息映射到分区。

Consumer
消费者读取消息。

消费者订阅一个或多个主题，并按照消息生成的顺序读取它们。
消费者通过检查消息的偏移量来区分已经读取过的消息。偏移量是另一种元数据，它是一个不断递增的整数值，在创建消息时，Kafka 会把它添加到消息里。在给定的分区里，每个消息的偏移量都是唯一的。消费者把每个分区最后读取的消息偏移量保存在Zookeeper 或Kafka
上，如果消费者关闭或重启，它的读取状态不会丢失。
消费者是消费组的一部分。群组保证每个分区只能被一个消费者使用。
如果一个消费者失效，消费组里的其他消费者可以接管失效消费者的工作，再平衡，分区重新分配。

Broker
一个独立的Kafka 服务器被称为broker。
broker 为消费者提供服务，对读取分区的请求作出响应，返回已经提交到磁盘上的消息。

如果某topic有N个partition，集群有N个broker，那么每个broker存储该topic的一个partition。
如果某topic有N个partition，集群有(N+M)个broker，那么其中有N个broker存储该topic的一个partition，剩下的M个broker不存储该topic的partition数据。
如果某topic有N个partition，集群中broker数目少于N个，那么一个broker存储该topic的一个或多个partition。在实际生产环境中，尽量避免这种情况的发生，这种情况容易导致Kafka集群数据不均衡。

broker 是集群的组成部分。每个集群都有一个broker 同时充当了集群控制器的角色（自动从集群的活跃成员中选举出来）。控制器负责管理工作，包括将分区分配给broker 和监控broker。在集群中，一个分区从属于一个broker，该broker 被称为分区的首领。
Topic
每条发布到Kafka集群的消息都有一个类别，这个类别被称为Topic。物理上不同Topic的消息分开存储。主题就好比数据库的表，尤其是分库分表之后的逻辑表。
Partition

主题可以被分为若干个分区，一个分区就是一个提交日志。
消息以追加的方式写入分区，然后以先入先出的顺序读取。
无法在整个主题范围内保证消息的顺序，但可以保证消息在单个分区内的顺序。
Kafka 通过分区来实现数据冗余和伸缩性。
在需要严格保证消息的消费顺序的场景下，需要将partition数目设为1。

Replicas
Kafka 使用主题来组织数据，每个主题被分为若干个分区，每个分区有多个副本。那些副本被保存在broker 上，每个broker 可以保存成百上千个属于不同主题和分区的副本。副本有以下两种类型：

首领副本
每个分区都有一个首领副本。为了保证一致性，所有生产者请求和消费者请求都会经过这个副本。
跟随者副本
首领以外的副本都是跟随者副本。跟随者副本不处理来自客户端的请求，它们唯一的任务就是从首领那里复制消息，保持与首领一致的状态。如果首领发生崩溃，其中的一个跟随者会被提升为新首领。

Offset

生产者Offset
消息写入的时候，每一个分区都有一个offset，这个offset就是生产者的offset，来表示消息写入时的偏移，同时也是这个分区的最新最大的offset。有些时候没有指定某一个分区的offset，这个工作kafka帮我们完成。
消费者Offset
这是某一个分区的offset情况，生产者写入的offset是最新最大的值是12，而当Consumer A进行消费时，从0开始消费，一直消费到了9，消费者的offset就记录在9，Consumer B就纪录在了11。等下一次他们再来消费时，他们可以选择接着上一次的位置消费，当然也可以选择从头消费，或者跳到最近的记录并从“现在”开始消费。

副本
Kafka通过副本保证高可用。副本分为首领副本(Leader)和跟随者副本(Follower)。跟随者副本包括同步副本和不同步副本，在发生首领副本切换的时候，只有同步副本可以切换为首领副本。
分区中的所有副本统称为AR（Assigned Repllicas）。
所有与leader副本保持一定程度同步的副本（包括Leader）组成ISR（In-Sync Replicas），ISR集合是AR集合中的一个子集。消息会先发送到leader副本，然后follower副本才能从leader副本中拉取消息进行同步，同步期间内follower副本相对于leader副本而言会有一定程度的滞后。前面所说的“一定程度”是指可以忍受的滞后范围，这个范围可以通过参数进行配置。
HW
HW是High Watermak的缩写，俗称高水位，它表示了一个特定消息的偏移量（offset），代表leader与follower之间共有消息的最大偏移，消费只能拉取到这个offset之前的消息。
LEO
LEO是Log End Offset的缩写，它表示了当前日志文件中下一条待写入消息的offset。
在这里插入图片描述

2 Kafka安装与配置

前置条件
安装jdk1.8
安装zookeeper3.4.14
Kafka的安装与配置
解压缩
配置环境变量
配置/kafka_2.12-1.0.2/config中的server.properties文件：

zookeeper.connect=localhost:2181/myKafka

2.1 Kafka启动与基本命令

# 首先启动zk
zkServer.sh start

# 启动kafka +-daemon视为后台启动
kafka-server-start.sh -daemon ./config/server.properties

## kafka-topics.sh 用于管理主题。
# 列出现有主题
kafka-topics.sh --list --zookeeper localhost:2181/myKafka
# 创建主题，该主题包含一个分区，该分区为Leader分区，它没有Follower分区副本
kafka-topics.sh --zookeeper localhost/myKafka --create --topic topic_1 --partitions 1 --replication-factor 1
# 查看指定主题的详细信息
kafka-topics.sh --zookeeper localhost:2181/myKafka -- describe --topic topic_1
# 删除指定主题
kafka-topics.sh --zookeeper localhost:2181/myKafka --delete --topic topic_1

## kafka-console-producer.sh用于生产消息：
# 开启生产者
kafka-console-producer.sh --topic topic_1 --broker-list localhost:9092

## kafka-console-consumer.sh用于消费消息：
# 开启消费者 kafka发送端口为9092
kafka-console-consumer.sh --bootstrap-server localhost:9092 - -topic topic_1
# 开启消费者方式二，从头消费，不按照偏移量消费
kafka-console-consumer.sh --bootstrap-server localhost:9092 - -topic topic_1 --from-beginning

# 停用生产者/消费者
ctrl + c

3 Kafka开发实战

3.1 消息的发送与接收

在这里插入图片描述
生产者主要的对象有： KafkaProducer ， ProducerRecord 。
其中 KafkaProducer 是用于发送消息的类， ProducerRecord 类用于封装Kafka的消息。
KafkaProducer 的创建需要指定的参数和含义：

参数	说明
bootstrap.servers	配置生产者如何与broker建立连接。该参数设置的是初始化参数。如果生产者需要连接的是Kafka集群，则这里配置集群中几个broker的地址，而不是全部，当生产者连接上此处指定的broker之后，在通过该连接发现集群中的其他节点。
key.serializer	要发送信息的key数据的序列化类。设置的时候可以写类名，也可以使用该类的Class对象。
value.serializer	要发送消息的alue数据的序列化类。设置的时候可以写类名，也可以使用
该类的Class对象。
acks	默认值：all。 acks=0：生产者不等待broker对消息的确认，只要将消息放到缓冲区，就认为消息已经发送完成。该情形不能保证broker是否真的收到了消息，retries配置也不会生效。发送的消息的返回的消息偏移量永远是-1。 acks=1：表示消息只需要写到主分区即可，然后就响应客户端，而不等待副本分区的确认。在该情形下，如果主分区收到消息确认之后就宕机了，而副本分区还没来得及同步该消息，则该消息丢失。 acks=all：首领分区会等待所有的ISR副本分区确认记录。该处理保证了只要有一个ISR副本分区存活，消息就不会丢失。这是Kafka最强的可靠性保证，等效于 acks=-1
retries	retries重试次数，当消息发送出现错误的时候，系统会重发消息。跟客户端收到错误时重发一样。如果设置了重试，还想保证消息的有序性，需要设置MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION=1，否则在重试此失败消息的时候，其他的消息可能发送成功了

其他参数可以从 org.apache.kafka.clients.producer.ProducerConfig 中找到。
消费者生产消息后，需要broker端的确认，可以同步确认，也可以异步确认。同步确认效率低，异步确认效率高，但是需要设置回调对象。

3.2 SpringBoot 整合 Kafka

首先spring会导入高版本的kafka，高版本会兼容低版本，所以集群中还是需要安装低版本的kafka。
在这里插入图片描述

// 生产者 同步发送消息
package com.lagou.kafka.demon.controller;
import *;

@RestController
public class KafkaSyncProducerController {

    @Autowired
    private KafkaTemplate<Integer,String> template;

    @RequestMapping("send/sync/{message}")
    public String send(@PathVariable String message){

        ListenableFuture<SendResult<Integer, String>> send = template.send("topic-spring-01", 0, 0, message);

        //同步发送消息
        try {
            SendResult<Integer, String> sendResult = send.get();
            RecordMetadata recordMetadata = sendResult.getRecordMetadata();
            System.out.println(recordMetadata.topic() + "\t"
                    + recordMetadata.partition() + "\t"
                    + recordMetadata.offset());

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        return "success";
    }

}

// 生产者异步发送消息

package com.lagou.kafka.demon.controller;

import *;

@RestController
public class KafkaASyncProducerController {

    @Autowired
    private KafkaTemplate<Integer,String> template;

    @RequestMapping("send/async/{message}")
    public String send(@PathVariable String message){

        ListenableFuture<SendResult<Integer, String>> send = template.send("topic-spring-01", 0, 1, message);

        //异步发送消息 异步等待broker端的返回结果
        send.addCallback(new ListenableFutureCallback<SendResult<Integer, String>>() {
            @Override
            public void onFailure(Throwable throwable) {
                System.out.println("发送消息失败");
            }

            @Override
            public void onSuccess(SendResult<Integer, String> result) {
                RecordMetadata metadata = result.getRecordMetadata();
                System.out.println("发送消息成功" + metadata.topic() + "\t"
                        + metadata.partition() + "\t"
                        + metadata.offset());

            }
        });

        return "success";
    }

}

// 消费者
package com.lagou.kafka.demon.consumer;

import *;

@Component
public class MyConsumer {

    @KafkaListener(topics = "topic-spring-01")
    public void onMessage(ConsumerRecord<Integer,String> record){
        System.out.println("消费者收到的消息："
                + record.topic() + "\t"
                + record.partition() + "\t"
                + record.offset() +"\t"
                + record.key() + "\t"
                + record.value());
    }
}

// 可以自定义config文件
// kafka会自动创建分区，且可以覆盖原有设置
package com.lagou.kafka.demon.config;

import *;

@Configuration
public class KafkaConfig {

    @Bean
    public NewTopic topic(){
        //分区 副本(short)
        return new NewTopic("nptc-01",3, (short)1);
    }

    @Bean
    public NewTopic topic2(){
        //分区 副本(short)
        return new NewTopic("nptc-02",5, (short)1);
    }

    public KafkaAdmin kafkaAdmin(){
        Map<String, Object> configs = new HashMap<>();
        configs.put("bootstrap.servers","centos7-1:9090");
        KafkaAdmin kafkaAdmin = new KafkaAdmin(configs);
        return kafkaAdmin;
    }

    @Bean
    @Autowired
    public KafkaTemplate<Integer, String> kafkaTemplate(ProducerFactory<Integer,String> producerFactory){

        //覆盖原有ProducerFactory原有设置
        Map<String,Object> configsOverride = new HashMap<>();
        configsOverride.put(ProducerConfig.BATCH_SIZE_CONFIG,200);

        KafkaTemplate<Integer,String> template = new KafkaTemplate<Integer, String>(
                producerFactory,configsOverride
        )：
        return template;
    }
}

4 服务端参数配置

$KAFKA_HOME/config/server.properties文件中的配置。

4.1 zookeeper.connect

该参数用于配置Kafka要连接的Zookeeper/集群的地址。
它的值是一个字符串，使用逗号分隔Zookeeper的多个地址。Zookeeper的单个地址是host:port 形式的，可以在最后添加Kafka在Zookeeper中的根节点路径。
如：

zookeeper.connect=centos7-1:2181,centos7-2:2181,centos7-3:2181/myKafka

4.2 listeners

用于指定当前Broker向外发布服务的地址和端口。与 advertised.listeners 配合，用于做内外网隔离。
此时，生产和消费的地址都需要基于listeners来改变。
在这里插入图片描述
内外网隔离配置(管理和业务分开)：
listener.security.protocol.map
监听器名称和安全协议的映射配置。比如，可以将内外网隔离，即使它们都使用SSL。
注：此时监听器的名称/端口号都不能一样
listener.security.protocol.map=INTERNAL:SSL,EXTERNAL:SSL
在这里插入图片描述
此时配置完会报错，还需要配置：
inter.broker.listener.name
用于配置broker之间通信使用的监听器名称，该名称必须在advertised.listeners列表中。
inter.broker.listener.name=EXTERNAL
advertised.listeners
需要将该地址发布到zookeeper供客户端使用，如果客户端使用的地址与listeners配置不同。可以在zookeeper的 get /myKafka/brokers/ids/<broker.id> 中找到。
在这里插入图片描述

4.3 broker.id

该属性用于唯一标记一个Kafka的Broker，它的值是一个任意integer值。
当Kafka以分布式集群运行的时候，尤为重要。最好该值跟该Broker所在的物理主机有关的，如主机名为 host1.lagou.com ，则 broker.id=1 ，如果主机名为 192.168.100.101 ，则 broker.id=101 等等。

4.4 log.dir

通过该属性的值，指定Kafka在磁盘上保存消息的日志片段的目录。它是一组用逗号分隔的本地文件系统路径。如果指定了多个路径，那么broker 会根据“最少使用”原则，把同一个分区的日志片段保存到同一个路径下。broker 会往拥有最少数目分区的路径新增分区，而不是往拥有最小磁盘空间的路径新增分区。
在这里插入图片描述

Shawlizao

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
大数据学习_消息中间件_Kafka架构与实战

目录1 概念和基本架构1.1 Kafka介绍1.2 Kafka优势1.3 Kafka应用场景1.4 kafka基本架构1.5 核心概念2 Kafka安装与配置2.1 Kafka启动与基本命令3 Kafka开发实战3.1 消息的发送与接收3.2 SpringBoot 整合 Kafka1 概念和基本架构1.1 Kafka介绍Kafka是最初由Linkedin公司开发，是一个分布式、分区的、多副本的、多生产者、多订阅者，基于zookeeper协调的分布式日志系统（也可以当做MQ系统），常见可以用于web
复制链接

扫一扫

专栏目录