罗罗编程学习记录
本页内容 展开查看

04.4.10.2 Kafka、RabbitMQ 与 NATS、MQTT

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.4 Rust / 04.4.10 缓存消息队列与后台任务

04.4.10.2-001 rdkafka 在 Rust 生态中处于什么位置,它和 librdkafka 是什么关系?

一句话结论

rdkafka 是 librdkafka 的 Rust 绑定封装,Rust 服务接入 Kafka 的主流选择;它在 C 库之上提供类型安全的 producer、consumer 与配置接口,底层消息收发仍由 librdkafka 的内部线程完成。

概念解释

rdkafka 不是纯 Rust 实现的 Kafka 客户端,而是通过 FFI 调用 C 语言编写的 librdkafka。这意味着协议解析、批量攒包、连接管理、rebalance 协调等重逻辑都在 C 侧完成,Rust 侧负责把配置、消息、回调包装成安全类型。因此构建时通常需要链接 librdkafka 或通过 feature 触发其编译,具体 feature 名称以 docs.rs/rdkafka 当前版本为准。

原理流程

  1. 在 Cargo.toml 引入 rdkafka,按需要开启 TLS 与构建相关 feature。
  2. ClientConfig 把键值配置透传给底层 librdkafka 句柄。
  3. create::<T>() 按类型构造 producer 或 consumer,底层建立连接与内部线程。
  4. 发送与消费调用进入 C 库,结果通过 Future 或回调回到 Rust 侧。
  5. 句柄 drop 时释放底层资源,producer 通常需要显式 flush。

代码或图示

[dependencies]
rdkafka = { version = "*", features = ["tokio"] }

常见误区

  • 以为 rdkafka 是纯 Rust 客户端,不了解其 C 依赖,部署镜像里缺少编译工具链或 TLS 库。
  • 以为 Rust 侧的 Future 直接驱动网络 IO,实际上 IO 由 librdkafka 内部线程完成。

追问

  • 为什么不直接用 FFI 调 librdkafka?答:rdkafka 封装了生命周期、消息类型与回调安全边界,避免裸指针与悬垂引用。
  • 构建失败提示找不到 librdkafka 怎么办?答:确认构建 feature 与系统依赖(编译器、TLS 库),具体 feature 组合查 docs.rs/rdkafka 当前版本。

04.4.10.2-002 FutureProducer、FutureConsumer 与 StreamConsumer 分别属于哪类 API?

一句话结论

FutureProducer 是异步生产者;消费侧分两类:StreamConsumer 以 Stream 形式逐条产出消息,FutureConsumer 面向手动 poll 与回调式上下文;选型上 tokio 服务优先 StreamConsumer。

概念解释

rdkafka 的 producer 只有 FutureProducer 这一异步形态,发送结果通过 DeliveryFuture 返回。consumer 侧,StreamConsumer 实现了 consumer_stream(),可直接在 while let Some(msg) 循环里 await;FutureConsumer 保留了基于 poll 的手动拉取模型,适合需要精细控制轮询节奏或自定义上下文的场景。两者共享 Consumer trait 上的订阅、提交 offset 等能力。

原理流程

  1. ClientConfig::new() 填配置后 create::<FutureProducer>() 或 create::<StreamConsumer>()。
  2. StreamConsumer 调用 subscribe 后用 consumer_stream() 得到消息流。
  3. 循环 while let Some(owned_msg) = stream.next().await 处理消息。
  4. 处理完成后按策略提交 offset。
  5. 退出循环前关闭 consumer,释放分区分配。

代码或图示

use rdkafka::consumer::{Consumer, StreamConsumer};
use rdkafka::ClientConfig;

let consumer: StreamConsumer = ClientConfig::new()
    .set("group.id", "order-consumer")
    .set("bootstrap.servers", "localhost:9092")
    .create()?;
consumer.subscribe(&["orders"])?;

常见误区

  • 把 FutureConsumer 当成 StreamConsumer 直接 .next().await,类型不匹配。
  • 以为三种类型共享同一套发送接口:只有 producer 有 send,consumer 没有发送概念。

追问

  • StreamConsumer 的消息流是否会自动拉取?答:会,流内部持续 poll 底层 consumer,迭代时按需产出。
  • 自定义消费上下文用哪个类型?答:实现 ConsumerContext trait,配合带上下文的 consumer 类型注册回调。

04.4.10.2-003 如何用 ClientConfig 创建一个 FutureProducer?

一句话结论

先 ClientConfig::new(),用 set 填入 bootstrap.servers 等键值,再 create::<FutureProducer>() 完成构造;配置项名称与 librdkafka 官方配置表一致。

概念解释

ClientConfig 是一个键值配置容器,set 接收字符串键与字符串值,所有配置原样透传给 librdkafka。create 是泛型方法,通过目标类型推断构造对应客户端。生产者最基础的配置是 bootstrap.servers;认证、TLS、批量参数都通过同一容器追加。配置非法或连接参数缺失会在 create 阶段返回 KafkaError。

原理流程

  1. ClientConfig::new() 建立空配置表。
  2. set("bootstrap.servers", "host1:9092,host2:9092") 填引导地址。
  3. 按需追加 message.timeout.ms、compression.type 等参数。
  4. create::<FutureProducer>() 初始化底层 producer 实例。
  5. 拿到 producer 句柄后即可发送消息。

代码或图示

use rdkafka::producer::FutureProducer;
use rdkafka::ClientConfig;

let producer: FutureProducer = ClientConfig::new()
    .set("bootstrap.servers", "localhost:9092")
    .set("message.timeout.ms", "5000")
    .create()?;

常见误区

  • 把 Rust 风格的 producer.servers = ... 当配置方式,实际必须用 set 键值对。
  • 以为 create 会阻塞等到所有 broker 就绪,它只初始化客户端,真正连接是异步建立的。

追问

  • 配置项写错名称会怎样?答:librdkafka 通常在日志中告警未知配置,行为不确定,需对照官方配置表核对。
  • 多个 broker 地址怎么写?答:逗号分隔,客户端从中任取引导节点发现集群拓扑。

04.4.10.2-004 FutureRecord 包含哪些关键字段?

一句话结论

FutureRecord 描述一条待发送消息:目标 topic、可选分区、key、payload、headers 与时间戳;topic 必填,其余可缺省。

概念解释

在 rdkafka 中构造消息不是直接传裸字节,而是用 FutureRecord::to(topic) 起步,链式调用 .key(..)、.payload(..)、.headers(..) 填充。分区可显式指定,不指定时由分区器按 key 哈希决定。payload 与 key 都是字节切片引用,发送期间生命周期由底层拷贝保证。时间戳不填则由 broker 追加时生成。

原理流程

  1. FutureRecord::to("orders") 绑定目标 topic。
  2. .key(&key) 提供分区键,保证同 key 落到同一分区。
  3. .payload(serde_json::to_vec(&body)?) 提供消息体。
  4. 可选 .headers(Headers::new()) 附加消息头。
  5. 把 record 交给 producer.send 进入批量发送流程。

代码或图示

use rdkafka::producer::{FutureProducer, FutureRecord};

let record = FutureRecord::to("orders")
    .key(b"order-1001")
    .payload(b"{\"status\":\"paid\"}");
let delivery = producer.send(record, std::time::Duration::from_secs(5));

常见误区

  • 把 payload 写成 String 直接传入,类型要求是字节切片,需先 into_bytes()。
  • 以为不指定 key 时消息按轮询分区,默认分区策略是哈希 key,无 key 时行为取决于配置。

追问

  • headers 如何追加自定义字段?答:构造 Headers 后 insert 键值,再挂到 record 上;具体方法名以 docs.rs/rdkafka 当前版本为准。
  • 时间戳字段在 record 上怎么设置?答:record 提供 timestamp 入口,不设置则由 broker 侧写入 LogAppendTime。

04.4.10.2-005 send 返回的 DeliveryFuture 何时 resolve,能拿到什么?

一句话结论

send 返回 DeliveryFuture,在 broker 确认写入(或发送失败、超时)后 resolve,成功时返回分区号与 offset,失败时携带 KafkaError。

概念解释

DeliveryFuture 代表「这条消息最终落盘结果」的承诺,而不是「消息已进入本地缓冲区」。它 resolve 的时机由 ack 配置决定:broker 写入副本并满足 acks 条件后才算成功。Future 中可读取 (i32, i64) 形式的分区与 offset;若在等待期内消息超时或被拒绝,Future 返回错误。不 await 这个 Future,本地缓冲区可能堆积且无法感知失败。

原理流程

  1. producer.send(record, timeout) 把消息放入本地队列并返回 Future。
  2. librdkafka 攒批发送到 broker。
  3. broker 按 acks 配置确认副本写入。
  4. Future resolve:成功给出分区与 offset,失败给出错误。
  5. 调用方根据结果记录发送日志或触发重试。

代码或图示

match delivery.await {
    Ok((partition, offset)) => {
        println!("sent to {partition} @ {offset}");
    }
    Err((err, _record)) => eprintln!("send failed: {err}"),
}

常见误区

  • 只调用 send 不 await,以为消息已成功发出。
  • 把 DeliveryFuture 的 resolve 等同于网络包已发出,实际是 broker 确认完成。

追问

  • 不 await Future 会丢消息吗?答:消息仍可能发出,但失败无人感知,且内部等待队列可能占用资源;生产代码应消费该 Future。
  • 超时参数起什么作用?答:限制等待交付结果的时长,超时后 Future 返回错误,具体语义对照 librdkafka message.timeout.ms。

04.4.10.2-006 生产者发送失败有哪些类型,发送错误与生产错误如何区分?

一句话结论

rdkafka 的错误分两类:调用 send 阶段的本地错误(队列满、序列化失败)与交付阶段的 KafkaError(broker 拒绝、超时、可重试);处理时要分别判断。

概念解释

本地错误发生在消息进入 producer 队列之前,例如缓冲区已满、记录字段非法,此时 send 直接返回错误。交付错误发生在 Future resolve 时,例如 broker 返回消息过大、授权失败、消息超时未确认。KafkaError 携带错误标签,部分错误可重试(临时网络抖动),部分不可重试(消息体超限、认证失败),重试前需分类。

原理流程

  1. 序列化 payload,构造 FutureRecord。
  2. send 入队:本地错误直接返回,不进入交付流程。
  3. 等待 DeliveryFuture resolve。
  4. 解析 KafkaError:可重试错误进入退避重发,不可重试错误转死信或告警。
  5. 记录错误类型、topic、key 便于排错。

代码或图示

match delivery.await {
    Ok(_) => {}
    Err((rdkafka::error::KafkaError::MessageProduction(code, _), _)) => {
        eprintln!("broker rejected: {code:?}");
    }
    Err((other, _)) => eprintln!("other failure: {other}"),
}

常见误区

  • 对所有交付错误都无脑重试,把消息超限、权限拒绝这类不可恢复错误也反复重发。
  • 忽略本地队列满错误,以为消息已经交给 broker。

追问

  • 如何判断错误是否可重试?答:对照 librdkafka 错误标签分类,网络/超时类可重试,参数/授权类不可重试;不确定时查官方错误表。
  • 消息体超限在哪一层暴露?答:通常在 broker 确认阶段返回 MessageProduction 错误,本地序列化阶段不一定拦截。

04.4.10.2-007 消费者组在 rdkafka 中如何配置与订阅?

一句话结论

配置 group.id 即加入消费者组,subscribe 传入 topic 列表后,组内成员自动做分区分配与 rebalance;同一组内一条分区只被一个成员消费。

概念解释

消费者组是 Kafka 横向扩展消费的基本单位:group.id 标识组,broker 把订阅 topic 的分区在组成员间分配。新成员加入或成员掉线都会触发 rebalance,分区在成员间重新分配。rdkafka 的 StreamConsumer 与 FutureConsumer 都通过 Consumer trait 的 subscribe 订阅;订阅后无需手动指定分区,组协调器负责分配。

原理流程

  1. 配置 group.id、bootstrap.servers、auto.offset.reset。
  2. create::<StreamConsumer>() 构造消费者。
  3. consumer.subscribe(&["topic-a", "topic-b"])? 声明订阅。
  4. 底层加入组、参与 rebalance、拿到分配分区。
  5. 从已提交 offset 开始逐条消费。

代码或图示

let consumer: StreamConsumer = ClientConfig::new()
    .set("group.id", "payment-consumer-group")
    .set("bootstrap.servers", "localhost:9092")
    .set("auto.offset.reset", "earliest")
    .create()?;
consumer.subscribe(&["payments"])?;

常见误区

  • 不同部署环境共用同一个 group.id,导致测试流量抢走生产分区。
  • 以为 subscribe 会立即拿到分区,实际分配在 rebalance 完成后才生效。

追问

  • 一个 topic 分区数少于组内成员会怎样?答:多余成员分配不到分区,空闲等待,不会重复消费。
  • group.id 改了会发生什么?答:相当于新组,从 auto.offset.reset 指定的位置重新开始消费。

04.4.10.2-008 StreamConsumer 的 consumer_stream 如何迭代消息?

一句话结论

调用 consumer_stream() 得到消息流,在 while let Some(msg) = stream.next().await 循环中逐条处理;消息是 BorrowedMessage,生命周期绑定本次迭代。

概念解释

consumer_stream() 返回实现 Stream 的类型,迭代项是 Result<BorrowedMessage, KafkaError>。BorrowedMessage 借用底层缓冲区,不能跨 await 长期持有;需要保留内容时应拷贝出 key、payload、headers。循环内处理完一条再取下一条,天然形成单分区顺序消费;并发处理需在循环内 spawn 任务并自行控制并发度。

原理流程

  1. 订阅完成后调用 consumer_stream()。
  2. next().await 等待下一条消息或错误。
  3. 拿到 BorrowedMessage,读取 topic、partition、offset、key、payload。
  4. 业务处理后按策略提交 offset。
  5. 继续下一轮迭代,直到任务被取消或进程退出。

代码或图示

use futures::StreamExt;

let mut stream = consumer.stream();
while let Some(Ok(msg)) = stream.next().await {
    let payload = msg.payload().unwrap_or_default().to_vec();
    println!("{}@{}", msg.partition(), msg.offset());
    // 业务处理后提交 offset
}

常见误区

  • 把 BorrowedMessage 存进结构体跨任务持有,导致借用生命周期报错。
  • 在循环内无限制 spawn 并发任务,破坏顺序且压垮下游。

追问

  • 流里的错误项怎么处理?答:迭代项是 Result,对 Err 做日志或分类,可恢复错误继续循环,致命错误退出。
  • 想批量拉取一批消息再处理怎么做?答:用流的 ready_chunks 或手动攒批,注意 offset 提交粒度与重试边界。

04.4.10.2-009 Consumer::poll 与 consumer_stream 是什么关系,如何取舍?

一句话结论

poll 是底层手动拉取接口,按超时时间等待一条消息;consumer_stream 是在 poll 之上封装的 Stream 适配;tokio 异步服务优先用 StreamConsumer,需要自定义轮询节奏时才用 poll。

概念解释

Consumer::poll(timeout) 阻塞等待单条消息返回 Option<Result<BorrowedMessage, KafkaError>>,是 rdkafka 通用模型。StreamConsumer 的消息流内部不断调用 poll,把结果转成异步迭代项。两者底层都是同一个 consumer 句柄;选择 poll 通常是为了把消费循环嵌进自定义 select! 分支,或配合 FutureConsumer 的上下文回调。

原理流程

  1. 通用 consumer 调用 poll(Duration) 等待消息。
  2. 超时无消息返回 None,有消息返回消息或错误。
  3. Stream 适配层循环 poll,把 Some 项喂给异步流。
  4. 异步代码通过 next().await 消费流。
  5. 退出时停止拉取并关闭句柄。

代码或图示

loop {
    match consumer.poll(std::time::Duration::from_millis(100)) {
        Some(Ok(msg)) => println!("{msg:?}"),
        Some(Err(err)) => eprintln!("{err}"),
        None => continue,
    }
}

常见误区

  • 在 tokio worker 线程里直接调用阻塞式 poll 并设置超长超时,卡住调度线程。
  • 以为 stream 与 poll 可以同时驱动同一个 consumer,两者语义互斥。

追问

  • poll 的超时参数影响什么?答:决定本次等待消息的最长时间,超时返回 None,过短增加空轮询,过长影响响应速度。
  • StreamConsumer 内部谁在调用 poll?答:流的实现内部轮询驱动,业务代码只面对异步迭代。

04.4.10.2-010 rebalance 事件(Assign/Revoke)如何通过 ConsumerContext 处理?

一句话结论

实现 ConsumerContext trait 的 rebalance 回调,在分区 Assign 时记录分配、Revoke 时提交已处理 offset;不处理回调也能消费,但宕机时容易丢已处理进度。

概念解释

消费者组 rebalance 时,broker 通知成员分区分配或回收。rdkafka 通过 ConsumerContext::rebalance 把事件传给 Rust 侧,事件类型包括 Rebalance::Assign、Rebalance::Revoke 等。在 Revoke 回调里,分区即将离开本消费者,应把内存中已处理的 offset 同步提交,避免重新分配后重复消费。自定义上下文需要挂到带 context 的 consumer 类型上。

原理流程

  1. 定义结构体实现 ConsumerContext。
  2. 覆盖 rebalance 方法,匹配 Assign/Revoke 事件。
  3. Revoke 时遍历待回收分区,提交最新 offset。
  4. Assign 时初始化该分区的本地状态。
  5. 用带上下文的 create_consumer 构造消费者并订阅。

代码或图示

use rdkafka::consumer::{ConsumerContext, Rebalance};

struct OrderContext;
impl ConsumerContext for OrderContext {
    fn rebalance(&self, base: &rdkafka::consumer::BaseConsumer, rebalance: &Rebalance) {
        match rebalance {
            Rebalance::Assign(tpl) => println!("assigned: {tpl:?}"),
            Rebalance::Revoke(tpl) => println!("revoked: {tpl:?}"),
            _ => {}
        }
    }
}

常见误区

  • Revoke 时不提交 offset,分区移到别的成员后从头重复消费。
  • 在回调里做阻塞重 IO,拖慢 rebalance 流程。

追问

  • 不实现 rebalance 回调会怎样?答:默认行为仍会完成分配/回收,但丢失了在边界提交 offset 与清理本地状态的钩子。
  • Assign 时本地状态怎么初始化?答:按分区列表准备缓存或计数,避免跨分区串状态。

04.4.10.2-011 enable.auto.commit 的语义与风险是什么?

一句话结论

开启自动提交后,rdkafka 后台按周期提交「已拉取」的 offset,而不是「已处理成功」的 offset;宕机时可能丢消息,崩溃恢复时也可能重复消费。

概念解释

enable.auto.commit 默认为开启,配合 auto.commit.interval.ms 周期性提交当前消费位置。自动提交的是 poll 拉取到的位置,业务是否处理成功并不参与判断。风险有二:消息已拉取但未处理完就提交了 offset,宕机后这部分消息丢失;处理成功但尚未到提交周期就崩溃,重启后从旧 offset 重放,造成重复消费。生产环境常关闭自动提交,在业务成功后手动提交。

原理流程

  1. 配置是否自动提交与提交周期。
  2. 消费者持续 poll 拉取消息。
  3. 后台定时器到点后提交当前拉取位置。
  4. 业务处理与提交彼此独立,没有事务绑定。
  5. 崩溃恢复时按已提交 offset 重放或跳过。

代码或图示

let consumer: StreamConsumer = ClientConfig::new()
    .set("group.id", "manual-offset-group")
    .set("enable.auto.commit", "false")
    .set("bootstrap.servers", "localhost:9092")
    .create()?;

常见误区

  • 以为自动提交代表业务已成功,实际上只代表消息被拉取过。
  • 关闭自动提交后忘记手动 commit,导致每次重启都从头消费。

追问

  • 自动提交周期怎么配?答:auto.commit.interval.ms,周期越短重复消费窗口越小,但提交开销越大。
  • 自动提交与手动提交能否混用?答:技术上可并存,但语义混乱,生产环境应二选一并保持一致。

04.4.10.2-012 手动提交有哪些 API,CommitMode 的 Sync 与 Async 怎么选?

一句话结论

手动提交用 commit_message 或 commit_offset,CommitMode::Async 后台提交不阻塞循环,CommitMode::Sync 等待提交结果;停机与 Revoke 边界用 Sync,稳态处理用 Async。

概念解释

Consumer trait 提供 commit_message(&msg, mode) 提交单条消息位置,commit_offset(tpl, mode) 按分区列表批量提交。CommitMode::Async 把提交交给后台线程,立即返回,吞吐好但失败不即时感知;CommitMode::Sync 等待 broker 确认,能拿到提交错误,代价是阻塞消费循环。常见做法:循环内 Async 提交,rebalance Revoke 或关闭前用 Sync 兜底。

