Desplegar una base de datos de vectores de Qdrant en GKE

En esta guía se muestra cómo desplegar un clúster de base de datos de vectores Qdrant en Google Kubernetes Engine (GKE).

Las bases de datos vectoriales son almacenes de datos diseñados específicamente para gestionar y buscar grandes colecciones de vectores de alta dimensión. Estos vectores representan datos como texto, imágenes, audio, vídeo o cualquier dato que se pueda codificar numéricamente. A diferencia de las bases de datos tradicionales, que se basan en coincidencias exactas, las bases de datos vectoriales se especializan en encontrar elementos similares o identificar patrones en conjuntos de datos masivos. Estas características hacen que Qdrant sea una opción adecuada para diversas aplicaciones, como la concordancia basada en redes neuronales o semántica, la búsqueda facetada y más. Qdrant no solo funciona como una base de datos vectorial, sino también como un motor de búsqueda de similitud vectorial.

Este tutorial está dirigido a administradores y arquitectos de plataformas en la nube, ingenieros de aprendizaje automático y profesionales de MLOps (DevOps) que quieran desplegar clústeres de bases de datos de Qdrant en GKE.

Ventajas

Qdrant ofrece las siguientes ventajas:

  • Amplia gama de bibliotecas para varios lenguajes de programación y API abierta para integrarse con otros servicios.
  • Escalado horizontal y compatibilidad con la fragmentación y la replicación, lo que simplifica el escalado y la alta disponibilidad.
  • Compatibilidad con contenedores y Kubernetes para permitir el despliegue y la gestión en entornos nativos de la nube modernos.
  • Cargas útiles flexibles con filtrado avanzado para adaptar los criterios de búsqueda con precisión.
  • Diferentes opciones de cuantización y otras optimizaciones para reducir los costes de infraestructura y mejorar el rendimiento.

Objetivos

En este tutorial, aprenderás a hacer lo siguiente:

  • Planifica y despliega la infraestructura de GKE para Qdrant.
  • Despliega el operador StatefulHA para asegurar la alta disponibilidad de Qdrant.
  • Implementa y configura el clúster de Qdrant.
  • Sube un conjunto de datos de demostración y ejecuta una consulta de búsqueda sencilla.
  • Recoger métricas y ejecutar un panel de control.

Arquitectura de despliegue

Esta arquitectura configura un clúster de GKE tolerante a fallos y escalable para Qdrant en varias zonas de disponibilidad, lo que garantiza el tiempo de actividad y la disponibilidad con actualizaciones continuas y mínimas interrupciones. Incluye el uso del operador StatefulHA para gestionar las conmutaciones por error de forma eficiente. Para obtener más información, consulta Clústeres regionales.

Diagrama de la arquitectura

En el siguiente diagrama se muestra un clúster de Qdrant que se ejecuta en varios nodos y zonas de un clúster de GKE:

Arquitectura de implementación de Qdrant

En esta arquitectura, Qdrant StatefulSet se implementa en tres nodos de tres zonas diferentes.

  • Puedes controlar cómo distribuye GKE los pods entre los nodos configurando las reglas de afinidad y las restricciones de distribución de topología de los pods necesarios en el archivo de valores del gráfico de Helm.
  • Si falla una zona, GKE vuelve a programar los pods en nodos nuevos según la configuración recomendada.

Para la persistencia de datos, la arquitectura de este tutorial tiene las siguientes características:

  • Usa discos SSD regionales (regional-pd StorageClass personalizado) para conservar los datos. Recomendamos los discos SSD regionales para las bases de datos debido a su baja latencia y a su alto número de operaciones de entrada/salida por segundo (IOPS).
  • Todos los datos del disco se replican entre las zonas primaria y secundaria de la región, lo que aumenta la tolerancia a posibles fallos de la zona.

Configurar un entorno

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

  1. Define las variables de entorno de tu proyecto, región y prefijo de recurso de clúster de Kubernetes:

    En este tutorial, usaremos la región us-central1 para crear los recursos de implementación.

    export PROJECT_ID=PROJECT_ID
