Milvus nos serviços de contentores do Snowpark

Este guia demonstra como iniciar uma demonstração do Milvus nos serviços de contentores do Snowpark.

Sobre o Snowpark Container Services

O Snowpark Container Services é uma oferta de contêineres totalmente gerenciada, projetada para facilitar a implantação, o gerenciamento e o dimensionamento de aplicativos em contêineres dentro do ecossistema Snowflake. Este serviço permite que os utilizadores executem cargas de trabalho em contentores diretamente no Snowflake, garantindo que os dados não precisam de ser movidos para fora do ambiente do Snowflake para processamento. Para obter mais informações, consulte a introdução oficial: Serviços de contentores do Snowpark.

Configurar a demonstração do Milvus

A seguir, os utilizadores poderão compreender as capacidades do Milvus e a forma de o utilizar no SPCS através da configuração e do código.

1. Obter informações sobre a conta

Descarregue o cliente SPCS: SnowSQL, depois inicie sessão na sua conta.

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

A regra de ${instance_name} é ${org_name}-${acct_name}. As informações pertinentes podem ser obtidas iniciando sessão em app.snowflake.com e verificando as informações da conta pessoal.

Informações da conta Snowflake

2. Configurar a função e os privilégios

Configurar a integração 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;

Crie uma função para o serviço. Tenha em atenção que a parte ${PASSWORD} tem de ser substituída pelo utilizador quando a demonstração for

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. Criar configuração de armazenamento de dados

• Criar armazém e base de dados

  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 privilégios de função

  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. Criar imagens

A imagem utilizada pelo Milvus tem de ser construída localmente e depois carregada pelo utilizador. Para a configuração relevante da imagem, consulte este repositório. Depois de clonar o código, vá para o diretório raiz do projeto e prepare-se para construir a imagem.

• Construir imagens localmente

  Abra o seu shell local e comece a construir imagens.

  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
  

  Existem duas imagens aqui, a primeira está a executar a base de dados Milvus e a segunda é o notebook utilizado para apresentação.

  Depois de as imagens locais serem construídas, prepare-se para as marcar e carregar.

• Marcar as imagens construídas

  Inicie sessão no hub docker do SPCS.

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

  E você pode marcar imagens para spcs agora.

  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
  

  Em seguida, use docker images | grep milvus no shell local para verificar se a imagem foi empacotada e marcada com sucesso.

  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
  

• Enviar imagens para o 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. Criar e iniciar serviços

Vamos voltar ao shell do SnowSQL.

• Criar pools de computação

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;

Verifique os pools de computação através de DESCRIBE até que o status seja ACTIVE ou IDLE.

DESCRIBE COMPUTE POOL MILVUS_COMPUTE_POOL;
DESCRIBE COMPUTE POOL JUPYTER_COMPUTE_POOL;

Status do pool de computação

• Carregar ficheiros de especificações

Depois de criar o compute pool, comece a preparar o ficheiro spce para o serviço. Os ficheiros também se encontram neste repositório. Consulte o diretório de especificações.

Abra os ficheiros de especificações destes dois serviços, encontre ${org_name}-${acct_name} no ficheiro de especificações e substitua-os por ${instance_name} da sua própria conta. Após a modificação, utilize o SnowSQL para concluir o carregamento.

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;

• Criar serviço

Quando o carregamento estiver concluído, está pronto para criar o serviço, Continue para concluir o processo de criação do serviço.

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;

Os serviços também podem ser visualizados em 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 tiver problemas ao iniciar o serviço, pode ver as informações do serviço em CALL SYSTEM$GET_SERVICE_STATUS('milvus');.

Estado do serviço

Mais informações podem ser obtidas em CALL SYSTEM$GET_SERVICE_LOGS('milvus', '0', 'milvus', 10);.

Utilizar o Notebook

Utilize o SnowSQL para conceder permissões.

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

Em seguida, visualize e registe o ponto de extremidade do nootbook Jupyter.

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

Registar a parte ingress_url da informação, depois abrir o browser e entrar em ingress_url, utilizar a conta milvus_user para iniciar sessão no sítio Web.

Obter o URL de entrada

Abrir o bloco de notas através do ingress_url, fazer duplo clique no ficheiro TestMilvus.ipynb na página para experimentar o Milvus. Selecione a primeira parte do bloco de código e clique no botão Executar para começar a estabelecer a ligação e a inicializar a função de incorporação.

Executar TestMilvus.ipynb no bloco de notas

Depois de estabelecer a ligação, continue a clicar em EXECUTAR. O código transformará um pedaço de texto em dados vectoriais após o processamento da incorporação e, em seguida, inseri-lo-á no 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.",
]

Em seguida, utilize um texto como consulta: "Quem iniciou a investigação em IA?", efectue a consulta após o processamento de incorporação e, finalmente, obtenha e apresente os resultados mais relevantes.

Obter e apresentar os resultados mais relevantes

Para mais informações sobre a utilização do cliente Milvus, consulte a secção Milvus Doc.

7. Limpar

Após a verificação, pode utilizar o SnowSQL para limpar os serviços, as funções e os recursos de dados.

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;

Sobre o Milvus

Para obter mais informações sobre o Milvus, pode começar com a introdução e o início rápido do Milvus. Obviamente, existe uma introdução mais detalhada à API, consulte as versões Python e Java, e também há informações sobre Embeddings e Integrações para referência.