Milvus/Zilliz 2026：毫秒级延迟处理百亿向量的向量数据库——部署指南

# etcd: 元数据协调
# MinIO: 对象存储，存储段和索引
# Pulsar/Kafka: 日志代理，处理流式插入
# Milvus: proxy、query/data/index 节点、coordinators

# Milvus index node 的 GPU 资源分配（Helm values）
indexNode:
  resources:
    limits:
      nvidia.com/gpu: 1  # 为索引构建请求 1 块 GPU
    requests:
      memory: "16Gi"
      cpu: "8"

# 下载 docker-compose 文件
curl -sfL https://raw.githubusercontent.com/milvus-io/milvus/master/scripts/standalone_embed.sh -o standalone_embed.sh

# 启动 Milvus 单机版
bash standalone_embed.sh start

# 验证
docker ps | grep milvus
# 输出: milvusdb/milvus:v2.5.10  "milvus run standalone"

# 安装 Python SDK
pip install pymilvus==2.5.10

# 测试连接
python -c "
from pymilvus import connections, utility
connections.connect(host='localhost', port='19530')
print('Milvus version:', utility.get_server_version())
"

# 添加 Milvus Helm 仓库
helm repo add milvus https://zilliztech.github.io/milvus-helm/
helm repo update

# 默认分布式模式安装
helm install my-milvus milvus/milvus \
  --set cluster.enabled=true \
  --set etcd.replicaCount=3 \
  --set minio.mode=distributed \
  --set minio.drivesPerNode=4 \
  --set queryNode.replicas=2

# 验证所有 Pod 运行正常
kubectl get pods -l app.kubernetes.io/instance=my-milvus

# 通过 LoadBalancer 暴露服务
kubectl patch svc my-milvus-proxy -p '{"spec":{"type":"LoadBalancer"}}'

# 获取访问地址
export MILVUS_HOST=$(kubectl get svc my-milvus-proxy -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo $MILVUS_HOST

# 在 https://cloud.zilliz.com 注册
# 创建免费集群（支持最高 100 万向量）
# 获取 API key 和 endpoint

pip install pymilvus==2.5.10

from pymilvus import connections, Collection

# 连接到 Zilliz Cloud
connections.connect(
    alias="default",
    uri="https://your-cluster.zillizcloud.com",
    token="your-api-key"
)

print("Connected to Zilliz Cloud!")

from pymilvus import FieldSchema, CollectionSchema, DataType, Collection

# 定义字段
fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1536),
    FieldSchema(name="text", dtype=DataType.VARCHAR, max_length=4096),
    FieldSchema(name="category", dtype=DataType.VARCHAR, max_length=64),
]

schema = CollectionSchema(fields, description="Document embeddings")
collection = Collection(name="documents", schema=schema)

# 创建 HNSW 索引用于快速 ANN 搜索
index_params = {
    "metric_type": "L2",
    "index_type": "HNSW",
    "params": {"M": 16, "efConstruction": 200}
}
collection.create_index(field_name="embedding", index_params=index_params)
collection.load()

import numpy as np

# 生成示例数据：10 万条向量，每条 1536 维
batch_size = 10000
total_vectors = 100000

for i in range(0, total_vectors, batch_size):
    embeddings = np.random.randn(batch_size, 1536).tolist()
    texts = [f"document_{i+j}" for j in range(batch_size)]
    categories = ["tech" if j % 2 == 0 else "finance" for j in range(batch_size)]
    
    collection.insert([embeddings, texts, categories])
    print(f"已插入 {i + batch_size}/{total_vectors} 条向量")

# 刷新确保持久化
collection.flush()
print(f"总插入数: {collection.num_entities}")

# 单向量搜索
results = collection.search(
    data=[np.random.randn(1536).tolist()],
    anns_field="embedding",
    param={"metric_type": "L2", "params": {"ef": 64}},
    limit=10,
    output_fields=["text", "category"]
)

for hit in results[0]:
    print(f"ID: {hit.id}, 距离: {hit.distance:.4f}, 文本: {hit.entity.text}")

# 混合搜索：向量相似度 + 元数据过滤
from pymilvus import Filter

expr = 'category == "tech" AND text like "%neural%"'

