在消息发送的过程中，涉及到了两个线程——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的数据都是有序的。

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/495776