Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il deployment di un database vettoriale Elasticsearch su GKE

Autopilot Standard

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

I database vettoriali sono datastore specificamente progettati per gestire ed eseguire ricerche in grandi raccolte di vettori ad alta dimensione. Questi vettori rappresentano dati come testo, immagini, audio, video o qualsiasi altro dato che può essere codificato numericamente. A differenza dei database relazionali che si basano sulle corrispondenze esatte, quelli vettoriali sono specializzati nella ricerca di elementi simili o nell'identificazione di pattern all'interno di enormi set di dati.

Elasticsearch è un database vettoriale che combina funzionalità di ricerca e analisi. Include un'API REST aperta per la gestione del cluster e supporta query strutturate, query a testo intero e query complesse. Elasticsearch ti consente di eseguire ricerche per frasi, somiglianze e prefissi con suggerimenti di completamento automatico.

Questo tutorial è rivolto agli amministratori e architetti della piattaforma cloud, agli ingegneri ML e ai 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 per l'integrazione con altri servizi.
Scalabilità orizzontale e supporto per sharding e replica che semplifica la scalabilità e la disponibilità elevata.
Bilanciamento del cluster con più nodi per un utilizzo ottimale delle risorse.
al supporto di container e Kubernetes, per un'integrazione completa nei moderni ambienti cloud-native.

Obiettivi

In questo tutorial imparerai a:

Pianifica ed esegui il deployment dell'infrastruttura GKE per Elasticsearch.
Eseguire il deployment e configurare Elasticsearch in un cluster GKE.
Esegui il deployment dell'operatore StatefulHA per garantire l'alta disponibilità di Elasticsearch.
Caricare un set di dati demo ed eseguire una query di ricerca.
Raccogli e visualizza le metriche su una dashboard.

Architettura di deployment

In questo tutorial, eseguirai il deployment di un cluster GKE a livello di regione 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 in sequenza, fornendo al contempo SLA (accordi sul livello del servizio) per uptime e disponibilità. Per ulteriori informazioni, consulta Cluster a livello di regione.

Quando un nodo diventa non raggiungibile, un pod su quel nodo non viene ripianificato immediatamente. Con i pod che utilizzano uno StatefulSet, possono essere necessari più di otto minuti prima che i pod delle applicazioni vengano eliminati e ripianificati su nuovi nodi.

Per risolvere questo problema, l'operatore StatefulHA:

Risolve il ritardo di riprogrammazione, gestisce le impostazioni di failover e riduce i tempi di recupero utilizzando le impostazioni .forceDeleteStrategy: AfterNodeUnreachable.
Assicurati che l'applicazione StatefulSet utilizzi RePD.
Estende GKE con una risorsa HighAvailabilityApplication personalizzata di cui è stato 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 possono essere idonei a una prova senza costi aggiuntivi.

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.

L'utilizzo di ElasticSearch è gratuito in base alla licenza pubblica lato server (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 gli strumenti a riga di comando Google Cloud CLI, kubectl, Helm e Terraform. Se non utilizzi Cloud Shell, devi installare Google Cloud CLI.

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.

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Nota: se hai già installato gcloud CLI in precedenza, assicurati di disporre della versione più recente eseguendo

gcloud components
      update

Crea o seleziona un progetto Google Cloud.

Crea un progetto Google Cloud:
```
gcloud projects create PROJECT_ID
```
Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.
Seleziona il progetto Google Cloud che hai creato:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del tuo progetto Google Cloud.

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

Abilita le API Cloud 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

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Nota: se hai già installato gcloud CLI in precedenza, assicurati di disporre della versione più recente eseguendo

gcloud components
      update

Crea o seleziona un progetto Google Cloud.

Crea un progetto Google Cloud:
```
gcloud projects create PROJECT_ID
```
Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.
Seleziona il progetto Google Cloud che hai creato:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il nome del tuo progetto Google Cloud.

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

Abilita le API Cloud 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

