Esta página se ha traducido con Cloud Translation API.

Desplegar una base de datos de vectores de Qdrant en GKE

Autopilot Standard

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

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

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos pueden disfrutar de una prueba gratuita. Google Cloud

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que hayas creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

En este tutorial, usarás Cloud Shell para ejecutar comandos. Cloud Shell es un entorno de shell para gestionar recursos alojados en Google Cloud. Viene preinstalado con las herramientas de línea de comandos 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.

Nota: Si ya has instalado la CLI de gcloud, asegúrate de tener la versión más reciente ejecutando gcloud components update.

Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Create or select a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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.

Verify that billing is enabled for your Google Cloud project.

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

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

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

Install the Google Cloud CLI.

Nota: Si ya has instalado la CLI de gcloud, asegúrate de tener la versión más reciente ejecutando gcloud components update.

Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente comando:

gcloud init

Create or select a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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.

Verify that billing is enabled for your Google Cloud project.

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

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

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: roles/storage.objectViewer, roles/container.admin, roles/iam.serviceAccountAdmin, roles/compute.admin, roles/gkebackup.admin, roles/monitoring.viewer
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Replace the following:
- PROJECT_ID: Your project ID.
- USER_IDENTIFIER: The identifier for your user account. For example, myemail@example.com.
- ROLE: The IAM role that you grant to your user account.

Configurar un entorno

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

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

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

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

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

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 mediante un clúster estándar o de 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 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.
Se han configurado tolerancias, afinidades de nodos y restricciones de distribución de topología 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:

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".
Añade el repositorio de gráficos de Helm de la base de datos Qdrant antes de implementarlo en tu clúster de GKE:
```
helm repo add qdrant https://qdrant.github.io/qdrant-helm
```
Crea un espacio de nombres qdrant para la base de datos:
```
kubectl create ns qdrant
```

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

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.

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

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

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

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

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

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 las tareas como los sistemas de búsqueda y recomendación sean más eficaces y precisas.

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

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
Haz clic en Nueva plantilla. Aparecerá la página Crear plantilla de tiempo de ejecución.
En la sección Información básica sobre el tiempo de ejecución:
- 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.
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.
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.
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:

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.
Para crear un tiempo de ejecución basado en tu plantilla, haz clic en Crear.
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:

Ve a la pestaña Mis cuadernos y haz clic en Importar. Aparecerá el panel Importar cuadernos.
En Importar fuente, selecciona URL.

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

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:

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.
Selecciona Conectar con un tiempo de ejecución y, a continuación, Conectar con un tiempo de ejecución.
Selecciona el tiempo de ejecución que has iniciado y haz clic en Conectar.
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:

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

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

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

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

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

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

Puedes ver el plan de copia de seguridad que acabas de crear qdrant-cluster-backup en 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.

Limpieza

Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

Eliminar el proyecto

La forma más fácil de evitar que te cobren es eliminar el proyecto que has creado para este tutorial.

Precaución: Eliminar un proyecto tiene los siguientes efectos:

Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.

Si tienes previsto consultar varias arquitecturas, tutoriales o guías de inicio rápido, reutilizar los proyectos puede ayudarte a no superar los límites de cuota de proyectos.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Si has eliminado el proyecto, ya has terminado. Si no has eliminado el proyecto, elimina los recursos concretos.

Eliminar recursos concretos

Define las variables de entorno.

export PROJECT_ID=${PROJECT_ID}
export KUBERNETES_CLUSTER_PREFIX=qdrant
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}

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

Para encontrar todos los discos sin vincular, haz lo siguiente:

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

Elimina 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

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

Siguientes pasos

Consulta Qdrant en GKE Marketplace.
Descubre el software de código abierto de Qdrant.
Prueba el operador de Qdrant que ofrece gestión de claves de API, compatibilidad con TLS con gestión de certificados y programación de copias de seguridad.
Consulta las prácticas recomendadas para desplegar bases de datos en GKE.
Descubre soluciones para ejecutar cargas de trabajo con gran cantidad de datos con GKE.

Desplegar una base de datos de vectores de Qdrant en GKE Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Ventajas

Objetivos

Arquitectura de despliegue

Diagrama de la arquitectura

Costes

Antes de empezar

Configurar un entorno

Crear la infraestructura del clúster

Autopilot

Estándar

Conéctate al clúster

Desplegar la base de datos Qdrant en tu clúster

Autopilot

Estándar

Ejecutar consultas con un cuaderno de Vertex AI Colab Enterprise

Crear una plantilla de tiempo de ejecución

Crear un tiempo de ejecución

Importar el cuaderno

Conectarse al entorno de ejecución y ejecutar consultas

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

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

Limpieza

Eliminar el proyecto

Eliminar recursos concretos

Siguientes pasos

Desplegar una base de datos de vectores de Qdrant en GKE