Esegui il deployment di un database vettoriale Qdrant su GKE

Autopilot . Standard

---

Questa guida mostra come eseguire il deployment di un database vettoriale Qdrant su Google Kubernetes Engine (GKE).

I database vettoriali sono datastore progettati specificamente per gestire ed eseguire ricerche in grandi raccolte di vettori ad alta dimensionalità. Questi vettori rappresentare dati come testo, immagini, audio, video o qualsiasi altro dato che può essere numerico codificati. A differenza dei database tradizionali che si basano su corrispondenze esatte, i database vettoriali sono specializzati nella ricerca di elementi simili o nell'identificazione di pattern all'interno di set di dati enormi. Queste caratteristiche rendono Qdrant una scelta adatta per una vasta gamma di applicazioni, tra cui la corrispondenza basata sulla rete neurale o la corrispondenza semantica, la ricerca tramite facet e altro ancora. Qdrant non solo funziona come database vettoriale, ma anche come motore di ricerca di somiglianze vettoriali.

Questo tutorial è destinato ad amministratori e architetti di piattaforme cloud, ML engineer e MLOps Professionisti (DevOps) interessati a eseguire il deployment del database Qdrant cluster su GKE.

Vantaggi

Qdrant offre i seguenti vantaggi:

• Ampia gamma di librerie per vari linguaggi di programmazione e API aperte per e l'integrazione con altri servizi.
• Scalabilità orizzontale e supporto dello sharding e della replica per semplificare scalabilità e disponibilità elevata.
• Supporto per container e Kubernetes che consente il deployment e la gestione negli ambienti moderni ambienti cloud-native.
• Payload flessibili con filtro avanzato per personalizzare in modo preciso i criteri di ricerca.
• Diverse opzioni di quantizzazione e altre ottimizzazioni per ridurre i costi dell'infrastruttura e migliorare le prestazioni.

Obiettivi

In questo tutorial imparerai a:

• Pianifica ed esegui il deployment dell'infrastruttura GKE per Qdrant.
• Esegui il deployment dell'operatore StatefulHA per garantire l'alta disponibilità di Qdrant.
• Eseguire il deployment e configurare il cluster Qdrant.
• Caricare un set di dati demo ed eseguire una semplice query di ricerca.
• Raccogliere metriche ed eseguire una dashboard.

Architettura di deployment

Questa architettura configura un servizio GKE scalabile e a tolleranza di errore cluster per Qdrant in più zone di disponibilità, garantendo tempi di attività con aggiornamenti in sequenza e interruzioni minime. Include l'utilizzo Operatore statefulHA per una gestione efficiente del failover. Per ulteriori informazioni, consulta Cluster a livello di regione.

Diagramma dell'architettura

Il seguente diagramma mostra un cluster Qdrant in esecuzione su più nodi e zone in un cluster GKE:

In questa architettura, il deployment di Qdrant StatefulSet viene eseguito in tre nodi in tre zone diverse.

• Puoi controllare il modo in cui GKE distribuisce i pod tra i nodi configurando le regole di affinità dei pod e i vincoli di distribuzione della topologia necessari nel file dei valori del grafico Helm.
• Se si verifica un errore in una zona, GKE ripianifica i pod su nuovi nodi in base alle configurazione.

Per la persistenza dei dati, l'architettura in questo tutorial ha le seguenti caratteristiche:

• Utilizza le impostazioni regionali Dischi SSD (regional-pd StorageClass personalizzato) per i dati persistenti. Ti consigliamo dischi SSD regionali per i database grazie alla loro bassa latenza e al loro numero elevato di IOPS.
• Tutti i dati del disco vengono replicati tra le zone primarie e secondarie della regione una maggiore tolleranza a potenziali guasti nelle zone.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

• GKE
• Google Cloud Managed Service for Prometheus
• Backup for GKE

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

In questo tutorial utilizzerai Cloud Shell per . Cloud Shell è un ambiente shell per la gestione di risorse ospitate su Google Cloud. È preinstallato Google Cloud CLI, kubectl, Helm e Terraform a riga di comando. Se non utilizzi Cloud Shell, devi installare Google Cloud CLI.

1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
2. Install the Google Cloud CLI.

3. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

4. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

