Iniziare con il cluster Milvus e K8s

Introduzione

Milvus è un database vettoriale distribuito che ha lo scopo di memorizzare, indicizzare e gestire vettori di incorporazione massiccia. La sua capacità di indicizzare e cercare in modo efficiente tra trilioni di vettori rende Milvus una scelta obbligata per i carichi di lavoro di AI e machine learning.

Kubernetes (K8s), invece, eccelle nella gestione e nella scalabilità delle applicazioni containerizzate. Offre funzioni come l'autoscaling, l'autoguarigione e il bilanciamento del carico, che sono fondamentali per mantenere alta la disponibilità e le prestazioni negli ambienti di produzione.

Perché usarli insieme?

K8s può scalare automaticamente i cluster Milvus in base al carico di lavoro. Quando i dati crescono o il numero di query aumenta, K8s è in grado di attivare più istanze Milvus per gestire il carico, garantendo la reattività delle applicazioni.

Una delle caratteristiche principali di K8s è la scalabilità orizzontale, che rende l'espansione del cluster Milvus un gioco da ragazzi. Man mano che il vostro set di dati cresce, K8s si adatta facilmente a questa crescita, rendendolo una soluzione semplice ed efficiente.

Inoltre, anche la capacità di gestire le query si espande orizzontalmente con K8s. Con l'aumento del carico di query, K8s può distribuire più istanze Milvus per gestire l'aumento delle query di ricerca per similarità, garantendo risposte a bassa latenza anche in presenza di carichi elevati.

Prerequisiti e impostazione di K8s

Prerequisiti

• Docker - Assicurarsi che Docker sia installato sul sistema.

• Kubernetes - Preparare un cluster Kubernetes. È possibile utilizzare minikube per lo sviluppo locale o il servizio Kubernetes di un provider cloud per gli ambienti di produzione.

• Helm - Installate Helm, un gestore di pacchetti per Kubernetes, per aiutarvi a gestire le applicazioni Kubernetes; potete consultare la nostra documentazione per vedere come farlo https://milvus.io/docs/install_cluster-helm.md.

• Kubectl - Installate kubectl, uno strumento a riga di comando per interagire con i cluster Kubernetes, per distribuire applicazioni, ispezionare e gestire le risorse del cluster e visualizzare i log.

Impostazione di K8s

Dopo aver installato tutto il necessario per eseguire un cluster K8s e se si è utilizzato minikube, avviare il cluster con:

minikube start

Controllare lo stato del cluster K8s con:

kubectl cluster-info

Distribuzione di Milvus su K8s

Per questa distribuzione, sceglieremo Milvus in modalità cluster per sfruttare tutte le sue capacità distribuite. Utilizzeremo Helm per semplificare il processo di installazione.

1. Comando di installazione di Helm

helm install my-milvus milvus/milvus --set pulsar.enabled=false --set kafka.enabled=true

Questo comando installa Milvus sul cluster K8s con Kafka abilitato e Pulsar disabilitato. Kafka funge da sistema di messaggistica all'interno di Milvus, gestendo lo streaming dei dati tra i diversi componenti. La disabilitazione di Pulsar e l'abilitazione di Kafka adattano la distribuzione alle nostre preferenze e ai nostri requisiti specifici di messaggistica.

2. Inoltro delle porte

Per accedere a Milvus dalla propria macchina locale, creare un port forward: kubectl port-forward svc/my-milvus 27017:19530.

Questo comando mappa la porta 19530 dal servizio Milvus svc/my-milvus alla stessa porta sul computer locale, consentendo di connettersi a Milvus con gli strumenti locali. Se si lascia la porta locale non specificata (come in :19530), K8s assegnerà una porta disponibile, rendendola dinamica. Se si sceglie questo metodo, assicurarsi di annotare la porta locale assegnata.

3. Verifica della distribuzione:

kubectl get pods 