原理流程

  1. 关闭 enable.auto.commit。
  2. 业务处理成功后调用 commit_message(&msg, CommitMode::Async)。
  3. 记录提交错误(异步失败可在回调或日志中观察)。
  4. Revoke 或关闭前遍历分区,用 CommitMode::Sync 提交最终位置。
  5. 提交失败按策略告警或回退到重放。

代码或图示

use rdkafka::consumer::{CommitMode, Consumer};

// 业务成功后
consumer.commit_message(&msg, CommitMode::Async)?;
// 停机或 Revoke 兜底
consumer.commit(tpl, CommitMode::Sync)?;

常见误区

  • 每处理一条都用 Sync 提交,消费吞吐被提交往返拖垮。
  • 业务失败也提交 offset,导致失败消息被跳过且无法重放。

追问

  • commit_message 与 commit_offset 区别?答:前者基于已消费消息对象,后者基于分区 offset 列表,批量补提交用后者。
  • 异步提交失败谁来感知?答:rdkafka 错误回调与日志可观察到提交错误,关键路径需在停机边界用 Sync 兜底确认。

04.4.10.2-013 at-least-once 与 at-most-once 在消费侧如何配置实现?

一句话结论

at-least-once:先处理成功再提交 offset,崩溃后可能重复;at-most-once:拉取后立即提交 offset,崩溃可能丢消息;二者是可靠性与重复消费的权衡。

概念解释

at-least-once(至少一次)要求「消息不丢」:处理成功才提交,未提交的位置在重启后重放,代价是可能重复消费,业务必须幂等。at-most-once(至多一次)要求「不重复」:拉取到就提交,不等待处理结果,宕机时已拉取未处理的消息直接跳过,代价是可能丢失。Kafka 默认语义偏向至少一次;exactly-once 需要事务或幂等生产者配合,消费侧单独配置无法达到。

原理流程

  1. 至少一次:关闭自动提交,业务成功后手动 commit。
  2. 崩溃恢复:从上次已提交位置重放,重复消息由业务幂等吸收。
  3. 至多一次:拉取后先 commit,再做业务。
  4. 崩溃发生在 commit 之后:该消息不再重放。
  5. 根据下游能否接受重复选择模式。

代码或图示

// at-least-once:先处理,后提交
process(&msg).await?;
consumer.commit_message(&msg, CommitMode::Async)?;

// at-most-once:先提交,后处理
consumer.commit_message(&msg, CommitMode::Async)?;
process(&msg).await?;

常见误区

  • 把「不丢消息」当成 exactly-once,至少一次仍会重复。
  • at-most-once 场景下业务失败也不补偿,静默丢消息却无监控。

追问

  • 下游是转账等强一致场景选哪种?答:不能只靠消费语义,需要事务消息、幂等键与对账,至少一次加幂等是常见组合。
  • 重复消费在什么情况下发生?答:处理成功但未提交就崩溃、Revoke 后分区重放、自动提交位置超前。

04.4.10.2-014 exactly-once 的边界在哪里,生产者幂等与事务分别是什么?

一句话结论

rdkafka 侧的「精确一次」分两层:生产者幂等避免重试导致的重复写入,事务(transactional.id)保证多分区原子写;消费侧仍需配合 offset 提交与业务幂等,不能宣称端到端 exactly-once。

概念解释

生产者幂等开启后,broker 为每条消息分配序列号,重试造成的重复写入被 broker 去重,避免生产者重发产生重复记录。事务模式下,生产者用 transactional.id 把一组写入与 offset 提交绑成原子事务,全部成功或全部回滚。但端到端 exactly-once 还要求消费-转换-写链路纳入事务闭环;普通服务只做生产或只做消费时,无法单独达成,重复仍要业务层兜底。

原理流程

  1. 生产者配置幂等所需参数(具体配置项以 librdkafka 文档为准)。
  2. 事务生产者初始化事务上下文,begin_transaction 后批量发送。
  3. 消费侧 offset 纳入事务一起提交。
  4. commit_transaction 原子生效,或 abort_transaction 回滚。
  5. 业务层仍保留唯一键去重作为最后防线。

代码或图示

// 待确认:事务生产者在 rdkafka 当前版本的初始化 API 与方法名,
// 验证方式为 docs.rs/rdkafka latest 的 producer 模块与官方事务示例;
// 答题时先讲清幂等与事务两层边界,不写死未核对的方法签名。

常见误区

  • 以为开了生产者幂等,下游就不会收到重复消息。
  • 把 Kafka 事务当成跨外部数据库的全局事务,实际只覆盖 Kafka 写入与 offset。

追问

  • 幂等生产者解决什么重复?答:解决生产者重试、网络重传导致的同一批次重复写入。
  • 事务需要什么前置条件?答:broker 侧开启事务支持,生产者稳定的 transactional.id,具体配置对照官方文档。

04.4.10.2-015 分区键与分区内顺序保证是什么?

一句话结论

同一 key 的消息由分区器哈希到同一分区,分区内按写入顺序追加;Kafka 只保证单分区有序,不保证跨分区全局有序。

概念解释

分区是 Kafka 顺序性的基本单位:生产者带 key 时,默认分区策略对 key 取哈希,相同 key 落到同一分区;分区内消息按 offset 严格递增。跨分区时,不同分区在不同消费者上并发处理,先后顺序无法保证。需要「某实体相关消息严格有序」时,必须把该实体 ID 作为 key;全局有序则只能用单分区,吞吐受限。

原理流程

  1. 业务选择分区键(如订单 ID、用户 ID)。
  2. 分区器对 key 哈希映射到固定分区。
  3. 同 key 消息顺序追加到该分区日志。
  4. 消费者按分区顺序逐条读取。
  5. 不同分区之间不维持顺序,并发消费时交错执行。

代码或图示

let record = FutureRecord::to("orders")
    .key(b"order-1001")
    .payload(body);
producer.send(record, Duration::from_secs(5));

常见误区

  • 以为不指定 key 也能保证消息顺序。
  • 要求「全局消息按时间有序」却使用多分区,顺序必然被并发打破。

追问

  • 某实体的状态变更必须串行怎么设计?答:以实体 ID 为 key,消费端按分区顺序处理,避免同实体并发任务。
  • 分区数调整会影响 key 映射吗?答:分区数变化后哈希取模结果可能改变,同 key 换分区,顺序性需重新评估。

04.4.10.2-016 linger.ms 与 batch.size 如何影响吞吐和延迟?

一句话结论

linger.ms 攒批等待时长,batch.size 单批字节上限;调大提升吞吐但增加发送延迟,调小降低延迟但批量变小、请求增多。

概念解释

生产者不会逐条发送消息,而是攒成批次再发。linger.ms 是一批消息最多等待多久:到点即发,无论是否攒满。batch.size 是批次字节阈值:攒满立即发,不等 linger。两个条件先到先触发。高吞吐日志场景调大 linger 与 batch;低延迟交易场景减小 linger 甚至设为 0。批次大小超过 broker 上限会触发消息超限错误。

原理流程

  1. 消息进入对应分区的待发缓冲区。
  2. 满足 batch.size 或到达 linger.ms 任一条件即组批。
  3. 批次通过网络发送到 broker。
  4. broker 确认后释放本地缓冲。
  5. 指标上观察发送延迟与批次大小,反向调整参数。

代码或图示

let producer: FutureProducer = ClientConfig::new()
    .set("bootstrap.servers", "localhost:9092")
    .set("linger.ms", "20")
    .set("batch.size", "16384")
    .create()?;

常见误区

  • linger 设很大只为吞吐,忽略端到端延迟 SLA。
  • 把 batch.size 当成消息体上限,它是单批次大小,单条消息大小由 message.max.bytes 约束。

追问

  • 缓冲区消息一直不够一批怎么办?答:linger 到点强制发送,不会无限等待。
  • 吞吐上不去先调什么?答:先看批次大小、压缩类型与分区数,再考虑 linger,避免盲目加大等待。

04.4.10.2-017 消费 lag 如何获取与监控?

一句话结论

lag 是「topic 最新 offset」与「消费者组已提交 offset」的差值;rdkafka 可通过分区的水印(low/high offset)与当前位置计算,外部监控通常由 broker 指标或消费组描述接口提供。

概念解释

消费滞后反映积压程度:对每个已分配分区,用 broker 端 high watermark 减去消费者当前 offset,累加即组 lag。rdkafka 提供 fetch_watermarks 获取分区首尾 offset,结合消费者位置估算滞后。生产环境更常见的做法是采集 Kafka 自带的消费组滞后指标,接入 Prometheus/Grafana;服务内部可周期性计算 lag 打日志,作为扩容与告警依据。

原理流程

  1. 枚举消费者当前分配的分区列表。
  2. 对每个分区 fetch_watermarks 取得 high offset。
  3. 读取消费者在该分区的当前 offset。
  4. 差值累加得到总 lag。
  5. 周期性上报指标,设置积压阈值告警。

代码或图示

let tpl = consumer.assignment()?;
for partition in tpl.elements() {
    let (low, high) = consumer.fetch_watermarks(
        partition.topic(), partition.partition(), Duration::from_secs(5))?;
    let lag = high.saturating_sub(partition.offset());
    println!("{}:{} lag={lag}", partition.topic(), partition.partition());
}

常见误区

  • 用已提交 offset 而不是消费位置算 lag,忽略「拉取未提交」的区间。
  • 只看单条消息处理速度,不看分区水位差,积压被掩盖。

追问

  • low watermark 与 high watermark 分别是什么?答:low 是最早未被删除的 offset,high 是已确认写入的最新 offset,lag 一般对照 high 计算。
  • lag 持续增长说明什么?答:消费速率低于生产速率,需扩容消费者、优化处理逻辑或排查下游瓶颈。

04.4.10.2-018 消息 schema 演进在 Rust 侧怎么组织,JSON 与 Avro 分别怎么做?

一句话结论

Rust 侧用结构体承载消息格式,JSON 走 serde 序列化;Avro 需要对应的 schema 编解码库并与注册中心对接;演进时遵守向后兼容规则(加可选字段、不改字段语义)。

概念解释

JSON 消息在 Rust 中用 serde::Serialize/Deserialize 结构体表达,版本演进靠可选字段与默认值兼容。Avro 是带 schema 的二进制格式,消息附带 schema 信息,Rust 生态的 Avro 编解码与 schema 注册表对接方式需以当前 crate 文档为准。无论哪种格式,演进规则一致:新消费端能读旧消息、旧消费端能读新消息;删除字段、改类型、改默认值都属于破坏性变更。

原理流程

  1. 定义与消息格式对应的 Rust 结构体。
  2. 生产者序列化前校验必填字段。
  3. 消费者反序列化时容忍缺失的可选字段。
  4. schema 变更走评审:确认兼容级别后再发布。
  5. 多版本并存期间,消费者按字段判空做分支处理。

代码或图示

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct OrderEvent {
    order_id: String,
    status: String,
    // 演进新增字段:旧消息缺失时使用默认值
    #[serde(default)]
    channel: Option<String>,
}

常见误区

  • 直接把字段类型从 i64 改成 String,旧消费者反序列化失败。
  • 演进时复用字段编号/名称但改变语义,下游静默错读。

追问

  • 可选字段在 JSON 里如何兼容旧消息?答:Option<T> 配合 #[serde(default)],缺失时为 None。
  • Avro 与 JSON 选型考虑什么?答:Avro 体积小、带 schema 约束,适合大规模事件流;JSON 可读性好、接入简单。

04.4.10.2-019 业务失败消息如何转入重试主题与死信队列?

一句话结论

消费失败不直接 commit,按失败类型转入重试主题(带延迟头与重试次数),超过最大次数后写入死信主题;原消息 offset 在失败转储完成后再提交。

概念解释

可靠消费链路通常分三层:主主题消费、重试主题延迟重投、死信主题永久保留。业务处理失败时,消费者把原消息复制到重试主题,附加重试次数与失败原因头;延迟由重试主题的等待机制或消息头控制。重试耗尽后写入死信主题等待人工介入。只有转储成功后才提交主主题 offset,避免失败消息被跳过。重试期间幂等键保持不变,防止重复执行产生副作用。

原理流程

  1. 主主题消息处理失败,分类错误类型。
  2. 未超最大次数:构造带 retry-count 头的新消息发往重试主题。
  3. 超次数:发往死信主题并告警。
  4. 转储成功后提交主主题 offset。
  5. 重试主题消费者到期后重新投递到主主题或直接重试处理。

代码或图示

// 伪流程:失败 -> 重试/死信 -> 再 commit
if process(&msg).await.is_err() {
    let count = retry_count(&msg) + 1;
    if count <= MAX_RETRY {
        producer.send(retry_record(&msg, count), timeout).await?;
    } else {
        producer.send(dlq_record(&msg), timeout).await?;
    }
}
consumer.commit_message(&msg, CommitMode::Async)?;

常见误区

  • 转储失败就 commit offset,失败消息直接丢失。
  • 重试主题不设上限,坏消息无限循环压垮链路。

追问

  • 延迟重试用什么实现?答:Kafka 侧可按层级重试主题或带延迟头的方案;延迟语义与具体中间件能力相关,需对照选型。
  • 死信消息怎么补偿?答:保留原始载荷、错误原因、时间与消费者标识,提供人工重放入口。

04.4.10.2-020 SASL 认证在 rdkafka 中如何配置?

一句话结论

通过 security.protocol 与 SASL 相关配置项设置机制(plain、SCRAM-SHA-256、SCRAM-SHA-512 等)、用户名与密码;具体配置键名对照 librdkafka 官方安全配置表。

概念解释

Kafka 集群开启 SASL 后,客户端需要提供认证身份。rdkafka 把 librdkafka 的安全配置原样透传:security.protocol 指定协议组合,sasl.mechanism 指定认证机制,sasl.username、sasl.password 提供凭证。SCRAM 类机制走用户名密码加盐握手,OAuthBearer 则携带令牌。凭证不得硬编码在仓库,应从环境变量或密钥管理系统读取。

原理流程

  1. 从环境变量读取用户名密码,不写进配置文件。
  2. set("security.protocol", "SASL_SSL") 指定安全协议。
  3. set("sasl.mechanism", "SCRAM-SHA-512") 选择机制。
  4. 填入 sasl.username、sasl.password。
  5. 构造客户端,观察认证日志确认握手成功。

代码或图示

let config = ClientConfig::new()
    .set("bootstrap.servers", env!("KAFKA_BROKERS"))
    .set("security.protocol", "SASL_SSL")
    .set("sasl.mechanism", "SCRAM-SHA-512")
    .set("sasl.username", &std::env::var("KAFKA_USER")?)
    .set("sasl.password", &std::env::var("KAFKA_PASSWORD")?);

常见误区

  • 在源码或提交记录里写明文密码。
  • 把 security.protocol 与 sasl.mechanism 配错组合,握手直接失败。

追问

  • 支持哪些 SASL 机制?答:以 librdkafka 当前版本与 broker 配置为准,常见 plain、SCRAM-SHA-256、SCRAM-SHA-512、OAuthBearer。
  • 认证失败先查什么?答:协议与机制是否一致、凭证是否有效、网络是否可达,再看 broker 端 ACL。

04.4.10.2-021 TLS/SSL 连接在 rdkafka 中如何配置?

一句话结论

通过 security.protocol 选择 SSL/SASL_SSL,并配置 CA 证书路径等 TLS 选项;证书内容按环境注入,不提交仓库。

概念解释

加密传输由 TLS 层完成,配置键对应 librdkafka 的 SSL 选项:CA 证书、客户端证书与私钥(双向认证时)、证书校验开关等。security.protocol=SSL 表示纯 TLS 加密,SASL_SSL 表示 TLS 之上叠加 SASL 认证。Rust 侧链接的 TLS 库由 rdkafka 构建 feature 决定,证书格式与校验行为以该 feature 为准。关闭证书校验仅限内网调试,生产必须保留校验。

原理流程

  1. 确认 broker 监听端口与协议类型。
  2. 配置 CA 证书路径或内置 CA。
  3. 需要双向认证时配置客户端证书与私钥。
  4. 设置 security.protocol 为 SSL 或 SASL_SSL。
  5. 构造客户端并检查 TLS 握手日志。

代码或图示

let config = ClientConfig::new()
    .set("bootstrap.servers", "broker:9093")
    .set("security.protocol", "SSL")
    .set("ssl.ca.location", "/etc/kafka/ca.crt");

常见误区

  • 生产环境关闭证书主机名校验只为连得通。
  • 证书路径写死本机绝对路径,换机器即失效。

追问

  • 双向认证需要哪几项?答:CA 证书、客户端证书、客户端私钥,具体配置键对照 librdkafka SSL 配置表。
  • TLS 握手报错怎么排查?答:先核对时间、证书链有效期、主机名与协议端口,再看客户端 TLS 库是否支持证书算法。

04.4.10.2-022 rdkafka 与 tokio 运行时的线程模型是怎样的?

一句话结论

librdkafka 在内部自有线程完成网络 IO 与协议处理,Rust 侧 Future/Stream 只是把结果桥接到 tokio 任务;业务 Future 跑在 tokio worker 上,C 线程与 tokio 线程彼此独立。

概念解释

rdkafka 不是把 socket 注册到 tokio reactor,而是 C 库内部维护线程做轮询、批量发送与心跳。Rust 的 FutureProducer 交付 Future、StreamConsumer 消息流,在内部线程与 tokio 任务之间传递消息。这意味着业务 await 消息时让出 tokio worker,但底层 poll 由 C 线程持续进行。阻塞业务逻辑会卡住 tokio 任务,不会卡住 librdkafka 内部线程;反之内部线程异常表现为客户端整体无响应。

原理流程

  1. create 初始化底层实例并启动内部线程。
  2. 发送消息进入本地队列,内部线程组批外发。
  3. 内部线程接收 broker 响应,唤醒对应 DeliveryFuture。
  4. 消费消息由内部线程 poll,桥接到消息流。
  5. 任务退出后关闭实例,内部线程随句柄释放结束。

代码或图示

[tokio worker 任务]  --send-->  [rdkafka 本地队列]  <--内部 C 线程-->  [broker]
        ^                              |
        |____ Future / Stream 桥接 ____|

常见误区

  • 以为 rdkafka 把 socket 注册进 tokio reactor,按 hyper 那套思路调优。
  • 在消费循环里跑阻塞重计算,卡住 tokio worker 却误以为是客户端线程问题。

追问

  • 业务阻塞该用什么隔离?答:CPU 密集或阻塞调用放到 spawn_blocking 或独立线程池,避免占住 tokio worker。
  • 客户端内部线程数可控吗?答:由 librdkafka 内部管理,相关线程参数对照官方配置表,不在 Rust 侧手动创建。

04.4.10.2-023 生产者本地缓冲区满时 send 会怎样?

一句话结论

待发消息超过本地缓冲上限(如 queue.buffering.max.messages)时,send 返回本地队列满错误;若不处理,生产者阻塞或丢消息取决于配置与调用方式。

概念解释

生产者维护本地待发送队列,broker 处理不及时或网络抖动时消息堆积。缓冲达到上限后,新消息无法入队,send 返回队列满类错误。相关参数包括最大排队消息数、缓冲区字节上限、消息超时等。消费侧 Lag 大不会直接撑爆生产者;生产侧下游 broker 慢、批次发不出去才会。处理方式是退避重试、告警扩容,而不是无限加大缓冲掩盖问题。

原理流程

  1. 消息持续进入本地队列等待组批。
  2. broker 消费速度下降,队列占用上升。
  3. 达到 queue.buffering.max.messages 上限。
  4. 后续 send 返回本地错误,调用方需捕获。
  5. 监控队列占用与发送延迟,定位下游瓶颈。

代码或图示

match producer.send(record, timeout) {
    Ok(fut) => { /* await 交付结果 */ }
    Err((rdkafka::error::KafkaError::QueueFull, _)) => {
        // 退避后重试,或降级落库补偿
        tokio::time::sleep(Duration::from_millis(50)).await;
    }
    Err((other, _)) => return Err(other.into()),
}

常见误区

  • 缓冲区满时反复紧循环重试,把 CPU 打满。
  • 只盯 broker 侧指标,不看生产者本地队列占用。

追问

  • 缓冲上限调大能解决什么?答:吸收短时抖动,不能解决 broker 长期处理能力不足。
  • 消息在缓冲区停留过久会怎样?答:超过 message.timeout.ms 后交付 Future 返回超时错误。

04.4.10.2-024 topic 通配订阅与手工分区分配有什么区别?

一句话结论

