Esegui il deployment di un database di vettori Elasticsearch su GKE

Questo tutorial mostra come eseguire il deployment di un cluster di database vettoriale Elasticsearch su Google Kubernetes Engine (GKE).

I database vettoriali sono spazi di archiviazione dei dati progettati specificamente per gestire e cercare grandi raccolte di vettori ad alta dimensione. Questi vettori rappresentano dati come testo, immagini, audio, video o qualsiasi dato che può essere codificato numericamente. A differenza dei database relazionali 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 di grandi dimensioni.

Elasticsearch è un database vettoriale che combina funzionalità di ricerca e analisi. È dotato di un'API REST aperta per la gestione del cluster e supporta query strutturate, query full-text e query complesse. Elasticsearch ti consente di eseguire ricerche di frasi, di somiglianza e di prefissi, con suggerimenti di completamento automatico.

Questo tutorial è destinato ad amministratori e architetti di piattaforme cloud, ML engineer e professionisti MLOps (DevOps) interessati al deployment di cluster di database Elasticsearch su GKE.

Vantaggi

Elasticsearch offre i seguenti vantaggi:

  • Ampia gamma di librerie per vari linguaggi di programmazione e API aperte da integrare con altri servizi.
  • Scalabilità orizzontale e supporto per sharding e replica che semplificano la scalabilità e l'alta disponibilità.
  • Bilanciamento del carico del cluster multimodale per un utilizzo ottimale delle risorse.
  • Supporto di container e Kubernetes per l'integrazione perfetta in ambienti cloud-native moderni.

Obiettivi

In questo tutorial imparerai a:

  • Pianifica ed esegui il deployment dell'infrastruttura GKE per Elasticsearch.
  • Esegui il deployment e configura Elasticsearch in un cluster GKE.
  • Esegui il deployment dell'operatore StatefulHA per garantire l'alta disponibilità di Elasticsearch.
  • Esegui un notebook per generare e archiviare vector embedding di esempio all'interno del tuo database ed esegui query di ricerca basate su vettori.
  • Raccogli e visualizza le metriche in una dashboard.

Architettura di deployment

In questo tutorial, esegui il deployment di un cluster GKE regionale ad alta disponibilità per Elasticsearch, con più nodi Kubernetes distribuiti in diverse zone di disponibilità. Questa configurazione contribuisce a garantire tolleranza di errore, scalabilità e ridondanza geografica. Consente aggiornamenti e manutenzione continui, fornendo al contempo SLA per uptime e disponibilità. Per saperne di più, consulta Cluster regionali.

Quando un nodo diventa irraggiungibile, un pod su quel nodo non viene riprogrammato immediatamente. Con i pod che utilizzano uno StatefulSet, possono essere necessari più di otto minuti prima che i pod dell'applicazione vengano eliminati e riprogrammati su nuovi nodi.

Per risolvere questo problema, l'operatore StatefulHA esegue le seguenti operazioni:

  • Risolve il ritardo nella ripianificazione, gestisce le impostazioni di failover e riduce i tempi di ripristino utilizzando .forceDeleteStrategy: AfterNodeUnreachable.
  • Assicura che l'applicazione StatefulSet utilizzi RePD.
  • Estende GKE con una risorsa HighAvailabilityApplication personalizzata di cui viene eseguito il deployment nello stesso spazio dei nomi di Elasticsearch. Ciò consente all'operatore StatefulHA di monitorare e rispondere agli eventi di failover.

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

Architettura di deployment di Elasticsearch

Costi

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

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per ulteriori informazioni, vedi Pulizia.

L'utilizzo di Elasticsearch è gratuito ai sensi della Server Side Public License (SSPL).

Prima di iniziare

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

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. Install the Google Cloud CLI.

  3. Se utilizzi un provider di identità (IdP) esterno, devi prima accedere alla gcloud CLI con la tua identità federata.

  4. Per inizializzare gcloud CLI, esegui questo comando: 

    gcloud init

  5. Create or select a Google Cloud 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.

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Cloud Resource Manager, Compute Engine, GKE, IAM Service Account Credentials, and Backup for GKE APIs: 

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

  8. Install the Google Cloud CLI.

  9. Se utilizzi un provider di identità (IdP) esterno, devi prima accedere alla gcloud CLI con la tua identità federata.

  10. Per inizializzare gcloud CLI, esegui questo comando: 

    gcloud init

  11. Create or select a Google Cloud 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.

  12. Verify that billing is enabled for your Google Cloud project.

  13. Enable the Cloud Resource Manager, Compute Engine, GKE, IAM Service Account Credentials, and Backup for GKE APIs: 

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

  14. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/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:USER_IDENTIFIER" --role=ROLE

    Replace the following:

    • PROJECT_ID: your project ID.
    • USER_IDENTIFIER: the identifier for your user account—for example, myemail@example.com.
    • ROLE: the IAM role that you grant to your user account.

    15. Configura l'ambiente

    Per configurare l'ambiente con Cloud Shell:

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

      export PROJECT_ID=PROJECT_ID