export KUBERNETES_CLUSTER_PREFIX=qdrant
export REGION=us-central1
    • Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

  2. Comprueba 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 ejemplo de GitHub:

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

  4. Ve al directorio qdrant para empezar a crear recursos de implementación:

    cd kubernetes-engine-samples/databases/qdrant

Crear la infraestructura del clúster

En esta sección, se ejecuta una secuencia de comandos de Terraform para crear un clúster de GKE privado, de alta disponibilidad y regional para desplegar tu base de datos de Qdrant.

Puedes elegir desplegar Qdrant con un clúster estándar o Autopilot. Cada una tiene sus propias ventajas y modelos de precios diferentes.

Autopilot

En el siguiente diagrama se muestra un clúster regional de Autopilot de GKE desplegado en tres zonas diferentes.

Clúster de Autopilot de GKE

Para desplegar 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}

Las siguientes variables se sustituyen en el tiempo de ejecución:

  • GOOGLE_OAUTH_ACCESS_TOKEN: se sustituye por un token de acceso obtenido mediante el comando gcloud auth print-access-token para autenticar 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 Configurar el entorno y asignadas a las nuevas variables relevantes del clúster de Autopilot que estás creando.

Cuando se te solicite, escribe yes.

El resultado debería ser similar al siguiente:

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

Outputs:

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

Terraform crea 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 monitorización para el clúster.
  • Configuración de Google Cloud Managed Service para Prometheus para la monitorización y las alertas de clústeres.

Estándar

En el siguiente diagrama se muestra un clúster de GKE regional privado estándar desplegado en tres zonas diferentes.

Clúster de GKE Standard

Para desplegar 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}

Las siguientes variables se sustituyen en el tiempo de ejecución:

  • GOOGLE_OAUTH_ACCESS_TOKEN se sustituye por un token de acceso obtenido mediante el comando gcloud auth print-access-token para autenticar 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 Configurar el entorno y asignadas a las nuevas variables relevantes del clúster estándar que estás creando.

Cuando se te solicite, escribe yes. Estos comandos pueden tardar varios minutos en completarse y el clúster en mostrar el estado "Listo".

El resultado debería ser similar al siguiente:

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

Outputs:

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

Terraform crea 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 privado de GKE en la región us-central1 con el autoescalado habilitado (de uno a dos nodos por zona).
  • Un ServiceAccount con permisos de registro y monitorización para el clúster.
  • Configuración de Google Cloud Managed Service para Prometheus para la monitorización y las alertas de clústeres.

Conéctate al clúster

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

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

Desplegar la base de datos Qdrant en tu clúster

En este tutorial, desplegarás la base de datos de Qdrant (en modo distribuido) y el operador de alta disponibilidad con estado en tu clúster de GKE mediante el gráfico de Helm.

La implementación crea un clúster de GKE con la siguiente configuración:

  • Tres réplicas de los nodos de Qdrant.
  • Las tolerancias, las afinidades de nodos y las restricciones de distribución de topología se configuran para asegurar una distribución adecuada entre los nodos de Kubernetes. Esto aprovecha los grupos de nodos y las diferentes zonas de disponibilidad.
  • Se aprovisiona un volumen de RePD con el tipo de disco SSD para el almacenamiento de datos.
  • Se usa un operador de alta disponibilidad con estado para gestionar los procesos de conmutación por error y asegurar la alta disponibilidad. Un StatefulSet es un controlador de Kubernetes que mantiene una identidad única y persistente para cada uno de sus pods.
  • Para la autenticación, la base de datos crea un secreto de Kubernetes que contiene la clave de API.

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

  1. Habilita el complemento StatefulHA:

    Autopilot

    GKE habilita automáticamente el complemento StatefulHA al crear el clúster.

    Estándar

    Ejecuta el siguiente comando:

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

    Este comando puede tardar 15 minutos en completarse y el clúster en mostrar el estado "Listo".

  2. Añade el repositorio de gráficos de Helm de la base de datos Qdrant antes de poder implementarlo en tu clúster de GKE:

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

  3. Crea un espacio de nombres qdrant para la base de datos:

    kubectl create ns qdrant

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

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

  5. Despliega un configmap de Kubernetes con una configuración de metrics sidecar y un clúster de Qdrant mediante Helm:

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

    El manifiesto de metrics-cm.yaml describe el archivo auxiliar metrics ConfigMap:

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

    El manifiesto values.yaml describe la configuración del clúster de Qdrant :

    replicaCount: 3