subscribe 按消费者组自动分配分区,支持 topic 名前缀/通配由 broker 侧机制配合;手工 assign 指定分区列表,不参与组协调,用于回放、审计等特殊场景。

概念解释

组订阅模式下,消费者加入组,协调器把分区分配给成员,扩缩容自动 rebalance。手工分配模式调用 assign 直接绑定分区与 offset,不加入组协调,适合一次性回放历史数据、指定分区审计、测试消费。两种模式不要混用:组内成员有的 subscribe 有的 assign 会导致分配语义混乱。通配订阅(按前缀匹配 topic)依赖客户端或 broker 的订阅机制,具体支持范围以 librdkafka 版本为准。

原理流程

  1. 常规消费:subscribe(&["topic"]) 加入组。
  2. 特殊回放:构造 TopicPartitionList,assign(&tpl) 指定分区与起始 offset。
  3. 手工分配后直接从指定位置 poll。
  4. 回放结束关闭消费者。
  5. 不要在同一实例上切换两种模式。

代码或图示

use rdkafka::topic_partition::TopicPartitionList;

let mut tpl = TopicPartitionList::new();
tpl.add_partition_offset("audit-topic", 0, rdkafka::offset::Offset::Beginning)?;
consumer.assign(&tpl)?;

常见误区

  • 手工 assign 后仍配置 group.id 并期待自动重平衡。
  • 回放任务与在线消费共用组,抢占分区影响业务。

追问

  • 手工分配如何指定起始位置?答:在分区列表上设置 offset(Beginning/End/具体数值),再 assign。
  • 前缀订阅怎么实现?答:依赖客户端订阅能力,具体语法与版本支持查 rdkafka/librdkafka 文档。

04.4.10.2-025 消息头(headers)如何在生产者写入、消费者读取?

一句话结论

生产者在 FutureRecord 上挂 Headers 附加键值对,消费者从 BorrowedMessage::headers() 读取;消息头适合放 trace id、重试次数、来源标记,不适合放业务大字段。

概念解释

消息头是与消息体并行的键值元数据,常见用途:链路追踪 ID、重试次数、事件类型、原始来源。rdkafka 的 headers 类型提供插入与遍历接口,键是字符串,值是字节切片。消费者读取时判断头是否存在,缺失则给默认值。消息头占用批次空间,敏感信息不应放入;大段业务数据应放在 payload 或外部存储。

原理流程

  1. 生产者构造 Headers,插入 trace id 等字段。
  2. record 挂 headers 后发送。
  3. broker 随消息持久化头信息。
  4. 消费者 msg.headers() 遍历,按键取出字节。
  5. 业务把 trace id 注入当前 span,重试次数用于判断重试层级。

代码或图示

use rdkafka::message::Headers;

let mut headers = Headers::new();
headers.insert("trace-id", b"trace-1001")?;
let record = FutureRecord::to("orders")
    .headers(headers)
    .payload(body);

// 消费侧
if let Some(headers) = msg.headers() {
    for header in headers.iter() {
        println!("{}={:?}", header.key(), header.value());
    }
}

常见误区

  • 把大段 JSON 或附件塞进消息头,撑大批次。
  • 假设消费者一定能读到某个头,未做缺失兜底。

追问

  • 消息头的值是什么类型?答:字节切片,需要按约定编码为字符串或二进制。
  • 头信息会被下游透传吗?答:跨主题转发时需手动复制头,broker 不会自动透传到新主题。

04.4.10.2-026 消息时间戳有哪两种类型,消费侧如何读取?

一句话结论

时间戳分 CreateTime(生产者写入时指定)与 LogAppendTime(broker 追加时生成),消费者通过消息的 timestamp 接口读取,同时拿到类型与毫秒值。

概念解释

消息时间戳由生产者在 record 上指定,或由 broker 在追加日志时统一打标。rdkafka 在消息对象上暴露 timestamp 访问器,返回类型与值的组合:类型为 CreateTime 说明来自生产者,为 LogAppendTime 说明由 broker 覆盖。消费侧做超时判断、窗口聚合时必须确认用的是哪种时间,避免把 broker 追加时间当业务发生时间。时间戳单位通常为毫秒,时区参考 UTC。

原理流程

  1. 生产者构造 record 时可选设置 timestamp。
  2. broker 按主题配置决定是否覆盖为追加时间。
  3. 消费者读取消息 timestamp,得到类型与毫秒值。
  4. 业务按类型选择用于排序、去重或窗口计算。
  5. 缺失时间戳时返回未设置状态,代码需兜底。

代码或图示

match msg.timestamp() {
    rdkafka::message::Timestamp::CreateTime(ms) => println!("producer time: {ms}"),
    rdkafka::message::Timestamp::LogAppendTime(ms) => println!("broker time: {ms}"),
    rdkafka::message::Timestamp::NotSet => println!("no timestamp"),
}

常见误区

  • 直接把 timestamp 毫秒值当业务事件时间,忽略类型可能是 broker 追加时间。
  • 跨时区处理时不转 UTC,窗口聚合出现偏移。

追问

  • 主题配置如何影响时间戳类型?答:broker 端可配置是否把消息统一改为 LogAppendTime,具体策略对照 Kafka 主题配置文档。
  • 时间戳缺失怎么处理?答:按未设置兜底,使用消费时刻或业务字段中的时间,不要强转零值。

04.4.10.2-027 auto.offset.reset 的 earliest、latest、none 分别什么含义?

一句话结论

无已提交 offset 时,earliest 从最早消息开始消费,latest 从最新位置开始,none 在无 offset 时直接报错;已有提交 offset 时该配置不生效。

概念解释

该配置只在「消费者组没有可提交的 offset」时起作用:新组、offset 过期被删除、或 offset 越界。earliest 从头回放历史,适合初始化补数;latest 只消费新消息,避免重启时灌入积压;none 要求必须已有 offset,否则抛错,用于严格场景。注意它解决的是起点选择,不处理「已提交 offset 因数据删除而越界」之外的所有情况。

原理流程

  1. 消费者加入组,查询已提交 offset。
  2. 存在有效 offset:从该位置继续,配置不生效。
  3. 无有效 offset:按 auto.offset.reset 选择起点。
  4. earliest 定位 low watermark,latest 定位 high watermark。
  5. none 直接返回错误,由人工处理。

代码或图示

let consumer: StreamConsumer = ClientConfig::new()
    .set("group.id", "replay-group")
    .set("auto.offset.reset", "earliest")
    .set("bootstrap.servers", "localhost:9092")
    .create()?;

常见误区

  • 以为改这个配置就能让现有组重新从头消费,实际已有提交 offset 时不生效。
  • 新组误用 earliest,上线瞬间拉取全量历史积压。

追问

  • 现有组想从头回放怎么做?答:用管理工具重置组 offset 到指定位置,或新建组配合 earliest。
  • offset 越界(数据已删除)会触发什么?答:按 reset 配置回退到最早或最新位置,none 则报错。

04.4.10.2-028 服务关闭时生产者如何 flush,消费者如何提交最终 offset?

一句话结论

停机时先停止拉取新消息,消费者提交剩余已处理 offset,生产者调用 flush 等待本地缓冲全部发完;顺序颠倒会丢消息或留下未提交进度。

概念解释

进程退出前有两个收尾动作:生产者本地缓冲区可能还有未发出的消息,需要 flush 阻塞等待交付完成;消费者可能有已处理未提交的 offset,需要在关闭前同步提交。典型停机流程:收到信号 → 停止消费循环 → 提交最终 offset → flush 生产者 → 关闭连接。不 flush 直接退出,缓冲区消息被丢弃;不提交就退出,重启后重复消费已处理消息。

原理流程

  1. 监听停机信号,取消消费循环。
  2. 处理完当前在途消息。
  3. 同步提交剩余分区 offset。
  4. 生产者 flush(Duration) 等待缓冲排空。
  5. 关闭 consumer/producer 句柄后退出进程。

代码或图示

// 生产者收尾:等待本地缓冲全部交付
producer.flush(Duration::from_secs(10));
// 消费者收尾:提交最后一批 offset
consumer.commit(tpl, CommitMode::Sync)?;

常见误区

  • 先退出运行时再 flush,Future 无人驱动导致缓冲永远发不出去。
  • 停机时不提交 offset,重启后整段重复消费。

追问

  • flush 超时怎么办?答:先记录未排空消息数量与关键 key,再退出;补偿链路负责重发。
  • 消费者关闭 API 名称是什么?答:consumer 提供关闭/停止方法释放分区分配,具体签名以 docs.rs/rdkafka 当前版本为准。

04.4.10.2-029 消费错误如何区分可恢复与不可恢复?

一句话结论

可恢复错误(临时网络抖动、拉取超时)继续循环等待重试;不可恢复错误(授权失败、主题不存在、致命 broker 错误)退出循环并告警,避免空转刷屏。

概念解释

消费流中的 KafkaError 来源多样:网络瞬时错误会自行重连,主题未授权或不存在属于配置错误,继续 poll 只会反复报错。错误标签区分 retriable 与 fatal 语义:retriable 错误等待内部恢复,fatal 错误需要上层介入。排错时先看错误码与 broker 返回码,再决定继续循环、退避还是退出。盲目 catch-all 继续跑,会掩盖配置问题并刷爆日志。

原理流程

  1. 迭代拿到 Err(KafkaError)。
  2. 按错误标签分类:网络/超时类可恢复。
  3. 可恢复错误短暂等待后继续循环。
  4. 配置/授权/致命类错误退出循环并上报告警。
  5. 记录 topic、分区、offset 与错误上下文便于复现。

代码或图示

match msg_result {
    Ok(msg) => process(msg).await,
    Err(rdkafka::error::KafkaError::Subscription(_)) => {
        return Err("topic subscription failed".into());
    }
    Err(e) => eprintln!("transient consumer error: {e}"),
}

常见误区

  • 所有错误都继续循环,主题被误删后消费者空转几小时无人发现。
  • 遇到瞬时错误立即退出进程,没有利用客户端内部重连能力。

追问

  • 客户端内部会自动重连吗?答:librdkafka 对网络断开有内部重连与元数据刷新,业务侧不必每次重连都重建客户端。
  • 错误上下文记什么?答:错误码、topic、分区、offset、group.id,便于 broker 端对照排查。

04.4.10.2-030 多 topic 订阅与分区暂停/恢复如何操作?

一句话结论

subscribe 可传入多个 topic;对已分配分区可 pause 暂停拉取、resume 恢复,用于限流或隔离慢分区。

概念解释

一个消费者实例可以订阅多个主题,组协调器把这些主题的分区统一分配。消费过程中若某分区处理过慢、需要人工隔离,可调用 pause 暂停该分区的拉取,消息留在 broker 端;恢复后继续。暂停不会提交 offset,也不丢消息。注意 pause/resume 作用于分区列表,不是整个消费者;批量暂停慢分区可以防止拖垮同实例其他分区。

原理流程

  1. subscribe(&["orders", "payments"]) 订阅多主题。
  2. 拿到分配分区后按业务标记慢分区。
  3. 对慢分区构造列表调用 pause。
  4. 限流解除后 resume 恢复拉取。
  5. 观察各分区 lag 变化确认隔离效果。

代码或图示

let mut tpl = TopicPartitionList::new();
tpl.add_partition("orders", 2);
consumer.pause(&tpl)?;
// 稍后恢复
consumer.resume(&tpl)?;

常见误区

  • 暂停整个消费者而不是分区,影响其他主题消费。
  • 长时间暂停后忘记恢复,分区 lag 持续上涨。

追问

  • pause 期间消息会丢吗?答:不会,消息保留在 broker,offset 未推进。
  • 多主题消费顺序如何保证?答:顺序仍按分区保证,跨主题、跨分区不保证。

04.4.10.2-031 statistics 回调能拿到哪些运行时数据?

一句话结论

statistics.interval.ms 配置周期后,客户端通过 statistics 回调输出 broker 连接、队列、消息收发、错误等内部指标,用于深度排障与容量分析。

概念解释

librdkafka 内部维护大量计数器:各 broker 连接状态、请求时延、生产者消息入队/出队、消费者 lag、重试与错误计数。配置统计周期后,序列化的统计数据通过上下文回调交付 Rust 侧。相比业务层自己埋点,statistics 反映客户端内部真实状态;数据结构较大,解析与存储按需要裁剪。具体字段以 librdkafka 统计文档为准。

原理流程

  1. 配置 statistics.interval.ms 周期。
  2. 实现上下文的 statistics 回调接收数据。
  3. 解析连接、队列、收发与错误字段。
  4. 提取关键指标接入监控系统。
  5. 定期核对客户端内部状态与业务指标是否一致。

代码或图示

// 待确认:当前 rdkafka 版本 statistics 回调的方法名与数据解析类型,
// 验证方式为 docs.rs/rdkafka latest 的 ConsumerContext/ProducerContext 文档;
// 答题先说明统计周期配置与回调用途,不写死未核对的字段结构。

常见误区

  • 只看业务日志,不采集客户端内部统计,连接泄漏与缓冲积压难以定位。
  • 把全量 statistics 直接打到业务日志,造成日志膨胀。

追问

  • 统计周期设多长?答:按监控粒度权衡,秒级到分钟级,过短增加序列化开销。
  • 哪些字段最值得采集?答:连接状态、待发队列长度、收发速率、错误计数与各分区 lag。

04.4.10.2-032 反序列化放在消费链路的哪一层,反序列化失败如何处理?

一句话结论

反序列化在拿到 payload 之后、业务处理之前完成;失败消息应转死信或重试主题,不能让坏消息卡住整个分区。

概念解释

消费链路通常是:拉取原始字节 → 反序列化为结构体 → 业务校验 → 处理 → 提交 offset。反序列化失败说明载荷格式损坏、版本不兼容或被污染,这类消息重试往往仍失败,应直接进入死信并告警;可兼容的版本问题可转入重试。反序列化放在业务层之前,能保证进入 handler 的都是类型完整的数据。Rust 侧用 serde 或对应格式库解析,错误类型需区分语法错误与缺失字段。

原理流程

  1. 读取 payload 字节与消息头中的格式标记。
  2. 调用反序列化得到目标结构体。
  3. 成功:进入业务校验与处理。
  4. 失败:记录原始载荷位置,转重试或死信。
  5. 转储成功后再提交 offset。

代码或图示

let body: OrderEvent = match serde_json::from_slice(msg.payload().unwrap_or_default()) {
    Ok(v) => v,
    Err(e) => {
        dlq(&msg, &format!("deserialize: {e}")).await?;
        consumer.commit_message(&msg, CommitMode::Async)?;
        continue;
    }
};

常见误区

  • 反序列化失败仍提交 offset,坏消息被跳过且无痕迹。
  • 把版本不兼容当瞬时错误无限重试,阻塞分区。

追问

  • 载荷为空怎么处理?答:按业务约定判空,空消息可能是心跳或占位,单独分类不要直接反序列化。
  • 多格式消息如何区分?答:消息头或主题命名标注格式与版本,消费侧按标记选择解码器。

04.4.10.2-033 生产者压缩类型如何选择?

一句话结论

compression.type 在批次级别压缩,常见 gzip、snappy、lz4、zstd;压缩率与 CPU 开销权衡,高吞吐链路优先低 CPU 算法,跨网带宽敏感场景选高压缩率算法。

概念解释

压缩作用于整个批次而非单条消息:生产者压缩、broker 存储、消费者解压。gzip 压缩率高但 CPU 开销大;snappy/lz4 速度快、压缩率中等;zstd 在压缩率与速度间较均衡。选择要看瓶颈是网络带宽还是 CPU,并确认 broker 与消费端支持同一算法。压缩对小消息收益有限,结合批次大小一起调整。具体可用算法以当前 Kafka 版本与 rdkafka 配置表为准。

原理流程

  1. 评估链路瓶颈:带宽受限还是 CPU 受限。
  2. 选择压缩算法并配置到生产者。
  3. 组批后压缩批次发送。
  4. broker 按配置存储压缩数据。
  5. 消费者解压后处理,观察 CPU 与网络指标。

代码或图示

let producer: FutureProducer = ClientConfig::new()
    .set("bootstrap.servers", "localhost:9092")
    .set("compression.type", "lz4")
    .create()?;

常见误区

  • 盲目用最高压缩率算法,生产者 CPU 成为瓶颈。
  • 生产端与 broker 压缩配置不一致,导致重新压缩或兼容问题。

追问

  • 压缩对消息顺序有影响吗?答:不影响,顺序在批次内与分区内保持。
  • 单条消息大小受什么限制?答:message.max.bytes 与 broker 端消息上限,压缩后大小仍需在阈值内。

04.4.10.2-034 消息大小与 message.max.bytes、message.timeout.ms 分别约束什么?

一句话结论

message.max.bytes 限制单条消息可写入的最大体积,message.timeout.ms 限制消息在生产者侧等待交付的最长时间;两者分别约束体积与时长。

概念解释

体积超限的消息会被 broker 拒绝,生产者配置的最大字节数应与 broker 端限制对齐,避免到发送阶段才失败。超时参数控制消息在本地队列与传输中的等待上限:超过时限未被确认,交付 Future 返回超时错误。大消息应考虑拆分或走外部对象存储,Kafka 不适合承载超大 payload。两条参数都要在生产者与 broker 两侧核对一致。

原理流程

  1. 评估业务单条消息平均与最大体积。
  2. 对齐生产者与 broker 的最大字节配置。
  3. 发送时记录消息进入队列时间。
  4. 超时未确认则交付 Future 报错。
  5. 超限消息在发送前本地校验拦截。

代码或图示

let producer: FutureProducer = ClientConfig::new()
    .set("bootstrap.servers", "localhost:9092")
    .set("message.max.bytes", "1048576")
    .set("message.timeout.ms", "5000")
    .create()?;

常见误区

  • 把大文件直接塞进消息体,触发超限且放大批次内存占用。
  • 超时设得过长,下游故障时本地队列长期堆积。

追问

  • 大附件怎么传?答:消息里放对象存储地址与元数据,附件本身存外部存储。
  • 超限错误在哪一层暴露?答:broker 确认阶段返回消息生产错误,本地可预先按字节数拦截。

04.4.10.2-035 消费幂等的业务键与去重表在 Kafka 场景如何落地?

一句话结论

每条消息携带业务唯一键,消费侧用去重表(数据库唯一约束或缓存记录)判断是否已处理;至少一次投递下,重复消息被幂等吸收。

概念解释

Kafka 至少一次语义下重复消费不可避免:崩溃重放、rebalance 重投、重试主题回放都会产生重复。幂等设计要求每个业务操作有稳定唯一键(订单号、事件 ID),处理前查去重表:已存在则跳过,不存在则执行并记录。去重记录要有 TTL 或定期清理,避免无限增长。数据库唯一约束是最后防线,应用层先查后写仍需防并发下的双写。

原理流程

  1. 生产者为事件分配全局唯一事件 ID。
  2. 消费者取出消息,提取业务唯一键。
  3. 查询去重表/缓存,命中已处理则直接提交 offset。
  4. 未命中:执行业务写入,事务内记录去重键。
  5. 提交 offset;重复重放时被去重表拦截。

代码或图示

let event_id = msg.key().and_then(|k| std::str::from_utf8(k).ok());
if already_processed(event_id).await? {
    consumer.commit_message(&msg, CommitMode::Async)?;
    continue;
}
apply_business(&body).await?;
mark_processed(event_id).await?;
consumer.commit_message(&msg, CommitMode::Async)?;

常见误区

  • 用 Kafka offset 当幂等键,重放后 offset 变化导致去重失效。
  • 去重记录与业务写入不在同一事务,崩溃后出现「已处理无记录」。

追问

  • 去重表存哪里?答:强一致用业务库唯一索引,高吞吐可用缓存加 TTL,最终一致性需对账兜底。
  • 重复消息间隔很久才到来怎么办?答:去重记录保留窗口覆盖最大重放周期,超长周期靠业务状态机兜底。

04.4.10.2-036 为什么单分区有序不代表全局有序?

一句话结论

顺序只在单个分区内按 offset 成立;多分区并行写入与消费时,不同分区的消息没有全局先后关系,跨分区事件顺序无法保证。

概念解释

Kafka 把主题切成多分区以扩展吞吐,每条消息落入一个分区。分区之间独立追加日志,消费者组内多成员并行处理。即使生产时间有先后,跨分区消息到达消费端的顺序也受网络、批次、处理速度影响。业务要求相关事件有序时,按实体 key 路由到同一分区;要求全局严格有序只能单分区,牺牲并行度。

原理流程

  1. 主题配置多分区。
  2. 生产者按 key 哈希选择分区。
  3. 各分区独立追加消息。
  4. 消费者多成员并行拉取不同分区。
  5. 合并结果时跨分区顺序不成立。