export KUBERNETES_CLUSTER_PREFIX=elasticsearch
export REGION=us-central1
      • Sostituisci PROJECT_ID con l'ID progetto Google Cloud.

      Questo tutorial utilizza la regione us-central1 per creare le risorse di deployment.

    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 del codice campione da GitHub:

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

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

      cd kubernetes-engine-samples/databases/elasticsearch

    Crea l'infrastruttura del cluster

    In questa sezione, esegui uno script Terraform per creare un cluster GKE regionale privato e a disponibilità elevata per eseguire il deployment del database Elasticsearch.

    Puoi scegliere di eseguire il deployment di Elasticsearch utilizzando un cluster standard o Autopilot. Ognuno ha i suoi vantaggi e modelli di prezzi diversi.

    Autopilot

    Il seguente diagramma mostra un cluster GKE Autopilot di cui è stato eseguito il deployment nel progetto.

    Cluster GKE Autopilot

    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}

    GKE sostituisce le seguenti variabili in fase di runtime:

    • GOOGLE_OAUTH_ACCESS_TOKEN utilizza il comando gcloud auth print-access-token per recuperare un token di accesso che autentica le interazioni con varie API Google Cloud
    • PROJECT_ID, REGION e KUBERNETES_CLUSTER_PREFIX sono le variabili di ambiente definite nella sezione Configura l'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 elasticsearch-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 dei cluster.

    Standard

    Il seguente diagramma mostra un cluster GKE regionale privato Standard di cui è stato eseguito il deployment in tre zone diverse.

    Cluster GKE Standard

    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}

    GKE sostituisce le seguenti variabili in fase di runtime:

    • GOOGLE_OAUTH_ACCESS_TOKEN utilizza il comando gcloud auth print-access-token per recuperare un token di accesso che autentica le interazioni con varie API Google Cloud.
    • PROJECT_ID, REGION e KUBERNETES_CLUSTER_PREFIX sono le variabili di ambiente definite nella sezione Configura l'ambiente e assegnate alle nuove variabili pertinenti per il cluster Standard che stai creando.

    Quando richiesto, digita yes. Potrebbero essere necessari diversi minuti prima che questi comandi vengano completati e che 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 elasticsearch-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 la 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 --location ${REGION}

    Esegui il deployment del database Elasticsearch e dell'operatore StatefulHA

    In questa sezione, esegui il deployment del database Elasticsearch (in modalità cluster) e dell'operatore StatefulHA nel cluster GKE utilizzando il grafico Helm dell'operatore ECK.

    Il deployment crea un cluster GKE con la seguente configurazione:

    • Tre repliche dei nodi Elasticsearch.
    • DaemonSet per modificare le impostazioni della memoria virtuale, per prestazioni ottimali di Elasticsearch. Un DaemonSet è un controller Kubernetes che garantisce che una copia di un pod venga eseguita su ogni nodo di un cluster.
    • Configurazione di NodeAffinity e PodAntiAffinity per garantire una distribuzione corretta tra i nodi Kubernetes, ottimizzando l'utilizzo dei node pool e massimizzando la disponibilità in diverse zone.
    • Un operatore HA stateful che gestisce i processi di failover e garantisce l'alta disponibilità. Uno StatefulSet è un controller Kubernetes che mantiene un'identità univoca permanente per ciascuno dei suoi pod.
    • Per l'autenticazione, il database crea secret di Kubernetes con credenziali di autenticazione, password e certificati.

    Per utilizzare il grafico Helm per eseguire il deployment del database Elasticsearch:

    1. Attiva il componente aggiuntivo StatefulHA:

      Autopilot

      GKE abilita automaticamente il componente aggiuntivo StatefulHA al momento della creazione del cluster.

      Standard

      Esegui questo comando:

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

      Il completamento di questo comando e la visualizzazione dello stato pronto del cluster potrebbero richiedere 15 minuti.

    2. Crea una definizione di risorsa personalizzata (CRD) di Elastic Cloud on Kubernetes (ECK):

      kubectl apply -f https://download.elastic.co/downloads/eck/2.11.1/crds.yaml

    3. Esegui il deployment dell'operatore ECK:

      kubectl apply -f https://download.elastic.co/downloads/eck/2.11.1/operator.yaml

    4. Crea lo spazio dei nomi elastic per il database:

      kubectl create ns elastic

    5. Installa la risorsa HighAvailabilityApplication (HAA), che definisce le regole di failover per Elasticsearch.

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

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

      kind: HighAvailabilityApplication
