Milvus 向量数据库高并发写入解决方案

Milvus 在面对高并发写入时,核心问题并不只是提高 Insert 请求的吞吐量,而是要解决:

  • 写入流量削峰
  • 数据写入吞吐
  • 资源隔离
  • 批量持久化
  • 数据一致性以及写入与查询之间的资源竞争

在企业级 RAG 知识库场景中,同时上传 PDF、Word、Excel 文档,经过解析、分块、Embedding 向量化后写入 Milvus,如果直接由业务服务并发调用 Insert,很容易出现:

  1. 大量小批次 Insert,导致请求开销和调度开销增加。
  2. Embedding 服务生成速度过快,Milvus 写入能力跟不上。
  3. DataNode、QueryNode 等组件资源竞争,影响查询性能。
  4. 数据持续写入导致 Flush、Compaction 压力增大。
  5. 多个客户端同时写入相同数据,出现重复数据或业务幂等问题。
  6. 高峰期写入积压,导致内存压力、请求超时甚至服务不可用。

为应对以上问题,采用如下架构:
Kafka 消息队列 + 批量写入 + 异步消费 + Milvus 分布式集群 + 写入限流

一、整体架构设计

文档处理与向量写入解耦,避免业务请求直接承受 Milvus 的写入压力。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
       用户上传文档
|
v
文档解析服务
|
v
文本分块
|
v
Embedding 服务
|
v
向量数据生产者
|
v
+-------------------+
| Kafka |
| 消息缓冲 / 削峰 |
+-------------------+
|
v
向量写入调度服务
|
+-------+-------+
| |
v v
Batch Worker Batch Worker
| |
+-------+-------+
|
v
Milvus Proxy
|
v
Milvus DataCoord
|
v
DataNode
|
v
Object Storage
|
v
Flush / Compaction

|
v
Milvus QueryNode
|
v
RAG 检索

注意:Milvus 内部采用组件化架构,Proxy 接收客户端请求,DataCoord 管理数据协调,DataNode 负责数据持久化相关处理,底层数据最终存储在对象存储中。Kafka 是业务侧缓冲层,不应与 Milvus 内部消息流机制混淆。

二、六个核心优化策略

2.1 Kafka 削峰填谷:解决瞬时高并发

解决问题:系统在某一时刻有 1000 个用户同时上传文档,每个文档经过切分产生 500 个 Chunk,那么短时间可能产生 50 万条向量数据。如果直接向 Milvus 发起 50 万次写入请求,会造成较大的请求压力。

解决方案:

  • 文档解析和 Embedding 完成后,将向量数据写入 Kafka。
  • 根据业务场景设置 Topic 和 Partition。
  • 写入消费者根据 Milvus 当前负载动态调整消费速度。
  • 当 Milvus 写入能力不足时,Kafka 暂存积压数据。
  • 当 Milvus 恢复后,消费者继续消费。

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from kafka import KafkaProducer
import json

producer = KafkaProducer(
bootstrap_servers=["localhost:9092"],
value_serializer=lambda x: json.dumps(
x, ensure_ascii=False
).encode("utf-8"),
acks="all",
retries=10,
enable_idempotence=True
)

def publish_vectors(vectors):
producer.send(
"milvus_vector_write",
value={
"vectors": vectors
}
)
producer.flush()

核心价值: 将瞬时流量转换成持续、可控的写入流量。

2.2 批量写入:减少请求开销

解决问题:大量小批次 Insert,导致请求开销和调度开销增加

例如:

写入方式 请求次数 说明
单条写入 100000 请求开销大
每100条批量 1000 有明显改善
每500条批量 200 减少请求开销
每1000条批量 100 进一步降低请求次数

解决方案:两种触发策略

  • 数量触发:达到 500~1000 条时执行批量写入。
  • 时间触发:等待 100~500ms,即使数量不足也执行写入。

具体阈值需要通过压测确定,不能认为批次越大越好,因为过大的批次也会增加内存占用和请求延迟。

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
from pymilvus import (
connections,
Collection
)
import time

connections.connect(
alias="default",
host="localhost",
port="19530"
)

collection = Collection("knowledge_vectors")

BATCH_SIZE = 500
FLUSH_INTERVAL = 0.3

buffer = []
last_flush_time = time.time()

def insert_batch(batch):
if not batch:
return

collection.insert(batch)

def add_vector(vector_data):
global last_flush_time

buffer.append(vector_data)

current_time = time.time()

if (
len(buffer) >= BATCH_SIZE
or current_time - last_flush_time >= FLUSH_INTERVAL
):
batch = buffer.copy()
buffer.clear()