6. Abilita le API Resource Manager, Compute Engine, GKE, IAM Service Account Credentials, and Backup for GKE.

   gcloud services enable cloudresourcemanager.googleapis.com compute.googleapis.com container.googleapis.com iamcredentials.googleapis.com gkebackup.googleapis.com

7. Install the Google Cloud CLI.

8. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.

9. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

10. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

11. Abilita le API Resource Manager, Compute Engine, GKE, IAM Service Account Credentials, and Backup for GKE.

    gcloud services enable cloudresourcemanager.googleapis.com compute.googleapis.com container.googleapis.com iamcredentials.googleapis.com gkebackup.googleapis.com

12. Grant roles to your user account. Run the following command once for each of the following IAM roles: role/storage.objectViewer, roles/container.admin, roles/iam.serviceAccountAdmin, roles/compute.admin, roles/gkebackup.admin, roles/monitoring.viewer

    gcloud projects add-iam-policy-binding PROJECT_ID --member="USER_IDENTIFIER" --role=ROLE

    • Replace PROJECT_ID with your project ID.

    • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:[e-mail].

    • Replace ROLE with each individual role.

Configura l'ambiente

Per configurare l'ambiente con Cloud Shell, segui questi passaggi:

1. Imposta le variabili di ambiente per il progetto, la regione e un cluster Kubernetes prefisso risorsa cluster:

   Ai fini di questo tutorial, utilizza la regione us-central1 per creare il tuo deployment Google Cloud.

   export PROJECT_ID=PROJECT_ID
   export KUBERNETES_CLUSTER_PREFIX=qdrant
   export REGION=us-central1
   

   • Sostituisci PROJECT_ID con il tuo Google Cloud dell'ID progetto.

2. Controlla la versione di Helm:

   helm version
   

   Aggiorna la versione se è precedente alla 3.13:

   curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
   

3. Clona il repository di codice campione da GitHub:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   

4. Vai alla directory qdrant per iniziare a creare risorse di deployment:

   cd kubernetes-engine-samples/databases/qdrant
   

Crea l'infrastruttura del tuo cluster

Questa sezione prevede l'esecuzione di uno script Terraform per creare un'infrastruttura cluster GKE a livello di regione per il deployment del tuo database Qdrant.

Puoi scegliere di eseguire il deployment di Qdrant utilizzando un cluster Standard o Autopilot. Ognuno ha i suoi vantaggi e modelli di prezzo diversi.

Autopilot

Il seguente diagramma mostra un cluster GKE a livello di regione Autopilot distribuite in tre zone diverse.

Per eseguire il deployment dell'infrastruttura del cluster, esegui questi comandi in Cloud Shell:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/gke-autopilot init
terraform -chdir=terraform/gke-autopilot apply \
-var project_id=${PROJECT_ID} \
-var region=${REGION} \
-var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Le seguenti variabili vengono sostituite in fase di runtime:

• GOOGLE_OAUTH_ACCESS_TOKEN: sostituito da un token di accesso recuperato da gcloud auth print-access-token per autenticare le interazioni con varie API Google Cloud
• PROJECT_ID, REGION e KUBERNETES_CLUSTER_PREFIX sono l'ambiente variabili definite nella sezione Configura il tuo ambiente e assegnate alle nuove variabili pertinenti per il cluster Autopilot che stai creando.

Quando richiesto, digita yes.

L'output è simile al seguente:

...
Apply complete! Resources: 9 added, 0 changed, 0 destroyed.

Outputs:

kubectl_connection_command = "gcloud container clusters get-credentials qdrant-cluster --region us-central1"

Terraform crea le seguenti risorse:

• Una rete VPC personalizzata e una subnet privata per i nodi Kubernetes.
• Un router Cloud per accedere a internet tramite Network Address Translation (NAT).
• Un cluster GKE privato nella regione us-central1.
• Un'ServiceAccount con autorizzazioni di logging e monitoraggio per il cluster.
• Configurazione di Google Cloud Managed Service per Prometheus per il monitoraggio e gli avvisi del cluster.

Standard

Il seguente diagramma mostra un cluster GKE a livello di regione privato standard di cui è stato eseguito il deployment in tre diverse zone.

