Implementa una base de datos vectorial de Elasticsearch en GKE

Configura tu entorno

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

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

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

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

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

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

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}

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

Outputs:

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

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}

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

Outputs:

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

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:

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

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

3. Implementar el operador de ECK:

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

4. Crea el espacio de nombres elastic para la base de datos:

   kubectl create ns elastic
   

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

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

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

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

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

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

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

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

2. Espera a que GKE inicie el Pod de Jupyter:

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

3. 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}|"
   

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

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

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:

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

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

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

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

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

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

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