Déployer un cluster Milvus sur EKS

Cette rubrique décrit comment déployer un cluster Milvus sur Amazon EKS.

Conditions préalables

• AWS CLI est installé sur votre PC local ou sur un Amazon EC2, qui servira de point de terminaison pour effectuer les opérations décrites dans ce document. Pour Amazon Linux 2 ou Amazon Linux 2023, les outils AWS CLI sont déjà installés. Pour installer AWS CLI sur votre PC local. Reportez-vous à la section Comment installer AWS CLI.
• Vous avez installé les outils Kubernetes et EKS sur le périphérique d'extrémité préféré, y compris :
  • kubectl
  • helm
  • eksctl
• Les autorisations AWS IAM ont été accordées correctement. Le principal de sécurité IAM que vous utilisez doit avoir la permission d'utiliser les rôles IAM d'Amazon EKS, les rôles liés aux services, AWS CloudFormation, les VPC et d'autres ressources connexes. Vous pouvez suivre l'une des méthodes suivantes pour accorder à votre principal les autorisations appropriées.
  • (Non recommandé) Il suffit de définir la politique d'association de l'utilisateur/du rôle que vous avez utilisé sur la politique gérée par AWS AdministratorAccess.
  • (Fortement recommandé) Pour appliquer le principe du moindre privilège, procédez comme suit :

    • Pour définir les autorisations pour eksctl, reportez-vous à la section Autorisations minimales pour eksctl.

    • Pour configurer l'autorisation de créer/supprimer des seaux AWS S3, reportez-vous aux paramètres d'autorisation suivants :

      {
        "Version": "2012-10-17",
        "Statement": [
          {
            "Sid": "S3BucketManagement",
            "Effect": "Allow",
            "Action": [
              "s3:CreateBucket",
              "s3:PutBucketAcl",
              "s3:PutBucketOwnershipControls",
              "s3:DeleteBucket"
            ],
            "Resource": [
              "arn:aws:s3:::milvus-bucket-*"
            ]
          }
        ]
      }
      

    • Pour définir les autorisations de création/suppression des politiques IAM, reportez-vous aux paramètres d'autorisation suivants. Remplacez YOUR_ACCOUNT_ID par votre propre adresse.

      {
        "Version": "2012-10-17",
        "Statement": [
          {
            "Sid": "IAMPolicyManagement",
            "Effect": "Allow",
            "Action": [
              "iam:CreatePolicy",
              "iam:DeletePolicy"
            ],
            "Resource": "arn:aws:iam::YOUR_ACCOUNT_ID:policy/MilvusS3ReadWrite"
          }
        ]
      }    
      

Configurer les ressources AWS

Vous pouvez configurer les ressources AWS requises, y compris un seau AWS S3 et un cluster EKS, à l'aide de la console de gestion AWS, de la CLI AWS ou d'outils IaC, tels que Terraform. Dans ce document, la CLI AWS est privilégiée pour montrer comment configurer les ressources AWS.

Créer un Amazon S3 Bucket

• Créez un bac AWS S3.

  Lisez Bucket Naming Rules et respectez les règles de nommage lorsque vous nommez votre bucket AWS S3.

  milvus_bucket_name="milvus-bucket-$(openssl rand -hex 12)"
  
  aws s3api create-bucket --bucket "$milvus_bucket_name" --region 'us-east-2' --acl private  --object-ownership ObjectWriter --create-bucket-configuration LocationConstraint='us-east-2'
  
  
  # Output
  #
  # "Location": "http://milvus-bucket-039dd013c0712f085d60e21f.s3.amazonaws.com/"
  

