Implementa una base de datos vectorial de Elasticsearch en GKE

Autopilot Standard

En este instructivo, se muestra cómo implementar un clúster de base de datos vectorial de Elasticsearch en Google Kubernetes Engine (GKE).

Las bases de datos vectoriales son almacenes de datos diseñados específicamente para administrar y buscar en grandes colecciones de vectores de alta dimensión. Estos vectores representan datos como texto, imágenes, audio, video o cualquier dato que se pueda codificar de forma numérica. A diferencia de las bases de datos relacionales, que se basan en coincidencias exactas, las bases de datos vectoriales se especializan en encontrar elementos similares o identificar patrones dentro de conjuntos de datos masivos.

Elasticsearch es una base de datos vectorial que combina funciones de búsqueda y estadísticas. Viene con una API de REST abierta para administrar tu clúster y admite consultas estructuradas, consultas de texto completo y consultas complejas. Elasticsearch te permite realizar búsquedas de frases, similitudes y prefijos con sugerencias de autocompletar.

Este instructivo está dirigido a administradores y arquitectos de plataformas de nube, ingenieros de AA y profesionales de MLOps (DevOps) interesados en implementar clústeres de bases de datos de Elasticsearch en GKE.

Ventajas

Elasticsearch ofrece los siguientes beneficios:

Amplia variedad de bibliotecas para varios lenguajes de programación y API abierta para integrar en otros servicios.
Escalamiento horizontal y compatibilidad con la fragmentación y la replicación que simplifica el escalamiento y la alta disponibilidad.
Balanceo de clústeres de varios nodos para un uso óptimo de los recursos.
Compatibilidad con contenedores y Kubernetes para una integración perfecta en entornos modernos nativos de la nube.

Objetivos

En este instructivo, aprenderás a realizar lo siguiente:

Planificar y, además, implementar la infraestructura de GKE para Elasticsearch.
Implementar y configurar Elasticsearch en un clúster de GKE.
Implementar el operador StatefulHA para garantizar la alta disponibilidad de Elasticsearch.
Subir un conjunto de datos de demostración y ejecutar una búsqueda.
Recopilar y visualizar métricas en un panel.

Arquitectura de implementación

En este instructivo, implementarás un clúster de GKE regional con alta disponibilidad para Elasticsearch, con varios nodos de Kubernetes distribuidos en varias zonas de disponibilidad. Esta configuración ayuda a garantizar la tolerancia a errores, la escalabilidad y la redundancia geográfica. Permite realizar actualizaciones y mantenimiento progresivos, a la vez que proporciona ANS de tiempo de actividad y disponibilidad. Para obtener más información, consulta Clústeres regionales.

Cuando un nodo se vuelve inaccesible, un Pod de ese nodo no se reprograma de inmediato. Con los Pods que usan un StatefulSet, pueden pasar más de ocho minutos hasta que los Pods de la aplicación se borren y se reprogramen en nodos nuevos.

Para abordar este problema, el operador StatefulHA hace lo siguiente:

Resuelve el retraso de reprogramación, controla la configuración de la conmutación por error y acorta el tiempo de recuperación; para ello, usa la configuración de .forceDeleteStrategy: AfterNodeUnreachable.
Garantiza que la aplicación StatefulSet use RePD.
Extiende GKE con un recurso HighAvailabilityApplication personalizado que se implementa en el mismo espacio de nombres que Elasticsearch. Esto permite que el operador de StatefulHA supervise y responda a los eventos de conmutación por error.

En el siguiente diagrama, se muestra un clúster de Elasticsearch que se ejecuta en múltiples nodos y zonas de un clúster de GKE:

Arquitectura de implementación de Elasticsearch

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

El uso de Elasticsearch es gratuito bajo la licencia pública del servidor (SSPL).

Antes de comenzar

En este instructivo, usarás Cloud Shell para ejecutar comandos. Cloud Shell es un entorno de shell que se usa para administrar recursos alojados en Google Cloud. Viene preinstalado con las herramientas de línea de comando de Google Cloud CLI, kubectl, Helm y Terraform. Si no usas Cloud Shell, debes instalar Google Cloud CLI.

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.

Install the Google Cloud CLI.

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

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.

Make sure that billing is enabled for your Google Cloud project.

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

Install the Google Cloud CLI.

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

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.

Make sure that billing is enabled for your Google Cloud project.

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

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:myemail@example.com.
- Replace ROLE with each individual role.

Configura tu entorno

Para configurar tu entorno con Cloud Shell, sigue estos pasos:

