Milvus auf Snowpark-Containerdiensten

Diese Anleitung zeigt, wie man eine Milvus-Demo auf Snowpark Container Services startet.

Über Snowpark Containerdienste

Snowpark Container Services ist ein vollständig verwaltetes Container-Angebot, das die Bereitstellung, Verwaltung und Skalierung von containerisierten Anwendungen innerhalb des Snowflake-Ökosystems erleichtert. Dieser Service ermöglicht es Anwendern, containerisierte Workloads direkt in Snowflake auszuführen und sicherzustellen, dass Daten zur Verarbeitung nicht aus der Snowflake-Umgebung herausgenommen werden müssen. Weitere Informationen finden Sie in der offiziellen Einführung: Snowpark Container Dienste.

Konfigurieren der Milvus-Demo

Im Folgenden werden die Fähigkeiten von Milvus und die Verwendung von Milvus in SPCS anhand von Konfiguration und Code erläutert.

1. Beschaffung von Kontoinformationen

Laden Sie den SPCS-Client herunter: SnowSQL, dann melden Sie sich bei Ihrem Konto an.

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

Die Regel von ${instance_name} lautet ${org_name}-${acct_name}. Die entsprechenden Informationen erhalten Sie, wenn Sie sich bei app.snowflake.com anmelden und die persönlichen Kontoinformationen überprüfen.

Snowflake-Kontoinformationen

2. Konfigurieren von Rolle und Berechtigungen

Konfigurieren Sie die OAUTH-Integration.

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;

Erstellen Sie eine Rolle für den Dienst. Beachten Sie, dass der Teil ${PASSWORD} hier durch den Benutzer ersetzt werden muss, wenn die Demo

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. Konfiguration der Datenspeicherung erstellen

• Lager und Datenbank erstellen

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

• Rollenprivilegien erteilen

  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;
  

• ACL konfigurieren

  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. Bilder erstellen

Das von Milvus verwendete Image muss lokal erstellt und dann vom Benutzer hochgeladen werden. Für die entsprechende Konfiguration des Images verweisen wir auf dieses Repo. Nachdem Sie den Code geklont haben, wechseln Sie in das Stammverzeichnis des Projekts und bereiten die Erstellung des Images vor.

• Images lokal erstellen

  Öffnen Sie Ihre lokale Shell und beginnen Sie mit dem Erstellen der 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
  

  Es gibt hier zwei Images, das erste führt die Milvus-Datenbank aus, das zweite ist das Notebook, das für die Anzeige verwendet wird.

  Nachdem die lokalen Abbilder erstellt wurden, bereiten Sie sie zum Markieren und Hochladen vor.

• Erstellte Images taggen

  Loggen Sie sich in den Docker-Hub von SPCS ein.

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

  Sie können jetzt Bilder für spcs taggen.

  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
  

  Verwenden Sie dann docker images | grep milvus in der lokalen Shell, um zu überprüfen, ob das Image erfolgreich verpackt und getaggt wurde.

  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
  

• Bilder an SPCS übertragen

  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. Dienste erstellen und starten

Kehren wir zurück in die SnowSQL-Shell.

• Compute-Pools erstellen

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;

Überprüfen Sie die Compute-Pools über DESCRIBE, bis der Status ACTIVE oder IDLE lautet.

DESCRIBE COMPUTE POOL MILVUS_COMPUTE_POOL;
DESCRIBE COMPUTE POOL JUPYTER_COMPUTE_POOL;

Compute-Pool-Status

• Hochladen von Spezifikationsdateien

Nachdem Sie den Compute-Pool erstellt haben, beginnen Sie mit der Vorbereitung der spce-Datei für den Dienst. Die Dateien befinden sich ebenfalls in diesem Repo. Bitte sehen Sie sich das Verzeichnis specs an.

Öffnen Sie die spec-Dateien dieser beiden Dienste, suchen Sie ${org_name}-${acct_name} in der spec-Datei und ersetzen Sie sie durch ${instance_name} Ihres eigenen Kontos. Nach der Änderung verwenden Sie SnowSQL, um den Upload abzuschließen.

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;

• Dienst erstellen

Wenn der Upload abgeschlossen ist, können Sie den Dienst erstellen. Fahren Sie fort, um den Prozess der Erstellung des Dienstes abzuschließen.

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;

Die Dienste können auch über SHOW SERVICES; eingesehen werden.

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  | ......
+---------+---------------+-------------+----------+----------------------+--------------------------------------------------------+-----------------

Wenn Sie Probleme beim Starten des Dienstes haben, können Sie die Dienstinformationen unter CALL SYSTEM$GET_SERVICE_STATUS('milvus'); einsehen.

Status des Dienstes

Weitere Informationen erhalten Sie unter CALL SYSTEM$GET_SERVICE_LOGS('milvus', '0', 'milvus', 10);.

Notebook verwenden

Verwenden Sie SnowSQL, um Berechtigungen zu erteilen.

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

Zeigen Sie dann den Endpunkt des Jupyter-Notizbuchs an und zeichnen Sie ihn auf.

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

Zeichnen Sie den ingress_url Teil der Informationen auf, öffnen Sie dann den Browser und geben Sie die ingress_url ein, verwenden Sie das milvus_user Konto, um sich auf der Website anzumelden.

Ermitteln Sie die Eingangs-URL

Öffnen Sie das Notebook über ingress_url, doppelklicken Sie auf die Datei TestMilvus.ipynb auf der Seite, um Milvus auszuprobieren. Wählen Sie den ersten Teil des Codeblocks aus und klicken Sie auf die Schaltfläche Ausführen, um die Verbindung herzustellen und die Einbettungsfunktion zu initialisieren.

TestMilvus.ipynb im Notizbuch ausführen

Nachdem Sie die Verbindung hergestellt haben, klicken Sie weiter auf RUN. Der Code wandelt einen Text nach der Einbettung in Vektordaten um und fügt ihn dann in Milvus ein.

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.",
]

Verwenden Sie dann einen Text als Abfrage: "Wer hat mit der KI-Forschung begonnen?", führen Sie die Abfrage nach der Einbettung durch und lassen Sie sich schließlich die relevantesten Ergebnisse anzeigen.

Ermitteln und Anzeigen der relevantesten Ergebnisse

Weitere Informationen über die Verwendung des Milvus-Clients finden Sie im Abschnitt Milvus Doc.

7. Aufräumen

Nach der Überprüfung können Sie SnowSQL verwenden, um die Dienste, Rollen und Datenressourcen zu bereinigen.

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;

Über Milvus

Weitere Informationen über Milvus finden Sie in der Milvus-Einführung und im Schnellstart. Natürlich gibt es auch eine detailliertere Einführung in die API, die Python- und Java-Versionen sowie Informationen zu Einbettungen und Integrationen als Referenz.