[Kafka] Apache Kafka 简介、集群搭建及配置详解

最新推荐文章于 2024-04-10 10:02:22 发布

置顶 Jia的博客

最新推荐文章于 2024-04-10 10:02:22 发布

阅读量457

点赞数 1

本文链接：https://blog.csdn.net/Konaji/article/details/83591014

版权

Kafka 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

前言

kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者规模的网站中的所有动作流数据。这种动作（网页浏览，搜索和其他用户的行动）是在现代网络上的许多社会功能的一个关键因素。这些数据通常是由于吞吐量的要求而通过处理日志和日志聚合来解决。

Kafka中相关名词

producer：生产者。
consumer：消费者。
topic: 消息以topic为类别记录,Kafka将消息种子(Feed)分门别类,每一类的消息称之为一个主题(Topic)。
broker：以集群的方式运行,可以由一个或多个服务组成，每个服务叫做一个broker;消费者可以订阅一个或多个主题(topic),并从Broker拉数据,从而消费这些已发布的消息。每个消息（也叫作record记录,也被称为消息）是由一个key，一个value和时间戳构成。

Kafka的应用场景

构建实时的流数据管道，可靠地获取系统和应用程序之间的数据。
构建实时流的应用程序，对数据流进行转换或反应。

Kafka集群部署

mkdir -p /usr/kafka  (多台机器同步创建)
tar -xzvf kafka_2.11-0.11.0.0.tgz -C /usr/kafka/

创建日志存放目录

mkdir -p /usr/data/kafka/logs (多台机器同步创建)

修改配置文件 (server.properties)

# 进入配置文件目录
cd /usr/kafka/kafka_2.11-0.11.0.0/config
# 查看配置信息 (自己可以在这配置基础上进行配置修改,复制出来修改即可)
cat server.properties | grep -v "#"
# 将配置文件移除并备份
mv server.properties server.properties.bak
# 配置新的配置信息
vim server.properties

填入以下内容

# 需要修改集群之间的brokerId
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=/usr/data/kafka/logs
num.partitions=1
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.retention.hours=168
log.segment.bytes=1073741824
log.retention.check.interval.ms=300000
# 修改ZK的连接地址
zookeeper.connect=node1:2181,node2:2181,node3:2181
zookeeper.connection.timeout.ms=6000
group.initial.rebalance.delay.ms=0
# 需要修改 hostname 每个机器上不一样
delete.topic.enable=true
host.name=node1

分发

scp -r /usr/kafka/kafka_2.11-0.11.0.0/ root@node2:/usr/kafka/
scp -r /usr/kafka/kafka_2.11-0.11.0.0/ root@node3:/usr/kafka/

修改node2与node3的配置文件 (server.properties)

# node2
broker.id=1
host.name=node2

# node3
broker.id=2
host.name=node3

启动方式一 :

cd /usr/kafka/kafka_2.11-0.11.0.0/bin
./kafka-server-start.sh /usr/kafka/kafka_2.11-0.11.0.0/config/server.properties

启动方式二 : 后台启动

# 注 : 这里是一行命令
nohup /usr/kafka/kafka_2.11-0.11.0.0/bin/kafka-server-start.sh 
/usr/kafka/kafka_2.11-0.11.0.0/config/server.properties >/dev/null 2>&1 &

Kafka 命令行的使用

创建topic

./kafka-topics.sh --create --zookeeper node1:2181 --topic test --partitions 1 --replication-factor 3

topic 主题的名字
zookeeper zookeeper地址
partitions 副本，副本的作用是备份
replication-factor 分片，分片的作用是分治

显示所有topic

./kafka-topics.sh --list --zookeeper node01:2181

查看topic

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

删除topic

./kafka-topics.sh --delete --topic test --zookeeper node1:2181

查看offset的最大值

bin/kafka-run-class.sh kafka.tools.GetOffsetShell --broker-list node1:9092 -topic test --time -1