insert_batch(batch)
last_flush_time = current_time

2.3 控制并发度:避免写入请求压垮 Milvus

解决问题:假设有 20 个 Worker,每个 Worker 同时发起 10 个 Insert 请求,那么 Milvus 同时可能承受 200 个写入请求。如果超过集群的处理能力,就会出现:

  • gRPC 请求超时。
  • DataNode 或 StreamingNode 资源紧张。
  • 内存使用率持续上升。
  • 写入延迟不断增加。
  • Compaction 和索引构建任务积压。

解决方案:
引入一个并发调度器。

示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
Kafka
|
v
Consumer Group
|
v
并发调度器
|
+---- Worker 1 ----+
+---- Worker 2 ----+
+---- Worker 3 ----+----> Milvus
+---- Worker 4 ----+
+---- Worker 5 ----+

可以使用信号量控制最大并发写入数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import asyncio
from pymilvus import AsyncMilvusClient

client = AsyncMilvusClient(
uri="http://localhost:19530"
)

MAX_CONCURRENCY = 5
semaphore = asyncio.Semaphore(MAX_CONCURRENCY)

async def write_batch(batch):
async with semaphore:
return await client.insert(
collection_name="knowledge_vectors",
data=batch
)

async def write_all(batches):
tasks = [
write_batch(batch)
for batch in batches
]

return await asyncio.gather(
*tasks,
return_exceptions=True
)

生产环境采用动态并发控制:

Milvus 状态 调度策略
CPU、内存正常,延迟低 逐步提高并发
写入延迟上升 降低并发
请求超时增加 暂停扩容,减少消费
Kafka 积压增加 根据数据库负载决定是否扩容 Worker
Milvus 恢复正常 逐步恢复消费

优化点:进一步采用 AIMD(加性增大、乘性减小)算法控制并发量。

例如:

  • 连续 30 秒写入成功率正常,增加 1 个并发。
  • 超时率超过阈值,并发量减半。
  • 设置最大并发和最小并发,防止震荡。

这样可以避免 Milvus 因瞬时流量过高而被压垮。

2.4 Milvus 集群扩容:提升整体写入能力

单个 Milvus 的写入能力存在瓶颈,可以考虑集群扩容。

Milvus Distributed 主要采用组件化架构,可以根据负载情况进行资源扩展。

组件 职责 优化方向
Proxy 接收客户端请求、请求路由 增加 Proxy 实例
StreamingNode(2.6 架构) 流式写入处理 根据写入负载扩容
DataCoord 数据协调、Segment 管理 关注协调任务和元数据压力
QueryNode 向量检索 独立扩容,保证查询能力
IndexNode 索引构建 增加计算资源
对象存储 持久化数据 提升 I/O 吞吐

注意:

  1. 版本差异,Milvus 2.6 的新架构引入了 StreamingNode,不能简单地把旧版本 DataNode 的职责和扩容方式直接套用到新版本。
  2. Collection 的 Shard 数量。
    Milvus 会根据 Shard 将写入请求路由到对应的虚拟通道,再分配到相应的写入处理组件。因此,合理设置 Shard 数量有助于提高写入并行度。

示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
from pymilvus import MilvusClient

client = MilvusClient(
uri="http://localhost:19530"
)

client.create_collection(
collection_name="knowledge_vectors",
dimension=768,
metric_type="COSINE",
shard_num=4
)

这里的 shard_num=4 只是示例,需要结合:

  • 写入吞吐量。
  • Collection 数据规模。
  • 并发写入数量。
  • 集群 StreamingNode 数量。
  • 查询负载。

进行压测确定。

注意:不要为了提高写入并发而无限增加 Shard。 Shard 过多也会增加通道、元数据和调度管理开销。

2.5 Flush 和 Compaction 优化:避免频繁持久化

不要在每次 Insert 后执行:collection.insert(data)collection.flush(),这种方式并不适合高并发场景。

原因是频繁 Flush 会导致 Segment 封存、持久化及后续索引构建等工作更加频繁,增加系统资源开销。

方案:

  1. 采用批量 Insert。
  2. 让 Milvus 自己管理正常的 Segment 封存和持久化流程。
  3. 不要每批数据都手动 Flush。
  4. 关注 Compaction 积压情况。
  5. 对历史数据采用批量导入。

注意:Milvus 的 Insert 返回成功,并不意味着数据已经完成持久化,也不意味着立即能够被搜索到。客户端确认、数据可见性和持久化是不同的阶段。

2.6 幂等性和失败重试:保证高并发下的数据正确性