Per eseguire il deployment dell'infrastruttura del cluster, esegui questi comandi in Cloud Shell:

export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
terraform -chdir=terraform/gke-standard init
terraform -chdir=terraform/gke-standard apply \
-var project_id=${PROJECT_ID} \
-var region=${REGION} \
-var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}

Le seguenti variabili vengono sostituite in fase di runtime:

• GOOGLE_OAUTH_ACCESS_TOKEN è stato sostituito da un token di accesso recuperato da gcloud auth print-access-token per autenticare le interazioni con vari le API Google Cloud.
• PROJECT_ID, REGION e KUBERNETES_CLUSTER_PREFIX sono le variabili di ambiente definita nella sezione Configurare l'ambiente e assegnata al nuovo e variabili pertinenti per il cluster standard che stai creando.

Quando richiesto, digita yes. Potrebbero essere necessari diversi minuti prima che questi comandi completata e affinché il cluster mostri lo stato Pronto.

L'output è simile al seguente:

...
Apply complete! Resources: 10 added, 0 changed, 0 destroyed.

Outputs:

kubectl_connection_command = "gcloud container clusters get-credentials qdrant-cluster --region us-central1"

Terraform crea le seguenti risorse:

• Una rete VPC personalizzata e una subnet privata per i nodi Kubernetes.
• Un router Cloud per accedere a internet tramite Network Address Translation (NAT).
• Un cluster GKE privato nella regione us-central1 con scalabilità automatica abilitata (da uno a due nodi per zona).
• Un'ServiceAccount con autorizzazioni di logging e monitoraggio per il cluster.
• Configurazione di Google Cloud Managed Service per Prometheus per il monitoraggio e gli avvisi dei cluster.

Connettiti al cluster

Configura kubectl per recuperare le credenziali e comunicare con il nuovo cluster GKE:

gcloud container clusters get-credentials \
    ${KUBERNETES_CLUSTER_PREFIX}-cluster --region ${REGION}

esegui il deployment del database Qdrant nel tuo cluster

In questo tutorial, eseguirai il deployment del database Qdrant (in modalità distribuita) e l'operatore stateful ad alta disponibilità al cluster GKE utilizzando il grafico Helm.

Il deployment crea un cluster GKE con la seguente configurazione:

• Tre repliche dei nodi Qdrant.
• Vengono configurate le tolleranze, le affinità dei nodi e i vincoli di diffusione della topologia per garantire la corretta distribuzione tra i nodi Kubernetes. Questo sfrutta il nodo e in zone di disponibilità diverse.
• Viene eseguito il provisioning di un volume RePD con tipo di disco SSD per l'archiviazione dei dati.
• Viene utilizzato un operatore stateful ad alta disponibilità per gestire i processi di failover l'alta disponibilità.
• Per l'autenticazione, il database crea un secret Kubernetes contenente la chiave API.

Per utilizzare il grafico Helm per eseguire il deployment del database Qdrant, segui questi passaggi:

1. Abilita il componente aggiuntivo StatefulHA:

   Autopilot

   GKE abilita automaticamente il componente aggiuntivo StatefulHA durante la creazione del cluster.

   Standard

   Esegui questo comando:

   gcloud container clusters update ${KUBERNETES_CLUSTER_PREFIX}-cluster \
       --project=${PROJECT_ID} \
       --region=${REGION} \
       --update-addons=StatefulHA=ENABLED
   

   Il completamento di questo comando e il cluster potrebbero richiedere 15 minuti per mostrare lo stato Pronto.

2. Aggiungi il repository dei grafici Helm del database Qdrant prima di eseguirne il deployment sul tuo Cluster GKE:

   helm repo add qdrant https://qdrant.github.io/qdrant-helm
   

3. Crea lo spazio dei nomi qdrant per il database:

   kubectl create ns qdrant
   

4. Applica il manifest per creare un disco SSD permanente a livello di regione StorageClass:

   kubectl apply -n qdrant -f manifests/01-regional-pd/regional-pd.yaml
   

   Il manifest regional-pd.yaml descrive il disco SSD permanente StorageClass:

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   allowVolumeExpansion: true
   metadata:
     name: ha-regional
   parameters:
     replication-type: regional-pd
     type: pd-ssd
     availability-class: regional-hard-failover
   provisioner: pd.csi.storage.gke.io
   reclaimPolicy: Retain
   volumeBindingMode: WaitForFirstConsumer

