Configuración de Milvus en Amazon EKS
Milvus está diseñado desde el principio para admitir Kubernetes y puede implementarse fácilmente en AWS. Para crear un clúster de base de datos vectorial Milvus fiable y elástico, podemos usar Amazon Elastic Kubernetes Service (Amazon EKS) como Kubernetes administrado, Amazon S3 como almacenamiento de objetos, Amazon Managed Streaming for Apache Kafka (Amazon MSK) como almacenamiento de mensajes y Amazon Elastic Load Balancing (Amazon ELB) como balanceador de carga.
Descripción general de la arquitectura de Milvus
Arquitectura de Milvus
EKS es el servicio Kubernetes administrado de Amazon que se ejecuta en EC2 o sin servidor en Fargate. Es ideal para organizaciones que ya usan Kubernetes localmente, ya que les permite migrar sus implementaciones a AWS con cambios mínimos.
Este blog utiliza EC2 para la implementación porque Fargate no puede gestionar las reclamaciones de volúmenes persistentes (PVC) necesarias para las dependencias de Milvus, como etcd.
Proporcionaremos una guía paso a paso sobre cómo implementar un clúster de Milvus usando EKS y otros servicios. Una versión más detallada de este blog está disponible aquí.
Requisitos previos
AWS CLI
Instala AWS CLI en tu PC/Mac local o instancia de Amazon EC2, que servirá como tu endpoint para las operaciones cubiertas en este documento. Si usas Amazon Linux 2 o Amazon Linux 2023, las herramientas de AWS CLI están instaladas de forma predeterminada. Consulta Cómo instalar AWS CLI.
A continuación se muestra una captura de pantalla que verifica que AWS CLI está instalado.
% which aws
/usr/local/bin/aws
% aws --version
aws-cli/2.15.34 Python/3.11.8 Darwin/23.5.0 exe/x86_64 prompt/off
Herramientas de EKS: Kubectl, eksctl, helm
Instala las herramientas de EKS en el dispositivo endpoint preferido, incluidas:
Consulta Introducción a EKS para conocer los pasos detallados de instalación. A continuación se muestra una captura de pantalla que verifica las instalaciones y versiones en una laptop Mac M2 usando z shell:
% kubectl version
Client Version: v1.30.2
Kustomize Version: v5.0.4-0.20230601165947-6ce0bf390ce3
# Download eksctl
ARCH=arm64
PLATFORM=$(uname -s)_$ARCH
curl -sLO "https://github.com/eksctl-io/eksctl/releases/latest/download/eksctl_$PLATFORM.tar.gz"
tar -xzf eksctl_$PLATFORM.tar.gz -C /tmp && rm eksctl_$PLATFORM.tar.gz
sudo mv /tmp/eksctl /usr/local/bin
% eksctl version
0.185.0
% helm list --all-namespaces
NAME NAMESPACE REVISION UPDATED STATUS CHART APP VERSION
my-milvus default 1 2024-07-09 16:00:14.117945 -0700 PDT deployed milvus-4.1.34 2.4.5
Crear un bucket de Amazon S3
Lee las reglas de nomenclatura de buckets y obsérvalas al nombrar tu bucket de AWS S3 usando la consola de AWS.
Crear un bucket de Amazon S3
Crear una clave administrada por el cliente de KMS.
La clave de KMS no puede ser una clave administrada por AWS. Debe ser una clave administrada por el cliente. Después de crearla, deberás esperar unos 10 minutos para que la clave se active antes de poder usarla en AWS Secrets Manager. Usando la consola de AWS, ve a KMS > Customer managed keys.
Crear una clave administrada por el cliente de KMS. .png
Crear un secreto personalizado en AWS Secrets Manager.
Asegúrate de haber esperado unos 10 minutos después de crear tu clave administrada por el cliente de KMS. Ahora, crea un nuevo secreto de AWS Secrets Manager. Usando la consola de AWS.
Elige otro tipo de secreto para el tipo de secreto.
Cambia el editor de pares clave/valor a Texto sin formato. Introduce JSON con claves que coincidan exactamente con “username” y “password”.
El nombre del secreto debe comenzar con AmazonMSK_.
La clave de cifrado debe ser una clave administrada por el cliente de KMS, no una clave administrada por AWS.
Crear un secreto personalizado en AWS Secrets Manager. .png
Crear una instancia de MSK
A continuación, utiliza la consola de AWS para crear un clúster de Amazon MSK con la función autoCreateTopics de Kafka y la seguridad SASL/SCRAM habilitadas.
Consideraciones al crear MSK:
La última versión estable de Milvus (v2.4.x) depende de la función autoCreateTopics de Kafka, por lo que al crear MSK, se debe usar una configuración personalizada, así como cambiar la propiedad auto.create.topics.enable del valor predeterminado 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.
auto.create.topics.enable=true
message.max.bytes=10485880
replica.fetch.max.bytes=20971760
Consulta las configuraciones personalizadas de MSK para obtener más detalles.
Crear una instancia de MSK.png
Milvus no admite la autenticación basada en roles de IAM para MSK, por lo que al crear MSK, habilita la opción de autenticación SASL/SCRAM en la configuración de seguridad y configura el nombre de usuario y la contraseña en AWS Secrets Manager. Consulta Autenticación con credenciales de inicio de sesión con AWS Secrets Manager para obtener más detalles.
El grupo de seguridad para MSK debe permitir el acceso desde el grupo de seguridad o el rango de direcciones IP del clúster de EKS.
configuración de seguridad
Espera ~15 minutos para que la instancia de MSK se aprovisione. Una vez que esté lista, haz clic en ella y podrás asociar el secreto personalizado de AWS Secrets Manager que creaste anteriormente.
AWS Secrets Manager
Crear un clúster de Amazon EKS
Hay muchas formas de crear un clúster de EKS, como mediante la consola, CloudFormation o eksctl. Consulta el documento Configuración para usar Amazon EKS.
Esta publicación usará eksctl. eksctl es una herramienta sencilla de línea de comandos para crear y administrar clústeres de Kubernetes en Amazon EKS. eksctl proporciona la forma más rápida y sencilla de crear un nuevo clúster con nodos para Amazon EKS. Para obtener más información, consulta la documentación oficial de eksctl.
Paso 1: Crea un archivo eks_cluster.yaml.
Consulta la documentación de Milvus para ver un ejemplo de archivo .yaml.
Reemplaza el nombre del clúster con el nombre de tu clúster,
Reemplaza region-code con la región de AWS donde deseas crear el clúster.
Reemplaza private-subnet-idx con tus subredes privadas. Nota: Este archivo de configuración crea un clúster de EKS en una VPC existente especificando subredes privadas. También puedes eliminar la configuración de VPC y subredes para que eksctl cree automáticamente una nueva VPC.
**Paso 2: Ejecuta el comando create cluster -f eks_cluster.yaml de eksctl para crear el clúster de EKS. **
create cluster -f eks_cluster.yaml
Consulta Inicio rápido de Amazon EKS. Este comando creará los siguientes recursos:
Un clúster de EKS con la versión especificada.
Un grupo de nodos administrado con 3 instancias EC2 m6i.2xlarge.
Un proveedor de identidad OIDC de IAM y una ServiceAccount llamada aws-load-balancer-controller se usarán más adelante al instalar el AWS Load Balancer Controller.
Un namespace milvus y una ServiceAccount milvus-s3-access-sa dentro de este namespace. Esto se utilizará más adelante al configurar S3 como el almacenamiento de objetos para Milvus.
Nota: Para simplificar, a milvus-s3-access-sa se le conceden permisos de acceso completo a S3. En implementaciones de producción, se recomienda seguir el principio de privilegio mínimo y conceder acceso únicamente al bucket de S3 específico utilizado para Milvus.
- Múltiples add-ons, donde vpc-cni, coredns, kube-proxy son add-ons principales requeridos por EKS. aws-ebs-csi-driver es el controlador AWS EBS CSI que permite a los clústeres de EKS gestionar el ciclo de vida de los volúmenes de Amazon EBS.
% eksctl create cluster -f eks_cluster.yaml
2024-07-10 17:45:32 [ℹ] eksctl version 0.185.0
2024-07-10 17:45:32 [ℹ] using region us-west-2
2024-07-10 17:45:32 [✔] using existing VPC (vpc-84c5b3fc) and
…
2024-07-10 17:45:32 [ℹ] building cluster stack "eksctl-MilvusEKSTest-cluster"
2024-07-10 17:45:33 [ℹ] deploying stack
…
Espera a que se complete la creación del clúster. Al completarse, deberías ver una respuesta como la siguiente salida:
% EKS cluster "MilvusEKSTest" in "us-west-2" region is ready
Una vez creado el clúster, puedes ver los nodos ejecutando:
% kubectl get nodes -A -o wide
NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME
ip-172-31-22-240.us-west-2.compute.internal Ready <none> 11m v1.28.8-eks-ae9a62a 172.31.22.240 52.40.226.172 Amazon Linux 2 5.10.219-208.866.amzn2.x86_64 containerd://1.7.11
ip-172-31-31-71.us-west-2.compute.internal Ready <none> 11m v1.28.8-eks-ae9a62a 172.31.31.71 35.165.133.62 Amazon Linux 2 5.10.219-208.866.amzn2.x86_64 containerd://1.7.11
ip-172-31-33-44.us-west-2.compute.internal Ready <none> 11m v1.28.8-eks-ae9a62a 172.31.33.44 35.91.5.162 Amazon Linux 2 5.10.219-208.866.amzn2.x86_64 containerd://1.7.11
Paso 3: Crea una ebs-sc StorageClass configurada con GP3 como tipo de almacenamiento y establécela como la StorageClass predeterminada.
Milvus usa etcd como Meta Storage y necesita esta StorageClass para crear y gestionar PVCs.
- Ejecuta este comando cat.
% cat <<EOF | kubectl apply -f -
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: ebs-sc
provisioner: ebs.csi.aws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
type: gp3
EOF
storageclass.storage.k8s.io/ebs-sc created
- Ejecuta un comando patch después de la creación para convertir esta StorageClass en la predeterminada.
% kubectl patch storageclass gp2 -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"false"}}}'
storageclass.storage.k8s.io/gp2 patched
- Verifica que la clase de almacenamiento se haya configurado correctamente.
% kubectl get storageclass
NAME PROVISIONER RECLAIMPOLICY VOLUMEBINDINGMODE ALLOWVOLUMEEXPANSION AGE
ebs-sc ebs.csi.aws.com Delete WaitForFirstConsumer false 6m39s
gp2 kubernetes.io/aws-ebs Delete WaitForFirstConsumer false 44m
Paso 4: Instala el AWS Load Balancer Controller
Esto se utilizará más adelante para el Milvus Service y el Attu Ingress. Consulta las instrucciones oficiales del EKS Load Balancer Controller.
Añade el repo eks-charts y actualízalo.
% helm repo add eks https://aws.github.io/eks-charts
"eks" has been added to your repositories
% helm repo update
Hang tight while we grab the latest from your chart repositories...
...Successfully got an update from the "eks" chart repository
...Successfully got an update from the "zilliztech" chart repository
...Successfully got an update from the "milvus" chart repository
Update Complete. ⎈Happy Helming!⎈
Instala el AWS Load Balancer Controller. Reemplaza cluster-name con el nombre de tu clúster. La ServiceAccount llamada aws-load-balancer-controller ya se creó cuando se creó el clúster de EKS.
% helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
-n kube-system \
--set clusterName=MilvusEKSTest \
--set serviceAccount.create=false \
--set serviceAccount.name=aws-load-balancer-controller
NAME: aws-load-balancer-controller
LAST DEPLOYED: Wed Jul 10 19:00:34 2024
NAMESPACE: kube-system
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
AWS Load Balancer controller installed!
Verifica si el controller se instaló correctamente. La salida debería verse así:
% kubectl get deployment -n kube-system aws-load-balancer-controller
NAME READY UP-TO-DATE AVAILABLE AGE
aws-load-balancer-controller 2/2 2 2 88s
Despliega un clúster de Milvus en Amazon EKS
Milvus admite múltiples métodos de despliegue, como Operator y Helm. Usar Operator es más sencillo, pero Helm es más directo y flexible. Por eso usamos Helm para el despliegue.
Puedes personalizar la configuración mediante los valores al desplegar Milvus con el archivo milvus_helm.yaml.
De forma predeterminada, Milvus crea minio y pulsar dentro del clúster como Object Storage y Message Storage, respectivamente. Haremos algunos cambios de configuración para que sea más adecuado para producción.
Paso 1: Agrega el repositorio Helm de Milvus y actualízalo.
% helm repo add milvus https://zilliztech.github.io/milvus-helm/
helm repo update
"milvus" already exists with the same configuration, skipping
Hang tight while we grab the latest from your chart repositories...
...Successfully got an update from the "eks" chart repository
...Successfully got an update from the "zilliztech" chart repository
...Successfully got an update from the "milvus" chart repository
Update Complete. ⎈Happy Helming!⎈
Paso 2: Crea un archivo milvus_cluster.yaml.
El siguiente código personaliza la instalación de Milvus, como configurar Amazon S3 como almacenamiento de objetos, Amazon MSK como cola de mensajes, etc. Proporcionaremos explicaciones detalladas y orientación de configuración después del bloque de código.
#####################################
# 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
# Kafka externo
# - estas configuraciones solo se usan cuando `externalKafka.enabled` es true
externalKafka:
enabled: true
brokerList: "<broker-list>"
securityProtocol: SASL_SSL
sasl:
mechanisms: SCRAM-SHA-512
username: "<username>"
password: "<password>"
#####################################
# Sección 3
#
# Exponga el servicio Milvus para que se pueda acceder a él desde fuera del clúster (servicio LoadBalancer).
# o acceda a él desde dentro del clúster (servicio ClusterIP). Establezca el tipo de servicio y el puerto para servirlo.
#####################################
service:
type: LoadBalancer
port: 19530
annotations:
service.beta.kubernetes.io/aws-load-balancer-type: external #AWS Load Balancer Controller satisface los servicios que tienen esta anotación
service.beta.kubernetes.io/aws-load-balancer-name : milvus-service #Nombre definido por el usuario dado a AWS Network Load Balancer
#service.beta.kubernetes.io/aws-load-balancer-scheme: internal # interno o orientado a Internet, lo que permite posteriormente el acceso público a través de Internet
service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing" #Coloca el balanceador de carga en subredes públicas
service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: ip #Las IP de los pods deben usarse como IP de destino (en lugar de las IP de los nodos)
#####################################
# Sección 4
#
# Instalación de Attu, la GUI de administración de Milvus
#####################################
attu:
enabled: true
name: attu
service:
annotations:
service.beta.kubernetes.io/aws-load-balancer-type: external
service.beta.kubernetes.io/aws-load-balancer-name : milvus-attu-service
service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing"
service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: ip
labels: {}
type: LoadBalancer
port: 3000
ingress:
enabled: false
#####################################
# Sección 5
#
# Implementación HA de los componentes principales de Milvus
#####################################
rootCoordinator:
replicas: 2
activeStandby:
enabled: true # Habilite active-standby cuando establezca varias réplicas para el coordinador raíz
resources:
limits:
cpu: 1
memory: 2Gi
indexCoordinator:
replicas: 2
activeStandby:
enabled: true # Habilite active-standby cuando establezca varias réplicas para el coordinador de índices
resources:
limits:
cpu: "0.5"
memory: 0.5Gi
queryCoordinator:
replicas: 2
activeStandby:
enabled: true # Habilite active-standby cuando establezca varias réplicas para el coordinador de consultas
resources:
limits:
cpu: "0.5"
memory: 0.5Gi
dataCoordinator:
replicas: 2
activeStandby:
enabled: true # Habilite active-standby cuando establezca varias réplicas para el coordinador de datos
resources:
limits:
cpu: "0.5"
memory: 0.5Gi
proxy:
replicas: 2
resources:
limits:
cpu: 1
memory: 4Gi
#####################################
# Sección 6
#
# Asignación de recursos de Milvus
#####################################
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 se divide en seis secciones. Siga las siguientes instrucciones para cambiar las configuraciones correspondientes.
Sección 1: Configure S3 como el almacenamiento de objetos. serviceAccount concede a Milvus acceso a S3 (aquí es milvus-s3-access-sa, que ya se creó al crear el clúster EKS).
Reemplace <region-code> por la región de AWS donde creó el clúster.
Reemplace <bucket-name> por el nombre del bucket de S3 y <root-path> por el prefijo del bucket de S3 (puede estar vacío).
Sección 2: Configure MSK como el almacenamiento de mensajes.
- Reemplace <broker-list> por el endpoint de MSK para el tipo de autenticación SASL/SCRAM, y
y por el nombre de usuario y la contraseña de MSK. Puede obtener <broker-list> desde la información del cliente de MSK, como se muestra en la imagen.
- Reemplace <broker-list> por el endpoint de MSK para el tipo de autenticación SASL/SCRAM, y
view client information.jpg
Sección 3: Esta sección expone el endpoint del servicio de Milvus para que se pueda acceder a él desde fuera del clúster. De forma predeterminada, el endpoint de Milvus usa el servicio de tipo ClusterIP, que solo es accesible dentro del clúster de EKS. Puede cambiarlo al tipo LoadBalancer si es necesario para permitir el acceso desde fuera del clúster de EKS. El Service de tipo LoadBalancer usa Amazon NLB como balanceador de carga.
De acuerdo con las mejores prácticas de seguridad, aws-load-balancer-scheme se configura aquí en modo interno de forma predeterminada, lo que significa que solo se permite el acceso de intranet a Milvus. Si realmente necesita acceso a Milvus desde Internet, debe cambiar internal a internet-facing. Haga clic para ver las instrucciones de configuración de NLB.
- Cambie la línea a:
aws-load-balancer-scheme: internet-facing
- Cambie la línea a:
# service.beta.kubernetes.io/aws-load-balancer-scheme: internal
service.beta.kubernetes.io/aws-load-balancer-scheme: "internet-facing"
Sección 4: Instale y configure Attu, que es una herramienta de administración de Milvus de código abierto. Tiene una GUI intuitiva que le permite interactuar fácilmente con la base de datos. Habilitamos Attu, configuramos ingress usando AWS ALB y lo establecemos en tipo internet-facing para que se pueda acceder a Attu a través de Internet.
- Haga clic aquí para ver la guía de configuración de ALB.
Sección 5: Habilite el despliegue HA de los componentes principales de Milvus. Según la arquitectura, ya sabemos que Milvus contiene múltiples componentes independientes y desacoplados. Por ejemplo, el servicio coordinador actúa como la capa de control, gestionando la coordinación de los componentes Root, Query, Data e Index. El Proxy en la capa de acceso sirve como endpoint de acceso a la base de datos. Estos componentes tienen de forma predeterminada solo 1 réplica de pod. Para mejorar la disponibilidad de Milvus, desplegar múltiples réplicas de estos componentes de servicio es especialmente necesario.
- Tenga en cuenta que los componentes coordinadores Root, Query, Data e Index deben desplegarse en múltiples réplicas con la opción activeStandby habilitada.
Sección 6: Ajuste la asignación de recursos para los componentes de Milvus para cumplir con 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 de vectores, tipos de índice, etc. También puede generar un archivo de configuración de 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.
Use Helm para crear Milvus (desplegado en el namespace milvus).
- Tenga en cuenta que puede reemplazar demo-milvus por un nombre personalizado.
% helm install demo-milvus milvus/milvus -n milvus -f milvus_cluster.yaml
W0710 19:35:08.789610 64030 warnings.go:70] annotation "kubernetes.io/ingress.class" is deprecated, please use 'spec.ingressClassName' instead
NAME: demo-milvus
LAST DEPLOYED: Wed Jul 10 19:35:06 2024
NAMESPACE: milvus
STATUS: deployed
REVISION: 1
TEST SUITE: None
Ejecute el siguiente comando para comprobar el estado del despliegue.
% kubectl get deployment -n milvus
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
La salida anterior muestra que todos los componentes de Milvus están AVAILABLE, y los componentes de coordinación tienen varias réplicas habilitadas.
Acceder y gestionar endpoints de Milvus
Hasta ahora, hemos desplegado correctamente la base de datos Milvus. Ahora podemos acceder a Milvus a través de endpoints. Milvus expone endpoints mediante servicios de Kubernetes. Attu expone endpoints mediante Kubernetes Ingress.
Acceder a los endpoints de Milvus usando servicios de Kubernetes
Ejecuta el siguiente comando para obtener los endpoints de servicio:
% kubectl get svc -n milvus
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
Puedes ver varios servicios. Milvus admite dos puertos, el puerto 19530 y el puerto 9091:
El puerto 19530 es para gRPC y API RESTful. Es el puerto predeterminado cuando te conectas a un servidor Milvus con diferentes SDK de Milvus o clientes HTTP.
El puerto 9091 es un puerto de administración para la recopilación de métricas, el perfilado pprof y las sondas de estado dentro de Kubernetes.
Entre ellos, el servicio demo-milvus proporciona un endpoint de acceso a la base de datos, que se utiliza para establecer una conexión con los clientes. Se accede al endpoint de la base de datos mediante el NLB como balanceador de carga del servicio. Puedes obtener el endpoint del servicio NLB en la columna EXTERNAL-IP.
Toma nota de la columna EXTERNAL-IP del NLB, que en este caso es:
milvus-nlb-xxxx.elb.us-west-2.amazonaws.com 19530:31201/TCP,9091:31088/TCP
Acceder a los endpoints de Milvus usando Attu
Cuando instalamos Milvus, también instalamos Attu, una herramienta de administración para gestionar Milvus. Ejecuta el siguiente comando para obtener el endpoint:
% kubectl get ingress -n milvus
NAME CLASS HOSTS ADDRESS PORTS AGE
demo-milvus-attu <none> * k8s-attu-xxxx.us-west-2.elb.amazonaws.com 80 27s
Deberías ver un ingress llamado demo-milvus-attu, donde la columna ADDRESS es la URL externa.
Abra la dirección de Ingress en un navegador y vea la siguiente página.
Haga clic en Connect para iniciar sesión.
interfaz de attu
Después de iniciar sesión, puede administrar bases de datos Milvus a través de:
administrar Milvus usando Attu
Probar la base de datos vectorial Milvus
Puede usar el código de ejemplo oficial de Milvus para probar si la base de datos Milvus funciona correctamente.
- Paso 1: Descargue directamente el código de ejemplo hello_milvus.py.
% wget https://raw.githubusercontent.com/milvus-io/pymilvus/master/examples/hello_milvus.py
- Paso 2: Modifique el host en el código de ejemplo al endpoint de Milvus Kubernetes que obtuvimos anteriormente.
print(fmt.format("start connecting to Milvus"))
connections.connect(
"default",
host="milvus-nlb-xxx.elb.us-west-2.amazonaws.com",
port="19530")
- Paso 3: Ejecute el código. Si se devuelve el siguiente resultado, Milvus se está ejecutando normalmente.
% python3 hello_milvus.py
=== 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 ===
¡Ahora ha configurado Milvus en EKS con éxito! ¡¡¡FELICITACIONES!!!
Conclusión
Esta publicación presentó la base de datos vectorial de código abierto Milvus y explicó cómo implementarla en AWS usando servicios administrados como Amazon EKS, S3, MSK y ELB para lograr mayor elasticidad y confiabilidad.
Recursos
Blog de AWS Milvus EKS: https://aws.amazon.com/cn/blogs/china/build-open-source-vector-database-milvus-based-on-amazon-eks/
Guía de Milvus EKS: https://milvus.io/docs/eks.md
Guía de configuración de Amazon EKS: https://docs.aws.amazon.com/eks/latest/userguide/setting-up.html
Guía del usuario de Amazon EKS: https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html
Sitio web oficial de Milvus: https://milvus.io/
Github de Milvus: https://github.com/milvus-io/milvus
Sitio web oficial de eksctl: https://eksctl.io/
Archivos YAML que necesitará para la instalación:
Archivo eks_cluster.yaml: https://aws.amazon.com/cn/blogs/china/build-open-source-vector-database-milvus-based-on-amazon-eks/
Archivo milvus_helm.yaml: https://raw.githubusercontent.com/milvus-io/milvus-helm/master/charts/milvus/values.yaml
Archivo milvus_cluster.yaml: Copiar/pegar desde dentro de este blog.
Sigue leyendo
Top 10 Context Engineering Techniques You Should Know for Production RAG
A practical guide to context engineering for production LLM systems, covering RAG, context processing, memory, agents, and multimodal context.
Why and How to Migrate from Self-Hosted Milvus to Zilliz Cloud
A simple, step-by-step guide to migrating from Milvus to Zilliz Cloud. Learn both endpoint and backup methods for a smooth, scalable vector database migration.
Creating Collections in Zilliz Cloud Just Got Way Easier
We've enhanced the entire collection creation experience to bring advanced capabilities directly into the interface, making it faster and easier to build production-ready schemas without switching tools.