高并发写入一定要考虑重复消费和失败重试。

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Kafka 消息
|
v
Worker 执行 Insert
|
v
Milvus 写入成功
|
v
Worker 返回结果
|
X 网络异常
|
v
Kafka 消息重新消费
|
v
再次 Insert

这里可能产生重复数据。

注意:Milvus 的普通 Insert 不会因为 Primary Key 相同就自动执行更新,也不会自动保证主键唯一。

使用确定性主键:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import hashlib

def generate_primary_key(
document_id,
chunk_index,
version
):
raw = (
f"{document_id}:"
f"{chunk_index}:"
f"{version}"
)

digest = hashlib.sha256(
raw.encode()
).digest()

return int.from_bytes(
digest[:8],
byteorder="big"
) & 0x7FFFFFFFFFFFFFFF

生产设计:

  • Document ID:文档唯一标识。
  • Chunk Index:分块序号。
  • Version:文档版本。
  • Primary Key:通过上述字段生成稳定 ID。

对于更新操作,可以采用 Upsert,或者通过业务版本管理实现旧版本删除、新版本写入。

但要注意,Upsert 也不是所有并发更新场景下的事务保障,尤其是同一实体同时被多个请求修改时,需要在业务层进行协调。

Kafka 消息确认建议遵循:

1
2
3
4
5
6
7
8
9
10
消费 Kafka 消息
|
v
执行 Milvus 批量写入
|
v
确认写入成功
|
v
提交 Kafka Offset

如果写入失败,则不能直接提交 Offset,而应该进入重试机制;对于无法恢复的异常,进入死信队列。

三、千万级数据如何进一步优化?

如果不是实时增量写入,而是一次性导入几十万、几百万甚至上千万条向量数据,采用 Milvus Bulk Import(批量导入)。

流程:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
原始文档数据
|
v
Embedding计算
|
v
多Worker并行处理
|
v
生成Parquet文件
|
v
上传对象存储
|
v
Milvus Bulk Import
|
v
后台索引构建
|
v
数据校验
|
v
Collection上线

两种写入方式的选择:

场景 推荐方案
实时新增文档 Insert 批量写入
文档更新 Upsert / 版本管理
百万级历史数据初始化 Bulk Import
千万级、亿级离线导入 Bulk Import
实时数据持续进入 Kafka + 批量 Insert

四、如何监控写入性能?

不能仅关注 Insert 成功率,还要监控写入链路的整体状态。

建立以下监控指标:

监控层 指标 作用
Kafka Consumer Lag 判断数据积压
Kafka 消费速率 判断消费能力
Worker Batch Size 判断批量效率
Worker 并发数 判断资源利用率
Worker 写入失败率 判断异常情况
Milvus Insert Throughput 判断写入吞吐
Milvus Insert Latency 判断写入延迟
Milvus CPU / Memory 判断资源瓶颈
Milvus Segment 数量及状态 判断数据组织情况
Milvus Compaction 状态 判断后台整理压力
Milvus Index Build 状态 判断索引构建是否积压

特别关注三个指标:

  1. 写入吞吐量:每秒能够写入多少条向量(Vectors/s)。
  2. P99 写入延迟:99% 的写入请求能否在目标时间内完成。
  3. Kafka Consumer Lag:消息积压是否持续增加。

如果 Kafka 积压不断增加,说明生产速度已经超过消费速度,需要判断瓶颈究竟在 Embedding、Worker,还是 Milvus。

五、企业级最终架构

六、实际项目中应该如何选择参数?

假设有一个知识库系统:

  • 7000 名用户。
  • 每个用户每天上传 10 份文档。
  • 每份文档平均产生 500 个 Chunk。
  • 每个 Chunk 对应一个 768 维向量。

那么:

\[ 7000 \times 10 \times 500 = 3500万 \]

每天需要写入约 3500 万条向量。

平均每秒写入量:

\[ \frac{3500万}{86400} \approx 405 \]

如果业务集中在 2 小时内完成,则平均每秒写入约 4861 条。

这意味着不能只按照日均 405 条设计,还必须考虑峰值流量。

采用以下初始配置进行压测:

参数 初始建议
Batch Size 500~1000
Worker 数量 4~8
单 Worker 并发 1~2
Batch 刷新间隔 300ms
Kafka Partition 8~16
重试次数 3~5
最大重试间隔 指数退避
Flush 不逐批手动执行

这些是压测起点,不是生产环境的固定配置。最终要根据向量维度、字段大小、硬件资源和 P99 延迟进行调整。

最后更新: 2026年11月17日 16:47