• Créez une politique IAM pour la lecture et l'écriture d'objets dans le seau créé ci-dessus. Remplacez le nom du seau par le vôtre.

  echo '{
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Action": [
          "s3:GetObject",
          "s3:PutObject",
          "s3:ListBucket",
          "s3:DeleteObject"
        ],
        "Resource": [
          "arn:aws:s3:::<bucket-name>",
          "arn:aws:s3:::<bucket-name>/*"
        ]
      }
    ]
  }' > milvus-s3-policy.json
  
  aws iam create-policy --policy-name MilvusS3ReadWrite --policy-document file://milvus-s3-policy.json
  
  
  # Get the ARN from the command output as follows:
  # {
  #     "Policy": {
  #         "PolicyName": "MilvusS3ReadWrite",
  #         "PolicyId": "AN5QQVVPM1BVTFlBNkdZT",
  #         "Arn": "arn:aws:iam::12345678901:policy/MilvusS3ReadWrite",
  #         "Path": "/",
  #         "DefaultVersionId": "v1",
  #         "AttachmentCount": 0,
  #         "PermissionsBoundaryUsageCount": 0,
  #         "IsAttachable": true,
  #         "CreateDate": "2023-11-16T06:00:01+00:00",
  #        "UpdateDate": "2023-11-16T06:00:01+00:00"
  #     }
  # }    
  

• Attachez la politique à votre utilisateur AWS.

  aws iam attach-user-policy --user-name <your-user-name> --policy-arn "arn:aws:iam::<your-iam-account-id>:policy/MilvusS3ReadWrite"
  

Créer un cluster Amazon EKS

• Préparez un fichier de configuration de cluster comme suit et nommez-le eks_cluster.yaml.

  apiVersion: eksctl.io/v1alpha5
  kind: ClusterConfig
  
  metadata:
    name: 'milvus-eks-cluster'
    region: 'us-east-2'
    version: "1.27"
  
  iam:
    withOIDC: true
  
    serviceAccounts:
    - metadata:
        name: aws-load-balancer-controller
        namespace: kube-system
      wellKnownPolicies:
        awsLoadBalancerController: true
  
  managedNodeGroups:
    - name: milvus-node-group
      labels: { role: milvus }
      instanceType: m6i.4xlarge
      desiredCapacity: 3
      privateNetworking: true
      
  addons:
  - name: vpc-cni
    version: latest
    attachPolicyARNs:
      - arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy
  - name: coredns
    version: latest
  - name: kube-proxy
    version: latest
  - name: aws-ebs-csi-driver
    version: latest
    wellKnownPolicies:
      ebsCSIController: true
  

• Exécutez la commande suivante pour créer un cluster EKS.

  eksctl create cluster -f eks_cluster.yaml
  

• Récupérez le fichier kubeconfig.

  aws eks update-kubeconfig --region 'us-east-2' --name 'milvus-eks-cluster'
  

• Vérifiez le cluster EKS.

  kubectl cluster-info
  
  kubectl get nodes -A -o wide
  

Créer une classe de stockage (StorageClass)

Milvus utilise etcd comme méta stockage et doit s'appuyer sur la StorageClass gp3 pour créer et gérer le PVC.

cat <<EOF | kubectl apply -f -
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ebs-gp3-sc
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: ebs.csi.aws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
  type: gp3
EOF

Définissez la StorageClass gp2 d'origine sur non-default.

kubectl patch storageclass gp2 -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"false"}}}'

Installer le contrôleur AWS LoadBalancer

• Ajouter le repo Helm chars.

  helm repo add eks https://aws.github.io/eks-charts
  helm repo update
  

• Installer le contrôleur AWS Load Balancer.

  helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
    -n kube-system \
    --set clusterName='milvus-eks-cluster' \
    --set serviceAccount.create=false \
    --set serviceAccount.name=aws-load-balancer-controller 
  

• Vérifier l'installation

  kubectl get deployment -n kube-system aws-load-balancer-controller
  

Déployer Milvus

Dans ce guide, nous utiliserons les tableaux Milvus Helm pour déployer un cluster Milvus. Vous pouvez trouver les graphiques ici.

• Ajouter le repo Milvus Helm Chart.

  helm repo add milvus https://zilliztech.github.io/milvus-helm/
  helm repo update
  

