🚀 Prueba Zilliz Cloud, el Milvus completamente gestionado, gratis—¡experimenta un rendimiento 10 veces más rápido! Prueba Ahora>>

milvus-logo
LFAI
  • Home
  • Blog
  • Cómo implementar la base de datos vectorial Milvus de código abierto en Amazon EKS

Cómo implementar la base de datos vectorial Milvus de código abierto en Amazon EKS

  • Engineering
August 09, 2024
AWS

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.

How to perform a vector similarity search 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:

Milvus Architecture 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 propiedad auto.create.topics.enable de la predeterminada false a true. Además, para aumentar el rendimiento de mensajes de MSK, se recomienda aumentar los valores de message.max.bytes y replica.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 configure username y password 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.

Figure 3 Security settings enable SASL SCRAM authentication.png 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.

  1. En primer lugar, cree un archivo eks_cluster.yaml con el siguiente fragmento de código. Sustituya cluster-name por el nombre de su clúster, sustituya region-code por la región de AWS en la que desea crear el clúster y sustituya private-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
  1. 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 ServiceAccount milvus-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
  1. 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"}}}'
  1. 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 denominada aws-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.

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

Figure 4 Configure MSK as the Message Storage of Milvus.png 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.

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

Figure 5 Log in to your Attu account.png 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.

Figure 6 The Attu interface.png 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

Like the article? Spread the word

Sigue Leyendo