Milvus en los servicios de contenedores Snowpark

Esta guía muestra cómo iniciar una demostración de Milvus en los servicios de contenedores Snowpark.

Acerca de Snowpark Container Services

Snowpark Container Services es una oferta de contenedores totalmente gestionados diseñada para facilitar el despliegue, la gestión y el escalado de aplicaciones en contenedores dentro del ecosistema Snowflake. Este servicio permite a los usuarios ejecutar cargas de trabajo en contenedores directamente dentro de Snowflake, asegurando que los datos no necesitan ser movidos fuera del entorno Snowflake para su procesamiento. Para más información, consulte la introducción oficial: Snowpark Container Services.

Configurar la demostración de Milvus

Lo siguiente permitirá a los usuarios comprender las capacidades de Milvus y cómo utilizar Milvus en SPCS a través de la configuración y el código.

1. Obtener la información de la cuenta

Descargue el cliente SPCS SnowSQL, y a continuación inicie sesión en su cuenta.

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

La regla de ${instance_name} es ${org_name}-${acct_name}. La información pertinente puede obtenerse iniciando sesión en app.snowflake.com y comprobando la información de la cuenta personal.

Información de la cuenta de copo de nieve

2. Configurar rol y privilegios

Configure la integración 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;

Cree un rol para el servicio, tenga en cuenta que la parte ${PASSWORD} aquí necesita ser reemplazada por el usuario cuando la demo sea

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. Crear configuración de almacenamiento de datos

• Crear almacén y base de datos

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

• Conceder privilegios de rol

  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;
  

• Configurar 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. Crear imágenes

La imagen utilizada por Milvus necesita ser construida localmente y luego cargada por el usuario. Para la configuración pertinente de la imagen, consulte este repositorio. Después de clonar el código, vaya al directorio raíz del proyecto y prepárese para construir la imagen.

• Construir imágenes localmente

  Abre tu shell local y comienza a construir las imágenes.

  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
  

  Hay dos imágenes aquí, la primera está ejecutando la base de datos Milvus, y el segundo es el cuaderno utilizado para la visualización.

  Una vez construidas las imágenes locales, prepárese para etiquetarlas y subirlas.

• Etiquetar las imágenes construidas

  Inicie sesión en el docker hub de SPCS.

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

  Y ya puedes etiquetar imágenes para 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
  

  A continuación, utilice docker images | grep milvus en el shell local para comprobar si la imagen se ha empaquetado y etiquetado correctamente.

  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
  

• Empujar imágenes a 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. Crear e iniciar servicios

Volvamos al shell SnowSQL.

• Crear pools de computación

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;

Compruebe los pools de computación a través de DESCRIBE hasta que el estado sea ACTIVE o IDLE.

DESCRIBE COMPUTE POOL MILVUS_COMPUTE_POOL;
DESCRIBE COMPUTE POOL JUPYTER_COMPUTE_POOL;

Estado de los pools de computación

• Cargar archivos de especificaciones

Después de crear el compute pool, comience a preparar el archivo spce para el servicio. Los archivos también se encuentran en este repositorio. Consulte el directorio de especificaciones.

Abra los archivos spec de estos dos servicios, busque ${org_name}-${acct_name} en el archivo spec y sustitúyalo por ${instance_name} de su propia cuenta. Después de la modificación, utilice SnowSQL para completar la carga.

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;

• Crear servicio

Cuando la carga se haya completado, usted está listo para crear el servicio, Continuar para completar el proceso de creación del servicio.

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;

Los servicios también pueden visualizarse a través de 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 tiene problemas para iniciar el servicio, puede ver la información del servicio a través de CALL SYSTEM$GET_SERVICE_STATUS('milvus');.

Estado del servicio

Puede obtener más información a través de CALL SYSTEM$GET_SERVICE_LOGS('milvus', '0', 'milvus', 10);.

Utilizar Notebook

Utilice SnowSQL para conceder permisos.

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

A continuación, visualice y registre el punto final del nootbook Jupyter.

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

Registre la parte ingress_url de la información, a continuación, abra el navegador y entre en ingress_url, utilice la cuenta milvus_user para iniciar sesión en el sitio web.

Obtener la URL de entrada

Abra el cuaderno a través de ingress_url, haga doble clic en el archivo TestMilvus.ipynb de la página para probar Milvus. Seleccione la primera parte del bloque de código y haga clic en el botón Ejecutar para empezar a establecer la conexión e inicializar la función de incrustación.

Ejecute TestMilvus.ipynb en el bloc de notas

Después de establecer la conexión, continúe haciendo clic en EJECUTAR. El código convertirá un trozo de texto en datos vectoriales después del procesamiento de incrustación, y luego lo insertará en 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.",
]

A continuación, utilice un texto como consulta: "¿Quién inició la investigación en IA?", realice la consulta tras el procesamiento de incrustación y, por último, obtenga y muestre los resultados más relevantes.

Obtener y mostrar los resultados más relevantes

Para más información sobre el uso del cliente Milvus, puede consultar la sección Milvus Doc.

7. Limpieza

Tras la verificación, puede utilizar SnowSQL para limpiar los servicios, roles y recursos de datos.

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;

Acerca de Milvus

Para más información sobre Milvus, puede empezar con la introducción a Milvus y el inicio rápido. Por supuesto, hay una introducción más detallada a la API, consulte las versiones Python y Java, y también hay información sobre Embeddings e Integraciones como referencia.