config:
  service:
    enable_tls: false
  cluster:
    enabled: true
  storage:
    optimizers:
      deleted_threshold: 0.5
      vacuum_min_vector_number: 1500
      default_segment_number: 2
      max_segment_size_kb: null
      memmap_threshold_kb: null
      indexing_threshold_kb: 25000
      flush_interval_sec: 5
      max_optimization_threads: 1

livenessProbe:
  enabled: true
  initialDelaySeconds: 60

resources:
  limits:
    cpu: "2"
    memory: 4Gi
  requests:
    cpu: "1"
    memory: 4Gi

tolerations:
  - key: "app.stateful/component"
    operator: "Equal"
    value: "qdrant"
    effect: NoSchedule

affinity:
  nodeAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
    - weight: 1
      preference:
        matchExpressions:
        - key: "app.stateful/component"
          operator: In
          values:
          - "qdrant"

topologySpreadConstraints:
  - maxSkew: 1
    topologyKey: "topology.kubernetes.io/zone"
    whenUnsatisfiable: ScheduleAnyway
    labelSelector:
      matchLabels:
        app.kubernetes.io/name: qdrant
        app.kubernetes.io/instance: qdrant

podDisruptionBudget:
  enabled: true
  maxUnavailable: 1

persistence:
  accessModes: ["ReadWriteOnce"]
  size: 10Gi
  storageClassName: ha-regional

apiKey: true

sidecarContainers:
  - name: metrics
    image: nginx:1.29
    resources:
      requests:
        memory: "128Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"
    ports:
    - containerPort: 80
    env:
    - name: QDRANT_APIKEY 
      valueFrom:
        secretKeyRef:
          name: qdrant-database-apikey          
          key: api-key
    volumeMounts:
        - name: nginx-conf
          mountPath: /etc/nginx/templates/default.conf.template
          subPath: default.conf.template
          readOnly: true
additionalVolumes:
  - name: nginx-conf
    configMap:
      name: nginx-conf
      items:
        - key: default.conf.template
          path: default.conf.template

    Esta configuración habilita el modo de clúster, lo que te permite configurar un clúster de Qdrant distribuido y de alta disponibilidad.

  6. Añade una etiqueta al conjunto con estado de Qdrant:

    kubectl label statefulset qdrant-database examples.ai.gke.io/source=qdrant-guide -n qdrant

  7. Implementa un balanceador de carga interno para acceder a tu base de datos de Qdrant que se ejecuta en la misma VPC que tu clúster de GKE:

    kubectl apply -n qdrant -f manifests/02-values-file/ilb.yaml

    El manifiesto de ilb.yaml describe el servicio LoadBalancer:

    apiVersion: v1
kind: Service
metadata:
  annotations:
    #cloud.google.com/neg: '{"ingress": true}'
    networking.gke.io/load-balancer-type: "Internal"
  labels:
    app.kubernetes.io/name: qdrant
  name: qdrant-ilb
spec:
  ports:
  - name: http
    port: 6333
    protocol: TCP
    targetPort: 6333
  - name: grpc
    port: 6334
    protocol: TCP
    targetPort: 6334
  selector:
    app: qdrant
    app.kubernetes.io/instance: qdrant-database
  type: LoadBalancer

  8. Comprueba el estado del despliegue:

    helm ls -n qdrant

    Si la base de datos qdrant se implementa correctamente, el resultado será similar al siguiente:

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

  9. Espera a que GKE inicie las cargas de trabajo necesarias:

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

    Este comando puede tardar unos minutos en completarse correctamente.

  10. Una vez que GKE inicie las cargas de trabajo, comprueba que GKE ha creado las cargas de trabajo de Qdrant:

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

  11. Inicia el recurso HighAvailabilityApplication (HAA) de Qdrant:

    kubectl apply -n qdrant -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: qdrant-database
  namespace: qdrant