apiVersion: ha.gke.io/v1
metadata:
  name: elasticsearch-ha-es-main
  namespace: elastic
spec:
  resourceSelection:
    resourceKind: StatefulSet
  policy:
    storageSettings:
      requireRegionalStorage: false
    failoverSettings:
      forceDeleteStrategy: AfterNodeUnreachable
      afterNodeUnreachable:
        afterNodeUnreachableSeconds: 20 # 60 seconds total

    6. Applica il manifest per creare un disco permanente SSD regionale StorageClass:

      kubectl apply -n elastic -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

    7. Esegui il deployment della risorsa DaemonSet per impostare la memoria virtuale in ogni nodo:

      kubectl apply -n elastic -f manifests/02-elasticsearch/mmap-count.yaml

      Il manifest mmap-count.yaml descrive DaemonSet:

      apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: max-map-count-setter
  labels:
    k8s-app: max-map-count-setter
spec:
  selector:
    matchLabels:
      name: max-map-count-setter
  template:
    metadata:
      labels:
        name: max-map-count-setter
    spec:
      initContainers:
        - name: max-map-count-setter
          image: docker.io/bash:5.2.21
          resources:
            limits:
              cpu: 100m
              memory: 32Mi
          securityContext:
            privileged: true
            runAsUser: 0
          command: ['/usr/local/bin/bash', '-e', '-c', 'echo 262144 > /proc/sys/vm/max_map_count']
      containers:
        - name: sleep
          image: docker.io/bash:5.2.21
          command: ['sleep', 'infinity']

    8. Applica il manifest per eseguire il deployment del cluster Elasticsearch:

      kubectl apply -n elastic -f manifests/02-elasticsearch/elasticsearch.yaml

      Il manifest elasticsearch.yaml descrive il deployment:

      apiVersion: elasticsearch.k8s.elastic.co/v1
kind: Elasticsearch
metadata:
  name: elasticsearch-ha
spec:
  version: 8.11.4
  nodeSets:
  - name: main
    count: 3
    volumeClaimTemplates:
    - metadata:
        name: elasticsearch-data 
      spec:
        accessModes:
        - ReadWriteOnce
        resources:
          requests:
            storage: 10Gi
        storageClassName: ha-regional
    config:
    podTemplate:
      metadata:
        labels:
          app.stateful/component: elasticsearch
      spec:
        initContainers:
        - name: max-map-count-check
          command: ['sh', '-c', "while true; do mmc=$(cat /proc/sys/vm/max_map_count); if [ ${mmc} -eq 262144 ]; then exit 0; fi; sleep 1; done"]
        containers:
        - name: metrics
          image: quay.io/prometheuscommunity/elasticsearch-exporter:v1.7.0
          command:
            - /bin/elasticsearch_exporter
            - --es.ssl-skip-verify
            - --es.uri=https://$(ES_USER):$(ES_PASSWORD)@localhost:9200
          securityContext:
            runAsNonRoot: true
            runAsGroup: 10000
            runAsUser: 10000
          resources:
            requests:
              memory: "128Mi"
              cpu: "25m"
            limits:
              memory: "128Mi"
              cpu: "100m"
          ports:
          - containerPort: 9114
          env:
          - name: ES_USER
            value: "elastic"
          - name: ES_PASSWORD
            valueFrom:
              secretKeyRef:
                name: elasticsearch-ha-es-elastic-user
                key: elastic
        - name: elasticsearch
          resources:
            limits:
              memory: 4Gi
              cpu: 1
        affinity:
          nodeAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
              - weight: 1
                preference:
                  matchExpressions:
                  - key: app.stateful/component
                    operator: In
                    values:
                    - elasticsearch
          podAntiAffinity:
            preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 1
              podAffinityTerm:
                labelSelector:
                  matchLabels:
                    app.stateful/component: elasticsearch
                topologyKey: topology.kubernetes.io/zone

      Attendi qualche minuto affinché il cluster Elasticsearch si avvii completamente.

    9. Controlla lo stato del deployment:

      kubectl get elasticsearch -n elastic --watch

      Se il database elasticsearch viene implementato correttamente, l'output è simile al seguente:

      NAME               HEALTH   NODES   VERSION   PHASE   AGE
