Cómo implementar la base de datos vectorial Milvus de código abierto en Amazon EKS
Este artículo se publicó originalmente en el sitio web de AWS y se ha traducido, editado y publicado aquí con permiso.
Visión general de las incrustaciones vectoriales y las bases de datos vectoriales
El auge de la IA Generativa (GenAI), en particular de los grandes modelos de lenguaje(LLM), ha impulsado significativamente el interés en las bases de datos vectoriales, estableciéndolas como un componente esencial dentro del ecosistema GenAI. Como resultado, las bases de datos vectoriales se están adoptando en casos de uso cada vez más frecuentes.
Un informe de IDC predice que, para 2025, más del 80% de los datos empresariales serán no estructurados y existirán en formatos como texto, imágenes, audio y vídeos. Comprender, procesar, almacenar y consultar esta enorme cantidad de datos no estructurados a gran escala supone un reto importante. La práctica común en GenAI y aprendizaje profundo es transformar los datos no estructurados en incrustaciones vectoriales, almacenarlos e indexarlos en una base de datos vectorial como Milvus o Zilliz Cloud (el Milvus totalmente gestionado) para búsquedas de similitud vectorial o similitud semántica.
Pero, ¿qué son exactamente las incrustaciones vectoriales? En pocas palabras, son representaciones numéricas de números de coma flotante en un espacio de alta dimensión. La distancia entre dos vectores indica su relevancia: cuanto más próximos están, más relevantes son entre sí, y viceversa. Esto significa que vectores similares corresponden a datos originales similares, lo que difiere de las búsquedas tradicionales por palabras clave o exactas.
Cómo realizar una búsqueda por similitud vectorial
Figura 1: Cómo realizar una búsqueda de similitud vectorial
La capacidad de almacenar, indexar y buscar incrustaciones vectoriales es la funcionalidad principal de las bases de datos vectoriales. Actualmente, las principales bases de datos vectoriales se dividen en dos categorías. La primera categoría amplía los productos de bases de datos relacionales existentes, como Amazon OpenSearch Service con el complemento KNN y Amazon RDS para PostgreSQL con la extensión pgvector. La segunda categoría comprende productos especializados de bases de datos vectoriales, incluidos ejemplos bien conocidos como Milvus, Zilliz Cloud (el Milvus totalmente gestionado), Pinecone, Weaviate, Qdrant y Chroma.
Las técnicas de incrustación y las bases de datos vectoriales tienen amplias aplicaciones en diversos casos de uso impulsados por la IA, como la búsqueda por similitud de imágenes, la deduplicación y el análisis de vídeos, el procesamiento del lenguaje natural, los sistemas de recomendación, la publicidad dirigida, la búsqueda personalizada, el servicio inteligente de atención al cliente y la detección de fraudes.
Milvus es una de las opciones de código abierto más populares entre las numerosas bases de datos vectoriales. Este post presenta Milvus y explora la práctica de implementar Milvus en AWS EKS.
¿Qué es Milvus?
Milvus es una base de datos vectorial de código abierto, nativa en la nube, altamente flexible, fiable y ultrarrápida. Potencia la búsqueda de similitud vectorial y las aplicaciones de IA y se esfuerza por hacer que las bases de datos vectoriales sean accesibles para todas las organizaciones. Milvus puede almacenar, indexar y gestionar más de mil millones de incrustaciones vectoriales generadas por redes neuronales profundas y otros modelos de aprendizaje automático (ML).
Milvus se publicó bajo la Licencia Apache 2.0 de código abierto en octubre de 2019. Actualmente es un proyecto de posgrado bajo LF AI & Data Foundation. En el momento de escribir este blog, Milvus había alcanzado más de 50 millones de descargas de Docker pull y era utilizado por muchos clientes, como NVIDIA, AT&T, IBM, eBay, Shopee y Walmart.
Características principales de Milvus
Como base de datos vectorial nativa de la nube, Milvus cuenta con las siguientes características clave:
Alto rendimiento y búsqueda en milisegundos en conjuntos de datos vectoriales a escala de miles de millones.
Soporte multilingüe y cadena de herramientas.
Escalabilidad horizontal y alta fiabilidad incluso en caso de interrupción.
Búsqueda híbrida, lograda combinando el filtrado escalar con la búsqueda de similitud vectorial.
Arquitectura de Milvus
Milvus sigue el principio de separar el flujo de datos del flujo de control. El sistema se divide en cuatro niveles, como se muestra en el diagrama:
Arquitectura de Milvus
Figura 2 Arquitectura de Milvus
Capa de acceso: La capa de acceso está compuesta por un grupo de proxies sin estado y sirve como capa frontal del sistema y punto final para los usuarios.
Servicio de coordinación: El servicio coordinador asigna tareas a los nodos trabajadores.
Nodos trabajadores: Los nodos trabajadores son ejecutores tontos que siguen instrucciones del servicio coordinador y ejecutan comandos DML/DDL activados por el usuario.
Almacenamiento: El almacenamiento es responsable de la persistencia de los datos. Comprende un metaalmacenamiento, un corredor de registros y un almacenamiento de objetos.
Opciones de despliegue de Milvus
Milvus admite tres modos de ejecución: Milvus Lite, Independiente y Distribuido.
Milvus Lite es una biblioteca Python que puede importarse en aplicaciones locales. Como versión ligera de Milvus, es ideal para la creación rápida de prototipos en cuadernos Jupyter o para su ejecución en dispositivos inteligentes con recursos limitados.
Milvus Standalone esuna implementación de servidor de una sola máquina. Si tiene una carga de trabajo de producción pero prefiere no usar Kubernetes, ejecutar Milvus Standalone en una sola máquina con suficiente memoria es una buena opción.
Milvus Distributed puede desplegarse en clústeres Kubernetes. Soporta conjuntos de datos más grandes, mayor disponibilidad y escalabilidad, y es más adecuado para entornos de producción.
Milvus está diseñado desde el principio para soportar Kubernetes, y puede desplegarse fácilmente en AWS. Podemos utilizar Amazon Elastic Kubernetes Service (Amazon EKS) como Kubernetes administrado, Amazon S3 como almacenamiento de objetos, Amazon Managed Streaming para Apache Kafka (Amazon MSK) como almacenamiento de mensajes y Amazon Elastic Load Balancing (Amazon ELB) como balanceador de carga para crear un clúster de base de datos Milvus fiable y elástico.
A continuación, proporcionaremos una guía paso a paso sobre la implementación de un clúster Milvus utilizando EKS y otros servicios.
Implementación de Milvus en AWS EKS
Requisitos previos
Utilizaremos AWS CLI para crear un clúster EKS e implementar una base de datos Milvus. Se requieren los siguientes prerrequisitos:
Un PC/Mac o una instancia de Amazon EC2 con AWS CLI instalado y configurado con los permisos adecuados. Las herramientas de AWS CLI están instaladas por defecto si utiliza Amazon Linux 2 o Amazon Linux 2023.
Herramientas EKS instaladas, incluidas Helm, Kubectl, eksctl, etc.
Un bucket de Amazon S3.
Una instancia de Amazon MSK.
Consideraciones al crear MSK
- La última versión estable de Milvus (v2.3.13) depende de la función
autoCreateTopics
de Kafka. Por lo tanto, al crear MSK, debemos utilizar una configuración personalizada y cambiar la propiedadauto.create.topics.enable
de la predeterminadafalse
atrue
. Además, para aumentar el rendimiento de mensajes de MSK, se recomienda aumentar los valores demessage.max.bytes
yreplica.fetch.max.bytes
. Consulte Configuraciones MSK personalizadas para obtener más detalles.
auto.create.topics.enable=true
message.max.bytes=10485880
replica.fetch.max.bytes=20971760
- Milvus no soporta la autenticación basada en roles IAM de MSK. Por lo tanto, al crear MSK, habilite la opción
SASL/SCRAM authentication
en la configuración de seguridad, y configureusername
ypassword
en el Administrador de Secretos de AWS. Consulte Autenticación de credenciales de inicio de sesión con AWS Secrets Manager para obtener más detalles.
Figura 3 Configuración de seguridad : habilitar autenticación SASL SCRAM.png
Figura 3: Configuración de seguridad: habilitar autenticación SASL/SCRAM
- Debemos habilitar el acceso al grupo de seguridad MSK desde el grupo de seguridad o el rango de direcciones IP del clúster EKS.
Creación de un clúster EKS
Hay muchas formas de crear un cluster EKS, como por ejemplo a través de la consola, CloudFormation, eksctl, etc. Este post mostrará cómo crear un clúster EKS utilizando eksctl.
eksctl
es una sencilla herramienta de línea de comandos para crear y administrar clústeres Kubernetes en Amazon EKS. Proporciona la forma más rápida y sencilla de crear un nuevo clúster con nodos para Amazon EKS. Consulte el sitio web de eksctl para obtener más información.
- En primer lugar, cree un archivo
eks_cluster.yaml
con el siguiente fragmento de código. Sustituyacluster-name
por el nombre de su clúster, sustituyaregion-code
por la región de AWS en la que desea crear el clúster y sustituyaprivate-subnet-idx
por sus subredes privadas. Nota: Este archivo de configuración crea un clúster EKS en una VPC existente especificando subredes privadas. Si desea crear una nueva VPC, elimine la configuración de VPC y subredes y, a continuación,eksctl
creará automáticamente una nueva.
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
- A continuación, ejecute el comando
eksctl
para crear el clúster EKS.
eksctl create cluster -f eks_cluster.yaml
Este comando creará los siguientes recursos:
Un clúster EKS con la versión especificada.
Un grupo de nodos gestionados con tres instancias EC2 m6i.2xlarge.
Un proveedor de identidad IAM OIDC y una ServiceAccount llamada
aws-load-balancer-controller
, que utilizaremos más adelante cuando instalemos el AWS Load Balancer Controller.Un espacio de nombres
milvus
y una ServiceAccountmilvus-s3-access-sa
dentro de este espacio de nombres. Este espacio de nombres se utilizará más adelante cuando configuremos S3 como almacenamiento de objetos para Milvus.Nota: Para simplificar, a
milvus-s3-access-sa
se le conceden permisos completos de acceso a S3. En despliegues de producción, se recomienda seguir el principio del menor privilegio y sólo conceder acceso al cubo S3 específico utilizado para Milvus.Múltiples complementos, donde
vpc-cni
,coredns
,kube-proxy
son complementos básicos requeridos por EKS.aws-ebs-csi-driver
es el controlador CSI de AWS EBS que permite a los clústeres EKS gestionar el ciclo de vida de los volúmenes de Amazon EBS.
Ahora sólo tenemos que esperar a que se complete la creación del clúster.
Esperar a que se complete la creación del clúster. Durante el proceso de creación del clúster, el archivo kubeconfig
se creará o actualizará automáticamente. También puede actualizarlo manualmente ejecutando el siguiente comando. Asegúrese de sustituir region-code
por la región de AWS en la que se está creando el clúster y cluster-name
por el nombre del clúster.
aws eks update-kubeconfig --region <region-code> --name <cluster-name>
Una vez creado el clúster, puede ver los nodos ejecutando:
kubectl get nodes -A -o wide
- Crear un
ebs-sc
StorageClass configurado con GP3 como tipo de almacenamiento, y establecerlo como StorageClass por defecto. Milvus utiliza etcd como su Meta Storage y necesita esta StorageClass para crear y administrar PVCs.
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
A continuación, establezca la StorageClass original de gp2
como no predeterminada:
kubectl patch storageclass gp2 -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"false"}}}'
- Instala el AWS Load Balancer Controller. Utilizaremos este controlador más adelante para el Servicio Milvus y Attu Ingress, así que vamos a instalarlo de antemano.
- Primero, añade el repo
eks-charts
y actualízalo.
helm repo add eks https://aws.github.io/eks-charts
helm repo update
- Luego, instala el AWS Load Balancer Controller. Sustituye
cluster-name
por el nombre de tu clúster. La ServiceAccount denominadaaws-load-balancer-controller
ya se creó cuando creamos el clúster EKS en los pasos anteriores.
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
- Compruebe si el controlador se ha instalado correctamente.
kubectl get deployment -n kube-system aws-load-balancer-controller
- El resultado debería ser el siguiente:
NAME READY UP-TO-DATE AVAILABLE AGE
aws-load-balancer-controller 2/2 2 2 12m
Desplegando un Cluster Milvus
Milvus soporta múltiples métodos de despliegue, como Operator y Helm. Operator es más simple, pero Helm es más directo y flexible. Usaremos Helm para desplegar Milvus en este ejemplo.
Al desplegar Milvus con Helm, puede personalizar la configuración a través del archivo values.yaml
. Haga clic en values.yaml para ver todas las opciones. Por defecto, Milvus crea en el cluster minio y pulsar como Almacenamiento de Objetos y Almacenamiento de Mensajes, respectivamente. Vamos a hacer algunos cambios de configuración para que sea más adecuado para la producción.
- En primer lugar, añada el repositorio Milvus Helm y actualícelo.
helm repo add milvus https://zilliztech.github.io/milvus-helm/
helm repo update
- Cree un archivo
milvus_cluster.yaml
con el siguiente fragmento de código. Este fragmento de código personaliza la configuración de Milvus, como la configuración de Amazon S3 como almacenamiento de objetos y Amazon MSK como cola de mensajes. Proporcionaremos explicaciones detalladas y orientación sobre la configuración más adelante.
#####################################
# 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
El código contiene seis secciones. Sigue las siguientes instrucciones para cambiar las configuraciones correspondientes.
Sección 1: Configurar S3 como almacenamiento de objetos. El serviceAccount concede a Milvus acceso a S3 (en este caso, es milvus-s3-access-sa
, que se creó cuando creamos el cluster EKS). Asegúrese de sustituir <region-code>
por la región de AWS en la que se encuentra su clúster. Sustituya <bucket-name>
por el nombre de su bucket de S3 y <root-path>
por el prefijo del bucket de S3 (este campo puede dejarse vacío).
Sección 2: Configure MSK como almacenamiento de mensajes. Sustituya <broker-list>
por las direcciones de endpoint correspondientes al tipo de autenticación SASL/SCRAM de MSK. Sustituya <username>
y <password>
por el nombre de usuario y la contraseña de la cuenta MSK. Puede obtener <broker-list>
de la información del cliente MSK, como se muestra en la imagen siguiente.
Figura 4 Configurar MSK como almacenamiento de mensajes de Milvus.png
Figura 4: Configurar MSK como almacenamiento de mensajes de Milvus
Sección 3: Exponer el servicio Milvus y permitir el acceso desde fuera del cluster. El punto final de Milvus utiliza el servicio de tipo ClusterIP por defecto, que sólo es accesible dentro del clúster EKS. Si es necesario, puede cambiarlo a tipo LoadBalancer para permitir el acceso desde fuera del cluster EKS. El servicio de tipo LoadBalancer utiliza Amazon NLB como balanceador de carga. De acuerdo con las mejores prácticas de seguridad, aws-load-balancer-scheme
está configurado como modo interno por defecto aquí, lo que significa que sólo se permite el acceso a Milvus desde la intranet. Haga clic para ver las instrucciones de configuración de NLB.
Sección 4: Instale y configure Attu, una herramienta de administración de milvus de código abierto. Tiene una GUI intuitiva que le permite interactuar fácilmente con Milvus. Habilitamos Attu, configuramos el ingreso utilizando AWS ALB y lo configuramos en el tipo internet-facing
para que se pueda acceder a Attu a través de Internet. Haga clic en este documento para obtener la guía de configuración de ALB.
Sección 5: Habilitar el despliegue en HA de los componentes principales de Milvus. Milvus contiene múltiples componentes independientes y desacoplados. Por ejemplo, el servicio coordinador actúa como capa de control, gestionando la coordinación para los componentes Raíz, Consulta, Datos e Índice. El Proxy en la capa de acceso sirve como punto final de acceso a la base de datos. Por defecto, estos componentes sólo tienen una réplica de pod. El despliegue de múltiples réplicas de estos componentes de servicio es especialmente necesario para mejorar la disponibilidad de Milvus.
Nota: El despliegue de múltiples réplicas de los componentes coordinadores de Raíz, Consulta, Datos e Índice requiere la opción activeStandby
activada.
Sección 6: Ajuste la asignación de recursos para los componentes de Milvus para satisfacer los requisitos de sus cargas de trabajo. El sitio web de Milvus también proporciona una herramienta de dimensionamiento para generar sugerencias de configuración basadas en el volumen de datos, dimensiones del vector, tipos de índice, etc. También puede generar un archivo de configuración Helm con un solo clic. La siguiente configuración es la sugerencia dada por la herramienta para 1 millón de vectores de 1024 dimensiones y tipo de índice HNSW.
- Utilice Helm para crear Milvus (desplegado en el espacio de nombres
milvus
). Nota: Puede sustituir<demo>
por un nombre personalizado.
helm install <demo> milvus/milvus -n milvus -f milvus_cluster.yaml
- Ejecute el siguiente comando para comprobar el estado del despliegue.
kubectl get deployment -n milvus
La siguiente salida muestra que los componentes de Milvus están todos DISPONIBLES, y los componentes de coordinación tienen múltiples réplicas habilitadas.
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
Acceso y gestión de Milvus
Hasta ahora, hemos desplegado con éxito la base de datos vectorial Milvus. Ahora, podemos acceder a Milvus a través de puntos finales. Milvus expone puntos finales a través de servicios Kubernetes. Attu expone puntos finales a través de Kubernetes Ingress.
Acceso a los puntos finales de Milvus
Ejecute el siguiente comando para obtener los puntos finales del servicio:
kubectl get svc -n milvus
Puede ver varios servicios. Milvus admite dos puertos, el puerto 19530
y el puerto 9091
:
- El puerto
19530
es para gRPC y RESTful API. Es el puerto por defecto cuando se conecta a un servidor Milvus con diferentes Milvus SDKs o clientes HTTP. - El puerto
9091
es un puerto de gestión para la recopilación de métricas, perfiles pprof y sondas de salud dentro de Kubernetes.
El servicio demo-milvus
proporciona un punto final de acceso a la base de datos, que se utiliza para establecer una conexión desde los clientes. Utiliza NLB como equilibrador de carga del servicio. Puede obtener el punto final del servicio en la columna 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
Gestión de Milvus con Attu
Como se ha descrito anteriormente, hemos instalado Attu para gestionar Milvus. Ejecute el siguiente comando para obtener el endpoint:
kubectl get ingress -n milvus
Puede ver un Ingress llamado demo-milvus-attu
, donde la columna ADDRESS
es la URL de acceso.
NAME CLASS HOSTS ADDRESS PORTS AGE
demo-milvus-attu <none> * k8s-attu-xxxx.us-west-2.elb.amazonaws.com 80 27s
Abra la dirección Ingress en un navegador y vea la siguiente página. Haga clic en Conectar para iniciar sesión.
Figura 5 Inicie sesión en su cuenta Attu.png
Figura 5: Inicie sesión en su cuenta de Attu
Después de iniciar sesión, puede gestionar las bases de datos de Milvus a través de Attu.
Figura 6 La interfaz de Attu.png
Figura 6: La interfaz de Attu
Probar la base de datos vectorial Milvus
Utilizaremos el código de ejemplo de Milvus para probar si la base de datos Milvus funciona correctamente. En primer lugar, descargue el código de ejemplo hello_milvus.py
utilizando el siguiente comando:
wget https://raw.githubusercontent.com/milvus-io/pymilvus/master/examples/hello_milvus.py
Modifique el host en el código de ejemplo al punto final del servicio Milvus.
print(fmt.format("start connecting to Milvus"))
connections.connect("default", host="milvus-nlb-xxx.elb.us-west-2.amazonaws.com", port="19530")
Ejecute el código:
python3 hello_milvus.py
Si el sistema devuelve el siguiente resultado, indica que Milvus funciona con normalidad.
=== 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 ===
Conclusión
Este post presenta Milvus, una de las bases de datos vectoriales de código abierto más populares, y proporciona una guía sobre el despliegue de Milvus en AWS utilizando servicios gestionados como Amazon EKS, S3, MSK y ELB para lograr una mayor elasticidad y fiabilidad.
Como componente central de varios sistemas GenAI, en particular Retrieval Augmented Generation (RAG), Milvus admite y se integra con una variedad de modelos y marcos GenAI principales, incluidos Amazon Sagemaker, PyTorch, HuggingFace, LlamaIndex y LangChain. Comience hoy mismo su viaje hacia la innovación GenAI con Milvus.
Referencias
- Visión general de las incrustaciones vectoriales y las bases de datos vectoriales
- ¿Qué es Milvus?
- Implementación de Milvus en AWS EKS
- Probar la base de datos vectorial Milvus
- Conclusión
- Referencias
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