spec:
  resourceSelection:
    resourceKind: StatefulSet
  policy:
    storageSettings:
      requireRegionalStorage: true
    failoverSettings:
      forceDeleteStrategy: AfterNodeUnreachable
      afterNodeUnreachable:
        afterNodeUnreachableSeconds: 20 # 60 seconds total

    Se crean los siguientes recursos de GKE para el clúster de Qdrant:

    • El StatefulSet de Qdrant que controla tres réplicas de Pod.
    • A PodDisruptionBudget, lo que garantiza que haya como máximo una réplica no disponible.
    • El servicio qdrant-database, que expone el puerto de Qdrant para las conexiones entrantes y la replicación entre nodos.
    • El qdrant-database-headless servicio, que proporciona la lista de QdrantPods en ejecución.
    • El secreto de qdrant-database-apikey, que facilita la conexión segura a la base de datos.
    • Pod del operador de alta disponibilidad con estado y recurso HighlyAvailableApplication, que monitoriza activamente la aplicación Qdrant. El recurso HighlyAvailableApplication define las reglas de conmutación por error que se aplican a Qdrant.

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

    kubectl describe highavailabilityapplication qdrant-database -n qdrant

    El resultado debería ser similar al siguiente:

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

Ejecutar consultas con un cuaderno de Vertex AI Colab Enterprise

Qdrant organiza los vectores y las cargas útiles en colecciones. La incrustación de vectores es una técnica que representa palabras o entidades como vectores numéricos y, al mismo tiempo, mantiene sus relaciones semánticas. Esto es importante para las búsquedas por similitud, ya que permite encontrar similitudes basadas en el significado en lugar de en coincidencias exactas, lo que hace que tareas como los sistemas de búsqueda y recomendación sean más eficaces y matizadas.

En esta sección se muestra cómo subir vectores a una nueva colección de Qdrant y ejecutar consultas 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. Crea un cuaderno de Colab Enterprise para hacer una consulta de búsqueda en la base de datos de Qdrant.

Para obtener más información sobre Vertex AI Colab Enterprise, consulta la documentación de Colab Enterprise.

Crear una plantilla de tiempo de ejecución

Para crear una plantilla de entorno de ejecución de Colab Enterprise, sigue estos pasos:

  1. En la Google Cloud consola, ve a la página Plantillas de tiempo de ejecución de Colab Enterprise y asegúrate de que tu proyecto esté seleccionado:

    Ir a Plantillas de entorno de ejecución

  2. Haz clic en Nueva plantilla. Aparecerá la página Crear plantilla de tiempo de ejecución.

  3. En la sección Información básica de Runtime:

    • En el campo Nombre visible, introduce qdrant-connect.
    • En la lista desplegable Región, selecciona us-central1. Es la misma región que tu clúster de GKE.

  4. En la sección Configurar recursos de computación:

    • En la lista desplegable Tipo de máquina, selecciona e2-standard-2.
    • En el campo Tamaño del disco, introduce 30.

  5. En la sección Redes y seguridad:

    • En la lista desplegable Red, selecciona la red en la que se encuentra tu clúster de GKE.
    • En la lista desplegable Subred, selecciona la subred correspondiente.
    • Desmarca la casilla Habilitar el acceso público a Internet.

  6. Para terminar de crear la plantilla de tiempo de ejecución, haga clic en Crear. Tu plantilla de entorno de ejecución aparece en la lista de la pestaña Plantillas de entorno de ejecución.

Crear un tiempo de ejecución

Para crear un entorno de ejecución de Colab Enterprise, sigue estos pasos:

  1. En la lista de plantillas de tiempo de ejecución de la plantilla que acaba de crear, vaya a la columna Acciones, haga clic en y, a continuación, en Crear tiempo de ejecución. Aparecerá el panel Crear tiempo de ejecución de Vertex AI.

  2. Para crear un tiempo de ejecución basado en tu plantilla, haz clic en Crear.

  3. En la pestaña Tiempos de ejecución que se abre, espera a que el estado cambie a Correcto.