elasticsearch-ha   green    3       8.11.4    Ready   2m30s

      Attendi che HEALTH venga visualizzato come green. Se necessario, premi Ctrl+C per uscire dal comando.

    10. Esegui il deployment di un bilanciatore del carico interno per accedere al database Elasticsearch in esecuzione nello stesso VPC del cluster GKE:

      kubectl apply -n elastic -f manifests/02-elasticsearch/ilb.yaml

      Il manifest ilb.yaml descrive il servizio LoadBalancer:

      apiVersion: v1
kind: Service
metadata:
  annotations:
    #cloud.google.com/neg: '{"ingress": true}'
    networking.gke.io/load-balancer-type: "Internal"
  labels:
    app.kubernetes.io/name: elasticsearch
  name: elastic-ilb
spec:
  ports:
  - name: https
    port: 9200
    protocol: TCP
    targetPort: 9200
  selector:
    common.k8s.elastic.co/type: elasticsearch
    elasticsearch.k8s.elastic.co/cluster-name: elasticsearch-ha
  type: LoadBalancer

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

      kubectl describe highavailabilityapplication elasticsearch-ha-es-main -n elastic

      L'output è simile al seguente:

      Status:
  Conditions:
    Last Transition Time:  2024-02-01T13:27:50Z
    Message:               Application is protected
    Observed Generation:   1
    Reason:                ApplicationProtected
    Status:                True
    Type:                  Protected
Events:                    <none>

    12. Una volta avviati i carichi di lavoro da GKE, verifica che GKE abbia creato i carichi di lavoro Elasticsearch:

      kubectl get pod,svc,statefulset,pdb,secret,daemonset -n elastic

      L'output è simile al seguente:

      NAME                             READY   STATUS    RESTARTS   AGE
pod/elasticsearch-ha-es-main-0   2/2     Running   0          7m16s
pod/elasticsearch-ha-es-main-1   2/2     Running   0          7m16s
pod/elasticsearch-ha-es-main-2   2/2     Running   0          7m16s
pod/max-map-count-setter-28wt9   1/1     Running   0          7m27s
pod/max-map-count-setter-cflsw   1/1     Running   0          7m27s
pod/max-map-count-setter-gzq9k   1/1     Running   0          7m27s

NAME                                        TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)    AGE
service/elasticsearch-ha-es-http            ClusterIP   10.52.8.28   <none>        9200/TCP   7m18s
service/elasticsearch-ha-es-internal-http   ClusterIP   10.52.3.48   <none>        9200/TCP   7m18s
service/elasticsearch-ha-es-main            ClusterIP   None         <none>        9200/TCP   7m16s
service/elasticsearch-ha-es-transport       ClusterIP   None         <none>        9300/TCP   7m18s

NAME                                        READY   AGE
statefulset.apps/elasticsearch-ha-es-main   3/3     7m16s

NAME                                                     MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
poddisruptionbudget.policy/elasticsearch-ha-es-default   2               N/A               1                     7m16s

NAME                                                 TYPE     DATA   AGE
secret/elasticsearch-ha-es-elastic-user              Opaque   1      7m18s
secret/elasticsearch-ha-es-file-settings             Opaque   1      7m16s
secret/elasticsearch-ha-es-http-ca-internal          Opaque   2      7m17s
secret/elasticsearch-ha-es-http-certs-internal       Opaque   3      7m17s
secret/elasticsearch-ha-es-http-certs-public         Opaque   2      7m17s
secret/elasticsearch-ha-es-internal-users            Opaque   4      7m18s
secret/elasticsearch-ha-es-main-es-config            Opaque   1      7m16s
secret/elasticsearch-ha-es-main-es-transport-certs   Opaque   7      7m16s
secret/elasticsearch-ha-es-remote-ca                 Opaque   1      7m16s
secret/elasticsearch-ha-es-transport-ca-internal     Opaque   2      7m16s
secret/elasticsearch-ha-es-transport-certs-public    Opaque   1      7m16s
secret/elasticsearch-ha-es-xpack-file-realm          Opaque   4      7m18s