代码或图示

partition-0: a1 -> a2 -> a3
partition-1: b1 -> b2
全局流: 交错到达,a1 与 b1 谁先消费取决于分区与调度

常见误区

  • 以为消息发送顺序就是消费顺序。
  • 跨分区做状态机推进,收到乱序旧事件覆盖新状态。

追问

  • 同一实体的事件怎么保证有序?答:实体 ID 作为 key,同实体进同一分区,消费端串行处理。
  • 乱序事件怎么防护?答:事件带版本号或时间戳,旧版本事件不覆盖新版本状态。

04.4.10.2-037 rdkafka 的构建 feature 与 TLS 后端有哪些注意点?

一句话结论

rdkafka 通过 feature 选择运行时集成与 TLS 后端,构建还依赖 librdkafka 编译或链接;具体 feature 名以 docs.rs/rdkafka 当前版本为准,不凭记忆写死。

概念解释

rdkafka 常见 feature 分组:异步运行时集成(tokio 或 async-std)、TLS 链接后端(openssl 或 rustls 类)、C 库来源(自带编译或系统库)。不同组合影响镜像依赖:链接系统 librdkafka 需要预装 C 库;自带编译需要编译器与头文件。答题时对不确定的 feature 名标注待确认,并给出验证路径。生产镜像要保留构建所需工具链或改用预编译依赖。

原理流程

  1. 查阅 docs.rs/rdkafka 当前版本 feature 列表。
  2. 按运行时选择集成 feature。
  3. 选择 TLS 后端并确认镜像包含对应依赖。
  4. 本地与 CI 分别验证构建。
  5. 升级 rdkafka 版本时复核 feature 兼容性。

代码或图示

[dependencies]
# 具体 feature 名称以 docs.rs/rdkafka 当前版本为准
rdkafka = { version = "*", features = ["tokio"] }

常见误区

  • 照着旧教程抄 feature 名,新版本已改名或合并导致编译失败。
  • 精简镜像时删掉 C 编译工具链,构建阶段失败。

追问

  • 系统库与自带编译怎么选?答:追求构建快、镜像可控用系统库;追求依赖一致用自带编译,需在文档中记录前提。
  • TLS 后端切换要注意什么?答:证书格式、主机名校验行为与系统信任库可能不同,切换后做连接验证。

04.4.10.2-038 如何在一个 Rust 服务里运行多个消费者实例?

一句话结论

同一进程内为每个消费者组/主题构造独立 consumer 句柄,各自在 tokio 任务中循环;共享连接资源需谨慎,分区分配与 offset 按组隔离。

概念解释

多个消费者实例对应多个 StreamConsumer 句柄:可以是不同 group.id 消费不同主题,也可以同组多实例分摊分区。进程内通过 tokio::spawn 启动各自的消费循环,错误与日志带消费者标识。共享的数据库连接池、HTTP 客户端用 Arc 克隆传入;consumer 句柄本身可按需克隆或共享引用。资源上限要按实例数核算,避免句柄与连接数超配。

原理流程

  1. 按主题/组定义消费者配置。
  2. 逐个构造 consumer 并订阅。
  3. 每个 consumer spawn 独立处理循环。
  4. 共享依赖用 Arc 传入各循环。
  5. 停机时统一取消各循环并提交 offset。

代码或图示

for topic in ["orders", "payments"] {
    let consumer = build_consumer(topic)?;
    tokio::spawn(async move {
        let mut stream = consumer.stream();
        while let Some(Ok(msg)) = stream.next().await {
            handle(msg).await;
        }
    });
}

常见误区

  • 多个循环共用一个 consumer 句柄却各自 poll,拉取位置互相干扰。
  • 同组多实例挤在单进程,进程故障时整组分区同时掉线。

追问

  • 同组消费者多实例放同机还是跨机?答:关键服务跨机部署,避免单机故障整组重平衡。
  • 共享连接池怎么配上限?答:按消费者实例数乘以每实例并发占用估算,留余量给 Web 请求。

04.4.10.2-039 消费积压扩容与 rebalance 风暴是什么关系?

一句话结论

积压时增加消费者实例会触发 rebalance 重新分配分区;扩缩容频繁、会话超时设置过短会导致反复 rebalance(风暴),期间消费暂停,反而加剧积压。

概念解释

消费者组成员变化(上线、下线、心跳超时)都会触发 rebalance,rebalance 期间分区暂时不可用。扩容解决的是并行度不足,但一次性大量加入、实例反复重启会造成连续 rebalance。心跳与会话超时配置过短,网络抖动就把成员判定掉线,触发无谓重平衡。治理方式:稳定部署节奏、合理设置会话与心跳参数、扩容分批进行,观察 rebalance 次数与暂停时长。

原理流程

  1. 监控发现 lag 持续上涨。
  2. 评估分区数是否允许扩展并行度。
  3. 分批启动新实例加入组。
  4. 每批触发一次 rebalance,等待分配稳定。
  5. 观察 lag 下降速度与 rebalance 频率,避免抖动。

代码或图示

lag 上涨 -> 扩容实例 -> 加入组触发 rebalance -> 分区重分配 -> 恢复消费
频繁上下线 -> 连续 rebalance -> 消费反复暂停 -> 积压加剧

常见误区

  • 积压时一口气起几十个实例,集中重平衡把消费窗口打没。
  • 会话超时设得过短,GC 停顿或网络抖动就被踢下线。

追问

  • 分区数少于消费者实例怎么办?答:多余实例空闲,需要先扩容主题分区数。
  • rebalance 期间已处理消息怎么办?答:依赖 Revoke 回调提交 offset,避免重放过多。

04.4.10.2-040 消费不到消息时的排查顺序是什么?

一句话结论

先查连接与订阅,再查分组 offset 起点、分区分配与权限,最后看业务过滤与反序列化;按链路从上到下定位,不要先怀疑代码逻辑。

概念解释

消费不到消息常见原因:broker 地址不通、主题名拼写错误、新组从 latest 起点跳过历史、无订阅权限、未分到分区、消息被业务层过滤或反序列化失败静默跳过。排查顺序应从外到内:网络与认证 → 订阅与分配 → offset 起点 → 消息内容与处理日志。每一步用对应证据(连接日志、分配列表、lag、消息样本)确认,避免凭猜测改配置。

原理流程

  1. 检查 bootstrap 地址、认证与 TLS 握手日志。
  2. 确认主题存在、订阅名正确、消费者组已加入。
  3. 查看分配到的分区与各分区 lag。
  4. 核对 offset 起点:新组是否从 latest 跳过历史。
  5. 拉取样本消息检查格式、过滤条件与错误日志。

代码或图示

连接/认证 -> 主题与订阅 -> 组分配分区 -> offset 起点 -> 样本消息 -> 业务过滤/反序列化

常见误区

  • 一上来改代码,实际是主题名或权限问题。
  • 忽略新组 latest 起点,误以为历史消息丢失。

追问

  • 怎么确认分区已分配?答:查看 assignment 列表与 rebalance 日志,空分配说明组协调或订阅有问题。
  • 有权限但读不到?答:核对 ACL 对 topic 的读权限与 group 权限,再看 broker 端消息是否真实存在。

04.4.10.2-041 lapin 的 Connection 与 Channel 为什么要分离?

一句话结论

Connection 是到 RabbitMQ broker 的一条 TCP 连接,Channel 是连接内的轻量级逻辑通道;AMQP 协议在通道上多路复用,单连接开多通道比多连接节省握手与资源开销。

概念解释

AMQP 0-9-1 把连接与通道分层:TCP 连接负责认证与加密,通道承载具体的声明、发布、消费命令。一个连接可以创建多个通道,彼此独立隔离;通道异常关闭不一定影响连接。Rust 侧 lapin 的 Connection 提供 create_channel(),Channel 上完成 exchange/queue 声明、publish、consume。高并发应用通常单连接多通道,而不是每任务一条 TCP 连接。

原理流程

  1. Connection::connect 建立 TCP 与 AMQP 握手。
  2. connection.create_channel() 打开逻辑通道。
  3. 通道上声明交换机、队列或发布消息。
  4. 多任务克隆通道句柄并发使用。
  5. 通道关闭后可在同一连接上重新打开。

代码或图示

use lapin::{Connection, ConnectionProperties};

let conn = Connection::connect("amqp://localhost:5672/%2f", ConnectionProperties::default()).await?;
let channel = conn.create_channel().await?;

常见误区

  • 每个消费任务新建一条 Connection,TCP 与认证开销放大。
  • 以为通道与连接一一对应,误解 AMQP 多路复用模型。

追问

  • 通道为什么轻量?答:通道不占独立 TCP,帧在连接上按通道号复用,创建与销毁成本低。
  • 一个连接开很多通道有上限吗?答:broker 与连接都有通道数限制,超配需拆分连接,具体上限对照 RabbitMQ 配置。

04.4.10.2-042 如何用 Connection::connect 与 ConnectionProperties 建立连接?

一句话结论

Connection::connect(uri, ConnectionProperties::default()) 异步建立连接,返回 Connection 句柄;URI 携带 vhost、凭证与协议信息,连接属性可配置客户端名称等元数据。

概念解释

connect 是异步方法,完成 TCP 连接、协议协商与认证。URI 格式类似 amqp://user:password@host:5672/vhost,vhost 需 URL 编码。ConnectionProperties 用于附加连接元信息(如客户端标识),默认值即可工作。连接建立后可克隆句柄在多任务间共享;断线不会自动恢复,需要外层重连循环处理。凭证从环境变量读取,不写入源码。

原理流程

  1. 从环境变量组装 AMQP URI。
  2. Connection::connect(uri, props) 发起异步连接。
  3. 完成握手认证,返回连接句柄。
  4. 打开业务通道。
  5. 监听连接状态,断线时进入重连流程。

代码或图示

let uri = std::env::var("AMQP_URL")?;
let conn = Connection::connect(&uri, ConnectionProperties::default()).await?;
let channel = conn.create_channel().await?;

常见误区

  • vhost 路径含斜杠或中文时未做 URL 编码,连接解析失败。
  • 把连接句柄 move 进单个任务,其他任务无法使用。

追问

  • 连接句柄能克隆吗?答:lapin 连接与通道句柄可克隆共享,内部引用计数管理,克隆后多任务并发使用。
  • 异步连接返回错误常见原因?答:地址不可达、凭证错误、vhost 不存在、TLS 配置不匹配。

04.4.10.2-043 RabbitMQ 交换机类型与 routing key 匹配规则是什么?

一句话结论

四种基础类型:direct 按 routing key 精确匹配,topic 按单词通配匹配,fanout 忽略 routing key 广播到所有绑定队列,headers 按消息头属性匹配;Rust 侧用 ExchangeKind 表达。

概念解释

交换机决定消息路由到哪些队列。direct 绑定 key 与消息 routing key 完全相等;topic 用 . 分词,支持 * 匹配一个单词、# 匹配多个单词;fanout 把消息复制到所有绑定队列,适合广播;headers 匹配基于消息头键值,性能开销较高。声明交换机时指定类型,绑定队列时给出 binding key。lapin 的 ExchangeKind 对应这几种类型,headers 类型的具体构造以当前版本文档为准。

原理流程

  1. exchange_declare 声明交换机与类型。
  2. 队列绑定到交换机,提供 binding key 或头匹配条件。
  3. 发布消息携带 routing key。
  4. 交换机按类型匹配绑定规则。
  5. 命中队列投递,未命中按返回策略处理。

代码或图示

use lapin::ExchangeKind;

channel.exchange_declare(
    "orders",
    ExchangeKind::Topic,
    Default::default(),
    Default::default(),
).await?;

常见误区

  • topic 绑定键里用 * 匹配多个单词,实际只匹配一个。
  • fanout 发布时还依赖 routing key 做过滤,无效。

追问

  • # 与 * 区别?答:* 匹配恰好一个单词,# 匹配零个或多个单词。
  • headers 交换机什么时候用?答:路由条件复杂、不能用 key 表达时;简单场景 direct/topic 更易排查。

04.4.10.2-044 队列声明参数 durable、exclusive、auto_delete 各是什么语义?

一句话结论

durable 队列 broker 重启后保留,exclusive 仅当前连接可用且连接断开即删除,auto_delete 最后一个消费者离开后自动删除;持久化队列通常只开 durable。

概念解释

队列属性决定生命周期与存活范围。durable 队列元数据持久化,broker 重启后重建;非 durable 队列重启即失。exclusive 队列绑定到声明它的连接,其他连接不可访问,连接关闭自动删除,常用于临时回调队列。auto_delete 在没有消费者时删除,适合临时队列。三个属性可组合,但语义需对照 AMQP 规范;业务主队列一般 durable=true、exclusive=false、auto_delete=false。

原理流程

  1. queue_declare 传入队列名与选项。
  2. broker 按属性创建或校验已有队列。
  3. 已存在队列属性与声明不一致会报错。
  4. 消费者绑定或订阅队列。
  5. 按属性决定重启、断连、空闲后的存活行为。

代码或图示

use lapin::options::QueueDeclareOptions;

let queue = channel.queue_declare(
    "order-events",
    QueueDeclareOptions { durable: true, ..Default::default() },
    Default::default(),
).await?;

常见误区

  • 重启后队列消失,原因是声明时未开 durable。
  • 对已存在队列改属性声明,broker 拒绝并报错。

追问

  • 队列已存在但属性不同会怎样?答:AMQP 通道报错,需要先清理队列或对齐声明。
  • 临时 RPC 回调队列用哪种?答:通常 exclusive 临时队列,连接结束即回收。

04.4.10.2-045 basic_publish 的选项与 BasicProperties 能设置哪些字段?

一句话结论

basic_publish 接收交换机名、routing key、发布选项、消息体与 BasicProperties;属性里常用 delivery_mode(持久化标记)、content_type、correlation_id、reply_to、消息头等。

概念解释

发布消息分两部分:发布选项控制 mandatory、 immediate 等路由行为;BasicProperties 是消息元数据。delivery_mode=2 标记消息持久化到磁盘;content_type 说明载荷格式;correlation_id 关联请求响应;reply_to 指定回调队列。消息体是字节数组,序列化在 Rust 侧完成。属性不设置时使用 broker 默认值,业务需持久化的消息要显式设置 delivery_mode。

原理流程

  1. 序列化业务对象为字节。
  2. 构造 BasicProperties,填持久化标记与关联 ID。
  3. basic_publish(exchange, routing_key, options, payload, props) 发送。
  4. broker 按交换机路由。
  5. 失败或不可路由时按 mandatory 与返回机制处理。

代码或图示

use lapin::BasicProperties;

let props = BasicProperties::default()
    .with_delivery_mode(2)
    .with_content_type("application/json")
    .with_correlation_id("req-1001".into());

channel.basic_publish(
    "orders",
    "order.created",
    Default::default(),
    serde_json::to_vec(&body)?,
    props,
).await?;

常见误区

  • 只把队列设为 durable,消息不设 delivery_mode=2,重启后消息仍丢失。
  • 用 reply_to 但回调队列未声明,响应无处投递。

追问

  • mandatory 选项起什么作用?答:消息路由不到队列时返回给生产者,配合 basic_return 监听处理。
  • correlation_id 用在哪?答:RPC 请求-响应链路中匹配回复与原请求。

04.4.10.2-046 发布确认(publisher confirms)如何在 lapin 中开启与确认?

一句话结论

通道调用 confirm_select 开启发布确认,每条发布对应的确认 Future 在 broker 持久化/路由完成后 resolve;未确认不应当作发送成功。

概念解释

RabbitMQ 的 publisher confirms 是通道级协议:开启后 broker 对每条发布返回 ack 或 nack。lapin 的 basic_publish 在确认模式下返回交付结果句柄,await 后得知 broker 是否接受。与 Kafka 交付 Future 类似,确认到达才代表消息已进入 broker 磁盘或队列。生产链路应等待确认再继续,批量发送时可收集多个确认句柄并发等待。未开启确认时,发布返回只代表写入了本地通道帧,不能保证 broker 持久化。

原理流程

  1. 通道 confirm_select(ConfirmSelectOptions::default()) 开启确认模式。
  2. basic_publish 返回确认句柄。
  3. broker 路由并持久化后回 ack/nack。
  4. await 句柄判断成功;nack 进入重试或告警。
  5. 批量场景收集句柄后统一等待。

代码或图示

use lapin::options::ConfirmSelectOptions;

channel.confirm_select(ConfirmSelectOptions::default()).await?;
let confirm = channel.basic_publish(
    "orders", "order.created", Default::default(), payload, props,
).await?;
confirm.await?;

常见误区

  • 不开启 confirm_select,把 publish 返回当作 broker 确认。
  • 发送后不等待确认句柄,broker 故障时消息丢失无感知。

追问

  • nack 说明什么?答:broker 未接受该消息,可能是内部错误或资源问题,需按策略重试。
  • 确认模式与事务发布区别?答:confirm 是异步批量确认,吞吐更好;事务发布是同步事务机制,lapin 中使用方式以当前版本文档为准。

04.4.10.2-047 basic_consume 如何订阅队列并逐条处理消息?

一句话结论

basic_consume 生成一个消费者流,迭代 Delivery 消息;每条消息携带 payload、属性与交付标签,处理后手动 ack 或 nack。

概念解释

消费者在通道上声明 consumer tag 订阅队列,broker 持续推送消息。lapin 返回的是消息流(Consumer 实现 Stream),迭代项为 Delivery。Delivery 包含消息体、BasicProperties、delivery_tag 与路由信息。消费模型为推模式:broker 按 prefetch 限额推送。流迭代中处理业务,完成后用交付标签 ack;不 ack 的消息在通道/连接断开后重新入队。

原理流程

  1. 队列已声明并绑定到交换机。
  2. basic_consume(queue, tag, options, args) 订阅。
  3. 迭代消费者流拿到 Delivery。
  4. 解析 payload 并执行业务。
  5. 成功 ack,失败 nack/reject 决定重投或丢弃。

代码或图示

use futures::StreamExt;

let mut consumer = channel.basic_consume(
    "order-events", "worker-1", Default::default(), Default::default(),
).await?;

while let Some(delivery) = consumer.next().await {
    let delivery = delivery?;
    process(&delivery.data).await;
    delivery.ack(BasicAckOptions::default()).await?;
}

常见误区

  • 忘记 ack,消息在断开后反复重投,队列积压。
  • 把 Delivery 跨任务长期持有,交付标签与通道生命周期脱节。

追问

  • consumer tag 有什么用?答:标识消费者,用于取消订阅与多消费者区分,建议带实例标识。
  • 消费者流断开重连后消息会怎样?答:未 ack 的消息重新入队,由新消费者重新投递。

04.4.10.2-048 ack、nack、reject 有什么区别,requeue 如何选择?

一句话结论

ack 确认成功处理;nack 批量拒绝并可选择 requeue 重新入队;reject 单条拒绝;需要重试选 requeue,坏消息不重投则丢弃或转死信。

概念解释

交付标签标识通道内一条未确认消息。ack 告诉 broker 处理完成,消息可删除。nack 拒绝当前消息,requeue=true 重新入队等待再次投递,false 丢弃或进死信。reject 语义类似 nack 但只针对单条。瞬时失败(下游超时)可 requeue 退避重试;业务格式错误反复重投无意义,应转死信。注意立即 requeue 可能形成快速重试循环,需要延迟队列配合退避。

原理流程

  1. 拿到 Delivery 与 delivery_tag。
  2. 业务成功:ack 确认。
  3. 瞬时失败:nack(requeue=true) 等待重投。
  4. 不可恢复失败:转死信后 nack(requeue=false) 或 reject。
  5. 未确认消息在断连后由 broker 重投。

代码或图示

match process(&delivery.data).await {
    Ok(()) => delivery.ack(BasicAckOptions::default()).await?,
    Err(Retryable) => delivery.nack(BasicNackOptions { requeue: true, ..Default::default() }).await?,
    Err(_) => delivery.nack(BasicNackOptions { requeue: false, ..Default::default() }).await?,
}

常见误区

  • 坏消息也 requeue,形成死循环刷爆 CPU 与日志。
  • 处理失败不 ack 也不 nack,消息悬挂直到断连才重投。

追问

  • requeue 后消息还是原顺序吗?答:重新入队后位置由 broker 决定,不保证原顺序。
  • 批量 nack 与单条 reject 选择?答:nack 支持多条标记,reject 单条;具体选项字段以 lapin 当前版本为准。

04.4.10.2-049 prefetch(basic_qos)如何控制消费者并发与背压?

一句话结论

basic_qos 设置未确认消息上限(prefetch count),broker 推满限额后暂停推送;它是消费者侧背压阀门,配合并发度控制处理节奏。

概念解释