Concedi i ruoli al tuo Account Google. Esegui questo comando una volta per ciascuno dei seguenti ruoli IAM: 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:EMAIL_ADDRESS" --role=ROLE
```
- Sostituisci PROJECT_ID con l'ID progetto.
- Sostituisci EMAIL_ADDRESS con il tuo indirizzo email.
- Sostituisci ROLE con ogni singolo ruolo.

Configura l'ambiente

Per configurare il tuo ambiente con Cloud Shell, segui questi passaggi:

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.

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

Clona il repository di codice campione da GitHub:

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

Passa alla directory elasticsearch per iniziare a creare risorse di deployment:
```
cd kubernetes-engine-samples/databases/elasticsearch
```

Crea l'infrastruttura del cluster

In questa sezione, eseguirai uno script Terraform per creare un cluster GKE privato a disponibilità elevata a livello di regione ed eseguire il deployment del tuo database Elasticsearch.

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

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 diverse API Google Cloud
PROJECT_ID, REGION e KUBERNETES_CLUSTER_PREFIX sono le variabili di ambiente definite nella sezione Configurare 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 risorse seguenti:

Una rete VPC personalizzata e una subnet privata per i nodi Kubernetes.
Un router Cloud per accedere a internet tramite NAT (Network Address Translation).
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 monitoraggio e avvisi dei 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.

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 Configurare l'ambiente e assegnate alle nuove variabili pertinenti per il cluster Standard che stai creando.

Quando richiesto, digita yes. Il completamento di questi comandi potrebbe richiedere diversi minuti e 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 risorse seguenti:

Una rete VPC personalizzata e una subnet privata per i nodi Kubernetes.
Un router Cloud per accedere a internet tramite NAT (Network Address Translation).
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 tuo nuovo cluster GKE:

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

Esegui il deployment del database Elasticsearch e dell'operatore StatefulHA

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

Il deployment crea un cluster GKE con la seguente configurazione:

Tre repliche dei nodi Elasticsearch.
DaemonSet per modificare le impostazioni della memoria virtuale, al fine di ottimizzare le prestazioni di Elasticsearch.
Configurazione di NodeAffinity e PodAntiAffinity per garantire una corretta distribuzione tra i nodi Kubernetes, ottimizzando l'uso dei pool di nodi e massimizzando la disponibilità in diverse zone.
Un operatore ad alta disponibilità stateful che gestisce i processi di failover e garantisce l'alta disponibilità.
Per l'autenticazione, il database crea Secret Kubernetes con credenziali di autenticazione, password e certificati.

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

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} \
    --region=${REGION} \
    --update-addons=StatefulHA=ENABLED
```
Il completamento di questo comando potrebbe richiedere 15 minuti e il cluster potrebbe mostrare lo stato Pronto.
Crea una definizione di risorsa personalizzata (CRD) Elastic Cloud su Kubernetes (ECK):
```
kubectl apply -f https://download.elastic.co/downloads/eck/2.11.1/crds.yaml
```

Esegui il deployment dell'operatore ECK:

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

Crea lo spazio dei nomi elastic per il database:
```
kubectl create ns elastic
```

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

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

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

Il file 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

Esegui il deployment della risorsa DaemonSet per impostare la memoria virtuale in ciascun nodo:

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

Il file 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']

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 per l'avvio completo del cluster Elasticsearch.

Controlla lo stato del deployment:
```
kubectl get elasticsearch -n elastic --watch
```
L'output è simile al seguente, se il deployment del database elasticsearch è stato eseguito correttamente:
```
NAME               HEALTH   NODES   VERSION   PHASE   AGE
elasticsearch-ha   green    3       8.11.4    Ready   2m30s
```
Attendi che HEALTH venga visualizzato come green. Premi Ctrl+C per uscire dal comando, se necessario.

Per verificare se le regole di failover vengono 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>

Dopo che GKE ha avviato i carichi di lavoro, 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

Le seguenti risorse GKE vengono create per il cluster Elasticsearch:

L'elemento Elasticsearch StatefulSet che controlla tre repliche di pod.
Un DaemonSet per configurare le impostazioni della memoria virtuale.
Servizi per la connessione a Elasticsearch.
Secret con credenziali di super user e certificati relativi ai servizi.
Pod dell'operatore ad alta disponibilità stateful e risorsa HighlyAvailableApplication, monitoraggio attivo dell'applicazione Elasticsearch.

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

In questa sezione caricherai i vettori nei documenti Elasticsearch ed eseguirai query di ricerca semantica utilizzando il client Python ufficiale Elasticsearch. Un documento in Elasticsearch è composto da vari campi, ognuno dei quali è abbinato al valore corrispondente. Per utilizzare in modo efficace Elasticsearch, ti consigliamo di strutturare i dati in questi documenti, che vengono poi indicizzati per scopi di ricerca.

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

Crea gli oggetti ConfigMap books-dataset e notebook ed esegui il pod Jupyter per interagire con il cluster Elasticsearch:

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

Il secret denominato elasticsearch-ha-es-elastic-user creato in precedenza è montato nel pod client come variabile di ambiente denominata PW.
Il ConfigMap books-dataset contiene un file csv con i dati dei libri per l'indice Elasticsearch.
Il ConfigMap notebook contiene il blocco note Jupyter per creare l'indice Elasticsearch da books-dataset.

Il manifest jupyter.yaml descrive il deployment notebook e il relativo servizio:

---
apiVersion: v1
kind: Service
metadata:
  labels: &labels
    app: jupyter-notebook
  name: notebook