5. Esegui il deployment di una ConfigMap Kubernetes con una configurazione collaterale metrics e un Qdrant utilizzando Helm:

   kubectl apply -n qdrant -f manifests/03-prometheus-metrics/metrics-cm.yaml
   helm install qdrant-database qdrant/qdrant -n qdrant \
   -f manifests/02-values-file/values.yaml
   

   Il file manifest metrics-cm.yaml descrive il file collaterale metrics ConfigMap:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: nginx-conf
   data:
     default.conf.template: |
       server {
         listen 80;
         location / {
           proxy_pass http://localhost:6333/metrics;
           proxy_http_version 1.1;
           proxy_set_header Host $http_host;
           proxy_set_header api-key ${QDRANT_APIKEY};
           proxy_set_header X-Forwarded-For $remote_addr;
         }
       }

   Il manifest values.yaml descrive la configurazione del cluster Qdrant :

   replicaCount: 3
   
   config:
     cluster:
       enabled: true
     storage:
       optimizers:
         deleted_threshold: 0.5
         vacuum_min_vector_number: 1500
         default_segment_number: 2
         max_segment_size_kb: null
         memmap_threshold_kb: null
         indexing_threshold_kb: 25000
         flush_interval_sec: 5
         max_optimization_threads: 1
   
   livenessProbe:
     enabled: true
     initialDelaySeconds: 60
   
   resources:
     limits:
       cpu: "2"
       memory: 4Gi
     requests:
       cpu: "1"
       memory: 4Gi
   
   tolerations:
     - key: "app.stateful/component"
       operator: "Equal"
       value: "qdrant"
       effect: NoSchedule
   
   affinity:
     nodeAffinity:
       preferredDuringSchedulingIgnoredDuringExecution:
       - weight: 1
         preference:
           matchExpressions:
           - key: "app.stateful/component"
             operator: In
             values:
             - "qdrant"
   
   topologySpreadConstraints:
     - maxSkew: 1
       topologyKey: "topology.kubernetes.io/zone"
       whenUnsatisfiable: ScheduleAnyway
       labelSelector:
         matchLabels:
           app.kubernetes.io/name: qdrant
           app.kubernetes.io/instance: qdrant
   
   podDisruptionBudget:
     enabled: true
     maxUnavailable: 1
   
   persistence:
     accessModes: ["ReadWriteOnce"]
     size: 10Gi
     storageClassName: ha-regional
   
   apiKey: true
   
   sidecarContainers:
     - name: metrics
       image: nginx:1.27
       resources:
         requests:
           memory: "128Mi"
           cpu: "250m"
         limits:
           memory: "128Mi"
           cpu: "500m"
       ports:
       - containerPort: 80
       env:
       - name: QDRANT_APIKEY 
         valueFrom:
           secretKeyRef:
             name: qdrant-database-apikey          
             key: api-key
       volumeMounts:
           - name: nginx-conf
             mountPath: /etc/nginx/templates/default.conf.template
             subPath: default.conf.template
             readOnly: true
   additionalVolumes:
     - name: nginx-conf
       configMap:
         name: nginx-conf
         items:
           - key: default.conf.template
             path: default.conf.template 

   Questa configurazione abilita la modalità cluster, consentendoti di impostare un un cluster Qdrant disponibile e distribuito.

6. Controlla lo stato del deployment:

   helm ls -n qdrant
   

   Se il deployment del database qdrant viene eseguito correttamente, l'output è simile al seguente:

   NAME    NAMESPACE       REVISION        UPDATED                                 STATUS          CHART           APP VERSION
   qdrant-database  qdrant          1               2024-02-06 20:21:15.737307567 +0000 UTC deployed        qdrant-0.7.6    v1.7.4
   

7. Attendi che GKE avvii i carichi di lavoro richiesti:

   kubectl wait pods -l app.kubernetes.io/instance=qdrant-database --for condition=Ready --timeout=300s -n qdrant
   

   Il completamento di questo comando potrebbe richiedere alcuni minuti.