RabbitMQ 推模式下,如果不限流,broker 可能把大量消息推给消费者,内存与处理队列膨胀。prefetch count 限制该通道/消费者未 ack 的最大消息数:达到上限后 broker 停止推送,直到消费者 ack 释放名额。prefetch 过小吞吐受限,过大失去背压保护。单线程消费按消息粒度限流;多并发 worker 时按总在途消息数估算 prefetch。全局 prefetch(global 标志)作用范围需对照 AMQP 规范与 lapin 选项。

原理流程

  1. 通道 basic_qos(0, prefetch_count, global) 设置限额。
  2. broker 推送消息直到未确认数达到限额。
  3. 消费者处理并 ack,释放名额。
  4. broker 继续推送下一批。
  5. 下游变慢时推送自动减速,形成背压。

代码或图示

use lapin::options::BasicQosOptions;

channel.basic_qos(
    20,
    BasicQosOptions { global: false },
).await?;

常见误区

  • 不设 prefetch,消费者内存被推送消息撑爆。
  • 多任务共享通道时 prefetch 按通道统计,与单任务预期不一致。

追问

  • prefetch 与并发 worker 数怎么配?答:prefetch 控制在途消息总量,worker 数控制并行度,两者相乘不超过下游承受能力。
  • prefetch=0 代表什么?答:不限制未确认数量,具体语义对照 AMQP 规范。

04.4.10.2-050 消息持久化为什么要队列、交换机、消息三者同时设置?

一句话结论

队列 durable 保证队列元数据存活,交换机 durable 保证交换机存活,消息 delivery_mode=2 保证消息落盘;缺任一项,broker 重启后链路或消息丢失。

概念解释

持久化是分层的:非 durable 交换机重启后不存在,绑定关系随之消失;非 durable 队列重启后不存在;消息标记为瞬态时只在内存,broker 重启即丢。业务主链路必须三处都持久化:交换机 durable、队列 durable、消息 delivery_mode=2。即使三者都做,镜像/仲裁队列等高可用复制属于另一层配置,单机 broker 重启仍依赖磁盘持久化。

原理流程

  1. 声明交换机时 durable: true。
  2. 声明队列时 durable: true。
  3. 绑定交换机与队列。
  4. 发布消息属性 delivery_mode=2。
  5. broker 重启后元数据与磁盘消息重建,链路可继续投递。

代码或图示

channel.exchange_declare("orders", ExchangeKind::Topic,
    ExchangeDeclareOptions { durable: true, ..Default::default() }, Default::default()).await?;
channel.queue_declare("order-events",
    QueueDeclareOptions { durable: true, ..Default::default() }, Default::default()).await?;
// 消息属性:delivery_mode(2)

常见误区

  • 只持久化队列,交换机非 durable,重启后路由关系消失。
  • 队列 durable 但消息瞬态,重启后队列在、消息没了。

追问

  • 持久化会牺牲什么?答:磁盘写入开销与吞吐,瞬态日志类消息可按需放弃持久化。
  • 高可用复制和持久化是一回事吗?答:不是,持久化防单机重启,镜像/仲裁队列防节点故障,需分别配置。

04.4.10.2-051 网络断开后如何重建 Connection、Channel 与拓扑?

一句话结论

外层用重连循环监听连接状态:断线后重新 connect、重建通道、重新声明交换机/队列/绑定并恢复消费者;拓扑声明要具备幂等性。

概念解释

lapin 不会自动把业务通道恢复到旧状态。断线后连接与通道关闭,需要业务层循环:等待重连 → 新建连接 → 重建通道 → 重新声明拓扑 → 重新 basic_consume。声明操作本身幂等:已存在的 durable 资源再次声明不会报错(属性一致时)。消费者恢复后,未 ack 消息由 broker 重投。重连需带退避,避免故障期间紧密重连打爆 broker。

原理流程

  1. 监听连接关闭事件或在消费循环中捕获错误。
  2. 指数退避后重新 Connection::connect。
  3. 新建通道并声明交换机、队列、绑定。
  4. 重新订阅队列,恢复处理循环。
  5. 观察重连次数与告警,人工介入长时间失败。

代码或图示

loop {
    match Connection::connect(&uri, ConnectionProperties::default()).await {
        Ok(conn) => { run_worker(conn).await; }
        Err(e) => eprintln!("connect failed: {e}"),
    }
    tokio::time::sleep(Duration::from_secs(5)).await;
}

常见误区

  • 只重连不重建拓扑,新通道上队列未声明导致发布/消费失败。
  • 重连无退避,broker 故障时形成连接风暴。

追问

  • 拓扑声明放哪里?答:封装成独立函数,连接恢复后统一调用,保证每次重连链路一致。
  • 重连期间在途消息怎么办?答:未 ack 消息 broker 会重投,业务需保证幂等。

04.4.10.2-052 死信队列如何通过 x-dead-letter-exchange 等参数配置?

一句话结论

队列声明时设置 x-dead-letter-exchange(可带 x-dead-letter-routing-key),被拒绝/过期/超限的消息转入死信交换机再路由到死信队列。

概念解释

死信(DLX)是 RabbitMQ 内置机制:消息被 nack/reject 且不 requeue、TTL 过期、或队列长度超限后,成为死信发送到指定死信交换机。队列参数声明死信交换机与可选 routing key;死信交换机再绑定死信队列。这样坏消息有处可去,不阻塞主队列。死信消息保留原始属性与死亡原因头(dead-letter 信息),供补偿处理。参数通过队列声明的 arguments 传入。

原理流程

  1. 声明死信交换机与死信队列并绑定。
  2. 主队列声明时带 DLX 参数与路由键。
  3. 主队列消息被拒绝且不重投,或过期/超限。
  4. 消息转入死信交换机,按绑定路由到死信队列。
  5. 死信消费者分析原因,人工或自动补偿。

代码或图示

use lapin::types::FieldTable;

let mut args = FieldTable::default();
args.insert("x-dead-letter-exchange".into(), "orders-dlx".into());
args.insert("x-dead-letter-routing-key".into(), "order.dead".into());
channel.queue_declare("order-events", Default::default(), args).await?;

常见误区

  • 死信交换机未声明或未绑定队列,死信消息被丢弃。
  • 把死信队列当普通重试队列直接消费,没有补偿与分析环节。

追问

  • 哪些消息会进死信?答:拒绝不重投、TTL 过期、队列长度超限,具体规则对照 RabbitMQ 文档。
  • 死信消息还能退回主队列吗?答:可以由补偿程序读取后重新发布到主交换机,需保持幂等。

04.4.10.2-053 延迟队列有哪两种实现思路?

一句话结论

方案一用 rabbitmq_delayed_message_exchange 插件的延迟交换机;方案二用 TTL 加死信队列:消息在队列过期后转入下一级重试队列。Rust 侧只负责发布与消费,延迟能力由 broker 机制提供。

概念解释

插件方案:消息带延迟头,延迟交换机到期后才路由到目标队列,实现简单但依赖插件安装。TTL+DLX 方案:消息进入带 TTL 的队列,过期后通过死信交换机转发到重试队列;多级 TTL 队列实现阶梯退避。后者不依赖插件,但队头阻塞(队首消息未过期会挡住后面消息)影响精确延迟。生产选择按 broker 可控性与延迟精度权衡。

原理流程

  1. 插件方案:声明延迟类型交换机,发布时设置延迟参数。
  2. 到期后交换机路由到业务队列。
  3. TTL 方案:声明 TTL 队列并绑定死信交换机。
  4. 消息过期转入死信交换机,再到重试/业务队列。
  5. 重试消息按退避级别进入对应 TTL 队列。

代码或图示

插件方案:  [delay-exchange] --到期--> [business-queue]
TTL方案:  [ttl-30s] --过期/DLX--> [retry-queue] --过期/DLX--> [business-queue]

常见误区

  • TTL 方案里每条消息设不同 TTL,被队头阻塞拖慢,延迟不准。
  • 引入插件但镜像/集群未统一安装,部分节点路由失败。

追问

  • 阶梯退避怎么搭?答:多个不同 TTL 的死信链路,30s、5min、1h 逐级升级。
  • 延迟精度要求高用哪种?答:插件方案按消息计时更精确;TTL 方案受队头阻塞影响,具体能力对照插件文档。

04.4.10.2-054 lapin 如何与 async 运行时集成,通道如何在多任务间共享?

一句话结论

lapin 基于 async trait 设计,发布与消费都是 await 方法;连接与通道句柄可克隆后 Arc 共享给多个 tokio 任务并发使用。

概念解释

lapin 的异步方法返回 Future,在 tokio 或 async-std 上驱动。Connection 与 Channel 句柄内部引用计数,可 Clone 后在任务间传递;多个任务克隆同一通道并发 publish/consume,帧在通道上多路复用。共享连接池思路:一个连接开多个通道,按业务域划分。注意通道关闭会影响该通道上所有消费者;重连需在业务层处理。句柄跨任务要求 Send,lapin 类型在支持的运行时下满足。

原理流程

  1. 建立连接并克隆句柄。
  2. 按需创建通道,通道句柄克隆进任务。
  3. 各任务并发发布或订阅。
  4. 通道事件通过内部任务桥接到 Future/流。
  5. 断线时整体进入重连流程。

代码或图示

let conn = Connection::connect(&uri, ConnectionProperties::default()).await?;
let channel = conn.create_channel().await?;
let shared = Arc::new(channel);

for _ in 0..4 {
    let ch = shared.clone();
    tokio::spawn(async move { /* 使用 ch 发布或消费 */ });
}

常见误区

  • 每个任务新建连接,浪费 TCP 与认证资源。
  • 通道关闭后仍在旧句柄上发布,未感知断线。

追问

  • lapin 支持哪个运行时?答:以 crate 文档为准,常见 tokio 与 async-std 适配,异步方法均为 await 风格。
  • 多任务共用通道会互相阻塞吗?答:帧多路复用,业务 await 不占线程;通道级错误会波及共享者,关键业务可分通道隔离。

04.4.10.2-055 消费失败重试与退避在 lapin 侧怎么组织?

一句话结论

失败消息携带重试次数头,进入延迟/重试队列按阶梯退避重投;超过次数转死信;requeue 只用于瞬时故障,不作为退避手段。

概念解释

RabbitMQ 原生 requeue 是立即重新入队,没有退避间隔,不适合慢故障重试。可靠做法:业务消息带 x-retry-count 等属性,失败后发布到重试队列(TTL+DLX 或延迟交换机),到期再回主队列。每次重试递增计数,超限进死信。消费端必须幂等,因为重试与重投都会产生重复。重试间隔、最大次数在配置中管理,区分瞬时错误与业务错误。

原理流程

  1. 主队列消息处理失败,读取当前重试次数。
  2. 未超限:复制消息到对应退避级别重试队列,计数加一。
  3. 重试队列到期经死信链路回到主队列。
  4. 超限:发布到死信队列并告警。
  5. 主消费者重新处理,幂等吸收重复。

代码或图示

let count = retry_count(&delivery) + 1;
if count <= MAX_RETRY {
    republish_to_retry(&channel, &delivery, count).await?;
} else {
    republish_to_dlx(&channel, &delivery).await?;
}
delivery.ack(BasicAckOptions::default()).await?;

常见误区

  • 用 requeue 做重试,消息立即循环重投,压垮服务。
  • 重试次数不随消息传递,重启后计数丢失导致无限重试。

追问

  • 重试消息保留原始头吗?答:重新发布时需手动复制属性与消息体,DLX 转发则保留头信息。
  • 退避级别怎么定?答:按错误类型分级,网络类短间隔重试,外部依赖类长间隔,最大次数封顶。

04.4.10.2-056 RPC 请求-响应模式在 RabbitMQ 中如何实现?

一句话结论

请求方发布消息并指定 reply_to 回调队列与 correlation_id,响应方处理后把结果发回回调队列;请求方按 correlation_id 匹配响应。

概念解释

RabbitMQ 自身不提供同步 RPC,需要应用层构造请求响应链路。请求方通常声明临时排他队列作为回调地址,消息属性带 reply_to 与 correlation_id。响应方消费请求,处理后向 reply_to 发布结果,带上同一 correlation_id。请求方订阅回调队列,按 ID 匹配等待结果。超时未收到响应需兜底,避免永久挂起。并发请求靠不同 correlation_id 区分。

原理流程

  1. 请求方创建临时回调队列。
  2. 发布请求,属性填 reply_to、correlation_id。
  3. 响应方消费请求并处理。
  4. 向 reply_to 发布响应,回写 correlation_id。
  5. 请求方匹配 ID 取回结果,超时则报错。

代码或图示

let props = BasicProperties::default()
    .with_reply_to(callback_queue.clone())
    .with_correlation_id("req-1001".into());
channel.basic_publish("rpc", "command", Default::default(), payload, props).await?;
// 响应方: 向 reply_to 发布带同一 correlation_id 的结果

常见误区

  • 多个请求共用一个 correlation_id,响应错配。
  • 回调队列未做超时处理,响应丢失后请求永久等待。

追问

  • 回调队列用哪种声明?答:临时场景通常 exclusive 队列,请求结束即回收。
  • 响应方挂了怎么办?答:请求方设置超时与重试,结合死信告警排查。

04.4.10.2-057 basic_return 在什么情况下收到消息?

一句话结论

发布时开启 mandatory,消息路由不到任何队列时 broker 通过 basic_return 把消息退回生产者;不监听则不可路由消息被静默丢弃。

概念解释

交换机收到消息后若无绑定队列匹配,默认丢弃并可记录日志。mandatory 标记要求 broker 在不可路由时把消息退回生产者。lapin 通道提供返回监听器接收退回消息,携带原消息与路由信息。生产者据此重试绑定、转储本地或告警。未开 mandatory 时退回机制不触发;开了但未监听返回流,退回消息同样无人处理。

原理流程

  1. 发布选项设置 mandatory: true。
  2. 交换机匹配不到绑定队列。
  3. broker 执行 basic_return 把消息退回。
  4. 生产者返回监听器收到消息。
  5. 按策略本地补偿、告警或重配拓扑。

代码或图示

let mut return_listener = channel.start_basic_return_listener();
while let Some(ret) = return_listener.next().await {
    eprintln!("unroutable: {} -> {}", ret.exchange, ret.routing_key);
}

常见误区

  • 以为消息发出去就一定入队,忽略不可路由情况。
  • 开了 mandatory 却不消费返回流,退回消息无人处理。

追问

  • mandatory 与 confirm nack 区别?答:mandatory 针对路由不到队列,confirm 针对 broker 是否接受确认,两者可同时开启。
  • 不可路由常见原因?答:绑定键不匹配、队列未绑定、交换机类型选错。

04.4.10.2-058 连接状态与通道状态如何监听?

一句话结论

连接与通道提供状态监听入口,可订阅关闭/可用事件;业务据此判断是否进入重连,而不是在每次发布时才发现断线。

概念解释

lapin 连接句柄可查询状态,通道有状态与关闭错误信息。断线原因分两类:网络断开、对端主动关闭、协议错误。监听状态变化后,外层 worker 退出并触发重连循环。通道关闭常伴随错误回复(如队列不存在、参数冲突),需要记录通道级错误码。状态监听具体 API 名称以 lapin 当前版本文档为准;不确定的方法标注待确认。

原理流程

  1. 建立连接后获取状态监听入口。
  2. 通道打开后记录其状态与错误来源。
  3. 状态变为关闭时读取错误原因。
  4. 通知外层循环停止当前处理。
  5. 进入退避重连流程。

代码或图示

// 待确认:当前 lapin 版本连接/通道状态监听的具体方法名,
// 验证方式为 docs.rs/lapin latest 的 Connection 与 Channel 文档;
// 答题先说明状态监听用途与断线分类,不写死未核对签名。

常见误区

  • 只在发布报错时才发现断线,积压期间无人感知。
  • 把通道级配置错误当成网络断线反复重连。

追问

  • 通道关闭错误怎么看?答:读取通道关闭回复中的错误码与文本,区分配置冲突与网络故障。
  • 连接存活探活靠什么?答:AMQP 心跳由 broker 与客户端协商,具体心跳配置对照 RabbitMQ 与 lapin 文档。

04.4.10.2-059 vhost 与连接字符串如何组织?

一句话结论

AMQP URI 中路径段是 vhost,默认 /;含特殊字符的 vhost 需 URL 编码,凭证与主机信息按 amqp://user:pass@host:port/vhost 拼装。

概念解释

vhost 是 broker 内的资源隔离边界,交换机、队列、权限都在 vhost 内。连接字符串 scheme 为 amqp(明文)或 amqps(TLS)。URI 路径段写入 vhost,/ 本身需编码为 %2f。多环境用不同 vhost 隔离测试与生产。凭证从环境变量注入,不在代码里拼接明文密码。URI 解析错误常见于 vhost 未编码或端口缺失。

原理流程

  1. 从配置读取主机、端口、凭证、vhost。
  2. vhost 做 URL 编码后拼入 URI 路径段。
  3. connect 解析 URI 并完成认证。
  4. 连接内资源都属于该 vhost。
  5. 跨 vhost 不能直接路由,需另建连接。

代码或图示

amqp://user:password@broker:5672/%2f
amqps://user:password@broker:5671/orders-vhost

常见误区

  • vhost 写 /%2f 时双重编码导致路径解析错误。
  • 不同环境共用默认 vhost,测试队列影响生产。

追问

  • 跨 vhost 怎么通信?答:不能直接转发,通过应用层桥接或联邦插件,具体方案对照 RabbitMQ 文档。
  • 端口默认值?答:amqp 5672,amqps 5671。

04.4.10.2-060 RabbitMQ 的 TLS 连接如何配置?

一句话结论

使用 amqps scheme 并在连接属性中提供 TLS 配置(CA 证书等);双向认证额外提供客户端证书与私钥,具体 TLS 类型与方法以 lapin 当前版本为准。

概念解释

加密连接走 5671 端口与 amqps URI。lapin 的 TLS 配置依赖底层 TLS 库,CA 证书、域名校验按运行时配置。单向认证只验证 broker 证书;双向认证客户端提交证书给 broker 校验。证书从环境或挂载目录读取,不写入仓库。TLS 握手失败先核对证书链、有效期、主机名与端口。待确认点:当前 lapin 版本 TLS 配置类型名与构造方式,验证路径 docs.rs/lapin。

原理流程

  1. 准备 CA 证书(与客户端证书/私钥,双向认证时)。
  2. 用 amqps:// URI 发起连接。
  3. 连接属性注入 TLS 配置。
  4. 完成 TLS 握手后进入 AMQP 认证。
  5. 握手失败按证书链与域名逐项排查。

代码或图示

// 待确认:lapin 当前版本 TLS 配置结构与 ConnectionProperties 注入方式,
// 验证方式为 docs.rs/lapin latest 与官方 TLS 示例;
// URI 使用 amqps:// 与 5671 端口是确定部分。

常见误区

  • 明文端口 5672 配 amqps,协议与端口不匹配握手失败。
  • 调试时关闭证书校验,生产未恢复校验。

追问

  • 证书文件路径写哪?答:通过环境变量或挂载配置传入,代码不写死本机绝对路径。
  • 双向认证缺什么?答:客户端证书与私钥,并在 broker 侧配置信任 CA。

04.4.10.2-061 RabbitMQ 重投场景下消费幂等如何设计?

一句话结论

以业务唯一键做去重表,消息重投时先查是否已处理;ack 动作放在业务与去重记录落库之后,保证重复消息被安全跳过。

概念解释

RabbitMQ 未 ack 消息在断连后重投,重试链路也会重新投递,重复消费是常态。幂等设计:消息携带稳定业务 ID,处理前查去重记录;命中则直接 ack 跳过;未命中执行业务并在同一事务内写去重记录,再 ack。去重窗口覆盖最大重试周期。外部副作用(发邮件、扣款)尤其需要幂等,避免重复触发。

原理流程

  1. 消息携带业务唯一 ID 与重试次数。
  2. 查去重表,已处理则 ack 跳过。
  3. 未命中:业务写入与去重记录在同一事务提交。
  4. ack 消息。
  5. 重投到达时被去重表拦截。

代码或图示

if processed(&body.id).await? {
    delivery.ack(BasicAckOptions::default()).await?;
    continue;
}
tx(|conn| apply(&body, conn)).await?;
delivery.ack(BasicAckOptions::default()).await?;

常见误区

  • 先 ack 再处理,崩溃后消息丢失而非重投。
  • 去重记录与业务写入分离,崩溃后重复执行副作用。

追问

  • 去重记录保留多久?答:覆盖重试与重投最大窗口,超期由清理任务回收。
  • 并发重复消息怎么防?答:数据库唯一索引约束业务 ID,并发双写只成功一笔。

