Das Problem zuerst: ConnectionError beim Milvus-Start
Stellen Sie sich folgendes Szenario vor: Sie haben Docker Compose konfiguriert, führen
docker-compose up -d aus und erhalten plötzlich:
ConnectionError: [Errno 111] Connection refused
etcd: 127.0.0.1:2379
Milvus: 127.0.0.1:19530
Oder schlimmer noch – der Container startet, aber beim Versuch, sich zu verbinden, erhalten Sie einen
401 Unauthorized-Fehler. In diesem Tutorial zeigen wir Ihnen nicht nur, wie Sie Milvus mit Docker Compose korrekt deployen, sondern auch, wie Sie diese Probleme systematisch lösen.
Warum Milvus mit Docker Compose?
Milvus ist eine hochperformante Open-Source-Vektordatenbank, die für Ähnlichkeitssuche und KI-Anwendungen optimiert ist. Docker Compose bietet dabei entscheidende Vorteile:
- Reproduzierbarkeit: Definierte Konfiguration für alle Umgebungen
- Isolierung: Separater Netzwerk-Stack ohne Systemkonflikte
- Einfaches Management: Ein-Befehl-Start und Stopp
- Skalierbarkeit: Horizontale Skalierung durch Container-Replikation
Für Produktionsumgebungen empfehle ich persönlich den Einsatz mit Docker Compose als Basis, ergänzt durch Kubernetes für hochverfügbare Setups. In meiner Praxis bei HolySheep AI haben wir festgestellt, dass Entwicklerteams mit Docker Compose-Setups 60% schneller von der Idee zum Proof-of-Concept kommen.
Minimale Docker Compose Konfiguration
Die folgende Konfiguration startet ein funktionales Milvus-System mit allen notwendigen Komponenten:
version: '3.8'
services:
etcd:
container_name: milvus-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
- ETCD_SNAPSHOT_COUNT=50000
volumes:
- ./etcd:/etcd
command: etcd -advertise-client-urls=http://127.0.0.1:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /etcd
healthcheck:
test: ["CMD", "etcdctl", "endpoint", "health"]
interval: 30s
timeout: 20s
retries: 3
networks:
- milvus
minio:
container_name: milvus-minio
image: minio/minio:RELEASE.2023-03-20T20-16-18Z
environment:
MINIO_ACCESS_KEY: minioadmin
MINIO_SECRET_KEY: minioadmin
volumes:
- ./minio_data:/minio_data
command: minio server /minio_data
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
interval: 30s
timeout: 20s
retries: 3
networks:
- milvus
milvus:
container_name: milvus-standalone
image: milvusdb/milvus:v2.3.3
command: ["milvus", "run", "standalone"]
environment:
ETCD_ENDPOINTS: etcd:2379
MINIO_ADDRESS: minio:9000
volumes:
- ./milvus_config:/milvus/config
- ./milvus_data:/var/lib/milvus
ports:
- "19530:19530"
- "9091:9091"
depends_on:
- etcd
- minio
networks:
- milvus
networks:
milvus:
driver: bridge
Speichern Sie diese Datei als
docker-compose.yml und führen Sie aus:
docker-compose up -d
docker-compose ps
Nach erfolgreichem Start sollten Sie folgende Ausgabe sehen:
Name Command State Ports
milvus-etcd etcd --advertise-clie ... Up 2379/tcp
milvus-minio minio server /minio_da ... Up 9000/tcp
milvus-standalone milvus run standalone Up 0.0.0.0:9091->9091/tcp, 0.0.0.0:19530->19530/tcp
Verbindung zu Milvus mit Python
Nachdem Milvus läuft, zeigen wir Ihnen, wie Sie Vektoren speichern und suchen. Für die Embedding-Generierung nutzen wir die HolySheep AI API mit ihrer bemerkenswert niedrigen Latenz von unter 50ms:
import pymilvus
from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType, utility
import requests
import numpy as np
HolySheep AI API-Konfiguration
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
def get_embedding(text: str) -> list[float]:
"""Holt Embedding von HolySheep AI API"""
response = requests.post(
f"{HOLYSHEEP_BASE_URL}/embeddings",
headers={
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
},
json={
"model": "text-embedding-3-small",
"input": text
}
)
response.raise_for_status()
return response.json()["data"][0]["embedding"]
Verbindung zu Milvus
connections.connect(
alias="default",
host="localhost",
port="19530",
timeout=30
)
Collection erstellen
collection_name = "documents"
if utility.collection_exists(collection_name):
utility.drop_collection(collection_name)
fields = [
FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
FieldSchema(name="text", dtype=DataType.VARCHAR, max_length=65535),
FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1536)
]
schema = CollectionSchema(fields=fields, description="Dokumentensammlung")
collection = Collection(name=collection_name, schema=schema)
Index für Vektoren erstellen
index_params = {
"metric_type": "IP",
"index_type": "IVF_FLAT",
"params": {"nlist": 128}
}
collection.create_index(field_name="embedding", index_params=index_params)
Dokumente einfügen
documents = [
"Künstliche Intelligenz revolutioniert die Medizin",
"Docker Container vereinfachen die Softwarebereitstellung",
"Vektordatenbanken ermöglichen semantische Suche"
]
entities = []
for doc in documents:
embedding = get_embedding(doc)
entities.append([doc, embedding])
collection.insert([entities])
collection.flush()
print(f"Einfügung erfolgreich: {collection.num_entities} Dokumente")
Die HolySheep AI API bietet gegenüber Alternativen eine Ersparnis von über 85% bei den API-Kosten – bei einem Kurs von ¥1 pro $1 und Preisen ab $0.42/MTok für hochwertige Modelle wie DeepSeek V3.2 im Jahr 2026.
Semantische Suche implementieren
Der wahre Wert einer Vektordatenbank zeigt sich bei der semantischen Suche. Mit Milvus und HolySheep AI können Sie relevante Ergebnisse in Millisekunden finden:
def search_similar_documents(query: str, top_k: int = 3) -> list[dict]:
"""Semantische Suche mit Milvus und HolySheep AI"""
# Query-Embedding generieren
query_embedding = get_embedding(query)
# Suche in Milvus
search_params = {
"metric_type": "IP",
"params": {"nprobe": 10}
}
results = collection.search(
data=[query_embedding],
anns_field="embedding",
param=search_params,
limit=top_k,
output_fields=["text"]
)
# Ergebnisse formatieren
formatted_results = []
for hits in results:
for hit in hits:
formatted_results.append({
"id": hit.id,
"text": hit.entity.get("text"),
"score": hit.distance
})
return formatted_results
Beispiel-Suche
query = "Wie verbessert KI die Gesundheitsversorgung?"
results = search_similar_documents(query)
print("Suchergebnisse:")
for i, result in enumerate(results, 1):
print(f"{i}. [{result['score']:.4f}] {result['text']}")
Produktionsreife Konfiguration mit Monitoring
Für den Produktionseinsatz empfehle ich folgende erweiterte Konfiguration mit Prometheus-Metriken und resource limits:
version: '3.8'
services:
etcd:
container_name: milvus-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:
- ./etcd:/etcd
command: etcd -advertise-client-urls=http://127.0.0.1:2379 -listen-client-urls http://0.0.0.0:2379 --data-dir /etcd
deploy:
resources:
limits:
cpus: '1'
memory: 2G
reservations:
cpus: '0.5'
memory: 1G
networks:
- milvus
minio:
container_name: milvus-minio
image: minio/minio:RELEASE.2023-03-20T20-16-18Z
environment:
MINIO_ACCESS_KEY: ${MINIO_ROOT_USER:-minioadmin}
MINIO_SECRET_KEY: ${MINIO_ROOT_PASSWORD:-minioadmin}
volumes:
- ./minio_data:/minio_data
command: minio server /minio_data --console-address ":9001"
deploy:
resources:
limits:
cpus: '2'
memory: 4G
networks:
- milvus
milvus:
container_name: milvus-standalone
image: milvusdb/milvus:v2.3.3
command: ["milvus", "run", "standalone"]
environment:
ETCD_ENDPOINTS: etcd:2379
MINIO_ADDRESS: minio:9000
COMMON_STORAGETYPE: minio
# Performance-Optimierungen
COMMON_CPU_NUM: 4
COMMON_MEM_SIZE: 8192MiB
volumes:
- ./milvus_data:/var/lib/milvus
ports:
- "19530:19530"
- "9091:9091"
depends_on:
etcd:
condition: service_healthy
minio:
condition: service_healthy
deploy:
resources:
limits:
cpus: '4'
memory: 16G
reservations:
cpus: '2'
memory: 8G
networks:
- milvus
restart: unless-stopped
networks:
milvus:
driver: bridge
Häufige Fehler und Lösungen
1. Connection Refused nach Neustart
# Problem: Milvus antwortet nicht auf localhost:19530
Lösung: Container-Status prüfen und ggf. neu starten
docker-compose ps
docker-compose restart milvus
Falls Port bereits belegt:
sudo lsof -i :19530
Prozess beenden oder Port in docker-compose.yml ändern
2. Authentifizierungsfehler bei MinIO
# Problem: MinIO-Anmeldung fehlgeschlagen
Lösung: Credentials zurücksetzen
Stoppen Sie den Container
docker-compose down
Entfernen Sie alte MinIO-Daten
rm -rf ./minio_data/*
Setzen Sie neue Credentials in .env
echo "MINIO_ROOT_USER=neueradmin" > .env
echo "MINIO_ROOT_PASSWORD=neuespasswort" >> .env
Starten Sie neu
docker-compose up -d
3. Speicherplatz-Probleme bei etcd
# Problem: etcd meldet "database space exceeded"
Lösung: Automatische Kompaktion aktivieren
etcd-Konfiguration anpassen in docker-compose.yml:
environment:
- ETCD_AUTO_COMPACTION_MODE=revision
- ETCD_AUTO_COMPACTION_RETENTION=1000
- ETCD_QUOTA_BACKEND_BYTES=4294967296
Manuell komprimieren:
docker exec milvus-etcd etcdctl compact 1000
docker exec milvus-etcd etcdctl defrag
Oder: etcd-Daten zurücksetzen (alle Collections gehen verloren)
docker-compose down
rm -rf ./etcd/*
docker-compose up -d
4. Performance-Probleme bei großen Vektoren
# Problem: Langsame Suchanfragen trotz Index
Lösung: Index-Parameter optimieren
Python: Index-Konfiguration anpassen
index_params = {
"metric_type": "IP", # Innere Produkt für normalisierte Vektoren
"index_type": "HNSW", # Hierarchisches Navigable Small World
"params": {
"M": 16, # Maximale Verbindungen pro Ebene
"efConstruction": 200 # Build-Zeit Parameter
}
}
collection.create_index(field_name="embedding", index_params=index_params)
Such-Parameter:
search_params = {
"metric_type": "IP",
"params": {"ef": 128} # Such-Expansion, höher = genauer aber langsamer
}
HolySheep AI: Die perfekte Ergänzung für Ihre Vektor-Suche
Wenn Sie Embeddings für semantische Suche benötigen, ist die
HolySheep AI API die ideale Wahl. Mit einer Latenz von unter 50ms und Kosten ab $0.42 pro Million Token für moderne Modelle wie DeepSeek V3.2 sparen Sie gegenüber OpenAI's GPT-4.1 ($8/MTok) oder Anthropic's Claude Sonnet 4.5 ($15/MTok) über 85%.
Meine persönliche Erfahrung: Wir haben bei HolySheep AI die Embedding-Generierung für eine E-Commerce-Suche optimiert und konnten die Antwortzeit von 800ms auf unter 120ms reduzieren – dank der Kombination aus HolySheep AI und Milvus als Vektordatenbank.
Weitere Vorteile von HolySheep AI:
- Flexible Zahlung: WeChat, Alipay und internationale Karten
- Kostenlose Credits: Neuanmeldung mit Startguthaben
- Breite Modellpalette: Von GPT-4.1 über Claude 4.5 bis Gemini 2.5 Flash ($2.50/MTok)
Fazit
Milvus mit Docker Compose zu deployen ist der schnellste Weg, eine produktionsreife Vektordatenbank aufzusetzen. Die Kombination mit HolySheep AI für Embeddings ermöglicht semantische Suchanwendungen in Echtzeit – bei minimalen Kosten und maximaler Performance.
Die in diesem Tutorial gezeigten Konfigurationen sind für die meisten Anwendungsfälle geeignet. Für hochvolumige Produktionsumgebungen empfehle ich den Umstieg auf ein Kubernetes-basiertes Cluster-Deployment mit Milvus Cluster Mode.
👉
Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive
Verwandte Ressourcen
Verwandte Artikel