一、问题背景

我们做的是一个图文内容检索系统,用户上传图片后提取 CLIP 向量,然后在向量库里做相似检索,返回候选素材。业务量级大概是 1000 万条向量、每天增量 20 万左右,向量维度 768,查询 QPS 峰值 50 左右,要求 P99 延迟控制在 100ms 以内。

之前在原型阶段用的是 FAISS 单机索引,简单够用,但随着数据量上去,索引重建、增量更新、多副本容灾这些事全得自己写,维护成本越来越高。于是开始正经评估专业向量数据库,候选就是 Milvus 和 Qdrant 这两个社区热度最高的。

网上大多数对比文章要么只讲功能列表,要么拿几千条数据跑个 demo,参考价值有限。所以我干脆自己搭环境、灌真实量级的数据、压测、看监控,把结论写下来。本文所有数字都来自我自己的测试环境,不是官方 benchmark,仅供参考。

二、环境与版本

  • 服务器:单机,AMD EPYC 7543 32 核 / 128GB RAM / NVMe SSD 2TB,CentOS 7.9
  • Milvus:2.4.6(standalone 模式,Docker Compose 部署,依赖 etcd 3.5.5 + MinIO)
  • Qdrant:1.9.2(Docker 部署,单节点)
  • 客户端:Python 3.10,pymilvus 2.4.4,qdrant-client 1.9.1
  • 测试数据:1000 万条随机生成的 768 维 float32 向量(模拟 CLIP 输出分布,做了归一化),外加 10 万条查询向量

需要说明的是,Milvus 我这里用的是 standalone 而不是 cluster,因为对比对象是单机 Qdrant,公平起见都在单机形态下比。如果上集群,Milvus 的横向扩展能力是另一个话题。

三、方案设计

两边的索引方案都选 HNSW,这是当前综合性能最好的选择。参数对齐如下:

  • Milvus:index_type=HNSW,M=16,efConstruction=200,查询时 ef=64
  • Qdrant:hnsw_config: m=16, ef_construct=200,查询时 hnsw_ef=64

距离度量统一用 COSINE(向量已归一化,等价于内积)。

测试分三块:
1. 批量写入 1000 万条,记录总耗时和写入期间内存峰值
2. 单并发和 32 并发下各跑 10 万次 Top-10 查询,记录 QPS、P50、P99
3. 静置后记录两个服务的内存占用(RSS)和磁盘占用

四、核心实现

4.1 部署

Milvus standalone 用官方 compose 文件:

wget https://github.com/milvus-io/milvus/releases/download/v2.4.6/milvus-standalone-docker-compose.yml -O docker-compose.yml
docker compose up -d
# 默认 19530 端口,健康检查
curl http://localhost:9091/healthz

Qdrant 更简单,一条命令:

docker run -d --name qdrant \
  -p 6333:6333 -p 6334:6334 \
  -v /data/qdrant:/qdrant/storage \
  qdrant/qdrant:v1.9.2

Qdrant 这点确实省心,单容器无外部依赖;Milvus 至少要拉 etcd 和 MinIO 三个容器,首次启动等健康检查大概花了 40 秒。

4.2 建集合与写入

Milvus 侧:

from pymilvus import connections, FieldSchema, CollectionSchema, DataType, Collection, utility

connections.connect(host="127.0.0.1", port="19530")

fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=False),
    FieldSchema(name="vec", dtype=DataType.FLOAT_VECTOR, dim=768),
]
schema = CollectionSchema(fields=fields, description="image_vectors")
col = Collection(name="img_vec", schema=schema)

col.create_index(
    field_name="vec",
    index_params={"index_type": "HNSW", "metric_type": "COSINE",
                  "params": {"M": 16, "efConstruction": 200}},
)
col.load()

# 分批写入,每批 5000
BATCH = 5000
for i in range(0, len(vectors), BATCH):
    col.insert([ids[i:i+BATCH], vectors[i:i+BATCH]])
col.flush()

Qdrant 侧:

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

client = QdrantClient(host="127.0.0.1", port=6333)

client.recreate_collection(
    collection_name="img_vec",
    vectors_config=VectorParams(size=768, distance=Distance.COSINE),
    hnsw_config={"m": 16, "ef_construct": 200},
)

