So stellen Sie die Open-Source-Datenbank Milvus Vector auf Amazon EKS bereit
Dieser Beitrag wurde ursprünglich auf der AWS-Website veröffentlicht und wird hier mit Genehmigung übersetzt, bearbeitet und erneut veröffentlicht.
Ein Überblick über Vektor-Embeddings und Vektordatenbanken
Der Aufstieg der generativen KI (GenAI), insbesondere großer Sprachmodelle(LLMs), hat das Interesse an Vektordatenbanken erheblich gesteigert und sie als wesentliche Komponente innerhalb des GenAI-Ökosystems etabliert. Infolgedessen werden Vektordatenbanken in immer mehr Anwendungsfällen eingesetzt.
Ein IDC-Bericht sagt voraus, dass bis 2025 über 80 % der Geschäftsdaten unstrukturiert sein werden und in Formaten wie Text, Bildern, Audio und Videos vorliegen. Das Verstehen, Verarbeiten, Speichern und Abfragen dieser riesigen Menge an unstrukturierten Daten in großem Umfang stellt eine große Herausforderung dar. Die gängige Praxis in GenAI und Deep Learning besteht darin, unstrukturierte Daten in Vektoreinbettungen umzuwandeln, zu speichern und in einer Vektordatenbank wie Milvus oder Zilliz Cloud (das vollständig verwaltete Milvus) für Vektorähnlichkeits- oder semantische Ähnlichkeitssuchen zu indizieren.
Aber was genau sind Vektoreinbettungen? Einfach ausgedrückt handelt es sich um numerische Darstellungen von Gleitkommazahlen in einem hochdimensionalen Raum. Der Abstand zwischen zwei Vektoren gibt deren Relevanz an: Je näher sie beieinander liegen, desto relevanter sind sie füreinander und umgekehrt. Dies bedeutet, dass ähnliche Vektoren ähnlichen Originaldaten entsprechen, was sich von der herkömmlichen Suche nach Schlüsselwörtern oder exakten Suchbegriffen unterscheidet.
So führen Sie eine vektorielle Ähnlichkeitssuche durch
Abbildung 1: So führen Sie eine Vektorähnlichkeitssuche durch
Die Fähigkeit, Vektoreinbettungen zu speichern, zu indizieren und zu durchsuchen, ist die Kernfunktionalität von Vektordatenbanken. Gegenwärtig lassen sich die gängigen Vektordatenbanken in zwei Kategorien einteilen. Die erste Kategorie erweitert bestehende relationale Datenbankprodukte, wie Amazon OpenSearch Service mit dem KNN-Plugin und Amazon RDS für PostgreSQL mit der pgvector-Erweiterung. Die zweite Kategorie umfasst spezialisierte Vektordatenbankprodukte, darunter bekannte Beispiele wie Milvus, Zilliz Cloud (das vollständig verwaltete Milvus), Pinecone, Weaviate, Qdrant und Chroma.
Einbettungstechniken und Vektordatenbanken finden breite Anwendung in verschiedenen KI-gesteuerten Anwendungsfällen, darunter Bildähnlichkeitssuche, Videodeduplizierung und -analyse, Verarbeitung natürlicher Sprache, Empfehlungssysteme, gezielte Werbung, personalisierte Suche, intelligenter Kundenservice und Betrugserkennung.
Milvus ist eine der beliebtesten Open-Source-Optionen unter den zahlreichen Vektordatenbanken. In diesem Beitrag wird Milvus vorgestellt und die Praxis der Bereitstellung von Milvus auf AWS EKS untersucht.
Was ist Milvus?
Milvus ist eine hochflexible, zuverlässige und blitzschnelle Cloud-native Open-Source-Vektordatenbank. Sie ermöglicht die Suche nach Vektorähnlichkeit und KI-Anwendungen und soll Vektordatenbanken für jedes Unternehmen zugänglich machen. Milvus kann mehr als eine Milliarde Vektoreinbettungen speichern, indizieren und verwalten, die von tiefen neuronalen Netzen und anderen Modellen des maschinellen Lernens (ML) erzeugt wurden.
Milvus wurde im Oktober 2019 unter der Open-Source-Lizenz Apache 2.0 veröffentlicht. Es ist derzeit ein Graduiertenprojekt der LF AI & Data Foundation. Zum Zeitpunkt der Erstellung dieses Blogs hatte Milvus mehr als 50 Millionen Docker-Pull-Downloads erreicht und wurde von vielen Kunden wie NVIDIA, AT&T, IBM, eBay, Shopee und Walmart verwendet.
Milvus Hauptmerkmale
Als Cloud-native Vektordatenbank zeichnet sich Milvus durch die folgenden Hauptmerkmale aus:
Hohe Leistung und Millisekunden-Suche auf Vektordatensätzen im Milliardenbereich.
Mehrsprachige Unterstützung und Toolchain.
Horizontale Skalierbarkeit und hohe Zuverlässigkeit auch im Falle einer Störung.
Hybride Suche, die durch die Kombination von skalarer Filterung und vektorieller Ähnlichkeitssuche erreicht wird.
Milvus-Architektur
Milvus folgt dem Prinzip der Trennung von Datenfluss und Kontrollfluss. Das System gliedert sich in vier Ebenen, wie in der Abbildung dargestellt:
Milvus-Architektur
Abbildung 2 Milvus-Architektur
Zugriffsschicht: Die Zugriffsschicht besteht aus einer Gruppe von zustandslosen Proxys und dient als Frontschicht des Systems und Endpunkt für die Benutzer.
Koordinator-Dienst: Der Koordinationsdienst weist den Arbeiterknoten Aufgaben zu.
Arbeiterknoten: Die Arbeitsknoten sind stumme Ausführer, die den Anweisungen des Koordinationsdienstes folgen und vom Benutzer ausgelöste DML/DDL-Befehle ausführen.
Speicherung: Der Speicher ist für die Datenpersistenz zuständig. Er umfasst einen Metaspeicher, einen Log-Broker und einen Objektspeicher.
Milvus-Bereitstellungsoptionen
Milvus unterstützt drei Betriebsmodi: Milvus Lite, Standalone und Verteilt.
Milvus Lite ist eine Python-Bibliothek, die in lokale Anwendungen importiert werden kann. Als leichtgewichtige Version von Milvus ist sie ideal für schnelles Prototyping in Jupyter Notebooks oder für den Betrieb auf Smart Devices mit begrenzten Ressourcen.
Milvus Standalone isteine Serverlösung für eine einzelne Maschine. Wenn Sie eine produktive Arbeitslast haben, aber nicht Kubernetes verwenden möchten, ist die Ausführung von Milvus Standalone auf einem einzelnen Rechner mit ausreichend Speicher eine gute Option.
Milvus Distributed kann auf Kubernetes-Clustern bereitgestellt werden. Es unterstützt größere Datensätze, höhere Verfügbarkeit und Skalierbarkeit und ist besser für Produktionsumgebungen geeignet.
Milvus wurde von Anfang an für die Unterstützung von Kubernetes entwickelt und kann problemlos auf AWS bereitgestellt werden. Wir können Amazon Elastic Kubernetes Service (Amazon EKS) als verwaltetes Kubernetes, Amazon S3 als Objektspeicher, Amazon Managed Streaming for Apache Kafka (Amazon MSK) als Nachrichtenspeicher und Amazon Elastic Load Balancing (Amazon ELB) als Load Balancer verwenden, um einen zuverlässigen, elastischen Milvus-Datenbank-Cluster aufzubauen.
Im Folgenden finden Sie eine schrittweise Anleitung für die Bereitstellung eines Milvus-Clusters mit EKS und anderen Services.
Bereitstellen von Milvus auf AWS EKS
Voraussetzungen
Wir werden AWS CLI verwenden, um einen EKS-Cluster zu erstellen und eine Milvus-Datenbank bereitzustellen. Die folgenden Voraussetzungen sind erforderlich:
Ein PC/Mac oder eine Amazon EC2-Instanz, auf der AWS CLI installiert und mit den entsprechenden Berechtigungen konfiguriert ist. Die AWS CLI-Tools sind standardmäßig installiert, wenn Sie Amazon Linux 2 oder Amazon Linux 2023 verwenden.
Installierte EKS-Tools, einschließlich Helm, Kubectl, eksctl, usw.
Ein Amazon S3-Bucket.
Eine Amazon MSK-Instanz.
Überlegungen bei der Erstellung von MSK
- Die letzte stabile Version von Milvus (v2.3.13) hängt von der
autoCreateTopics
-Funktion von Kafka ab. Daher müssen wir bei der Erstellung von MSK eine benutzerdefinierte Konfiguration verwenden und die Eigenschaftauto.create.topics.enable
von der Standardeinstellungfalse
auftrue
ändern. Um den Nachrichtendurchsatz von MSK zu erhöhen, wird außerdem empfohlen, die Werte vonmessage.max.bytes
undreplica.fetch.max.bytes
zu erhöhen. Siehe Benutzerdefinierte MSK-Konfigurationen für weitere Details.
auto.create.topics.enable=true
message.max.bytes=10485880
replica.fetch.max.bytes=20971760
- Milvus unterstützt nicht die rollenbasierte IAM-Authentifizierung von MSK. Aktivieren Sie daher bei der Erstellung von MSK die Option
SASL/SCRAM authentication
in der Sicherheitskonfiguration und konfigurieren Sieusername
undpassword
im AWS Secrets Manager. Weitere Informationen finden Sie unter Authentifizierung mit Anmeldeinformationen mit AWS Secrets Manager.
Abbildung 3 Sicherheitseinstellungen: SASL SCRAM-Authentifizierung aktivieren.png
Abbildung 3: Sicherheitseinstellungen: SASL/SCRAM-Authentifizierung aktivieren
- Wir müssen den Zugriff auf die MSK-Sicherheitsgruppe von der Sicherheitsgruppe oder dem IP-Adressbereich des EKS-Clusters aus aktivieren.
Erstellen eines EKS Clusters
Es gibt viele Möglichkeiten, einen EKS-Cluster zu erstellen, z.B. über die Konsole, CloudFormation, eksctl, etc. In diesem Beitrag wird gezeigt, wie man einen EKS-Cluster mit eksctl erstellt.
eksctl
eksctl ist ein einfaches Befehlszeilen-Tool zur Erstellung und Verwaltung von Kubernetes-Clustern auf Amazon EKS. Es bietet die schnellste und einfachste Möglichkeit, einen neuen Cluster mit Knoten für Amazon EKS zu erstellen. Weitere Informationen finden Sie auf der Website von eksctl.
- Erstellen Sie zunächst eine
eks_cluster.yaml
Datei mit dem folgenden Code-Schnipsel. Ersetzen Siecluster-name
durch Ihren Clusternamen,region-code
durch die AWS-Region, in der Sie den Cluster erstellen möchten, undprivate-subnet-idx
durch Ihre privaten Subnetze. Hinweis: Diese Konfigurationsdatei erstellt einen EKS-Cluster in einer bestehenden VPC, indem private Subnetze angegeben werden. Wenn Sie eine neue VPC erstellen möchten, entfernen Sie die Konfiguration der VPC und der Subnetze, dann wirdeksctl
automatisch eine neue VPC erstellen.
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: <cluster-name>
region: <region-code>
version: "1.26"
iam:
withOIDC: true
serviceAccounts:
- metadata:
name: aws-load-balancer-controller
namespace: kube-system
wellKnownPolicies:
awsLoadBalancerController: true
- metadata:
name: milvus-s3-access-sa
# if no namespace is set, "default" will be used;
# the namespace will be created if it doesn't exist already
namespace: milvus
labels: {aws-usage: "milvus"}
attachPolicyARNs:
- "arn:aws:iam::aws:policy/AmazonS3FullAccess"
# Use existed VPC to create EKS.
# If you don't config vpc subnets, eksctl will automatically create a brand new VPC
vpc:
subnets:
private:
us-west-2a: { id: <private-subnet-id1> }
us-west-2b: { id: <private-subnet-id2> }
us-west-2c: { id: <private-subnet-id3> }
managedNodeGroups:
- name: ng-1-milvus
labels: { role: milvus }
instanceType: m6i.2xlarge
desiredCapacity: 3
privateNetworking: true
addons:
- name: vpc-cni # no version is specified so it deploys the default version
attachPolicyARNs:
- arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy
- name: coredns
version: latest # auto discovers the latest available
- name: kube-proxy
version: latest
- name: aws-ebs-csi-driver
wellKnownPolicies: # add IAM and service account
ebsCSIController: true
- Führen Sie dann den Befehl
eksctl
aus, um den EKS-Cluster zu erstellen.
eksctl create cluster -f eks_cluster.yaml
Mit diesem Befehl werden die folgenden Ressourcen erstellt:
Ein EKS-Cluster mit der angegebenen Version.
Eine verwaltete Knotengruppe mit drei m6i.2xlarge EC2-Instanzen.
Ein IAM OIDC Identity Provider und ein ServiceAccount namens
aws-load-balancer-controller
, den wir später bei der Installation des AWS Load Balancer Controllers verwenden werden.Ein Namespace
milvus
und ein ServiceAccountmilvus-s3-access-sa
innerhalb dieses Namespaces. Dieser Namespace wird später bei der Konfiguration von S3 als Objektspeicher für Milvus verwendet.Hinweis: Der Einfachheit halber wird
milvus-s3-access-sa
hier mit vollen S3-Zugriffsrechten ausgestattet. In Produktionsumgebungen wird empfohlen, das Prinzip der geringsten Rechte zu befolgen und nur Zugriff auf den spezifischen S3-Bucket zu gewähren, der für Milvus verwendet wird.Mehrere Add-ons, wobei
vpc-cni
,coredns
,kube-proxy
Kern-Add-ons sind, die von EKS benötigt werden.aws-ebs-csi-driver
ist der AWS EBS CSI-Treiber, der es EKS-Clustern ermöglicht, den Lebenszyklus von Amazon EBS-Volumes zu verwalten.
Jetzt müssen wir nur noch auf den Abschluss der Cluster-Erstellung warten.
Warten Sie auf den Abschluss der Cluster-Erstellung. Während der Erstellung des Clusters wird die Datei kubeconfig
automatisch erstellt oder aktualisiert. Sie können sie auch manuell aktualisieren, indem Sie den folgenden Befehl ausführen. Achten Sie darauf, region-code
durch die AWS-Region zu ersetzen, in der Ihr Cluster erstellt wird, und cluster-name
durch den Namen Ihres Clusters.
aws eks update-kubeconfig --region <region-code> --name <cluster-name>
Sobald der Cluster erstellt ist, können Sie die Knoten anzeigen, indem Sie diesen Befehl ausführen:
kubectl get nodes -A -o wide
- Erstellen Sie eine
ebs-sc
StorageClass, die mit GP3 als Speichertyp konfiguriert ist, und legen Sie sie als Standard StorageClass fest. Milvus verwendet etcd als Metaspeicher und benötigt diese StorageClass, um PVCs zu erstellen und zu verwalten.
cat <<EOF | kubectl apply -f -
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: ebs-sc
annotations:
storageclass.kubernetes.io/is-default-class: "true"
provisioner: ebs.csi.aws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
type: gp3
EOF
Setzen Sie dann die ursprüngliche StorageClass gp2
auf nicht standardmäßig:
kubectl patch storageclass gp2 -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"false"}}}'
- Installieren Sie den AWS Load Balancer Controller. Wir werden diesen Controller später für den Milvus Service und Attu Ingress verwenden, daher sollten wir ihn vorher installieren.
- Fügen Sie zunächst das
eks-charts
Repo hinzu und aktualisieren Sie es.
helm repo add eks https://aws.github.io/eks-charts
helm repo update
- Als nächstes installieren Sie den AWS Load Balancer Controller. Ersetzen Sie
cluster-name
durch Ihren Clusternamen. Der ServiceAccount mit dem Namenaws-load-balancer-controller
wurde bereits beim Erstellen des EKS-Clusters in den vorherigen Schritten erstellt.
helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
-n kube-system \
--set clusterName=<cluster-name> \
--set serviceAccount.create=false \
--set serviceAccount.name=aws-load-balancer-controller
- Überprüfen Sie, ob der Controller erfolgreich installiert wurde.
kubectl get deployment -n kube-system aws-load-balancer-controller
- Die Ausgabe sollte wie folgt aussehen:
NAME READY UP-TO-DATE AVAILABLE AGE
aws-load-balancer-controller 2/2 2 2 12m
Bereitstellen eines Milvus-Clusters
Milvus unterstützt mehrere Bereitstellungsmethoden, wie Operator und Helm. Operator ist einfacher, aber Helm ist direkter und flexibler. In diesem Beispiel verwenden wir Helm für die Bereitstellung von Milvus.
Wenn Sie Milvus mit Helm bereitstellen, können Sie die Konfiguration über die Datei values.yaml
anpassen. Klicken Sie auf values.yaml, um alle Optionen anzuzeigen. Standardmäßig erstellt Milvus im Cluster minio und pulsar als Objektspeicher bzw. Nachrichtenspeicher. Wir werden einige Konfigurationsänderungen vornehmen, um sie für die Produktion besser geeignet zu machen.
- Fügen Sie zunächst das Milvus Helm Repo hinzu und aktualisieren Sie es.
helm repo add milvus https://zilliztech.github.io/milvus-helm/
helm repo update
- Erstellen Sie eine Datei
milvus_cluster.yaml
mit dem folgenden Codeschnipsel. Dieser Codeausschnitt passt die Konfiguration von Milvus an, z. B. die Konfiguration von Amazon S3 als Objektspeicher und Amazon MSK als Nachrichtenwarteschlange. Detaillierte Erklärungen und Anleitungen zur Konfiguration werden später gegeben.
#####################################
# Section 1
#
# Configure S3 as the Object Storage
#####################################
# Service account
# - this service account are used by External S3 access
serviceAccount:
create: false
name: milvus-s3-access-sa
# Close in-cluster minio
minio:
enabled: false
# External S3
# - these configs are only used when `externalS3.enabled` is true
externalS3:
enabled: true
host: "s3.<region-code>.amazonaws.com"
port: "443"
useSSL: true
bucketName: "<bucket-name>"
rootPath: "<root-path>"
useIAM: true
cloudProvider: "aws"
iamEndpoint: ""
#####################################
# Section 2
#
# Configure MSK as the Message Storage
#####################################
# Close in-cluster pulsar
pulsar:
enabled: false
# External kafka
# - these configs are only used when `externalKafka.enabled` is true
externalKafka:
enabled: true
brokerList: "<broker-list>"
securityProtocol: SASL_SSL
sasl:
mechanisms: SCRAM-SHA-512
username: "<username>"
password: "<password>"
#####################################
# Section 3
#
# Expose the Milvus service to be accessed from outside the cluster (LoadBalancer service).
# or access it from within the cluster (ClusterIP service). Set the service type and the port to serve it.
#####################################
service:
type: LoadBalancer
port: 19530
annotations:
service.beta.kubernetes.io/aws-load-balancer-type: external #AWS Load Balancer Controller fulfills services that has this annotation
service.beta.kubernetes.io/aws-load-balancer-name : milvus-service #User defined name given to AWS Network Load Balancer
service.beta.kubernetes.io/aws-load-balancer-scheme: internal # internal or internet-facing, later allowing for public access via internet
service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: ip #The Pod IPs should be used as the target IPs (rather than the node IPs)
#####################################
# Section 4
#
# Installing Attu the Milvus management GUI
#####################################
attu:
enabled: true
name: attu
ingress:
enabled: true
annotations:
kubernetes.io/ingress.class: alb # Annotation: set ALB ingress type
alb.ingress.kubernetes.io/scheme: internet-facing #Places the load balancer on public subnets
alb.ingress.kubernetes.io/target-type: ip #The Pod IPs should be used as the target IPs (rather than the node IPs)
alb.ingress.kubernetes.io/group.name: attu # Groups multiple Ingress resources
hosts:
-
#####################################
# Section 5
#
# HA deployment of Milvus Core Components
#####################################
rootCoordinator:
replicas: 2
activeStandby:
enabled: true # Enable active-standby when you set multiple replicas for root coordinator
resources:
limits:
cpu: 1
memory: 2Gi
indexCoordinator:
replicas: 2
activeStandby:
enabled: true # Enable active-standby when you set multiple replicas for index coordinator
resources:
limits:
cpu: "0.5"
memory: 0.5Gi
queryCoordinator:
replicas: 2
activeStandby:
enabled: true # Enable active-standby when you set multiple replicas for query coordinator
resources:
limits:
cpu: "0.5"
memory: 0.5Gi
dataCoordinator:
replicas: 2
activeStandby:
enabled: true # Enable active-standby when you set multiple replicas for data coordinator
resources:
limits:
cpu: "0.5"
memory: 0.5Gi
proxy:
replicas: 2
resources:
limits:
cpu: 1
memory: 4Gi
#####################################
# Section 6
#
# Milvus Resource Allocation
#####################################
queryNode:
replicas: 1
resources:
limits:
cpu: 2
memory: 8Gi
dataNode:
replicas: 1
resources:
limits:
cpu: 1
memory: 4Gi
indexNode:
replicas: 1
resources:
limits:
cpu: 4
memory: 8Gi
Der Code besteht aus sechs Abschnitten. Folgen Sie den folgenden Anweisungen, um die entsprechenden Konfigurationen zu ändern.
Abschnitt 1: Konfigurieren Sie S3 als Objektspeicher. Der serviceAccount gewährt Milvus den Zugriff auf S3 (in diesem Fall ist es milvus-s3-access-sa
, das bei der Erstellung des EKS-Clusters angelegt wurde). Stellen Sie sicher, dass Sie <region-code>
durch die AWS-Region ersetzen, in der sich Ihr Cluster befindet. Ersetzen Sie <bucket-name>
durch den Namen Ihres S3-Buckets und <root-path>
durch das Präfix für das S3-Bucket (dieses Feld kann leer bleiben).
Abschnitt 2: Konfigurieren Sie MSK als Nachrichtenspeicher. Ersetzen Sie <broker-list>
durch die Endpunktadressen, die dem SASL/SCRAM-Authentifizierungstyp von MSK entsprechen. Ersetzen Sie <username>
und <password>
durch den Benutzernamen und das Passwort des MSK-Kontos. Die Adresse <broker-list>
können Sie den MSK-Clientinformationen entnehmen, wie in der folgenden Abbildung dargestellt.
Abbildung 4: MSK als Nachrichtenspeicher von Milvus konfigurieren.png
Abbildung 4: MSK als Nachrichtenspeicher für Milvus konfigurieren
Abschnitt 3: Expose Milvus service and enable access from outside the cluster. Der Milvus-Endpunkt verwendet standardmäßig einen Dienst vom Typ ClusterIP, der nur innerhalb des EKS-Clusters zugänglich ist. Bei Bedarf können Sie ihn auf den Typ LoadBalancer ändern, um den Zugriff von außerhalb des EKS-Clusters zu ermöglichen. Der Service vom Typ LoadBalancer verwendet Amazon NLB als Load Balancer. Gemäß den bewährten Sicherheitspraktiken ist aws-load-balancer-scheme
hier standardmäßig als interner Modus konfiguriert, was bedeutet, dass nur der Intranetzugriff auf Milvus erlaubt ist. Klicken Sie hier, um die NLB-Konfigurationsanweisungen anzuzeigen.
Abschnitt 4: Installieren und konfigurieren Sie Attu, ein Open-Source-Verwaltungstool für Milvus. Es verfügt über eine intuitive grafische Benutzeroberfläche, mit der Sie leicht mit Milvus interagieren können. Wir aktivieren Attu, konfigurieren den Ingress mit AWS ALB und stellen es auf den Typ internet-facing
ein, damit Attu über das Internet zugänglich ist. Klicken Sie auf dieses Dokument für die Anleitung zur ALB-Konfiguration.
Abschnitt 5: Aktivieren Sie die HA-Bereitstellung der Milvus-Kernkomponenten. Milvus enthält mehrere unabhängige und entkoppelte Komponenten. Der Coordinator Service fungiert beispielsweise als Kontrollschicht und übernimmt die Koordination der Komponenten Root, Query, Data und Index. Der Proxy in der Zugriffsschicht dient als Endpunkt für den Datenbankzugriff. Diese Komponenten haben standardmäßig nur 1 Pod-Replikat. Die Bereitstellung mehrerer Replikate dieser Dienstkomponenten ist insbesondere zur Verbesserung der Verfügbarkeit von Milvus erforderlich.
Hinweis: Für die Bereitstellung mehrerer Replikate der Root-, Abfrage-, Daten- und Indexkoordinator-Komponenten muss die Option activeStandby
aktiviert sein.
Abschnitt 6: Passen Sie die Ressourcenzuweisung für Milvus-Komponenten an die Anforderungen Ihrer Workloads an. Die Milvus-Website bietet auch ein Sizing-Tool zur Generierung von Konfigurationsvorschlägen auf der Grundlage von Datenvolumen, Vektordimensionen, Indextypen usw. Es kann auch eine Helm-Konfigurationsdatei mit nur einem Klick erzeugen. Die folgende Konfiguration ist der Vorschlag, den das Tool für 1 Million Vektoren mit 1024 Dimensionen und den Index-Typ HNSW macht.
- Verwenden Sie Helm, um Milvus zu erstellen (bereitgestellt im Namespace
milvus
). Hinweis: Sie können<demo>
durch einen eigenen Namen ersetzen.
helm install <demo> milvus/milvus -n milvus -f milvus_cluster.yaml
- Führen Sie den folgenden Befehl aus, um den Bereitstellungsstatus zu überprüfen.
kubectl get deployment -n milvus
Die folgende Ausgabe zeigt, dass alle Milvus-Komponenten AVAILABLE sind und dass für die Koordinierungskomponenten mehrere Replikate aktiviert sind.
NAME READY UP-TO-DATE AVAILABLE AGE
demo-milvus-attu 1/1 1 1 5m27s
demo-milvus-datacoord 2/2 2 2 5m27s
demo-milvus-datanode 1/1 1 1 5m27s
demo-milvus-indexcoord 2/2 2 2 5m27s
demo-milvus-indexnode 1/1 1 1 5m27s
demo-milvus-proxy 2/2 2 2 5m27s
demo-milvus-querycoord 2/2 2 2 5m27s
demo-milvus-querynode 1/1 1 1 5m27s
demo-milvus-rootcoord 2/2 2 2 5m27s
Zugriff auf und Verwaltung von Milvus
Bis jetzt haben wir die Milvus-Vektor-Datenbank erfolgreich bereitgestellt. Nun können wir über Endpunkte auf Milvus zugreifen. Milvus stellt Endpunkte über Kubernetes-Dienste bereit. Attu stellt Endpunkte über Kubernetes Ingress zur Verfügung.
Zugriff auf Milvus-Endpunkte
Führen Sie den folgenden Befehl aus, um Service-Endpunkte abzurufen:
kubectl get svc -n milvus
Sie können verschiedene Dienste anzeigen. Milvus unterstützt zwei Ports, Port 19530
und Port 9091
:
- Port
19530
ist für gRPC und RESTful API. Es ist der Standardport, wenn Sie sich mit verschiedenen Milvus-SDKs oder HTTP-Clients mit einem Milvus-Server verbinden. - Port
9091
ist ein Verwaltungsport für die Sammlung von Metriken, pprof profiling und Health Probes innerhalb von Kubernetes.
Der Dienst demo-milvus
bietet einen Endpunkt für den Datenbankzugriff, über den Clients eine Verbindung herstellen können. Er verwendet NLB als Dienst-Load-Balancer. Sie können den Endpunkt des Dienstes in der Spalte EXTERNAL-IP
abrufen.
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
demo-etcd ClusterIP 172.20.103.138 <none> 2379/TCP,2380/TCP 62m
demo-etcd-headless ClusterIP None <none> 2379/TCP,2380/TCP 62m
demo-milvus LoadBalancer 172.20.219.33 milvus-nlb-xxxx.elb.us-west-2.amazonaws.com 19530:31201/TCP,9091:31088/TCP 62m
demo-milvus-datacoord ClusterIP 172.20.214.106 <none> 13333/TCP,9091/TCP 62m
demo-milvus-datanode ClusterIP None <none> 9091/TCP 62m
demo-milvus-indexcoord ClusterIP 172.20.106.51 <none> 31000/TCP,9091/TCP 62m
demo-milvus-indexnode ClusterIP None <none> 9091/TCP 62m
demo-milvus-querycoord ClusterIP 172.20.136.213 <none> 19531/TCP,9091/TCP 62m
demo-milvus-querynode ClusterIP None <none> 9091/TCP 62m
demo-milvus-rootcoord ClusterIP 172.20.173.98 <none> 53100/TCP,9091/TCP 62m
Verwaltung von Milvus mit Attu
Wie bereits beschrieben, haben wir Attu installiert, um Milvus zu verwalten. Führen Sie den folgenden Befehl aus, um den Endpunkt abzurufen:
kubectl get ingress -n milvus
Sie können einen Ingress mit dem Namen demo-milvus-attu
sehen, wobei die Spalte ADDRESS
die Zugriffs-URL ist.
NAME CLASS HOSTS ADDRESS PORTS AGE
demo-milvus-attu <none> * k8s-attu-xxxx.us-west-2.elb.amazonaws.com 80 27s
Öffnen Sie die Ingress-Adresse in einem Browser und sehen Sie die folgende Seite. Klicken Sie auf Verbinden, um sich anzumelden.
Abbildung 5 Anmelden bei Ihrem Attu-Konto.png
Abbildung 5: Einloggen in Ihr Attu-Konto
Nachdem Sie sich angemeldet haben, können Sie Milvus-Datenbanken über Attu verwalten.
Abbildung 6: Die Attu-Benutzeroberfläche.png
Abbildung 6: Die Attu-Benutzeroberfläche
Testen der Milvus-Vektordatenbank
Wir werden den Milvus-Beispielcode verwenden, um zu testen, ob die Milvus-Datenbank richtig funktioniert. Laden Sie zunächst den Beispielcode hello_milvus.py
mit dem folgenden Befehl herunter:
wget https://raw.githubusercontent.com/milvus-io/pymilvus/master/examples/hello_milvus.py
Ändern Sie den Host im Beispielcode auf den Endpunkt des Milvus-Dienstes.
print(fmt.format("start connecting to Milvus"))
connections.connect("default", host="milvus-nlb-xxx.elb.us-west-2.amazonaws.com", port="19530")
Führen Sie den Code aus:
python3 hello_milvus.py
Wenn das System das folgende Ergebnis zurückgibt, bedeutet dies, dass Milvus normal läuft.
=== start connecting to Milvus ===
Does collection hello_milvus exist in Milvus: False
=== Create collection `hello_milvus` ===
=== Start inserting entities ===
Number of entities in Milvus: 3000
=== Start Creating index IVF_FLAT ===
=== Start loading ===
Schlussfolgerung
Dieser Beitrag stellt Milvus vor, eine der beliebtesten Open-Source-Vektordatenbanken, und bietet eine Anleitung für die Bereitstellung von Milvus auf AWS unter Verwendung von verwalteten Services wie Amazon EKS, S3, MSK und ELB, um eine größere Elastizität und Zuverlässigkeit zu erreichen.
Als Kernkomponente verschiedener GenAI-Systeme, insbesondere Retrieval Augmented Generation (RAG), unterstützt und integriert Milvus eine Vielzahl von Mainstream-GenAI-Modellen und -Frameworks, darunter Amazon Sagemaker, PyTorch, HuggingFace, LlamaIndex und LangChain. Beginnen Sie Ihre GenAI-Innovationsreise mit Milvus noch heute!
Referenzen
- Ein Überblick über Vektor-Embeddings und Vektordatenbanken
- Was ist Milvus?
- Bereitstellen von Milvus auf AWS EKS
- Testen der Milvus-Vektordatenbank
- Schlussfolgerung
- Referenzen
On This Page
Try Managed Milvus for Free
Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.
Get StartedLike the article? Spread the word