注:示例代码使用的语言是Python
1、生产者消息发送流程
1.1、发送原理
- 在消息发送的过程中,涉及到了两个线程——main 线程和 Sender 线程。在 main 线程 中创建了一个双端队列 RecordAccumulator。main 线程将消息发送给 RecordAccumulator, Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。
参数说明:
- batch size:只有数据积累到batch.size之后,sender才会发送数据。默认16K
- linger.ms:如果数据迟迟未达到batch.size,sender等待linger.ms设置的时间到了之后在发送是数据。单位ms,默认值为0ms,表示没有延迟。
- acks: - 0:生产者发送过来的数据不需要等待应答,异步发送。- 1:生产者发送过来的数据,需要等待Leader收到后应该。- -1(all):生产者发送过来的数据,Leader和ISR(In-Sync Replicas)队列里面所有的节点收齐数据后应答。注:-1与all等价
2、异步发送 API
2.1、普通异步发送
示例:创建 Kafka 生产者,采用异步的方式发送到 Kafka Broker
from kafka3 import KafkaProducer
def producer(topic: str, msg: str, partition=0):
"""
:function: 生产者,生产数据
:param topic: 写入数据所在的topic
:param msg: 写入的数据
:param partition: 写入数据所在的分区
:return:
"""
print("开始生产数据......")
# 初始化生产者对象,bootstrap_servers参数传入kafka集群
# 将acks的值设为0,acks=0,此方式也是异步的方式,但是生产环境中不会这样使用,因为存在数据丢失的风险
# producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"], acks=0)
producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
# 将发送消息转换成bytes类型,编码使用utf-8
future = producer.send(topic=topic, value=bytes(msg, 'utf-8'), partition=partition)
producer.close()
if __name__ == '__main__':
msg = "this is profucer01"
topic = "first"
producer(topic, msg)
2.2、带回调函数的异步发送
- 回调函数会在 producer 收到 ack 时调用,为异步调用,该方法有两个参数,分别是元 数据信息(RecordMetadata)和异常信息(Exception),如果 Exception 为 null,说明消息发 送成功,如果 Exception 不为 null,说明消息发送失败。
- 注意:消息发送失败会自动重试,不需要在回调函数中手动重试。
"""
带回调函数的异步发送
回调函数会在 producer 收到 ack 时调用,为异步调用,该方法有两个参数,分别是元数据信息(RecordMetadata)和异常信息(Exception),
如果 Exception 为 null,说明消息发送成功,如果 Exception 不为 null,说明消息发送失败。
"""
from kafka3 import KafkaProducer
def producer(topic: str, msg: str, partition=0):
"""
:function: 生产者,生产数据
:param topic: 写入数据所在的topic
:param msg: 写入的数据
:param partition: 写入数据所在的分区
:return:
"""
print("开始生产数据......")
# 定义发送成功的回调函数
def on_send_success(record_metadata):
print("消息成功发送到主题:", record_metadata.topic)
print("分区:", record_metadata.partition)
print("偏移量:", record_metadata.offset)
# 定义发送失败的回调函数
def on_send_error(excp):
print("发送消息时出现错误:", excp)
# 可以根据实际情况执行一些错误处理逻辑
# 初始化生产者对象,bootstrap_servers参数传入kafka集群
producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
# 将发送消息转换成bytes类型,编码使用utf-8
producer.send(topic=topic, value=bytes(msg, 'utf-8'), partition=partition).add_callback(on_send_success).add_errback(on_send_error)
producer.close()
3、同步发送 API
- 只需在异步发送的基础上,再调用一下 get()方法即可。或者将acks的值设为all,acks="all",此方式也是同步的方式。
from kafka3 import KafkaProducer
def producer(topic: str, msg: str, partition=0):
"""
:function: 生产者,生产数据
:param topic: 写入数据所在的topic
:param msg: 写入的数据
:param partition: 写入数据所在的分区
:return:
"""
print("开始生产数据......")
# 初始化生产者对象,bootstrap_servers参数传入kafka集群
# 将acks的值设为all,acks="all",此方式也是同步的方式.
# producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"], acks="all")
producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
# 将发送消息转换成bytes类型,编码使用utf-8
future = producer.send(topic=topic, value=bytes(msg, 'utf-8'), partition=partition)
# 等待 Future 返回结果,设置超时时间为10秒
future.get(timeout=10)
producer.close()
4、生产者分区
4.1、分区的优势
- 1、便于合理使用存储资源,每个Partition在一个Broker上存储,可以把海量的数据按照分区切割成一 块一块数据存储在多台Broker上。合理控制分区的任务,可以实现负载均衡的效果。
- 2、提高并行度,生产者可以以分区为单位发送数据;消费者可以以分区为单位进行消费数据。
4.2、生产者发送消息的分区策略
- 1、如果不指定分区,会使用默认分区策略。默认分区策略如下: - 如果key存在的情况下,将key的hash值与topic的partition进行取余得到partition值- 如果key不存在的情况下,会随机选择一个分区
- 2、如果指明了分区,那么将会把数据发送到指定分区
示例1:将数据发往指定 partition
- 将所有数据发往分区 0 中。
# 指定分区
def producer_01(topic: str, msg: str, partition=0):
"""
:function: 指定分区
:param topic: 写入数据所在的topic
:param msg: 写入的数据
:param partition: 写入数据所在的分区
:return:
"""
# 初始化生产者对象,bootstrap_servers参数传入kafka集群
producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
# 将发送消息转换成bytes类型,编码使用utf-8
future = producer.send(topic=topic, value=bytes(msg, 'utf-8'), partition=partition)
try:
# 等待消息发送完成
sendResult = future.get(timeout=10)
print(f"消息: {msg}\n所在的分区: {sendResult.partition}\n偏移量为: {sendResult.offset}\n")
# 关闭生产
producer.close()
except KafkaError as e:
print(f"消息: {msg} 发送失败\n失败信息为: {e}\n")
msg = "this is partition"
topic = "first"
for i in range(5):
producer_01(topic, msg+str(i))
示例2:有 key 的情况下将数据发送到Kafka
- 没有指明 partition 值但有 key 的情况下,将 key 的 hash 值与 topic 的 partition 数进行取 余得到 partition 值。
# 没有指明 partition 值但有 key 的情况下,将 key 的 hash 值与 topic 的 partition 数进行取余得到 partition 值。
def producer_02(topic: str, msg: str, key: str):
"""
:function: 指定分区
:param topic: 写入数据所在的topic
:param msg: 写入的数据
:param key: 发送消息的key值
:return:
"""
# 初始化生产者对象,bootstrap_servers参数传入kafka集群
producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
# 将发送消息转换成bytes类型,编码使用utf-8
future = producer.send(topic=topic, key=bytes(key, 'utf-8'), value=bytes(msg, 'utf-8'))
try:
# 等待消息发送完成
sendResult = future.get(timeout=10)
print(f"消息: {msg}\n所在的分区: {sendResult.partition}\n偏移量为: {sendResult.offset}\n")
# 关闭生产
producer.close()
except KafkaError as e:
print(f"消息: {msg} 发送失败\n失败信息为: {e}\n")
msg = "this is partition"
topic = "first"
key = "a"
for i in range(5):
producer_02(topic, msg+str(i), key)
4.3、自定义分区器
- 可以根据实际需要,自定义实现分区器。
- 示例:自定义分区 发送过来的数据中如果包含 hello,就发往 0 号分区,不包含 hello,就发往 1 号分区。
# 自定义分区 发送过来的数据中如果包含 hello,就发往 0 号分区,不包含 hello,就发往 1 号分区。
def producer_03(topic: str, msg: str):
"""
:function: 自定义分区
:param topic: 写入数据所在的topic
:param msg: 写入的数据
:return:
"""
# 自定义分区器
def my_partitioner(msg):
if "hello" in str(msg):
return 0
else:
return 1
# 初始化生产者对象,bootstrap_servers参数传入kafka集群
producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"])
# 将发送消息转换成bytes类型,编码使用utf-8
future = producer.send(topic=topic, value=bytes(msg, 'utf-8'), partition=my_partitioner(msg))
try:
# 等待消息发送完成
sendResult = future.get(timeout=10)
print(f"消息: {msg}\n所在的分区: {sendResult.partition}\n偏移量为: {sendResult.offset}\n")
# 关闭生产
producer.close()
except KafkaError as e:
print(f"消息: {msg} 发送失败\n失败信息为: {e}\n")
msg = "hello this is partition"
msg1 = "this is partition"
5、生产者提高吞吐量
- 实际工作中,会根据实际的情况动态的调整生产者的吞吐量以适应实际需求,调整吞吐量主要是通过调整以下参数实现: - batch.size:批次大小,默认16k- linger.ms:等待时间,修改为5-100ms- compression.type:压缩snappy- RecordAccumulator:缓冲区大小,默认32m,修改为64m
"""
生产者提高吞吐量
1、linger.ms:等待时间,修改为5-100ms
2、compression.type:压缩snappy
3、RecordAccumulator:缓冲区大小,修改为64m
"""
from kafka3 import KafkaProducer
from kafka3.errors import KafkaError
def producer(topic: str, msg: str):
"""
:function: 生产者,生产数据
:param topic: 写入数据所在的topic
:param msg: 写入的数据
:return:
"""
# 初始化生产者对象,bootstrap_servers参数传入kafka集群
producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"],
linger_ms=5, # linger_ms设置为5ms
compression_type="snappy", # 设置压缩类型为snappy
buffer_memory=64*1024*1024 # 设置缓冲区大小为64MB
)
# 将发送消息转换成bytes类型,编码使用utf-8
future = producer.send(topic=topic, value=bytes(msg, 'utf-8'))
try:
# 等待消息发送完成
sendResult = future.get(timeout=10)
print(f"消息: {msg}\n所在的分区: {sendResult.partition}\n偏移量为: {sendResult.offset}\n")
# 关闭生产
producer.close()
except KafkaError as e:
print(f"消息: {msg} 发送失败\n失败信息为: {e}\n")
6、数据可靠性
说明:数据的可靠性保证主要是通过acks的设置来保证的,下面说明acks在不同取值下的数据可靠性情况:
- acks=0时- 因为生产者发送数据后就不管了,所以当Leader或Follower发生异常时,就会发生数据丢失。- 实际使用很少
- acks=1时- 因为生产者只需要等到Leader应答后就算完成本次发生了,但是当Leader应答完成后,还没有开始同步副本数据,Leader此时挂掉,新的Leader上线后并不会收到丢失数据,因为生产者已经认为数据发送成功了,这时就会发生数据丢失。- 实际使用:一般用于传输普通日志
- acks=-1时- 因为生产者需要等到Leader和Follower都收到数据后才算完成本次数据传输,所以可靠性高,但是当分区副本只有1个或者ISR应答的最小副本设置为1,此时和acks=1时效果一样,存在数据丢失的风险。- 实际使用:对可靠性要求较高的场景中,比如涉及到金钱相关的场景
综上分析:要想使得数据完全可靠条件=ACK级别设置为1 + 分区副本数大于等于2 + ISR应答最小副本数大于等于2(min.insync.replicas 参数保证)
Python代码设置acks
# acks取值:0、1、"all"
producer = KafkaProducer(bootstrap_servers=["170.22.70.174:9092", "170.22.70.178:9092", "170.22.70.179:9092"], acks=0)
7、数据去重
- 至少一次(At Least Once)= ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2;可以保证数据不丢失,但是不能保证数据不重复。
- 最多一次(At Most Once)= ACK级别设置为0;可以保证数据不重复,但是不能保证数据不丢失。
那么如何保证数据只存储一次呢?这就需要使用幂等性。
1、幂等性
1、幂等性:
- 1、幂等性就是指Producer不论向Broker发送多少次重复数据,Broker端都只会持久化一条,保证了不重复。
- 2、精确一次(Exactly Once) = 幂等性 + 至少一次( ack=-1 + 分区副本数>=2 + ISR最小副本数量>=2) 。
2、幂等性实现原理:
具有**<PID, Partition, SeqNumber>相同主键的消息提交时,Broker只会持久化一条**。 - 其 中PID是Kafka每次重启都会分配一个新的;- Partition 表示分区号;- Sequence Number 每次发送消息的序列号,是单调自增的。
注意:幂等性只能保证的是在单分区单会话内不重复。
3、使用幂等性
- 开启参数 enable_idempotence 默认为 true,false 关闭。
- 目前的 kafka3 库并不支持直接设置生产者的幂等性。在 Kafka 中启用幂等性需要使用 kafka-python 或其他支持 Kafka 协议的库。
- 以下是使用 kafka-python 库设置生产者的幂等性的示例代码:
from kafka import KafkaProducer
# 创建 KafkaProducer 实例,开启幂等性
producer = KafkaProducer(
bootstrap_servers="127.0.0.1:9092",
acks="all", # 设置 acks 参数为 "all",要求所有副本都确认消息
enable_idempotence=True
)
8、生产者事务
说明:开启事务必须开启幂等性。
1、事务原理
存储事务信息的特殊主题:__transaction_state_分区_Leader
- 默认有50个分区,每个分区负责一部分事务。
- 事务划分是根据transaction.id的hash值%50,计算出该事物属于哪个分区。
- 该分区Leader副本所在的broker节点即为这个transaction.id对应的Transaction Coordinator节点。
注意事项:生产者在使用事务功能之前,必须先自定义一个唯一的transaction.id。有了该transaction.id,即使客户端挂掉了,它重启之后也能继续处理未完成的事务。
2、使用事务
- 目前的 kafka3 库并不支持直接创建事务。Kafka 事务的支持需要使用 kafka-python 或其他支持 Kafka 协议的库。
- 以下是使用 kafka-python 库创建事务的示例代码:
from kafka import KafkaProducer
from kafka.errors import KafkaError
# 创建 KafkaProducer 实例,开启事务
producer = KafkaProducer(
bootstrap_servers="127.0.0.1:9092",
enable_idempotence=True # 开启幂等性
)
# 初始化事务
producer.init_transactions()
# 开始事务
producer.begin_transaction()
try:
# 发送事务性消息
for i in range(3):
key = b"my_key"
value = b"my_value_%d" % i
producer.send("my_topic", key=key, value=value)
# 提交事务
producer.commit_transaction()
except KafkaError as e:
# 回滚事务
producer.abort_transaction()
print(f"发送消息失败: {e}")
finally:
# 关闭 KafkaProducer 实例
producer.close()
9、数据的有序性
说明:数据的有序性只能保证单分区有序,分区与分区之间是无序的。
1、Kafka在1.x版本之前保证数据单分区有序,条件如下:
- max.in.flight.requests.per.connection=1 (不需要开启幂等性)
2、Kafka在1.x版本之后保证数据单分区有序,条件如下:
- 未开启幂等性- 设置:max.in.flight.requests.per.connection=1
- 开启幂等性- 设置:max.in.flight.requests.per.connection 小于等于5- 原因:因为在Kafka1.x以后,启用幂等性,Kafka服务端会缓存生产者发来的最近5个request的元数据,所以至少可以保证最近5个request的数据都是有序的。
版权归原作者 测试有道 所有, 如有侵权,请联系我们删除。