• Préparez le fichier de configuration Milvus milvus.yaml, et remplacez <bucket-name> <s3-access-key> <s3-secret-key> par le vôtre.

  • Pour configurer HA pour votre Milvus, reportez-vous à ce calculateur pour plus d'informations. Vous pouvez télécharger les configurations correspondantes directement à partir du calculateur, et vous devez supprimer les configurations liées à MinIO.
  • Pour mettre en œuvre des déploiements multirépliques de coordinateurs, remplacez xxCoordinator.activeStandby.enabled par true.

  cluster:
    enabled: true
  
  service:
    type: LoadBalancer
    port: 19530
    annotations: 
      service.beta.kubernetes.io/aws-load-balancer-type: external
      service.beta.kubernetes.io/aws-load-balancer-name: milvus-service
      service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
      service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: ip
  
  minio:
    enabled: false
  
  externalS3:
    enabled: true
    host: "s3.us-east-2.amazonaws.com"
    port: "443"
    useSSL: true
    bucketName: "<bucket-name>"
    useIAM: false
    cloudProvider: "aws"
    iamEndpoint: ""
    accessKey: "<s3-access-key>"
    secretKey: "<s3-secret-key>"
    region: "us-east-2"
  
  # HA Configurations
  rootCoordinator:
    replicas: 2
    activeStandby:
      enabled: true
    resources: 
      limits:
        cpu: 1
        memory: 2Gi
  
  indexCoordinator:
    replicas: 2
    activeStandby:
      enabled: true
    resources: 
      limits:
        cpu: "0.5"
        memory: 0.5Gi
  
  queryCoordinator:
    replicas: 2
    activeStandby:
      enabled: true
    resources: 
      limits:
        cpu: "0.5"
        memory: 0.5Gi
  
  dataCoordinator:
    replicas: 2
    activeStandby:
      enabled: true
    resources: 
      limits:
        cpu: "0.5"
        memory: 0.5Gi
  
  proxy:
    replicas: 2
    resources: 
      limits:
        cpu: 1
        memory: 2Gi  
  

• Installez Milvus.

  helm install milvus-demo milvus/milvus -n milvus -f milvus.yaml
  

• Attendez que tous les pods soient Running.

  kubectl get pods -n milvus
  

  Helm ne prend pas en charge la planification de l'ordre de création des services. Il est normal que les pods commerciaux redémarrent une ou deux fois avant que etcd et pulsar ne soient en place au début.

• Obtenir l'adresse du service Milvus.

  kubectl get svc -n milvus
  

Vérifier l'installation

Vous pouvez suivre le guide simple ci-dessous pour vérifier l'installation. Pour plus de détails, reportez-vous à cet exemple.

• Téléchargez le code d'exemple.

  wget https://raw.githubusercontent.com/milvus-io/pymilvus/master/examples/hello_milvus.py
  

• Remplacez l'argument host dans le code d'exemple par l'adresse du service Milvus ci-dessus.

```python
...
connections.connect("default", host="milvus-service-06b515b1ce9ad10.elb.us-east-2.amazonaws.com", port="19530")
...
```

