Milvus sur les services de conteneurs Snowpark

Ce guide montre comment démarrer une démo Milvus sur les services de conteneurs Snowpark.

A propos de Snowpark Container Services

Snowpark Container Services est une offre de conteneurs entièrement gérée conçue pour faciliter le déploiement, la gestion et la mise à l'échelle des applications conteneurisées au sein de l'écosystème Snowflake. Ce service permet aux utilisateurs d'exécuter des charges de travail conteneurisées directement dans Snowflake, garantissant que les données n'ont pas besoin d'être déplacées hors de l'environnement Snowflake pour être traitées. Pour plus d'informations, veuillez vous référer à l'introduction officielle : Snowpark Container Services.

Configurer la démo Milvus

Ce qui suit permettra aux utilisateurs de comprendre les capacités de Milvus et la manière d'utiliser Milvus dans SPCS par le biais de la configuration et du code.

1. Obtenir des informations sur le compte

Télécharger le client SPCS : SnowSQL, puis connectez-vous à votre compte.

snowsql -a ${instance_name} -u ${user_name}

La règle de ${instance_name} est ${org_name}-${acct_name}. Les informations pertinentes peuvent être obtenues en se connectant à app.snowflake.com et en vérifiant les informations personnelles du compte.

Informations sur le compte Snowflake

2. Configurer le rôle et les privilèges

Configurer l'intégration OAUTH.

USE ROLE ACCOUNTADMIN;
CREATE SECURITY INTEGRATION SNOWSERVICES_INGRESS_OAUTH
  TYPE=oauth
  OAUTH_CLIENT=snowservices_ingress
  ENABLED=true;
  
USE ROLE ACCOUNTADMIN;
GRANT BIND SERVICE ENDPOINT ON ACCOUNT TO ROLE SYSADMIN;

Créez un rôle pour le service, notez que la partie ${PASSWORD} doit être remplacée par l'utilisateur lorsque la démo est terminée.

USE ROLE SECURITYADMIN;
CREATE ROLE MILVUS_ROLE;

USE ROLE USERADMIN;
CREATE USER milvus_user
  PASSWORD='milvususerok'
  DEFAULT_ROLE = MILVUS_ROLE
  DEFAULT_SECONDARY_ROLES = ('ALL')
  MUST_CHANGE_PASSWORD = FALSE;
  
USE ROLE SECURITYADMIN;
GRANT ROLE MILVUS_ROLE TO USER milvus_user;

3. Créer la configuration du stockage des données

• Créer l'entrepôt et la base de données

  USE ROLE SYSADMIN;
  CREATE OR REPLACE WAREHOUSE MILVUS_WAREHOUSE WITH
  WAREHOUSE_SIZE='X-SMALL'
  AUTO_SUSPEND = 180
  AUTO_RESUME = true
  INITIALLY_SUSPENDED=false;
  
  USE ROLE SYSADMIN;
  CREATE DATABASE IF NOT EXISTS MILVUS_DEMO;
  USE DATABASE MILVUS_DEMO;
  CREATE IMAGE REPOSITORY MILVUS_DEMO.PUBLIC.MILVUS_REPO;
  CREATE OR REPLACE STAGE YAML_STAGE;
  CREATE OR REPLACE STAGE DATA ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE');
  CREATE OR REPLACE STAGE FILES ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE');
  

• Accorder des privilèges aux rôles

  USE ROLE SECURITYADMIN;
  GRANT ALL PRIVILEGES ON DATABASE MILVUS_DEMO TO MILVUS_ROLE;
  GRANT ALL PRIVILEGES ON SCHEMA MILVUS_DEMO.PUBLIC TO MILVUS_ROLE;
  GRANT ALL PRIVILEGES ON WAREHOUSE MILVUS_WAREHOUSE TO MILVUS_ROLE;
  GRANT ALL PRIVILEGES ON STAGE MILVUS_DEMO.PUBLIC.FILES TO MILVUS_ROLE;
  

• Configurer l'ACL

  USE ROLE ACCOUNTADMIN;
  USE DATABASE MILVUS_DEMO;
  USE SCHEMA PUBLIC;
  CREATE NETWORK RULE allow_all_rule
  TYPE = 'HOST_PORT'
  MODE= 'EGRESS'
  VALUE_LIST = ('0.0.0.0:443','0.0.0.0:80');
  
  CREATE EXTERNAL ACCESS INTEGRATION allow_all_eai
  ALLOWED_NETWORK_RULES=(allow_all_rule)
  ENABLED=TRUE;
  
  GRANT USAGE ON INTEGRATION allow_all_eai TO ROLE SYSADMIN;
  