查看offset的最小值

bin/kafka-run-class.sh kafka.tools.GetOffsetShell --broker-list node1:9092 -topic test --time -2

生产数据

# 单机启动
./kafka-console-producer.sh --topic order --broker-list node1:9092

# 集群启动
./kafka-console-producer.sh --topic order --broker-list node1:9092,node2:9092,node3:9092

消费数据

# 单机启动
./kafka-console-consumer.sh --topic order --bootstrap-server node1:9092

# 集群启动
./kafka-console-consumer.sh --topic order --bootstrap-server node1:9092,node2:9092,node3:9092

# 从最原始偏移量消费消息
./kafka-console-consumer.sh --topic order --bootstrap-server node1:9092 --from-beginning

Java 操作

引入pom依赖

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>1.0.0</version>
</dependency>

生产者

ProducerPro.java 配置文件

public class ProducerPro {
    public static Properties props = new Properties();
    static {
        //指定kafka的broker地址
        props.put("bootstrap.servers", "node1:9092,node2:9092,node3:9092");
        //消息确认机制 有4个值(0,1,-1,all)
        props.put("acks", "all");
        //重试次数
        props.put("retries", 0);
        //默认的批量处理消息字节数
        props.put("batch.size", 16384);
        //消息字节数比batch.size要小的多，我们需要linger特定的时间以获取更多的消息
        //这个设置默认为0，即没有延迟。设定linger.ms=1
        //例如，将会减少请求数目，但是同时会增加1ms的延迟。
        props.put("linger.ms", 1);
        props.put("buffer.memory", 33554432);
        /**
         * 序列化的作用：为了数据的保存和传输。
         * product：name=zhangsan,age=10,sex=0
         * 序列化：将对象保存到本地，product--->  name=zhangsan,age=10,sex=0
         * 发序列化：name=zhangsan,age=10,sex=0  -->product
         *      k:name v:zhangsan
         *      k:age  v:10
         *      k:sex  v:0
         *      Class.forname()
         */
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
    }
}

MyProducer.java

public class MyProducer {

    public static void main(String[] args) {
        //主题
        String topic = "test";
        //推送的数据
        String value = "msg";
        KafkaProducer<String, String> kafkaProducer =
                new KafkaProducer<String, String>(ProducerPro.props);
        ProducerRecord record = new ProducerRecord(topic,value);
        kafkaProducer.send(record);
        kafkaProducer.flush();
        kafkaProducer.close();
    }

}

消费者

ConsumerPro.java 配置文件

public class ConsumerPro {
    public static Properties props = new Properties();
    static {
        //指定kafka集群地址
        props.put("bootstrap.servers", "node1:9092,node2:9092,node3:9092");
        //指定消费者组id
        props.put("group.id", "group1");
        //是否自动提交offset
        // 0.8以前，保存在zookeeper，0.8+以后的版本，保存到topic下，这个topic叫做 __consumer_offsets
        props.put("enable.auto.commit", "true");
        //自动确认offset的时间间隔
        props.put("auto.commit.interval.ms", "1000");
        // key的序列化类  持久化（网络、磁盘），反序列化就是讲磁盘或者网络中的数据还原对象。
        props.put("key.deserializer", 
                  "org.apache.kafka.common.serialization.StringDeserializer");
        // value的序列化类
        props.put("value.deserializer", 
                  "org.apache.kafka.common.serialization.StringDeserializer");
    }
}

MyConsumer.java

public class MyConsumer {

    public static void main(String[] args) {
        //订阅主题 (这里可以订阅多个主题,可以同时接收多个主题消息)
        List<String> topics = new ArrayList();
        topics.add("test");
        topics.add("test1");
        KafkaConsumer<String,String> kafkaConsumer = new KafkaConsumer(ConsumerPro.props);
        kafkaConsumer.subscribe(topics);
        while (true) {
            ConsumerRecords<String, String> poll = kafkaConsumer.poll(1000);
            for (ConsumerRecord<String, String> record : poll) {
                String value = record.value();
                System.out.println(value);
            }
        }
    }

}