NAME                                    READY   STATUS    RESTARTS   AGE
my-milvus-datacoord-595b996bd4-zprpd    1/1     Running   0          85m
my-milvus-datanode-d9d555785-47nkt      1/1     Running   0          85m
my-milvus-etcd-0                        1/1     Running   0          84m
my-milvus-etcd-1                        1/1     Running   0          85m
my-milvus-etcd-2                        1/1     Running   0          85m
my-milvus-indexcoord-65bc68968c-6jg6q   1/1     Running   0          85m
my-milvus-indexnode-54586f55d-z9vx4     1/1     Running   0          85m
my-milvus-kafka-0                       1/1     Running   0          85m
my-milvus-kafka-1                       1/1     Running   0          85m
my-milvus-kafka-2                       1/1     Running   0          85m
my-milvus-minio-0                       1/1     Running   0          96m
my-milvus-minio-1                       1/1     Running   0          96m
my-milvus-minio-2                       1/1     Running   0          96m
my-milvus-minio-3                       1/1     Running   0          96m
my-milvus-proxy-76bb7d497f-sqwvd        1/1     Running   0          85m
my-milvus-querycoord-6f4c7b7598-b6twj   1/1     Running   0          85m
my-milvus-querynode-677bdf485b-ktc6m    1/1     Running   0          85m
my-milvus-rootcoord-7498fddfd8-v5zw8    1/1     Running   0          85m
my-milvus-zookeeper-0                   1/1     Running   0          85m
my-milvus-zookeeper-1                   1/1     Running   0          85m
my-milvus-zookeeper-2                   1/1     Running   0          85m

Dovreste vedere un elenco di pod simile all'output precedente, tutti in stato di esecuzione. Questo indica che il cluster Milvus è operativo. In particolare, cercate il valore 1/1 nella colonna READY, che indica che ogni pod è completamente pronto e funzionante. Se qualche pod non è in esecuzione, potrebbe essere necessario indagare ulteriormente per garantire il successo della distribuzione.

Con il cluster Milvus distribuito e tutti i componenti confermati in esecuzione, si è ora pronti a procedere all'ingestione e all'indicizzazione dei dati. Questo comporta la connessione all'istanza Milvus, la creazione di raccolte e l'inserimento di vettori per la ricerca e il recupero.

Ingestione e indicizzazione dei dati

Per iniziare a ingerire e indicizzare i dati nel nostro cluster Milvus, utilizzeremo l'SDK pymilvus. Esistono due opzioni di installazione:

• SDK di base: pip install pymilvus

• Per le incorporazioni di testo e i modelli avanzati: pip install pymilvus[model]

Per inserire i dati nel nostro cluster, utilizzeremo pymilvus, è possibile installare l'SDK solo con pip install pymilvus oppure, se si desidera estrarre rich text embeddings, è possibile utilizzare anche PyMilvus Models installando pip install pymilvus[model].

Connessione e creazione di una raccolta:

Per prima cosa, collegarsi all'istanza di Milvus utilizzando la porta inoltrata in precedenza. Assicurarsi che l'URI corrisponda alla porta locale assegnata da K8s:

from pymilvus import MilvusClient

client = MilvusClient(
        uri="http://127.0.0.1:52070",
    )

client.create_collection(collection_name="quick_setup", dimension=5)

Il parametro dimension=5 definisce la dimensione del vettore per questa raccolta, essenziale per le funzionalità di ricerca vettoriale.

Inserire i dati

Ecco come inserire un primo insieme di dati, dove ogni vettore rappresenta un elemento e il campo colore aggiunge un attributo descrittivo:

data=[
    {"id": 0, "vector": [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592], "color": "pink_8682"},
    {"id": 1, "vector": [0.19886812562848388, 0.06023560599112088, 0.6976963061752597, 0.2614474506242501, 0.838729485096104], "color": "red_7025"},
    {"id": 2, "vector": [0.43742130801983836, -0.5597502546264526, 0.6457887650909682, 0.7894058910881185, 0.20785793220625592], "color": "orange_6781"},
    {"id": 3, "vector": [0.3172005263489739, 0.9719044792798428, -0.36981146090600725, -0.4860894583077995, 0.95791889146345], "color": "pink_9298"},
    {"id": 4, "vector": [0.4452349528804562, -0.8757026943054742, 0.8220779437047674, 0.46406290649483184, 0.30337481143159106], "color": "red_4794"},
    {"id": 5, "vector": [0.985825131989184, -0.8144651566660419, 0.6299267002202009, 0.1206906911183383, -0.1446277761879955], "color": "yellow_4222"},
    {"id": 6, "vector": [0.8371977790571115, -0.015764369584852833, -0.31062937026679327, -0.562666951622192, -0.8984947637863987], "color": "red_9392"},
    {"id": 7, "vector": [-0.33445148015177995, -0.2567135004164067, 0.8987539745369246, 0.9402995886420709, 0.5378064918413052], "color": "grey_8510"},
    {"id": 8, "vector": [0.39524717779832685, 0.4000257286739164, -0.5890507376891594, -0.8650502298996872, -0.6140360785406336], "color": "white_9381"},
    {"id": 9, "vector": [0.5718280481994695, 0.24070317428066512, -0.3737913482606834, -0.06726932177492717, -0.6980531615588608], "color": "purple_4976"}
]

res = client.insert(
    collection_name="quick_setup",
    data=data
)

print(res)

Il codice fornito presuppone che sia stata creata una collezione nella modalità di impostazione rapida. Come mostrato nel codice precedente,

I dati da inserire sono organizzati in un elenco di dizionari, dove ogni dizionario rappresenta un record di dati, definito entità.

Ogni dizionario contiene un campo non definito da schemi, chiamato colore.

Ogni dizionario contiene le chiavi corrispondenti sia ai campi predefiniti che a quelli dinamici.

Inserire ancora più dati

colors = ["green", "blue", "yellow", "red", "black", "white", "purple", "pink", "orange", "brown", "grey"]
data = [ {
    "id": i, 
    "vector": [ random.uniform(-1, 1) for _ in range(5) ], 
    "color": f"{random.choice(colors)}_{str(random.randint(1000, 9999))}" 
} for i in range(1000) ]

res = client.insert(
    collection_name="quick_setup",
    data=data[10:]
)

print(res)

Ricerca per somiglianza

Dopo aver popolato la collezione, è possibile eseguire una ricerca di somiglianza per trovare vettori vicini a un vettore di query. Il valore della variabile query_vectors è un elenco contenente un sottoelenco di float. Il sottoelenco rappresenta un incorporamento vettoriale di 5 dimensioni.

query_vectors = [
    [0.041732933, 0.013779674, -0.027564144, -0.013061441, 0.009748648]
]

res = client.search(
    collection_name="quick_setup",     # target collection
    data=query_vectors,                # query vectors
    limit=3,                           # number of returned entities
)

print(res)

Questa query cerca i 3 vettori più simili al nostro vettore di interrogazione, dimostrando le potenti capacità di ricerca di Milvus.

Disinstallare Milvus da K8s

Una volta terminato questo tutorial, potete disinstallare Milvus dal vostro cluster K8s con:helm uninstall my-milvus.

Questo comando rimuoverà tutti i componenti di Milvus distribuiti nella release my-milvus, liberando le risorse del cluster.

Conclusione

• La distribuzione di Milvus su un cluster Kubernetes dimostra la scalabilità e la flessibilità dei database vettoriali nella gestione dei carichi di lavoro di AI e apprendimento automatico. Con questo tutorial si sono apprese le basi della configurazione di Milvus con Helm, della creazione di una collezione e dell'esecuzione di ingestioni di dati e ricerche di similarità.

• L'installazione di Milvus su un cluster Kubernetes con Helm dovrebbe essere semplice. Per approfondire la scalabilità dei cluster Milvus per grandi insiemi di dati o carichi di lavoro più intensivi, la nostra documentazione offre una guida dettagliata https://milvus.io/docs/scaleout.md.

Sentitevi liberi di controllare il codice su Github, di provare Milvus, di sperimentare diverse configurazioni e casi d'uso e di condividere le vostre esperienze con la comunità unendovi al nostro Discord.