NAME                                  DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
daemonset.apps/max-map-count-setter   6         6         6       6            6           <none>          13m

    Per il cluster Elasticsearch vengono create le seguenti risorse GKE:

    • StatefulSet Elasticsearch che controlla tre repliche di pod.
    • Un DaemonSet per configurare le impostazioni della memoria virtuale.
    • Servizi a cui connettersi a Elasticsearch.
    • Secret con credenziali di superutente e certificati correlati al servizio.
    • Pod operatore HA stateful e risorsa HighlyAvailableApplication, che monitorano attivamente l'applicazione Elasticsearch.

    Esegui query con il notebook Vertex AI Colab Enterprise

    Questa sezione spiega come generare incorporamenti nei documenti Elasticsearch ed eseguire query di ricerca semantica utilizzando il client Python Elasticsearch ufficiale nel notebook Colab Enterprise. Un documento in Elasticsearch è composto da vari campi, ciascuno accoppiato al valore corrispondente.

    Per saperne di più su Vertex AI Colab Enterprise, consulta la documentazione di Colab Enterprise.

    Best practice:

    Per utilizzare in modo efficace Elasticsearch, ti consigliamo di strutturare i dati in questi documenti, che vengono poi indicizzati a scopo di ricerca.

    In questo esempio, utilizzi un set di dati di un file CSV che contiene un elenco di libri di generi diversi. Elasticsearch funge da motore di ricerca e il pod che crei funge da client che esegue query sul database Elasticsearch.

    Puoi utilizzare un modello di runtime dedicato per il deployment nel VPC (Virtual Private Cloud) elasticsearch-vpc, in modo che il notebook possa comunicare con le risorse nel tuo cluster GKE.

    Creare un modello di runtime

    Per creare un modello di runtime Colab Enterprise:

    1. Nella console Google Cloud , vai alla pagina Modelli di runtime di Colab Enterprise e assicurati che il tuo progetto sia selezionato:

      Vai a Modelli di runtime

    2. Fai clic su Nuovo modello. Viene visualizzata la pagina Crea nuovo modello di runtime.

    3. Nella sezione Informazioni di base del runtime:

      • Nel campo Nome visualizzato, inserisci elastic-connect.
      • Nell'elenco a discesa Regione, seleziona us-central1. Si tratta della stessa regione del cluster GKE.

    4. Nella sezione Configura il calcolo:

      • Nell'elenco a discesa Tipo di macchina, seleziona e2-standard-2.
      • Nel campo Dimensione disco, inserisci 30.

    5. Nella sezione Networking e sicurezza:

      • Nell'elenco a discesa Rete, seleziona la rete in cui si trova il cluster GKE.
      • Nell'elenco a discesa Subnet, seleziona una subnet corrispondente.
      • Deseleziona la casella di controllo Abilita l'accesso a internet pubblico.

    6. Per completare la creazione del modello di runtime, fai clic su Crea. Il modello di runtime viene visualizzato nell'elenco della scheda Modelli di runtime.

    Crea un runtime

    Per creare un runtime Colab Enterprise:

    1. Nell'elenco dei modelli di runtime per il modello appena creato, nella colonna Azioni, fai clic su e poi su Crea runtime. Viene visualizzato il riquadro Crea runtime di Vertex AI.

    2. Per creare un runtime basato sul modello, fai clic su Crea.

    3. Nella scheda Runtime che si apre, attendi che lo stato diventi In buono stato.

    Importare il notebook

    Per importare il notebook in Colab Enterprise:

    1. Vai alla scheda I miei notebook e fai clic su Importa. Viene visualizzato il riquadro Importa blocchi note.

    2. In Origine importazione, seleziona URL.

    3. In URL notebook, inserisci il seguente link:

      https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/main/databases/elasticsearch/manifests/03-notebook/vector-database.ipynb

    4. Fai clic su Importa.

    Connettiti al runtime ed esegui query

    Per connetterti al runtime ed eseguire query:

    1. Nel notebook, accanto al pulsante Connetti, fai clic su Opzioni di connessione aggiuntive. Viene visualizzato il riquadro Connetti al runtime di Vertex AI.

    2. Seleziona Connetti a un runtime e poi Connetti a un runtime esistente.

    3. Seleziona il runtime che hai avviato e fai clic su Connetti.

    4. Per eseguire le celle del notebook, fai clic sul pulsante Esegui cella accanto a ogni cella di codice.

    Il blocco note contiene sia celle di codice sia testo che descrive ogni blocco di codice. L'esecuzione di una cella di codice esegue i relativi comandi e mostra un output. Puoi eseguire le celle in ordine o singole celle in base alle esigenze.

    Visualizzare le metriche Prometheus per il cluster

    Il cluster GKE è configurato con Google Cloud Managed Service per Prometheus, che consente la raccolta delle metriche nel formato Prometheus. Questo servizio fornisce una soluzione completamente gestita per il monitoraggio e gli avvisi, consentendo la raccolta, l'archiviazione e l'analisi delle metriche del cluster e delle relative applicazioni.

    Il seguente diagramma mostra come Prometheus raccoglie le metriche per il tuo cluster:

    Raccolta delle metriche Prometheus

    Il cluster GKE privato nel diagramma contiene i seguenti componenti:

    • Pod Elasticsearch che espongono le metriche sul percorso / e sulla porta 9114. Queste metriche vengono fornite dal container sidecar denominato metrics che contiene elasticsearch_exporter.
    • Raccoglitori basati su Prometheus che elaborano le metriche del pod Elasticsearch.
    • Una risorsa PodMonitoring che invia le metriche a Cloud Monitoring.

    La configurazione del cluster definisce un container sidecar con l'esportatore di metriche nel formato Prometheus:

    apiVersion: elasticsearch.k8s.elastic.co/v1