8. Dopo che GKE avvia i carichi di lavoro, verifica che GKE abbia creato carichi di lavoro Qdrant:

   kubectl get pod,svc,statefulset,pdb,secret -n qdrant
   

9. Avvia la risorsa HighAvailabilityApplication (HAA) per Qdrant:

   kubectl apply -n qdrant -f manifests/01-regional-pd/ha-app.yaml
   

   Il manifest ha-app.yaml descrive la risorsa HighAvailabilityApplication:

   kind: HighAvailabilityApplication
   apiVersion: ha.gke.io/v1
   metadata:
     name: qdrant-database
     namespace: qdrant
   spec:
     resourceSelection:
       resourceKind: StatefulSet
     policy:
       storageSettings:
         requireRegionalStorage: true
       failoverSettings:
         forceDeleteStrategy: AfterNodeUnreachable
         afterNodeUnreachable:
           afterNodeUnreachableSeconds: 20 # 60 seconds total

   Le seguenti risorse GKE vengono create per il cluster Qdrant:

   • Qdrant StatefulSet che controlla tre repliche di pod.
   • A PodDisruptionBudget, assicurando che sia al massimo una replica non disponibile.
   • Il servizio qdrant-database, che mostra la porta Qdrant per le connessioni in entrata e replica tra nodi.
   • Il servizio qdrant-database-headless, che fornisce l'elenco dei servizi Qdrant in esecuzione di pod.
   • Il secret di qdrant-database-apikey, che facilita la connessione sicura al database.
   • Pod dell'operatore ad alta disponibilità stateful e HighlyAvailableApplication risorsa, monitoraggio attivo di Qdrant un'applicazione. La risorsa HighlyAvailableApplication definisce le regole di failover da applicare a Qdrant.

10. Per verificare se le regole di failover sono state applicate, descrivi la risorsa e conferma Status: Message: Application is protected.

    kubectl describe highavailabilityapplication qdrant-database -n qdrant
    

    L'output è simile al seguente:

    Status:
    Conditions:
        Last Transition Time:  2023-11-30T09:54:52Z
        Message:               Application is protected
        Observed Generation:   1
        Reason:                ApplicationProtected
        Status:                True
        Type:                  Protected
    

Carica il set di dati ed esegui query di ricerca con il blocco note Jupyter

Qdrant organizza vettori e payload in raccolte. L'incorporamento vettoriale è una tecnica che rappresenta parole o entità come vettori numerici mantenendo la relazioni semantiche. Questo è importante per le ricerche di somiglianze, in quanto consente trovare somiglianze basate sul significato piuttosto che sulle corrispondenze esatte, rendendo sistemi di ricerca e consigli più efficaci e articolati.

Questa sezione mostra come caricare i vettori. in una nuova raccolta Qdrant ed eseguire semplici query di ricerca.

In questo esempio, viene utilizzato un set di dati di un file CSV che contiene un elenco di libri di generi diversi. Qdrant fungerà da motore di ricerca, mentre lo Jupyter il pod di blocchi note che crei servirà da client per eseguire query sul database Qdrant.

1. Crea gli oggetti ConfigMap books-dataset e demo-app ed esegui il deployment del blocco note Jupyter:

   kubectl create -n qdrant configmap books-dataset --from-file=manifests/04-notebook/dataset.csv
   kubectl create -n qdrant configmap notebook --from-file=manifests/04-notebook/vector-database.ipynb
   kubectl apply -n qdrant -f manifests/04-notebook/jupyter.yaml
   

   • Il secret denominato qdrant-apikey creato in precedenza è montato sul client Pod come variabile di ambiente denominata APIKEY.
   • Il ConfigMap books-dataset contiene un file csv con i dati dei libri per la raccolta Qdrant
   • Il ConfigMap notebook contiene il blocco note Jupyter per creare Raccolta Qdrant di books-dataset.

2. Attendi che GKE avvii il pod Jupyter:

   kubectl wait pods -l app=jupyter-notebook --for condition=Ready --timeout=300s -n qdrant
   