4. Créer des images

L'image utilisée par Milvus doit être construite localement et ensuite téléchargée par l'utilisateur. Pour la configuration de l'image, veuillez vous référer à ce repo. Après avoir cloné le code, allez dans le répertoire racine du projet et préparez-vous à construire l'image.

• Construire les images localement

  Ouvrez votre shell local et commencez à construire les images.

  cd ${repo_git_root_path}
  docker build --rm --no-cache --platform linux/amd64 -t milvus ./images/milvus
  docker build --rm --no-cache --platform linux/amd64 -t jupyter ./images/jupyter
  

  Il y a deux images ici, la première exécute la base de données Milvus, et la seconde est le bloc-notes utilisé pour l'affichage.

  Une fois les images locales construites, préparez-vous à les étiqueter et à les télécharger.

• Marquer les images construites

  Connectez-vous au hub docker de SPCS.

  docker login ${instance_name}.registry.snowflakecomputing.com -u ${user_name}
  

  Et vous pouvez taguer les images pour spcs maintenant.

  docker tag milvus ${instance_name}.registry.snowflakecomputing.com/milvus_demo/public/milvus_repo/milvus
  docker tag jupyter ${instance_name}.registry.snowflakecomputing.com/milvus_demo/public/milvus_repo/jupyter
  

  Ensuite, utilisez docker images | grep milvus dans le shell local pour vérifier si l'image a été empaquetée et étiquetée avec succès.

  docker images | grep milvus
  
  ${instance_name}.registry.snowflakecomputing.com/milvus_demo/public/milvus_repo/milvus    latest        3721bbb8f62b   2 days ago    2.95GB
  ${instance_name}.registry.snowflakecomputing.com/milvus_demo/public/milvus_repo/jupyter   latest        20633f5bcadf   2 days ago    2GB
  

• Pousser les images vers SPCS

  docker push ${instance_name}.registry.snowflakecomputing.com/milvus_demo/public/milvus_repo/milvus
  docker push ${instance_name}.registry.snowflakecomputing.com/milvus_demo/public/milvus_repo/jupyter
  

5. Créer et démarrer des services

Revenons au shell SnowSQL.

• Créer des pools de calcul

USE ROLE SYSADMIN;
CREATE COMPUTE POOL IF NOT EXISTS MILVUS_COMPUTE_POOL
  MIN_NODES = 1
  MAX_NODES = 1
  INSTANCE_FAMILY = CPU_X64_S
  AUTO_RESUME = true;
CREATE COMPUTE POOL IF NOT EXISTS JUPYTER_COMPUTE_POOL
  MIN_NODES = 1
  MAX_NODES = 1
  INSTANCE_FAMILY = CPU_X64_S
  AUTO_RESUME = true;

Vérifiez les compute pools via DESCRIBE jusqu'à ce que le statut soit ACTIVE ou IDLE.

DESCRIBE COMPUTE POOL MILVUS_COMPUTE_POOL;
DESCRIBE COMPUTE POOL JUPYTER_COMPUTE_POOL;

Statut du pool de calcul

• Téléchargement des fichiers de spécifications

Après avoir créé le compute pool, commencez à préparer le fichier spce pour le service. Les fichiers se trouvent également dans ce répertoire. Veuillez vous référer au répertoire specs.

Ouvrez les fichiers spec de ces deux services, trouvez ${org_name}-${acct_name} dans le fichier spec, et remplacez-les par ${instance_name} de votre propre compte. Après modification, utilisez SnowSQL pour terminer le téléchargement.

PUT file://${path/to/jupyter.yaml} @yaml_stage overwrite=true auto_compress=false;
PUT file://${path/to/milvus.yaml} @yaml_stage overwrite=true auto_compress=false;

• Création du service

Lorsque le téléchargement est terminé, vous êtes prêt à créer le service, Continuer pour terminer le processus de création du service.

USE ROLE SYSADMIN;
USE DATABASE MILVUS_DEMO;
USE SCHEMA PUBLIC;

CREATE SERVICE MILVUS
  IN COMPUTE POOL MILVUS_COMPUTE_POOL 
  FROM @YAML_STAGE
  SPEC='milvus.yaml'
  MIN_INSTANCES=1
  MAX_INSTANCES=1;