04.4.10.2-062 长连接与短连接在 Rust 服务中如何取舍?

一句话结论

常驻服务用长连接(单连接多通道),低频任务或临时脚本可用短连接;长连接需自带重连与心跳维护,短连接省去状态管理但握手成本高。

概念解释

消息队列客户端通常是长连接:TCP 与 AMQP 握手成本高,持续推送依赖连接存活。Web 服务内嵌消费者时维护长连接,断线重连。短连接适合定时批处理:每次任务启动连接、取一批消息、处理完关闭。长连接的代价是必须处理断线、重连、拓扑恢复;短连接每次重新声明拓扑,不保留在途消费者状态。高频消息链路不要为了简单改用短连接。

原理流程

  1. 评估消息频率与服务形态。
  2. 常驻消费者:建立长连接,监听断线并重连。
  3. 批处理任务:按需建连,处理完释放。
  4. 长连接维护心跳与通道资源上限。
  5. 按监控指标调整连接数量。

代码或图示

长连接: 启动建连 -> 持续消费 -> 断线重连 -> 退出关闭
短连接: 建连 -> 拉取一批 -> 处理 -> 关闭连接

常见误区

  • 高频消费用短连接,反复握手拖慢吞吐。
  • 长连接不做重连,网络抖动后消费者永久掉线。

追问

  • 长连接空闲会被断开吗?答:受 AMQP 心跳与 broker 超时配置影响,需保持心跳协商。
  • 连接数怎么规划?答:按实例数、业务通道数与 broker 连接上限核算,留余量。

04.4.10.2-063 单连接多通道与多连接的并发模型怎么选?

一句话结论

默认单连接多通道:通道轻量、帧多路复用;只有单连接通道数到上限、或需要资源/故障隔离时才拆多连接。

概念解释

AMQP 连接是 TCP 与认证边界,通道是连接内逻辑复用单元。大多数应用一条连接开若干通道,按业务域隔离(发布通道、各消费者通道)。多连接增加 broker 连接表压力与握手开销,但能隔离故障:一个连接异常不影响其他。判断依据:通道数是否接近上限、是否需要不同凭证/vhost、是否要求故障隔离。Rust 侧连接与通道都可克隆共享,拆分成本主要在重连与资源管理。

原理流程

  1. 估算通道需求与 broker 连接/通道上限。
  2. 默认单连接创建多通道。
  3. 不同 vhost 或凭证必须拆分连接。
  4. 关键业务域按故障隔离拆分连接。
  5. 监控连接数、通道数与错误率。

代码或图示

Connection A
 ├─ Channel publish-orders
 ├─ Channel consumer-orders
 └─ Channel consumer-payments
Connection B(隔离/不同 vhost 时启用)

常见误区

  • 每个消费者一条连接,broker 连接表被占满。
  • 把所有业务塞一个通道,通道错误波及全部消费者。

追问

  • 通道有数量上限吗?答:broker 与连接均有配置上限,超配需拆分连接,具体数值对照 RabbitMQ 配置。
  • 通道隔离粒度怎么定?答:按业务域或可靠性等级,发布与消费分开,关键消费者独立通道。

04.4.10.2-064 消息发布后丢失的排查顺序是什么?

一句话结论

先确认生产者是否收到 broker 确认,再查交换机路由、队列绑定与消息持久化,最后看消费者是否异常丢弃;按发布链路从源头往下游定位。

概念解释

消息丢失可能发生在各层:生产者本地缓冲未发、未开确认不知失败、交换机不可路由、队列未绑定、消息瞬态重启丢失、消费者未 ack 后崩溃、业务过滤丢弃。排查按链路顺序:确认日志与 confirm 记录 → broker 端交换机/绑定/队列状态 → 消息是否持久化 → 消费者 ack 与错误日志。每一层用证据确认,不要直接怀疑消费者代码。

原理流程

  1. 检查生产者 confirm/nack 记录与发送日志。
  2. 在 broker 管理侧查看交换机绑定与队列深度。
  3. 核对消息 delivery_mode 与队列/交换机 durable。
  4. 检查消费者是否订阅、prefetch 与 ack 记录。
  5. 追踪单条消息的 correlation_id/业务键定位断点。

代码或图示

生产者确认 -> 交换机路由 -> 队列绑定 -> 持久化 -> 消费者订阅 -> ack/业务处理

常见误区

  • 不开启 confirm,发布失败无从定位。
  • 业务层过滤掉消息却不记录,表现为「消息消失」。

追问

  • 怎么追踪单条消息?答:用 correlation_id 或业务键贯穿生产者、broker 与消费者日志。
  • 重启后消息没了先查什么?答:队列与交换机 durable、消息 delivery_mode 是否持久化。

04.4.10.2-065 lapin 与 tokio、async-std 的兼容性如何判断?

一句话结论

lapin 异步 API 不绑定单一运行时,以 crate 文档标注的适配为准;在 tokio 服务中直接 await 其异步方法,跨运行时驱动需确认类型的 Send 与调度约束。

概念解释

lapin 的 Future 设计在异步抽象之上,具体运行时适配以当前版本说明为准。tokio 服务里消费者流与发布方法都在 tokio 任务中 await。若项目使用 async-std,需核对 lapin 版本对该运行时的支持。不确定的适配细节标注待确认并查 docs.rs。运行时混用(tokio 任务里驱动 async-std 专用类型)容易出现上下文错误,应避免。

原理流程

  1. 查阅 docs.rs/lapin 当前版本的运行时说明。
  2. 在主运行时中构造连接与通道。
  3. 异步方法在该运行时任务内 await。
  4. 跨任务共享句柄确认满足 Send。
  5. 若切换运行时,回归验证连接、消费与重连。

代码或图示

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let conn = Connection::connect(&uri, ConnectionProperties::default()).await?;
    // ... 在 tokio 任务中驱动消费循环
    Ok(())
}

常见误区

  • 凭旧版本记忆声称只支持某一运行时,未核对当前文档。
  • 把异步句柄 move 到无运行时上下文的线程调用阻塞方法。

追问

  • 类型跨任务要求什么?答:句柄需满足 Send,可在 tokio 多线程运行时任务间传递;具体约束以源码 trait 实现为准。
  • 出现运行时上下文错误怎么查?答:确认构造与 await 都在同一运行时上下文,未在 enter 守卫外调用阻塞入口。

04.4.10.2-066 NATS 与 Kafka、RabbitMQ 的定位差异是什么?

一句话结论

NATS 是轻量级云原生消息系统,核心是 subject 路由的高速消息总线;Kafka 偏向日志流式存储与回溯,RabbitMQ 偏向复杂路由与可靠队列;NATS 持久化由 JetStream 提供。

概念解释

NATS Core 提供至少一次的 subject 发布订阅,内存转发、吞吐高、部署简单;JetStream 在其上增加持久化流、消费确认与重放。Kafka 以分区日志为中心,擅长事件回溯与流处理;RabbitMQ 交换机路由能力强,擅长任务队列与复杂拓扑。选型维度:消息是否需要持久化与回溯、路由复杂度、吞吐延迟要求、运维复杂度。NATS 适合微服务总线、边缘与轻量场景;重日志流选 Kafka。

原理流程

  1. 梳理消息模式:广播、队列、流回溯还是任务分发。
  2. 评估持久化、顺序、路由与吞吐要求。
  3. 对比三者运维模型与团队经验。
  4. 选定后用对应 Rust 客户端接入。
  5. 关键链路补充幂等与监控。

代码或图示

NATS Core: subject 发布订阅, 内存转发
JetStream: 持久化 Stream + Consumer, 确认重放
Kafka:     分区日志, 持久化回溯
RabbitMQ:  交换机路由, 任务队列

常见误区

  • 把 NATS Core 当成持久化消息队列,未启用 JetStream 时重启消息丢失。
  • 用 NATS 替代 Kafka 做长期事件留存,能力不匹配。

追问

  • NATS 持久化在哪一层开启?答:JetStream 模块创建 Stream,Core 本身不持久化历史消息。
  • 微服务内部总线优先选什么?答:NATS 接入轻量、路由简单;复杂路由与严格队列语义再评估 RabbitMQ。

04.4.10.2-067 async_nats::connect 如何建立连接,默认重连行为是什么?

一句话结论

async_nats::connect(url) 异步建立 NATS 连接并返回 Client;客户端默认在断连后自动重连,订阅与发布行为按重连后状态恢复,具体恢复细节以当前版本为准。

概念解释

async-nats 是 NATS 官方维护的 Rust 异步客户端。connect 接收服务器地址(可多个集群节点),完成协议握手返回可克隆的 Client 句柄。连接内置重连机制:网络断开后客户端按策略尝试重连,重连期间发布与订阅行为受影响。多地址配置时客户端在节点间故障转移。认证信息可在 URI 或连接选项中传入。断线事件可通过连接的事件/状态接口观察,API 名称以 docs.rs/async-nats 当前版本为准。

原理流程

  1. 配置单节点或多节点 NATS 地址。
  2. async_nats::connect(url).await? 建立连接。
  3. 拿到 Client 克隆给发布与订阅任务。
  4. 断线后客户端内部重连并恢复订阅。
  5. 监听状态事件,长时间不可用触发告警。

代码或图示

use async_nats::connect;

let client = connect("nats://localhost:4222").await?;
// client 可克隆后在多任务间共享

常见误区

  • 以为断线后需要业务层手动重建订阅,忽略客户端自动重连能力。
  • 只配单节点地址,节点故障时无故障转移。

追问

  • 多节点地址怎么写?答:connect 支持地址列表或集群发现,具体格式以 crate 文档为准。
  • 重连期间消息会丢吗?答:Core 消息内存转发,重连窗口内消息可能丢失;需要不丢应使用 JetStream。

04.4.10.2-068 NATS subject 命名规范与层级分隔符是什么?

一句话结论

subject 以 . 分隔层级,命名用小写点分单词(如 orders.created.paid);发布方与订阅方通过 subject 匹配规则关联。

概念解释

NATS subject 是点分字符串,每段是一个层级。命名习惯:业务域.资源.事件,全小写、用连字符连接单词。订阅通配:* 匹配单层,> 匹配多层(只能放末尾)。subject 设计应稳定且可预测,避免运行时动态拼接出难以订阅的主题。大小写敏感,前缀规划要支持后续按域订阅。与 MQTT 的 / 层级与 +/# 规则不同,不要混用。

原理流程

  1. 按业务域规划 subject 前缀。
  2. 发布方按 域.资源.事件 命名。
  3. 订阅方用精确 subject 或通配符订阅。
  4. 匹配按层级逐段进行。
  5. 主题演进时保持前缀兼容。

代码或图示

发布: orders.created.1001
订阅: orders.created.*      (单层通配)
订阅: orders.>              (多层通配,末尾)

常见误区

  • > 放在中间层级,匹配规则非法。
  • subject 含大写或空格,订阅方按规范匹配不上。

追问

  • * 与 > 匹配范围?答:* 替换恰好一段,> 替换一段或多段且必须在末尾。
  • 动态 subject 有什么风险?答:不可预测的层级使订阅与权限规划困难,事件主体应放进消息体。

04.4.10.2-069 如何订阅 NATS 主题并迭代消息?

一句话结论

client.subscribe(subject).await? 返回消息流,迭代 Message 读取 payload 与 reply subject;JetStream 订阅则通过 Consumer 拉取并 ack。

概念解释

Core 订阅返回 Subscriber(实现 Stream),每条消息是 Message,包含 payload 字节、subject、reply 可选字段。迭代方式与其他异步流一致:while let Some(msg) = subscriber.next().await。Core 消息无内置确认,收到即处理;需要持久化与确认时走 JetStream Consumer。订阅可带队列组实现负载均衡。消息体序列化在 Rust 侧用 serde 完成。

原理流程

  1. client.subscribe(subject) 建立订阅。
  2. 拿到消息流并在任务中迭代。
  3. 读取 msg.payload 解析业务对象。
  4. 需要回复时向 msg.reply 发布响应。
  5. 流结束或任务取消时停止迭代。

代码或图示

use futures::StreamExt;

let mut sub = client.subscribe("orders.created.*").await?;
while let Some(msg) = sub.next().await {
    println!("{}: {:?}", msg.subject, msg.payload);
}

常见误区

  • 在 Core 订阅里等待消息确认,Core 本身没有 ack 语义。
  • 把消息 payload 当字符串直接用,忽略二进制与编码判断。

追问

  • 消息 reply 字段什么时候有?答:发布方设置了响应主题(请求-响应模式)时携带,订阅方据此回复。
  • 订阅流可以并发处理吗?答:可以在迭代内 spawn 任务,但顺序与并发度自行控制;需要竞争消费用队列组。

04.4.10.2-070 NATS queue group 如何实现竞争消费?

一句话结论

同一 subject 的订阅者加入同一 queue group,broker 把每条消息投递给组内一个成员,实现负载均衡;不同组之间仍各自收到广播副本。

概念解释

queue group 是 NATS 的竞争消费机制:多个订阅者用相同组名订阅同一 subject,消息在组内负载均衡,每条只由一个成员处理。组名相同互斥消费,组名不同则互相独立、各自收到全量。这与 Kafka 消费者组概念类似,但分区模型不同:NATS 按订阅者均衡投递。扩容消费者只需加入同组;宕机成员的订阅由客户端重连恢复。Core 模式下组内消息不持久化,断线窗口可能丢失。

原理流程

  1. 多个消费者进程订阅同一 subject。
  2. 订阅时指定同一 queue group 名称。
  3. NATS 把消息轮询/均衡投给组内一员。
  4. 成员下线后组内重新分配。
  5. 其他 group 仍独立收到广播。

代码或图示

let sub = client
    .subscribe("orders.created.*")
    .queue_group("order-workers")
    .await?;

常见误区

  • 同组消费者误以为都能收到全量消息。
  • 组名按实例号区分,失去竞争消费效果。

追问

  • 队列组与普通订阅混合?答:普通订阅者收到广播副本,队列组内竞争一份,两者可并存。
  • 消息顺序在队列组内保证吗?答:不保证跨成员顺序,相关消息需要路由键分组或单消费者处理。

04.4.10.2-071 JetStream 的 Stream 与 Consumer 分别是什么概念?

一句话结论

Stream 是持久化消息流(主题集合、存储与保留策略),Consumer 是订阅 Stream 的消费视图(位置、确认、重试策略);一个 Stream 可挂多个 Consumer。

概念解释

JetStream 把消息持久化为 Stream:配置 subject 匹配、存储类型(内存/文件)、保留策略与过期规则。Consumer 绑定到 Stream,定义从哪里开始读、如何确认、重试次数与并发。每个 Consumer 维护自己的消费位置,互不影响。类比 Kafka:Stream 类似带配置的日志分区集合,Consumer 类似消费组视图。Rust 侧通过 client.jetstream() 拿到 JetStream 上下文再操作。

原理流程

  1. 调用 client.jetstream() 获取 JetStream 接口。
  2. get_or_create_stream 定义 subject 与持久化策略。
  3. 在 Stream 上 create_consumer 配置消费视图。
  4. 拉取/订阅 Consumer 消息并 ack。
  5. 未 ack 消息按策略重投。

代码或图示

let js = client.jetstream();
let stream = js.get_or_create_stream(StreamConfig {
    name: "orders".into(),
    subjects: vec!["orders.>".into()],
    ..Default::default()
}).await?;

常见误区

  • 把 Stream 当消费者订阅对象,跳过 Consumer 直接读持久化消息。
  • 多个 Consumer 共用一个消费位置,实际各有独立进度。

追问

  • Stream 保留策略有哪些?答:按消息数、时长、大小等保留方式,具体枚举以 JetStream 文档与 crate 配置为准。
  • 一个 Stream 能被多个应用消费吗?答:可以,各 Consumer 独立维护进度与确认。

04.4.10.2-072 JetStream at-least-once 的确认与重投语义是什么?

一句话结论

JetStream 消费者处理成功后显式 ack,未 ack 的消息在超时后按策略重新投递;因此是至少一次,重复消费需业务幂等。

概念解释

JetStream 消息有交付状态:未确认、已确认、重试中。消费者收到消息后处理,成功调用 ack;显式 nak 或不 ack 会触发重投,重投次数与等待时间由 Consumer 配置控制。消息在 Stream 中持久化,重连后进度可恢复。与 Kafka 类似,至少一次不等于不重复:崩溃、未 ack、nak 都会导致重放。业务用唯一键去重兜底。pull 与 push 两种消费模式的确认入口一致,具体 API 以 async-nats 当前版本为准。

原理流程

  1. Consumer 拉取/接收一条消息。
  2. 执行业务处理。
  3. 成功:ack 标记完成。
  4. 失败:nak 或留待超时,进入重投队列。
  5. 超过重试上限按配置进入死信/丢弃状态。

代码或图示

while let Some(msg) = consumer.messages().await?.next().await {
    match process(&msg).await {
        Ok(()) => msg.ack().await?,
        Err(_) => msg.nak().await,
    }
}

常见误区

  • 处理成功忘记 ack,消息反复重投。
  • 把 nak 当永久丢弃,实际 nak 触发重投;终态失败需按配置处理。

追问

  • ack 超时在哪里配?答:Consumer 配置的 ack 等待时间与重试策略,具体字段对照 JetStream 文档。
  • 重投次数耗尽后消息去哪?答:按 Consumer/Stream 配置进入丢弃或死信状态,需查阅配置项。

04.4.10.2-073 NATS KV(Key-Value)存储如何创建与读写?

一句话结论

JetStream 上下文提供 KV 桶:创建 KeyValue 后按 key 读写删除;KV 底层是专用 Stream,适合配置、状态与轻量元数据,不适合大对象。

概念解释

NATS KV 是构建在 JetStream 之上的键值抽象:每个桶对应一个 Stream,key 的 put/get/delete 映射为消息操作。支持 revision 版本、历史查看与 watch 监听变更。Rust 侧通过 JetStream 接口创建或获取 KV 桶。适用场景:功能开关、服务注册表、会话状态;大文件与二进制对象应使用 Object Store。KV 操作有一致性语义与 revision 乐观并发控制,具体 API 字段以 docs.rs/async-nats 为准。

原理流程

  1. 获取 JetStream 上下文。
  2. create_key_value 或读取已有桶。
  3. put(key, value) 写入,返回 revision。
  4. get(key) 读取值与版本。
  5. 监听变更或按 revision 做乐观更新。

代码或图示

let kv = js.create_key_value(KeyValueConfig {
    bucket: "config".into(),
    ..Default::default()
}).await?;
kv.put("feature-checkout", b"on".into()).await?;
let entry = kv.get("feature-checkout").await?;

常见误区

  • 用 KV 存大二进制,底层消息体积受限。
  • 忽略 revision 直接覆盖写,并发更新互相覆盖。

追问

  • KV 有版本号吗?答:每次写入带 revision,可用于乐观并发控制,读取时可获取历史版本。
  • KV 与 Core subject 发布怎么选?答:需要状态读取与版本控制用 KV;纯事件通知用 subject 发布。

04.4.10.2-074 Object Store 适合什么场景,大对象如何分片?

一句话结论

Object Store 用于存储大文件/二进制,底层自动分块为多个消息并维护元数据;超过 KV 与单消息体积限制的内容走对象存储。

概念解释

大对象不适合直接放进单条 NATS 消息:有体积上限且重放成本高。Object Store 把文件切块分块存储,记录块索引与元数据(名称、大小、哈希),读取时重组。Rust 侧通过 JetStream 对象存储接口 put/get。适合分发安装包、图片、模型文件等;频繁读写的热状态仍用 KV。对象删除与版本管理语义以 crate 文档为准。

原理流程

  1. 获取 JetStream 对象存储接口。
  2. 上传时把文件分块写入,记录元数据。
  3. 下载时按索引重组块。
  4. 对象按名称寻址与管理。
  5. 超大或冷数据评估是否改用外部对象存储。

代码或图示

Object Store:
  object meta (name, size, digest)
  chunk-1, chunk-2, ... chunk-N  -> 下载时重组

常见误区

  • 把几 MB 字段塞进单条 subject 消息,触发消息体积限制。
  • 对象存储里存需要高频条件查询的数据,模型不匹配。

追问

  • 对象分片由谁完成?答:客户端/对象存储接口负责切块与重组,业务侧按对象名读写。
  • 体积上限受什么影响?答:JetStream 消息与 Stream 配置限制,具体数值对照 NATS 文档。

04.4.10.2-075 NATS 请求-响应模式如何实现?

一句话结论

发布时可指定 reply 主题,服务端向 reply 主题发布响应;客户端用 request 一步完成请求并等待匹配响应,按 inbox 与消息关联。

概念解释

