Milvus/Zilliz 2026: 100억 벡터를 밀리초 지연으로 처리하는 벡터 데이터베이스 — 배포 가이드

# 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 키와 엔드포인트 복사

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)

# 빠른 ANN 검색을 위한 HNSW 인덱스 생성
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}초 소요")
print(f"처리량: {batch/elapsed:,.0f} 벡터/초")
# GPU index node 출력: 100,000 벡터 삽입 완료, 0.31초 소요
# 출력: 처리량: 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 임베딩을 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

# 다중 테넌트 격리를 위한 파티션 생성
collection.create_partition("tenant_acme")
collection.create_partition("tenant_globalcorp")

# 테넌트별 데이터 삽입
collection.insert(
    data=[[embedding], ["doc_1"]],
    partition_name="tenant_acme"
)

# 특정 테넌트 파티션 내에서만 검색
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)"