CREATE SERVICE JUPYTER
  IN COMPUTE POOL JUPYTER_COMPUTE_POOL 
  FROM @YAML_STAGE
  SPEC='jupyter.yaml'
  MIN_INSTANCES=1
  MAX_INSTANCES=1;

Les services peuvent également être visualisés sur SHOW SERVICES;.

SHOW SERVICES;

+---------+---------------+-------------+----------+----------------------+--------------------------------------------------------+-----------------
| name    | database_name | schema_name | owner    | compute_pool         | dns_name                                               | ......
|---------+---------------+-------------+----------+----------------------+--------------------------------------------------------+-----------------
| JUPYTER | MILVUS_DEMO   | PUBLIC      | SYSADMIN | JUPYTER_COMPUTE_POOL | jupyter.public.milvus-demo.snowflakecomputing.internal | ...... 
| MILVUS  | MILVUS_DEMO   | PUBLIC      | SYSADMIN | MILVUS_COMPUTE_POOL  | milvus.public.milvus-demo.snowflakecomputing.internal  | ......
+---------+---------------+-------------+----------+----------------------+--------------------------------------------------------+-----------------

Si vous rencontrez des problèmes au démarrage du service, vous pouvez consulter les informations sur le service à l'adresse CALL SYSTEM$GET_SERVICE_STATUS('milvus');.

Statut du service

De plus amples informations peuvent être obtenues sur CALL SYSTEM$GET_SERVICE_LOGS('milvus', '0', 'milvus', 10);.

Utiliser le carnet de notes

Utilisez SnowSQL pour accorder des autorisations.

USE ROLE SECURITYADMIN;
GRANT USAGE ON SERVICE MILVUS_DEMO.PUBLIC.JUPYTER TO ROLE MILVUS_ROLE;

Ensuite, affichez et enregistrez le point de terminaison du carnet de notes Jupyter.

USE ROLE SYSADMIN;
SHOW ENDPOINTS IN SERVICE MILVUS_DEMO.PUBLIC.JUPYTER;

Enregistrez la partie ingress_url des informations, puis ouvrez le navigateur et entrez dans ingress_url, utilisez le compte milvus_user pour vous connecter au site web.

Obtenir l'URL d'entrée

Ouvrir le bloc-notes par l'intermédiaire de ingress_url, double-cliquer sur le fichier TestMilvus.ipynb sur la page pour essayer Milvus. Sélectionnez la première partie du bloc de code et cliquez sur le bouton Run pour commencer à établir la connexion et à initialiser la fonction d'intégration.

Exécuter TestMilvus.ipynb dans le bloc-notes

Après avoir établi la connexion, continuez à cliquer sur le bouton Exécuter. Le code transformera un morceau de texte en données vectorielles après le traitement d'incorporation, puis l'insérera dans Milvus.

docs = [
    "Artificial intelligence was founded as an academic discipline in 1956.",
    "Alan Turing was the first person to conduct substantial research in AI.",
    "Born in Maida Vale, London, Turing was raised in southern England.",
]

Utilisez ensuite un texte comme requête : "Qui a lancé la recherche sur l'IA ?", exécutez la requête après le traitement d'intégration, puis obtenez et affichez les résultats les plus pertinents.

Obtenir et afficher les résultats les plus pertinents

Pour plus d'informations sur l'utilisation du client Milvus, vous pouvez vous référer à la section Milvus Doc.

7. Nettoyer

Après la vérification, vous pouvez utiliser SnowSQL pour nettoyer les services, les rôles et les ressources de données.

USE ROLE ACCOUNTADMIN;
DROP USER milvus_user;

USE ROLE SYSADMIN;
DROP SERVICE MILVUS;
DROP SERVICE JUPYTER;

DROP COMPUTE POOL MILVUS_COMPUTE_POOL;
DROP COMPUTE POOL JUPYTER_COMPUTE_POOL;

DROP IMAGE REPOSITORY MILVUS_DEMO.PUBLIC.MILVUS_REPO;
DROP DATABASE MILVUS_DEMO;
DROP WAREHOUSE MILVUS_WAREHOUSE;

USE ROLE ACCOUNTADMIN;
DROP ROLE MILVUS_ROLE;
DROP SECURITY INTEGRATION SNOWSERVICES_INGRESS_OAUTH;

A propos de Milvus

Pour plus d'informations sur Milvus, vous pouvez commencer par l'introduction et le démarrage rapide de Milvus. Bien entendu, il existe une introduction plus détaillée à l'API, une référence aux versions Python et Java, ainsi que des informations sur Embeddings et Integrations à titre de référence.