Configura las variables de entorno del proyecto, la región y el prefijo de recursos del clúster de Kubernetes:
```
export PROJECT_ID=PROJECT_ID
export KUBERNETES_CLUSTER_PREFIX=elasticsearch
export REGION=us-central1
```
- Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.
En este instructivo, se usa la región us-central1 para crear los recursos de implementación.

Verifica la versión de Helm:

helm version

Actualiza la versión si es anterior a la 3.13:

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

Clona el repositorio de código de muestra de GitHub:

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

Navega al directorio elasticsearch para comenzar a crear recursos de implementación:
```
cd kubernetes-engine-samples/databases/elasticsearch
```

Crea la infraestructura del clúster

En esta sección, debes ejecutar una secuencia de comandos de Terraform para crear un clúster de GKE regional, con alta disponibilidad y privado para implementar tu base de datos de Elasticsearch.

Puedes implementar Elasticsearch mediante un clúster de Standard o Autopilot. Cada uno tiene sus propias ventajas y diferentes modelos de precios.

Autopilot

En el siguiente diagrama, se muestra un clúster de GKE Autopilot implementado en el proyecto.

Clúster de GKE Autopilot

Para implementar la infraestructura del clúster, ejecuta los siguientes comandos en 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 reemplaza las siguientes variables en el entorno de ejecución:

GOOGLE_OAUTH_ACCESS_TOKEN usa el comando gcloud auth print-access-token para recuperar un token de acceso que autentica las interacciones con varias APIs de Google Cloud
PROJECT_ID, REGION y KUBERNETES_CLUSTER_PREFIX son las variables de entorno definidas en la sección Configura tu entorno y asignadas a las nuevas variables relevantes para el clúster de Autopilot que creas.

Cuando se te solicite, escribe yes.

El resultado es similar al siguiente:

...
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 los siguientes recursos:

Una red de VPC personalizada y una subred privada para los nodos de Kubernetes
Un Cloud Router para acceder a Internet a través de la traducción de direcciones de red (NAT).
Un clúster de GKE privado en la región us-central1.
Un ServiceAccount con permisos de registro y supervisión para el clúster.
Configuración de Google Cloud Managed Service para Prometheus para la supervisión y las alertas de clústeres.

Estándar

En el siguiente diagrama, se muestra un clúster de GKE regional privado de Standard implementado en tres zonas diferentes.

Clúster de GKE Standard

Para implementar la infraestructura del clúster, ejecuta los siguientes comandos en 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 reemplaza las siguientes variables en el entorno de ejecución:

GOOGLE_OAUTH_ACCESS_TOKEN usa el comando gcloud auth print-access-token para recuperar un token de acceso que autentica las interacciones con varias APIs de Google Cloud.
PROJECT_ID, REGION y KUBERNETES_CLUSTER_PREFIX son las variables de entorno definidas en la sección Configura tu entorno y asignadas a las nuevas variables relevantes para el clúster de Standard que creas.

Cuando se te solicite, escribe yes. Es posible que estos comandos tarden varios minutos en completarse y que el clúster muestre un estado de preparación.

El resultado es similar al siguiente:

...
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 los siguientes recursos:

Una red de VPC personalizada y una subred privada para los nodos de Kubernetes
Un Cloud Router para acceder a Internet a través de la traducción de direcciones de red (NAT).
Un clúster de GKE privado en la región us-central1 con el ajuste de escala automático habilitado (de uno a dos nodos por zona).
Un ServiceAccount con permisos de registro y supervisión para el clúster.
Configuración de Google Cloud Managed Service para Prometheus para la supervisión y las alertas de clústeres.

Conéctate al clúster

Configura kubectl para recuperar credenciales y comunicarte con tu clúster de GKE nuevo:

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

Implementa la base de datos de Elasticsearch y el operador StatefulHA

En esta sección, implementarás la base de datos de Elasticsearch (en modo de clúster) y el operador StatefulHA en tu clúster de GKE con el Gráfico de Helm para operadores de ECK.

El objeto Deployment crea un clúster de GKE con la siguiente configuración:

Tres réplicas de los nodos de Elasticsearch.
DaemonSet para cambiar la configuración de memoria virtual para obtener un rendimiento óptimo de Elasticsearch.
Configuración de NodeAffinity y PodAntiAffinity para garantizar una distribución adecuada entre los nodos de Kubernetes, lo que optimiza el uso de grupos de nodos y maximiza la disponibilidad en las diferentes zonas.
Un operador de HA con estado que administra los procesos de conmutación por error y garantiza una alta disponibilidad.
Para la autenticación, la base de datos crea objetos Secret de Kubernetes con credenciales de autenticación, contraseñas y certificados.