• Exécutez le code d'exemple.

  python3 hello_milvus.py
  

  La sortie doit être similaire à ce qui suit :

  === 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                  ===
  
  
  === Start searching based on vector similarity ===
  
  hit: id: 2998, distance: 0.0, entity: {'random': 0.9728033590489911}, random field: 0.9728033590489911
  hit: id: 1262, distance: 0.08883658051490784, entity: {'random': 0.2978858685751561}, random field: 0.2978858685751561
  hit: id: 1265, distance: 0.09590047597885132, entity: {'random': 0.3042039939240304}, random field: 0.3042039939240304
  hit: id: 2999, distance: 0.0, entity: {'random': 0.02316334456872482}, random field: 0.02316334456872482
  hit: id: 1580, distance: 0.05628091096878052, entity: {'random': 0.3855988746044062}, random field: 0.3855988746044062
  hit: id: 2377, distance: 0.08096685260534286, entity: {'random': 0.8745922204004368}, random field: 0.8745922204004368
  search latency = 0.4693s
  
  === Start querying with `random > 0.5` ===
  
  query result:
  -{'embeddings': [0.20963514, 0.39746657, 0.12019053, 0.6947492, 0.9535575, 0.5454552, 0.82360446, 0.21096309], 'pk': '0', 'random': 0.6378742006852851}
  search latency = 0.9407s
  query pagination(limit=4):
          [{'random': 0.6378742006852851, 'pk': '0'}, {'random': 0.5763523024650556, 'pk': '100'}, {'random': 0.9425935891639464, 'pk': '1000'}, {'random': 0.7893211256191387, 'pk': '1001'}]
  query pagination(offset=1, limit=3):
          [{'random': 0.5763523024650556, 'pk': '100'}, {'random': 0.9425935891639464, 'pk': '1000'}, {'random': 0.7893211256191387, 'pk': '1001'}]
  
  === Start hybrid searching with `random > 0.5` ===
  
  hit: id: 2998, distance: 0.0, entity: {'random': 0.9728033590489911}, random field: 0.9728033590489911
  hit: id: 747, distance: 0.14606499671936035, entity: {'random': 0.5648774800635661}, random field: 0.5648774800635661
  hit: id: 2527, distance: 0.1530652642250061, entity: {'random': 0.8928974315571507}, random field: 0.8928974315571507
  hit: id: 2377, distance: 0.08096685260534286, entity: {'random': 0.8745922204004368}, random field: 0.8745922204004368
  hit: id: 2034, distance: 0.20354536175727844, entity: {'random': 0.5526117606328499}, random field: 0.5526117606328499
  hit: id: 958, distance: 0.21908017992973328, entity: {'random': 0.6647383716417955}, random field: 0.6647383716417955
  search latency = 0.4652s
  
  === Start deleting with expr `pk in ["0" , "1"]` ===
  
  query before delete by expr=`pk in ["0" , "1"]` -> result:
  -{'random': 0.6378742006852851, 'embeddings': [0.20963514, 0.39746657, 0.12019053, 0.6947492, 0.9535575, 0.5454552, 0.82360446, 0.21096309], 'pk': '0'}
  -{'random': 0.43925103574669633, 'embeddings': [0.52323616, 0.8035404, 0.77824664, 0.80369574, 0.4914803, 0.8265614, 0.6145269, 0.80234545], 'pk': '1'}
  
  query after delete by expr=`pk in ["0" , "1"]` -> result: []
  
  
  === Drop collection `hello_milvus` ===
  

Le nettoyage fonctionne

Au cas où vous devriez restaurer l'environnement en désinstallant Milvus, en détruisant le cluster EKS et en supprimant les buckets AWS S3 et les politiques IAM associées.

• Désinstaller Milvus.

  helm uninstall milvus-demo -n milvus
  

• Détruire le cluster EKS.

  eksctl delete cluster --name milvus-eks-cluster --region us-east-2
  

• Supprimez le seau AWS S3 et les politiques IAM correspondantes.

  Vous devez remplacer le nom du seau et l'ARN de la politique par les vôtres.

  aws s3 rm s3://milvus-bucket-039dd013c0712f085d60e21f --recursive
  
  aws s3api delete-bucket --bucket milvus-bucket-039dd013c0712f085d60e21f --region us-east-2
  
  aws iam detach-user-policy --user-name <your-user-name> --policy-arn "arn:aws:iam::12345678901:policy/MilvusS3ReadWrite"
  
  aws iam delete-policy --policy-arn 'arn:aws:iam::12345678901:policy/MilvusS3ReadWrite'
  

Prochaines étapes

Si vous souhaitez apprendre à déployer Milvus sur d'autres clouds :

• Déployer Milvus Cluster sur GCP avec Kubernetes
• Déployer Milvus Cluster sur Azure avec Kubernetes