kind: Elasticsearch
metadata:
  name: elasticsearch-ha
spec:
  ...
  nodeSets:
  - name: main
    ...
    podTemplate:
      spec:
        containers:
        ...
        - name: metrics
          image: quay.io/prometheuscommunity/elasticsearch-exporter:v1.7.0
          command:
          - /bin/elasticsearch_exporter
          - --es.ssl-skip-verify
          - --es.uri=https://$(ES_USER):$(ES_PASSWORD)@localhost:9200
          ...
          env:
          - name: ES_USER
            value: "elastic"
          - name: ES_PASSWORD
            valueFrom:
            secretKeyRef:
              name: elasticsearch-ha-es-elastic-user
              key: elastic

    Per esportare e visualizzare le metriche, segui questi passaggi:

    1. Crea la risorsa PodMonitoring per estrarre le metriche in base a labelSelector:

      kubectl apply -n elastic -f manifests/04-prometheus-metrics/pod-monitoring.yaml

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

      apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: elasticsearch
spec:
  selector:
    matchLabels:
      app.stateful/component: elasticsearch
      elasticsearch.k8s.elastic.co/cluster-name: elasticsearch-ha
  endpoints:
  - port: 9114
    interval: 30s
    path: /metrics

      Dopo alcuni minuti, viene visualizzata la dashboard integrata "Panoramica di Elasticsearch Prometheus".

    2. Per visualizzare altri grafici correlati ai dati, importa una dashboard di Cloud Monitoring personalizzata 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 alle dashboard di Cloud Monitoring:

      Vai alla panoramica delle dashboard

    4. Nell'elenco delle dashboard, apri la dashboard ElasticSearch Overview. Potrebbero essere necessari 1-2 minuti per raccogliere e visualizzare le metriche.

      La dashboard mostra un conteggio delle metriche chiave:

      • Indici
      • Documenti e shard
      • Operazioni in attesa
      • Nodi in esecuzione con i relativi stati di integrità

    Esegui il backup della configurazione del cluster

    La funzionalità Backup per GKE consente di pianificare backup regolari dell'intera configurazione del cluster GKE, inclusi i workload di cui è stato eseguito il deployment e i relativi dati.

    In questo tutorial, configurerai un piano di backup per il tuo cluster GKE per eseguire backup di tutti i workload, inclusi secret e volumi, ogni giorno alle 3:00. Per garantire una gestione efficiente dello spazio di archiviazione, i backup più vecchi di tre giorni vengono eliminati automaticamente.

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

      gcloud container clusters update ${KUBERNETES_CLUSTER_PREFIX}-cluster \
    --project=${PROJECT_ID} \
    --location=${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 al 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: [elasticsearch-cluster-backup]
Waiting for operation [projects/PROJECT_ID/locations/us-central1/operations/operation-1706528750815-610142ffdc9ac-71be4a05-f61c99fc] to complete...⠹

      Il completamento dell'operazione potrebbe richiedere alcuni minuti. Al termine dell'esecuzione, l'output è simile al seguente:

      Created backup plan [elasticsearch-cluster-backup].

    3. Puoi vedere il piano di backup appena creato elasticsearch-cluster-backup elencato nella console di 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 creato per questo tutorial.

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

    Se hai eliminato il progetto, la pulizia è completa. Se non hai eliminato il 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=elasticsearch
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