Para usar el gráfico de Helm para implementar la base de datos de Elasticsearch, sigue estos pasos:

Habilita el complemento StatefulHA:
Autopilot
GKE habilita automáticamente el complemento StatefulHA durante la creación del clúster.
Estándar
Ejecuta el siguiente comando:
```
gcloud container clusters update ${KUBERNETES_CLUSTER_PREFIX}-cluster \
    --project=${PROJECT_ID} \
    --region=${REGION} \
    --update-addons=StatefulHA=ENABLED
```
Es posible que este comando tarde 15 minutos en completarse y que el clúster muestre un estado de preparación.
Crea una definición de recurso personalizado (CRD) de Elastic Cloud on Kubernetes (ECK):
```
kubectl apply -f https://download.elastic.co/downloads/eck/2.11.1/crds.yaml
```

Implementar el operador de ECK:

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

Crea el espacio de nombres elastic para la base de datos:
```
kubectl create ns elastic
```

Instala el recurso HighAvailabilityApplication (HAA), que define las reglas de conmutación por error para Elasticsearch.

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

El manifiesto ha-app.yaml describe el recurso 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

Aplica el manifiesto para crear un disco SSD persistente regional StorageClass:

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

El manifiesto regional-pd.yaml describe el disco SSD persistente 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

Implementa el recurso DaemonSet para establecer la memoria virtual en cada nodo:

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

El manifiesto mmap-count.yaml describe el 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']

Aplica el manifiesto para implementar el clúster de Elasticsearch:

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

El manifiesto elasticsearch.yaml describe el 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

Espera unos minutos para que el clúster de Elasticsearch se inicie por completo.

Verifica el estado de la implementación:
```
kubectl get elasticsearch -n elastic --watch
```
El resultado es similar al siguiente, si la base de datos elasticsearch se implementó de forma correcta:
```
NAME               HEALTH   NODES   VERSION   PHASE   AGE
elasticsearch-ha   green    3       8.11.4    Ready   2m30s
```
Espera a que HEALTH se muestre como green. Presiona Ctrl+C para salir del comando si es necesario.

Para verificar si se aplican las reglas de conmutación por error, describe el recurso y confirma Status: Message: Application is protected.

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

El resultado es similar al siguiente:

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>

Una vez que GKE inicie las cargas de trabajo, verifica que GKE haya creado las cargas de trabajo de Elasticsearch:

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

El resultado es similar al siguiente:

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

Los siguientes recursos de GKE se crean para el clúster de Elasticsearch:

El StatefulSet de Elasticsearch que controla tres réplicas de Pods.
Un DaemonSet para establecer la configuración de memoria virtual.
Servicios para conectarse a Elasticsearch.
Secrets con credenciales de superusuario y certificados relacionados con el servicio.
Pod de operador de HA con estado y recurso HighlyAvailableApplication, que supervisan de forma activa la aplicación de Elasticsearch.

Sube un conjunto de datos de demostración y ejecuta búsquedas con el notebook de Jupyter

En esta sección, subirás vectores a documentos de Elasticsearch y realizarás búsquedas semánticas con el cliente oficial de Python de Elasticsearch. Un documento en Elasticsearch se compone de varios campos, cada uno vinculado con su valor correspondiente. Para utilizar Elasticsearch de manera eficaz, te recomendamos estructurar los datos en estos documentos, que luego se indexarán para fines de búsqueda.

En este ejemplo, se usa un conjunto de datos de un archivo CSV que contiene una lista de libros de diferentes géneros. Elasticsearch sirve como motor de búsqueda y el Pod que creas sirve como un cliente que consulta la base de datos de Elasticsearch.

Crea los ConfigMaps books-dataset y notebook, y ejecuta el Pod de Jupyter para interactuar con tu clúster de 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

El Secret con el nombre elasticsearch-ha-es-elastic-user que se creó antes se activa en el Pod del cliente como una variable de entorno llamada PW.
El ConfigMap books-dataset contiene un archivo csv con datos de libros para el índice de Elasticsearch.
El ConfigMap notebook contiene el notebook de Jupyter para crear el índice de Elasticsearch a partir de books-dataset.

En el manifiesto de jupyter.yaml, se describe el objeto Deployment notebook y su Service:

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

Espera a que GKE inicie el Pod de Jupyter:

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

Obtén la URL con el token de acceso para conectarte 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}|"

Abre esta URL y haz clic en el archivo vector-database.ipynb.

Haz clic en Ejecutar > Ejecutar todas las celdas. Jupyter ejecuta el código y realiza una búsqueda para el texto drama about people and unhappy love.