spec:
  ports:
  - port: 8888
  selector: *labels
  type: LoadBalancer
  # type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: notebook
  labels: &labels
    app: jupyter-notebook
spec:
  selector:
    matchLabels: *labels
  template:
    metadata: 
      labels: *labels
    spec:
      containers:
      - name: jupyter
        image: tensorflow/tensorflow:2.15.0-jupyter
        resources:
          requests:
            memory: "4500Mi"
            cpu: "1"
          limits:
            memory: "4500Mi"
            cpu: "1"
        ports:
        - containerPort: 8888
        env:
        - name: PW
          valueFrom:
            secretKeyRef:
              name: elasticsearch-ha-es-elastic-user
              key: elastic
        volumeMounts:
        - name: books-dataset
          mountPath: /usr/local/dataset
        - name: notebook
          mountPath: /tf
        - name: elastic-cert
          mountPath: /usr/local/cert
      volumes:
      - name: books-dataset
        configMap:
          name: books-dataset
      - name: notebook
        configMap:
          name: notebook
      - name: elastic-cert
        secret:
          secretName: elasticsearch-ha-es-http-certs-public

Attendi che GKE avvii il pod Jupyter:

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

Recupera l'URL con il token di accesso per connetterti a Jupyter:

export EXTERNAL_IP=$(kubectl -n elastic get svc notebook --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
kubectl logs deploy/notebook -n elastic| grep '^ .*http://127'|sed "s|127.0.0.1|${EXTERNAL_IP}|"

Apri questo URL e fai clic sul file vector-database.ipynb.

Fai clic su Esegui > Esegui tutte le celle. Jupyter esegue il codice ed esegue una query di ricerca per il testo drama about people and unhappy love.

Questa query esegue una ricerca semantica sul tuo indice books in Elasticsearch, recuperando un massimo di due risultati con il punteggio di corrispondenza più alto pertinente alla query.

L'output è simile al seguente:

Title: Romeo and Juliet, Author: William Shakespeare, Paul Werstine (Editor),
Barbara A. Mowat (Editor), Paavo Emil Cajander (Translator), score: 1.8473973
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.
---------
Title: A Midsummer Night's Dream, Author: William Shakespeare, Paul Werstine
(Editor), Barbara A. Mowat (Editor), Catherine Belsey (Contributor), score: 1.8415744
Shakespeare's intertwined love polygons begin to get complicated from the
start--Demetrius and Lysander both want Hermia but she only has eyes for Lysander.
Bad news is, Hermia's father wants Demetrius for a son-in-law. On the outside
is Helena, whose unreturned love burns hot for Demetrius. Hermia and Lysander
plan to flee from the city under cover of darkness but are pursued by an enraged
Demetrius (who is himself pursued by an enraptured Helena). In the forest, unbeknownst
to the mortals, Oberon and Titania (King and Queen of the faeries) are having a
spat over a servant boy. The plot twists up when Oberon's head mischief-maker,
Puck, runs loose with a flower which causes people to fall in love with the first
thing they see upon waking. Throw in a group of labourers preparing a play for
the Duke's wedding (one of whom is given a donkey's head and Titania for a lover
by Puck) and the complications become fantastically funny.
---------

Visualizza le metriche di Prometheus per il tuo cluster

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

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

Raccolta di metriche Prometheus

Il cluster privato GKE nel diagramma contiene i seguenti componenti:

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

La configurazione del cluster definisce un container collaterale con un 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:

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

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

Il 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 "Elasticsearch Prometheus Overview".

Per visualizzare altri grafici relativi 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
```
Una volta eseguito correttamente il comando, vai alle dashboard di Cloud Monitoring:

Vai alla panoramica delle dashboard
Dall'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 carichi di lavoro 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 i 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 più vecchi di tre giorni vengono eliminati automaticamente.

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

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: [elasticsearch-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. Al termine dell'esecuzione, l'output è simile al seguente:

Created backup plan [elasticsearch-cluster-backup].

Puoi visualizzare il piano di backup elasticsearch-cluster-backup appena creato nell'elenco della console di Backup per GKE.

Vai a Backup per GKE

Se vuoi ripristinare le configurazioni di backup salvate, vedi 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 che hai creato per 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 è completata. Se non hai eliminato il progetto, procedi con l'eliminazione delle singole risorse.

Elimina singole risorse

Imposta le variabili di ambiente.

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

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.

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)")

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

Elimina il repository GitHub:
```
rm -r ~/kubernetes-engine-samples/
```

Passaggi successivi

Scopri il software open source Elasticsearch.
Scopri le best practice per il deployment dei database su GKE.
Scopri le soluzioni per l'esecuzione di carichi di lavoro ad alta intensità di dati con GKE.