自定义Partition

MyPartitioner.java

public class MyPartitioner implements Partitioner {
    @Override
    public int partition(String topic, Object key,
                         byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        int numPartition = cluster.availablePartitionsForTopic(topic).size();
        if (keyBytes==null){
            String uuid = UUID.randomUUID().toString();
            int index = Math.abs(uuid.hashCode() % numPartition);
            return index;
        }else{
            int index = Math.abs(keyBytes.hashCode() % numPartition);
            return index;
        }
    }

    @Override
    public void close() {}

    @Override
    public void configure(Map<String, ?> map) {}
}

修改配置文件

props.put("partition.class","com.kafka.test.demo.MyPartitioner");

配置文件

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/servers/kafka/kafka-logs

#topic在当前broker上的分片个数
num.partitions=2

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

#segment文件保留的最长时间，超时将被删除（默认保留168小时=7天）
log.retention.hours=168
#一个topic的数据量大小达到一定阀值时，会删除topic的数据，默认等于-1,表示没有限制
log.retention.bytes=-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=node1:2181,node2:2181,node3: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=node1
#广播地址，主要用于外网连接kafka集群，一般用不到
advertised.host.name=192.168.200.100

Producer.properties

#指定kafka节点列表，用于获取metadata，不必全部指定（老版本这样指定）
metadata.broker.list=node1:9092,node2:9092,node3:9092

# 指定分区处理类。默认kafka.producer.DefaultPartitioner，表通过key哈希到对应分区
partitioner.class=kafka.producer.DefaultPartitioner

# 是否压缩，默认0表示不压缩，1表示用gzip压缩，2表示用snappy压缩。压缩后消息中会有头来指明消息压缩类型，故在消费者端消息解压是透明的无需指定。
gzip   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=0 

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

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

# 在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

Consumer.properties

# zookeeper连接服务器地址
zookeeper.connect=node1:2181,node2:2181,node3:2181

# zookeeper的session过期时间，默认5000ms，用于检测消费者是否挂掉
zookeeper.session.timeout.ms=5000

#当消费者挂掉，其他消费者要等该指定时间才能检查到并且触发重新负载均衡
zookeeper.connection.timeout.ms=10000

#ZooKeeper集群中leader和follower之间的同步时间
zookeeper.sync.time.ms=2000
#指定 消费者组id
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

# 当有新的consumer加入到group时,将会reblance,此后将会有partitions的消费端迁移到新的consumer上,如果一个consumer获得了某个partition的消费权限,那么它将会向zk注册 "Partition Owner registry"节点信息,但是有可能此时旧的consumer尚没有释放此节点, 此值用于控制,注册节点的重试次数. 
rebalance.max.retries=5

# 发送到消费端的最小数据，若是不满足这个数值则会等待直到满足指定大小。默认为1表示立即接收
fetch.min.bytes=1

# 当消息的尺寸不足时,server阻塞的时间,如果超时,消息将立即发送给consumer
fetch.wait.max.ms=5000
socket.receive.buffer.bytes=655360

# 如果zookeeper没有offset值或offset值超出范围。那么就给个初始的offset。
# earliest：当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
# latest当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据
# none:topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常
auto.offset.reset=earliest

# 指定序列化处理类
derializer.class=kafka.serializer.DefaultDecoder

Jia的博客

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
[Kafka] Apache Kafka 简介、集群搭建及配置详解

Apache Kafka 简介、集群搭建及配置详解前言kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者规模的网站中的所有动作流数据。这种动作（网页浏览，搜索和其他用户的行动）是在现代网络上的许多社会功能的一个关键因素。这些数据通常是由于吞吐量的要求而通过处理日志和日志聚合来解决。Kafka中相关名词producer：生产者。consumer：消费者。topic: 消...
复制链接

扫一扫