Come distribuire il database vettoriale open source Milvus su Amazon EKS
Questo post è stato pubblicato originariamente sul sito web di AWS ed è stato tradotto, modificato e ripubblicato qui con l'autorizzazione.
Una panoramica sugli embeddings vettoriali e i database vettoriali
L'ascesa dell'IA generativa (GenAI), in particolare dei modelli linguistici di grandi dimensioni(LLM), ha aumentato in modo significativo l'interesse per i database vettoriali, rendendoli una componente essenziale dell'ecosistema GenAI. Di conseguenza, i database vettoriali vengono adottati in un numero crescente di casi d'uso.
Un rapporto IDC prevede che entro il 2025 oltre l'80% dei dati aziendali sarà non strutturato, in formati quali testo, immagini, audio e video. La comprensione, l'elaborazione, l'archiviazione e l'interrogazione di questa vasta quantità di dati non strutturati su scala rappresentano una sfida significativa. La pratica comune nella GenAI e nel deep learning è quella di trasformare i dati non strutturati in embeddings vettoriali, memorizzarli e indicizzarli in un database vettoriale come Milvus o Zilliz Cloud (il Milvus completamente gestito) per ricerche di similarità vettoriale o di similarità semantica.
Ma cosa sono esattamente gli embeddings vettoriali? In poche parole, sono rappresentazioni numeriche di numeri in virgola mobile in uno spazio ad alta densità . La distanza tra due vettori indica la loro rilevanza: più sono vicini, più sono rilevanti l'uno per l'altro, e viceversa. Ciò significa che vettori simili corrispondono a dati originali simili, a differenza delle tradizionali ricerche per parole chiave o esatte.
Come eseguire una ricerca di similarità vettoriale
Figura 1: Come eseguire una ricerca per similarità vettoriale
La capacità di memorizzare, indicizzare e cercare le incorporazioni vettoriali è la funzionalità principale dei database vettoriali. Attualmente, i principali database vettoriali si dividono in due categorie. La prima categoria estende i prodotti di database relazionali esistenti, come Amazon OpenSearch Service con il plugin KNN e Amazon RDS per PostgreSQL con l'estensione pgvector. La seconda categoria comprende prodotti specializzati in database vettoriali, tra cui esempi ben noti come Milvus, Zilliz Cloud (il Milvus completamente gestito), Pinecone, Weaviate, Qdrant e Chroma.
Le tecniche di embedding e i database vettoriali trovano ampie applicazioni in diversi casi d'uso guidati dall'intelligenza artificiale, tra cui la ricerca per similarità di immagini, la deduplicazione e l'analisi dei video, l'elaborazione del linguaggio naturale, i sistemi di raccomandazione, la pubblicità mirata, la ricerca personalizzata, il servizio clienti intelligente e il rilevamento delle frodi.
Milvus è una delle opzioni open-source più popolari tra i numerosi database vettoriali. Questo post presenta Milvus ed esplora la pratica di implementazione di Milvus su AWS EKS.
Che cos'è Milvus?
Milvus è un database vettoriale open-source cloud-native altamente flessibile, affidabile e velocissimo. È in grado di alimentare la ricerca di similarità vettoriale e le applicazioni di intelligenza artificiale e si sforza di rendere i database vettoriali accessibili a tutte le organizzazioni. Milvus è in grado di memorizzare, indicizzare e gestire oltre un miliardo di incorporazioni vettoriali generate da reti neurali profonde e altri modelli di apprendimento automatico (ML).
Milvus è stato rilasciato sotto la licenza open-source Apache 2.0 nell'ottobre 2019. Attualmente è un progetto di laurea della LF AI & Data Foundation. Al momento della stesura di questo blog, Milvus ha raggiunto più di 50 milioni di download di Docker pull ed è utilizzato da molti clienti, come NVIDIA, AT&T, IBM, eBay, Shopee e Walmart.
Caratteristiche principali di Milvus
Come database vettoriale cloud-native, Milvus vanta le seguenti caratteristiche principali:
Prestazioni elevate e ricerca al millisecondo su set di dati vettoriali di dimensioni miliardarie.
Supporto multilingue e toolchain.
Scalabilità orizzontale ed elevata affidabilità anche in caso di interruzioni.
Ricerca ibrida, ottenuta accoppiando il filtraggio scalare con la ricerca di similarità vettoriale.
Architettura di Milvus
Milvus segue il principio della separazione tra flusso di dati e flusso di controllo. Il sistema è suddiviso in quattro livelli, come mostrato nel diagramma:
Architettura Milvus
Figura 2 Architettura Milvus
Livello di accesso: Il livello di accesso è composto da un gruppo di proxy stateless e funge da livello frontale del sistema e da endpoint per gli utenti.
Servizio di coordinamento: Il servizio di coordinamento assegna i compiti ai nodi lavoratori.
Nodi worker: I nodi worker sono esecutori muti che seguono le istruzioni del servizio coordinatore ed eseguono i comandi DML/DDL attivati dall'utente.
Storage: Lo storage è responsabile della persistenza dei dati. Comprende un meta-archivio, un log broker e un object storage.
Opzioni di distribuzione di Milvus
Milvus supporta tre modalità di funzionamento: Milvus Lite, Standalone e Distribuito.
Milvus Lite è una libreria Python che può essere importata nelle applicazioni locali. Essendo una versione leggera di Milvus, è ideale per la prototipazione rapida in Jupyter Notebook o per l'esecuzione su dispositivi intelligenti con risorse limitate.
Milvus Standalone èuna versione server a macchina singola. Se avete un carico di lavoro di produzione ma preferite non usare Kubernetes, l'esecuzione di Milvus Standalone su una singola macchina con memoria sufficiente è una buona opzione.
Milvus Distributed può essere distribuito su cluster Kubernetes. Supporta set di dati più grandi, maggiore disponibilità e scalabilità ed è più adatto agli ambienti di produzione.
Milvus è stato progettato fin dall'inizio per supportare Kubernetes e può essere facilmente distribuito su AWS. Possiamo usare Amazon Elastic Kubernetes Service (Amazon EKS) come Kubernetes gestito, Amazon S3 come Object Storage, Amazon Managed Streaming for Apache Kafka (Amazon MSK) come Message storage e Amazon Elastic Load Balancing (Amazon ELB) come Load Balancer per costruire un cluster di database Milvus affidabile ed elastico.
In seguito, forniremo una guida passo-passo per l'implementazione di un cluster Milvus utilizzando EKS e altri servizi.
Distribuzione di Milvus su AWS EKS
Prerequisiti
Utilizzeremo AWS CLI per creare un cluster EKS e distribuire un database Milvus. Sono necessari i seguenti prerequisiti:
Un PC/Mac o un'istanza Amazon EC2 con AWS CLI installato e configurato con le autorizzazioni appropriate. Gli strumenti AWS CLI sono installati per impostazione predefinita se si utilizza Amazon Linux 2 o Amazon Linux 2023.
Strumenti EKS installati, tra cui Helm, Kubectl, eksctl, ecc.
Un bucket Amazon S3.
Un'istanza Amazon MSK.
Considerazioni sulla creazione di MSK
- L'ultima versione stabile di Milvus (v2.3.13) dipende dalla funzione
autoCreateTopics
di Kafka. Pertanto, quando si crea MSK, è necessario utilizzare una configurazione personalizzata e modificare la proprietÃauto.create.topics.enable
dal valore predefinitofalse
atrue
. Inoltre, per aumentare il throughput dei messaggi di MSK, si raccomanda di aumentare i valori dimessage.max.bytes
ereplica.fetch.max.bytes
. Per maggiori dettagli, vedere Configurazioni MSK personalizzate.
auto.create.topics.enable=true
message.max.bytes=10485880
replica.fetch.max.bytes=20971760
- Milvus non supporta l'autenticazione basata sui ruoli IAM di MSK. Pertanto, quando si crea MSK, abilitare l'opzione
SASL/SCRAM authentication
nella configurazione della sicurezza e configurareusername
epassword
in AWS Secrets Manager. Per i dettagli, vedere Autenticazione delle credenziali di accesso con AWS Secrets Manager.
Figura 3 Impostazioni di sicurezza: abilitare l'autenticazione SASL SCRAM.png
Figura 3: Impostazioni di sicurezza: abilitare l'autenticazione SASL/SCRAM
- È necessario abilitare l'accesso al gruppo di sicurezza MSK dal gruppo di sicurezza o dall'intervallo di indirizzi IP del cluster EKS.
Creare un cluster EKS
Ci sono molti modi per creare un cluster EKS, ad esempio tramite la console, CloudFormation, eksctl, ecc. Questo post mostra come creare un cluster EKS utilizzando eksctl.
eksctl
è un semplice strumento da riga di comando per creare e gestire cluster Kubernetes su Amazon EKS. Offre il modo più semplice e veloce per creare un nuovo cluster con nodi per Amazon EKS. Per ulteriori informazioni, consultare il sito web di eksctl.
- Per prima cosa, creare un file
eks_cluster.yaml
con il seguente frammento di codice. Sostituirecluster-name
con il nome del cluster,region-code
con la regione AWS in cui si desidera creare il cluster eprivate-subnet-idx
con le sottoreti private. Nota: Questo file di configurazione crea un cluster EKS in una VPC esistente specificando le sottoreti private. Se si desidera creare una nuova VPC, rimuovere la configurazione della VPC e delle sottoreti eeksctl
ne creerà automaticamente una nuova.
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
- Quindi, eseguire il comando
eksctl
per creare il cluster EKS.
eksctl create cluster -f eks_cluster.yaml
Questo comando creerà le seguenti risorse:
Un cluster EKS con la versione specificata.
Un gruppo di nodi gestiti con tre istanze EC2 m6i.2xlarge.
Un provider di identità IAM OIDC e un ServiceAccount chiamato
aws-load-balancer-controller
, che verrà utilizzato in seguito per l'installazione di AWS Load Balancer Controller.Uno spazio dei nomi
milvus
e un ServiceAccountmilvus-s3-access-sa
all'interno di questo spazio dei nomi. Questo spazio dei nomi sarà usato in seguito per configurare S3 come archivio di oggetti per Milvus.Nota: per semplicità , al sito
milvus-s3-access-sa
vengono concessi tutti i permessi di accesso a S3. Nelle distribuzioni di produzione, si raccomanda di seguire il principio del minimo privilegio e di concedere l'accesso solo allo specifico bucket S3 usato per Milvus.Più componenti aggiuntivi, dove
vpc-cni
,coredns
,kube-proxy
sono componenti aggiuntivi fondamentali richiesti da EKS.aws-ebs-csi-driver
è il driver CSI di AWS EBS che consente ai cluster EKS di gestire il ciclo di vita dei volumi Amazon EBS.
Ora dobbiamo solo attendere il completamento della creazione del cluster.
Attendere il completamento della creazione del cluster. Durante il processo di creazione del cluster, il file kubeconfig
verrà creato o aggiornato automaticamente. È anche possibile aggiornarlo manualmente eseguendo il seguente comando. Assicurarsi di sostituire region-code
con la regione AWS in cui si sta creando il cluster e di sostituire cluster-name
con il nome del cluster.
aws eks update-kubeconfig --region <region-code> --name <cluster-name>
Una volta creato il cluster, è possibile visualizzare i nodi eseguendo:
kubectl get nodes -A -o wide
- Creare una StorageClass
ebs-sc
configurata con GP3 come tipo di storage e impostarla come StorageClass predefinita. Milvus usa etcd come Meta Storage e ha bisogno di questa StorageClass per creare e gestire i PVC.
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
Quindi, impostare la StorageClass originale gp2
come non predefinita:
kubectl patch storageclass gp2 -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"false"}}}'
- Installare il controller AWS Load Balancer. Questo controller verrà utilizzato in seguito per il servizio Milvus e Attu Ingress, quindi installiamolo prima.
- Per prima cosa, aggiungere il repo
eks-charts
e aggiornarlo.
helm repo add eks https://aws.github.io/eks-charts
helm repo update
- Quindi, installare il controllore AWS Load Balancer. Sostituire
cluster-name
con il nome del cluster. Il ServiceAccountaws-load-balancer-controller
è già stato creato quando abbiamo creato il cluster EKS nei passi precedenti.
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
- Verificare se il controller è stato installato correttamente.
kubectl get deployment -n kube-system aws-load-balancer-controller
- L'output dovrebbe apparire come segue:
NAME READY UP-TO-DATE AVAILABLE AGE
aws-load-balancer-controller 2/2 2 2 12m
Distribuzione di un cluster Milvus
Milvus supporta diversi metodi di distribuzione, come Operator e Helm. Operator è più semplice, ma Helm è più diretto e flessibile. In questo esempio useremo Helm per distribuire Milvus.
Quando si distribuisce Milvus con Helm, è possibile personalizzare la configurazione tramite il file values.yaml
. Fare clic su values.yaml per visualizzare tutte le opzioni. Per impostazione predefinita, Milvus crea minio e pulsar all'interno del cluster, rispettivamente come Object Storage e Message Storage. Verranno apportate alcune modifiche alla configurazione per renderla più adatta alla produzione.
- Per prima cosa, aggiungere il repo Milvus Helm e aggiornarlo.
helm repo add milvus https://zilliztech.github.io/milvus-helm/
helm repo update
- Creare un file
milvus_cluster.yaml
con il seguente frammento di codice. Questo frammento di codice personalizza la configurazione di Milvus, ad esempio configurando Amazon S3 come archivio di oggetti e Amazon MSK come coda di messaggi. In seguito verranno fornite spiegazioni dettagliate e indicazioni sulla configurazione.
#####################################
# 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
Il codice contiene sei sezioni. Seguire le istruzioni seguenti per modificare le configurazioni corrispondenti.
Sezione 1: Configurare S3 come archivio oggetti. Il serviceAccount concede a Milvus l'accesso a S3 (in questo caso, è milvus-s3-access-sa
, creato quando abbiamo creato il cluster EKS). Assicurarsi di sostituire <region-code>
con la regione AWS in cui si trova il cluster. Sostituire <bucket-name>
con il nome del bucket S3 e <root-path>
con il prefisso del bucket S3 (questo campo può essere lasciato vuoto).
Sezione 2: Configurare MSK come Message Storage. Sostituire <broker-list>
con gli indirizzi degli endpoint corrispondenti al tipo di autenticazione SASL/SCRAM di MSK. Sostituire <username>
e <password>
con il nome utente e la password dell'account MSK. È possibile ottenere <broker-list>
dalle informazioni del client MSK, come mostrato nell'immagine seguente.
Figura 4 Configurazione di MSK come archivio messaggi di Milvus.png
Figura 4: Configurare MSK come archivio messaggi di Milvus
Sezione 3: Esporre il servizio Milvus e abilitare l'accesso dall'esterno del cluster. Per impostazione predefinita, l'endpoint Milvus utilizza un servizio di tipo ClusterIP, accessibile solo all'interno del cluster EKS. Se necessario, è possibile cambiarlo in tipo LoadBalancer per consentire l'accesso dall'esterno del cluster EKS. Il servizio di tipo LoadBalancer utilizza Amazon NLB come bilanciatore di carico. Secondo le migliori pratiche di sicurezza, aws-load-balancer-scheme
è configurato come modalità interna per impostazione predefinita, il che significa che è consentito solo l'accesso intranet a Milvus. Fare clic per visualizzare le istruzioni di configurazione di NLB.
Sezione 4: Installare e configurare Attu, uno strumento di amministrazione open-source di Milvus. Ha un'interfaccia grafica intuitiva che consente di interagire facilmente con Milvus. Abilitiamo Attu, configuriamo l'ingresso utilizzando AWS ALB e lo impostiamo sul tipo internet-facing
in modo che Attu sia accessibile via Internet. Fare clic su questo documento per la guida alla configurazione di ALB.
Sezione 5: Abilitare la distribuzione HA dei componenti principali di Milvus. Milvus contiene diversi componenti indipendenti e disaccoppiati. Ad esempio, il servizio coordinatore agisce come livello di controllo, gestendo il coordinamento dei componenti Root, Query, Data e Index. Il Proxy nel livello di accesso serve come endpoint di accesso al database. Per impostazione predefinita, questi componenti hanno una sola replica del pod. La distribuzione di più repliche di questi componenti del servizio è particolarmente necessaria per migliorare la disponibilità di Milvus.
Nota: la distribuzione multi-replica dei componenti Root, Query, Data e Index coordinator richiede l'abilitazione dell'opzione activeStandby
.
Sezione 6: Regolare l'allocazione delle risorse per i componenti di Milvus per soddisfare i requisiti dei carichi di lavoro. Il sito web di Milvus fornisce anche uno strumento di dimensionamento per generare suggerimenti di configurazione in base al volume dei dati, alle dimensioni dei vettori, ai tipi di indici, ecc. Può anche generare un file di configurazione Helm con un solo clic. La configurazione seguente è il suggerimento fornito dallo strumento per 1 milione di vettori di 1024 dimensioni e tipo di indice HNSW.
- Utilizzare Helm per creare Milvus (distribuito nello spazio dei nomi
milvus
). Nota: è possibile sostituire<demo>
con un nome personalizzato.
helm install <demo> milvus/milvus -n milvus -f milvus_cluster.yaml
- Eseguire il seguente comando per verificare lo stato di distribuzione.
kubectl get deployment -n milvus
L'output seguente mostra che i componenti di Milvus sono tutti AVAILABLE e che i componenti di coordinamento hanno repliche multiple abilitate.
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
Accesso e gestione di Milvus
Finora abbiamo distribuito con successo il database dei vettori di Milvus. Ora possiamo accedere a Milvus attraverso gli endpoint. Milvus espone gli endpoint tramite i servizi Kubernetes. Attu espone gli endpoint tramite Kubernetes Ingress.
Accesso agli endpoint di Milvus
Eseguire il seguente comando per ottenere gli endpoint dei servizi:
kubectl get svc -n milvus
È possibile visualizzare diversi servizi. Milvus supporta due porte, la porta 19530
e la porta 9091
:
- La porta
19530
è per gRPC e API RESTful. È la porta predefinita quando ci si connette a un server Milvus con diversi SDK Milvus o client HTTP. - La porta
9091
è una porta di gestione per la raccolta di metriche, la profilazione pprof e le sonde di salute in Kubernetes.
Il servizio demo-milvus
fornisce un endpoint di accesso al database, utilizzato per stabilire una connessione dai client. Utilizza NLB come bilanciatore di carico del servizio. È possibile ottenere l'endpoint del servizio dalla colonna EXTERNAL-IP
.
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
Gestione di Milvus con Attu
Come descritto in precedenza, abbiamo installato Attu per gestire Milvus. Eseguire il seguente comando per ottenere l'endpoint:
kubectl get ingress -n milvus
Si può vedere un Ingress chiamato demo-milvus-attu
, dove la colonna ADDRESS
è l'URL di accesso.
NAME CLASS HOSTS ADDRESS PORTS AGE
demo-milvus-attu <none> * k8s-attu-xxxx.us-west-2.elb.amazonaws.com 80 27s
Aprire l'indirizzo Ingress in un browser e vedere la seguente pagina. Fare clic su Connetti per accedere.
Figura 5 Accesso all'account Attu.png
Figura 5: Accesso all'account Attu
Dopo aver effettuato il login, è possibile gestire i database Milvus attraverso Attu.
Figura 6 L'interfaccia di Attu.png
Figura 6: L'interfaccia di Attu
Test del database vettoriale Milvus
Utilizzeremo il codice di esempio di Milvus per verificare se il database Milvus funziona correttamente. Per prima cosa, scaricare il codice di esempio hello_milvus.py
utilizzando il seguente comando:
wget https://raw.githubusercontent.com/milvus-io/pymilvus/master/examples/hello_milvus.py
Modificare l'host nel codice di esempio con l'endpoint del servizio Milvus.
print(fmt.format("start connecting to Milvus"))
connections.connect("default", host="milvus-nlb-xxx.elb.us-west-2.amazonaws.com", port="19530")
Eseguire il codice:
python3 hello_milvus.py
Se il sistema restituisce il seguente risultato, significa che Milvus funziona normalmente.
=== 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 ===
Conclusione
Questo post presenta Milvus, uno dei database vettoriali open-source più diffusi, e fornisce una guida all'implementazione di Milvus su AWS utilizzando servizi gestiti come Amazon EKS, S3, MSK e ELB per ottenere maggiore elasticità e affidabilità .
Come componente centrale di vari sistemi GenAI, in particolare della Retrieval Augmented Generation (RAG), Milvus supporta e si integra con una varietà di modelli e framework GenAI mainstream, tra cui Amazon Sagemaker, PyTorch, HuggingFace, LlamaIndex e LangChain. Iniziate oggi stesso il vostro viaggio nell'innovazione GenAI con Milvus!
Riferimenti
- Una panoramica sugli embeddings vettoriali e i database vettoriali
- Che cos'è Milvus?
- Distribuzione di Milvus su AWS EKS
- Test del database vettoriale Milvus
- Conclusione
- Riferimenti
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