3. Apri questo URL e fai clic sul file vector-database.ipynb. Premi Esegui -> Corsa tutte le celle. Jupyter eseguirà tutto il codice ed eseguirà una query di ricerca.

   Questa query esegue una ricerca semantica sulla tua raccolta my_books in Qdrant, recupera un massimo di due risultati con il punteggio di corrispondenza più alto pertinente al testo della query.

   Stampa ogni risultato separato da una riga di trattini, nel seguente formato :

   • Title: titolo del libro
   • Author: autore del libro
   • Description: come archiviato nel campo dei metadati description del documento
   • Published: data di pubblicazione del libro
   • Score: punteggio di pertinenza di Qdrant

   L'output è simile al seguente:

   Title: Romeo and Juliet
   Author: William Shakespeare, Paul Werstine (Editor), Barbara A. Mowat (Editor),
   Paavo Emil Cajander (Translator)
   Description: In Romeo and Juliet, Shakespeare creates a violent world, in which
   two young people fall in love. It is not simply that their families disapprove;
   the Montagues and the Capulets are engaged in a blood feud.In this death-filled
   setting, the movement from love at first sight to the lovers' final union in
   death seems almost inevitable. And yet, this play set in an extraordinary world
   has become the quintessential story of young love. In part because of its exquisite
   language, it is easy to respond as if it were about all young lovers. Published: 01/01/04
   Score: 0.8935013
   -----
   Title: The Unbearable Lightness of Being
   Author: Milan Kundera, Michael Henry Heim (Translator)
   Description: In The Unbearable Lightness of Being, Milan Kundera tells the story
   of a young woman in love with a man torn between his love for her and his incorrigible
   womanizing and one of his mistresses and her humbly faithful lover. This magnificent
   novel juxtaposes geographically distant places, brilliant and playful reflections,
   and a variety of styles, to take its place as perhaps the major achievement of
   one of the world's truly great writers. Published: 10/27/09
   Score: 0.8931863
   -----
   

Visualizza le metriche di Prometheus per il tuo cluster

Il cluster GKE è configurato con Google Cloud Managed Service per Prometheus, che consente di metriche nel formato Prometheus. Questo servizio offre soluzione gestita per il monitoraggio e gli avvisi, che consente la raccolta, e l'analisi delle metriche dal cluster e dalle sue applicazioni.

Il seguente diagramma mostra in che modo Prometheus raccoglie le metriche per il cluster:

Il cluster privato GKE nel diagramma contiene i seguenti componenti:

• Pod Qdrant che espongono le metriche sul percorso / e sulla porta 80. Queste metriche sono forniti dal container collaterale denominato metrics.
• Collettori basati su Prometheus che elaborano le metriche dai pod Qdrant.
• Una risorsa PodMonitoring che invia le metriche a Cloud Monitoring.

Per esportare e visualizzare le metriche:

1. Crea la PodMonitoring risorsa per eseguire lo scraping delle metriche in base a labelSelector:

   kubectl apply -n qdrant -f manifests/03-prometheus-metrics/pod-monitoring.yaml
   

   Il manifest pod-monitoring.yaml descrive la risorsa PodMonitoring:

   apiVersion: monitoring.googleapis.com/v1
   kind: PodMonitoring
   metadata:
     name: qdrant
   spec:
     selector:
       matchLabels:
         app: qdrant
         app.kubernetes.io/instance: qdrant-database
     endpoints:
     - port: 80
       interval: 30s
       path: / 

2. Crea una dashboard di Cloud Monitoring con le configurazioni definite in dashboard.json :

   gcloud --project "${PROJECT_ID}" monitoring dashboards create --config-from-file monitoring/dashboard.json
   

3. Una volta eseguito correttamente il comando, vai a Cloud Monitoring Dashboard:

   Vai alla panoramica delle dashboard

4. Dall'elenco delle dashboard, apri la dashboard Qdrant Overview. Potrebbe impiegano 1-2 minuti per raccogliere e visualizzare le metriche.

   La dashboard mostra un conteggio delle metriche chiave:

   • Raccolte
   • Vettori incorporati
   • Operazioni in attesa
   • Nodi in esecuzione

Esegui il backup della configurazione del cluster

La guida di Backup per GKE consente di pianificare backup regolari dell'intero cluster GKE della configurazione, inclusi i carichi di lavoro di cui è stato eseguito il deployment e i relativi dati.