BATCH = 5000
for i in range(0, len(vectors), BATCH):
    points = [PointStruct(id=ids[j], vector=vectors[j].tolist())
              for j in range(i, min(i+BATCH, len(vectors)))]
    client.upsert(collection_name="img_vec", points=points, wait=False)

注意 Qdrant 的 wait=False 很关键,默认同步等待会严重拖慢批量写入,这个后面踩坑部分细说。

4.3 查询压测

查询代码用 asyncio 并发打,这里贴核心片段(以 Qdrant 为例,Milvus 逻辑对称):

import asyncio, time
from qdrant_client import AsyncQdrantClient

async def bench(client, queries, concurrency=32):
    sem = asyncio.Semaphore(concurrency)
    latencies = []

    async def one(q):
        async with sem:
            t0 = time.perf_counter()
            await client.search(collection_name="img_vec", query_vector=q,
                                limit=10, search_params={"hnsw_ef": 64})
            latencies.append((time.perf_counter() - t0) * 1000)

    await asyncio.gather(*[one(q) for q in queries])
    latencies.sort()
    n = len(latencies)
    return {
        "qps": n / (sum(latencies) / 1000),
        "p50": latencies[n // 2],
        "p99": latencies[int(n * 0.99)],
    }

五、踩坑与优化

坑 1:Qdrant 默认同步写入。 一开始没加 wait=False,1000 万条写入跑了快 3 小时,后来改成异步批量 upsert,降到 52 分钟。Milvus 的 insert 本身是异步的,flush 才落盘,所以写入这块 Milvus 天然占优。

坑 2:Milvus 首次 load 集合很慢。 1000 万条数据建完索引后 load() 花了将近 4 分钟把数据加载进内存(实际是 mmap),Qdrant 因为用的是磁盘 + 内存混合的段结构,服务重启后加载几乎无感。这一点对需要频繁重启的场景影响挺大。

坑 3:内存监控口径。 一开始用 docker stats 看,Milvus 显示内存很低,实际是因为 standalone 的 querynode 在独立容器里,得把所有容器加起来算。最终我统一用宿主机 ps aux 汇总相关进程 RSS。

优化点: Qdrant 开了 on_disk_payload=True 并把 HNSW 索引放内存,向量本体放磁盘(on_disk=True),内存直接降了一截,召回率没明显变化。Milvus 这边把 queryNode.cache.memoryLimit 调到 32GB 后,P99 从 118ms 降到 89ms,效果很明显。

六、效果数据

写入 1000 万条(768 维):

指标 Milvus 2.4.6 Qdrant 1.9.2
总写入耗时 38 min 52 min
写入吞吐 ~4380 条/s ~3200 条/s
索引构建耗时 22 min 18 min

查询(Top-10,ef=64):

场景 Milvus QPS / P99 Qdrant QPS / P99
单并发 142 / 9.8ms 168 / 8.1ms
32 并发 1180 / 89ms 960 / 118ms

资源占用(静置,全量数据加载后):

指标 Milvus Qdrant
内存 RSS 41.2 GB 26.7 GB
磁盘占用 38.5 GB 31.2 GB
容器数 3 1

结论挺清晰的:单并发低延迟 Qdrant 略优,高并发下 Milvus 的吞吐和尾延迟更好;内存占用 Qdrant 明显更省(它默认做了向量磁盘存储 + 量化友好的结构),Milvus 则是拿内存换查询性能。写入吞吐 Milvus 领先约 37%,符合预期。

七、总结

选型这事没有绝对赢家,看你的约束条件:

  • 如果团队运维人力有限、数据量在千万级以内、机器内存紧张,Qdrant 单容器、低内存、部署简单,很香。我们最终生产环境选的就是 Qdrant,主要就是看中它 26GB 内存扛 1000 万条这个性价比。
  • 如果写入量大、需要水平扩展、要上亿级规模和多租户,Milvus 的分布式架构和生态更成熟,代价是运维复杂度和内存开销。

另外提醒一句,所有 benchmark 都跟数据分布、参数、硬件强相关,本文数字你当参考系就行,真选型一定要拿自己的数据跑一遍。我踩过的坑里,Qdrant 的同步写入和 Milvus 的 load 耗时这两个最容易在 POC 阶段被忽略,建议重点验证。