Importar el cuaderno

Para importar el cuaderno en Colab Enterprise, sigue estos pasos:

  1. Ve a la pestaña Mis cuadernos y haz clic en Importar. Aparecerá el panel Importar cuadernos.

  2. En Importar fuente, selecciona URL.

  3. En URLs de cuadernos, introduce el siguiente enlace:

    https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/refs/heads/main/databases/qdrant/manifests/04-notebook/vector-database.ipynb

  4. Haz clic en Importar.

Conectarse al entorno de ejecución y ejecutar consultas

Para conectarte al entorno de ejecución y ejecutar consultas, sigue estos pasos:

  1. En el cuaderno, junto al botón Conectar, haz clic en Opciones de conexión adicionales. Aparecerá el panel Conectar con el entorno de ejecución de Vertex AI.

  2. Selecciona Conectar con un tiempo de ejecución y, a continuación, Conectar con un tiempo de ejecución.

  3. Selecciona el tiempo de ejecución que has iniciado y haz clic en Conectar.

  4. Para ejecutar las celdas del cuaderno, haz clic en el botón Ejecutar celda situado junto a cada celda de código.

El cuaderno contiene celdas de código y texto que describe cada bloque de código. Al ejecutar una celda de código, se ejecutan sus comandos y se muestra un resultado. Puedes ejecutar las celdas en orden o ejecutar celdas concretas según sea necesario.

Ver las métricas de Prometheus de un clúster

El clúster de GKE está configurado con Google Cloud Managed Service para Prometheus, que permite recoger métricas en formato Prometheus. Este servicio proporciona una solución totalmente gestionada para la monitorización y las alertas, lo que permite recoger, almacenar y analizar métricas del clúster y sus aplicaciones.

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

Recogida de métricas de Prometheus

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

  • Pods de Qdrant que exponen métricas en la ruta / y el puerto 80. Estas métricas las proporciona el contenedor sidecar llamado metrics.
  • Recogedores basados en Prometheus que procesan las métricas de los pods de Qdrant.
  • Un recurso PodMonitoring que envía las métricas a Cloud Monitoring.

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

  1. Crea el recurso PodMonitoring para recoger métricas por labelSelector:

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

    El manifiesto pod-monitoring.yaml describe el recurso PodMonitoring:

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

  2. Crea un panel de control de Cloud Monitoring con las configuraciones definidas en dashboard.json :

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

  3. Una vez que se haya ejecutado correctamente el comando, vaya a Paneles de control de Cloud Monitoring:

    Ir a Información general sobre los paneles de control

  4. En la lista de paneles de control, abre el panel Qdrant Overview. Las métricas pueden tardar entre 1 y 2 minutos en recogerse y mostrarse.

    El panel muestra un recuento de las métricas clave:

    • Colecciones
    • Vectores insertados
    • Operaciones pendientes
    • Nodos en ejecución

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

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

En este tutorial, configurarás un plan de copias de seguridad para tu clúster de GKE con el fin de crear copias de seguridad de todas las cargas de trabajo, incluidos los secretos y los volúmenes, todos los días a las 3:00. Para garantizar una gestión eficiente del almacenamiento, las copias de seguridad de más de tres días se eliminarán automáticamente.

Para configurar Planes de copia de seguridad, sigue estos pasos:

  1. Habilita la función de copia de seguridad de GKE en el clúster:

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

  2. Crea un plan de copia de seguridad con una programación diaria para todos los espacios de nombres 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 pertinentes en el tiempo de ejecución.

    El formato del nombre del clúster es relativo a tu proyecto y región, como se indica a continuación:

    projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_NAME

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

    Create request issued for: [qdrant-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 completada la ejecución, el resultado será similar al siguiente:

    Created backup plan [qdrant-cluster-backup].

  3. Puedes ver el plan de copia de seguridad que acabas de crear qdrant-cluster-backupen la consola de Copia de seguridad de GKE.

    Ir a Copia de seguridad de GKE

Si quieres restaurar las configuraciones de copia de seguridad guardadas, consulta Restaurar una copia de seguridad.