In questo tutorial configurerai un piano di backup per l'esecuzione del tuo cluster GKE backup di tutti i carichi di lavoro, inclusi secret e volumi, ogni giorno alle 03:00. Per garantire una gestione efficiente dello spazio di archiviazione, i backup che risalgono a più di tre giorni fa verranno eliminati automaticamente.

Per configurare i piani di backup: segui questi passaggi:

1. Abilita la funzionalità Backup per GKE per il tuo cluster:

   gcloud container clusters update ${KUBERNETES_CLUSTER_PREFIX}-cluster \
   --project=${PROJECT_ID} \
   --region=${REGION} \
   --update-addons=BackupRestore=ENABLED
   

2. Crea un piano di backup con una pianificazione giornaliera per tutti gli spazi dei nomi all'interno del cluster:

   gcloud beta container backup-restore backup-plans create ${KUBERNETES_CLUSTER_PREFIX}-cluster-backup \
   --project=${PROJECT_ID} \
   --location=${REGION} \
   --cluster="projects/${PROJECT_ID}/locations/${REGION}/clusters/${KUBERNETES_CLUSTER_PREFIX}-cluster" \
   --all-namespaces \
   --include-secrets \
   --include-volume-data \
   --cron-schedule="0 3 * * *" \
   --backup-retain-days=3
   

   Il comando utilizza le variabili di ambiente pertinenti in fase di runtime.

   Il formato del nome del cluster è relativo al progetto e alla regione, come segue:

   projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_NAME
   

   Quando richiesto, digita y.. L'output è simile al seguente:

   Create request issued for: [qdrant-cluster-backup]
   Waiting for operation [projects/PROJECT_ID/locations/us-central1/operations/operation-1706528750815-610142ffdc9ac-71be4a05-f61c99fc] to complete...⠹
   

   Questa operazione potrebbe richiedere alcuni minuti. Dopo il completa, l'output è simile al seguente:

   Created backup plan [qdrant-cluster-backup].
   

3. Puoi visualizzare il piano di backup qdrant-cluster-backup appena creato nell'elenco la console Backup per GKE.

   Vai a Backup per GKE

Se vuoi ripristinare le configurazioni di backup salvate, consulta Ripristinare un backup.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Il modo più semplice per evitare la fatturazione è eliminare il progetto per cui questo tutorial.

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Elimina un progetto Google Cloud:

gcloud projects delete PROJECT_ID

Se hai eliminato il progetto, la pulizia è stata completata. Se non hai eliminato progetto, procedi con l'eliminazione delle singole risorse.

Elimina singole risorse

1. Imposta le variabili di ambiente.

   export PROJECT_ID=${PROJECT_ID}
   export KUBERNETES_CLUSTER_PREFIX=qdrant
   export REGION=us-central1
   

2. Esegui il comando terraform destroy:

   export GOOGLE_OAUTH_ACCESS_TOKEN=$(gcloud auth print-access-token)
   terraform  -chdir=terraform/FOLDER destroy \
   -var project_id=${PROJECT_ID} \
   -var region=${REGION} \
   -var cluster_prefix=${KUBERNETES_CLUSTER_PREFIX}
   

   Sostituisci FOLDER con gke-autopilot o gke-standard, a seconda del tipo di cluster GKE che hai creato.

   Quando richiesto, digita yes.

3. Trova tutti i dischi scollegati:

   export disk_list=$(gcloud compute disks list --filter="-users:* AND labels.name=${KUBERNETES_CLUSTER_PREFIX}-cluster" --format "value[separator=|](name,region)")
   

4. Elimina i dischi:

   for i in $disk_list; do
    disk_name=$(echo $i| cut -d'|' -f1)
    disk_region=$(echo $i| cut -d'|' -f2|sed 's|.*/||')
    echo "Deleting $disk_name"
    gcloud compute disks delete $disk_name --region $disk_region --quiet
   done
   

5. Elimina il repository GitHub:

   rm -r ~/kubernetes-engine-samples/
   

Passaggi successivi

• Esplora il software open source Qdrant.
• Prova l'operatore Qdrant che offre la gestione delle chiavi API, Supporto TLS con gestione dei certificati, e la pianificazione del backup.
• Scopri le best practice per il deployment dei database su GKE.
• Scopri le soluzioni per eseguire carichi di lavoro ad alta intensità di dati con GKE.