Milvus sui servizi container di Snowpark

Questa guida mostra come avviare una demo di Milvus sui servizi container di Snowpark.

Informazioni su Snowpark Container Services

Snowpark Container Services è un'offerta di container completamente gestita, progettata per facilitare la distribuzione, la gestione e la scalabilità di applicazioni containerizzate all'interno dell'ecosistema Snowflake. Questo servizio consente agli utenti di eseguire carichi di lavoro containerizzati direttamente all'interno di Snowflake, garantendo che i dati non debbano essere spostati fuori dall'ambiente Snowflake per l'elaborazione. Per ulteriori informazioni, consultare l'introduzione ufficiale: Snowpark Container Services.

Configurazione della demo Milvus

Di seguito, gli utenti potranno comprendere le funzionalità di Milvus e come utilizzare Milvus in SPCS attraverso la configurazione e il codice.

1. Ottenere le informazioni sull'account

Scaricare il client SPCS: SnowSQL, quindi accedere al proprio account.

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

La regola di ${instance_name} è ${org_name}-${acct_name}. Le informazioni pertinenti possono essere ottenute accedendo a app.snowflake.com e controllando le informazioni sull'account personale.

Informazioni sull'account Snowflake

2. Configurare ruolo e privilegi

Configurare l'integrazione 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;

Creare un ruolo per il servizio, tenendo presente che la parte ${PASSWORD} deve essere sostituita dall'utente quando la demo viene eseguita.

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. Creare la configurazione dell'archiviazione dei dati

• Creare il magazzino e il database

  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');
  

• Assegnare i privilegi del ruolo

  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;
  

• Configurare le 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. Creare le immagini

L'immagine utilizzata da Milvus deve essere costruita localmente e poi caricata dall'utente. Per la configurazione dell'immagine, fare riferimento a questo repo. Dopo aver clonato il codice, andare nella directory principale del progetto e prepararsi a costruire l'immagine.

• Costruire le immagini localmente

  Aprire la shell locale e iniziare a compilare le immagini.

  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
  

  Ci sono due immagini: la prima gestisce il database di Milvus e la seconda è il notebook utilizzato per la visualizzazione.

  Una volta costruite le immagini locali, preparatevi a taggarle e a caricarle.

• Taggare le immagini costruite

  Accedere all'hub docker di SPCS.

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

  È possibile taggare le immagini per SPCS.

  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
  

  Quindi utilizzare docker images | grep milvus nella shell locale per verificare se l'immagine è stata impacchettata e taggata con successo.

  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
  

• Spingere le immagini su 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. Creare e avviare i servizi

Torniamo alla shell di SnowSQL.

• Creare i pool di calcolo

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;

Controllate i pool di calcolo attraverso DESCRIBE fino a quando lo stato è ACTIVE o IDLE.

DESCRIBE COMPUTE POOL MILVUS_COMPUTE_POOL;
DESCRIBE COMPUTE POOL JUPYTER_COMPUTE_POOL;

Stato del pool di calcolo

• Caricare i file delle specifiche

Dopo aver creato il pool di calcolo, iniziare a preparare il file spce per il servizio. I file si trovano anche in questo repo. Fare riferimento alla cartella specs.

Aprire i file spec di questi due servizi, trovare ${org_name}-${acct_name} nel file spec e sostituirlo con ${nome_instanza} del proprio account. Dopo la modifica, usare SnowSQL per completare il caricamento.

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;

• Creare il servizio

Una volta completato il caricamento, si è pronti a creare il servizio: continuare per completare il processo di creazione del servizio.

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;

I servizi possono essere visualizzati anche attraverso 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  | ......
+---------+---------------+-------------+----------+----------------------+--------------------------------------------------------+-----------------

Se si riscontrano problemi nell'avvio del servizio, è possibile visualizzare le informazioni sul servizio tramite CALL SYSTEM$GET_SERVICE_STATUS('milvus');.

Stato del servizio

Ulteriori informazioni possono essere ottenute tramite CALL SYSTEM$GET_SERVICE_LOGS('milvus', '0', 'milvus', 10);.

Utilizzare il blocco note

Utilizzare SnowSQL per concedere le autorizzazioni.

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

Quindi visualizzare e registrare l'endpoint del Jupyter nootbook.

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

Registrare la parte ingress_url delle informazioni, quindi aprire il browser e inserire ingress_url, utilizzare l'account milvus_user per accedere al sito web.

Ottenere l'URL di ingresso

Aprire il blocco note attraverso ingress_url, fare doppio clic sul file TestMilvus.ipynb nella pagina per provare Milvus. Selezionate la prima parte del blocco di codice e fate clic sul pulsante Esegui per iniziare a stabilire la connessione e inizializzare la funzione di incorporamento.

Esecuzione di TestMilvus.ipynb nel blocco note

Dopo aver stabilito la connessione, continuare a fare clic su ESEGUI. Il codice trasformerà un testo in dati vettoriali dopo l'elaborazione di embedding e lo inserirà in 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.",
]

Utilizzare quindi un testo come query: "Chi ha iniziato la ricerca sull'IA?", eseguire la query dopo l'elaborazione dell'incorporazione e infine ottenere e visualizzare i risultati più rilevanti.

Ottenere e visualizzare i risultati più rilevanti

Per ulteriori informazioni sull'uso del client Milvus, è possibile consultare la sezione Milvus Doc.

7. Pulire

Dopo la verifica, è possibile utilizzare SnowSQL per ripulire i servizi, i ruoli e le risorse di dati.

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;

Informazioni su Milvus

Per maggiori informazioni su Milvus, potete iniziare con l'introduzione e l'avvio rapido di Milvus. Naturalmente, c'è un'introduzione più dettagliata all'API, si può fare riferimento alle versioni Python e Java, e ci sono anche informazioni su Embeddings e Integrations come riferimento.