NATS 内置请求响应模式:client.request(subject, payload) 内部创建临时 inbox 作为 reply,发布请求并订阅响应,等待返回匹配消息。服务端消费请求,读取 msg.reply 后发布结果到该主题。响应按临时 inbox 隔离,并发请求互不干扰。超时未响应需设置等待上限。与 RabbitMQ RPC 相比,NATS 的临时 inbox 由客户端自动管理,代码更简洁。

原理流程

  1. 客户端调用 request(subject, payload)。
  2. 客户端创建临时响应主题并订阅。
  3. 请求发到目标 subject,携带 reply。
  4. 服务端处理后向 reply 发布响应。
  5. 客户端收到匹配响应返回结果,超时则报错。

代码或图示

let reply = client.request("health.check", payload.into()).await?;
println!("reply: {:?}", reply.payload);

// 服务端
while let Some(msg) = sub.next().await {
    if let Some(reply) = msg.reply {
        client.publish(reply, response.into()).await?;
    }
}

常见误区

  • 服务端不检查 reply 字段,响应无处可发。
  • 请求不设超时,响应丢失后 Future 长期挂起。

追问

  • 临时 inbox 何时回收?答:客户端请求结束后清理,具体生命周期以 crate 实现为准。
  • 响应如何关联请求?答:inbox 主题在客户端内部唯一,响应回到该主题即匹配原请求。

04.4.10.2-076 NATS 重连后订阅如何恢复?

一句话结论

客户端自动重连后,已注册的订阅由客户端内部重新注册;业务侧应监听重连事件,核对订阅与 JetStream 消费位置是否恢复,必要时手动补订阅。

概念解释

async-nats 内置重连:连接断开后按策略重试,成功后恢复 Core 订阅。JetStream 消费进度保存在服务端 Consumer 中,重连后从上次位置继续;Core 消息不持久化,重连窗口内消息丢失。业务可通过连接状态/事件接口观察断线与重连时刻,在重连后做自检:订阅是否存在、消费者是否在拉取。具体状态监听 API 以 docs.rs/async-nats 当前版本为准,不确定处标注待确认。

原理流程

  1. 网络断开,客户端进入重连状态。
  2. 重连成功,内部重新注册 Core 订阅。
  3. JetStream Consumer 从服务端保存的位置继续。
  4. 业务监听事件确认恢复完成。
  5. 长时间不可用触发告警与人工介入。

代码或图示

断线 -> 内部退避重连 -> 重注册 Core 订阅 -> JetStream 恢复消费位置 -> 业务自检

常见误区

  • 以为重连后未确认消息会自动重放,Core 模式下并不持久化。
  • 不监听重连事件,订阅实际未恢复时静默丢消息。

追问

  • 重连窗口消息丢失怎么兜底?答:关键链路改用 JetStream 持久化,或业务层补偿重发。
  • 如何确认订阅恢复?答:重连后检查订阅句柄状态与消息流入速率,异常则重新订阅。

04.4.10.2-077 async-nats 的消息头与消息体是什么类型?

一句话结论

消息体是字节数组 Bytes,消息头为键值元数据结构;Rust 侧按约定编码字符串或二进制,读取时判断字段是否存在。

概念解释

async-nats 的 Message 携带 payload 字节与可选 headers。headers 用于元数据(trace id、版本、来源),不放大段业务数据。序列化在业务层完成:JSON 用 serde,二进制按 schema 编码。headers 的具体类型与读写方法名以当前 crate 文档为准;读取缺失字段必须兜底。消息体克隆会复制字节,大消息注意内存占用。

原理流程

  1. 生产者序列化业务对象为字节。
  2. 构造消息头附加元数据。
  3. publish(subject, payload) 发送。
  4. 消费者读取 payload 与 headers。
  5. 按格式反序列化为业务对象。

代码或图示

let mut headers = async_nats::HeaderMap::new();
headers.insert("trace-id", "trace-1001");
client.publish_with_headers("orders.created", headers, body.into()).await?;

常见误区

  • 假设消息一定带某个头,未判空导致解析错误。
  • 在头里放大字段,浪费消息体积。

追问

  • payload 类型是什么?答:字节容器,业务自行按 UTF-8 或二进制解码。
  • 大消息体如何降低复制?答:避免不必要克隆,按需要切片读取,具体优化点对照 crate 文档。

04.4.10.2-078 JetStream 如何保留历史消息与回放?

一句话结论

Stream 按配置保留消息(按数量、时长或大小),新 Consumer 可从指定起点(最早、最新或最后消费位置)回放历史。

概念解释

Core NATS 消息过内存即丢;JetStream Stream 把消息落盘并保留到满足淘汰策略。Consumer 配置起始位置决定读历史:从头回放、只读新消息、或接上次位置。保留策略控制磁盘占用,过期消息被删除。回放场景:新服务上线补数、故障后重放事件、审计追溯。注意回放会放大下游负载,需限速与幂等。Stream 多 Consumer 互不影响各自回放位置。

原理流程

  1. 创建 Stream 时配置保留策略与 subject。
  2. 消息写入 Stream 持久化。
  3. 新建 Consumer 选择起始位置。
  4. 按位置回放历史消息并 ack。
  5. 超过保留策略的消息被淘汰。

代码或图示

Stream retention: limits / interest / work-queue(具体枚举以 NATS 文档为准)
Consumer start:   all / last / new / 按时间或序号

常见误区

  • 无限期保留所有消息,磁盘随时间涨满。
  • 回放历史时未做限速,压垮下游服务。

追问

  • 回放会不会重复写业务?答:会,回放与正常消息叠加,消费端必须幂等。
  • 保留策略有哪几类?答:按限制、按兴趣、工作队列等,具体名称与语义对照 JetStream 官方文档。

04.4.10.2-079 NATS 认证方式在 connect 时如何传入?

一句话结论

支持 token、用户名密码、NKey 等方式,凭证可放在 URI 或连接选项中;生产凭证从环境变量读取,不写入源码。

概念解释

NATS 服务端可配置认证:用户密码、token、NKey 签名等。async-nats 连接时通过 URI 内嵌凭证或连接选项传入。NKey 涉及密钥签名握手,具体构造方式以 crate 文档为准。凭证属于敏感信息,按环境变量或密钥管理注入;日志中不得打印密码与 token。连接失败先核对认证方式是否与服务端配置一致,再查网络与权限。

原理流程

  1. 确认服务端认证机制(用户密码/token/NKey)。
  2. 从环境变量读取凭证。
  3. 组装 URI 或构造连接选项。
  4. connect 完成认证握手。
  5. 认证失败按错误类型排查凭证与权限。

代码或图示

nats://user:password@host:4222
nats://token@host:4222
// NKey 等其他方式的构造以 docs.rs/async-nats 当前版本为准

常见误区

  • 在代码或日志里写明文凭证。
  • 认证机制与服务端配置不匹配(如服务端要求 NKey 却传密码)。

追问

  • 多节点认证如何保持一致?答:凭证在集群配置中统一管理,客户端配置一套有效凭证即可。
  • 认证失败错误怎么读?答:连接返回错误中区分凭证无效、权限不足与网络不可达。

04.4.10.2-080 JetStream 消费者积压与限制如何排查?

一句话结论

积压表现为 Consumer 未 ack 消息堆积、流内待消费序号滞后;排查消费速率、并发 ack、重试次数与 Stream 资源限制,再决定扩容或调参。

概念解释

JetStream 积压来源:消费速度低于生产速度、下游慢导致 ack 延迟、失败消息反复重试、Consumer 并发配置过低。排查指标:待消费消息数、未确认消息数、重试次数、消费时延。Consumer 拉取/推送模式与并发度影响吞吐;Stream 磁盘与内存限制触达后会拒绝新消息。定位慢在下游依赖还是消费循环本身,再扩容消费者或优化处理逻辑。

原理流程

  1. 查看 Consumer 待消费与未确认计数。
  2. 统计消费时延与失败/重试比例。
  3. 检查下游依赖(DB、外部 API)是否瓶颈。
  4. 核对 Stream 磁盘/内存限制是否触达。
  5. 调整并发、重试或扩容 Consumer 后观察积压回落。

代码或图示

待消费积压 -> 消费时延高? -> 下游依赖慢 / 消费循环慢 / 重试风暴 / 资源限制

常见误区

  • 只加消费者不改下游瓶颈,积压依旧。
  • 失败消息无限 nak 重试,形成重试风暴占满消费额度。

追问

  • 未确认消息过多怎么办?答:检查 ack 逻辑与超时配置,避免消息长期悬挂占用并发额度。
  • Stream 写不进去先查什么?答:磁盘配额、保留策略与主题匹配,再看客户端发布错误。

04.4.10.2-081 MQTT 在物联网场景与消息队列的定位有什么差异?

一句话结论

MQTT 面向受限设备与弱网络,基于发布订阅的轻量协议,QoS 分级、retain 与遗嘱是其特色;它不是为高吞吐日志流或复杂路由设计的队列系统。

概念解释

MQTT 运行在 TCP 之上,客户端与 Broker 通信,主题层级用 / 分隔。设计目标:低带宽、低功耗、海量设备连接。消息可靠性靠 QoS 0/1/2 分级;retain 保留最新消息供新订阅者获取;遗嘱消息在设备异常离线时通知其他端。服务端到设备的推送、遥测上报是典型场景。与 Kafka/RabbitMQ 相比,MQTT 不强调消息持久化回溯与复杂交换机路由。Rust 侧常用 rumqttc 客户端。

原理流程

  1. 设备/服务端连接 MQTT Broker。
  2. 按主题发布或订阅消息。
  3. Broker 按主题路由,按 QoS 完成握手。
  4. 保留消息与遗嘱按规则投递。
  5. 应用层接入业务处理或转存后端系统。

代码或图示

device --publish telemetry--> broker --match topic--> subscriber
device offline -> last-will 消息 -> broker -> 通知订阅者

常见误区

  • 把 MQTT 当持久化消息队列使用,忽略其设备导向定位。
  • 用 MQTT 主题做复杂条件路由,规则能力有限。

追问

  • MQTT 与 NATS 主题规则有何不同?答:MQTT 用 / 分层,+ 单层、# 多层;NATS 用 . 分层,* 单层、> 多层。
  • 海量连接瓶颈在哪?答:Broker 连接数、会话状态与心跳维护,需按 Broker 集群能力规划。

04.4.10.2-082 rumqttc 的 Client 与 EventLoop 为什么拆成两个对象?

一句话结论

Client 是发布/订阅的调用句柄,EventLoop 负责驱动网络连接、心跳与事件收发;拆分后发布动作可在任意任务调用,网络循环在独立任务中驱动。

概念解释

rumqttc 把 API 句柄与事件循环分离:Client 提供 publish、subscribe、unsubscribe 等方法,内部把命令发给事件循环;EventLoop 跑连接、重连、心跳与入站消息分发。这样业务任务持有 Client 即可发布,事件循环在 tokio 任务中 poll 驱动。两者通过内部通道协作。若不驱动 EventLoop,连接不会建立、订阅不生效、入站消息不处理。具体构造签名以 docs.rs/rumqttc 当前版本为准。

原理流程

  1. 调用客户端构造方法同时得到 Client 与 EventLoop。
  2. EventLoop spawn 到独立任务循环 poll。
  3. 业务任务用 Client 发布/订阅。
  4. 入站事件由 EventLoop 解析为事件枚举。
  5. 断线时 EventLoop 内部重连并恢复会话。

代码或图示

let (mut client, mut eventloop) = rumqttc::Client::new(options, 10);
tokio::spawn(async move {
    while let Ok(event) = eventloop.poll().await {
        // 处理 Event::Incoming(...)
    }
});
client.subscribe("devices/+/telemetry", QoS::AtLeastOnce).await?;

常见误区

  • 只创建 Client 不驱动 EventLoop,消息永远发不出去。
  • 把 EventLoop 放在阻塞线程跑,tokio 任务无法并发发布。

追问

  • Client 句柄能克隆吗?答:按 crate 实现可克隆共享给多任务,具体以当前文档为准。
  • 事件循环断线谁重连?答:EventLoop 内部按配置重连,业务监听事件判断连接状态。

04.4.10.2-083 MQTT QoS 0、1、2 的握手语义与可靠性层级是什么?

一句话结论

QoS 0 至多一次、不确认;QoS 1 至少一次、靠 PUBACK 保证到达,可能重复;QoS 2 恰好一次、四次握手去重,开销最高。

概念解释

QoS 分级定义消息送达保证:0 发布即忘,无握手;1 发送后等待 PUBACK,超时重发,消息可能重复;2 通过 PUBREC/PUBREL/PUBCOMP 四次握手完成消息 ID 去重,避免重复投递,成本最高。设备遥测可用 0 或 1;控制指令等敏感操作评估 1 或 2。订阅端实际收到的 QoS 是发布与订阅协商后的较低值。重复消息仍需业务幂等兜底,QoS 2 不代表业务 exactly-once。

原理流程

  1. 发布方按主题与目标支持级别确定 QoS。
  2. QoS 0:直接下发,无确认。
  3. QoS 1:下发后等 PUBACK,未确认则重发。
  4. QoS 2:四次握手交换消息 ID 状态,完成去重。
  5. 订阅方按协商级别处理消息与确认。

代码或图示

QoS 0: PUBLISH
QoS 1: PUBLISH <-> PUBACK
QoS 2: PUBLISH <-> PUBREC -> PUBREL <-> PUBCOMP

常见误区

  • 以为 QoS 2 业务层就不会重复执行副作用。
  • 所有消息都用 QoS 2,握手开销拖慢海量设备场景。

追问

  • 发布与订阅 QoS 不一致取哪个?答:取两者协商后的较低级别,具体规则对照 MQTT 规范。
  • QoS 1 重复消息怎么识别?答:消息 ID 与业务键结合去重,业务层保留幂等判断。

04.4.10.2-084 retain 标志的作用是什么,保留消息如何清除?

一句话结论

retain 标记的最新消息会被 Broker 保留,新订阅者一上线就能收到;发布空载荷的 retain 消息可清除对应主题的保留消息。

概念解释

普通消息只投递给当前在线订阅者;retain 消息由 Broker 存一份最新值,后续任何订阅者匹配主题即收到。典型用途:设备最后状态、在线标志、配置快照。每个主题只保留一条 retain 消息,新 retain 覆盖旧值。清除方式:向同一主题发布 payload 为空且 retain=true 的消息。retain 消息不参与 QoS 重放历史,只存最新一条。设备离线状态不要误用 retain 表达。

原理流程

  1. 发布消息时设置 retain=true。
  2. Broker 覆盖该主题的保留消息。
  3. 新订阅者匹配主题,先收到保留消息。
  4. 需要清除:发布空载荷 retain 消息。
  5. 业务区分实时消息与状态快照。

代码或图示

client.publish(
    "devices/1001/state",
    QoS::AtLeastOnce,
    true, // retain
    payload,
).await?;

常见误区

  • 用 retain 存历史事件,实际只留最新一条。
  • 忘记清理测试 retain 消息,新订阅者一直收到旧状态。

追问

  • retain 消息会随会话过期吗?答:保留消息由 Broker 按配置存储,与会话状态是不同概念,具体行为对照 MQTT 规范与 Broker 实现。
  • 空载荷 retain 消息还带 QoS 吗?答:清除消息仍按主题与发布规则处理,具体行为以规范为准。

04.4.10.2-085 遗嘱消息(Last Will)在设备异常离线时如何工作?

一句话结论

连接时注册遗嘱主题、载荷与 QoS,设备未正常断开(断线、心跳超时)时 Broker 代为发布遗嘱;正常断开不触发遗嘱。

概念解释

Last Will 是连接级配置:客户端连接 Broker 时登记一条遗嘱消息,设备异常掉线(TCP 断开、keep_alive 超时、会话异常)时,Broker 把遗嘱发到指定主题,通知其他端设备离线。正常调用断开流程时遗嘱不发布。遗嘱常用于上报设备离线状态。遗嘱消息自身也可设置 retain,使离线状态被新订阅者读到。遗嘱内容在连接建立时固定,不能运行时修改。

原理流程

  1. 连接选项中配置遗嘱主题、载荷、QoS、retain。
  2. 设备正常上线,遗嘱暂存 Broker。
  3. 异常离线:Broker 发布遗嘱到遗嘱主题。
  4. 订阅者收到离线通知并更新状态。
  5. 正常断开:遗嘱被丢弃,不发布。

代码或图示

connect(will = { topic: "devices/1001/state", payload: "offline", retain: true })
异常断线 -> broker 发布 will -> 订阅者收到 offline
正常断开 -> will 不发布

常见误区

  • 设备正常下线也期待触发遗嘱,实际只有异常断开才发布。
  • 遗嘱载荷与上线状态主题不一致,状态更新错乱。

追问

  • 遗嘱能设置 retain 吗?答:可以,离线状态适合 retain 持久化到主题。
  • 遗嘱何时被清除?答:连接正常结束时遗嘱不发布并移除,异常时发布后按保留规则处理。

04.4.10.2-086 MQTT 主题通配符 + 与 # 的匹配规则与位置限制是什么?

一句话结论

+ 匹配恰好一层,可出现在任意层级;# 匹配多层且必须放在主题末尾;订阅侧使用通配,发布主题一般不用通配。

概念解释

主题用 / 分层。+ 替换单层,例如 devices/+/telemetry 匹配 devices/a/telemetry。# 替换零层或多层,只能是最后一段,例如 devices/#。通配符只用于订阅,发布消息的主题必须是具体层级。层级为空或通配符位置非法(如 # 在中间)会被 Broker 拒绝。设计主题时把可变标识(设备 ID)放在固定层级,便于通配订阅。

原理流程

  1. 规划主题层级:域/设备标识/事件。
  2. 订阅方按需要用 + 或 # 匹配。
  3. Broker 逐层比对主题字符串。
  4. 命中规则的消息投递给订阅者。
  5. 非法通配订阅在连接/订阅阶段被拒绝。

代码或图示

devices/+/telemetry      单层匹配
devices/+/+/config       多层 + 组合
devices/#                末尾多层匹配

常见误区

  • 把 # 写在主题中间,订阅被拒绝。
  • 发布时使用通配主题,消息无法精确路由。

追问

  • 空层级主题合法吗?答:连续 / 产生空层级,按规范与 Broker 实现判断,设计上应避免。
  • 通配订阅权限如何控制?答:Broker 按主题 ACL 限制可订阅范围,敏感主题需隔离。

04.4.10.2-087 连接选项 clean session、keep_alive、client_id 分别控制什么?

一句话结论

client_id 标识会话,clean session 决定断开后是否保留会话与订阅,keep_alive 定义心跳间隔判断设备存活。

概念解释

client_id 是客户端在 Broker 中的唯一身份,同 ID 重复连接会踢掉旧连接。clean session=true:断开后清除订阅与未送达消息;false:会话持久保留,重连后恢复订阅与离线消息(受 Broker 会话配置支持)。keep_alive 秒数内无任何报文,Broker 判定离线并触发遗嘱。QoS 1/2 离线消息依赖持久会话。设备重连场景需权衡 clean session 与消息可达性。MQTT 5 的会话续接字段语义略有差异,具体以规范与 rumqttc 版本为准。

原理流程

  1. 连接时生成/复用稳定 client_id。
  2. 设置 clean session 决定会话保留。
  3. 配置 keep_alive 心跳间隔。
  4. 断线后按会话状态恢复或清空订阅。
  5. 超时未心跳触发离线判定与遗嘱。

代码或图示

client_id: 设备唯一标识
clean_session: true  -> 断开即清会话
              false -> 保留订阅与离线消息
keep_alive: 心跳秒数,超时判离线

常见误区

  • 每次重连随机 client_id,持久会话与离线消息无法恢复。
  • keep_alive 设过长,设备掉线发现滞后。

追问

  • clean session=false 前提是什么?答:Broker 支持持久会话,且订阅与离线消息有存储能力。
  • client_id 冲突会怎样?答:后连接者通常踢掉先前同 ID 连接,具体行为对照 Broker 实现。

04.4.10.2-088 rumqttc 的订阅与退订 API 如何使用?

一句话结论

client.subscribe(topic, qos) 订阅主题,unsubscribe(topic) 退订;订阅结果与消息到达通过 EventLoop 事件流观察。

概念解释

订阅调用向 Broker 发起 SUBSCRIBE 报文,可一次订阅多个主题。返回结果表示订阅请求是否被接受;实际消息在 EventLoop 的入站事件中收到。退订发送 UNSUBSCRIBE,解除主题匹配。订阅 QoS 与发布 QoS 协商后决定实际级别。多主题订阅可用批量订阅接口,具体方法签名以 docs.rs/rumqttc 当前版本为准。订阅动作不阻塞消息循环,事件在 EventLoop 任务中分发。