Esta consulta realiza una búsqueda semántica en el índice books de Elasticsearch y recupera un máximo de dos resultados con la puntuación de coincidencia más alta relevante para tu consulta.

El resultado es similar al siguiente:

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

Visualiza las métricas de Prometheus de tu clúster

El clúster de GKE se configura con Google Cloud Managed Service para Prometheus, que permite la recopilación de métricas en el formato Prometheus. Este servicio proporciona una solución completamente administrada para la supervisión y las alertas, lo que permite la recopilación, el almacenamiento y el análisis de métricas del clúster y sus aplicaciones.

En el siguiente diagrama, se muestra cómo Prometheus recopila métricas para tu clúster:

Recopilación de métricas de Prometheus

El clúster privado de GKE en el diagrama contiene los siguientes componentes:

Pods de Elasticsearch que exponen métricas en la ruta / y el puerto 9114. El contenedor de archivo adicional llamado metrics proporciona estas métricas y contiene el elasticsearch_exporter.
Recopiladores basados en Prometheus que procesan las métricas del Pod de Elasticsearch
Un recurso PodMonitoring que envía las métricas a Cloud Monitoring.

La configuración del clúster define un contenedor de archivo adicional con el exportador de métricas en el 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

Para exportar y ver las métricas, sigue estos pasos:

Crea el recurso PodMonitoring para extraer métricas por labelSelector:

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

El manifiesto pod-monitoring.yaml describe el recurso 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

Después de unos minutos, se mostrará el panel integrado “Elasticsearch Prometheus Overview”.

Para ver más gráficos relacionados con los datos, importa un panel de Cloud Monitoring personalizado con los parámetros de configuración definidos en dashboard.json:
```
gcloud --project "${PROJECT_ID}" monitoring dashboards create --config-from-file monitoring/dashboard.json
```
Después de que el comando se ejecute de forma correcta, ve a los Paneles de Cloud Monitoring:

Ir a Descripción general de los paneles
En la lista de paneles, abre el panel ElasticSearch Overview. La recopilación y visualización de las métricas puede llevar entre 1 y 2 minutos.

En el panel, se muestra un recuento de las métricas clave:
- Índices
- Documentos y fragmentos
- Operaciones pendientes
- Ejecuta nodos con sus estados

Crea una copia de seguridad de la configuración del clúster

La función Copia de seguridad para GKE te permite programar copias de seguridad regulares de toda la configuración del clúster de GKE, incluidas las cargas de trabajo implementadas y sus datos.

En este instructivo, configurarás un plan de copia de seguridad para tu clúster de GKE a fin de realizar copias de seguridad de todas las cargas de trabajo, incluidos Secrets y Volumes, todos los días a las 3 a.m. Para garantizar una administración del almacenamiento eficiente, las copias de seguridad que tengan más de tres días se borran automáticamente.

Habilita la función Copia de seguridad para GKE en tu clúster:

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

Crea un plan de copia de seguridad con un programa diario para todos los espacios de nombres dentro del clúster:

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

El comando usa las variables de entorno relevantes en el entorno de ejecución.

El formato del nombre del clúster se relaciona con tu proyecto y región de la siguiente manera:

projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_NAME

Cuando se te solicite, escribe y.. El resultado es similar al siguiente:

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

Esta operación puede tardar unos minutos en completarse correctamente. Una vez que se completa la ejecución, el resultado es similar al siguiente:

Created backup plan [elasticsearch-cluster-backup].

Puedes ver el plan de copia de seguridad recién creado elasticsearch-cluster-backup en la consola de Copia de seguridad para GKE.

Ir a Copia de seguridad para GKE

Si deseas restablecer las opciones de configuración de copia de seguridad guardadas, consulta Restablece una copia de seguridad.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

La manera más fácil de evitar la facturación es borrar el proyecto que creaste para el instructivo.

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Si borraste el proyecto, tu limpieza se completó. Si no borraste el proyecto, borra los recursos individuales.

Borra los recursos individuales

Configurar variables de entorno

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

Ejecuta el 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}

Reemplaza FOLDER por gke-autopilot o gke-standard, según el tipo de clúster de GKE que hayas creado.

Cuando se te solicite, escribe yes.

Busca todos los discos no conectados:

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

Borra los discos:

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

Borra el repositorio de GitHub
```
rm -r ~/kubernetes-engine-samples/
```

¿Qué sigue?

Explora el software de código abierto de Elasticsearch.
Conoce las prácticas recomendadas para implementar bases de datos en GKE.
Descubre soluciones para ejecutar cargas de trabajo con uso intensivo de datos con GKE.