Milvus与Qdrant选型实测：千万级向量下的部署与性能对比

# docker-compose-milvus.yml
version: '3.5'
services:
  etcd:
    image: quay.io/coreos/etcd:v3.5.5
    environment:
      - ETCD_AUTO_COMPACTION_MODE=revision
      - ETCD_AUTO_COMPACTION_RETENTION=1000
      - ETCD_QUOTA_BACKEND_BYTES=4294967296
    volumes:
      - ${DOCKER_VOLUME_DIRECTORY:-.}/volumes/etcd:/etcd
    command: etcd -advertise-client-urls=http://etcd:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /etcd

  minio:
    image: minio/minio:RELEASE.2023-03-20T20-16-18Z
    environment:
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
    volumes:
      - ${DOCKER_VOLUME_DIRECTORY:-.}/volumes/minio:/minio_data
    command: minio server /minio_data
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

  standalone:
    image: milvusdb/milvus:v2.4.1
    command: ["milvus", "run", "standalone"]
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
      # 关键：关闭mmap，强制索引进内存
      KNOWHERE_MMAP_ENABLED: "false"
      # 限制compaction线程数，避免写入抖动
      DATA_COORD_ENABLE_COMPACTION: "true"
    ports:
      - "19530:19530"
    volumes:
      - ${DOCKER_VOLUME_DIRECTORY:-.}/volumes/milvus:/var/lib/milvus
    depends_on:
      - etcd
      - minio

# docker-compose-qdrant.yml
version: '3.5'
services:
  qdrant:
    image: qdrant/qdrant:v1.9.2
    ports:
      - "6333:6333"
      - "6334:6334" # gRPC端口
    volumes:
      - ./qdrant_storage:/qdrant/storage
    environment:
      QDRANT__STORAGE__WAL__WRITE_AHEAD_LOG_INTERVAL_MS: "500"
      QDRANT__STORAGE__WAL__FSYNC: "false"
      QDRANT__STORAGE__OPTIMIZER__FLUSH_INTERVAL_SEC: "60"
      # 限制内存中索引数量，防止OOM
      QDRANT__STORAGE__OPTIMIZER__MEMORY_QUOTA: "40GB"
    ulimits:
      nofile: 65535

import numpy as np

dim = 768
total = 10_000_000
# 分10批生成，避免一次性占用80GB内存
for i in range(10):
    data = np.random.randn(1_000_000, dim).astype(np.float32)
    # 归一化，L2距离等价于余弦相似度
    data /= np.linalg.norm(data, axis=1, keepdims=True) + 1e-9
    np.save(f'/data/vectors_{i}.npy', data)
    print(f"Batch {i} saved")

from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType, utility
import numpy as np
import time

connections.connect(host='localhost', port='19530')

# 创建collection（已存在则跳过）
dim = 768
fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True),
    FieldSchema(name="vector", dtype=DataType.FLOAT_VECTOR, dim=dim)
]
schema = CollectionSchema(fields, description="test")
col = Collection(name="test_milvus", schema=schema)

# 创建HNSW索引
index_params = {
    "index_type": "HNSW",
    "metric_type": "L2",
    "params": {"M": 16, "efConstruction": 200}
}
col.create_index("vector", index_params)

# 批量插入（每次100万）
for i in range(10):
    data = np.load(f'/data/vectors_{i}.npy')
    ids = np.arange(i*1_000_000, (i+1)*1_000_000, dtype=np.int64)
    entities = [ids, data]
    t0 = time.time()
    col.insert(entities)
    print(f"Batch {i} inserted, {time.time()-t0:.2f}s")

# 关键：等待flush完成
col.flush()
print(f"Total entities: {col.num_entities}")

# 查询压测
col.load()
query_vec = np.random.randn(1, dim).astype(np.float32)
query_vec /= np.linalg.norm(query_vec)

latencies = []
for _ in range(1000):
    t0 = time.time()
    results = col.search(query_vec, "vector", param={"metric_type": "L2", "params": {"ef": 64}}, limit=10)
    latencies.append((time.time() - t0) * 1000)  # ms

latencies.sort()
print(f"P50: {latencies[500]:.2f}ms, P99: {latencies[990]:.2f}ms")

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
import numpy as np
import time

client = QdrantClient(host="localhost", port=6333, prefer_grpc=True)

# 创建collection
client.create_collection(
    collection_name="test_qdrant",
    vectors_config=VectorParams(size=768, distance=Distance.L2),
    hnsw_config={"m": 16, "ef_construct": 200}
)

# 批量上传（每批100万）
for i in range(10):
    data = np.load(f'/data/vectors_{i}.npy')
    ids = np.arange(i*1_000_000, (i+1)*1_000_000, dtype=np.int64)
    points = [
        PointStruct(id=int(ids[j]), vector=data[j].tolist())
        for j in range(len(ids))
    ]
    t0 = time.time()
    client.upsert(
        collection_name="test_qdrant",
        points=points,
        batch_size=10000  # 关键：控制批量大小，防止内存溢出
    )
    print(f"Batch {i} upserted, {time.time()-t0:.2f}s")

# 查询压测
query_vec = np.random.randn(768).astype(np.float32)
query_vec /= np.linalg.norm(query_vec)

latencies = []
for _ in range(1000):
    t0 = time.time()
    client.search(
        collection_name="test_qdrant",
        query_vector=query_vec.tolist(),
        limit=10,
        search_params={"ef": 64}
    )
    latencies.append((time.time() - t0) * 1000)

latencies.sort()
print(f"P50: {latencies[500]:.2f}ms, P99: {latencies[990]:.2f}ms")

# 挂载到standalone的/etc/milvus/configs/milvus.yaml
segments:
  maxSize: 512  # MB，从1024改小
indexNode:
  gracefulStopTimeout: 30s