原理流程

  1. 业务任务调用 subscribe 带主题与 QoS。
  2. Client 把订阅命令交给 EventLoop。
  3. EventLoop 发送 SUBSCRIBE 并等待确认。
  4. 匹配消息作为入站事件进入事件流。
  5. 不再需要时 unsubscribe 解除。

代码或图示

client.subscribe("devices/+/telemetry", QoS::AtLeastOnce).await?;
// 事件循环中
match event {
    Event::Incoming(Publish(msg)) => { /* 处理 msg.topic, msg.payload */ }
    _ => {}
}

常见误区

  • 订阅后在 Client 句柄上直接等消息,忽略消息要从 EventLoop 事件取。
  • 退订后未清理本地处理状态,残留旧主题逻辑。

追问

  • 批量订阅怎么做?答:使用多主题订阅接口传入主题与 QoS 列表,具体名称对照当前 crate 文档。
  • 订阅被拒绝如何感知?答:EventLoop 事件流中观察订阅确认/错误事件。

04.4.10.2-089 事件循环中的 Incoming/Outgoing 事件如何驱动业务?

一句话结论

EventLoop poll 返回事件枚举:Incoming 是 Broker 下行报文(Publish、Connack、Suback 等),Outgoing 是本地发出报文;业务在 Incoming 分支处理消息与连接状态。

概念解释

rumqttc 把协议报文抽象为事件。Event::Incoming(Publish) 携带收到的消息;Connack 表示连接结果;Suback/Unsuback 确认订阅动作;Outgoing 用于观察本地发送。业务循环匹配事件枚举,在 Publish 分支解析 payload。连接断开、重连也通过事件暴露。事件枚举变体名称以当前版本为准;不处理连接事件会错过离线/重连状态。

原理流程

  1. EventLoop 持续 poll 得到事件。
  2. 匹配 Event::Incoming 区分报文类型。
  3. Publish 分支读取主题与载荷并执行业务。
  4. Connack/状态事件更新连接状态标记。
  5. Outgoing 事件按需用于观测发送流量。

代码或图示

use rumqttc::{Event, QoS, Packet::Publish};

while let Ok(event) = eventloop.poll().await {
    match event {
        Event::Incoming(Publish(p)) => println!("{}: {:?}", p.topic, p.payload),
        Event::Incoming(_) => {}
        Event::Outgoing(_) => {}
    }
}

常见误区

  • 只处理 Publish 事件,忽略 Connack 失败与断线事件。
  • 在事件循环里跑阻塞重计算,卡住后续报文处理。

追问

  • 连接成功怎么判断?答:监听 Incoming Connack 事件,按返回码确认会话建立。
  • 事件循环报错退出怎么办?答:外层按错误类型决定重连或终止,避免无限紧循环。

04.4.10.2-090 MQTT 5 与 3.1.1 在 rumqttc 中的支持差异需要注意什么?

一句话结论

协议版本在连接选项中指定,MQTT 5 新增属性报文、共享订阅、消息过期等特性;具体版本支持程度与 API 字段以 rumqttc 当前版本文档为准,不确定项标注待确认。

概念解释

MQTT 5 在 3.1.1 基础上增加:报文属性、原因码、共享订阅、主题别名、消息过期会话等。rumqttc 对两个版本的支持范围随版本演进,连接选项中选择协议版本。答题时不臆造具体字段名:凡涉及 MQTT 5 属性读写、共享订阅接口,先查 docs.rs/rumqttc 最新文档与官方协议支持说明。设备侧需与 Broker 支持的版本对齐,混用版本可能握手失败。

原理流程

  1. 确认 Broker 支持的协议版本。
  2. 连接选项指定 MQTT 3.1.1 或 5。
  3. 握手协商版本与能力。
  4. 按版本可用特性组织消息与订阅。
  5. 升级前回归验证订阅、QoS 与遗嘱行为。

代码或图示

// 待确认:rumqttc 当前版本对 MQTT 5 特性(属性报文、共享订阅等)的
// 完整支持清单与对应 API,验证方式为 docs.rs/rumqttc latest 与 changelog。

常见误区

  • 凭印象声称 rumqttc 已完整支持 MQTT 5 全部特性。
  • Broker 与客户端版本不一致,握手原因码未正确处理。

追问

  • 共享订阅是什么?答:MQTT 5 队列组式订阅,多客户端竞争消费同一主题,具体支持以 Broker 与 crate 为准。
  • 版本不兼容先查什么?答:连接返回原因码、协议版本配置与 Broker 日志。

04.4.10.2-091 设备侧断线重连与会话恢复如何处理?

一句话结论

EventLoop 按配置自动重连,clean session=false 时重连后恢复订阅与离线消息;业务侧监听连接事件,重连成功后补发本地缓存的关键状态。

概念解释

弱网环境设备频繁掉线:rumqttc 事件循环内置重连,业务不要自行反复创建客户端。持久会话(clean session=false)下,Broker 保留订阅与离线 QoS 1/2 消息,重连后补发;非持久会话重连需重新订阅。重连成功后,设备应上报当前状态(可能用 retain),避免与 Broker 侧旧状态不一致。重连间隔需退避,避免 Broker 压力。会话恢复与离线消息能力依赖 Broker 配置。

原理流程

  1. 连接配置 client_id、clean session、keep_alive 与重连策略。
  2. 断线后 EventLoop 退避重连。
  3. 持久会话:Broker 恢复订阅并补发离线消息。
  4. 非持久会话:重连后重新执行订阅。
  5. 设备上线后上报最新状态,纠正离线期间数据差。

代码或图示

断线 -> 退避重连 -> 会话恢复/重新订阅 -> 补发离线消息 -> 上报当前状态

常见误区

  • 重连后不重新订阅(非持久会话),主题收不到消息。
  • 本地缓存关键事件未补发,离线期间数据丢失。

追问

  • 离线消息受什么限制?答:持久会话与 Broker 消息存储配置,QoS 0 离线不保证留存。
  • 重连风暴怎么防?答:退避间隔加抖动,限制重试频率,避免海量设备同时重连。

04.4.10.2-092 设备频繁上下线(心跳超时)如何排查?

一句话结论

先查网络链路与 keep_alive 配置,再看设备负载、Broker 连接容量与 NAT 超时;心跳超时是表象,要定位报文为什么没有按时到达。

概念解释

频繁离线表现为 keep_alive 超时触发遗嘱与重连。可能原因:弱网丢包、NAT 会话老化、设备 CPU 繁忙无法按时心跳、Broker 负载过高丢报文、keep_alive 设置过短。排查路径:网络质量与链路中间设备超时 → 设备进程状态与阻塞点 → Broker 连接/消息指标 → 心跳参数与遗嘱日志。设备侧阻塞任务会拖慢事件循环,心跳报文发不出去。

原理流程

  1. 核对 keep_alive 时长与网络 RTT、NAT 超时。
  2. 检查设备网络丢包与重连日志。
  3. 查看设备进程是否被阻塞任务卡住。
  4. 检查 Broker 连接数、内存与报文丢弃指标。
  5. 调整心跳间隔、退避策略或扩容 Broker 后观察。

代码或图示

心跳超时 -> 网络丢包 / NAT 老化 / 设备阻塞 / Broker 过载 / 心跳过短

常见误区

  • 一味调大 keep_alive,掩盖设备阻塞或网络问题。
  • 设备主循环跑同步重计算,心跳报文无法按时发出。

追问

  • 事件循环被阻塞怎么定位?答:检查 publish/处理逻辑里的同步 IO 与长任务,移到独立任务或异步化。
  • Broker 侧看哪些指标?答:连接数、订阅数、入站/出站报文速率与拒绝/丢弃计数,具体对照 Broker 监控文档。

04.4.10.2-093 Kafka、RabbitMQ、NATS、MQTT 的选型对比矩阵怎么列?

一句话结论

按吞吐、顺序、持久化、路由模型、消费模式与场景定位对比:Kafka 重日志流,RabbitMQ 重路由与任务队列,NATS 重轻量总线,MQTT 重设备连接。

概念解释

选型维度:消息持久化与历史回溯、单分区/队列顺序保证、路由表达能力、消费组竞争模式、吞吐与延迟、运维复杂度、客户端成熟度。Kafka:分区日志、可回溯、高吞吐、路由简单。RabbitMQ:交换机多类型路由、任务队列、确认机制成熟。NATS:轻量高速、JetStream 补持久化、微服务总线。MQTT:受限设备、弱网、QoS 与遗嘱。没有全能选型,先定消息模式再挑中间件。

原理流程

  1. 明确消息模式:事件流、任务分发、广播、设备遥测。
  2. 列出持久化、顺序、回溯、路由硬性要求。
  3. 对比团队经验与运维成本。
  4. 小规模原型验证吞吐与故障恢复。
  5. 确定主选与降级备选。

代码或图示

| 维度   | Kafka        | RabbitMQ       | NATS          | MQTT          |
| 定位   | 事件日志流    | 路由/任务队列  | 轻量消息总线  | 设备接入      |
| 持久化 | 分区日志回溯  | 队列可持久化   | JetStream     | 依赖会话/Broker|
| 路由   | topic/key    | 交换机多类型   | subject 通配  | topic 通配    |
| 消费   | 消费者组      | 队列竞争       | 队列组        | 订阅/共享订阅 |

常见误区

  • 只看吞吐选型,忽略路由能力与团队运维经验。
  • 用设备协议承载后端业务流,能力与场景错配。

追问

  • 任务队列(发邮件、异步处理)优先选什么?答:RabbitMQ 队列语义成熟;NATS 与 Kafka 也可承载,按现有基础设施决定。
  • 事件溯源与回溯选什么?答:Kafka 分区日志或 NATS JetStream 保留策略,按规模与运维能力选。

04.4.10.2-094 消息可靠性设计的三段防线是什么?

一句话结论

生产确认保证消息离开生产者并被 Broker 接受,持久化保证 Broker 重启不丢,消费确认保证处理完成后再提交;三段缺一不可。

概念解释

可靠链路分段设防:生产段等待发布确认(Kafka 交付 Future、RabbitMQ confirm、NATS request/ack 或 JetStream ack);存储段开启持久化(durable 队列、磁盘消息、Stream 落盘);消费段处理成功后确认 offset/ack/nack。任何一段缺失都会出现静默丢失:不确认不知发送失败,不持久化重启丢消息,过早确认跳过失败消息。三段配合业务幂等才能形成完整可靠性。

原理流程

  1. 生产者等待 Broker 确认再继续,失败重试或补偿。
  2. Broker 侧配置持久化与副本/磁盘写入。
  3. 消费者处理成功后提交确认。
  4. 失败消息进入重试/死信链路。
  5. 全链路埋点追踪消息状态。

代码或图示

生产确认 -> 持久化存储 -> 消费确认 -> 重试/死信

常见误区

  • 只做消费侧幂等,生产与持久化段裸奔。
  • 确认动作与业务写入不在同一一致性边界,崩溃后状态不一致。

追问

  • 三段都做了还会丢吗?答:Broker 故障、磁盘损坏、机房灾难仍需副本/备份与对账兜底。
  • 如何追踪一条消息状态?答:贯穿生产、存储、消费的唯一 ID 与各段确认日志。

04.4.10.2-095 幂等消费的业务唯一键与去重表怎么落地?

一句话结论

每条业务消息带全局唯一事件 ID,消费端先查去重表:已处理则跳过并确认,未命中则业务写入与去重记录同事务提交,再确认消息。

概念解释

至少一次投递下重复不可避免,幂等是消费侧必备防线。唯一键来自生产者(事件 ID 或业务主键),不能用中间件 offset/消息 ID 充当,因为重放后这些会变。去重表可用业务库唯一索引强约束,或缓存加 TTL 加速。并发重复写入靠数据库唯一约束兜底。去重记录保留窗口覆盖最大重放周期,定期清理。外部副作用操作(扣款、通知)必须在幂等保护内执行。

原理流程

  1. 生产者为事件分配稳定唯一 ID。
  2. 消费者提取 ID 查询去重记录。
  3. 命中:直接确认消息并跳过。
  4. 未命中:事务内执行业务并插入去重记录。
  5. 提交确认;重放消息被去重表拦截。

代码或图示

if dedup_exists(event_id).await? {
    ack(msg); continue;
}
tx(|conn| { apply(&body, conn); mark_dedup(event_id, conn) }).await?;
ack(msg);

常见误区

  • 先查后写不加唯一约束,并发下双写重复执行。
  • 去重记录与业务写入分离提交,崩溃留下重复副作用。

追问

  • 去重表存不下历史怎么办?答:按业务状态机兜底,已终态事件直接拒绝;热窗口用缓存。
  • 重复间隔超过去重窗口怎么办?答:延长关键业务保留期,或对账系统扫描补偿。

04.4.10.2-096 事务消息与 outbox 模式如何保证本地事务与发消息一致?

一句话结论

outbox 模式:业务写入与「待发消息」记录在同一本地事务提交,后台进程把 outbox 表投递到 Broker 并标记已发;避免先提交业务再发消息导致的丢失。

概念解释

直接模式的问题:先写库再发消息,发消息失败则业务已提交;先发消息再写库,写库失败则消息已发出。outbox 把消息写入与业务变更放进同一数据库事务:事务提交后两者同时生效。后台投递器扫描 outbox 记录,发布到消息中间件,成功后标记已发;投递至少一次,消费者幂等。部分中间件提供事务消息(半消息/本地消息表),思路相同。Rust 侧 outbox 表用 SQLx 等数据访问层管理,投递器独立运行。

原理流程

  1. 业务事务内写业务数据与 outbox 消息记录。
  2. 事务提交,两者原子生效。
  3. 后台投递器扫描待发记录并发布。
  4. 发布确认后标记 outbox 已发。
  5. 失败记录按重试策略重投,消费端幂等吸收重复。

代码或图示

[业务库事务] 业务数据 + outbox 行  ->  提交
后台投递器: 扫描 outbox -> 发布 MQ -> 确认 -> 标记 sent

常见误区

  • 消息发送失败后不回查 outbox,消息永久卡在待发。
  • outbox 记录与业务不在同一事务,一致性被打破。

追问

  • 投递器并发怎么防重复发?答:outbox 行加状态与锁/认领机制,配合消费者幂等。
  • 事务消息中间件方案区别?答:Broker 侧协调半消息与回查,outbox 是应用侧表方案,按基础设施选择。

04.4.10.2-097 顺序消费与并发消费如何权衡?

一句话结论

按业务实体划分顺序边界:同一实体消息串行处理,不同实体之间并发;用分区键/队列组保证同实体落同一分区或队列,避免为全局有序牺牲吞吐。

概念解释

全局严格有序需要单分区/单队列,吞吐受限。实践中的顺序要求通常是「同一实体的事件有序」:按实体 ID 作分区键,同实体进同一分区,消费端对该实体串行;不同实体并行。消费并发模型:分区内顺序拉取,分区间并行;任务内可按实体键分流到串行处理器。跨分区乱序事件带版本号/时间戳防护旧状态覆盖新状态。顺序与并发的取舍本质是确定哪些实体必须串行。

原理流程

  1. 识别必须保序的业务实体与操作序列。
  2. 以实体 ID 为键路由到固定分区/队列。
  3. 同实体消息串行处理,实体间并发。
  4. 事件带版本号拒绝乱序旧事件。
  5. 监控顺序冲突与乱序丢弃记录。

代码或图示

key = entity_id
partition-0: entity A 串行
partition-1: entity B 串行
不同实体并行;同实体不并发

常见误区

  • 为局部顺序要求把主题设为单分区,整体吞吐下降。
  • 同实体消息进并发任务池,先后交错导致状态错乱。

追问

  • 消费端同实体并发怎么限制?答:按 key 分流到独立串行任务或加实体级锁,队列组内注意分区分配。
  • 乱序旧事件怎么拦截?答:事件版本号/时间戳比对,旧版本不覆盖新版本状态。

04.4.10.2-098 重试预算、退避与死信处理的通用设计是什么?

一句话结论

为每条消息设最大重试次数与总时长预算,失败按指数退避加抖动重投,耗尽后进死信;重试区分瞬时错误与不可恢复错误,避免坏消息循环。

概念解释

重试不是无限重发:重试预算包含最大次数、累计时长与退避间隔。瞬时错误(网络、超时、下游抖动)可重试;业务校验、格式错误不可重试,直接死信。退避用指数增长加随机抖动,避免同时重投形成风暴。死信消息保留原始载荷、错误原因、重试轨迹,提供人工重放入口。重试期间消息状态可见,便于监控失败率与积压。各中间件重试链路不同,预算与分类思路通用。

原理流程

  1. 错误分类:可重试 / 不可重试。
  2. 可重试:递增计数,按退避策略进入延迟重试。
  3. 超过次数或总时长预算:转死信并告警。
  4. 不可重试:直接死信。
  5. 死信消息支持人工或自动补偿重放。

代码或图示

失败 -> 分类
  可重试: count+1, 指数退避+jitter, 未超预算 -> 重试队列
  不可重试 / 超预算 -> DLQ -> 告警 -> 补偿/重放

常见误区

  • 所有错误用相同重试策略,坏消息反复阻塞主链路。
  • 退避不加抖动,故障恢复瞬间同步重投打爆下游。

追问

  • 退避间隔怎么起步?答:按下游恢复时间评估,常见秒级起步指数增长,封顶上限。
  • 死信重放要注意什么?答:保留幂等键,重放前修正根因,避免再次进入死信循环。

04.4.10.2-099 消息积压的通用治理手段有哪些?

一句话结论

先定位瓶颈(生产过快、消费过慢、下游依赖、重试风暴),再用扩容消费者、优化处理逻辑、限流与分区/队列拆分治理;积压期间保护下游不被打垮。

概念解释

积压是消费速率持续低于生产速率的结果。定位步骤:看积压趋势与消费速率,拆解单条处理耗时,区分 CPU 瓶颈、下游 DB/API 瓶颈、阻塞任务、失败重试占比。治理手段:增加消费者实例/并发、拆分慢任务、优化下游依赖、限流生产端、按业务键拆分队列。扩容受分区数与队列并行度限制。积压期优先保护核心下游,非核心消息可降级延后。治理后复盘生产峰值与容量基线。

原理流程

  1. 监控积压深度、消费速率与处理时延。
  2. 剖析单条耗时,定位瓶颈环节。
  3. 区分重试/坏消息占比,清理无效循环。
  4. 扩容消费者或优化处理逻辑。
  5. 限流与降级兜底,复盘容量规划。

代码或图示

积压 -> 生产过快? 消费慢? 下游慢? 重试风暴?
治理: 扩容并发 / 拆队列 / 优化下游 / 限流生产 / 降级非核心

常见误区

  • 积压就加机器,不定位瓶颈,资源耗尽仍不下降。
  • 扩容超过分区/队列并行度,多余实例空闲。

追问

  • 分区数不够怎么扩容?答:先扩主题分区再扩消费者实例,注意 key 映射变化。
  • 积压时能否先丢弃非核心消息?答:按业务优先级降级,丢弃需记录并后续补偿,不能静默丢弃。

04.4.10.2-100 Rust 服务接入消息中间件的工程清单包含哪些项?

一句话结论

接入前确认依赖与运行时适配,连接与重连、配置外置、幂等与重试、监控埋点、优雅停机逐项落实;上线前用真实链路做验证。

概念解释

工程清单覆盖:Cargo 依赖与 feature 核对、客户端类型与 API 版本以 docs.rs 为准;连接配置(地址、认证、TLS、重连退避)从环境变量读取;消息序列化、唯一键与去重表;消费者并发、prefetch/并发度、重试与死信;指标埋点(吞吐、lag/积压、成功率、时延、错误分类);停机时提交确认与排空缓冲;测试覆盖正常、重复、断线与积压场景。不确定的 API 标注待确认并留验证点,不凭记忆写死版本行为。

原理流程

  1. 核对 crate 版本、feature 与运行时兼容性。
  2. 外置配置:地址、凭证、并发、重试参数。
  3. 实现生产确认、持久化、消费确认三段防线。
  4. 接入幂等、重试预算与死信链路。
  5. 暴露指标与日志,完成断线/积压/停机场景验证。

代码或图示

依赖核对 -> 配置外置 -> 可靠性三段 -> 幂等重试死信 -> 监控埋点 -> 优雅停机 -> 场景测试

常见误区

  • 本地开发能跑就上线,未验证断线重连与积压恢复。
  • 凭证与环境参数硬编码进仓库。

追问

  • 上线前必测哪些场景?答:正常收发、重复消费、断线重连、重启恢复、积压扩容、停机排空。
  • 指标至少暴露哪些?答:生产/消费速率、积压深度、成功率与失败分类、处理时延分布、重试次数。