results = collection.search(
    data=[np.random.randn(1536).tolist()],
    anns_field="embedding",
    param={"metric_type": "L2", "params": {"ef": 128}},
    limit=20,
    expr=expr,  # 预过滤表达式
    output_fields=["text", "category"]
)

print(f"找到 {len(results[0])} 条过滤结果")

# 索引插入吞吐基准测试脚本
import time
from pymilvus import Collection

collection = Collection("benchmark")
batch = 100000  # 10 万向量
embeddings = np.random.randn(batch, 1536).tolist()

t0 = time.time()
collection.insert([embeddings])
collection.flush()
elapsed = time.time() - t0

print(f"已插入 {batch:,} 条向量，耗时 {elapsed:.2f}s")
print(f"吞吐: {batch/elapsed:,.0f} 向量/秒")
# GPU index node 输出: 已插入 100,000 条向量，耗时 0.31s
# 输出: 吞吐: 320,000 向量/秒

pip install langchain-milvus==0.1.8

from langchain_milvus import Milvus
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
vector_store = Milvus(
    embedding_function=embeddings,
    collection_name="langchain_docs",
    connection_args={"host": "localhost", "port": "19530"},
    auto_id=True
)

# 添加文档
from langchain_core.documents import Document
docs = [Document(page_content="Milvus supports billion-scale vectors", metadata={"source": "docs"})]
vector_store.add_documents(docs)

# 相似度搜索
results = vector_store.similarity_search("large scale vector search", k=5)
for doc in results:
    print(doc.page_content)

pip install llama-index-vector-stores-milvus==0.6.0

from llama_index.vector_stores.milvus import MilvusVectorStore
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

vector_store = MilvusVectorStore(
    uri="http://localhost:19530",
    collection_name="llamaindex_docs",
    dim=1536,
    overwrite=True
)

# 加载并索引文档
documents = SimpleDirectoryReader("./data").load_data()
index = VectorStoreIndex.from_documents(documents, vector_store=vector_store)

# 查询
query_engine = index.as_query_engine()
response = query_engine.query("What is Milvus architecture?")
print(response)

from openai import OpenAI
import numpy as np

client = OpenAI()

def get_embedding(text: str) -> list[float]:
    resp = client.embeddings.create(
        model="text-embedding-3-large",
        input=text,
        dimensions=1536
    )
    return resp.data[0].embedding

# 将 OpenAI embedding 插入 Milvus
embedding = get_embedding("Milvus vector database handles 10 billion vectors")
collection.insert([[embedding], ["milvus_overview"]])

# 分层存储的 Helm values
extraConfigFiles:
  user.yaml: |+
    common:
      storageType: remote
    minio:
      address: minio.milvus.svc:9000
      bucketName: milvus-bucket
      rootPath: files
    # 启用分层存储
    queryNode:
      cache:
        warmUp: async
        memoryLimit: 8GB  # 热数据保存在内存中
      disk:
        enabled: true     # 温数据保存在本地磁盘
        capacity: 100GB

# 安装 Milvus Backup 工具
git clone https://github.com/zilliztech/milvus-backup.git
cd milvus-backup
make

# 创建备份
./milvus-backup create -n prod_backup_2026_05

# 恢复到新集群
./milvus-backup restore -n prod_backup_2026_05 -c restored_collection

# Helm values 中的 Milvus 监控配置
metrics:
  enabled: true
  serviceMonitor:
    enabled: true
    interval: 30s

# Grafana 仪表板: https://github.com/zilliztech/milvus-insight

# 端口转发访问 Milvus 指标
kubectl port-forward svc/my-milvus-proxy 9091:9091

# 检查健康状态
curl http://localhost:9091/metrics | grep milvus_querynode_latency

# 创建 partition 实现多租户隔离
collection.create_partition("tenant_acme")
collection.create_partition("tenant_globalcorp")

# 插入租户专属数据
collection.insert(
    data=[[embedding], ["doc_1"]],
    partition_name="tenant_acme"
)

# 仅在租户 partition 内搜索
results = collection.search(
    data=[query_vector],
    anns_field="embedding",
    param={"metric_type": "L2", "params": {"ef": 64}},
    limit=10,
    partition_names=["tenant_acme"]
)

0 2 * * * /usr/local/bin/milvus-backup create -n "auto_$(date +\%Y\%m\%d)"