milvus-logo
LFAI
Home
  • Guide d'administration
    • Déploiement

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 :
  • 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 :

Traduit parDeepLogo

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started
Feedback

Cette page a-t - elle été utile ?