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 Eigenschaft auto.create.topics.enable von der Standardeinstellung false auf true ändern. Um den Nachrichtendurchsatz von MSK zu erhöhen, wird außerdem empfohlen, die Werte von message.max.bytes und replica.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 Sie username und password 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.

1. Erstellen Sie zunächst eine eks_cluster.yaml Datei mit dem folgenden Code-Schnipsel. Ersetzen Sie cluster-name durch Ihren Clusternamen, region-code durch die AWS-Region, in der Sie den Cluster erstellen möchten, und private-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 wird eksctl 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

2. 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 ServiceAccount milvus-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

3. 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"}}}'

4. 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 Namen aws-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.

1. 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

2. 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.

1. 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

2. 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

• Amazon EKS Benutzerhandbuch
• Offizielle Milvus Website
• Milvus GitHub Repository
• eksctl Offizielle Website